Changeset 988 for vendor/current/pidl

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

Location:

vendor/current/pidl

Files:

• README (modified) (3 diffs)
• TODO (modified) (1 diff)
• lib/Parse/Pidl/Dump.pm (modified) (2 diffs)
• lib/Parse/Pidl/NDR.pm (modified) (1 diff)
• lib/Parse/Pidl/Samba3/ClientNDR.pm (modified) (3 diffs)
• lib/Parse/Pidl/Samba3/ServerNDR.pm (modified) (10 diffs)
• lib/Parse/Pidl/Samba3/Template.pm (added)
• lib/Parse/Pidl/Samba4/Header.pm (modified) (2 diffs)
• lib/Parse/Pidl/Samba4/NDR/Client.pm (modified) (7 diffs)
• lib/Parse/Pidl/Samba4/NDR/Parser.pm (modified) (34 diffs)
• lib/Parse/Pidl/Samba4/NDR/Server.pm (modified) (4 diffs)
• lib/Parse/Pidl/Samba4/Python.pm (modified) (47 diffs)
• lib/Parse/Pidl/Samba4/Template.pm (modified) (6 diffs)
• lib/Parse/Pidl/Typelist.pm (modified) (2 diffs)
• lib/Parse/Pidl/Util.pm (modified) (3 diffs)
• lib/Parse/Pidl/Wireshark/Conformance.pm (modified) (5 diffs)
• lib/Parse/Pidl/Wireshark/NDR.pm (modified) (53 diffs)
• lib/wscript_build (modified) (1 diff)
• pidl (modified) (31 diffs)
• tests/Util.pm (modified) (1 diff)
• tests/samba-ndr.pl (modified) (2 diffs)
• tests/typelist.pl (modified) (2 diffs)
• tests/wireshark-conf.pl (modified) (1 diff)
• tests/wireshark-ndr.pl (modified) (1 diff)
• wscript (modified) (4 diffs)

vendor/current/pidl/README

@@ -1 +1 @@
 Introduction:
 =============
-This directory contains the source code of the pidl (Perl IDL) 
-compiler for Samba 4. 
+This directory contains the source code of the pidl (Perl IDL)
+compiler for Samba 4.
 
 The main sources for pidl are available using Git as part of
-the combined Samba 3 / Samba 4 tree. Use:
+the Samba source tree. Use:
 git clone git://git.samba.org/samba.git
 
