r9150: The ethereal parser generators work now. Thanks to Ronnie Sahlberg for

help with the debugging and comments on the generated code (-:
(This used to be commit 4c165f8ff65b4500d8366b655d6df2a065f35bf5)

diff --git a/source4/build/pidl/Parse/Pidl/Dump.pm b/source4/build/pidl/Parse/Pidl/Dump.pm
index 7a18cf517375f55f848ff6fc0add3a99a154deff..bca599262aa4161634946f49f981322e10bdbd3d 100644 (file)
--- a/source4/build/pidl/Parse/Pidl/Dump.pm
+++ b/source4/build/pidl/Parse/Pidl/Dump.pm
@@ -5,7 +5,13 @@
 
 package Parse::Pidl::Dump;
 
+use Exporter;
+
+@ISA = qw(Exporter);
+@EXPORT_OK = qw(DumpTypedef DumpStruct DumpEnum DumpBitmap DumpUnion DumpFunction);
+
 use strict;
+use Parse::Pidl::Util qw(has_property);
 
 my($res);
 
@@ -68,7 +74,7 @@ sub DumpStruct($)
     $res .= "struct {\n";
     if (defined $struct->{ELEMENTS}) {
        foreach my $e (@{$struct->{ELEMENTS}}) {
-           $res .= DumpElement($e);
+           $res .= "\t" . DumpElement($e);
            $res .= ";\n";
        }
     }
@@ -85,7 +91,39 @@ sub DumpEnum($)
     my($enum) = shift;
     my($res);
 
-    $res .= "enum";
+    $res .= "enum {\n";
+
+    foreach (@{$enum->{ELEMENTS}}) {
+       if (/^([A-Za-z0-9_]+)[ \t]*\((.*)\)$/) {
+               $res .= "\t$1 = $2,\n";
+       } else {
+               $res .= "\t$_,\n";
+       }
+    }
+
+    $res.= "}";
+    
+    return $res;
+}
+
+#####################################################################
+# dump a struct
+sub DumpBitmap($)
+{
+    my($bitmap) = shift;
+    my($res);
+
+    $res .= "bitmap {\n";
+
+    foreach (@{$bitmap->{ELEMENTS}}) {
+       if (/^([A-Za-z0-9_]+)[ \t]*\((.*)\)$/) {
+               $res .= "\t$1 = $2,\n";
+       } else {
+               die ("Bitmap $bitmap->{NAME} has field $_ without proper value");
+       }
+    }
+
+    $res.= "}";
     
     return $res;
 }
@@ -98,7 +136,7 @@ sub DumpUnionElement($)
     my($element) = shift;
     my($res);
 
