r1767: Checkin of workarea. Sorry Jelmer but this overwrites some of your changes
[samba.git] / source4 / build / pidl / eparser.pm
index acc8fddc8065df2bd8a0b41c971922d3e8460c54..1223c0ca7764322debc8b54c0c34d98e0b1c022c 100644 (file)
@@ -2,7 +2,6 @@
 # Samba4 parser generator for IDL structures
 # Copyright tridge@samba.org 2000-2003
 # Copyright tpot@samba.org 2001,2004
-# Copyright jelmer@samba.org 2004
 # released under the GNU GPL
 
 package IdlEParser;
@@ -14,6 +13,9 @@ my %needed;
 my %structs;
 
 my $module;
+my $if_uuid;
+my $if_version;
+my $if_endpoints;
 
 sub pidl($)
 {
@@ -66,10 +68,11 @@ sub find_sibling($$)
 
 ####################################################################
 # work out the name of a size_is() variable
-sub find_size_var($$)
+sub find_size_var($$$)
 {
        my($e) = shift;
        my($size) = shift;
+       my($var_prefix) = shift;
 
        my($fn) = $e->{PARENT};
 
@@ -78,7 +81,7 @@ sub find_size_var($$)
        }
 
        if ($size =~ /ndr->|\(/) {
-           return $size;
+               return $size;
        }
 
        my $prefix = "";
@@ -89,19 +92,19 @@ sub find_size_var($$)
        }
 
        if ($fn->{TYPE} ne "FUNCTION") {
-               return $prefix . "elt_$size";
+               return $prefix . "r->$size";
        }
 
        my $e2 = find_sibling($e, $size);
 
        if (util::has_property($e2, "in") && util::has_property($e2, "out")) {
-               return $prefix . "elt_$size";
+               return $prefix . "$var_prefix$size";
        }
        if (util::has_property($e2, "in")) {
-               return $prefix . "elt_$size";
+               return $prefix . "r->in.$size";
        }
        if (util::has_property($e2, "out")) {
-               return $prefix . "elt_$size";
+               return $prefix . "r->out.$size";
        }
 
        die "invalid variable in $size for element $e->{NAME} in $fn->{NAME}\n";
@@ -220,12 +223,13 @@ sub union_alignment
 
 #####################################################################
 # parse an array - pull side
-sub ParseArrayPull($$)
+sub ParseArrayPull($$$)
 {
        my $e = shift;
+       my $var_prefix = shift;
        my $ndr_flags = shift;
 
-       my $size = find_size_var($e, util::array_size($e));
+       my $size = find_size_var($e, util::array_size($e), $var_prefix);
        my $alloc_size = $size;
 
        # if this is a conformant array then we use that size to allocate, and make sure
@@ -234,133 +238,148 @@ sub ParseArrayPull($$)
                $alloc_size = $e->{CONFORMANT_SIZE};
 
                pidl "\tif ($size > $alloc_size) {\n";
-               pidl "\t\tproto_tree_add_text(tree, ndr->tvb, ndr->offset, 0, \"Bad conformant size (%u should be %u)\", $alloc_size, $size);\n";
-               pidl "\t\tif (check_col(ndr->pinfo->cinfo, COL_INFO))\n";
-               pidl "\t\t\tcol_append_fstr(ndr->pinfo->cinfo, COL_INFO, \", Bad conformant size (%u should be %u)\", $alloc_size, $size);\n";
+               pidl "\t\treturn; // ndr_pull_error(ndr, NDR_ERR_CONFORMANT_SIZE, \"Bad conformant size %u should be %u\", $alloc_size, $size);\n";
                pidl "\t}\n";
        } elsif (!util::is_inline_array($e)) {
-#              if ($var_prefix =~ /^r->out/ && $size =~ /^\*r->in/) {
-#                      my $size2 = substr($size, 1);
-#                      pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { NDR_ALLOC(ndr, $size2); }\n";
-#              }
+               if ($var_prefix =~ /^r->out/ && $size =~ /^\*r->in/) {
+                       my $size2 = substr($size, 1);
+                       pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { NDR_ALLOC(ndr, $size2); }\n";
+               }
 
                # non fixed arrays encode the size just before the array
+               pidl "\t{\n";
+               pidl "\t\tuint32_t _array_size;\n";
+               pidl "\t\tndr_pull_uint32(ndr, tree, hf_array_size, &_array_size);\n";
+               if ($size =~ /r->in/) {
+                       pidl "\t\tif (!(ndr->flags & LIBNDR_FLAG_REF_ALLOC) && _array_size != $size) {\n";
+               } else {
+                       pidl "\t\tif ($size != _array_size) {\n";
+               }
+               pidl "\t\t\t//return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %u should be %u\", _array_size, $size);\n";
+               pidl "\t\t\treturn;\n";
+               pidl "\t\t}\n";
+               if ($size =~ /r->in/) {
+                       pidl "else { $size = _array_size; }\n";
+               }
+               pidl "\t}\n";
+       }
 
-           if (!($size =~ /\d+/)) {
-               pidl "\t\tndr_pull_uint32(ndr, tree, hf_array_size, &$size);\n";
-           } else {
-               pidl "\t\tndr_pull_uint32(ndr, tree, hf_array_size, NULL);\n";
-           }
+       if ((util::need_alloc($e) && !util::is_fixed_array($e)) ||
+           ($var_prefix eq "r->in." && util::has_property($e, "ref"))) {
+               if (!util::is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
+                       pidl "\t\tNDR_ALLOC_N(ndr, $var_prefix$e->{NAME}, MAX(1, $alloc_size));\n";
+               }
        }
 
-#      if ((util::need_alloc($e) && !util::is_fixed_array($e)) ||
-#          ($var_prefix eq "r->in." && util::has_property($e, "ref"))) {
-#              if (!util::is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
-#                      pidl "\t\tNDR_ALLOC_N(ndr, $var_prefix$e->{NAME}, MAX(1, $alloc_size));\n";
-#              }
-#      }
+       if (($var_prefix eq "r->out." && util::has_property($e, "ref"))) {
+               if (!util::is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
+                       pidl "\tif (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
+                       pidl "\t\tNDR_ALLOC_N(ndr, $var_prefix$e->{NAME}, MAX(1, $alloc_size));\n";
+                       pidl "\t}\n";
+               }
+       }
 
-#      if (($var_prefix eq "r->out." && util::has_property($e, "ref"))) {
-#              if (!util::is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
-#                      pidl "\tif (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
-#                      pidl "\t\tNDR_ALLOC_N(ndr, $var_prefix$e->{NAME}, MAX(1, $alloc_size));\n";
-#                      pidl "\t}\n";
-#              }
-#      }
+       pidl "\t{\n";
 
        if (my $length = util::has_property($e, "length_is")) {
-               $length = find_size_var($e, $length);
+               $length = find_size_var($e, $length, $var_prefix);
+               pidl "\t\tuint32_t _offset, _length;\n";
                pidl "\t\tndr_pull_uint32(ndr, tree, hf_array_offset, &_offset);\n";
                pidl "\t\tndr_pull_uint32(ndr, tree, hf_array_length, &_length);\n";
+               pidl "\t\tif (_offset != 0) return; // ndr_pull_error(ndr, NDR_ERR_OFFSET, \"Bad array offset 0x%08x\", _offset);\n";
+               pidl "\t\tif (_length > $size || _length != $length) return; // ndr_pull_error(ndr, NDR_ERR_LENGTH, \"Bad array length 0x%08x > size 0x%08x\", _offset, $size);\n\n";
                $size = "_length";
        }
 
        if (util::is_scalar_type($e->{TYPE})) {
-               pidl "\tndr_pull_array_$e->{TYPE}(ndr, tree, hf_$e->{NAME}_$e->{TYPE}, $ndr_flags, $size);\n";
+               pidl "\t\tndr_pull_array_$e->{TYPE}(ndr, $ndr_flags, tree, \"$e->{NAME}\", hf_$e->{NAME}_$e->{TYPE}, $var_prefix$e->{NAME}, $size);\n";
        } else {
-               pidl "\tndr_pull_array(ndr, tree, $ndr_flags, $size, ndr_pull_$e->{TYPE});\n";
+               pidl "\t\tndr_pull_array(ndr, $ndr_flags, tree, \"$e->{NAME}\", (void **)$var_prefix$e->{NAME}, sizeof($var_prefix$e->{NAME}\[0]), $size, (ndr_pull_flags_fn_t)ndr_pull_$e->{TYPE});\n";
        }
+
+       pidl "\t}\n";
 }
 
 
 #####################################################################
 # parse scalars in a structure element - pull size