-Pidl works by building a parse tree from a .pidl file (a simple 
-dump of it's internal parse tree) or a .idl file 
-(a file format mostly like the IDL file format midl uses). 
-The IDL file parser is in idl.yp (a yacc file converted to 
+Pidl works by building a parse tree from a .pidl file (a simple
+dump of it's internal parse tree) or a .idl file
+(a file format mostly like the IDL file format midl uses).
+The IDL file parser is in idl.yp (a yacc file converted to
 perl code by yapp)
-
-After a parse tree is present, pidl will call one of it's backends 
-(which one depends on the options given on the command-line). Here is 
-a list of current backends:
 
 Standalone installation:
 ========================
-Run Makefile.PL to generate the Makefile. 
+Run Makefile.PL to generate the Makefile.
 
 Then run "make install" (as root) to install.
@@ -26 +22 @@
 Internals overview:
 ===================
+
+After a parse tree is present, pidl will call one of it's backends
+(which one depends on the options given on the command-line). Here is
+a list of current backends:
 
 -- Generic --
@@ -56 +56 @@
 
 Tips for hacking on pidl:
- - Look at the pidl's parse tree by using the --keep option and looking 
-   at the generated .pidl file. 
- - The various backends have a lot in common, if you don't understand how one 
-   implements something, look at the others
+ - Inspect pidl's parse tree by using the --keep option and looking at the
+   generated .pidl file.
+ - The various backends have a lot in common, if you don't understand how one
+   implements something, look at the others.
  - See pidl(1) and the documentation on midl
- - See 'info bison' and yapp(1) for information on the file format of idl.yp 
+ - See 'info bison' and yapp(1) for information on the file format of idl.yp
+ - Run the tests (all in tests/)

vendor/current/pidl/TODO

@@ -15 +15 @@
 - --explain-ndr option that dumps out parse tree ?
 
-- seperate tables for NDR and DCE/RPC
+- separate tables for NDR and DCE/RPC
  - maybe no tables for NDR at all? we only need them for ndrdump 
    and that can use dlsym()

vendor/current/pidl/lib/Parse/Pidl/Dump.pm

@@ -40 +40 @@
 
     foreach my $d ($props) {
-        foreach my $k (keys %{$d}) {
+        foreach my $k (sort(keys %{$d})) {
             if ($k eq "in") {
                 $res .= "[in] ";
@@ -245 +245 @@
 
     $res .= "[\n";
-    foreach my $k (keys %{$data}) {
+    foreach my $k (sort(keys %{$data})) {
             $first || ($res .= ",\n"); $first = 0;
             $res .= "$k($data->{$k})";

vendor/current/pidl/lib/Parse/Pidl/NDR.pm

@@ -950 +950 @@
         my ($e) = @_;
 
+        if (property_matches($e, "flag", ".*STR_NULLTERM.*")) {
+                return 1;
+        }
+        if (exists($e->{LEVELS}) and $e->{LEVELS}->[0]->{TYPE} eq "ARRAY" and
+                ($e->{LEVELS}->[0]->{IS_FIXED} or $e->{LEVELS}->[0]->{IS_INLINE}) and
+                has_property($e, "charset"))
+        {
+                return 1;
+        }
+
         foreach my $l (@{$e->{LEVELS}}) {
                 return 1 if ($l->{TYPE} eq "ARRAY" and $l->{IS_ZERO_TERMINATED});
+        }
+        if (property_matches($e, "charset", ".*DOS.*")) {
+                return 1;
         }
 

vendor/current/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm

@@ -14 +14 @@
 use strict;
 use Parse::Pidl qw(fatal warning error);
-use Parse::Pidl::Util qw(has_property ParseExpr);
+use Parse::Pidl::Util qw(has_property ParseExpr genpad);
 use Parse::Pidl::NDR qw(ContainsPipe);
 use Parse::Pidl::Typelist qw(mapTypeName);
@@ -29 +29 @@
 sub fn_declare($$) { my ($self,$n) = @_; $self->pidl($n); $self->pidl_hdr("$n;"); }
 
-sub genpad($)
-{
-        my ($s) = @_;
-        my $nt = int((length($s)+1)/8);
-        my $lt = ($nt*8)-1;
-        my $ns = (length($s)-$lt);
-        return "\t"x($nt)." "x($ns);
-}
-
 sub new($)
 {
@@ -60 +51 @@
         my $ret = "";
 
-        foreach my $d (keys %{$props}) {
+        foreach my $d (sort(keys %{$props})) {
                 next if (grep(/^$d$/, @$ignores));
                 if($props->{$d} ne "1") {

vendor/current/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm

@@ -15 +15 @@
 use Parse::Pidl::Typelist qw(mapTypeName scalar_is_reference);
 use Parse::Pidl::Util qw(ParseExpr has_property is_constant);
-use Parse::Pidl::NDR qw(GetNextLevel);
+use Parse::Pidl::NDR qw(GetNextLevel ContainsPipe);
 use Parse::Pidl::Samba4 qw(ElementStars DeclLong);
 use Parse::Pidl::Samba4::Header qw(GenerateFunctionOutEnv);
@@ -25 +25 @@
 my $res_hdr;
 my $tabs = "";
+sub pidl_reset() { $res=""; $res_hdr="", $tabs=""; }
+sub pidl_return() { my $s = $res; my $h = $res_hdr; pidl_reset(); return ($s, $h) }
 sub indent() { $tabs.="\t"; }
 sub deindent() { $tabs = substr($tabs, 1); }
@@ -49 +51 @@
 }
 
-sub AllocOutVar($$$$$)
-{
-        my ($e, $mem_ctx, $name, $env, $fail) = @_;
+sub AllocOutVar($$$$$$$)
+{
+        my ($e, $mem_ctx, $name, $env, $check, $cleanup, $return) = @_;
 
         my $l = $e->{LEVELS}[0];
@@ -84 +86 @@
         }
 
-        pidl "if ($name == NULL) {";
-        $fail->();
-        pidl "}";
-        pidl "";
-}
-
-sub CallWithStruct($$$$)
-{
-        my ($pipes_struct, $mem_ctx, $fn, $fail) = @_;
+        pidl "if (" . $check->($name) . ") {";
+        indent;
+        pidl $cleanup->($name) if defined($cleanup);
+        pidl $return->($name) if defined($return);
+        deindent;
+        pidl "}";
+        pidl "";
+}
+
+sub CallWithStruct($$$$$$)
+{
+        my ($pipes_struct, $mem_ctx, $fn, $check, $cleanup, $return) = @_;
         my $env = GenerateFunctionOutEnv($fn);
         my $hasout = 0;
@@ -101 +106 @@
         pidl "ZERO_STRUCT(r->out);" if ($hasout);
 
-        my $proto = "_$fn->{NAME}(struct pipes_struct *p, struct $fn->{NAME} *r";
-        my $ret = "_$fn->{NAME}($pipes_struct, r";
         foreach (@{$fn->{ELEMENTS}}) {
                 my @dir = @{$_->{DIRECTION}};
@@ -111 +114 @@
 
         foreach (@{$fn->{ELEMENTS}}) {
+                next if ContainsPipe($_, $_->{LEVELS}[0]);
                 my @dir = @{$_->{DIRECTION}};
                 if (grep(/in/, @dir) and grep(/out/, @dir)) {
@@ -116 +120 @@
                 } elsif (grep(/out/, @dir) and not
                                  has_property($_, "represent_as")) {
-                        AllocOutVar($_, $mem_ctx, "r->out.$_->{NAME}", $env, $fail);
-                }
-        }
-        $ret .= ")";
-        $proto .= ");";
+                        AllocOutVar($_, $mem_ctx, "r->out.$_->{NAME}", $env,
+                                    $check, $cleanup, $return);
+                }
+        }
+
+        my $proto = "_$fn->{NAME}(struct pipes_struct *p, struct $fn->{NAME} *r)";
+        my $ret = "_$fn->{NAME}($pipes_struct, r)";
 
         if ($fn->{RETURN_TYPE}) {
                 $ret = "r->out.result = $ret";
-                $proto = "$fn->{RETURN_TYPE} $proto";
+                $proto = mapTypeName($fn->{RETURN_TYPE})." $proto";
         } else {
                 $proto = "void $proto";
         }
 
-        pidl_hdr "$proto";
+        pidl_hdr "$proto;";
         pidl "$ret;";
 }
@@ -176 +182 @@
         pidl "";
 
-        CallWithStruct("p", "r", $fn, 
-        sub { 
-                        pidl "\ttalloc_free(r);";
-                        pidl "\treturn false;";
+        CallWithStruct("p", "r", $fn,
+                sub ($) {
+                        my ($name) = @_;
+                        return "${name} == NULL";
+                },
+                sub ($) {
+                        my ($name) = @_;
+                        return "talloc_free(r);";
+                },
+                sub ($) {
+                        my ($name) = @_;
+                        return "return false;";
                 }
         );
@@ -286 +300 @@
         my($ndr,$header,$ndr_header) = @_;
 
-        $res = "";
-        $res_hdr = "";
+        pidl_reset();
 
         pidl "/*";
@@ -304 +317 @@
         }
 
-        return ($res, $res_hdr);
+        return pidl_return();
 }
 

vendor/current/pidl/lib/Parse/Pidl/Samba4/Header.pm

@@ -39 +39 @@
         my $ret = "";
 
-        foreach my $d (keys %{$props}) {
+        foreach my $d (sort(keys %{$props})) {
                 next if (grep(/^$d$/, @$ignores));
                 if($props->{$d} ne "1") {
@@ -143 +143 @@
                 my $with_val = 0;
                 my $without_val = 0;
-                pidl " { __donnot_use_enum_$name=0x7FFFFFFF}\n";
+                pidl " { __do_not_use_enum_$name=0x7FFFFFFF}\n";
                 foreach my $e (@{$enum->{ELEMENTS}}) {
                         my $t = "$e";

vendor/current/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm

@@ -12 +12 @@
 
 use Parse::Pidl qw(fatal warning error);
-use Parse::Pidl::Util qw(has_property ParseExpr);
+use Parse::Pidl::Util qw(has_property ParseExpr genpad);
 use Parse::Pidl::NDR qw(ContainsPipe);
 use Parse::Pidl::Typelist qw(mapTypeName);
@@ -29 +29 @@
 sub pidl_both($$) { my ($self, $txt) = @_; $self->{hdr} .= "$txt\n"; $self->{res_hdr} .= "$txt\n"; }
 sub fn_declare($$) { my ($self,$n) = @_; $self->pidl($n); $self->pidl_hdr("$n;"); }
-
-sub genpad($)
-{
-        my ($s) = @_;
-        my $nt = int((length($s)+1)/8);
-        my $lt = ($nt*8)-1;
-        my $ns = (length($s)-$lt);
-        return "\t"x($nt)." "x($ns);
-}
 
 sub new($)
@@ -159 +150 @@
 
         $self->pidl("status = dcerpc_binding_handle_call_recv(subreq);");
-        $self->pidl("if (!NT_STATUS_IS_OK(status)) {");
-        $self->indent;
-        $self->pidl("tevent_req_nterror(req, status);");
+        $self->pidl("TALLOC_FREE(subreq);");
+        $self->pidl("if (tevent_req_nterror(req, status)) {");
+        $self->indent;
         $self->pidl("return;");
         $self->deindent;
@@ -260 +251 @@
         my $ret = "";
 
-        foreach my $d (keys %{$props}) {
+        foreach my $d (sort(keys %{$props})) {
                 next if (grep(/^$d$/, @$ignores));
                 if($props->{$d} ne "1") {
@@ -401 +392 @@
                 }
 
+                my $dest_ptr = "$o$e->{NAME}";
+                my $elem_size = "sizeof(*$dest_ptr)";
+                $self->pidl("if ($dest_ptr != $out_var) {");
+                $self->indent;
                 if (has_property($e, "charset")) {
-                        $self->pidl("memcpy(discard_const_p(uint8_t *, $o$e->{NAME}), $out_var, $copy_len_var * sizeof(*$o$e->{NAME}));");
-                } else {
-                        $self->pidl("memcpy($o$e->{NAME}, $out_var, $copy_len_var * sizeof(*$o$e->{NAME}));");
-                }
+                        $dest_ptr = "discard_const_p(uint8_t *, $dest_ptr)";
+                }
+                $self->pidl("memcpy($dest_ptr, $out_var, $copy_len_var * $elem_size);");
+                $self->deindent;
+                $self->pidl("}");
 
                 $self->deindent;
@@ -564 +560 @@
         $self->pidl("status = dcerpc_$name\_r_recv(subreq, mem_ctx);");
         $self->pidl("TALLOC_FREE(subreq);");
-        $self->pidl("if (!NT_STATUS_IS_OK(status)) {");
-        $self->indent;
-        $self->pidl("tevent_req_nterror(req, status);");
+        $self->pidl("if (tevent_req_nterror(req, status)) {");
+        $self->indent;
         $self->pidl("return;");
         $self->deindent;
@@ -693 +688 @@
         }
         $self->pidl("");
+
+        $self->pidl("/* Out parameters */");
+        foreach my $e (@{$fn->{ELEMENTS}}) {
+                next unless grep(/out/, @{$e->{DIRECTION}});
+
+                $self->ParseCopyArgument($fn, $e, "r.out.", "_");
+        }
+        $self->pidl("");
+
+        if (defined($fn->{RETURN_TYPE})) {
+                $self->pidl("/* Result */");
+                $self->pidl("ZERO_STRUCT(r.out.result);");
+                $self->pidl("");
+        }
 
         $self->pidl("status = dcerpc_$name\_r(h, mem_ctx, &r);");

vendor/current/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm

@@ -199 +199 @@
                         $size = $length = "ndr_string_length($var_name, sizeof(*$var_name))";
                 }
+                if (defined($l->{SIZE_IS})) {
+                        $size = ParseExpr($l->{SIZE_IS}, $env, $e);
+                }
+                if (defined($l->{LENGTH_IS})) {
+                        $length = ParseExpr($l->{LENGTH_IS}, $env, $e);
+                }
         } else {
                 $size = ParseExpr($l->{SIZE_IS}, $env, $e);
@@ -256 +262 @@
                         }
                 }
-                warning($element->{ORIGINAL}, "Got pointer for `$e->{NAME}', expected fully derefenced variable") if ($nump > length($ptr));
+                warning($element->{ORIGINAL}, "Got pointer for `$e->{NAME}', expected fully dereferenced variable") if ($nump > length($ptr));
                 return ($origvar);
         }
@@ -413 +419 @@
         }
 
-        if ($l->{IS_CONFORMANT} and not $l->{IS_ZERO_TERMINATED}) {
+        if ($l->{IS_CONFORMANT} and (defined($l->{SIZE_IS}) or not $l->{IS_ZERO_TERMINATED})) {
                 $self->defer("if ($var_name) {");
                 $self->defer_indent;
@@ -425 +431 @@
         }
 
-        if ($l->{IS_VARYING} and not $l->{IS_ZERO_TERMINATED}) {
+        if ($l->{IS_VARYING} and (defined($l->{LENGTH_IS}) or not $l->{IS_ZERO_TERMINATED})) {
                 $self->defer("if ($var_name) {");
                 $self->defer_indent;
@@ -627 +633 @@
         }
 
-        if ($l->{TYPE} eq "POINTER" and $deferred) {
+        if ($l->{TYPE} eq "POINTER" and $l->{POINTER_TYPE} eq "ignore") {
+                $self->pidl("/* [ignore] '$e->{NAME}' */");
+        } elsif ($l->{TYPE} eq "POINTER" and $deferred) {
                 my $rel_var_name = $var_name;
                 if ($l->{POINTER_TYPE} ne "ref") {
@@ -663 +671 @@
 
                 if ((($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) and not $array_pointless) {
-                        $self->pidl("for ($counter = 0; $counter < $length; $counter++) {");
+                        $self->pidl("for ($counter = 0; $counter < ($length); $counter++) {");
                         $self->indent;
                         $self->ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 0);
@@ -671 +679 @@
 
                 if ($deferred and ContainsDeferred($e, $l) and not $array_pointless) {
-                        $self->pidl("for ($counter = 0; $counter < $length; $counter++) {");
+                        $self->pidl("for ($counter = 0; $counter < ($length); $counter++) {");
                         $self->indent;
                         $self->ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 0, 1);
@@ -730 +738 @@
 
         if ($l->{POINTER_TYPE} eq "ref") {
-                $self->pidl("if ($var_name == NULL) {");
-                $self->indent;
-                $self->pidl("return ndr_push_error($ndr, NDR_ERR_INVALID_POINTER, \"NULL [ref] pointer\");");
-                $self->deindent;
-                $self->pidl("}");
+                if ($l->{LEVEL_INDEX} > 0) {
+                        $self->pidl("if ($var_name == NULL) {");
+                        $self->indent;
+                        $self->pidl("return ndr_push_error($ndr, NDR_ERR_INVALID_POINTER, \"NULL [ref] pointer\");");
+                        $self->deindent;
+                        $self->pidl("}");
+                }
                 if ($l->{LEVEL} eq "EMBEDDED") {
-                        $self->pidl("NDR_CHECK(ndr_push_ref_ptr(ndr));");
+                        $self->pidl("NDR_CHECK(ndr_push_ref_ptr(ndr)); /* $var_name */");
                 }
         } elsif ($l->{POINTER_TYPE} eq "relative") {
@@ -746 +756 @@
         } elsif ($l->{POINTER_TYPE} eq "full") {
                 $self->pidl("NDR_CHECK(ndr_push_full_ptr($ndr, $var_name));");
+        } elsif ($l->{POINTER_TYPE} eq "ignore") {
+                # We don't want this pointer to appear on the wire at all
+                $self->pidl("NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));");
         } else {
                 die("Unhandled pointer type $l->{POINTER_TYPE}");
@@ -805 +818 @@
 
         return if (has_property($e, "noprint"));
+        my $cur_depth = 0;
+        my $ignore_depth = 0xFFFF;
 
         if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}) {
@@ -818 +833 @@
 
         foreach my $l (@{$e->{LEVELS}}) {
+                $cur_depth += 1;
+
+                if ($cur_depth > $ignore_depth) {
+                        next;
+                }
+
                 if ($l->{TYPE} eq "POINTER") {
                         $self->pidl("ndr_print_ptr($ndr, \"$e->{NAME}\", $var_name);");
+                        if ($l->{POINTER_TYPE} eq "ignore") {
+                                $self->pidl("/* [ignore] '$e->{NAME}' */");
+                                $ignore_depth = $cur_depth;
+                                last;
+                        }
                         $self->pidl("$ndr->depth++;");
                         if ($l->{POINTER_TYPE} ne "ref") {
@@ -833 +859 @@
                         }
                         
-                        if ($l->{IS_ZERO_TERMINATED}) {
+                        if ($l->{IS_ZERO_TERMINATED} and not defined($l->{LENGTH_IS})) {
                                 $length = "ndr_string_length($var_name, sizeof(*$var_name))";
                         } else {
@@ -852 +878 @@
                                 $self->pidl("$ndr->print($ndr, \"\%s: ARRAY(\%d)\", \"$e->{NAME}\", (int)$length);");
                                 $self->pidl("$ndr->depth++;");
-                                $self->pidl("for ($counter=0;$counter<$length;$counter++) {");
+                                $self->pidl("for ($counter = 0; $counter < ($length); $counter++) {");
                                 $self->indent;
 
@@ -867 +893 @@
 
         foreach my $l (reverse @{$e->{LEVELS}}) {
+                $cur_depth -= 1;
+
+                if ($cur_depth > $ignore_depth) {
+                        next;
+                }
+
                 if ($l->{TYPE} eq "POINTER") {
+                        if ($l->{POINTER_TYPE} eq "ignore") {
+                                next;
+                        }
+
                         if ($l->{POINTER_TYPE} ne "ref") {
                                 $self->deindent;
@@ -1007 +1043 @@
 
         return undef unless ($l->{TYPE} eq "POINTER" or $l->{TYPE} eq "ARRAY");
+        return undef if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ignore"));
 
         return undef unless ($l->{TYPE} ne "ARRAY" or ArrayDynamicallyAllocated($e,$l));
@@ -1115 +1152 @@
 
         # add additional constructions
-        if ($l->{TYPE} eq "POINTER" and $deferred) {
+        if ($l->{TYPE} eq "POINTER" and $l->{POINTER_TYPE} eq "ignore") {
+                $self->pidl("/* [ignore] '$e->{NAME}' */");
+        } elsif ($l->{TYPE} eq "POINTER" and $deferred) {
                 if ($l->{POINTER_TYPE} ne "ref") {
                         $self->pidl("if ($var_name) {");
@@ -1135 +1174 @@
 
                 if ($l->{POINTER_TYPE} ne "ref") {
-                        if ($l->{POINTER_TYPE} eq "relative") {
+                        if ($l->{POINTER_TYPE} eq "relative" or $l->{POINTER_TYPE} eq "relative_short") {
                                 $self->pidl("if ($ndr->offset > $ndr->relative_highest_offset) {");
                                 $self->indent;
@@ -1167 +1206 @@
                         }
 
-                        $self->pidl("for ($counter = 0; $counter < $length; $counter++) {");
+                        $self->pidl("for ($counter = 0; $counter < ($length); $counter++) {");
                         $self->indent;
                         $self->ParseElementPullLevel($e, $nl, $ndr, $var_name, $env, 1, 0);
@@ -1175 +1214 @@
 
                 if ($deferred and ContainsDeferred($e, $l)) {
-                        $self->pidl("for ($counter = 0; $counter < $length; $counter++) {");
+                        $self->pidl("for ($counter = 0; $counter < ($length); $counter++) {");
                         $self->indent;
                         $self->ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 0, 1);
@@ -1256 +1295 @@
         } elsif ($l->{POINTER_TYPE} eq "relative_short") {
                 $self->pidl("NDR_CHECK(ndr_pull_relative_ptr_short($ndr, &_ptr_$e->{NAME}));");
+        } elsif ($l->{POINTER_TYPE} eq "ignore") {
+                #We want to consume the pointer bytes, but ignore the pointer value
+                $self->pidl("NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &_ptr_$e->{NAME}));");
+                $self->pidl("_ptr_$e->{NAME} = 0;");
         } else {
                 die("Unhandled pointer type $l->{POINTER_TYPE}");
@@ -1263 +1306 @@
         $self->indent;
 
-        # Don't do this for arrays, they're allocated at the actual level 
-        # of the array
-        unless ($next_is_array or $next_is_string) { 
-                $self->pidl("NDR_PULL_ALLOC($ndr, $var_name);"); 
+        if ($l->{POINTER_TYPE} eq "ignore") {
+                # Don't do anything, we don't want to do the
+                # allocation, as we forced it to NULL just above, and
+                # we may not know the declared type anyway.
         } else {
-                # FIXME: Yes, this is nasty.
-                # We allocate an array twice
-                # - once just to indicate that it's there,
-                # - then the real allocation...
-                $self->pidl("NDR_PULL_ALLOC($ndr, $var_name);");
+                # Don't do this for arrays, they're allocated at the actual level 
+                # of the array
+                unless ($next_is_array or $next_is_string) { 
+                       $self->pidl("NDR_PULL_ALLOC($ndr, $var_name);"); 
+                } else {
+                       # FIXME: Yes, this is nasty.
+                       # We allocate an array twice
+                       # - once just to indicate that it's there,
+                       # - then the real allocation...
+                       $self->pidl("NDR_PULL_ALLOC($ndr, $var_name);");
+                }
         }
 
@@ -1285 +1334 @@
 }
 
+sub CheckRefPtrs($$$$)
+{
+        my ($self,$e,$ndr,$env) = @_;
+
+        return if ContainsPipe($e, $e->{LEVELS}[0]);
+        return if ($e->{LEVELS}[0]->{TYPE} ne "POINTER");
+        return if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref");
+
+        my $var_name = $env->{$e->{NAME}};
+        $var_name = append_prefix($e, $var_name);
+
+        $self->pidl("if ($var_name == NULL) {");
+        $self->indent;
+        $self->pidl("return ndr_push_error($ndr, NDR_ERR_INVALID_POINTER, \"NULL [ref] pointer\");");
+        $self->deindent;
+        $self->pidl("}");
+}
+
 sub ParseStructPushPrimitives($$$$$)
 {
         my ($self, $struct, $ndr, $varname, $env) = @_;
+
+        $self->CheckRefPtrs($_, $ndr, $env) foreach (@{$struct->{ELEMENTS}});
 
         # see if the structure contains a conformant array. If it
@@ -1307 +1376 @@
                                         $size = "ndr_string_length($varname->$e->{NAME}, sizeof(*$varname->$e->{NAME}))";
                                 }
+                                if (defined($e->{LEVELS}[0]->{SIZE_IS})) {
+                                        $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env, $e->{ORIGINAL});
+                                }
                         } else {
                                 $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env, $e->{ORIGINAL});
@@ -1357 +1429 @@
         $self->start_flags($struct, $ndr);
 
+        $self->pidl("NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);");
         $self->pidl("if (ndr_flags & NDR_SCALARS) {");
         $self->indent;
@@ -1610 +1683 @@
         foreach my $l (@{$e->{LEVELS}}) {
                 my $mem_flags = $self->ParseMemCtxPullFlags($e, $l);
+
+                if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ignore")) {
+                        last;
+                }
+
                 if (defined($mem_flags)) {
-                        $self->pidl("TALLOC_CTX *_mem_save_$e->{NAME}_$l->{LEVEL_INDEX};");
+                        $self->pidl("TALLOC_CTX *_mem_save_$e->{NAME}_$l->{LEVEL_INDEX} = NULL;");
                 }
         }
@@ -1674 +1752 @@
         my $env = GenerateStructEnv($struct, $varname);
 
+        $self->pidl("NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);");
         $self->pidl("if (ndr_flags & NDR_SCALARS) {");
         $self->indent;
@@ -1778 +1857 @@
                         }
                         $self->DeclareArrayVariables($el);
-                        $self->ParseElementPush($el, $ndr, {$el->{NAME} => "$varname->$el->{NAME}"}, 1, 0);
+                        my $el_env = {$el->{NAME} => "$varname->$el->{NAME}"};
+                        $self->CheckRefPtrs($el, $ndr, $el_env);
+                        $self->ParseElementPush($el, $ndr, $el_env, 1, 0);
                         $self->deindent;
                 }
@@ -1837 +1918 @@
         $self->start_flags($e, $ndr);
 
+        $self->pidl("NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);");
         $self->pidl("if (ndr_flags & NDR_SCALARS) {");
         $self->indent;
@@ -2014 +2096 @@
         $self->pidl("level = ndr_pull_get_switch_value($ndr, $varname);");
 
+        $self->pidl("NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);");
         $self->pidl("if (ndr_flags & NDR_SCALARS) {");
         $self->indent;
@@ -2296 +2379 @@
         }
 
+        $self->pidl("NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);");
+
         $self->pidl("if (flags & NDR_IN) {");
         $self->indent;
@@ -2302 +2387 @@
 
         EnvSubstituteValue($env, $fn);
+
+        foreach my $e (@{$fn->{ELEMENTS}}) {
+                if (grep(/in/,@{$e->{DIRECTION}})) {
+                        $self->CheckRefPtrs($e, $ndr, $env);
+                }
+        }
 
         foreach my $e (@{$fn->{ELEMENTS}}) {
@@ -2316 +2407 @@
 
         $env = GenerateFunctionOutEnv($fn);
+        EnvSubstituteValue($env, $fn);
+
+        foreach my $e (@{$fn->{ELEMENTS}}) {
+                if (grep(/out/,@{$e->{DIRECTION}})) {
+                        $self->CheckRefPtrs($e, $ndr, $env);
+                }
+        }
+
         foreach my $e (@{$fn->{ELEMENTS}}) {
                 if (grep(/out/,@{$e->{DIRECTION}})) {
@@ -2382 +2481 @@
                 $double_cases{"$e->{NAME}"} = 1;
         }
+
+        $self->pidl("NDR_PULL_CHECK_FN_FLAGS(ndr, flags);");
 
         $self->pidl("if (flags & NDR_IN) {");
@@ -2704 +2805 @@
                 my $name = uc $interface->{NAME};
                 $self->pidl_hdr("#define NDR_$name\_UUID " . 
-                Parse::Pidl::Util::make_str(lc($interface->{PROPERTIES}->{uuid})));
-
-                if(!defined $interface->{PROPERTIES}->{version}) { $interface->{PROPERTIES}->{version} = "0.0"; }
-                $self->pidl_hdr("#define NDR_$name\_VERSION $interface->{PROPERTIES}->{version}");
+                Parse::Pidl::Util::make_str(lc($interface->{UUID})));
+
+                $self->pidl_hdr("#define NDR_$name\_VERSION $interface->{VERSION}");
 
                 $self->pidl_hdr("#define NDR_$name\_NAME \"$interface->{NAME}\"");

vendor/current/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm

@@ -78 +78 @@
         my $name = $interface->{NAME}; 
         my $uname = uc $name;
-        my $uuid = lc($interface->{PROPERTIES}->{uuid});
-        my $if_version = $interface->{PROPERTIES}->{version};
+        my $uuid = lc($interface->{UUID});
+        my $if_version = $interface->{VERSION};
 
         pidl "
@@ -252 +252 @@
         }
 
-        return false;   
-}
-        
+        return false;
+}
+
 NTSTATUS dcerpc_server_$name\_init(void)
 {
@@ -290 +290 @@
         my $count = 0;
 
+        $res .= "NTSTATUS dcerpc_server_$interface->{NAME}\_init(void);\n";
+        $res .= "\n";
+
         if (!defined $interface->{PROPERTIES}->{uuid}) {
                 return $res;
@@ -320 +323 @@
         $res .= "/* server functions auto-generated by pidl */\n";
         $res .= "#include \"$header\"\n";
+        $res .= "#include <util/debug.h>\n";
         $res .= "\n";
 

vendor/current/pidl/lib/Parse/Pidl/Samba4/Python.pm

@@ -11 +11 @@
 use strict;
 use Parse::Pidl qw(warning fatal error);
-use Parse::Pidl::Typelist qw(hasType resolveType getType mapTypeName expandAlias);
+use Parse::Pidl::Typelist qw(hasType resolveType getType mapTypeName expandAlias bitmap_type_fn enum_type_fn);
 use Parse::Pidl::Util qw(has_property ParseExpr unmake_str);
 use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred ContainsPipe is_charset_array);
@@ -23 +23 @@
 sub new($) {
         my ($class) = @_;
-        my $self = { res => "", res_hdr => "", tabs => "", constants => {},
+        my $self = { res => "", res_hdr => "", tabs => "",
+                                 constants => [], constants_uniq => {},
                      module_methods => [], module_objects => [], ready_types => [],
-                                 module_imports => {}, type_imports => {},
+                                 module_imports => [], module_imports_uniq => {},
+                                 type_imports => [], type_imports_uniq => {},
                                  patch_type_calls => [], prereadycode => [],
                                  postreadycode => []};
@@ -95 +97 @@
         my ($self, $name, $type, $value) = @_;
 
-        $self->{constants}->{$name} = [$type, $value];
+        unless (defined $self->{constants_uniq}->{$name}) {
+                my $h = {"key" => $name, "val" => [$type, $value]};
+                push @{$self->{constants}}, $h;
+                $self->{constants_uniq}->{$name} = $h;
+        }
 }
 
@@ -107 +113 @@
                 $e =~ /^([A-Za-z0-9_]+)/;
                 my $cname = $1;
-                
+
                 $self->register_constant($cname, $d, $cname);
         }
@@ -201 +207 @@
                         $self->pidl("{");
                         $self->indent;
-                        $self->pidl("$cname *object = ($cname *)py_talloc_get_ptr(obj);");
+                        $self->pidl("$cname *object = ($cname *)pytalloc_get_ptr(obj);");
                         $self->pidl("PyObject *py_$e->{NAME};");
-                        $self->ConvertObjectToPython("py_talloc_get_mem_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}", "return NULL;");
+                        $self->ConvertObjectToPython("pytalloc_get_mem_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}", "return NULL;");
                         $self->pidl("return py_$e->{NAME};");
                         $self->deindent;
@@ -212 +218 @@
                         $self->pidl("{");
                         $self->indent;
-                        $self->pidl("$cname *object = ($cname *)py_talloc_get_ptr(py_obj);");
-                        my $mem_ctx = "py_talloc_get_mem_ctx(py_obj)";
+                        $self->pidl("$cname *object = ($cname *)pytalloc_get_ptr(py_obj);");
+                        my $mem_ctx = "pytalloc_get_mem_ctx(py_obj)";
                         my $l = $e->{LEVELS}[0];
                         my $nl = GetNextLevel($e, $l);
-                        if ($l->{TYPE} eq "POINTER" and 
+                        if ($l->{TYPE} eq "POINTER" and
                                 not ($nl->{TYPE} eq "ARRAY" and ($nl->{IS_FIXED} or is_charset_array($e, $nl))) and
                                 not ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE}))) {
-                                $self->pidl("talloc_unlink(py_talloc_get_mem_ctx(py_obj), $varname);");
+                                $self->pidl("talloc_unlink($mem_ctx, discard_const($varname));");
                         }
                         $self->ConvertObjectFromPython($env, $mem_ctx, $e, "value", $varname, "return -1;");
@@ -232 +238 @@
                 $self->indent;
                 foreach my $e (@{$d->{ELEMENTS}}) {
-                        $self->pidl("{ discard_const_p(char, \"$e->{NAME}\"), py_$name\_get_$e->{NAME}, py_$name\_set_$e->{NAME} },");
-                }
-                $self->pidl("{ NULL }");
+                        $self->pidl("{");
+                        $self->indent;
+                        $self->pidl(".name = discard_const_p(char, \"$e->{NAME}\"),");
+                        $self->pidl(".get = py_$name\_get_$e->{NAME},");
+                        $self->pidl(".set = py_$name\_set_$e->{NAME},");
+                        $self->pidl(".doc = discard_const_p(char, \"PIDL-generated element $e->{NAME}\")");
+                        $self->deindent;
+                        $self->pidl("},");
+                }
+                $self->pidl("{ .name = NULL }");
                 $self->deindent;
                 $self->pidl("};");
@@ -243 +256 @@
         $self->pidl("{");
         $self->indent;
-        $self->pidl("return py_talloc_new($cname, type);");
+        $self->pidl("return pytalloc_new($cname, type);");
         $self->deindent;
         $self->pidl("}");
@@ -250 +263 @@
         my $py_methods = "NULL";
 
-        # If the struct is not public there ndr_pull/ndr_push functions will 
+        # If the struct is not public there ndr_pull/ndr_push functions will
         # be static so not callable from here
         if (has_property($d, "public")) {
@@ -256 +269 @@
                 $self->pidl("{");
                 $self->indent;
-                $self->pidl("$cname *object = ($cname *)py_talloc_get_ptr(py_obj);");
+                $self->pidl("$cname *object = ($cname *)pytalloc_get_ptr(py_obj);");
+                $self->pidl("PyObject *ret = NULL;");
                 $self->pidl("DATA_BLOB blob;");
                 $self->pidl("enum ndr_err_code err;");
-                $self->pidl("err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_$name);");
+                $self->pidl("TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj));");
+                $self->pidl("if (tmp_ctx == NULL) {");
+                $self->indent;
+                $self->pidl("PyErr_SetNdrError(NDR_ERR_ALLOC);");
+                $self->pidl("return NULL;");
+                $self->deindent;
+                $self->pidl("}");
+                $self->pidl("err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_$name);");
                 $self->pidl("if (err != NDR_ERR_SUCCESS) {");
                 $self->indent;
+                $self->pidl("TALLOC_FREE(tmp_ctx);");
                 $self->pidl("PyErr_SetNdrError(err);");
                 $self->pidl("return NULL;");
@@ -267 +289 @@
                 $self->pidl("}");
                 $self->pidl("");
-                $self->pidl("return PyString_FromStringAndSize((char *)blob.data, blob.length);");
-                $self->deindent;
-                $self->pidl("}");
-                $self->pidl("");
-
-                $self->pidl("static PyObject *py_$name\_ndr_unpack(PyObject *py_obj, PyObject *args)");
+                $self->pidl("ret = PyString_FromStringAndSize((char *)blob.data, blob.length);");
+                $self->pidl("TALLOC_FREE(tmp_ctx);");
+                $self->pidl("return ret;");
+                $self->deindent;
+                $self->pidl("}");
+                $self->pidl("");
+
+                $self->pidl("static PyObject *py_$name\_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)");
                 $self->pidl("{");
                 $self->indent;
-                $self->pidl("$cname *object = ($cname *)py_talloc_get_ptr(py_obj);");
+                $self->pidl("$cname *object = ($cname *)pytalloc_get_ptr(py_obj);");
                 $self->pidl("DATA_BLOB blob;");
+                $self->pidl("Py_ssize_t blob_length = 0;");
                 $self->pidl("enum ndr_err_code err;");
-                $self->pidl("if (!PyArg_ParseTuple(args, \"s#:__ndr_unpack__\", &blob.data, &blob.length))");
-                $self->pidl("\treturn NULL;");
-                $self->pidl("");
-                $self->pidl("err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_$name);");
+                $self->pidl("const char * const kwnames[] = { \"data_blob\", \"allow_remaining\", NULL };");
+                $self->pidl("PyObject *allow_remaining_obj = NULL;");
+                $self->pidl("bool allow_remaining = false;");
+                $self->pidl("");
+                $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"s#|O:__ndr_unpack__\",");
+                $self->indent;
+                $self->pidl("discard_const_p(char *, kwnames),");
+                $self->pidl("&blob.data, &blob_length,");
+                $self->pidl("&allow_remaining_obj)) {");
+                $self->deindent;
+                $self->indent;
+                $self->pidl("return NULL;");
+                $self->deindent;
+                $self->pidl("}");
+                $self->pidl("blob.length = blob_length;");
+                $self->pidl("");
+                $self->pidl("if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {");
+                $self->indent;
+                $self->pidl("allow_remaining = true;");
+                $self->deindent;
+                $self->pidl("}");
+                $self->pidl("");
+                $self->pidl("if (allow_remaining) {");
+                $self->indent;
+                $self->pidl("err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_$name);");
+                $self->deindent;
+                $self->pidl("} else {");
+                $self->indent;
+                $self->pidl("err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_$name);");
+                $self->deindent;
+                $self->pidl("}");
                 $self->pidl("if (err != NDR_ERR_SUCCESS) {");
                 $self->indent;
@@ -297 +349 @@
                 $self->pidl("{");
                 $self->indent;
-                $self->pidl("$cname *object = ($cname *)py_talloc_get_ptr(py_obj);");
+                $self->pidl("$cname *object = ($cname *)pytalloc_get_ptr(py_obj);");
                 $self->pidl("PyObject *ret;");
                 $self->pidl("char *retstr;");
                 $self->pidl("");
-                $self->pidl("retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_$name, \"$name\", object);");
+                $self->pidl("retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_$name, \"$name\", object);");
                 $self->pidl("ret = PyString_FromString(retstr);");
                 $self->pidl("talloc_free(retstr);");
@@ -314 +366 @@
                 $self->indent;
                 $self->pidl("{ \"__ndr_pack__\", (PyCFunction)py_$name\_ndr_pack, METH_NOARGS, \"S.ndr_pack(object) -> blob\\nNDR pack\" },");
-                $self->pidl("{ \"__ndr_unpack__\", (PyCFunction)py_$name\_ndr_unpack, METH_VARARGS, \"S.ndr_unpack(class, blob) -> None\\nNDR unpack\" },");
+                $self->pidl("{ \"__ndr_unpack__\", (PyCFunction)py_$name\_ndr_unpack, METH_VARARGS|METH_KEYWORDS, \"S.ndr_unpack(class, blob, allow_remaining=False) -> None\\nNDR unpack\" },");
                 $self->pidl("{ \"__ndr_print__\", (PyCFunction)py_$name\_ndr_print, METH_VARARGS, \"S.ndr_print(object) -> None\\nNDR print\" },");
                 $self->pidl("{ NULL, NULL, 0, NULL }");
@@ -322 +374 @@
         }
 
-        $self->pidl_hdr("staticforward PyTypeObject $name\_Type;\n");
+        $self->pidl_hdr("static PyTypeObject $name\_Type;\n");
         $self->pidl("");
         my $docstring = $self->DocString($d, $name);
@@ -336 +388 @@
         $self->pidl(".tp_methods = $py_methods,");
         $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,");
-        $self->pidl(".tp_basicsize = sizeof(py_talloc_Object),");
         $self->pidl(".tp_new = py_$name\_new,");
         $self->deindent;
@@ -343 +394 @@
         $self->pidl("");
 
-        my $talloc_typename = $self->import_type_variable("talloc", "Object");
-        $self->register_module_prereadycode(["$name\_Type.tp_base = $talloc_typename;", ""]);
+        my $talloc_typename = $self->import_type_variable("talloc", "BaseObject");
+        $self->register_module_prereadycode(["$name\_Type.tp_base = $talloc_typename;",
+                                             "$name\_Type.tp_basicsize = pytalloc_BaseObject_size();",
+                                             ""]);
 
         return "&$typeobject";
@@ -372 +425 @@
                 foreach my $dir (@{$e->{DIRECTION}}) {
                          my $main = get_metadata_var($e);
-                         if ($main) { 
-                                 $metadata_args->{$dir}->{$main} = $e->{NAME}; 
+                         if ($main) {
+                                 $metadata_args->{$dir}->{$main} = $e->{NAME};
                          }
                  }
@@ -399 +452 @@
         foreach my $e (@{$fn->{ELEMENTS}}) {
                 next unless (grep(/out/,@{$e->{DIRECTION}}));
-                next if (($metadata_args->{in}->{$e->{NAME}} and grep(/in/, @{$e->{DIRECTION}})) or 
+                next if (($metadata_args->{in}->{$e->{NAME}} and grep(/in/, @{$e->{DIRECTION}})) or
                          ($metadata_args->{out}->{$e->{NAME}}) and grep(/out/, @{$e->{DIRECTION}}));
                 $self->pidl("PyObject *py_$e->{NAME};");
@@ -482 +535 @@
         foreach my $e (@{$fn->{ELEMENTS}}) {
                 next unless (grep(/in/,@{$e->{DIRECTION}}));
-                next if (($metadata_args->{in}->{$e->{NAME}} and grep(/in/, @{$e->{DIRECTION}})) or 
+                next if (($metadata_args->{in}->{$e->{NAME}} and grep(/in/, @{$e->{DIRECTION}})) or
                                  ($metadata_args->{out}->{$e->{NAME}}) and grep(/out/, @{$e->{DIRECTION}}));
                 $self->pidl("PyObject *py_$e->{NAME};");
@@ -612 +665 @@
         if ($actual_ctype->{TYPE} eq "UNION" and defined($actual_ctype->{ELEMENTS})) {
                 $self->pidl("PyObject *py_import_$d->{NAME}(TALLOC_CTX *mem_ctx, int level, " .mapTypeName($d) . " *in)");
+                $self->pidl_hdr("PyObject *py_import_$d->{NAME}(TALLOC_CTX *mem_ctx, int level, " .mapTypeName($d) . " *in);\n");
                 $self->pidl("{");
                 $self->indent;
@@ -620 +674 @@
 
                 $self->pidl(mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, int level, PyObject *in)");
+                $self->pidl_hdr(mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, int level, PyObject *in);\n");
                 $self->pidl("{");
                 $self->indent;
@@ -658 +713 @@
 
         if (defined $interface->{PROPERTIES}->{uuid}) {
-                $self->pidl_hdr("staticforward PyTypeObject $interface->{NAME}_InterfaceType;\n");
+                $self->pidl_hdr("static PyTypeObject $interface->{NAME}_InterfaceType;\n");
                 $self->pidl("");
 
@@ -704 +759 @@
                 $self->deindent;
                 $self->pidl("}");
-        
-                $self->pidl("");
-
-                my $signature = 
+
+                $self->pidl("");
+
+                my $signature =
 "\"$interface->{NAME}(binding, lp_ctx=None, credentials=None) -> connection\\n\"
 \"\\n\"
@@ -741 +796 @@
                 $self->register_module_prereadycode(["$if_typename.tp_base = $dcerpc_typename;", ""]);
                 $self->register_module_postreadycode(["if (!PyInterface_AddNdrRpcMethods(&$if_typename, py_ndr_$interface->{NAME}\_methods))", "\treturn;", ""]);
+
+
+                $self->pidl("static PyObject *syntax_$interface->{NAME}_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)");
+                $self->pidl("{");
+                $self->indent;
+                $self->pidl("return py_dcerpc_syntax_init_helper(type, args, kwargs, &ndr_table_$interface->{NAME}.syntax_id);");
+                $self->deindent;
+                $self->pidl("}");
+
+                $self->pidl("");
+
+                my $signature = "\"abstract_syntax()\\n\"";
+
+                my $docstring = $self->DocString($interface, $interface->{NAME}."_syntax");
+
+                if ($docstring) {
+                        $docstring = "$signature$docstring";
+                } else {
+                        $docstring = $signature;
+                }
+
+                my $syntax_typename = "$interface->{NAME}_SyntaxType";
+
+                $self->pidl("static PyTypeObject $syntax_typename = {");
+                $self->indent;
+                $self->pidl("PyObject_HEAD_INIT(NULL) 0,");
+                $self->pidl(".tp_name = \"$basename.$interface->{NAME}\",");
+                $self->pidl(".tp_doc = $docstring,");
+                $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,");
+                $self->pidl(".tp_new = syntax_$interface->{NAME}_new,");
+                $self->deindent;
+                $self->pidl("};");
+
+                $self->pidl("");
+
+                $self->register_module_typeobject("abstract_syntax", "&$syntax_typename");
+                my $ndr_typename = $self->import_type_variable("samba.dcerpc.misc", "ndr_syntax_id");
+                $self->register_module_prereadycode(["$syntax_typename.tp_base = $ndr_typename;",
+                                                     "$syntax_typename.tp_basicsize = pytalloc_BaseObject_size();",
+                                                     ""]);
         }
 
@@ -778 +873 @@
         $var_name = "dep_$var_name";
 
-        $self->{module_imports}->{$var_name} = $module_path;
-
+        unless (defined $self->{module_imports_uniq}->{$var_name}) {
+                my $h = { "key" => $var_name, "val" => $module_path};
+                push @{$self->{module_imports}}, $h;
+                $self->{module_imports_uniq}->{$var_name} = $h;
+        }
         return $var_name;
 }
@@ -788 +886 @@
 
         $self->register_module_import($module);
-        unless (defined($self->{type_imports}->{$name})) {
-                $self->{type_imports}->{$name} = $module;
+        unless (defined $self->{type_imports_uniq}->{$name}) {
+                my $h = { "key" => $name, "val" => $module};
+                push @{$self->{type_imports}}, $h;
+                $self->{type_imports_uniq}->{$name} = $h;
         }
         return "$name\_Type";
@@ -797 +897 @@
 {
         my ($self, $orig_ctype) = @_;
-        # FIXME: Have a global lookup table for types that look different on the 
+        # FIXME: Have a global lookup table for types that look different on the
         # wire than they are named in C?
-        if ($orig_ctype->{NAME} eq "dom_sid2" or $orig_ctype->{NAME} eq "dom_sid28") {
+        if ($orig_ctype->{NAME} eq "dom_sid2" or
+            $orig_ctype->{NAME} eq "dom_sid28" or
+            $orig_ctype->{NAME} eq "dom_sid0") {
                 $orig_ctype->{NAME} = "dom_sid";
         }
+        if ($orig_ctype->{NAME} eq "spoolss_security_descriptor") {
+                $orig_ctype->{NAME} = "security_descriptor";
+        }
+
         my $ctype = resolveType($orig_ctype);
         unless (defined($ctype->{BASEFILE})) {
@@ -868 +974 @@
         }
 
-        if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP") {
+        # We need to cover ENUMs, BITMAPS and SCALAR values here, as
+        # all could otherwise be assigned invalid integer values
+        my $ctype_alias = "";
+        my $uint_max = "";
+        if ($actual_ctype->{TYPE} eq "ENUM") {
+                # Importantly, ENUM values are unsigned in pidl, and
+                # typically map to uint32
+                $ctype_alias = enum_type_fn($actual_ctype);
+        } elsif ($actual_ctype->{TYPE} eq "BITMAP") {
+                $ctype_alias = bitmap_type_fn($actual_ctype);
+        } elsif ($actual_ctype->{TYPE} eq "SCALAR") {
+                $ctype_alias = expandAlias($actual_ctype->{NAME});
+        }
+
+        # This is the unsigned Python Integer -> C integer validation
+        # case.  The signed case is below.
+        if ($ctype_alias  =~ /^(uint[0-9]*|hyper|udlong|udlongr
+                                |NTTIME_hyper|NTTIME|NTTIME_1sec
+                                |uid_t|gid_t)$/x) {
+                $self->pidl("{");
+                $self->indent;
+                $self->pidl("const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof($target));");
                 $self->pidl("if (PyLong_Check($cvar)) {");
                 $self->indent;
-                $self->pidl("$target = PyLong_AsLongLong($cvar);");
+                $self->pidl("unsigned long long test_var;");
+                $self->pidl("test_var = PyLong_AsUnsignedLongLong($cvar);");
+                $self->pidl("if (PyErr_Occurred() != NULL) {");
+                $self->indent;
+                $self->pidl($fail);
+                $self->deindent;
+                $self->pidl("}");
+                $self->pidl("if (test_var > uint_max) {");
+                $self->indent;
+                $self->pidl("PyErr_Format(PyExc_OverflowError, \"Expected type %s or %s within range 0 - %llu, got %llu\",\\");
+                $self->pidl("  PyInt_Type.tp_name, PyLong_Type.tp_name, uint_max, test_var);");
+                $self->pidl($fail);
+                $self->deindent;
+                $self->pidl("}");
+                $self->pidl("$target = test_var;");
                 $self->deindent;
                 $self->pidl("} else if (PyInt_Check($cvar)) {");
                 $self->indent;
-                $self->pidl("$target = PyInt_AsLong($cvar);");
+                $self->pidl("long test_var;");
+                $self->pidl("test_var = PyInt_AsLong($cvar);");
+                $self->pidl("if (test_var < 0 || test_var > uint_max) {");
+                $self->indent;
+                $self->pidl("PyErr_Format(PyExc_OverflowError, \"Expected type %s or %s within range 0 - %llu, got %ld\",\\");
+                $self->pidl("  PyInt_Type.tp_name, PyLong_Type.tp_name, uint_max, test_var);");
+                $self->pidl($fail);
+                $self->deindent;
+                $self->pidl("}");
+                $self->pidl("$target = test_var;");
                 $self->deindent;
                 $self->pidl("} else {");
@@ -884 +1034 @@
                 $self->deindent;
                 $self->pidl("}");
+                $self->deindent;
+                $self->pidl("}");
                 return;
         }
-        if ($actual_ctype->{TYPE} eq "SCALAR" ) {
-                if (expandAlias($actual_ctype->{NAME}) =~ /^(u?int64|hyper|dlong|udlong|udlongr|NTTIME_hyper|NTTIME|NTTIME_1sec)$/) {
-                        $self->pidl("if (PyLong_Check($cvar)) {");
-                        $self->indent;
-                        $self->pidl("$target = PyLong_AsLongLong($cvar);");
-                        $self->deindent;
-                        $self->pidl("} else if (PyInt_Check($cvar)) {");
-                        $self->indent;
-                        $self->pidl("$target = PyInt_AsLong($cvar);");
-                        $self->deindent;
-                        $self->pidl("} else {");
-                        $self->indent;
-                        $self->pidl("PyErr_Format(PyExc_TypeError, \"Expected type %s or %s\",\\");
-                        $self->pidl("  PyInt_Type.tp_name, PyLong_Type.tp_name);");
-                        $self->pidl($fail);
-                        $self->deindent;
-                        $self->pidl("}");
-                        return;
-                }
-                if (expandAlias($actual_ctype->{NAME}) =~ /^(char|u?int[0-9]*|time_t|uid_t|gid_t)$/) {
-                        $self->pidl("PY_CHECK_TYPE(&PyInt_Type, $cvar, $fail);");
-                        $self->pidl("$target = PyInt_AsLong($cvar);");
-                        return;
-                }
+
+        # Confirm the signed python integer fits in the C type
+        # correctly.  It is subtly different from the unsigned case
+        # above, so while it looks like a duplicate, it is not
+        # actually a duplicate.
+        if ($ctype_alias  =~ /^(dlong|char|int[0-9]*|time_t)$/x) {
+                $self->pidl("{");
+                $self->indent;
+                $self->pidl("const long long int_max = ndr_sizeof2intmax(sizeof($target));");
+                $self->pidl("const long long int_min = -int_max - 1;");
+                $self->pidl("if (PyLong_Check($cvar)) {");
+                $self->indent;
+                $self->pidl("long long test_var;");
+                $self->pidl("test_var = PyLong_AsLongLong($cvar);");
+                $self->pidl("if (PyErr_Occurred() != NULL) {");
+                $self->indent;
+                $self->pidl($fail);
+                $self->deindent;
+                $self->pidl("}");
+                $self->pidl("if (test_var < int_min || test_var > int_max) {");
+                $self->indent;
+                $self->pidl("PyErr_Format(PyExc_OverflowError, \"Expected type %s or %s within range %lld - %lld, got %lld\",\\");
+                $self->pidl("  PyInt_Type.tp_name, PyLong_Type.tp_name, int_min, int_max, test_var);");
+                $self->pidl($fail);
+                $self->deindent;
+                $self->pidl("}");
+                $self->pidl("$target = test_var;");
+                $self->deindent;
+                $self->pidl("} else if (PyInt_Check($cvar)) {");
+                $self->indent;
+                $self->pidl("long test_var;");
+                $self->pidl("test_var = PyInt_AsLong($cvar);");
+                $self->pidl("if (test_var < int_min || test_var > int_max) {");
+                $self->indent;
+                $self->pidl("PyErr_Format(PyExc_OverflowError, \"Expected type %s or %s within range %lld - %lld, got %ld\",\\");
+                $self->pidl("  PyInt_Type.tp_name, PyLong_Type.tp_name, int_min, int_max, test_var);");
+                $self->pidl($fail);
+                $self->deindent;
+                $self->pidl("}");
+                $self->pidl("$target = test_var;");
+                $self->deindent;
+                $self->pidl("} else {");
+                $self->indent;
+                $self->pidl("PyErr_Format(PyExc_TypeError, \"Expected type %s or %s\",\\");
+                $self->pidl("  PyInt_Type.tp_name, PyLong_Type.tp_name);");
+                $self->pidl($fail);
+                $self->deindent;
+                $self->pidl("}");
+                $self->deindent;
+                $self->pidl("}");
+                return;
         }
 
@@ -920 +1099 @@
                 }
                 $self->pidl("PY_CHECK_TYPE($ctype_name, $cvar, $fail);");
-                $self->pidl("if (talloc_reference($mem_ctx, py_talloc_get_mem_ctx($cvar)) == NULL) {");
+                $self->pidl("if (talloc_reference($mem_ctx, pytalloc_get_mem_ctx($cvar)) == NULL) {");
                 $self->indent;
                 $self->pidl("PyErr_NoMemory();");
@@ -926 +1105 @@
                 $self->deindent;
                 $self->pidl("}");
-                $self->assign($target, "(".mapTypeName($ctype)." *)py_talloc_get_ptr($cvar)");
+                $self->assign($target, "(".mapTypeName($ctype)." *)pytalloc_get_ptr($cvar)");
                 return;
         }
@@ -935 +1114 @@
         }
 
-        if ($actual_ctype->{TYPE} eq "SCALAR" and 
+        if ($actual_ctype->{TYPE} eq "SCALAR" and
                 ($actual_ctype->{NAME} eq "string" or $actual_ctype->{NAME} eq "nbt_string" or $actual_ctype->{NAME} eq "nbt_name" or $actual_ctype->{NAME} eq "wrepl_nbt_name")) {
                 $self->pidl("$target = talloc_strdup($mem_ctx, PyString_AS_STRING($cvar));");
@@ -973 +1152 @@
         if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "WERROR") {
                 $self->pidl("$target = W_ERROR(PyInt_AsLong($cvar));");
+                return;
+        }
+
+        if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "HRESULT") {
+                $self->pidl("$target = HRES_ERROR(PyInt_AsLong($cvar));");
                 return;
         }
@@ -1060 +1244 @@
                                 $self->pidl("if (!$var_name) { $fail; }");
                                 $self->pidl("talloc_set_name_const($var_name, \"ARRAY: $var_name\");");
+                        } else {
+                                $self->pidl("if (ARRAY_SIZE($var_name) != PyList_GET_SIZE($py_var)) {");
+                                $self->indent;
+                                $self->pidl("PyErr_Format(PyExc_TypeError, \"Expected list of type %s, length %zu, got %zd\", Py_TYPE($py_var)->tp_name, ARRAY_SIZE($var_name),  PyList_GET_SIZE($py_var));");
+                                $self->pidl("$fail");
+                                $self->deindent;
+                                $self->pidl("}");
                         }
                         $self->pidl("for ($counter = 0; $counter < PyList_GET_SIZE($py_var); $counter++) {");
@@ -1109 +1300 @@
         $ctypename = expandAlias($ctypename);
 
-        if ($ctypename =~ /^(u?int64|hyper|dlong|udlong|udlongr|NTTIME_hyper|NTTIME|NTTIME_1sec)$/) {
-                return "PyLong_FromLongLong($cvar)";
-        }
-
-        if ($ctypename =~ /^(char|u?int[0-9]*|time_t|uid_t|gid_t)$/) {
+        if ($ctypename =~ /^(int64|dlong)$/) {
+                return "ndr_PyLong_FromLongLong($cvar)";
+        }
+
+        if ($ctypename =~ /^(uint64|hyper|NTTIME_hyper|NTTIME|NTTIME_1sec|udlong|udlongr|uid_t|gid_t)$/) {
+                return "ndr_PyLong_FromUnsignedLongLong($cvar)";
+        }
+
+        if ($ctypename =~ /^(char|int|int8|int16|int32|time_t)$/) {
                 return "PyInt_FromLong($cvar)";
+        }
+
+        # Needed to ensure unsigned values in a 32 or 16 bit enum is
+        # cast correctly to a uint32_t, not sign extended to a a
+        # possibly 64 bit unsigned long.  (enums are signed in C,
+        # unsigned in NDR)
+        if ($ctypename =~ /^(uint32|uint3264)$/) {
+                return "ndr_PyLong_FromUnsignedLongLong((uint32_t)$cvar)";
+        }
+
+        if ($ctypename =~ /^(uint|uint8|uint16|uint1632)$/) {
+                return "PyInt_FromLong((uint16_t)$cvar)";
         }
 
@@ -1129 +1336 @@
         }
 
+        if ($ctypename eq "HRESULT") {
+                return "PyErr_FromHRESULT($cvar)";
+        }
+
         if (($ctypename eq "string" or $ctypename eq "nbt_string" or $ctypename eq "nbt_name" or $ctypename eq "wrepl_nbt_name")) {
                 return "PyString_FromStringOrNULL($cvar)";
@@ -1138 +1349 @@
 
         # Not yet supported
-        if ($ctypename eq "string_array") { return "PyCObject_FromTallocPtr($cvar)"; }
+        if ($ctypename eq "string_array") { return "pytalloc_CObject_FromTallocPtr($cvar)"; }
         if ($ctypename eq "ipv4address") { return "PyString_FromStringOrNULL($cvar)"; }
         if ($ctypename eq "ipv6address") { return "PyString_FromStringOrNULL($cvar)"; }
@@ -1144 +1355 @@
         if ($ctypename eq "dnsp_string") { return "PyString_FromStringOrNULL($cvar)"; }
         if ($ctypename eq "pointer") {
-                return "PyCObject_FromTallocPtr($cvar)";
+                return "pytalloc_CObject_FromTallocPtr($cvar)";
         }
 
@@ -1161 +1372 @@
         if ($actual_ctype->{TYPE} eq "TYPEDEF") {
                 $actual_ctype = $actual_ctype->{DATA};
-        } 
-        
+        }
+
         if ($actual_ctype->{TYPE} eq "ENUM") {
                 return $self->ConvertScalarToPython(Parse::Pidl::Typelist::enum_type_fn($actual_ctype), $cvar);
@@ -1177 +1388 @@
                         return "NULL"; # FIXME!
                 }
-                return "py_talloc_reference_ex($ctype_name, $mem_ctx, $cvar)";
+                return "pytalloc_reference_ex($ctype_name, $mem_ctx, $cvar)";
         }
 
@@ -1255 +1466 @@
                         my $counter = "$e->{NAME}_cntr_$l->{LEVEL_INDEX}";
                         $self->pidl("int $counter;");
-                        $self->pidl("for ($counter = 0; $counter < $length; $counter++) {");
+                        $self->pidl("for ($counter = 0; $counter < ($length); $counter++) {");
                         $self->indent;
                         my $member_var = "py_$e->{NAME}_$l->{LEVEL_INDEX}";
@@ -1300 +1511 @@
     $self->pidl_hdr("
 /* Python wrapper functions auto-generated by pidl */
+#define PY_SSIZE_T_CLEAN 1 /* We use Py_ssize_t for PyArg_ParseTupleAndKeywords */
 #include <Python.h>
 #include \"includes.h\"
@@ -1308 +1520 @@
 #include \"$ndr_hdr\"
 
+/*
+ * These functions are here to ensure they can be optomised out by
+ * the compiler based on the constant input values
+ */
+
+static inline unsigned long long ndr_sizeof2uintmax(size_t var_size)
+{
+        switch (var_size) {
+        case 8:
+                return UINT64_MAX;
+        case 4:
+                return UINT32_MAX;
+        case 2:
+                return UINT16_MAX;
+        case 1:
+                return UINT8_MAX;
+        }
+
+        return 0;
+}
+
+static inline long long ndr_sizeof2intmax(size_t var_size)
+{
+        switch (var_size) {
+        case 8:
+                return INT64_MAX;
+        case 4:
+                return INT32_MAX;
+        case 2:
+                return INT16_MAX;
+        case 1:
+                return INT8_MAX;
+        }
+
+        return 0;
+}
+
+static inline PyObject *ndr_PyLong_FromLongLong(long long v)
+{
+        if (v > LONG_MAX || v < LONG_MIN) {
+                return PyLong_FromLongLong(v);
+        } else {
+                return PyInt_FromLong(v);
+        }
+}
+
+static inline PyObject *ndr_PyLong_FromUnsignedLongLong(unsigned long long v)
+{
+        if (v > LONG_MAX) {
+                return PyLong_FromUnsignedLongLong(v);
+        } else {
+                return PyInt_FromLong(v);
+        }
+}
+
 ");
 
@@ -1314 +1581 @@
             ($x->{TYPE} eq "INTERFACE") && $self->Interface($x, $basename);
         }
-        
+
         $self->pidl("static PyMethodDef $basename\_methods[] = {");
         $self->indent;
@@ -1333 +1600 @@
         $self->indent;
         $self->pidl("PyObject *m;");
-        foreach (keys %{$self->{module_imports}}) {
-                $self->pidl("PyObject *$_;");
+        foreach my $h (@{$self->{module_imports}}) {
+                $self->pidl("PyObject *$h->{'key'};");
         }
         $self->pidl("");
 
-        foreach (keys %{$self->{module_imports}}) {
-                my $var_name = $_;
-                my $module_path = $self->{module_imports}->{$var_name};
+        foreach my $h (@{$self->{module_imports}}) {
+                my $var_name = $h->{'key'};
+                my $module_path = $h->{'val'};
                 $self->pidl("$var_name = PyImport_ImportModule(\"$module_path\");");
                 $self->pidl("if ($var_name == NULL)");
@@ -1347 +1614 @@
         }
 
-        foreach (keys %{$self->{type_imports}}) {
-                my $type_var = "$_\_Type";
-                my $module_path = $self->{type_imports}->{$_};
+        foreach my $h (@{$self->{type_imports}}) {
+                my $type_var = "$h->{'key'}\_Type";
+                my $module_path = $h->{'val'};
                 $self->pidl_hdr("static PyTypeObject *$type_var;\n");
-                my $pretty_name = PrettifyTypeName($_, $module_path);
+                my $pretty_name = PrettifyTypeName($h->{'key'}, $module_path);
                 my $module_var = "dep_$module_path";
                 $module_var =~ s/\./_/g;
@@ -1382 +1649 @@
         $self->pidl("\treturn;");
         $self->pidl("");
-        foreach my $name (keys %{$self->{constants}}) {
+        foreach my $h (@{$self->{constants}}) {
+                my $name = $h->{'key'};
                 my $py_obj;
-                my ($ctype, $cvar) = @{$self->{constants}->{$name}};
+                my ($ctype, $cvar) = @{$h->{'val'}};
                 if ($cvar =~ /^[0-9]+$/ or $cvar =~ /^0x[0-9a-fA-F]+$/) {
-                        $py_obj = "PyInt_FromLong($cvar)";
+                        $py_obj = "ndr_PyLong_FromUnsignedLongLong($cvar)";
                 } elsif ($cvar =~ /^".*"$/) {
                         $py_obj = "PyString_FromString($cvar)";

vendor/current/pidl/lib/Parse/Pidl/Samba4/Template.pm

@@ -8 +8 @@
 use vars qw($VERSION);
 $VERSION = '0.01';
+
+use Parse::Pidl::Util qw(genpad);
 
 use strict;
@@ -21 +23 @@
         my $name = $interface->{NAME};
 
-        $res .= 
-"/* 
+        $res .=
+"/*
    Unix SMB/CIFS implementation.
 
@@ -28 +30 @@
 
    Copyright (C) YOUR NAME HERE YEAR
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
@@ -53 +55 @@
                 if ($d->{TYPE} eq "FUNCTION") {
                         my $fname = $d->{NAME};
+                        my $pad = genpad("static $d->{RETURN_TYPE} dcesrv_$fname");
                         $res .=
 "
-/* 
-  $fname 
+/*
+  $fname
 */
-static $d->{RETURN_TYPE} dcesrv_$fname(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
-                       struct $fname *r)
+
+static $d->{RETURN_TYPE} dcesrv_$fname(struct dcesrv_call_state *dce_call,
+$pad"."TALLOC_CTX *mem_ctx,
+$pad"."struct $fname *r)
 {
 ";
@@ -75 +80 @@
         }
 
-        $res .= 
+        $res .=
 "
 /* include the generated boilerplate */
@@ -90 +95 @@
         $res = "";
         foreach my $x (@{$idl}) {
-                ($x->{TYPE} eq "INTERFACE") && 
+                ($x->{TYPE} eq "INTERFACE") &&
                     Template($x);
         }

vendor/current/pidl/lib/Parse/Pidl/Typelist.pm

@@ -61 +61 @@
         "NTTIME_hyper"  => "NTTIME",
         "WERROR"        => "WERROR",
+        "HRESULT"       => "HRESULT",
         "NTSTATUS"      => "NTSTATUS",
         "COMRESULT" => "COMRESULT",
@@ -84 +85 @@
         "short" => "int16",
         "HYPER_T" => "hyper",
-        "HRESULT" => "COMRESULT",
+        "mode_t"        => "uint32",
 );
 

vendor/current/pidl/lib/Parse/Pidl/Util.pm

@@ -7 +7 @@
 require Exporter;
 @ISA = qw(Exporter);
-@EXPORT = qw(has_property property_matches ParseExpr ParseExprExt is_constant make_str unmake_str print_uuid MyDumper);
+@EXPORT = qw(has_property property_matches ParseExpr ParseExprExt is_constant make_str unmake_str print_uuid MyDumper genpad);
 use vars qw($VERSION);
 $VERSION = '0.01';
@@ -44 +44 @@
 {
         require Data::Dumper;
+        $Data::Dumper::Sortkeys = 1;
         my $s = shift;
         return Data::Dumper::Dumper($s);
@@ -176 +177 @@
 }
 
+=item B<genpad>
+return an empty string consisting of tabs and spaces suitable for proper indent
+of C-functions.
+
+=cut
+sub genpad($)
+{
+        my ($s) = @_;
+        my $nt = int((length($s)+1)/8);
+        my $lt = ($nt*8)-1;
+        my $ns = (length($s)-$lt);
+        return "\t"x($nt)." "x($ns);
+}
+
 =back
 

vendor/current/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm

@@ -22 +22 @@
 Conformance files are simple text files with a single command on each line.
 Empty lines and lines starting with a '#' character are ignored.
-Arguments to commands are seperated by spaces.
+Arguments to commands are separated by spaces.
 
 The following commands are currently supported:
@@ -60 +60 @@
 
 Remove the specified prefix from all function names (if present).
-        
+
 =item I<PROTOCOL> longname shortname filtername
 
@@ -270 +270 @@
 
         if (defined($type)) {
-            $data->{noemit}->{$type} = 1;
+                $data->{noemit}->{$type} = 1;
         } else {
-            $data->{noemit_dissector} = 1;
+                $data->{noemit_dissector} = 1;
         }
 }
@@ -285 +285 @@
         }
 
-    $data->{manual}->{$fn} = 1;
+        $data->{manual}->{$fn} = 1;
 }
 
@@ -364 +364 @@
 my %field_handlers = (
         TYPE => \&handle_type,
-        NOEMIT => \&handle_noemit, 
+        NOEMIT => \&handle_noemit,
         MANUAL => \&handle_manual,
-        PARAM_VALUE => \&handle_param_value, 
-        HF_FIELD => \&handle_hf_field, 
-        HF_RENAME => \&handle_hf_rename, 
+        PARAM_VALUE => \&handle_param_value,
+        HF_FIELD => \&handle_hf_field,
+        HF_RENAME => \&handle_hf_rename,
         ETT_FIELD => \&handle_ett_field,
         TFS => \&handle_tfs,

vendor/current/pidl/lib/Parse/Pidl/Wireshark/NDR.pm

@@ -28 +28 @@
 use Parse::Pidl::Dump qw(DumpType DumpFunction);
 use Parse::Pidl::Wireshark::Conformance qw(ReadConformance);
-use File::Basename;     
+use File::Basename;
 
 use vars qw($VERSION);
@@ -58 +58 @@
 sub field2name($)
 {
-    my($field) = shift;
-
-    $field =~ s/_/ /g;          # Replace underscores with spaces
-    $field =~ s/(\w+)/\u\L$1/g; # Capitalise each word
-    
-    return $field;
+        my($field) = shift;
+
+        $field =~ s/_/ /g;              # Replace underscores with spaces
+        $field =~ s/(\w+)/\u\L$1/g;     # Capitalise each word
+
+        return $field;
 }
 
@@ -92 +92 @@
         my ($self, $d) = @_;
         return if (defined($self->{cur_fn}) and defined($self->{conformance}->{manual}->{$self->{cur_fn}}));
- 
+
         if ($d) {
                 $self->{res}->{code} .= $self->{tabs};
@@ -144 +144 @@
         return if (defined($self->{conformance}->{noemit}->{StripPrefixes($name, $self->{conformance}->{strip_prefixes})}));
 
-        foreach (@{$e->{ELEMENTS}}) {
+        foreach (@{$e->{ELEMENTS}}) {
                 if (/([^=]*)=(.*)/) {
                         $self->pidl_hdr("#define $1 ($2)");
                 }
         }
-        
+
         $self->pidl_hdr("extern const value_string $valsstring\[];");
-        $self->pidl_hdr("int $dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 *param _U_);");
+        $self->pidl_hdr("int $dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_, int hf_index _U_, g$e->{BASE_TYPE} *param _U_);");
 
         $self->pidl_def("const value_string ".$valsstring."[] = {");
-        foreach (@{$e->{ELEMENTS}}) {
+        foreach (@{$e->{ELEMENTS}}) {
                 next unless (/([^=]*)=(.*)/);
                 $self->pidl_def("\t{ $1, \"$1\" },");
@@ -164 +164 @@
         $self->pidl_fn_start($dissectorname);
         $self->pidl_code("int");
-        $self->pidl_code("$dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 *param _U_)");
+        $self->pidl_code("$dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_, int hf_index _U_, g$e->{BASE_TYPE} *param _U_)");
         $self->pidl_code("{");
         $self->indent;
         $self->pidl_code("g$e->{BASE_TYPE} parameter=0;");
-        $self->pidl_code("if(param){");
+        $self->pidl_code("if (param) {");
         $self->indent;
-        $self->pidl_code("parameter=(g$e->{BASE_TYPE})*param;");
+        $self->pidl_code("parameter = *param;");
         $self->deindent;
         $self->pidl_code("}");
         $self->pidl_code("offset = dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, &parameter);");
-        $self->pidl_code("if(param){");
+        $self->pidl_code("if (param) {");
         $self->indent;
-        $self->pidl_code("*param=(guint32)parameter;");
+        $self->pidl_code("*param = parameter;");
         $self->deindent;
         $self->pidl_code("}");
@@ -187 +187 @@
         $enum_size =~ s/uint//g;
         $self->register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_UINT$enum_size", "BASE_DEC", "0", "VALS($valsstring)", $enum_size / 8);
+}
+
+sub Pipe($$$$)
+{
+        my ($self,$e,$name,$ifname) = @_;
+        error($e->{ORIGINAL}, "Pipe not yet supported");
+        return;
 }
 
@@ -206 +213 @@
         $self->pidl_code("proto_tree *tree = NULL;");
         $self->pidl_code("");
-                
+
         $self->pidl_code("g$e->{BASE_TYPE} flags;");
         if ($e->{ALIGN} > 1) {
@@ -216 +223 @@
         $self->pidl_code("if (parent_tree) {");
         $self->indent;
-        $self->pidl_code("item = proto_tree_add_item(parent_tree, hf_index, tvb, offset, $e->{ALIGN}, TRUE);");
+        $self->pidl_code("item = proto_tree_add_item(parent_tree, hf_index, tvb, offset, $e->{ALIGN}, DREP_ENC_INTEGER(drep));");
         $self->pidl_code("tree = proto_item_add_subtree(item,ett_$ifname\_$name);");
         $self->deindent;
@@ -234 +241 @@
 
                 $self->{hf_used}->{$hf_bitname} = 1;
-                
+
                 $self->register_hf_field($hf_bitname, field2name($en), $filtername, "FT_BOOLEAN", $e->{ALIGN} * 8, "TFS(&$name\_$en\_tfs)", $ev, "");
 
@@ -247 +254 @@
                 }
                 $self->pidl_def("};");
-                
+
                 $self->pidl_code("proto_tree_add_boolean(tree, $hf_bitname, tvb, offset-$e->{ALIGN}, $e->{ALIGN}, flags);");
                 $self->pidl_code("if (flags&$ev){");
@@ -271 +278 @@
 }
 
-sub ElementLevel($$$$$$$)
-{
-        my ($self,$e,$l,$hf,$myname,$pn,$ifname) = @_;
-
-        my $param = 0;
+sub ElementLevel($$$$$$$$)
+{
+        my ($self,$e,$l,$hf,$myname,$pn,$ifname,$param) = @_;
 
         if (defined($self->{conformance}->{dissectorparams}->{$myname})) {
@@ -317 +322 @@
 
                         ($bs = 1) if (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_ASCII.*"));
-                        
+
                         if (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_SIZE4.*") and property_matches($e, "flag", ".*LIBNDR_FLAG_STR_LEN4.*")) {
                                 $self->pidl_code("char *data;\n");
@@ -324 +329 @@
                         } elsif (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_SIZE4.*")) {
                                 $self->pidl_code("offset = dissect_ndr_vstring(tvb, offset, pinfo, tree, drep, $bs, $hf, FALSE, NULL);");
+                        } elsif (property_matches($e, "flag", ".*STR_NULLTERM.*")) {
+                                if ($bs == 2) {
+                                        $self->pidl_code("offset = dissect_null_term_wstring(tvb, offset, pinfo, tree, drep, $hf , 0);")
+                                } else {
+                                        $self->pidl_code("offset = dissect_null_term_string(tvb, offset, pinfo, tree, drep, $hf , 0);")
+                                }
                         } else {
                                 warn("Unable to handle string with flags $e->{PROPERTIES}->{flag}");
                         }
+                } elsif ($l->{DATA_TYPE} eq "DATA_BLOB") {
+                        my $remain = 0;
+                        $remain = 1 if (property_matches($e->{ORIGINAL}, "flag", ".*LIBNDR_FLAG_REMAINING.*"));
+                        $self->pidl_code("offset = dissect_ndr_datablob(tvb, offset, pinfo, tree, drep, $hf, $remain);");
                 } else {
                         my $call;
 
                         if ($self->{conformance}->{imports}->{$l->{DATA_TYPE}}) {
-                                $call = $self->{conformance}->{imports}->{$l->{DATA_TYPE}}->{DATA};     
+                                $call = $self->{conformance}->{imports}->{$l->{DATA_TYPE}}->{DATA};
                                 $self->{conformance}->{imports}->{$l->{DATA_TYPE}}->{USED} = 1;
-                        } elsif (defined($self->{conformance}->{imports}->{"$pn.$e->{NAME}"})) {
-                                $call = $self->{conformance}->{imports}->{"$pn.$e->{NAME}"}->{DATA};
+
+                        } elsif (defined($self->{conformance}->{imports}->{"$pn.$e->{NAME}"})) {
+                                $call = $self->{conformance}->{imports}->{"$pn.$e->{NAME}"}->{DATA};
                                 $self->{conformance}->{imports}->{"$pn.$e->{NAME}"}->{USED} = 1;
-                            
+
                         } elsif (defined($self->{conformance}->{types}->{$l->{DATA_TYPE}})) {
                                 $call= $self->{conformance}->{types}->{$l->{DATA_TYPE}}->{DISSECTOR_NAME};
                                 $self->{conformance}->{types}->{$l->{DATA_TYPE}}->{USED} = 1;
                         } else {
-                                $self->pidl_code("offset = $ifname\_dissect_struct_" . $l->{DATA_TYPE} . "(tvb,offset,pinfo,tree,drep,$hf,$param);");
+                                my $t;
+                                if (ref($l->{DATA_TYPE}) eq "HASH" ) {
+                                        $t = "$l->{DATA_TYPE}->{TYPE}_$l->{DATA_TYPE}->{NAME}";
+                                } else {
+                                        $t = $l->{DATA_TYPE};
+                                }
+
+                                $self->pidl_code("offset = $ifname\_dissect_struct_" . $t . "(tvb,offset,pinfo,tree,drep,$hf,$param);");
 
                                 return;
@@ -351 +374 @@
                 }
         } elsif ($_->{TYPE} eq "SUBCONTEXT") {
+                my $varswitch;
+                if (has_property($e, "switch_is")) {
+                        $varswitch = $e->{PROPERTIES}->{switch_is};
+                }
                 my $num_bits = ($l->{HEADER_SIZE}*8);
+                my $hf2 = $self->register_hf_field($hf."_", "Subcontext length", "$ifname.$pn.$_->{NAME}subcontext", "FT_UINT$num_bits", "BASE_HEX", "NULL", 0, "");
+                $num_bits = 3264 if ($num_bits == 32);
+                $self->{hf_used}->{$hf2} = 1;
+                $self->pidl_code("dcerpc_info *di = (dcerpc_info*)pinfo->private_data;");
                 $self->pidl_code("guint$num_bits size;");
-                $self->pidl_code("int start_offset = offset;");
+                $self->pidl_code("int conformant = di->conformant_run;");
                 $self->pidl_code("tvbuff_t *subtvb;");
-                $self->pidl_code("offset = dissect_ndr_uint$num_bits(tvb, offset, pinfo, tree, drep, $hf, &size);");
-                $self->pidl_code("proto_tree_add_text(tree, tvb, start_offset, offset - start_offset + size, \"Subcontext size\");");
+                $self->pidl_code("");
+                # We need to be able to dissect the length of the context in every case
+                # and conformant run skips the dissections of scalars ...
+                $self->pidl_code("if (!conformant) {");
+                $self->indent;
+                $self->pidl_code("guint32 saved_flags = di->call_data->flags;");
+                $self->pidl_code("offset = dissect_ndr_uint$num_bits(tvb, offset, pinfo, tree, drep, $hf2, &size);");
+                # This is a subcontext, there is normally no such thing as
+                # 64 bit NDR is subcontext so we clear the flag so that we can
+                # continue to dissect handmarshalled stuff with pidl
+                $self->pidl_code("di->call_data->flags &= ~DCERPC_IS_NDR64;");
 
                 $self->pidl_code("subtvb = tvb_new_subset(tvb, offset, size, -1);");
-                $self->pidl_code("$myname\_(subtvb, 0, pinfo, tree, drep);");
+                if ($param ne 0) {
+                        $self->pidl_code("$myname\_(subtvb, 0, pinfo, tree, drep, $param);");
+                } else {
+                        $self->pidl_code("$myname\_(subtvb, 0, pinfo, tree, drep);");
+                }
+                $self->pidl_code("offset += size;");
+                $self->pidl_code("di->call_data->flags = saved_flags;");
+                $self->deindent;
+                $self->pidl_code("}");
+        } elsif ($_->{TYPE} eq "PIPE") {
+                error($e->{ORIGINAL}, "Type PIPE not yet supported");
         } else {
                 die("Unknown type `$_->{TYPE}'");
@@ -365 +415 @@
 }
 
-sub Element($$$)
-{
-        my ($self,$e,$pn,$ifname) = @_;
+sub SwitchType($$;$)
+{
+        my ($e, $type, $nodiscriminant) = @_;
+
+        my $switch_dt =  getType($type);
+        my $switch_type = undef;
+        if ($switch_dt->{DATA}->{TYPE} eq "ENUM") {
+                $switch_type = Parse::Pidl::Typelist::enum_type_fn($switch_dt->{DATA});
+        } elsif ($switch_dt->{DATA}->{TYPE} eq "BITMAP") {
+                $switch_type = Parse::Pidl::Typelist::bitmap_type_fn($switch_dt->{DATA});
+        } elsif ($switch_dt->{DATA}->{TYPE} eq "SCALAR") {
+                if (defined $e->{SWITCH_TYPE}) {
+                        $switch_type = "$e->{SWITCH_TYPE}";
+                } else {
+                        $switch_type = "$switch_dt->{DATA}->{NAME}";
+                }
+        } elsif (not defined $e->{SWITCH_TYPE}) {
+                $switch_type = $nodiscriminant;
+        }
+
+        return $switch_type
+}
+
+sub Element($$$$$)
+{
+        my ($self,$e,$pn,$ifname,$isoruseswitch) = @_;
 
         my $dissectorname = "$ifname\_dissect\_element\_".StripPrefixes($pn, $self->{conformance}->{strip_prefixes})."\_".StripPrefixes($e->{NAME}, $self->{conformance}->{strip_prefixes});
 
-        my $call_code = "offset = $dissectorname(tvb, offset, pinfo, tree, drep);";
+        my ($call_code, $moreparam);
+        my $param = 0;
+        if (defined $isoruseswitch) {
+                my $type = $isoruseswitch->[0];
+                my $name = $isoruseswitch->[1];
+
+                my $switch_raw_type = SwitchType($e, $type, "uint32");
+                if (not defined($switch_raw_type)) {
+                        die("Unknown type[$type]\n");
+                }
+                my $switch_type = "g${switch_raw_type}";
+
+                $moreparam = ", $switch_type *".$name;
+                $param = $name;
+                $call_code = "offset = $dissectorname(tvb, offset, pinfo, tree, drep, &$name);";
+        } else {
+                $moreparam = "";
+                $call_code = "offset = $dissectorname(tvb, offset, pinfo, tree, drep);";
+        }
+
 
         my $type = $self->find_type($e->{TYPE});
@@ -393 +485 @@
                 };
         }
+        if (property_matches($e, "flag", ".*LIBNDR_FLAG_ALIGN.*")) {
+                my $align_flag = $e->{PROPERTIES}->{flag};
+                if ($align_flag =~ m/LIBNDR_FLAG_ALIGN(\d+)/) {
+                        $call_code = "ALIGN_TO_$1_BYTES; ".$call_code;
+                }
+        }
 
         my $hf = $self->register_hf_field("hf_$ifname\_$pn\_$e->{NAME}", field2name($e->{NAME}), "$ifname.$pn.$e->{NAME}", $type->{FT_TYPE}, $type->{BASE_TYPE}, $type->{VALSSTRING}, $type->{MASK}, "");
@@ -404 +502 @@
         my $add = "";
 
+        my $oldparam = undef;
         foreach (@{$e->{LEVELS}}) {
+                if (defined $_->{SWITCH_IS}) {
+                        $oldparam = $param;
+                        $param = "*$param";
+                }
                 next if ($_->{TYPE} eq "SWITCH");
-                $self->pidl_def("static int $dissectorname$add(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_);");
+                $self->pidl_def("static int $dissectorname$add(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_$moreparam);");
                 $self->pidl_fn_start("$dissectorname$add");
                 $self->pidl_code("static int");
-                $self->pidl_code("$dissectorname$add(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)");
+                $self->pidl_code("$dissectorname$add(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_$moreparam)");
                 $self->pidl_code("{");
                 $self->indent;
 
-                $self->ElementLevel($e,$_,$hf,$dissectorname.$add,$pn,$ifname);
+                $self->ElementLevel($e,$_,$hf,$dissectorname.$add,$pn,$ifname,$param);
+                if (defined $oldparam) {
+                        $param = $oldparam;
+                }
 
                 $self->pidl_code("");
@@ -434 +540 @@
 
         foreach (@{$fn->{ELEMENTS}}) {
-            $dissectornames{$_->{NAME}} = $self->Element($_, $fn->{NAME}, $ifname) if not defined($dissectornames{$_->{NAME}});
-        }
-        
+            $dissectornames{$_->{NAME}} = $self->Element($_, $fn->{NAME}, $ifname, undef) if not defined($dissectornames{$_->{NAME}});
+        }
+
         my $fn_name = $_->{NAME};
         $fn_name =~ s/^${ifname}_//;
@@ -447 +553 @@
         $self->indent;
         if ( not defined($fn->{RETURN_TYPE})) {
-        } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS" or $fn->{RETURN_TYPE} eq "WERROR") 
+        } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS" or $fn->{RETURN_TYPE} eq "WERROR")
         {
                 $self->pidl_code("guint32 status;\n");
@@ -456 +562 @@
                         $self->pidl_code("g$fn->{RETURN_TYPE} status;\n");
                 } else {
-                error($fn, "return type `$fn->{RETURN_TYPE}' not yet supported");
+                        error($fn, "return type `$fn->{RETURN_TYPE}' not yet supported");
                 }
         } else {
@@ -474 +580 @@
         } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") {
                 $self->pidl_code("offset = dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf\_$ifname\_status, &status);\n");
-                $self->pidl_code("if (status != 0 && check_col(pinfo->cinfo, COL_INFO))");
+                $self->pidl_code("if (status != 0)");
                 $self->pidl_code("\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Error: %s\", val_to_str(status, NT_errors, \"Unknown NT status 0x%08x\"));\n");
                 $return_types{$ifname}->{"status"} = ["NTSTATUS", "NT Error"];
         } elsif ($fn->{RETURN_TYPE} eq "WERROR") {
                 $self->pidl_code("offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, hf\_$ifname\_werror, &status);\n");
-                $self->pidl_code("if (status != 0 && check_col(pinfo->cinfo, COL_INFO))");
+                $self->pidl_code("if (status != 0)");
                 $self->pidl_code("\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Error: %s\", val_to_str(status, WERR_errors, \"Unknown DOS error 0x%08x\"));\n");
-                
+
                 $return_types{$ifname}->{"werror"} = ["WERROR", "Windows Error"];
         } elsif (my $type = getType($fn->{RETURN_TYPE})) {
@@ -489 +595 @@
 
                         $self->pidl_code("offset = $return_dissect(tvb, offset, pinfo, tree, drep, hf\_$ifname\_$fn->{RETURN_TYPE}_status, &status);");
-                        $self->pidl_code("if (status != 0 && check_col(pinfo->cinfo, COL_INFO))");
+                        $self->pidl_code("if (status != 0)");
                         $self->pidl_code("\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Status: %s\", val_to_str(status, $ifname\_$fn->{RETURN_TYPE}\_vals, \"Unknown " . $fn->{RETURN_TYPE} . " error 0x%08x\"));\n");
                         $return_types{$ifname}->{$fn->{RETURN_TYPE}."_status"} = [$fn->{RETURN_TYPE}, $fn->{RETURN_TYPE}];
                 } elsif ($type->{DATA}->{TYPE} eq "SCALAR") {
                         $self->pidl_code("offset = dissect_ndr_$fn->{RETURN_TYPE}(tvb, offset, pinfo, tree, drep, hf\_$ifname\_$fn->{RETURN_TYPE}_status, &status);");
-                        $self->pidl_code("if (status != 0 && check_col(pinfo->cinfo, COL_INFO))");
+                        $self->pidl_code("if (status != 0)");
                         $self->pidl_code("\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Status: %d\", status);\n");
                         $return_types{$ifname}->{$fn->{RETURN_TYPE}."_status"} = [$fn->{RETURN_TYPE}, $fn->{RETURN_TYPE}];
@@ -535 +641 @@
 
         my $res = "";
-        ($res.="\t".$self->Element($_, $name, $ifname)."\n\n") foreach (@{$e->{ELEMENTS}});
+        my $varswitchs = {};
+        # will contain the switch var declaration;
+        my $vars = [];
+        foreach (@{$e->{ELEMENTS}}) {
+                if (has_property($_, "switch_is")) {
+                        $varswitchs->{$_->{PROPERTIES}->{switch_is}} = [];
+                }
+        }
+        foreach (@{$e->{ELEMENTS}}) {
+                my $switch_info = undef;
+
+                my $v = $_->{NAME};
+                if (scalar(grep {/^$v$/} keys(%$varswitchs)) == 1) {
+                        # This element is one of the switch attribute
+                        my $switch_raw_type = SwitchType($e, $_->{TYPE}, "uint32");
+                        if (not defined($switch_raw_type)) {
+                                die("Unknown type[$_->{TYPE}]\n");
+                        }
+                        my $switch_type = "g${switch_raw_type}";
+
+                        push @$vars, "$switch_type $v;";
+                        $switch_info = [ $_->{TYPE}, $v ];
+                        $varswitchs->{$v} = $switch_info;
+                }
+
+                if (has_property($_, "switch_is")) {
+                        my $varswitch = $_->{PROPERTIES}->{switch_is};
+                        $switch_info = $varswitchs->{$varswitch};
+                }
+
+                $res.="\t".$self->Element($_, $name, $ifname, $switch_info)."\n\n";
+        }
+
+        my $doalign = undef;
+        if ($e->{ALIGN} > 1 and not property_matches($e, "flag", ".*LIBNDR_FLAG_NOALIGN.*")) {
+                $doalign = 1;
+        } elsif (property_matches($e, "flag", ".*LIBNDR_FLAG_NOALIGN.*")) {
+                $doalign = 0;
+        }
 
         $self->pidl_hdr("int $dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *parent_tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 param _U_);");
@@ -544 +688 @@
         $self->pidl_code("{");
         $self->indent;
+        $self->pidl_code($_) foreach (@$vars);
         $self->pidl_code("proto_item *item = NULL;");
         $self->pidl_code("proto_tree *tree = NULL;");
-        if ($e->{ALIGN} > 1) {
-                $self->pidl_code("dcerpc_info *di = pinfo->private_data;");
+        if (defined($doalign)) {
+                $self->pidl_code("dcerpc_info *di = (dcerpc_info *)pinfo->private_data;");
+                if ($doalign == 0) {
+                        $self->pidl_code("gboolean oldalign = di->no_align;");
+                }
         }
         $self->pidl_code("int old_offset;");
         $self->pidl_code("");
 
-        if ($e->{ALIGN} > 1) {
-                $self->pidl_code("ALIGN_TO_$e->{ALIGN}_BYTES;");
-        }
-        $self->pidl_code("");
+        if (defined($doalign)) {
+                if ($doalign == 1) {
+                        $self->pidl_code("ALIGN_TO_$e->{ALIGN}_BYTES;");
+                }
+                if ($doalign == 0) {
+                        $self->pidl_code("di->no_align = TRUE;");
+                }
+                $self->pidl_code("");
+        }
 
         $self->pidl_code("old_offset = offset;");
@@ -561 +714 @@
         $self->pidl_code("if (parent_tree) {");
         $self->indent;
-        $self->pidl_code("item = proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);");
+        $self->pidl_code("item = proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, ENC_NA);");
         $self->pidl_code("tree = proto_item_add_subtree(item, ett_$ifname\_$name);");
         $self->deindent;
@@ -569 +722 @@
 
         $self->pidl_code("proto_item_set_len(item, offset-old_offset);\n");
-        if ($e->{ALIGN} > 1) {
+        if (defined($doalign) and $doalign == 1) {
                 $self->pidl_code("");
                 $self->pidl_code("if (di->call_data->flags & DCERPC_IS_NDR64) {");
@@ -577 +730 @@
                 $self->pidl_code("}");
         }
+        if (defined($doalign) and $doalign == 0) {
+                $self->pidl_code("");
+                $self->pidl_code("di->no_align = oldalign;");
+        }
         $self->pidl_code("");
         $self->pidl_code("return offset;");
@@ -593 +750 @@
 
         return if (defined($self->{conformance}->{noemit}->{StripPrefixes($name, $self->{conformance}->{strip_prefixes})}));
-        
+
         $self->register_ett("ett_$ifname\_$name");
 
@@ -600 +757 @@
                 $res.="\n\t\t$_->{CASE}:\n";
                 if ($_->{TYPE} ne "EMPTY") {
-                        $res.="\t\t\t".$self->Element($_, $name, $ifname)."\n";
+                        $res.="\t\t\t".$self->Element($_, $name, $ifname, undef)."\n";
                 }
                 $res.="\t\tbreak;\n";
         }
 
-        my $switch_type;
-        my $switch_dissect;
-        my $switch_dt = getType($e->{SWITCH_TYPE});
-        if ($switch_dt->{DATA}->{TYPE} eq "ENUM") {
-                $switch_type = "g".Parse::Pidl::Typelist::enum_type_fn($switch_dt->{DATA});
-                $switch_dissect = "dissect_ndr_" .Parse::Pidl::Typelist::enum_type_fn($switch_dt->{DATA});
-        } elsif ($switch_dt->{DATA}->{TYPE} eq "SCALAR") {
-                $switch_type = "g$e->{SWITCH_TYPE}";
-                $switch_dissect = "dissect_ndr_$e->{SWITCH_TYPE}";
+        my $switch_type = undef;
+        my $switch_dissect = undef;
+        my $switch_raw_type = SwitchType($e, $e->{SWITCH_TYPE});
+        if (defined($switch_raw_type)) {
+                $switch_type = "g${switch_raw_type}";
+                $switch_dissect = "dissect_ndr_${switch_raw_type}";
         }
 
@@ -624 +778 @@
         $self->pidl_code("proto_tree *tree = NULL;");
         $self->pidl_code("int old_offset;");
-        $self->pidl_code("$switch_type level;");
+        if (!defined $switch_type) {
+                $self->pidl_code("guint32 level = param;");
+        } else {
+                $self->pidl_code("$switch_type level;");
+        }
         $self->pidl_code("");
 
@@ -637 +795 @@
         $self->pidl_code("");
 
-        $self->pidl_code("offset = $switch_dissect(tvb, offset, pinfo, tree, drep, hf_index, &level);");
-
-        if ($e->{ALIGN} > 1) {
-                $self->pidl_code("ALIGN_TO_$e->{ALIGN}_BYTES;");
-                $self->pidl_code("");
+        if (defined $switch_type) {
+                $self->pidl_code("offset = $switch_dissect(tvb, offset, pinfo, tree, drep, hf_index, &level);");
+
+                if ($e->{ALIGN} > 1) {
+                        $self->pidl_code("ALIGN_TO_$e->{ALIGN}_BYTES;");
+                        $self->pidl_code("");
+                }
         }
 
@@ -660 +820 @@
 {
         my ($self,$const,$ifname) = @_;
-        
+
         if (!defined($const->{ARRAY_LEN}[0])) {
-                $self->pidl_hdr("#define $const->{NAME}\t( $const->{VALUE} )\n");
-        } else {
-                $self->pidl_hdr("#define $const->{NAME}\t $const->{VALUE}\n");
-        }
+                $self->pidl_hdr("#define $const->{NAME}\t( $const->{VALUE} )\n");
+        } else {
+                $self->pidl_hdr("#define $const->{NAME}\t $const->{VALUE}\n");
+        }
 }
 
@@ -680 +840 @@
 
         $self->PrintIdl(DumpType($e->{ORIGINAL}));
-
         {
                 ENUM => \&Enum,
@@ -686 +845 @@
                 UNION => \&Union,
                 BITMAP => \&Bitmap,
-                TYPEDEF => \&Typedef
+                TYPEDEF => \&Typedef,
+                PIPE    => \&Pipe
         }->{$e->{TYPE}}->($self, $e, $name, $ifname);
 }
@@ -701 +861 @@
         $self->{res}->{code}.=$self->DumpHfList()."\n";
         $self->{res}->{code}.="\n".DumpEttList($self->{ett})."\n";
-        
+
         if (defined($x->{UUID})) {
-            # These can be changed to non-pidl_code names if the old dissectors
-            # in epan/dissctors are deleted.
-    
-            my $name = uc($x->{NAME}) . " (pidl)";
-            my $short_name = uc($x->{NAME});
-            my $filter_name = $x->{NAME};
-
-            if (has_property($x, "helpstring")) {
-                $name = $x->{PROPERTIES}->{helpstring};
-            }
-
-            if (defined($self->{conformance}->{protocols}->{$x->{NAME}})) {
+                # These can be changed to non-pidl_code names if the old
+                # dissectors in epan/dissectors are deleted.
+
+                my $name = uc($x->{NAME}) . " (pidl)";
+                my $short_name = uc($x->{NAME});
+                my $filter_name = $x->{NAME};
+
+                if (has_property($x, "helpstring")) {
+                        $name = $x->{PROPERTIES}->{helpstring};
+                }
+
+                if (defined($self->{conformance}->{protocols}->{$x->{NAME}})) {
                 $short_name = $self->{conformance}->{protocols}->{$x->{NAME}}->{SHORTNAME};
                 $name = $self->{conformance}->{protocols}->{$x->{NAME}}->{LONGNAME};
                 $filter_name = $self->{conformance}->{protocols}->{$x->{NAME}}->{FILTERNAME};
-            }
-
-            $self->pidl_code("proto_dcerpc_$x->{NAME} = proto_register_protocol(".make_str($name).", ".make_str($short_name).", ".make_str($filter_name).");");
-            
-            $self->pidl_code("proto_register_field_array(proto_dcerpc_$x->{NAME}, hf, array_length (hf));");
-            $self->pidl_code("proto_register_subtree_array(ett, array_length(ett));");
+                }
+
+                $self->pidl_code("proto_dcerpc_$x->{NAME} = proto_register_protocol(".make_str($name).", ".make_str($short_name).", ".make_str($filter_name).");");
+
+                $self->pidl_code("proto_register_field_array(proto_dcerpc_$x->{NAME}, hf, array_length (hf));");
+                $self->pidl_code("proto_register_subtree_array(ett, array_length(ett));");
         } else {
-            $self->pidl_code("proto_dcerpc = proto_get_id_by_filter_name(\"dcerpc\");");
-            $self->pidl_code("proto_register_field_array(proto_dcerpc, hf, array_length(hf));");
-            $self->pidl_code("proto_register_subtree_array(ett, array_length(ett));");
-        }
-            
+                $self->pidl_code("proto_dcerpc = proto_get_id_by_filter_name(\"dcerpc\");");
+                $self->pidl_code("proto_register_field_array(proto_dcerpc, hf, array_length(hf));");
+                $self->pidl_code("proto_register_subtree_array(ett, array_length(ett));");
+        }
+
         $self->deindent;
         $self->pidl_code("}\n");
@@ -741 +901 @@
         if (defined($x->{UUID})) {
                 $self->pidl_fn_start("proto_reg_handoff_dcerpc_$x->{NAME}");
-            $self->pidl_code("void proto_reg_handoff_dcerpc_$x->{NAME}(void)");
-            $self->pidl_code("{");
-            $self->indent;
-            $self->pidl_code("dcerpc_init_uuid(proto_dcerpc_$x->{NAME}, ett_dcerpc_$x->{NAME},");
-            $self->pidl_code("\t&uuid_dcerpc_$x->{NAME}, ver_dcerpc_$x->{NAME},");
-            $self->pidl_code("\t$x->{NAME}_dissectors, hf_$x->{NAME}_opnum);");
-            $self->deindent;
-            $self->pidl_code("}");
+                $self->pidl_code("void proto_reg_handoff_dcerpc_$x->{NAME}(void)");
+                $self->pidl_code("{");
+                $self->indent;
+                $self->pidl_code("dcerpc_init_uuid(proto_dcerpc_$x->{NAME}, ett_dcerpc_$x->{NAME},");
+                $self->pidl_code("\t&uuid_dcerpc_$x->{NAME}, ver_dcerpc_$x->{NAME},");
+                $self->pidl_code("\t$x->{NAME}_dissectors, hf_$x->{NAME}_opnum);");
+                $self->deindent;
+                $self->pidl_code("}");
                 $self->pidl_fn_end("proto_reg_handoff_dcerpc_$x->{NAME}");
 
@@ -771 +931 @@
         foreach (@imports) {
                 next if($_ eq "security");
-                s/\.idl\"$//;
                 s/^\"//;
+                s/\.idl"?$//;
                 $self->pidl_hdr("#include \"packet-dcerpc-$_\.h\"");
         }
@@ -796 +956 @@
                 my $if_uuid = $x->{UUID};
 
-            $self->pidl_def("/* Version information */\n\n");
-            
-            $self->pidl_def("static e_uuid_t uuid_dcerpc_$x->{NAME} = {");
-            $self->pidl_def("\t0x" . substr($if_uuid, 1, 8) 
-                . ", 0x" . substr($if_uuid, 10, 4)
-            . ", 0x" . substr($if_uuid, 15, 4) . ",");
-            $self->pidl_def("\t{ 0x" . substr($if_uuid, 20, 2) 
+                $self->pidl_def("/* Version information */\n\n");
+
+                $self->pidl_def("static e_uuid_t uuid_dcerpc_$x->{NAME} = {");
+                $self->pidl_def("\t0x" . substr($if_uuid, 1, 8)
+                . ", 0x" . substr($if_uuid, 10, 4)
+                . ", 0x" . substr($if_uuid, 15, 4) . ",");
+                $self->pidl_def("\t{ 0x" . substr($if_uuid, 20, 2)
                 . ", 0x" . substr($if_uuid, 22, 2)
-            . ", 0x" . substr($if_uuid, 25, 2)
-            . ", 0x" . substr($if_uuid, 27, 2)
-            . ", 0x" . substr($if_uuid, 29, 2)
-            . ", 0x" . substr($if_uuid, 31, 2)
-            . ", 0x" . substr($if_uuid, 33, 2)
-            . ", 0x" . substr($if_uuid, 35, 2) . " }");
-            $self->pidl_def("};");
-        
-            my $maj = $x->{VERSION};
-            $maj =~ s/\.(.*)$//g;
-            $self->pidl_def("static guint16 ver_dcerpc_$x->{NAME} = $maj;");
-            $self->pidl_def("");
+                . ", 0x" . substr($if_uuid, 25, 2)
+                . ", 0x" . substr($if_uuid, 27, 2)
+                . ", 0x" . substr($if_uuid, 29, 2)
+                . ", 0x" . substr($if_uuid, 31, 2)
+                . ", 0x" . substr($if_uuid, 33, 2)
+                . ", 0x" . substr($if_uuid, 35, 2) . " }");
+                $self->pidl_def("};");
+
+                my $maj = 0x0000FFFF & $x->{VERSION};
+                $maj =~ s/\.(.*)$//g;
+                $self->pidl_def("static guint16 ver_dcerpc_$x->{NAME} = $maj;");
+                $self->pidl_def("");
         }
 
@@ -821 +981 @@
 
         $self->Interface($x);
-
         $self->pidl_code("\n".DumpFunctionTable($x));
 
-        foreach (keys %{$return_types{$x->{NAME}}}) {
+        foreach (sort(keys %{$return_types{$x->{NAME}}})) {
                 my ($type, $desc) = @{$return_types{$x->{NAME}}->{$_}};
                 my $dt = $self->find_type($type);
@@ -869 +1028 @@
         $self->{conformance} = {
                 imports => {},
-                header_fields=> {} 
+                header_fields=> {}
         };
 
         ReadConformance($cnf_file, $self->{conformance}) or print STDERR "warning: No conformance file `$cnf_file'\n";
-        
+
         foreach my $bytes (qw(1 2 4 8)) {
                 my $bits = $bytes * 8;
@@ -879 +1038 @@
                 $self->register_type("int$bits", "offset = PIDL_dissect_uint$bits(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_INT$bits", "BASE_DEC", 0, "NULL", $bytes);
         }
-                
+
+        $self->register_type("uint3264", "offset = dissect_ndr_uint3264(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);", "FT_UINT32", "BASE_DEC", 0, "NULL", 8);
+        $self->register_type("hyper", "offset = dissect_ndr_uint64(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);", "FT_UINT64", "BASE_DEC", 0, "NULL", 8);
         $self->register_type("udlong", "offset = dissect_ndr_duint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);", "FT_UINT64", "BASE_DEC", 0, "NULL", 4);
         $self->register_type("bool8", "offset = PIDL_dissect_uint8(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_INT8", "BASE_DEC", 0, "NULL", 1);
@@ -891 +1052 @@
         $self->register_type("time_t", "offset = dissect_ndr_time_t(tvb, offset, pinfo,tree, drep, \@HF\@, NULL);","FT_ABSOLUTE_TIME", "ABSOLUTE_TIME_LOCAL", 0, "NULL", 4);
         $self->register_type("NTTIME_1sec", "offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, drep, \@HF\@);", "FT_ABSOLUTE_TIME", "ABSOLUTE_TIME_LOCAL", 0, "NULL", 4);
-        $self->register_type("SID", "
+        $self->register_type("dom_sid28", "{
                 dcerpc_info *di = (dcerpc_info *)pinfo->private_data;
-
                 di->hf_index = \@HF\@;
 
+                offset = dissect_ndr_nt_SID28(tvb, offset, pinfo, tree, drep);
+        }", "FT_STRING", "BASE_NONE", 0, "NULL", 4);
+        $self->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_NONE", 0, "NULL", 4);
-        $self->register_type("WERROR", 
+        }", "FT_STRING", "BASE_NONE", 0, "NULL", 4);
+        $self->register_type("WERROR",
                 "offset = PIDL_dissect_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_UINT32", "BASE_DEC", 0, "VALS(WERR_errors)", 4);
-        $self->register_type("NTSTATUS", 
+        $self->register_type("NTSTATUS",
                 "offset = PIDL_dissect_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_UINT32", "BASE_DEC", 0, "VALS(NT_errors)", 4);
+        $self->register_type("ipv6address", "proto_tree_add_item(tree, \@HF\@, tvb, offset, 16, ENC_NA); offset += 16;", "FT_IPv6", "BASE_NONE", 0, "NULL", 16);
+        $self->register_type("ipv4address", "proto_tree_add_item(tree, \@HF\@, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4;", "FT_IPv4", "BASE_NONE", 0, "NULL", 4);
 
 }
@@ -915 +1084 @@
         return (undef, undef) if defined($self->{conformance}->{noemit_dissector});
 
-        my $notice = 
+        my $notice =
 "/* DO NOT EDIT
         This filter was automatically generated
         from $idl_file and $cnf_file.
-        
-        Pidl is a perl based IDL compiler for DCE/RPC idl files. 
+
+        Pidl is a perl based IDL compiler for DCE/RPC idl files.
         It is maintained by the Samba team, not the Wireshark team.
-        Instructions on how to download and install Pidl can be 
+        Instructions on how to download and install Pidl can be
         found at http://wiki.wireshark.org/Pidl
 */
@@ -931 +1100 @@
 
         $self->{res}->{headers} = "\n";
-        $self->{res}->{headers} .= "#ifdef HAVE_CONFIG_H\n";
         $self->{res}->{headers} .= "#include \"config.h\"\n";
-        $self->{res}->{headers} .= "#endif\n\n";
 
         $self->{res}->{headers} .= "#ifdef _MSC_VER\n";
@@ -984 +1151 @@
 
         $self->CheckUsed($self->{conformance});
-    
+
         return ($parser,$header);
 }
@@ -996 +1163 @@
         my ($self, $name) = @_;
 
-        push (@{$self->{ett}}, $name);  
+        push (@{$self->{ett}}, $name);
 }
 
@@ -1025 +1192 @@
 ###############################################################################
 
-sub register_hf_field($$$$$$$$$) 
+sub register_hf_field($$$$$$$$$)
 {
         my ($self,$index,$name,$filter_name,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_;
@@ -1045 +1212 @@
         };
 
-        if ((not defined($blurb) or $blurb eq "") and 
+        if ((not defined($blurb) or $blurb eq "") and
                         defined($self->{conformance}->{fielddescription}->{$index})) {
-                $self->{conformance}->{header_fields}->{$index}->{BLURB} = 
+                $self->{conformance}->{header_fields}->{$index}->{BLURB} =
                         $self->{conformance}->{fielddescription}->{$index}->{DESCRIPTION};
                 $self->{conformance}->{fielddescription}->{$index}->{USED} = 1;
@@ -1055 +1222 @@
 }
 
+sub change_hf_field_type($$$$)
+{
+        my ($self,$index,$ft_type,$base_type) = @_;
+        if (defined ($self->{conformance}->{hf_renames}->{$index})) {
+                print "Field $index has been renamed to ".$self->{conformance}->{hf_renames}->{$index}->{NEWNAME}." you can't change it's type";
+                return 0;
+        }
+
+        if (!defined ($self->{conformance}->{header_fields}->{$index})) {
+                print "Field $index doesn't exists";
+                return 0;
+        }
+        $self->{conformance}->{header_fields}->{$index}->{FT_TYPE} = $ft_type;
+        $self->{conformance}->{header_fields}->{$index}->{BASE_TYPE} = $base_type;
+        return 1;
+}
+
 sub DumpHfDeclaration($)
 {
@@ -1062 +1246 @@
         $res = "\n/* Header field declarations */\n";
 
-        foreach (keys %{$self->{conformance}->{header_fields}}) 
+        foreach (sort(keys %{$self->{conformance}->{header_fields}}))
         {
                 $res .= "static gint $_ = -1;\n";
@@ -1072 +1256 @@
 sub make_str_or_null($)
 {
-      my $str = shift;
-      if (substr($str, 0, 1) eq "\"") {
-              $str = substr($str, 1, length($str)-2);
-      }
-      $str =~ s/^\s*//;
-      $str =~ s/\s*$//;
-      if ($str eq "") {
-              return "NULL";
-      }
-      return make_str($str);
+        my $str = shift;
+        if (substr($str, 0, 1) eq "\"") {
+                $str = substr($str, 1, length($str)-2);
+        }
+        $str =~ s/^\s*//;
+        $str =~ s/\s*$//;
+        if ($str eq "") {
+                return "NULL";
+        }
+        return make_str($str);
 }
 
@@ -1089 +1273 @@
         my $res = "\tstatic hf_register_info hf[] = {\n";
 
-        foreach (values %{$self->{conformance}->{header_fields}}) 
+        foreach (sort {$a->{INDEX} cmp $b->{INDEX}} values %{$self->{conformance}->{header_fields}})
         {
-                $res .= "\t{ &$_->{INDEX}, 
+                $res .= "\t{ &$_->{INDEX},
           { ".make_str($_->{NAME}).", ".make_str($_->{FILTER}).", $_->{FT_TYPE}, $_->{BASE_TYPE}, $_->{VALSSTRING}, $_->{MASK}, ".make_str_or_null($_->{BLURB}).", HFILL }},
 ";
@@ -1110 +1294 @@
         my $res = "static dcerpc_sub_dissector $if->{NAME}\_dissectors[] = {\n";
         foreach (@{$if->{FUNCTIONS}}) {
-                my $fn_name = $_->{NAME};
+                my $fn_name = $_->{NAME};
                 $fn_name =~ s/^$if->{NAME}_//;
                 $res.= "\t{ $_->{OPNUM}, \"$fn_name\",\n";

vendor/current/pidl/lib/wscript_build

@@ -2 +2 @@
 
 # install the pidl modules
-bld.INSTALL_WILDCARD('${DATAROOTDIR}/perl5', '**/*.pm', flat=False)
+bld.INSTALL_FILES(bld.env.PERL_LIB_INSTALL_DIR,
+                  '''
+                  Parse/Pidl.pm
+                  Parse/Pidl/Samba4.pm
+                  Parse/Pidl/CUtil.pm
+                  Parse/Pidl/Expr.pm
+                  Parse/Pidl/Wireshark/Conformance.pm
+                  Parse/Pidl/Wireshark/NDR.pm
+                  Parse/Pidl/ODL.pm
+                  Parse/Pidl/Dump.pm
+                  Parse/Pidl/Util.pm
+                  Parse/Pidl/Samba4/Header.pm
+                  Parse/Pidl/Samba4/COM/Header.pm
+                  Parse/Pidl/Samba4/COM/Proxy.pm
+                  Parse/Pidl/Samba4/COM/Stub.pm
+                  Parse/Pidl/Samba4/TDR.pm
+                  Parse/Pidl/Samba4/NDR/Server.pm
+                  Parse/Pidl/Samba4/NDR/Client.pm
+                  Parse/Pidl/Samba4/NDR/Parser.pm
+                  Parse/Pidl/Samba4/Python.pm
+                  Parse/Pidl/Samba4/Template.pm
+                  Parse/Pidl/IDL.pm
+                  Parse/Pidl/Typelist.pm
+                  Parse/Pidl/Samba3/ClientNDR.pm
+                  Parse/Pidl/Samba3/ServerNDR.pm
+                  Parse/Pidl/Compat.pm
+                  Parse/Pidl/NDR.pm
+                  ''',
+                  flat=False)
+
+if not bld.CONFIG_SET('USING_SYSTEM_PARSE_YAPP_DRIVER'):
+    bld.INSTALL_FILES(bld.env.PERL_LIB_INSTALL_DIR,
+                      'Parse/Yapp/Driver.pm',
+                      flat=False)

vendor/current/pidl/pidl

@@ -22 +22 @@
 =head1 DESCRIPTION
 
-pidl is an IDL compiler written in Perl that aims to be somewhat 
-compatible with the midl compiler. IDL is short for 
+pidl is an IDL compiler written in Perl that aims to be somewhat
+compatible with the midl compiler. IDL is short for
 "Interface Definition Language".
 
-pidl can generate stubs for DCE/RPC server code, DCE/RPC 
+pidl can generate stubs for DCE/RPC server code, DCE/RPC
 client code and Wireshark dissectors for DCE/RPC traffic.
 
-IDL compilers like pidl take a description 
-of an interface as their input and use it to generate C 
-(though support for other languages may be added later) code that 
-can use these interfaces, pretty print data sent 
-using these interfaces, or even generate Wireshark 
-dissectors that can parse data sent over the 
-wire by these interfaces. 
-
-pidl takes IDL files in the same format as is used by midl, 
+IDL compilers like pidl take a description
+of an interface as their input and use it to generate C
+(though support for other languages may be added later) code that
+can use these interfaces, pretty print data sent
+using these interfaces, or even generate Wireshark
+dissectors that can parse data sent over the
+wire by these interfaces.
+
+pidl takes IDL files in the same format as is used by midl,
 converts it to a .pidl file (which contains pidl's internal representation of the interface) and can then generate whatever output you need.
-.pidl files should be used for debugging purposes only. Write your 
+.pidl files should be used for debugging purposes only. Write your
 interface definitions in .idl format.
 
-The goal of pidl is to implement a IDL compiler that can be used 
-while developing the RPC subsystem in Samba (for 
+The goal of pidl is to implement a IDL compiler that can be used
+while developing the RPC subsystem in Samba (for
 both marshalling/unmarshalling and debugging purposes).
 
@@ -57 +57 @@
 
 Show pidl version
-                
+
 =item I<--outputdir OUTNAME>
 
-Write output files to the specified directory.  Defaults to the current 
+Write output files to the specified directory.  Defaults to the current
 directory.
 
 =item I<--includedir DIR>
 
-Add DIR to the search path used by the preprocessor. This option can be 
+Add DIR to the search path used by the preprocessor. This option can be
 specified multiple times.
-                
+
 =item I<--parse-idl-tree>
 
-Read internal tree structure from input files rather 
+Read internal tree structure from input files rather
 than assuming they contain IDL.
 
@@ -83 +83 @@
 =item I<--ndr-parser>
 
-Generate a C file and C header containing NDR parsers. The filename for 
-the parser defaults to ndr_OUTNAME.c. The header filename will be the 
+Generate a C file and C header containing NDR parsers. The filename for
+the parser defaults to ndr_OUTNAME.c. The header filename will be the
 parser filename with the extension changed from .c to .h.
 
 =item I<--tdr-parser>
 
-Generate a C file and C header containing TDR parsers. The filename for 
-the parser defaults to tdr_OUTNAME.c. The header filename will be the 
+Generate a C file and C header containing TDR parsers. The filename for
+the parser defaults to tdr_OUTNAME.c. The header filename will be the
 parser filename with the extension changed from .c to .h.
 
@@ -99 +99 @@
 =item I<--server>
 
-Generate boilerplate for the RPC server that implements 
+Generate boilerplate for the RPC server that implements
 the interface. Filename defaults to ndr_OUTNAME_s.c.
 
 =item I<--template>
 
-Generate stubs for a RPC server that implements the interface. Output will 
+Generate stubs for a RPC server that implements the interface. Output will
 be written to stdout.
 
@@ -110 +110 @@
 
 Generate an Wireshark dissector (in C) and header file. The dissector filename
-defaults to packet-dcerpc-OUTNAME.c while the header filename defaults to 
+defaults to packet-dcerpc-OUTNAME.c while the header filename defaults to
 packet-dcerpc-OUTNAME.h.
-        
-Pidl will read additional data from an Wireshark conformance file if present. 
-Such a file should have the same location as the IDL file but with the 
+
+Pidl will read additional data from an Wireshark conformance file if present.
+Such a file should have the same location as the IDL file but with the
 extension I<cnf> rather than I<idl>. See L<Parse::Pidl::Wireshark::Conformance>
 for details on the format of this file.
@@ -120 +120 @@
 =item I<--diff>
 
-Parse an IDL file,  generate a new IDL file based on the internal data 
-structures and see if there are any differences with the original IDL file. 
+Parse an IDL file,  generate a new IDL file based on the internal data
+structures and see if there are any differences with the original IDL file.
 Useful for debugging pidl.
 
 =item I<--dump-idl-tree>
 
-Tell pidl to dump the internal tree representation of an IDL 
+Tell pidl to dump the internal tree representation of an IDL
 file the to disk. Useful for debugging pidl.
 
 =item I<--dump-ndr-tree>
 
-Tell pidl to dump the internal NDR information tree it generated 
+Tell pidl to dump the internal NDR information tree it generated
 from the IDL file to disk.  Useful for debugging pidl.
 
 =item I<--samba3-ndr-client>
 
-Generate client calls for Samba3, to be placed in rpc_client/. Instead of 
-calling out to the code in Samba3's rpc_parse/, this will call out to 
+Generate client calls for Samba3, to be placed in rpc_client/. Instead of
+calling out to the code in Samba3's rpc_parse/, this will call out to
 Samba4's NDR code instead.
 
 =item I<--samba3-ndr-server>
 
-Generate server calls for Samba3, to be placed in rpc_server/. Instead of 
-calling out to the code in Samba3's rpc_parse/, this will call out to 
+Generate server calls for Samba3, to be placed in rpc_server/. Instead of
+calling out to the code in Samba3's rpc_parse/, this will call out to
 Samba4's NDR code instead.
 
@@ -152 +152 @@
 IDL files are always preprocessed using the C preprocessor.
 
-Pretty much everything in an interface (the interface itself, functions, 
-parameters) can have attributes (or properties whatever name you give them). 
-Attributes always prepend the element they apply to and are surrounded 
-by square brackets ([]). Multiple attributes are separated by comma's; 
-arguments to attributes are specified between parentheses. 
-
-See the section COMPATIBILITY for the list of attributes that 
+Pretty much everything in an interface (the interface itself, functions,
+parameters) can have attributes (or properties whatever name you give them).
+Attributes always prepend the element they apply to and are surrounded
+by square brackets ([]). Multiple attributes are separated by comma's;
+arguments to attributes are specified between parentheses.
+
+See the section COMPATIBILITY for the list of attributes that
 pidl supports.
 
 C-style comments can be used.
-        
+
 =head2 CONFORMANT ARRAYS
 
 A conformant array is one with that ends in [*] or []. The strange
-things about conformant arrays are that they can only appear as the last 
-element of a structure (unless there is a pointer to the conformant array, 
-of course) and the array size appears before the structure itself on the wire. 
+things about conformant arrays are that they can only appear as the last
+element of a structure (unless there is a pointer to the conformant array,
+of course) and the array size appears before the structure itself on the wire.
 
 So, in this example:
@@ -174 +174 @@
         typedef struct {
                 long abc;
-                long count;     
+                long count;
                 long foo;
                 [size_is(count)] long s[*];
@@ -194 +194 @@
    typedef struct {
                 long abc;
-                long count;     
+                long count;
                 long foo;
                 long s[1];
@@ -203 +203 @@
     typedef struct {
                 long abc;
-                long count;     
+                long count;
                 long foo;
                 long *s;
@@ -214 +214 @@
         typedef struct {
                 long abc;
-                long count;     
+                long count;
                 long foo;
                 [size_is(count)] long *s;
@@ -249 +249 @@
 
 Fixed arrays are an extension added to support some of the strange
-embedded structures in security descriptors and spoolss. 
-
-This section is by no means complete. See the OpenGroup and MSDN 
+embedded structures in security descriptors and spoolss.
+
+This section is by no means complete. See the OpenGroup and MSDN
         documentation for additional information.
 
@@ -258 +258 @@
 =head2 Missing features in pidl
 
-The following MIDL features are not (yet) implemented in pidl 
+The following MIDL features are not (yet) implemented in pidl
 or are implemented with an incompatible interface:
 
@@ -267 +267 @@
 Asynchronous communication
 
-=item * 
+=item *
 
 Typelibs (.tlb files)
@@ -279 +279 @@
 =head2 Supported attributes and statements
 
-in, out, ref, length_is, switch_is, size_is, uuid, case, default, string, 
-unique, ptr, pointer_default, v1_enum, object, helpstring, range, local, 
-call_as, endpoint, switch_type, progid, coclass, iid_is, represent_as, 
+in, out, ref, length_is, switch_is, size_is, uuid, case, default, string,
+unique, ptr, pointer_default, v1_enum, object, helpstring, range, local,
+call_as, endpoint, switch_type, progid, coclass, iid_is, represent_as,
 transmit_as, import, include, cpp_quote.
 
@@ -295 +295 @@
 specify [public] then pull/push functions for other than top-level
 functions are declared static.
-                                
+
 =item noprint
 
@@ -325 +325 @@
 
 Specifies that a size of I<length>
-bytes should be read, followed by a blob of that size, 
+bytes should be read, followed by a blob of that size,
 which will be parsed as NDR.
 
-subcontext() is deprecated now, and should not be used in new code. 
+subcontext() is deprecated now, and should not be used in new code.
 Instead, use represent_as() or transmit_as().
 
 =item flag
 
-Specify boolean options, mostly used for 
-low-level NDR options. Several options 
+Specify boolean options, mostly used for
+low-level NDR options. Several options
 can be specified using the | character.
 Note that flags are inherited by substructures!
@@ -347 +347 @@
 =item charset(name)
 
-Specify that the array or string uses the specified 
-charset. If this attribute is specified, pidl will 
-take care of converting the character data from this format 
+Specify that the array or string uses the specified
+charset. If this attribute is specified, pidl will
+take care of converting the character data from this format
 to the host format. Commonly used values are UCS2, DOS and UTF8.
 
@@ -356 +356 @@
 =head2 Unsupported MIDL properties or statements
 
-aggregatable, appobject, async_uuid, bindable, control, 
-defaultbind, defaultcollelem, defaultvalue, defaultvtable, dispinterface, 
-displaybind, dual, entry, first_is, helpcontext, helpfile, helpstringcontext, 
-helpstringdll, hidden, idl_module, idl_quote, id, immediatebind, importlib, 
-includelib, last_is, lcid, licensed, max_is, module, 
-ms_union, no_injected_text, nonbrowsable, noncreatable, nonextensible, odl, 
-oleautomation, optional, pragma, propget, propputref, propput, readonly, 
-requestedit, restricted, retval, source, uidefault, 
-usesgetlasterror, vararg, vi_progid, wire_marshal. 
+aggregatable, appobject, async_uuid, bindable, control,
+defaultbind, defaultcollelem, defaultvalue, defaultvtable, dispinterface,
+displaybind, dual, entry, first_is, helpcontext, helpfile, helpstringcontext,
+helpstringdll, hidden, idl_module, idl_quote, id, immediatebind, importlib,
+includelib, last_is, lcid, licensed, max_is, module,
+ms_union, no_injected_text, nonbrowsable, noncreatable, nonextensible, odl,
+oleautomation, optional, pragma, propget, propputref, propput, readonly,
+requestedit, restricted, retval, source, uidefault,
+usesgetlasterror, vararg, vi_progid, wire_marshal.
 
 =head1 EXAMPLES
@@ -370 +370 @@
         # Generating an Wireshark parser
         $ ./pidl --ws-parser -- atsvc.idl
-        
+
         # Generating a TDR parser and header
         $ ./pidl --tdr-parser --header -- regf.idl
@@ -383 +383 @@
 
 L<http://msdn.microsoft.com/library/en-us/rpc/rpc/field_attributes.asp>,
-L<http://wiki.wireshark.org/DCE/RPC>, 
+L<http://wiki.wireshark.org/DCE/RPC>,
 L<http://www.samba.org/>,
 L<yapp(1)>
@@ -393 +393 @@
 =head1 AUTHOR
 
-pidl was written by Andrew Tridgell, Stefan Metzmacher, Tim Potter and Jelmer 
+pidl was written by Andrew Tridgell, Stefan Metzmacher, Tim Potter and Jelmer
 Vernooij. The current maintainer is Jelmer Vernooij.
 
-This manpage was written by Jelmer Vernooij, partially based on the original 
-pidl README by Andrew Tridgell. 
-        
+This manpage was written by Jelmer Vernooij, partially based on the original
+pidl README by Andrew Tridgell.
+
 =cut
 
@@ -405 +405 @@
 use FindBin qw($RealBin $Script);
 use lib "$RealBin/lib";
-use lib "$RealBin/../share/perl5";
 use Getopt::Long;
 use File::Basename;
@@ -452 +451 @@
     my($v) = shift;
     local(*FILE);
-    open(FILE, ">$filename") || die "can't open $filename";    
+    open(FILE, ">$filename") || die "can't open $filename";
     print FILE $v;
     close(FILE);
 }
 
-my(@opt_incdirs) = (); 
+my(@opt_incdirs) = ();
 my($opt_help) = 0;
 my($opt_version) = 0;
@@ -471 +470 @@
 my($opt_samba3_ndr_client);
 my($opt_samba3_ndr_server);
+my($opt_samba3_template) = 0;
 my($opt_template) = 0;
 my($opt_client);
@@ -527 +527 @@
 
 Samba 3 output:
- --samba3-ndr-client[=OUTF] create client calls for Samba3 
+ --samba3-ndr-client[=OUTF] create client calls for Samba3
                             using Samba4's NDR code [cli_BASENAME.c]
- --samba3-ndr-server[=OUTF] create server call wrapper for Samba3 
+ --samba3-ndr-server[=OUTF] create server call wrapper for Samba3
                             using Samba4's NDR code [srv_BASENAME.c]
+ --samba3-template          print a template for a pipe
 
 Wireshark parsers:
@@ -547 +548 @@
 # main program
 my $result = GetOptions (
-            'help|h|?' => \$opt_help, 
+            'help|h|?' => \$opt_help,
             'version' => \$opt_version,
             'outputdir=s' => \$opt_outputdir,
@@ -556 +557 @@
                 'samba3-ndr-client:s' => \$opt_samba3_ndr_client,
                 'samba3-ndr-server:s' => \$opt_samba3_ndr_server,
+            'samba3-template' => \$opt_samba3_template,
                 'header:s' => \$opt_header,
             'server:s' => \$opt_server,
@@ -667 +669 @@
         if (defined($opt_ws_parser) or
             defined($opt_client) or
-            defined($opt_server) or 
+            defined($opt_server) or
             defined($opt_header) or
             defined($opt_ndr_parser) or
-            defined($opt_python) or 
+            defined($opt_python) or
             defined($opt_dump_ndr_tree) or
-            defined($opt_samba3_header) or 
-            defined($opt_samba3_parser) or 
-            defined($opt_samba3_server) or 
+            defined($opt_samba3_header) or
+            defined($opt_samba3_parser) or
+            defined($opt_samba3_server) or
             defined($opt_samba3_ndr_client) or
             defined($opt_samba3_ndr_server)) {
@@ -710 +712 @@
         if (defined($opt_python)) {
                 require Parse::Pidl::Samba4::Python;
-                my $generator = new Parse::Pidl::Samba4::Python(); 
-                my ($prsr) = $generator->Parse($basename, $ndr, 
+                my $generator = new Parse::Pidl::Samba4::Python();
+                my ($prsr) = $generator->Parse($basename, $ndr,
                                         "$outputdir/ndr_$basename\_c.h", $h_filename);
                 FileSave("$outputdir/py_$basename.c", $prsr);
@@ -769 +771 @@
         }
 
+        if ($opt_samba3_template) {
+                require Parse::Pidl::Samba3::Template;
+                print Parse::Pidl::Samba3::Template::Parse($pidl);
+        }
+
         if (defined($opt_samba3_ndr_client)) {
                 my $client = ($opt_samba3_ndr_client or "$outputdir/cli_$basename.c");

vendor/current/pidl/tests/Util.pm

@@ -119 +119 @@
         my $outfile;
         if (defined($test_data_prefix)) {
-                $outfile = "$test_data_prefix/test-$name";      
+                $outfile = "$test_data_prefix/test-$name";
         } else {
                 $outfile = "./test-$name";

vendor/current/pidl/tests/samba-ndr.pl

@@ -222 +222 @@
                         ALIGN => 4,
                         ELEMENTS => [ ]}, "ndr", "x");
-is($generator->{res}, "if (ndr_flags & NDR_SCALARS) {
+is($generator->{res}, "NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
+if (ndr_flags & NDR_SCALARS) {
         NDR_CHECK(ndr_push_align(ndr, 4));
         NDR_CHECK(ndr_push_trailer_align(ndr, 4));
@@ -246 +247 @@
                         SURROUNDING_ELEMENT => $e,
                         ELEMENTS => [ $e ]}, "ndr", "x");
-is($generator->{res}, "if (ndr_flags & NDR_SCALARS) {
+is($generator->{res}, "NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
+if (ndr_flags & NDR_SCALARS) {
         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_string_array_size(ndr, x->el1)));
         NDR_CHECK(ndr_push_align(ndr, 4));

vendor/current/pidl/tests/typelist.pl

@@ -53 +53 @@
 
 is(1, hasType("foo"));
-is(0, hasType("nonexistant"));
+is(0, hasType("nonexistent"));
 is(0, hasType({TYPE => "ENUM", NAME => "someUnknownType"}));
 is(1, hasType({TYPE => "ENUM", NAME => "foo"}));
@@ -60 +60 @@
 
 is(1, is_scalar("uint32"));
-is(0, is_scalar("nonexistant"));
+is(0, is_scalar("nonexistent"));
 is(1, is_scalar({TYPE => "ENUM"}));
 is(0, is_scalar({TYPE => "STRUCT"}));

vendor/current/pidl/tests/wireshark-conf.pl

@@ -16 +16 @@
 {
         my $str = shift;
-    open(TMP, "+>", undef) or die("unable to open temp file");
+        open(TMP, "+>", undef) or die("unable to open temp file");
         print TMP $str;
         seek(TMP, 0, 0);

vendor/current/pidl/tests/wireshark-ndr.pl

@@ -228 +228 @@
 
 is($x->DumpHfList(), "\tstatic hf_register_info hf[] = {
-        { &hf_bla, 
+        { &hf_bla,
           { \"Bla\", \"bla.field\", FT_UINT32, BASE_DEC, NULL, 255, \"NULL\", HFILL }},
         };

vendor/current/pidl/wscript

@@ -1 +1 @@
 #!/usr/bin/env python
 
-import os, sys, Logs
+import os, Logs
 from samba_utils import MODE_755
 
+# This function checks if a perl module is installed on the system.
+def check_system_perl_module(conf, module, version=None):
+    bundle_name = module.replace('::', '_')
+    module_check = module
+
+    # Create module string with version
+    if version:
+        module_check = module + ' ' + str(version)
+
+    # Check if we have to bundle it.
+    if conf.LIB_MUST_BE_BUNDLED(bundle_name.lower()):
+        return False
+
+    # Check for system perl module
+    if not conf.check_perl_module(module_check):
+        return False
+
+    conf.define('USING_SYSTEM_%s' % bundle_name.upper(), 1)
+
+    return True
+
 def set_options(opt):
-    opt.tool_options('perl')
+    return
 
 def configure(conf):
-    conf.check_tool('perl')
+    # Check if perl(Parse::Yapp::Driver) is available.
+    check_system_perl_module(conf, "Parse::Yapp::Driver", 1.05)
+
     # we need a recent version of MakeMaker to get the right man page names
     if conf.CHECK_PERL_MANPAGE():
@@ -20 +43 @@
 
 def build(bld):
-    bld.INSTALL_FILES('${BINDIR}', 'pidl', chmod=MODE_755)
+    bld.INSTALL_FILES('${BINDIR}', 'pidl', chmod=MODE_755, perl_fixup=True)
 
     bld.RECURSE('lib')
@@ -26 +49 @@
     if not bld.CONFIG_SET('HAVE_PERL_MAKEMAKER'):
         return
-
-    pidl_src = ['pidl']
-    pidl_src.extend(bld.path.ant_glob('lib/**/*.pm').split())
 
     pidl_manpages = {
@@ -45 +65 @@
     bld.env.pidl_srcdir = os.path.join(bld.srcnode.abspath(), 'pidl')
 
-    blib_bld = os.path.join(bld.srcnode.abspath(bld.env), 'pidl/blib')
-
     bld.SET_BUILD_GROUP('final')
     if 'POD2MAN' in bld.env and bld.env['POD2MAN'] != '':
         for src, manpage in pidl_manpages.iteritems():
-            bld(rule='${PERL} ${POD2MAN} -c "Samba Documentation" ${SRC} ${TGT}',
+            bld(rule='${POD2MAN} -c "Samba Documentation" ${SRC} ${TGT}',
                 shell=True,
                 source=src,