-    if (util::has_property($element, "default")) {
+    if (has_property($element, "default")) {
        $res .= "[default] ;\n";
     } else {
        $res .= "[case($element->{PROPERTIES}->{case})] ";
@@ -135,12 +173,10 @@ sub DumpType($)
     my($res);
 
     if (ref($data) eq "HASH") {
-       ($data->{TYPE} eq "STRUCT") &&
-           ($res .= DumpStruct($data));
-       ($data->{TYPE} eq "UNION") &&
-           ($res .= DumpUnion($data));
-       ($data->{TYPE} eq "ENUM") &&
-           ($res .= DumpEnum($data));
+       ($data->{TYPE} eq "STRUCT") && ($res .= DumpStruct($data));
+       ($data->{TYPE} eq "UNION") && ($res .= DumpUnion($data));
+       ($data->{TYPE} eq "ENUM") && ($res .= DumpEnum($data));
+       ($data->{TYPE} eq "BITMAP") && ($res .= DumpBitmap($data));
     } else {
        $res .= "$data";
     }

diff --git a/source4/build/pidl/Parse/Pidl/Ethereal/Conformance.pm b/source4/build/pidl/Parse/Pidl/Ethereal/Conformance.pm
index 54031f031a36142ca16dc3f2eaa20616462b8e95..910b6041589f4e3fc67989f5775bc29098978601 100644 (file)
--- a/source4/build/pidl/Parse/Pidl/Ethereal/Conformance.pm
+++ b/source4/build/pidl/Parse/Pidl/Ethereal/Conformance.pm
@@ -8,7 +8,7 @@ package Parse::Pidl::Ethereal::Conformance;
 require Exporter;
 
 @ISA = qw(Exporter);
-@EXPORT_OK = qw(EmitProhibited FindDissectorParam %hf_renames);
+@EXPORT_OK = qw(EmitProhibited FindDissectorParam %hf_renames %protocols);
 
 use strict;
 
@@ -21,7 +21,7 @@ sub handle_union_tag_size($$)
        #FIXME  
 }
 
-use vars qw(%hf_renames %types %header_fields);
+use vars qw(%hf_renames %types %header_fields %protocols);
 
 sub handle_type($$$$$$$)
 {
@@ -86,6 +86,25 @@ sub handle_noemit($)
        push (@noemit, $type);
 }
 
+
+sub handle_protocol($$$$)
+{
+       my ($name, $longname, $shortname, $filtername) = @_;
+
+       $protocols{$name} = {
+               LONGNAME => $longname,
+               SHORTNAME => $shortname,
+               FILTERNAME => $filtername
+       };
+}
+
+sub handle_fielddescription($$)
+{
+       my ($field,$desc) = @_;
+
+       #FIXME
+}
+
 my %field_handlers = (
        UNION_TAG_SIZE => \&handle_union_tag_size,
        TYPE => \&handle_type,
@@ -93,7 +112,9 @@ my %field_handlers = (
        PARAM_VALUE => \&handle_param_value, 
        HF_FIELD => \&handle_hf_field, 
        HF_RENAME => \&handle_hf_rename, 
-       STRIP_PREFIX => \&handle_strip_prefix
+       STRIP_PREFIX => \&handle_strip_prefix,
+       PROTOCOL => \&handle_protocol,
+       FIELD_DESCRIPTION => \&handle_fielddescription
 );
 
 sub Parse($)

diff --git a/source4/build/pidl/Parse/Pidl/Ethereal/NDR.pm b/source4/build/pidl/Parse/Pidl/Ethereal/NDR.pm
index 4f3ae7588befba584b8b7c4e1b3b4d561c32b4eb..76a83b5ecbcb623cb7166f295334989e1928ad92 100644 (file)
--- a/source4/build/pidl/Parse/Pidl/Ethereal/NDR.pm
+++ b/source4/build/pidl/Parse/Pidl/Ethereal/NDR.pm
@@ -8,15 +8,21 @@
 
 # TODO:
 #  - order of functions generated per element level
-#  - strings
+#  - subcontexts using tvb_new_subset()
+#  - fixed arrays
+#  - strip prefixes
+#  - allow overrides in conformance file
 
 package Parse::Pidl::Ethereal::NDR;
 
 use strict;
 use Parse::Pidl::Typelist;
-use Parse::Pidl::Util qw(has_property ParseExpr);
+use Parse::Pidl::Util qw(has_property ParseExpr property_matches);
 use Parse::Pidl::NDR;
-use Parse::Pidl::Ethereal::Conformance qw(EmitProhibited FindDissectorParam %hf_renames);
+use Parse::Pidl::Dump qw(DumpTypedef DumpFunction);
+use Parse::Pidl::Ethereal::Conformance qw(EmitProhibited FindDissectorParam %hf_renames %protocols);
+
+my %types;
 
 my %ptrtype_mappings = (
        "unique" => "NDR_POINTER_UNIQUE",
@@ -24,14 +30,6 @@ my %ptrtype_mappings = (
        "ptr" => "NDR_POINTER_PTR"
 );
 
-my %dissectors = (
-       "uint16" => "dissect_ndr_uint16",
-       "uint8" => "dissect_ndr_uint8",
-       "uint32" => "dissect_ndr_uint32",
-       "time_t" => "dissect_ndr_time_t",
-       "GUID" => "dissect_ndr_uuid_t"
-);
-
 sub type2ft($)
 {
     my($t) = shift;
@@ -40,29 +38,12 @@ sub type2ft($)
     return "FT_INT$1" if $t =~ /int(8|16|32|64)/;
     return "FT_UINT64", if $t eq "HYPER_T" or $t eq "NTTIME"
        or $t eq "NTTIME_1sec" or $t eq "NTTIME_hyper" or $t eq "hyper";
+
+    return "FT_STRING" if ($t eq "string");
    
     return "FT_NONE";
 }
 
-# Determine the display base for an element
-
-sub elementbase($)
-{
-    my($e) = shift;
-
-    if (my $base = has_property($e, "display")) {
-       return "BASE_" . uc($base);
-    }
- 
-    return "BASE_DEC", if $e->{TYPE} eq "ENUM";
-    return "BASE_DEC", if $e->{TYPE} =~ /u?int(8|16|32|64)/;
-    return "BASE_DEC", if $e->{TYPE} eq "NTTIME" or $e->{TYPE} eq "HYPER_T";
-
-    # Probably an enum
-
-    return "BASE_DEC";
-}
-
 # Convert a IDL structure field name (e.g access_mask) to a prettier
 # string like 'Access Mask'.
 
@@ -76,16 +57,6 @@ sub field2name($)
     return $field;
 }
 
-sub bitmapbase($)
-{
-    my $e = shift;
-
-    return "16", if has_property($e->{DATA}, "bitmap16bit");
-    return "8", if has_property($e->{DATA}, "bitmap8bit");
-
-    return "32";
-}
-
 my %res = ();
 my $tabs = "";
 sub pidl_code($)
@@ -111,6 +82,15 @@ sub deindent()
        $tabs = substr($tabs, 0, -1);
 }
 
+sub PrintIdl($)
+{
+       my $idl = shift;
+
+       foreach (split /\n/, $idl) {
+               pidl_code "/* IDL: $_ */";
+       }
+}
+
 #####################################################################
 # parse the interface definitions
 sub Interface($)
@@ -154,7 +134,9 @@ sub Enum($$$)
        pidl_code "return offset;";
        pidl_code "}\n";
 
-       register_type($name, $dissectorname, enum_ft($e), "BASE_DEC", "0", "VALS($valsstring)", enum_size($e));
+       my $enum_size = $e->{BASE_TYPE};
+       $enum_size =~ s/uint//g;
+       register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", type2ft($e->{BASE_TYPE}), "BASE_DEC", "0", "VALS($valsstring)", $enum_size / 8);
 }
 
 sub Bitmap($$$)