-sub ParseElementPullSwitch($$$)
+sub ParseElementPullSwitch($$$$)
 {
        my($e) = shift;
+       my($var_prefix) = shift;
        my($ndr_flags) = shift;
        my $switch = shift;
-       my $switch_var = find_size_var($e, $switch);
+       my $switch_var = find_size_var($e, $switch, $var_prefix);
 
        my $cprefix = util::c_pull_prefix($e);
 
-       pidl "\t{\n";
-       pidl "\t\tguint16 _level;\n";
-
        my $utype = $structs{$e->{TYPE}};
        if (!defined $utype ||
            !util::has_property($utype->{DATA}, "nodiscriminant")) {
                my $e2 = find_sibling($e, $switch);
                pidl "\tif (($ndr_flags) & NDR_SCALARS) {\n";
-               pidl "\t\tndr_pull_level(ndr, tree, hf_level, &_level);\n";
+               pidl "\t\t $e2->{TYPE} _level;\n";
+               pidl "\t\tndr_pull_$e2->{TYPE}(ndr, tree, hf_level, &_level);\n";
+               if ($switch_var =~ /r->in/) {
+                       pidl "\t\tif (!(ndr->flags & LIBNDR_FLAG_REF_ALLOC) && _level != $switch_var) {\n";
+               } else {
+                       pidl "\t\tif (_level != $switch_var) {\n";
+               }
+               pidl "\t\t\treturn; // ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u in $e->{NAME}\", _level);\n";
+               pidl "\t\t}\n";
+               if ($switch_var =~ /r->/) {
+                       pidl "else { $switch_var = _level; }\n";
+               }
                pidl "\t}\n";
-       } else {
-               pidl "\t_level = $switch_var;\n";
        }
 
        my $sub_size = util::has_property($e, "subcontext");
        if (defined $sub_size) {
-               pidl "\tndr_pull_subcontext_union_fn(ndr, tree, $sub_size, $switch_var, (ndr_pull_union_fn_t) ndr_pull_$e->{TYPE});\n";
+               pidl "\tndr_pull_subcontext_union_fn(ndr, $sub_size, $switch_var, $cprefix$var_prefix$e->{NAME}, (ndr_pull_union_fn_t) ndr_pull_$e->{TYPE});\n";
        } else {
-               pidl "\tndr_pull_$e->{TYPE}(ndr, tree, $ndr_flags, _level);\n";
+               pidl "\tndr_pull_$e->{TYPE}(ndr, $ndr_flags, tree, $switch_var, $cprefix$var_prefix$e->{NAME});\n";
        }
-       pidl "\t}\n";
+
+
 }
 
 #####################################################################
 # parse scalars in a structure element - pull size
