diff options
Diffstat (limited to 'source4')
| -rw-r--r-- | source4/build/pidl/eparser.pm | 574 |
1 files changed, 334 insertions, 240 deletions
diff --git a/source4/build/pidl/eparser.pm b/source4/build/pidl/eparser.pm index bb29389538..6c6596bf07 100644 --- a/source4/build/pidl/eparser.pm +++ b/source4/build/pidl/eparser.pm @@ -1,18 +1,129 @@ ################################################### # parser generator for IDL structures -# Copyright tpot@samba.org 2001 -# Copyright tridge@samba.org 2000 +# Copyright tpot@samba.org 2004 # released under the GNU GPL package IdlEParser; use strict; use dump; +#use Data::Dumper; -my($module); +##################################################################### +# Code for managing hf's + +my %hf_info = (); + +# Convert an idl type to an ethereal FT_* type + +sub type2ft($) +{ + my($t) = shift; + + return "FT_UINT32", if ($t eq "uint32"); + return "FT_UINT16", if ($t eq "uint16"); + return "FT_BYTES"; +} + +# Select an ethereal BASE_* type for an idl type + +sub type2base($) +{ + my($t) = shift; + + return "BASE_DEC", if ($t eq "uint32") or ($t eq "uint16"); + return "BASE_NONE"; +} + +# Create a new field. The name of the field is hf_${name}_${type} where +# name and type are taken from the IDL definition for the element. + +sub AddField($$) +{ + my($name) = shift; + my($type) = shift; + + my $hf_name = "${name}_${type}"; + return, if defined $hf_info{$hf_name}; + + $hf_info{$hf_name} = { + 'name' => $name, # Field name + 'type' => $type, # Field type + 'ft' => type2ft($type), # Ethereal type + 'base' => type2base($type), # Base of type + }; +} + +# Generate field definitions from %hf_info + +sub EtherealFieldDefinitions() +{ + my($res) = ""; + + $res .= << "EOF"; +static int hf_opnum = -1; +static int hf_rc = -1; +static int hf_policy_handle = -1; +EOF + + foreach my $hf (keys(%hf_info)) { + my($hf_name) = "$hf_info{$hf}{name}_$hf_info{$hf}{type}"; + $res .= "static int hf_$hf_name = -1;\n"; + } + + return $res; +} + +# Generate field initialisers + +sub EtherealFieldInitialisation($) +{ + my($module) = shift; + my($res) = ""; + + # Fields present in all parsers + + $res .= << "EOF"; +\t{ &hf_opnum, +\t { \"Operation\", \"$module.opnum\", FT_UINT16, BASE_DEC, NULL, 0x0, \"Operation\", HFILL }}, +\t{ &hf_policy_handle, +\t { \"Policy handle\", \"$module.policy\", FT_BYTES, BASE_NONE, NULL, 0x0, \"Policy handle\", HFILL }}, +\t{ &hf_rc, +\t { \"Return code\", \"$module.rc\", FT_UINT32, BASE_HEX, VALS(NT_errors), 0x0, \"Return status code\", HFILL }}, +EOF + + foreach my $hf (keys(%hf_info)) { + $res .= "\t{ &hf_$hf,\n"; + $res .= "\t { \"$hf_info{$hf}{name}\", \"$hf\", $hf_info{$hf}{ft}, $hf_info{$hf}{base},\n"; + $res .= "\t NULL, 0, \"$hf\", HFILL }},\n"; + } + + return $res; +} ##################################################################### -# handlers for parsing ndr argument types +# Code for managing subtrees + +sub EtherealSubtreeDefinitions($) +{ + my($module) = shift; + my($res) = ""; + + $res .= << "EOF"; +static gint ett_dcerpc_$module = -1; +EOF + + return $res; +} + +sub EtherealSubtreeInitialisation() +{ + my($res) = ""; + return $res; +} + +##################################################################### +# Generate dissection functions for NDR types sub ParamSimpleNdrType($) { @@ -49,45 +160,52 @@ sub ParamStruct($) my($p) = shift; my($res); - $res .= "\toffset = dissect_${module}_$p->{TYPE}(tvb, offset, pinfo, tree, drep);\n"; + $res .= "\toffset = dissect_$p->{TYPE}(tvb, offset, pinfo, tree, drep);\n"; return $res; } +# Index of NDR types and functions to generate code to dissect that type + my %param_handlers = ( - 'uint8' => \&ParamSimpleNdrType, - 'uint16' => \&ParamSimpleNdrType, - 'uint32' => \&ParamSimpleNdrType, + 'uint8' => \&ParamSimpleNdrType, + 'uint16' => \&ParamSimpleNdrType, + 'uint32' => \&ParamSimpleNdrType, 'policy_handle' => \&ParamPolicyHandle, - 'string' => \&ParamString, + 'string' => \&ParamString, ); -my %hf_info = (); # Field info - remember for trailing stuff +# Generate a parser for a NDR parameter -##################################################################### -# parse a function sub ParseParameter($) { my($p) = shift; my($res); + # Call function registered for this type + if (defined($param_handlers{$p->{TYPE}})) { $res .= &{$param_handlers{$p->{TYPE}}}($p); return $res; } + # Unknown type - make a note in the protocol tree + $res .= "\tproto_tree_add_text(tree, tvb, offset, -1, \"Unhandled IDL type '$p->{TYPE}'\");\n"; return $res; } ##################################################################### -# parse a function -sub ParseFunction($) +# Generate code fragment for an IDL function + +sub EtherealFunction($) { my($f) = shift; my($res); + # Comment displaying IDL for this function + $res .= "/*\n\n"; $res .= IdlDump::DumpFunction($f); $res .= "*/\n\n"; @@ -125,52 +243,38 @@ sub ParseFunction($) } ##################################################################### -# parse a function -sub ParseEnum($$) -{ - my($name) = shift; - my($enum) = shift; +# Generate code fragment for an IDL struct - return "/* Enum $name */\n\n"; -} - -##################################################################### -# parse a function -sub ParseStruct($$) -{ - my($name) = shift; +sub EtherealStruct($$) +{ + my($module) = shift; my($struct) = shift; - my($res); - - # Add struct name to param handler list - - $param_handlers{$name} = \&ParamStruct; - - # Create parse function + my($res) = ""; $res .= "/*\n\n"; - $res .= IdlDump::DumpStruct($struct); + $res .= IdlDump::DumpStruct($struct->{DATA}); $res .= "\n\n*/\n\n"; $res .= << "EOF"; -int dissect_${module}_$name(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep) +int dissect_$struct->{NAME}(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep) { proto_item *item = NULL; proto_tree *tree = NULL; int old_offset = offset; if (parent_tree) { - item = proto_tree_add_text(parent_tree, tvb, offset, -1, "$name"); + item = proto_tree_add_text(parent_tree, tvb, offset, -1, "$struct->{NAME}"); tree = proto_item_add_subtree(item, ett_dcerpc_$module); } EOF - foreach my $d (@{$struct->{ELEMENTS}}) { + # Parse elements + + foreach my $d (@{$struct->{DATA}->{ELEMENTS}}) { $res .= ParseParameter($d); } - $res .= << "EOF"; proto_item_set_len(item, offset - old_offset); @@ -184,212 +288,184 @@ EOF } ##################################################################### -# parse a function -sub ParseUnion($$) -{ - my($name) = shift; - my($union) = shift; +# Generate code fragment for an IDL union - return "/* Union $name */\n\n"; -} - -##################################################################### -# parse a function -sub ParseTypedef($) +sub EtherealUnion($$) { - my($typedef) = shift; - my($data) = $typedef->{DATA}; + my($module) = shift; + my($union) = shift; my($res) = ""; - $res .= ParseEnum($typedef->{NAME}, $data), if $data->{TYPE} eq "ENUM"; - $res .= ParseStruct($typedef->{NAME}, $data), if $data->{TYPE} eq "STRUCT"; - $res .= ParseUnion($typedef->{NAME}, $data), if $data->{TYPE} eq "UNION"; - - return $res; -} + $res .= "/*\n\n"; + $res .= IdlDump::DumpUnion($union->{DATA}); + $res .= "\n\n*/\n\n"; -##################################################################### -# parse the interface definitions -sub Pass2Interface($) + $res .= << "EOF"; +int dissect_$union->{NAME}(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep) { - my($interface) = shift; - my($data) = $interface->{DATA}; - my($res) = ""; + proto_item *item = NULL; + proto_tree *tree = NULL; + int old_offset = offset; - foreach my $d (@{$data}) { - $res .= ParseFunction($d), if $d->{TYPE} eq "FUNCTION"; - $res .= ParseTypedef($d), if $d->{TYPE} eq "TYPEDEF"; + if (parent_tree) { + item = proto_tree_add_text(parent_tree, tvb, offset, -1, "$union->{NAME}"); + tree = proto_item_add_subtree(item, ett_dcerpc_$module); } - return $res; -} - -##################################################################### -# Pass 1: Stuff required before structs and functions +EOF -sub Pass1ModuleHeader($) -{ - my($d) = shift; - my($res) = ""; + # TODO: Parse elements - $res .= << "EOF"; -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif +$res .= << "EOF"; -#include "packet-dcerpc.h" -#include "packet-dcerpc-nt.h" + proto_item_set_len(item, offset - old_offset); -extern const value_string NT_errors[]; + return offset; +} EOF - # UUID - - if ($d->{TYPE} eq "MODULEHEADER" and defined($d->{PROPERTIES}->{uuid})) { - my $uuid = $d->{PROPERTIES}->{uuid}; - $res .= "static e_uuid_t uuid_dcerpc_$module = {\n"; - $res .= "\t0x" . substr($uuid, 0, 8); - $res .= ", 0x" . substr($uuid, 9, 4); - $res .= ", 0x" . substr($uuid, 14, 4) . ",\n"; - $res .= "\t{ 0x" . substr($uuid, 19, 2); - $res .= ", 0x" . substr($uuid, 21, 2); - $res .= ", 0x" . substr($uuid, 24, 2); - $res .= ", 0x" . substr($uuid, 26, 2); - $res .= ", 0x" . substr($uuid, 28, 2); - $res .= ", 0x" . substr($uuid, 30, 2); - $res .= ", 0x" . substr($uuid, 32, 2); - $res .= ", 0x" . substr($uuid, 34, 2) . " }\n"; - $res .= "};\n\n"; - - $res .= "static guint16 ver_dcerpc_samr = " . - $d->{PROPERTIES}->{version} . ";\n\n"; - } - return $res; } -# Convert an idl type to an ethereal FT_* type +##################################################################### +# Generate code fragment for an IDL typedef -sub type2ft($) -{ - my($t) = shift; +sub EtherealTypedef($$) +{ + my($module) = shift; + my($typedef) = shift; - return "FT_UINT32", if ($t eq "uint32"); - return "FT_UINT16", if ($t eq "uint16"); - - return "FT_BYTES"; + return EtherealStruct($module, $typedef), + if $typedef->{DATA}{TYPE} eq "STRUCT"; + + return EtherealUnion($module, $typedef), + if $typedef->{DATA}{TYPE} eq "UNION"; + + return "/* Unsupported typedef $typedef->{DATA}{TYPE} " . + "$typedef->{NAME}*/\n\n"; } -# Select an ethereal BASE_* type for an idl type +##################################################################### +# Generate code fragment for the start of the dissector -sub type2base($) +sub EtherealHeader($) { - my($t) = shift; + my($module) = shift; + my($res) = ""; - return "BASE_DEC", if ($t eq "uint32") or ($t eq "uint16"); + $res .= << "EOF"; +/* parser auto-generated by pidl */ - return "BASE_NONE"; -} +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif -sub AddField($$) -{ - my($name) = shift; - my($type) = shift; - my($res) = ""; +#include "packet-dcerpc.h" +#include "packet-dcerpc-nt.h" - my $hf_name = "${name}_${type}"; - return $res, if defined $hf_info{$hf_name}; - - # Make a note about new field - - $res .= "static int hf_$hf_name = -1;\n"; - $hf_info{$hf_name} = { - 'ft' => type2ft($type), - 'base' => type2base($name), - 'name' => $name - }; +extern const value_string NT_errors[]; - return $res; -} +static int proto_dcerpc_$module = -1; -sub ScanFunction($) -{ - my($fn) = shift; - my($res) = ""; +EOF - foreach my $args ($fn) { - foreach my $params (@{$args}) { - $res .= AddField($params->{NAME}, $params->{TYPE}); - } - } return $res; } - -sub ScanTypedef($) + +sub EtherealUuidRegistration($$$) { - my($td) = shift; + my($module) = shift; + my($uuid) = shift; + my($uuid_version) = shift; my($res) = ""; - if ($td->{TYPE} eq "STRUCT") { - foreach my $e (@{$td->{ELEMENTS}}) { - $res .= AddField($e->{NAME}, $e->{TYPE}); - } - } + # Various objects for dissector initialisation + + $res .= "static e_uuid_t uuid_dcerpc_$module = {\n"; + $res .= "\t0x" . substr($uuid, 0, 8); + $res .= ", 0x" . substr($uuid, 9, 4); + $res .= ", 0x" . substr($uuid, 14, 4) . ",\n"; + $res .= "\t{ 0x" . substr($uuid, 19, 2); + $res .= ", 0x" . substr($uuid, 21, 2); + $res .= ", 0x" . substr($uuid, 24, 2); + $res .= ", 0x" . substr($uuid, 26, 2); + $res .= ", 0x" . substr($uuid, 28, 2); + $res .= ", 0x" . substr($uuid, 30, 2); + $res .= ", 0x" . substr($uuid, 32, 2); + $res .= ", 0x" . substr($uuid, 34, 2) . " }\n"; + $res .= "};\n\n"; + + $res .= "static guint16 ver_dcerpc_$module = " . $uuid_version . ";\n\n"; return $res; } -sub Pass1Interface($) +##################################################################### +# Generate code fragment for the tail of the dissector + +sub EtherealModuleRegistration($$$) { - my($interface) = shift; + my($module) = shift; + my($hf_register_info) = shift; + my($ett_info) = shift; my($res) = ""; $res .= << "EOF"; -static int proto_dcerpc_$module = -1; +void +proto_register_dcerpc_${module}(void) +{ + static hf_register_info hf[] = { +$hf_register_info + }; -static int hf_opnum = -1; -static int hf_rc = -1; -static int hf_policy_handle = -1; + static gint *ett[] = { + &ett_dcerpc_$module, +$ett_info + }; -static gint ett_dcerpc_$module = -1; + proto_dcerpc_$module = proto_register_protocol("$module", "$module", "$module"); -EOF + proto_register_field_array(proto_dcerpc_$module, hf, array_length (hf)); + proto_register_subtree_array(ett, array_length(ett)); - foreach my $fn (@{$interface->{DATA}}) { - $res .= ScanFunction($fn->{DATA}), if $fn->{TYPE} eq "FUNCTION"; - $res .= ScanTypedef($fn->{DATA}), if $fn->{TYPE} eq "TYPEDEF"; - } +} - $res .= "\n"; +void +proto_reg_handoff_dcerpc_$module(void) +{ + dcerpc_init_uuid(proto_dcerpc_$module, ett_dcerpc_$module, + &uuid_dcerpc_$module, ver_dcerpc_$module, + dcerpc_${module}_dissectors, hf_opnum); +} +EOF return $res; } ##################################################################### -# Pass 3: trailing stuff +# Generate code fragment for DCERPC subdissector registration -sub Pass3Interface($) +sub EtherealSubdissectorRegistration($$) { - my($interface) = shift; + my($module) = shift; + my($functions) = shift; my($res) = ""; $res .= "static dcerpc_sub_dissector dcerpc_${module}_dissectors[] = {\n"; my $num = 0; - foreach my $d (@{$interface->{DATA}}) { - if ($d->{TYPE} eq "FUNCTION") { - # Strip module name from function name, if present - my $n = $d->{NAME}; - $n = substr($d->{NAME}, length($module) + 1), - if $module eq substr($d->{NAME}, 0, length($module)); - - $res .= "\t{ $num, \"$n\",\n"; - $res .= "\t\t$d->{NAME}_rqst,\n"; - $res .= "\t\t$d->{NAME}_resp },\n"; - $num++; - } + foreach my $name (@$functions) { + # Strip module name from function name, if present + my($n) = $name; + $n = substr($name, length($module) + 1), + if $module eq substr($name, 0, length($module)); + + $res .= "\t{ $num, \"$n\",\n"; + $res .= "\t\t${name}_rqst,\n"; + $res .= "\t\t${name}_resp },\n"; + $num++; } $res .= "};\n\n"; @@ -398,83 +474,101 @@ sub Pass3Interface($) } ##################################################################### -# parse a parsed IDL structure back into an IDL file +# Generate an ethereal dissector from an IDL syntax tree. + sub Parse($) { my($idl) = shift; - my($res) = "/* parser auto-generated by pidl */\n\n"; - my($d); + my($res) = ""; - # Pass 0: set module name + # + # Phase 1 : Gather information from IDL tree + # - foreach $d (@{$idl}) { - $module = $d->{NAME}, if ($d->{TYPE} eq "INTERFACE"); - } + my($module) = ""; + my($uuid) = ""; + my($uuid_version) = ""; + my(@fns) = (); - # Pass 1: header stuff + foreach my $d (@$idl) { - foreach $d (@{$idl}) { - $res .= Pass1ModuleHeader($d), if $d->{TYPE} eq "MODULEHEADER"; - $res .= Pass1Interface($d), if $d->{TYPE} eq "INTERFACE"; - } + # Get data from interface definition - # Pass 2: typedefs and functions + $module = $d->{NAME}, if $d->{TYPE} eq "INTERFACE"; - foreach $d (@{$idl}) { - $res .= Pass2Interface($d), if $d->{TYPE} eq "INTERFACE"; - } + if ($d->{TYPE} eq "MODULEHEADER") { + $uuid = $d->{PROPERTIES}->{uuid}; + $uuid_version = $d->{PROPERTIES}->{version}; + } - # Pass 3: trailing stuff + # Iterate over function definitions and register field info - foreach $d (@{$idl}) { - $res .= Pass3Interface($d), if $d->{TYPE} eq "INTERFACE"; - } + if ($d->{TYPE} eq "INTERFACE") { - my $hf_register_info = << "EOF"; -\t{ &hf_opnum, -\t { \"Operation\", \"$module.opnum\", FT_UINT16, BASE_DEC, NULL, 0x0, \"Operation\", HFILL }}, -\t{ &hf_policy_handle, -\t { \"Policy handle\", \"$module.policy\", FT_BYTES, BASE_NONE, NULL, 0x0, \"Policy handle\", HFILL }}, -\t{ &hf_rc, -\t { \"Return code\", \"$module.rc\", FT_UINT32, BASE_HEX, VALS(NT_errors), 0x0, \"Return status code\", HFILL }}, -EOF + foreach my $d (@{$d->{DATA}}) { - foreach my $hf (keys(%hf_info)) { - $hf_register_info .= "\t{ &hf_$hf,\n"; - $hf_register_info .= "\t { \"$hf_info{$hf}{name}\", \"$hf\", $hf_info{$hf}{ft}, $hf_info{$hf}{base},\n"; - $hf_register_info .= "\t NULL, 0, \"$hf\", HFILL }},\n"; + if ($d->{TYPE} eq "FUNCTION") { + + # Register function name + + $fns[$#fns + 1] = $d->{NAME}; + + # Register function fields (parameter names) + + foreach my $e (@{$d->{DATA}}) { + AddField($e->{NAME}, $e->{TYPE}); + } + } + + if ($d->{TYPE} eq "TYPEDEF") { + + # Register structure names + + $param_handlers{$d->{NAME}} = \&ParamStruct; + + # Register typedef fields (element names) + + if ($d->{DATA}->{TYPE} eq "STRUCT") { + foreach my $e (@{$d->{DATA}->{ELEMENTS}}) { + AddField($e->{NAME}, $e->{TYPE}); + } + } + } + } + } } - - my $ett_info = "/* spotty */"; - - $res .= << "EOF"; -void -proto_register_dcerpc_${module}(void) -{ - static hf_register_info hf[] = { -$hf_register_info - }; - static gint *ett[] = { - &ett_dcerpc_$module, -$ett_info - }; + # + # Phase 2 : Spit out parser from fragments generated above + # - proto_dcerpc_$module = proto_register_protocol("$module", "$module", "$module"); + $res .= EtherealHeader($module); + $res .= EtherealFieldDefinitions(); + $res .= EtherealSubtreeDefinitions($module); - proto_register_field_array (proto_dcerpc_$module, hf, array_length (hf)); - proto_register_subtree_array(ett, array_length(ett)); + foreach my $d (@$idl) { -} + if ($d->{TYPE} eq "INTERFACE") { + foreach my $d (@{$d->{DATA}}) { -void -proto_reg_handoff_dcerpc_$module(void) -{ - dcerpc_init_uuid(proto_dcerpc_$module, ett_dcerpc_$module, - &uuid_dcerpc_$module, ver_dcerpc_$module, - dcerpc_${module}_dissectors, hf_opnum); -} -EOF + # Generate function code fragments + + $res .= EtherealFunction($d), if $d->{TYPE} eq "FUNCTION"; + + # Generate structure code fragments + + $res .= EtherealTypedef($module, $d), + if $d->{TYPE} eq "TYPEDEF"; + } + } + } + + $res .= EtherealSubdissectorRegistration($module, \@fns); + + $res .= EtherealUuidRegistration($module, $uuid, $uuid_version); + $res .= EtherealModuleRegistration($module, + EtherealFieldInitialisation($module), + EtherealSubtreeInitialisation()); return $res; } |