@@ -164,6 +146,7 @@ sub Bitmap($$$)
 
        register_ett("ett_$ifname\_$name");
 
+
        pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);";
 
        pidl_code "int";
@@ -173,12 +156,10 @@ sub Bitmap($$$)
        pidl_code "proto_item *item=NULL;";
        pidl_code "proto_tree *tree=NULL;";
        pidl_code "";
-
-       if ($e->{ALIGN} == 8) {
-               pidl_code "guint8 flags;";
-       } elsif ($e->{ALIGN} == 4) {
-               pidl_code "guint32 flags;";
-               pidl_code "ALIGN_TO_4_BYTES;";
+               
+       pidl_code "g$e->{BASE_TYPE} flags;";
+       if ($e->{ALIGN} > 1) {
+               pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;";
        }
 
        pidl_code "";
@@ -193,36 +174,41 @@ sub Bitmap($$$)
        pidl_code "offset=dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, NULL, drep, -1, &flags);";
 
        foreach (@{$e->{ELEMENTS}}) {
-               next unless (/([^=]*)=(.*)/);
+               next unless (/([^ ]*) (.*)/);
                my ($en,$ev) = ($1,$2);
                my $hf_bitname = "hf_$ifname\_$name\_$en";
                my $filtername = "$ifname\.$name\.$en";
                
-               register_hf_field($hf_bitname, field2name($en), $filtername, "FT_BOOLEAN", $e->{ALIGN} * 8, "TFS(&$en\_tfs)", $ev, "");
+               register_hf_field($hf_bitname, field2name($en), $filtername, "FT_BOOLEAN", $e->{ALIGN} * 8, "TFS(&$name\_$en\_tfs)", $ev, "");
 
-               pidl_def "static const true_false_string $name\_tfs = {";
-               pidl_def "   \"$name is SET\",";
-               pidl_def "   \"$name is NOT SET\",";
+               pidl_def "static const true_false_string $name\_$en\_tfs = {";
+               pidl_def "   \"$en is SET\",";
+               pidl_def "   \"$en is NOT SET\",";
                pidl_def "};";
                
                pidl_code "proto_tree_add_boolean(tree, $hf_bitname, tvb, offset-$e->{ALIGN}, $e->{ALIGN}, flags);";
                pidl_code "if (flags&$ev){";
-               pidl_code "\tproto_item_append_text(item,\"$en\");";
-               pidl_code "}\n";
+               pidl_code "\tproto_item_append_text(item,\"$en \");";
+               pidl_code "}";
                pidl_code "flags&=(~$ev);";
+               pidl_code "";
        }
 
        pidl_code "if(flags){";
-       pidl_code "proto_item_append_text(item, \"UNKNOWN-FLAGS\");";
+       pidl_code "\tproto_item_append_text(item, \"UNKNOWN-FLAGS\");";
        pidl_code "}\n";
-       deindent;
        pidl_code "return offset;";
+       deindent;
        pidl_code "}\n";
+
+       my $size = $e->{BASE_TYPE};
+       $size =~ s/uint//g;
+       register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", type2ft($e->{BASE_TYPE}), "BASE_DEC", "0", "NULL", $size/8);
 }
 