-sub ParseElementPullScalar($$)
+sub ParseElementPullScalar($$$)
 {
        my($e) = shift;
+       my($var_prefix) = shift;
        my($ndr_flags) = shift;
-
        my $cprefix = util::c_pull_prefix($e);
        my $sub_size = util::has_property($e, "subcontext");
 
        start_flags($e);
 
        if (util::has_property($e, "relative")) {
-               pidl "\tndr_pull_relative(ndr, get_subtree(tree, \"$e->{NAME}\", ndr, ett_$e->{TYPE}), ndr_pull_$e->{TYPE});\n";
+               pidl "\tndr_pull_relative(ndr, (const void **)&$var_prefix$e->{NAME}, sizeof(*$var_prefix$e->{NAME}), (ndr_pull_flags_fn_t)ndr_pull_$e->{TYPE});\n";
        } elsif (util::is_inline_array($e)) {
-               ParseArrayPull($e, "NDR_SCALARS");
+               ParseArrayPull($e, "r->", "NDR_SCALARS");
        } elsif (util::need_wire_pointer($e)) {
-               pidl "\tndr_pull_ptr(ndr, tree, hf_ptr, &ptr_$e->{NAME});\n";
-#              pidl "\tif (ptr_$e->{NAME}) {\n";
-#              pidl "\t\tNDR_ALLOC(ndr, $var_prefix$e->{NAME});\n";
-#              pidl "\t} else {\n";
-#              pidl "\t\t$var_prefix$e->{NAME} = NULL;\n";
-#              pidl "\t}\n";
+               pidl "\tndr_pull_ptr(ndr, tree, hf_ptr, &_ptr_$e->{NAME});\n";
+               pidl "\tif (_ptr_$e->{NAME}) {\n";
+               pidl "\t\tNDR_ALLOC(ndr, $var_prefix$e->{NAME});\n";
+               pidl "\t} else {\n";
+               pidl "\t\t$var_prefix$e->{NAME} = NULL;\n";
+               pidl "\t}\n";
        } elsif (util::need_alloc($e)) {
                # no scalar component
        } elsif (my $switch = util::has_property($e, "switch_is")) {
-               ParseElementPullSwitch($e, $ndr_flags, $switch);
+               ParseElementPullSwitch($e, $var_prefix, $ndr_flags, $switch);
        } elsif (defined $sub_size) {
                if (util::is_builtin_type($e->{TYPE})) {
-                       pidl "\tndr_pull_subcontext_fn(ndr, get_subtree(tree, \"$e->{NAME}\", ndr, ett_$e->{TYPE}), $sub_size, (ndr_pull_fn_t) ndr_pull_$e->{TYPE});\n";
+                       pidl "\tndr_pull_subcontext_fn(ndr, tree, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_fn_t) ndr_pull_$e->{TYPE});\n";
                } else {
-                       pidl "\tndr_pull_subcontext_flags_fn(ndr, get_subtree(tree, \"$e->{NAME}\", ndr, ett_$e->{TYPE}), $sub_size, (ndr_pull_flags_fn_t) ndr_pull_$e->{TYPE});\n";
+                       pidl "\tndr_pull_subcontext_flags_fn(ndr, tree, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_flags_fn_t) ndr_pull_$e->{TYPE});\n";
                }
-           } elsif (util::is_builtin_type($e->{TYPE})) {
-                       $needed{"hf_$e->{NAME}_$e->{TYPE}"} = {
-                           'name' => $e->{NAME},
-                           'type' => $e->{TYPE},
-                           'ft'   => type2ft($e->{TYPE}),
-                           'base' => type2base($e->{TYPE})
-                           };
-       
-               pidl "\tndr_pull_$e->{TYPE}(ndr, tree, hf_$e->{NAME}_$e->{TYPE}, &elt_$e->{NAME});\n";
+       } elsif (util::is_builtin_type($e->{TYPE})) {
+               pidl "\tndr_pull_$e->{TYPE}(ndr, tree, hf_$e->{NAME}_$e->{TYPE}, $cprefix$var_prefix$e->{NAME});\n";
        } else {
-               pidl "\tndr_pull_$e->{TYPE}(ndr, get_subtree(tree, \"$e->{NAME}\", ndr, ett_$e->{TYPE}), $ndr_flags);\n";
+               pidl "\tndr_pull_$e->{TYPE}(ndr, $ndr_flags, get_subtree(tree, \"$e->{NAME}\", ndr, ett_$e->{TYPE}), $cprefix$var_prefix$e->{NAME});\n";
        }
 
        end_flags($e);
@@ -368,9 +387,10 @@ sub ParseElementPullScalar($$)
 
 #####################################################################
 # parse buffers in a structure element - pull side
-sub ParseElementPullBuffer($$)
+sub ParseElementPullBuffer($$$)
 {
        my($e) = shift;
+       my($var_prefix) = shift;
        my($ndr_flags) = shift;
        my $cprefix = util::c_pull_prefix($e);
        my $sub_size = util::has_property($e, "subcontext");
@@ -386,33 +406,33 @@ sub ParseElementPullBuffer($$)
        start_flags($e);
 
        if (util::need_wire_pointer($e)) {
-               pidl "\tif (ptr_$e->{NAME}) {\n";
+               pidl "\tif ($var_prefix$e->{NAME}) {\n";
        }
            
        if (util::is_inline_array($e)) {
-               ParseArrayPull($e, "NDR_BUFFERS");
+               ParseArrayPull($e, "r->", "NDR_BUFFERS");
        } elsif (util::array_size($e)) {
-               ParseArrayPull($e, "NDR_SCALARS|NDR_BUFFERS");
+               ParseArrayPull($e, "r->", "NDR_SCALARS|NDR_BUFFERS");
        } elsif (my $switch = util::has_property($e, "switch_is")) {
                if ($e->{POINTERS}) {
-                       ParseElementPullSwitch($e, "NDR_SCALARS|NDR_BUFFERS", $switch);
+                       ParseElementPullSwitch($e, $var_prefix, "NDR_SCALARS|NDR_BUFFERS", $switch);
                } else {
-                       ParseElementPullSwitch($e, "NDR_BUFFERS", $switch);
+                       ParseElementPullSwitch($e, $var_prefix, "NDR_BUFFERS", $switch);
                }
        } elsif (defined $sub_size) {
                if ($e->{POINTERS}) {
                        if (util::is_builtin_type($e->{TYPE})) {
-                               pidl "\tndr_pull_subcontext_fn(ndr, get_subtree(tree, \"$e->{NAME}\", ndr, ett_$e->{TYPE}), $sub_size, _pull_$e->{TYPE});\n";
+                               pidl "\tndr_pull_subcontext_fn(ndr, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_fn_t) ndr_pull_$e->{TYPE});\n";
                        } else {
-                               pidl "\tndr_pull_subcontext_flags_fn(ndr, get_subtree(tree, \"$e->{NAME}\", ndr, ett_$e->{TYPE}), $sub_size, ndr_pull_$e->{TYPE});\n";
+                               pidl "\tndr_pull_subcontext_flags_fn(ndr, tree, $sub_size, $cprefix$var_prefix$e->{NAME}, (ndr_pull_flags_fn_t) ndr_pull_$e->{TYPE});\n";
                        }
                }
        } elsif (util::is_builtin_type($e->{TYPE})) {
-               pidl "\tndr_pull_$e->{TYPE}(ndr, tree, hf_$e->{NAME}_$e->{TYPE}, &elt_$e->{NAME});\n";
+               pidl "\t\tndr_pull_$e->{TYPE}(ndr, tree, hf_$e->{NAME}_$e->{TYPE}, $cprefix$var_prefix$e->{NAME});\n";
        } elsif ($e->{POINTERS}) {
-               pidl "\tndr_pull_$e->{TYPE}(ndr, get_subtree(tree, \"$e->{NAME}\", ndr, ett_$e->{TYPE}), NDR_SCALARS|NDR_BUFFERS);\n";
+               pidl "\t\tndr_pull_$e->{TYPE}(ndr, NDR_SCALARS|NDR_BUFFERS, get_subtree(tree, \"$e->{NAME}\", ndr, ett_$e->{TYPE}), $cprefix$var_prefix$e->{NAME});\n";
        } else {
-               pidl "\tndr_pull_$e->{TYPE}(ndr, get_subtree(tree, \"$e->{NAME}\", ndr, ett_$e->{TYPE}), $ndr_flags);\n";
+               pidl "\t\tndr_pull_$e->{TYPE}(ndr, $ndr_flags, get_subtree(tree, \"$e->{NAME}\", ndr, ett_$e->{TYPE}), $cprefix$var_prefix$e->{NAME});\n";
        }
 
        if (util::need_wire_pointer($e)) {
@@ -429,14 +449,6 @@ sub ParseStructPull($)
        my($struct) = shift;
        my $conform_e;
 
-       pidl "\tguint32 _U_ _offset, _U_ _length, _U_ _level;\n";
-
-       for my $e (@{$struct->{ELEMENTS}}) {
-           if (util::is_builtin_type($e->{TYPE})) {
-               pidl "\tg$e->{TYPE} elt_$e->{NAME};\n";
-           }
-       }
-
        if (! defined $struct->{ELEMENTS}) {
                return;
        }
@@ -449,7 +461,7 @@ sub ParseStructPull($)
        my $e = $struct->{ELEMENTS}[-1];
        if (defined $e->{ARRAY_LEN} && $e->{ARRAY_LEN} eq "*") {
                $conform_e = $e;
-               pidl "\tguint32 _conformant_size;\n";
+               pidl "\tuint32_t _conformant_size;\n";
                $conform_e->{CONFORMANT_SIZE} = "_conformant_size";
        }
 
@@ -457,26 +469,13 @@ sub ParseStructPull($)
        foreach my $e (@{$struct->{ELEMENTS}}) {
                if (util::need_wire_pointer($e) &&
                    !util::has_property($e, "relative")) {
-                       pidl "\tguint32 ptr_$e->{NAME};\n";
+                       pidl "\tuint32_t _ptr_$e->{NAME};\n";
                }
        }
 
-       pidl "\n";
-
-       # Some debugging stuff.  Put a note in the proto tree saying
-       # which function was called with what NDR flags.
-
-#      pidl "\tif ((ndr_flags & (NDR_SCALARS|NDR_BUFFERS)) == (NDR_SCALARS|NDR_BUFFERS))\n";
-#      pidl "\t\tproto_tree_add_text(tree, ndr->tvb, ndr->offset, 0, \"%s(NDR_SCALARS|NDR_BUFFERS)\", __FUNCTION__);\n";
-#      pidl "\telse if (ndr_flags & NDR_SCALARS)\n";
-#      pidl "\t\tproto_tree_add_text(tree, ndr->tvb, ndr->offset, 0, \"%s(NDR_SCALARS)\", __FUNCTION__);\n";
-#      pidl "\telse if (ndr_flags & NDR_BUFFERS)\n";
-#      pidl "\t\tproto_tree_add_text(tree, ndr->tvb, ndr->offset, 0, \"%s(NDR_BUFFERS)\", __FUNCTION__);\n";
-#      pidl "\n";
-
        start_flags($struct);
 
-       pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n\n";
+       pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
 
        pidl "\tndr_pull_struct_start(ndr);\n";
 
@@ -488,22 +487,23 @@ sub ParseStructPull($)
        pidl "\tndr_pull_align(ndr, $align);\n";
 
        foreach my $e (@{$struct->{ELEMENTS}}) {
-               ParseElementPullScalar($e, "NDR_SCALARS");
+               ParseElementPullScalar($e, "r->", "NDR_SCALARS");
        }       
 
-       pidl "\nbuffers:\n\n";
+       pidl "buffers:\n";
        pidl "\tif (!(ndr_flags & NDR_BUFFERS)) goto done;\n";
        foreach my $e (@{$struct->{ELEMENTS}}) {
-               ParseElementPullBuffer($e, "NDR_BUFFERS");
+               ParseElementPullBuffer($e, "r->", "NDR_BUFFERS");
        }
 
        pidl "\tndr_pull_struct_end(ndr);\n";
 
-       pidl "done: ;\n";
+       pidl "done:\n";
 
        end_flags($struct);
 }
 
+
 #####################################################################
 # parse a union - pull side
 sub ParseUnionPull($)
@@ -513,42 +513,33 @@ sub ParseUnionPull($)
 
        start_flags($e);
 
-       pidl "\titem = proto_tree_add_text(tree, ndr->tvb, ndr->offset, 0, \"$e->{PARENT}{NAME}\");\n";
-       pidl "\ttree = proto_item_add_subtree(item, ett_$e->{PARENT}{NAME});\n";        
-
        pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
 
        pidl "\tndr_pull_struct_start(ndr);\n";
 
-       foreach my $el (@{$e->{DATA}}) {
-               my $e2 = $el->{DATA};
-               if ($e2->{POINTERS}) {
-                       pidl "\tguint32 ptr_$e2->{NAME};\n";
-               }
-       }
-
 #      my $align = union_alignment($e);
 #      pidl "\tndr_pull_align(ndr, $align);\n";
 
        pidl "\tswitch (level) {\n";
        foreach my $el (@{$e->{DATA}}) {
                if ($el->{CASE} eq "default") {
-                       pidl "\t\tdefault: {\n";
+                       pidl "\tdefault: {\n";
                        $have_default = 1;
                } else {
                        pidl "\tcase $el->{CASE}: {\n";
                }
                if ($el->{TYPE} eq "UNION_ELEMENT") {
-                       ParseElementPullScalar($el->{DATA}, "NDR_SCALARS");
+                       my $e2 = $el->{DATA};
+                       if ($e2->{POINTERS}) {
+                               pidl "\t\tuint32_t _ptr_$e2->{NAME};\n";
+                       }
+                       ParseElementPullScalar($el->{DATA}, "r->", "NDR_SCALARS");
                }
-               pidl "\t\tbreak;\n\t}\n";
+               pidl "\tbreak; }\n\n";
        }
        if (! $have_default) {
-               pidl "\tdefault: {\n";
-               pidl "\t\tproto_tree_add_text(tree, ndr->tvb, ndr->offset, 0, \"Bad switch value %u\", level);\n";
-               pidl "\t\tif (check_col(ndr->pinfo->cinfo, COL_INFO))\n";
-               pidl "\t\t\tcol_append_fstr(ndr->pinfo->cinfo, COL_INFO, \", Bad switch value %u\", level);\n";
-               pidl "\t}\n";
+               pidl "\tdefault:\n";
+               pidl "\t\treturn; // ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
        }
        pidl "\t}\n";
        pidl "buffers:\n";
@@ -556,51 +547,25 @@ sub ParseUnionPull($)
        pidl "\tswitch (level) {\n";
        foreach my $el (@{$e->{DATA}}) {
                if ($el->{CASE} eq "default") {
-                       pidl "\tdefault: {\n";
+                       pidl "\tdefault:\n";
                } else {
-                       pidl "\tcase $el->{CASE}: {\n";
+                       pidl "\tcase $el->{CASE}:\n";
                }
                if ($el->{TYPE} eq "UNION_ELEMENT") {
-               ParseElementPullBuffer($el->{DATA}, "NDR_BUFFERS");
+                       ParseElementPullBuffer($el->{DATA}, "r->", "NDR_BUFFERS");
                }
-               pidl "\t\tbreak;\n\t}\n";
+               pidl "\tbreak;\n\n";
        }
        if (! $have_default) {
                pidl "\tdefault:\n";
-               pidl "\t\tproto_tree_add_text(tree, ndr->tvb, ndr->offset, 0, \"Bad switch value %u\", level);\n";
-               pidl "\t\tif (check_col(ndr->pinfo->cinfo, COL_INFO))\n";
-               pidl "\t\t\tcol_append_fstr(ndr->pinfo->cinfo, COL_INFO, \", 7Bad switch value %u\", level);\n";
+               pidl "\t\treturn; // ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);\n";
        }
        pidl "\t}\n";
        pidl "\tndr_pull_struct_end(ndr);\n";
        pidl "done:\n";
-       pidl "return;\n";
        end_flags($e);
 }
 
-#####################################################################
-# parse a enum - pull side
-sub ParseEnumPull($)
-{
-       my $enum = shift;
-
-       my $name;
-       my $ndx = 0;
-
-       for my $e (@{$enum->{ELEMENTS}}) {
-           if ($e =~ /([a-zA-Z0-9_]+)=([0-9x]+)/) {
-               $name = $1;
-               $ndx = $2;
-           } else {
-               $name = $e;
-           }
-           pidl "#define $name $ndx\n";
-           $ndx++;
-       }
-
-       pidl "\n";
-}
-
 #####################################################################
 # parse a type
 sub ParseTypePull($)
@@ -612,8 +577,6 @@ sub ParseTypePull($)
                    ParseStructPull($data);
                ($data->{TYPE} eq "UNION") &&
                    ParseUnionPull($data);
-               ($data->{TYPE} eq "ENUM") &&
-                   ParseEnumPull($data);
        }
 }
 
