}
if ($size =~ /ndr->|\(/) {
- return $size;
+ return $size;
}
my $prefix = "";
}
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";
if (defined $e->{CONFORMANT_SIZE}) {
$alloc_size = $e->{CONFORMANT_SIZE};
- pidl "//\tif ($size > $alloc_size) {\n";
- pidl "//\t\treturn ndr_pull_error(ndr, \"Bad conformant size %u should be %u\", $alloc_size, $size);\n";
- pidl "//\t}\n";
+ pidl "\tif ($size > $alloc_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";
+ 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\tguint32 _array_size;\n\n";
- pidl "\t\tndr_pull_uint32(ndr, subtree, hf_array_size, &_array_size);\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\t// if (!(ndr->flags & LIBNDR_FLAG_REF_ALLOC) && _array_size != $size) {\n";
+ pidl "\t\tif (!(ndr->flags & LIBNDR_FLAG_REF_ALLOC) && _array_size != $size) {\n";
} else {
- pidl "\t\t// if ($size != _array_size) {\n";
+ pidl "\t\tif ($size != _array_size) {\n";
}
- pidl "\t\t\t// return ndr_pull_error(ndr, \"Bad array size %u should be %u\", _array_size, $size);\n";
- pidl "\t\t// }\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";
}
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";
+ 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";
+ 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 (my $length = util::has_property($e, "length_is")) {
$length = find_size_var($e, $length, $var_prefix);
- pidl "\t\tguint32 _offset, _length;\n";
- pidl "\t\tndr_pull_uint32(ndr, subtree, hf_array_offset, &_offset);\n";
- pidl "\t\tndr_pull_uint32(ndr, subtree, hf_array_length, &_length);\n";
- pidl "//\t\tif (_offset != 0) return ndr_pull_error(ndr, \"Bad array offset 0x%08x\", _offset);\n";
- pidl "\t\t//if (_length > $size || _length != $length) return ndr_pull_error(ndr, \"Bad array length 0x%08x > size 0x%08x\", _offset, $size);\n\n";
+ 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 "\t\tndr_pull_array_$e->{TYPE}(ndr, subtree, 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 "\t\tndr_pull_array(ndr, subtree, $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";
if (!defined $utype ||
!util::has_property($utype->{DATA}, "nodiscriminant")) {
my $e2 = find_sibling($e, $switch);
- pidl "\tguint16 _level;\n";
pidl "\tif (($ndr_flags) & NDR_SCALARS) {\n";
- pidl "\t\tndr_pull_level(ndr, subtree, 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\t//if (_level != $switch_var) {\n";
+ pidl "\t\tif (_level != $switch_var) {\n";
}
- pidl "\t\t\t//return ndr_pull_error(ndr, \"Bad switch value %u in $e->{NAME}\");\t\t}\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 }\n";
+ pidl "else { $switch_var = _level; }\n";
}
pidl "\t}\n";
}
my $sub_size = util::has_property($e, "subcontext");
if (defined $sub_size) {
- pidl "\tndr_pull_subcontext_union_fn(ndr, subtree, $sub_size, $switch_var, $cprefix$var_prefix$e->{NAME}, (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, subtree, $ndr_flags, _level);\n";
+ pidl "\tndr_pull_$e->{TYPE}(ndr, $ndr_flags, tree, $switch_var, $cprefix$var_prefix$e->{NAME});\n";
}
start_flags($e);
if (util::has_property($e, "relative")) {
- pidl "\tndr_pull_relative(ndr, subtree, 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, "r->", "NDR_SCALARS");
} elsif (util::need_wire_pointer($e)) {
- pidl "\tndr_pull_ptr(ndr, subtree, 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, $var_prefix, $ndr_flags, $switch);
} elsif (defined $sub_size) {
if (util::is_builtin_type($e->{TYPE})) {
- pidl "\tndr_pull_subcontext_fn(ndr, subtree, $sub_size, $cprefix$var_prefix$e->{NAME}, (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, subtree, $sub_size, $cprefix$var_prefix$e->{NAME}, (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})) {
- pidl "\tndr_pull_$e->{TYPE}(ndr, subtree, 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, subtree, $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);
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)) {
} elsif (defined $sub_size) {
if ($e->{POINTERS}) {
if (util::is_builtin_type($e->{TYPE})) {
- pidl "\tndr_pull_subcontext_fn(ndr, subtree, $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, subtree, $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 "\t\tndr_pull_$e->{TYPE}(ndr, subtree, 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 "\t\tndr_pull_$e->{TYPE}(ndr, subtree, 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 "\t\tndr_pull_$e->{TYPE}(ndr, subtree, $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)) {
my($struct) = shift;
my $conform_e;
- for my $x (@{$struct->{ELEMENTS}}) {
- pidl "\tg$x->{TYPE} elt_$x->{NAME};\n",
- if util::is_builtin_type($x->{TYPE});
- }
-
if (! defined $struct->{ELEMENTS}) {
return;
}
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";
}
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";
}
}
start_flags($struct);
- pidl "\titem = proto_tree_add_text(tree, ndr->tvb, ndr->offset, 0, \"$struct->{PARENT}{NAME}\");\n";
- pidl "\tsubtree = proto_item_add_subtree(item, ett_$struct->{PARENT}{NAME});\n";
-
pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
pidl "\tndr_pull_struct_start(ndr);\n";
if (defined $conform_e) {
- pidl "\tndr_pull_uint32(ndr, subtree, hf_conformant_size, &$conform_e->{CONFORMANT_SIZE});\n";
+ pidl "\tndr_pull_uint32(ndr, tree, hf_conformant_size, &$conform_e->{CONFORMANT_SIZE});\n";
}
my $align = struct_alignment($struct);
pidl "\tndr_pull_struct_end(ndr);\n";
- pidl "done: ;\n";
+ pidl "done:\n";
end_flags($struct);
}
+
#####################################################################
# parse a union - pull side
sub ParseUnionPull($)
start_flags($e);
- pidl "\titem = proto_tree_add_text(tree, ndr->tvb, ndr->offset, 0, \"$e->{PARENT}{NAME}\");\n";
- pidl "\tsubtree = 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";
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") {
my $e2 = $el->{DATA};
if ($e2->{POINTERS}) {
- pidl "\t\tguint32 ptr_$e2->{NAME};\n";
+ 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\t// return ndr_pull_error(ndr, \"Bad 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 "buffers:\n";
if ($el->{TYPE} eq "UNION_ELEMENT") {
ParseElementPullBuffer($el->{DATA}, "r->", "NDR_BUFFERS");
}
- pidl "\t\tbreak;\n\n";
+ pidl "\tbreak;\n\n";
}
if (! $have_default) {
pidl "\tdefault:\n";
- pidl "\t\t// return ndr_pull_error(ndr, \"Bad 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";
end_flags($e);
}
-#####################################################################
-# parse a enum - pull side
-sub ParseEnumPull($)
-{
- my $e = shift;
-
- my $name;
- my $ndx = 0;
-
- for my $x (@{$e->{ELEMENTS}}) {
- if ($x =~ /([a-zA-Z_]+)=([0-9]+)/) {
- $name = $1;
- $ndx = $2;
- } else {
- $name = $x;
- }
- pidl "#define $name $ndx\n";
- $ndx++;
- }
-
- pidl "\n";
-}
-
#####################################################################
# parse a type
sub ParseTypePull($)
ParseStructPull($data);
($data->{TYPE} eq "UNION") &&
ParseUnionPull($data);
- ($data->{TYPE} eq "ENUM") &&
- ParseEnumPull($data);
}
}
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 gint ett_$e->{NAME} = -1;\n\n";
- 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";
- pidl "\tproto_item *item = NULL;\n";
- pidl "\tproto_tree *subtree = NULL;\n";
ParseTypePull($e->{DATA});
+ pidl "\treturn;\n";
pidl "}\n\n";
}
if ($e->{DATA}->{TYPE} eq "UNION") {
- pidl "static gint ett_$e->{NAME} = -1;\n\n";
- 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";
- pidl "\tproto_tree *subtree = 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($$)
if (util::array_size($e)) {
if (util::need_wire_pointer($e)) {
- pidl "\tndr_pull_ptr(ndr, &ptr_$e->{NAME});\n";
- pidl "\tif (ptr_$e->{NAME}) {\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";
} 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";
+ 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";
+ pidl "\tNDR_ALLOC(ndr, r->in.$e->{NAME});\n";
}
ParseElementPullScalar($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($)
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 "\tproto_tree *subtree = tree;\n";
- pidl "\tstruct e_ndr_pull *ndr = ndr_pull_init(tvb, offset, pinfo, drep);\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 "\tguint32 ptr_$e->{NAME};\n";
+ pidl "\tuint32_t _ptr_$e->{NAME};\n";
+ }
+ }
+
+ pidl "\n\tZERO_STRUCTP(r);\n\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 "\tg$e->{TYPE} elt_$e->{NAME};\n",
- if util::is_builtin_type($e->{TYPE});
}
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 "\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 $static . "int $fn->{NAME}_resp(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)\n";
- pidl "{\n";
- pidl "\tproto_tree *subtree = tree;\n";
- pidl "\tstruct e_ndr_pull *ndr = ndr_pull_init(tvb, offset, pinfo, drep);\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) &&
+ if (util::need_wire_pointer($e) &&
util::has_property($e, "out")) {
- pidl "\tguint32 ptr_$e->{NAME};\n";
+ pidl "\tuint32_t _ptr_$e->{NAME};\n";
}
- pidl "\tg$e->{TYPE} elt_$e->{NAME};\n",
- if util::is_builtin_type($e->{TYPE});
}
+ 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, subtree, hf_rc);\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 "\treturn offset;\n";
+ pidl "\n\treturn ndr->offset;\n";
pidl "}\n\n";
}
{
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_dissectors[] = {\n";
my $num = 0;
my($data) = $interface->{DATA};
foreach my $d (@{$data}) {
- if ($d->{TYPE} eq "TYPEDEF") {
+ if ($d->{TYPE} eq "TYPEDEF") {
$structs{$d->{NAME}} = $d;
}
}
}
FunctionTable($interface);
+
}
sub type2ft($)
sub NeededFunction($)
{
my $fn = shift;
+ $needed{"pull_$fn->{NAME}"} = 1;
foreach my $e (@{$fn->{DATA}}) {
- $needed{"hf_$e->{NAME}_$e->{TYPE}"} = {
- 'name' => $e->{NAME},
- 'type' => $e->{TYPE},
- 'ft' => type2ft($e->{TYPE}),
- 'base' => type2base($e->{TYPE})
- };
$e->{PARENT} = $fn;
+ $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}}) {
-
- $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;
- }
+ 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;
}
}
$if_endpoints = $h->{PROPERTIES}->{endpoints};
}
+#####################################################################
+# Generate a header file that contains function prototypes for
+# structs and typedefs.
sub ParseHeader($$)
{
my($idl) = shift;
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] 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";
+ 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";
}
}
}
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}) {
- ($x->{TYPE} eq "MODULEHEADER") &&
- ModuleHeader($x);
+
+ ($x->{TYPE} eq "MODULEHEADER") && ModuleHeader($x);
- if ($x->{TYPE} eq "INTERFACE") {
- $module = $x->{NAME};
- BuildNeeded($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 int proto_dcerpc_$module = -1;\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
pidl "\n";
- for my $x (@{$idl}) {
- ParseInterface($x);
+ # Declarations for ett variables
+
+ foreach my $y (keys(%needed)) {
+ pidl "static gint $y = -1;\n", if $y =~ /^ett_/;
}
- # Only perform module initialisation if we found a uuid
+ pidl "\n";
+
+ foreach my $x (@{$idl}) {
+ ($x->{TYPE} eq "MODULEHEADER") &&
+ ModuleHeader($x);
+
+ if ($x->{TYPE} eq "INTERFACE") {
+ BuildNeeded($x);
+ ParseInterface($x);
+ }
+ }
+
+ pidl "int proto_dcerpc_pidl_$module = -1;\n\n";
+
+ pidl "static gint ett_dcerpc_$module = -1;\n\n";
if (defined($if_uuid)) {
pidl "static guint16 ver_dcerpc_$module = " . $if_version . ";\n\n";
}
- pidl "void proto_register_dcerpc_$module(void)\n";
+ pidl "void proto_register_dcerpc_pidl_$module(void)\n";
pidl "{\n";
pidl "\tstatic hf_register_info hf[] = {\n";
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";
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_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 "void proto_reg_handoff_dcerpc_$module(void)\n";
+ pidl "void proto_reg_handoff_dcerpc_pidl_$module(void)\n";
pidl "{\n";
- pidl "\tdcerpc_init_uuid(proto_dcerpc_$module, ett_dcerpc_$module, \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";
git.samba.org / samba.git / blobdiff