-sub ElementLevel($$$$)
+sub ElementLevel($$$$$)
 {
-       my ($e,$l,$hf,$myname) = @_;
+       my ($e,$l,$hf,$myname,$pn) = @_;
 
        if ($l->{TYPE} eq "POINTER") {
                my $type;
@@ -231,19 +217,37 @@ sub ElementLevel($$$$)
                } elsif ($l->{LEVEL} eq "EMBEDDED") {
                        $type = "embedded";
                }
-               pidl_code "offset=dissect_ndr_$type\_pointer(tvb,offset,pinfo,tree,drep,$myname\_,$ptrtype_mappings{$l->{POINTER_TYPE}},\"\",$hf);";
+               pidl_code "offset=dissect_ndr_$type\_pointer(tvb,offset,pinfo,tree,drep,$myname\_,$ptrtype_mappings{$l->{POINTER_TYPE}},\"".field2name($e->{NAME}) . " ($e->{TYPE})\",$hf);";
        } elsif ($l->{TYPE} eq "ARRAY") {
                my $af = "";
 
-               ($af = "ucarray") if ($l->{IS_VARYING});
-               ($af = "uvarray") if ($l->{IS_CONFORMANT});
+               ($af = "ucarray") if ($l->{IS_CONFORMANT});
+               ($af = "uvarray") if ($l->{IS_VARYING});
                ($af = "ucvarray") if ($l->{IS_CONFORMANT} and $l->{IS_VARYING});
 
                pidl_code "offset=dissect_ndr_$af(tvb,offset,pinfo,tree,drep,$myname\_);";
        } elsif ($l->{TYPE} eq "DATA") {
-               pidl_code "guint32 param="  . FindDissectorParam($myname).";";
-               defined($dissectors{$l->{DATA_TYPE}}) or warn("Unknown data type $l->{DATA_TYPE}");
-               pidl_code "offset=".$dissectors{$l->{DATA_TYPE}}."(tvb, offset, pinfo, tree, drep, $hf, param);";
+               if ($l->{DATA_TYPE} eq "string") {
+                       my $bs = 2;
+
+                       if (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_ASCII.*")) {
+                               $bs = 1;
+                       }
+                       
+                       if (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_SIZE4.*") and property_matches($e, "flag", ".*LIBNDR_FLAG_STR_LEN4.*")) {
+                               pidl_code "offset=dissect_ndr_cvstring(tvb,offset,pinfo,tree,drep,$bs,$hf,FALSE,NULL);";
+                       } elsif (property_matches($e, "flag", ".*LIBNDR_FLAG_LEN4.*")) {
+                               pidl_code "offset=dissect_ndr_vstring(tvb,offset,pinfo,tree,drep,$bs,$hf,FALSE,NULL);";
+                       }
+               } elsif (defined($types{$l->{DATA_TYPE}})) {
+                       my $param = FindDissectorParam($myname);
+                       my $x = $types{$l->{DATA_TYPE}}->{CALL};
+                       $x =~ s/\@HF\@/$hf/g;
+                       $x =~ s/\@PARAM\@/$param/g;
+                       pidl_code "$x";
+               } else {
+                       warn("Unknown data type `$l->{DATA_TYPE}'");
+               }
        } elsif ($_->{TYPE} eq "SUBCONTEXT") {
                die("subcontext() not supported")
        }