@@ -624,36 +587,32 @@ sub ParseTypedefPull($)
        my($e) = shift;
        my $static = fn_prefix($e);
 
-#      if (! $needed{"pull_$e->{NAME}"}) {
+       if (! $needed{"pull_$e->{NAME}"}) {
 #              print "pull_$e->{NAME} not needed\n";
-#              return;
-#      }
+               return;
+       }
 
        pidl "/*\n\n";
        pidl IdlDump::DumpTypedef($e);
        pidl "*/\n\n";
 
        if ($e->{DATA}->{TYPE} eq "STRUCT") {
-               pidl $static . "void ndr_pull_$e->{NAME}(struct e_ndr_pull *ndr, proto_tree *tree, int ndr_flags)";
+               pidl $static . "void ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, proto_tree *tree, struct $e->{NAME} *r)";
                pidl "\n{\n";
                ParseTypePull($e->{DATA});
+               pidl "\treturn;\n";
                pidl "}\n\n";
        }
 
        if ($e->{DATA}->{TYPE} eq "UNION") {
-               pidl $static . "void ndr_pull_$e->{NAME}(struct e_ndr_pull *ndr, proto_tree *tree, int ndr_flags, int level)";
+               pidl $static . "void ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, proto_tree *tree, uint16_t level, union $e->{NAME} *r)";
                pidl "\n{\n";
-               pidl "\tproto_item *item = NULL;\n";
                ParseTypePull($e->{DATA});
+               pidl "\treturn;\n";
                pidl "}\n\n";
        }
-
-       if ($e->{DATA}->{TYPE} eq "ENUM") {
-           ParseEnumPull($e->{DATA});
-       }
 }
 
-
 #####################################################################
 # parse a function element
 sub ParseFunctionElementPull($$)
@@ -663,23 +622,66 @@ sub ParseFunctionElementPull($$)
 
        if (util::array_size($e)) {
                if (util::need_wire_pointer($e)) {
-                       pidl "\tndr_pull_ptr(ndr, tree, hf_ptr, &ptr_$e->{NAME});\n";
-                       pidl "\tif (ptr_$e->{NAME}) {\n";
-                       pidl "\t\tguint32 " . find_size_var($e, util::array_size($e)) . ";\n";
+                       pidl "\tndr_pull_ptr(ndr, &_ptr_$e->{NAME});\n";
+                       pidl "\tif (_ptr_$e->{NAME}) {\n";
+               } elsif ($inout eq "out" && util::has_property($e, "ref")) {
+                       pidl "\tif (r->$inout.$e->{NAME}) {\n";
                } else {
                        pidl "\t{\n";
                }
-               ParseArrayPull($e, "NDR_SCALARS|NDR_BUFFERS");
+               ParseArrayPull($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
                pidl "\t}\n";
        } else {
+               if ($inout eq "out" && util::has_property($e, "ref")) {
+                       pidl "\tif (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {\n";
+                       pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});\n";
+                       pidl "\t}\n";
+               }
+               if ($inout eq "in" && util::has_property($e, "ref")) {
+                       pidl "\tNDR_ALLOC(ndr, r->in.$e->{NAME});\n";
+               }
 
-               ParseElementPullScalar($e, "NDR_SCALARS|NDR_BUFFERS");
+               ParseElementPullScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
                if ($e->{POINTERS}) {
-                       ParseElementPullBuffer($e, "NDR_SCALARS|NDR_BUFFERS");
+                       ParseElementPullBuffer($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
+               }
+       }
+}
+
+
+############################################################
+# allocate ref variables
+sub AllocateRefVars($)
+{
+       my $e = shift;
+       my $asize = util::array_size($e);
+
+       # note that if the variable is also an "in"
+       # variable then we copy the initial value from
+       # the in side
+
+       if (!defined $asize) {
+               # its a simple variable
+               pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});\n";
+               if (util::has_property($e, "in")) {
+                       pidl "\t*r->out.$e->{NAME} = *r->in.$e->{NAME};\n";
+               } else {
+                       pidl "\tZERO_STRUCTP(r->out.$e->{NAME});\n";
                }
+               return;
+       }
+
+       # its an array
+       my $size = find_size_var($e, $asize, "r->out.");
+       pidl "\tNDR_ALLOC_N(ndr, r->out.$e->{NAME}, MAX(1, $size));\n";
+       if (util::has_property($e, "in")) {
+               pidl "\tmemcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));\n";
+       } else {
+               pidl "\tmemset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));\n";
        }
 }
 
+
 #####################################################################
 # parse a function
 sub ParseFunctionPull($)
@@ -687,84 +689,78 @@ sub ParseFunctionPull($)
        my($fn) = shift;
        my $static = fn_prefix($fn);
 
-       # Comment displaying IDL for this function
-       
        pidl "/*\n\n";
        pidl IdlDump::DumpFunction($fn);
        pidl "*/\n\n";
 
-       # Request
+       # request function
+       pidl "int $fn->{NAME}_rqst(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)\n{\n";
 
-       pidl $static . "int $fn->{NAME}_rqst(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)\n";
-       pidl "{\n";
-       pidl "\tstruct e_ndr_pull *ndr = ndr_pull_init(tvb, offset, pinfo, drep);\n";
-       pidl "\tguint32 _U_ _offset, _U_ _length, _U_ _level;\n";
+       pidl "\tstruct ndr_pull *ndr = ndr_pull_init(tvb, offset, pinfo, drep);\n";
+       pidl "\tstruct $fn->{NAME} *r = (struct $fn->{NAME} *)g_malloc(sizeof(struct $fn->{NAME}));\n\n";
 
        # declare any internal pointers we need
        foreach my $e (@{$fn->{DATA}}) {
+               if (util::need_wire_pointer($e) &&
+                   util::has_property($e, "in")) {
+                       pidl "\tuint32_t _ptr_$e->{NAME};\n";
+               }
+       }
 