@@ -260,14 +264,16 @@ sub Element($$$)
        my $hf = register_hf_field("hf_$ifname\_$pn\_$e->{NAME}", field2name($e->{NAME}), "$ifname.$pn.$e->{NAME}", type2ft($e->{TYPE}), "BASE_HEX", "NULL", 0, "");
        my $add = "";
 
+
        foreach (@{$e->{LEVELS}}) {
                next if ($_->{TYPE} eq "SWITCH");
+               pidl_def "static int $dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep);";
                pidl_code "static int";
                pidl_code "$dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)";
                pidl_code "{";
                indent;
 
-               ElementLevel($e,$_,$hf,$dissectorname.$add);
+               ElementLevel($e,$_,$hf,$dissectorname.$add,$pn);
 
                pidl_code "return offset;";
                deindent;
@@ -288,12 +294,13 @@ sub Function($$$)
                $dissectornames{$_->{NAME}} = Element($_, $fn->{NAME}, $ifname) 
        }
        
+       PrintIdl DumpFunction($fn->{ORIGINAL});
        pidl_code "static int";
        pidl_code "$ifname\_dissect\_$fn->{NAME}_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)";
        pidl_code "{";
        indent;
        foreach (@{$fn->{ELEMENTS}}) {
-               if (grep(/in/,@{$_->{DIRECTION}})) {
+               if (grep(/out/,@{$_->{DIRECTION}})) {
                        pidl_code "$dissectornames{$_->{NAME}}";
                        pidl_code "offset=dissect_deferred_pointers(pinfo,tvb,offset,drep);";
                        pidl_code "";
@@ -308,7 +315,7 @@ sub Function($$$)
        pidl_code "{";
        indent;
        foreach (@{$fn->{ELEMENTS}}) {
-               if (grep(/out/,@{$_->{DIRECTION}})) {
+               if (grep(/in/,@{$_->{DIRECTION}})) {
                        pidl_code "$dissectornames{$_->{NAME}}";
                        pidl_code "offset=dissect_deferred_pointers(pinfo,tvb,offset,drep);";
                }
@@ -329,7 +336,7 @@ sub Struct($$$)
        register_ett("ett_$ifname\_$name");
 
        my $res = "";
-       ($res.="\t".Element($_, $name, $ifname)."\n") foreach (@{$e->{ELEMENTS}});
+       ($res.="\t".Element($_, $name, $ifname)."\n\n") foreach (@{$e->{ELEMENTS}});
 
        pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_);";
 
@@ -342,7 +349,9 @@ sub Struct($$$)
        pidl_code "int old_offset;";
        pidl_code "";
 
-       pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;";
+       if ($e->{ALIGN} > 1) {
+               pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;";
+       }
        pidl_code "";
 
        pidl_code "old_offset=offset;";
@@ -356,12 +365,12 @@ sub Struct($$$)
 
        pidl_code "\n$res";
 
-
-       pidl_code "";
        pidl_code "proto_item_set_len(item, offset-old_offset);";
        pidl_code "return offset;";
        deindent;
        pidl_code "}\n";
+
+       register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0);
 }
 
 sub Union($$$)
@@ -375,7 +384,9 @@ sub Union($$$)
        my $res = "";
        foreach (@{$e->{ELEMENTS}}) {
                $res.="\t\t\t$_->{CASE}:\n";
-               $res.="\t\t\t\t".Element($_, $name, $ifname)."\n";
+               if ($_->{TYPE} ne "EMPTY") {
+                       $res.="\t\t\t\t".Element($_, $name, $ifname)."\n";
+               }
                $res.="\t\t\tbreak;\n\n";
        }
 
@@ -389,13 +400,10 @@ sub Union($$$)
        pidl_code "g$e->{SWITCH_TYPE} level;";
        pidl_code "";
 
-       if ($e->{ALIGN} == 2) {
-               pidl_code "ALIGN_TO_2_BYTES;";
-       } elsif ($e->{ALIGN} == 4) {
-               pidl_code "ALIGN_TO_4_BYTES;";
+       if ($e->{ALIGN} > 1) {
+               pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;";
        }
 
-
        pidl_code "";
 
        pidl_code "old_offset=offset;";
@@ -416,12 +424,15 @@ sub Union($$$)
        deindent;
        pidl_code "}";
 
+       register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0);
 }
 
 sub Typedef($$)
 {
        my ($e,$ifname) = @_;
 
+       PrintIdl DumpTypedef($e->{ORIGINAL});
+
        {
                ENUM => \&Enum,
                STRUCT => \&Struct,
@@ -446,12 +457,19 @@ sub RegisterInterface($)
            # in epan/dissctors are deleted.
     
            my $name = "\"" . uc($x->{NAME}) . " (pidl)\"";
-               if (has_property($x, "helpstring")) {
-                       $name = $x->{PROPERTIES}->{helpstring};
-               }
-           my $short_name = "idl_$x->{NAME}";
-           my $filter_name = "idl_$x->{NAME}";
-    
+           my $short_name = $x->{NAME};
+           my $filter_name = $x->{NAME};
+
+           if (has_property($x, "helpstring")) {
+               $name = $x->{PROPERTIES}->{helpstring};
+           }
+
+           if (defined($protocols{$x->{NAME}})) {
+               $short_name = $protocols{$x->{NAME}}->{SHORTNAME};
+               $name = $protocols{$x->{NAME}}->{LONGNAME};
+               $filter_name = $protocols{$x->{NAME}}->{FILTERNAME};
+           }
+
            pidl_code "proto_dcerpc_$x->{NAME} = proto_register_protocol($name, \"$short_name\", \"$filter_name\");";
            
            pidl_code "proto_register_field_array(proto_dcerpc_$x->{NAME}, hf, array_length (hf));";
@@ -498,10 +516,6 @@ sub ProcessInterface($)
        register_ett("ett_dcerpc_$x->{NAME}");
        register_hf_field("hf_$x->{NAME}_opnum", "Operation", "$x->{NAME}.opnum", "FT_UINT16", "BASE_DEC", "NULL", 0, "");
 
-       foreach (@{$x->{TYPEDEFS}}) {
-               $dissectors{$_->{NAME}} = "$x->{NAME}_dissect_$_->{NAME}";
-       }
-
        if (defined($x->{UUID})) {
                my $if_uuid = $x->{UUID};
 
@@ -521,7 +535,9 @@ sub ProcessInterface($)
            . ", 0x" . substr($if_uuid, 35, 2) . " }";
            pidl_def "};";
        
-           pidl_def "static guint16 ver_dcerpc_$x->{NAME} = $x->{VERSION};";
+           my $maj = $x->{VERSION};
+           $maj =~ s/\.(.*)$//g;
+           pidl_def "static guint16 ver_dcerpc_$x->{NAME} = $maj;";
            pidl_def "";
        }
 
@@ -535,12 +551,62 @@ sub ProcessInterface($)
        pidl_hdr "#endif /* $define */";
 }
 
+
+sub register_type($$$$$$$)
+{
+       my ($type,$call,$ft,$base,$mask,$vals,$length) = @_;
+
+       $types{$type} = {
+               TYPE => $type,
+               CALL => $call,
+               FT_TYPE => $ft,
+               BASE => $base,
+               MASK => $mask,
+               VALSSTRING => $vals,
+               LENGTH => $length
+       };
+}
+
+# Loads the default types
+sub Initialize()
+{
+       foreach my $bytes (qw(1 2 4 8)) {
+               my $bits = $bytes * 8;
+               register_type("uint$bits", "offset=dissect_ndr_uint$bits(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);", "FT_UINT$bits", "BASE_DEC", 0, "NULL", $bytes);
+               register_type("int$bits", "offset=dissect_ndr_int$bits(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);", "FT_INT$bits", "BASE_DEC", 0, "NULL", $bytes);
+       }
+               
+       register_type("udlong", "offset=dissect_ndr_duint32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);", "FT_UINT64", "BASE_DEC", 0, "NULL", 4);
+       register_type("bool8", "offset=dissect_ndr_uint8(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT8", "BASE_DEC", 0, "NULL", 1);
+       register_type("char", "offset=dissect_ndr_int8(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT8", "BASE_DEC", 0, "NULL", 1);
+       register_type("long", "offset=dissect_ndr_int32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT32", "BASE_DEC", 0, "NULL", 4);
+       register_type("dlong", "offset=dissect_ndr_duint32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT64", "BASE_DEC", 0, "NULL", 8);
+       register_type("GUID", "offset=dissect_ndr_uuid_t(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_GUID", "BASE_NONE", 0, "NULL", 4);
+       register_type("policy_handle", "offset=dissect_nt_policy_hnd(tvb,offset,pinfo,tree,drep,\@HF\@,NULL,NULL,\@PARAM\@&0x01,\@PARAM\@&0x02);","FT_BYTES", "BASE_NONE", 0, "NULL", 4);
+       register_type("NTTIME", "offset=dissect_ndr_nt_NTTIME(tvb,offset,pinfo,tree,drep,\@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4);
+       register_type("NTTIME_hyper", "offset=dissect_ndr_nt_NTTIME(tvb,offset,pinfo,tree,drep,\@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4);
+       register_type("time_t", "offset=dissect_ndr_time_t(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_ABSOLUTE_TIME", "BASE_DEC", 0, "NULL", 4);
+       register_type("NTTIME_1sec", "offset=dissect_ndr_nt_NTTIME(tvb,offset,pinfo,tree,drep,\@HF\@);", "FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4);
+       register_type("SID", "
+               dcerpc_info *di = (dcerpc_info *)pinfo->private_data;
+
+               di->hf_index = \@HF\@;
+
+               offset=dissect_ndr_nt_SID_with_options(tvb,offset,pinfo,tree,drep,param);
+       ","FT_STRING", "BASE_DEC", 0, "NULL", 4);
+       register_type("WERROR", 
+               "offset=dissect_ndr_uint32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_UINT32", "BASE_DEC", 0, "VALS(NT_errors)", 4);
+
+}
+
 #####################################################################
 # Generate ethereal parser and header code
 sub Parse($$$)
 {
        my($ndr,$module,$filename) = @_;
 
+       Initialize();
+
        $tabs = "";
        my $h_filename = $filename;
 

diff --git a/source4/build/pidl/Parse/Pidl/NDR.pm b/source4/build/pidl/Parse/Pidl/NDR.pm
index 2c98e3254e47011fd7bd1b88005a36b4a61327d1..e00a0c98281aa5c96a82da4dc7679d2a301287a2 100644 (file)
--- a/source4/build/pidl/Parse/Pidl/NDR.pm
+++ b/source4/build/pidl/Parse/Pidl/NDR.pm
@@ -312,7 +312,8 @@ sub ParseElement($)
                TYPE => $e->{TYPE},
                PROPERTIES => $e->{PROPERTIES},
                LEVELS => GetElementLevelTable($e),
-               ALIGN => align_type($e->{TYPE})
+               ALIGN => align_type($e->{TYPE}),
+               ORIGINAL => $e
        };
 }
 
@@ -342,7 +343,8 @@ sub ParseStruct($)
                TYPE => "STRUCT",
                SURROUNDING_ELEMENT => $surrounding,
                ELEMENTS => \@elements,
-               PROPERTIES => $struct->{PROPERTIES}
+               PROPERTIES => $struct->{PROPERTIES},
+               ORIGINAL => $struct
        };
 }
 
@@ -377,7 +379,8 @@ sub ParseUnion($)
                TYPE => "UNION",
                SWITCH_TYPE => $switch_type,
                ELEMENTS => \@elements,
-               PROPERTIES => $e->{PROPERTIES}
+               PROPERTIES => $e->{PROPERTIES},
+               ORIGINAL => $e
        };
 }
 
@@ -389,7 +392,8 @@ sub ParseEnum($)
                TYPE => "ENUM",
                BASE_TYPE => Parse::Pidl::Typelist::enum_type_fn($e),
                ELEMENTS => $e->{ELEMENTS},
-               PROPERTIES => $e->{PROPERTIES}
+               PROPERTIES => $e->{PROPERTIES},
+               ORIGINAL => $e
        };
 }
 