-           if (util::has_property($e, "in")) {
+       pidl "\n\tZERO_STRUCTP(r);\n\n";
 
-               if (util::need_wire_pointer($e)) {
-                   pidl "\tguint32 ptr_$e->{NAME};\n";
-               }
-               
-               if (util::is_builtin_type($e->{TYPE})) {
-                   pidl "\tg$e->{TYPE} elt_$e->{NAME};\n";
+       # auto-init the out section of a structure. I originally argued that
+       # this was a bad idea as it hides bugs, but coping correctly
+       # with initialisation and not wiping ref vars is turning
+       # out to be too tricky (tridge)
+       foreach my $e (@{$fn->{DATA}}) {
+               if (util::has_property($e, "out")) {
+                       pidl "\tZERO_STRUCT(r->out);\n\n";
+                       last;
                }
-           }
        }
 
-       pidl "\n";
-
        foreach my $e (@{$fn->{DATA}}) {
                if (util::has_property($e, "in")) {
                        ParseFunctionElementPull($e, "in");
-               }               
+               }
+               # we need to allocate any reference output variables, so that
+               # a dcerpc backend can be sure they are non-null
+               if (util::has_property($e, "out") && util::has_property($e, "ref")) {
+                       AllocateRefVars($e);
+               }
        }
 
-       pidl "\toffset = ndr->offset;\n";
-       pidl "\tndr_pull_free(ndr);\n";
-       pidl "\n";
-       pidl "\treturn offset;\n";
+       pidl "\n\treturn ndr->offset;\n";
        pidl "}\n\n";
 
-       # Response
+       # response function
+       pidl "int $fn->{NAME}_resp(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)\n{\n";
+
+       pidl "\tstruct ndr_pull *ndr = ndr_pull_init(tvb, offset, pinfo, drep);\n";
+       pidl "\tstruct $fn->{NAME} *r = (struct $fn->{NAME} *)g_malloc(sizeof(struct $fn->{NAME}));\n\n";
 
-       pidl $static . "int $fn->{NAME}_resp(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)\n";
-       pidl "{\n";
-       pidl "\tstruct e_ndr_pull *ndr = ndr_pull_init(tvb, offset, pinfo, drep);\n";
        # declare any internal pointers we need
        foreach my $e (@{$fn->{DATA}}) {
-
-           if (util::has_property($e, "out")) {
-
-               if (util::need_wire_pointer($e)) {
-                   pidl "\tguint32 ptr_$e->{NAME};\n";
-               }
-
-               if (util::is_builtin_type($e->{TYPE})) {
-                   pidl "\tg$e->{TYPE} elt_$e->{NAME};\n";
+               if (util::need_wire_pointer($e) &&
+                   util::has_property($e, "out")) {
+                       pidl "\tuint32_t _ptr_$e->{NAME};\n";
                }
-           }
        }
 
-       pidl "\n";
+       pidl "\tZERO_STRUCTP(r);\n\n";
 
        foreach my $e (@{$fn->{DATA}}) {
                if (util::has_property($e, "out")) {
                        ParseFunctionElementPull($e, "out");
-               }               
+               }
        }
 
        if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
-               pidl "\tndr_pull_$fn->{RETURN_TYPE}(ndr, tree, hf_rc, NULL);\n";
+               pidl "\tndr_pull_$fn->{RETURN_TYPE}(ndr, tree, hf_rc, &r->out.result);\n";
        }
 
-       pidl "\toffset = ndr->offset;\n";
-       pidl "\tndr_pull_free(ndr);\n";
-       pidl "\n";
-       pidl "\treturn offset;\n";
+       pidl "\n\treturn ndr->offset;\n";
        pidl "}\n\n";
 }
 
@@ -774,18 +770,8 @@ sub FunctionTable($)
 {
        my($interface) = shift;
        my($data) = $interface->{DATA};
-       my $count = 0;
-       my $uname = uc $interface->{NAME};
-
-       foreach my $d (@{$data}) {
-               if ($d->{TYPE} eq "FUNCTION") { $count++; }
-       }
-
-       if ($count == 0) {
-               return;
-       }
 
-       pidl "static dcerpc_sub_dissector dcerpc_" . $interface->{NAME} . "_dissectors[] = {\n";
+       pidl "static dcerpc_sub_dissector dcerpc_dissectors[] = {\n";
        my $num = 0;
        foreach my $d (@{$data}) {
                if ($d->{TYPE} eq "FUNCTION") {
@@ -810,7 +796,7 @@ sub ParseInterface($)
        my($data) = $interface->{DATA};
 
        foreach my $d (@{$data}) {
-               if ($d->{TYPE} eq "TYPEDEF") {
+               if ($d->{TYPE} eq "TYPEDEF") {
                    $structs{$d->{NAME}} = $d;
            }
        }
@@ -823,6 +809,7 @@ sub ParseInterface($)
        }
 
        FunctionTable($interface);
+
 }
 
 sub type2ft($)
@@ -847,70 +834,74 @@ sub type2base($)
 sub NeededFunction($)
 {
        my $fn = shift;
+       $needed{"pull_$fn->{NAME}"} = 1;
        foreach my $e (@{$fn->{DATA}}) {
-
-           if (util::is_scalar_type($e->{TYPE})) {
-
-               $needed{"hf_$e->{NAME}_$e->{TYPE}"} = {
-                   'name' => $e->{NAME},
-                   'type' => $e->{TYPE},
-                   'ft'   => type2ft($e->{TYPE}),
-                   'base' => type2base($e->{TYPE})
-                   };
                $e->{PARENT} = $fn;
-           } else {
-               $needed{"ett_$e->{TYPE}"} = 1;
-           }
+               $needed{"pull_$e->{TYPE}"} = 1;
+
+               if (util::is_scalar_type($e->{TYPE})) {
+                   $needed{"hf_$e->{NAME}_$e->{TYPE}"} = {
+                       'name' => $e->{NAME},
+                       'type' => $e->{TYPE},
+                       'ft'   => type2ft($e->{TYPE}),
+                       'base' => type2base($e->{TYPE})
+                       };
+                   $e->{PARENT} = $fn;
+               } else {
+                   $needed{"ett_$e->{TYPE}"} = 1;
+               }
        }
 }
 
 sub NeededTypedef($)
 {
        my $t = shift;
-
        if (util::has_property($t->{DATA}, "public")) {
                $needed{"pull_$t->{NAME}"} = 1;
        }
 
        if ($t->{DATA}->{TYPE} eq "STRUCT") {
 
-           $needed{"ett_$t->{NAME}"} = 1;
-
-               for my $e (@{$t->{DATA}->{ELEMENTS}}) {
-
-                   if (util::is_scalar_type($e->{TYPE})) {
-
-                       $needed{"hf_$e->{NAME}_$e->{TYPE}"} = {
-                           'name' => $e->{NAME},
-                           'type' => $e->{TYPE},
-                           'ft'   => type2ft($e->{TYPE}),
-                           'base' => type2base($e->{TYPE})
-                           };
-                       
-                       $e->{PARENT} = $t->{DATA};
-
-                       if ($needed{"pull_$t->{NAME}"}) {
-                           $needed{"pull_$e->{TYPE}"} = 1;
-                       }
-                   } else {
-                       
-                       $needed{"ett_$e->{TYPE}"} = 1;
-
+           for my $e (@{$t->{DATA}->{ELEMENTS}}) {
+               $e->{PARENT} = $t->{DATA};
+               if ($needed{"pull_$t->{NAME}"}) {
+                   $needed{"pull_$e->{TYPE}"} = 1;
+               }
+           
+               if (util::is_scalar_type($e->{TYPE})) {
+               
+                   $needed{"hf_$e->{NAME}_$e->{TYPE}"} = {
+                       'name' => $e->{NAME},
+                       'type' => $e->{TYPE},
+                       'ft'   => type2ft($e->{TYPE}),
+                       'base' => type2base($e->{TYPE})
+                       };
+                   
+                   $e->{PARENT} = $t->{DATA};
+                   
+                   if ($needed{"pull_$t->{NAME}"}) {
+                       $needed{"pull_$e->{TYPE}"} = 1;
                    }
+               } else {
+                   
+                   $needed{"ett_$e->{TYPE}"} = 1;
+                   
                }
+           }
        }
-       if ($t->{DATA}->{TYPE} eq "UNION") {
-
-           $needed{"ett_$t->{NAME}"} = 1;
 
+       if ($t->{DATA}->{TYPE} eq "UNION") {
                for my $e (@{$t->{DATA}->{DATA}}) {
                        $e->{PARENT} = $t->{DATA};
                        if ($e->{TYPE} eq "UNION_ELEMENT") {
                                if ($needed{"pull_$t->{NAME}"}) {
                                        $needed{"pull_$e->{DATA}->{TYPE}"} = 1;
                                }
+                               $needed{"ett_$e->{DATA}{TYPE}"} = 1;
                        }
                }
+
+           $needed{"ett_$t->{NAME}"} = 1;
        }
 }
 
@@ -930,6 +921,20 @@ sub BuildNeeded($)
        }
 }
 
+#####################################################################
+# parse the interface definitions
+sub ModuleHeader($)
+{
+    my($h) = shift;
+
+    $if_uuid = $h->{PROPERTIES}->{uuid};
+    $if_version = $h->{PROPERTIES}->{version};
+    $if_endpoints = $h->{PROPERTIES}->{endpoints};
+}
+
+#####################################################################
+# Generate a header file that contains function prototypes for 
+# structs and typedefs.
 sub ParseHeader($$)
 {
        my($idl) = shift;
@@ -939,21 +944,24 @@ sub ParseHeader($$)
 
        pidl "/* parser auto-generated by pidl */\n\n";
 
+       pidl "#include \"ndr_$module.h\"\n\n";
+
        foreach my $x (@{$idl}) {
            if ($x->{TYPE} eq "INTERFACE") { 
                foreach my $d (@{$x->{DATA}}) {
 
-                   # Make prototypes for [public] push/pull functions
+                   # Make prototypes for [public] structures and
+                   # unions.
 
                    if ($d->{TYPE} eq "TYPEDEF" and 
                        util::has_property($d->{DATA}, "public")) {
                        
                        if ($d->{DATA}{TYPE} eq "STRUCT") { 
-                           pidl "void ndr_pull_$d->{NAME}(struct e_ndr_pull *ndr, proto_tree *tree, int ndr_flags);\n\n";
+                           pidl "void ndr_pull_$d->{NAME}(struct ndr_pull *ndr, int ndr_flags, proto_tree *tree, struct $d->{NAME} *r);\n\n";
                        }
 
                        if ($d->{DATA}{TYPE} eq "UNION") {
-                           pidl "void ndr_pull_$d->{NAME}(struct e_ndr_pull *ndr, proto_tree *tree, int ndr_flags, int level);\n";
+                           pidl "void ndr_pull_$d->{NAME}(struct ndr_pull *ndr, int ndr_flags, proto_tree *tree, struct $d->{NAME} *r, uint16 level);\n\n";
                        }
                    }
                }
@@ -970,38 +978,35 @@ sub Parse($$)
        my($idl) = shift;
        my($filename) = shift;
 
-       %needed = ();
+       %needed = ();           # Clear after generating header file
 
        open(OUT, ">$filename") || die "can't open $filename";    
 
+       # Look for name of module
+
        foreach my $x (@{$idl}) {
-               if ($x->{TYPE} eq "INTERFACE") { 
-                   $module = $x->{NAME};
-                   BuildNeeded($x);
-               }
-           }
 
+           ($x->{TYPE} eq "MODULEHEADER") && ModuleHeader($x);
+               
+           if ($x->{TYPE} eq "INTERFACE") { 
+               $module = $x->{NAME};
+               BuildNeeded($x);
+           }
+       }
+       
        pidl "/* parser auto-generated by pidl */\n\n";
-       pidl "#ifdef HAVE_CONFIG_H\n";
-       pidl "#include \"config.h\"\n";
-       pidl "#endif\n\n";
-
-       pidl "#include \"packet-dcerpc.h\"\n";
-       pidl "#include \"packet-dcerpc-nt.h\"\n\n";
-       pidl "#include \"packet-dcerpc-eparser.h\"\n\n";
+       pidl "#include \"eparser.h\"\n\n";
 
        pidl "extern const value_string NT_errors[];\n\n";
 
-       pidl "static gint ett_dcerpc_$module = -1;\n\n";
-
        pidl "static int hf_opnum = -1;\n";
        pidl "static int hf_rc = -1;\n";
        pidl "static int hf_ptr = -1;\n";
        pidl "static int hf_array_size = -1;\n";
        pidl "static int hf_array_offset = -1;\n";
        pidl "static int hf_array_length = -1;\n";
-       pidl "static int hf_conformant_size = -1;\n";
        pidl "static int hf_level = -1;\n";
+       pidl "static int hf_conformant_size = -1;\n";
 
        # Declarations for hf variables
 
@@ -1014,40 +1019,45 @@ sub Parse($$)
        # Declarations for ett variables
 
        foreach my $y (keys(%needed)) {
-               
            pidl "static gint $y = -1;\n", if $y =~ /^ett_/;
        }
 
        pidl "\n";
 
-       for my $x (@{$idl}) {
-           ParseInterface($x);
-       }
+       foreach my $x (@{$idl}) {
+               ($x->{TYPE} eq "MODULEHEADER") && 
+                   ModuleHeader($x);
 
-       # Only perform module initialisation if we found a uuid
-       
-       for my $x (@{$idl}) {
-               pidl "static int proto_dcerpc_" . $x->{NAME} ." = -1;\n\n";
-               if ((my $if_uuid = $x->{PROPERTIES}->{uuid})) {
-                       pidl "static e_uuid_t uuid_dcerpc_" . $x->{NAME} ." = {\n";
-                       pidl "\t0x" . substr($if_uuid, 0, 8);
-                       pidl ", 0x" . substr($if_uuid, 9, 4);
-                       pidl ", 0x" . substr($if_uuid, 14, 4) . ",\n";
-                       pidl "\t{ 0x" . substr($if_uuid, 19, 2);
-                       pidl ", 0x" . substr($if_uuid, 21, 2);
-                       pidl ", 0x" . substr($if_uuid, 24, 2);
-                       pidl ", 0x" . substr($if_uuid, 26, 2);
-                       pidl ", 0x" . substr($if_uuid, 28, 2);
-                       pidl ", 0x" . substr($if_uuid, 30, 2);
-                       pidl ", 0x" . substr($if_uuid, 32, 2);
-                       pidl ", 0x" . substr($if_uuid, 34, 2) . " }\n";
-                       pidl "};\n\n";
-
-                       pidl "static guint16 ver_dcerpc_" . $x->{NAME} . " = " . $x->{PROPERTIES}->{version}. ";\n\n";
+               if ($x->{TYPE} eq "INTERFACE") { 
+                       BuildNeeded($x);
+                       ParseInterface($x);
                }
        }
 
-       pidl "void proto_register_dcerpc_$module(void)\n";
+       pidl "int proto_dcerpc_pidl_$module = -1;\n\n";
+
+       pidl "static gint ett_dcerpc_$module = -1;\n\n";
+
+       if (defined($if_uuid)) {
+
+           pidl "static e_uuid_t uuid_dcerpc_$module = {\n";
+           pidl "\t0x" . substr($if_uuid, 0, 8);
+           pidl ", 0x" . substr($if_uuid, 9, 4);
+           pidl ", 0x" . substr($if_uuid, 14, 4) . ",\n";
+           pidl "\t{ 0x" . substr($if_uuid, 19, 2);
+           pidl ", 0x" . substr($if_uuid, 21, 2);
+           pidl ", 0x" . substr($if_uuid, 24, 2);
+           pidl ", 0x" . substr($if_uuid, 26, 2);
+           pidl ", 0x" . substr($if_uuid, 28, 2);
+           pidl ", 0x" . substr($if_uuid, 30, 2);
+           pidl ", 0x" . substr($if_uuid, 32, 2);
+           pidl ", 0x" . substr($if_uuid, 34, 2) . " }\n";
+           pidl "};\n\n";
+
+           pidl "static guint16 ver_dcerpc_$module = " . $if_version . ";\n\n";
+       }
+
+       pidl "void proto_register_dcerpc_pidl_$module(void)\n";
        pidl "{\n";
 
        pidl "\tstatic hf_register_info hf[] = {\n";
@@ -1057,10 +1067,10 @@ sub Parse($$)
        pidl "\t{ &hf_array_size, { \"Array size\", \"$module.array_size\", FT_UINT32, BASE_DEC, NULL, 0x0, \"Array size\", HFILL }},\n";
        pidl "\t{ &hf_array_offset, { \"Array offset\", \"$module.array_offset\", FT_UINT32, BASE_DEC, NULL, 0x0, \"Array offset\", HFILL }},\n";
        pidl "\t{ &hf_array_length, { \"Array length\", \"$module.array_length\", FT_UINT32, BASE_DEC, NULL, 0x0, \"Array length\", HFILL }},\n";
-       pidl "\t{ &hf_conformant_size, { \"Conformant size\", \"$module.conformant_size\", FT_UINT32, BASE_DEC, NULL, 0x0, \"Conformant size\", HFILL }},\n";
-       pidl "\t{ &hf_level, { \"Level\", \"$module.level\", FT_UINT32, BASE_DEC, NULL, 0x0, \"Level\", HFILL }},\n";
        pidl "\t{ &hf_ptr, { \"Pointer\", \"$module.ptr\", FT_UINT32, BASE_HEX, NULL, 0x0, \"Pointer\", HFILL }},\n";
-       
+       pidl "\t{ &hf_level, { \"Level\", \"$module.level\", FT_UINT32, BASE_DEC, NULL, 0x0, \"Level\", HFILL }},\n";
+       pidl "\t{ &hf_conformant_size, { \"Conformant size\", \"$module.conformant_size\", FT_UINT32, BASE_DEC, NULL, 0x0, \"Conformant size\", HFILL }},\n";
+
        foreach my $x (keys(%needed)) {
            next, if !($x =~ /^hf_/);
            pidl "\t{ &$x,\n";
@@ -1076,33 +1086,31 @@ sub Parse($$)
        }
        pidl "\t};\n\n";
        
-       for my $x (@{$idl}) {
-               if (defined($x->{PROPERTIES}->{uuid})) {
-                       $module = $x->{NAME};
+       if (defined($if_uuid)) {
 
-                       pidl "\tproto_dcerpc_$module = proto_register_protocol(\"$module\", \"$module\", \"$module\");\n\n";
+           pidl "\tproto_dcerpc_pidl_$module = proto_register_protocol(\"pidl_$module\", \"pidl_$module\", \"pidl_$module\");\n\n";
 
-                       pidl "\tproto_register_field_array(proto_dcerpc_$module, hf, array_length (hf));\n";
-                       pidl "\tproto_register_subtree_array(ett, array_length(ett));\n";
+           pidl "\tproto_register_field_array(proto_dcerpc_pidl_$module, hf, array_length (hf));\n";
+           pidl "\tproto_register_subtree_array(ett, array_length(ett));\n";
 
-                       pidl "}\n\n";
+           pidl "}\n\n";
 
-                       pidl "void proto_reg_handoff_dcerpc_$module(void)\n";
-                       pidl "{\n";
-                       pidl "\tdcerpc_init_uuid(proto_dcerpc_$module, ett_dcerpc_$module, \n";
-                       pidl "\t\t&uuid_dcerpc_$module, ver_dcerpc_$module, \n";
-                       pidl "\t\tdcerpc_" . $module . "_dissectors, hf_opnum);\n";
-                       pidl "}\n";
+           pidl "void proto_reg_handoff_dcerpc_pidl_$module(void)\n";
+           pidl "{\n";
+           pidl "\tdcerpc_init_uuid(proto_dcerpc_pidl_$module, ett_dcerpc_$module, \n";
+           pidl "\t\t&uuid_dcerpc_$module, ver_dcerpc_$module, \n";
+           pidl "\t\tdcerpc_dissectors, hf_opnum);\n";
+           pidl "}\n";
 
-               } else {
+       } else {
 
-                       pidl "\tint proto_dcerpc;\n\n";
-                       pidl "\tproto_dcerpc = proto_get_id_by_filter_name(\"dcerpc\");\n";
-                       pidl "\tproto_register_field_array(proto_dcerpc, hf, array_length(hf));\n";
-                       pidl "\tproto_register_subtree_array(ett, array_length(ett));\n";
+           pidl "\tint proto_dcerpc;\n\n";
+           pidl "\tproto_dcerpc = proto_get_id_by_filter_name(\"dcerpc\");\n";
+           pidl "\tproto_register_field_array(proto_dcerpc, hf, array_length(hf));\n";
+           pidl "\tproto_register_subtree_array(ett, array_length(ett));\n";
+
+           pidl "}\n";
 
-                       pidl "}\n";
-               }
        }
 
        close(OUT);