@@ -401,7 +405,8 @@ sub ParseBitmap($)
                TYPE => "BITMAP",
                BASE_TYPE => Parse::Pidl::Typelist::bitmap_type_fn($e),
                ELEMENTS => $e->{ELEMENTS},
-               PROPERTIES => $e->{PROPERTIES}
+               PROPERTIES => $e->{PROPERTIES},
+               ORIGINAL => $e
        };
 }
 
@@ -431,7 +436,8 @@ sub ParseTypedef($$)
                NAME => $d->{NAME},
                TYPE => $d->{TYPE},
                PROPERTIES => $d->{PROPERTIES},
-               DATA => $data
+               DATA => $data,
+               ORIGINAL => $d
        };
 }
 
@@ -473,7 +479,8 @@ sub ParseFunction($$$)
                        OPNUM => $thisopnum,
                        RETURN_TYPE => $rettype,
                        PROPERTIES => $d->{PROPERTIES},
-                       ELEMENTS => \@elements
+                       ELEMENTS => \@elements,
+                       ORIGINAL => $d
                };
 }
 

diff --git a/source4/librpc/idl/atsvc.idl b/source4/librpc/idl/atsvc.idl
index a11a2cf7464a0f3f4ef2508253a19b4c4f2196fd..d2e06b0e4272c5b6325f034ce8e7fb4945d282d5 100644 (file)
--- a/source4/librpc/idl/atsvc.idl
+++ b/source4/librpc/idl/atsvc.idl
@@ -12,10 +12,62 @@
   endpoint("ncacn_np:[\\pipe\\atsvc]", "ncalrpc:")
 ] interface atsvc
 {
+       typedef [bitmap32bit] bitmap {
+                First   =       0x00000001,
+                Second  =       0x00000002,
+                Third   =       0x00000004,
+                Fourth  =       0x00000008,
+                Fifth   =       0x00000010,
+                Sixth   =       0x00000020,
+                Seventh =       0x00000040,
+                Eight   =       0x00000080,
+                Ninth   =       0x00000100,
+                Tenth   =       0x00000200,
+                Eleventh=       0x00000400,
+                Twelfth =       0x00000800,
+                Thitteenth      =       0x00001000,
+                Fourteenth      =       0x00002000,
+                Fifteenth       =       0x00004000,
+                Sixteenth       =       0x00008000,
+                Seventeenth     =       0x00010000,
+                Eighteenth      =       0x00020000,
+                Ninteenth       =       0x00040000,
+                Twentyth        =       0x00080000,
+                Twentyfirst     =       0x00100000,
+                Twentysecond    =       0x00200000,
+                Twentythird     =       0x00400000,
+                Twentyfourth    =       0x00800000,
+                Twentyfifth     =       0x01000000,
+                Twentysixth     =       0x02000000,
+                Twentyseventh   =       0x04000000,
+                Twentyeighth    =       0x08000000,
+                Twentyninth     =       0x10000000,
+                Thirtieth       =       0x20000000,
+                Thirtyfirst     =       0x40000000
+        } atsvc_DaysOfMonth;
+
+        typedef [bitmap8bit] bitmap {
+                JOB_RUN_PERIODICALLY    = 0x01,
+                JOB_EXEC_ERROR          = 0x02,
+                JOB_RUNS_TODAY          = 0x04,
+                JOB_ADD_CURRENT_DATE    = 0x08,
+                JOB_NONINTERACTIVE      = 0x10
+        } atsvc_Flags;
+
+       typedef [bitmap8bit] bitmap {
+               DAYSOFWEEK_MONDAY = 0x01,
+               DAYSOFWEEK_TUESDAY = 0x02,
+               DAYSOFWEEK_WEDNESDAY = 0x04,
+               DAYSOFWEEK_THURSDAY = 0x08,
+               DAYSOFWEEK_FRIDAY = 0x10,
+               DAYSOFWEEK_SATURDAY = 0x20,
+               DAYSOFWEEK_SUNDAY = 0x40
+       } atsvc_DaysOfWeek;
+       
        typedef struct {
                uint32 job_time;
-               uint32 days_of_month;
-               uint8 days_of_week;
+               atsvc_DaysOfMonth days_of_month;
+               atsvc_DaysOfWeek days_of_week;
                uint8 flags;
                unistr *command;
        } atsvc_JobInfo;
@@ -39,8 +91,8 @@
        typedef struct {
                uint32 job_id;
                uint32 job_time;
-               uint32 days_of_month;
-               uint8 days_of_week;
+               atsvc_DaysOfMonth days_of_month;
+               atsvc_DaysOfWeek days_of_week;
                uint8 flags;
                unistr *command;
        } atsvc_JobEnumInfo;