# Samba4 parser generator for IDL structures
# Copyright tridge@samba.org 2000-2003
# Copyright tpot@samba.org 2001
+# Copyright jelmer@samba.org 2004
# released under the GNU GPL
package IdlParser;
use strict;
-use Data::Dumper;
+use needed;
# the list of needed functions
-my %needed;
my %structs;
sub pidl($)
{
- print IDL shift;
+ print OUT shift;
}
#####################################################################
die "invalid variable in $size for element $e->{NAME} in $fn->{NAME}\n";
}
+#####################################################################
+# check that a variable we get from find_size_var isn't a null pointer
+sub check_null_pointer($)
+{
+ my $size = shift;
+ if ($size =~ /^\*/) {
+ my $size2 = substr($size, 1);
+ pidl "\tif ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;\n";
+ }
+}
+
#####################################################################
# work out is a parse function should be declared static or not
sub fn_prefix($)
{
- my $e = shift;
- if (util::has_property($e, "public")) {
- return "static ";
+ my $fn = shift;
+ if ($fn->{TYPE} eq "TYPEDEF") {
+ if (util::has_property($fn->{DATA}, "public")) {
+ return "";
+ }
}
- return "";
+
+ if ($fn->{TYPE} eq "FUNCTION") {
+ if (util::has_property($fn, "public")) {
+ return "";
+ }
+ }
+ return "static ";
}
my $e = shift;
my $flags = util::has_property($e, "flag");
if (defined $flags) {
- pidl "\t{ uint32 _flags_save_$e->{TYPE} = ndr->flags;\n";
- pidl "\tndr->flags |= $flags;\n";
+ pidl "\t{ uint32_t _flags_save_$e->{TYPE} = ndr->flags;\n";
+ pidl "\tndr_set_flags(&ndr->flags, $flags);\n";
}
}
}
}
+#####################################################################
+# check the size_is and length_is constraints
+sub CheckArraySizes($$)
+{
+ my $e = shift;
+ my $var_prefix = shift;
+
+ if (util::has_property($e, "size_is")) {
+ my $size = find_size_var($e, util::array_size($e), $var_prefix);
+ pidl "\tif ($var_prefix$e->{NAME}) {\n";
+ check_null_pointer($size);
+ pidl "\t\tNDR_CHECK(ndr_check_array_size(ndr, (void*)&$var_prefix$e->{NAME}, $size));\n";
+ pidl "\t}\n";
+ }
+
+ if (my $length = util::has_property($e, "length_is")) {
+ $length = find_size_var($e, $length, $var_prefix);
+ pidl "\tif ($var_prefix$e->{NAME}) {\n";
+ check_null_pointer($length);
+ pidl "\t\tNDR_CHECK(ndr_check_array_length(ndr, (void*)&$var_prefix$e->{NAME}, $length));\n";
+ pidl "\t}\n";
+ }
+}
+
+
#####################################################################
# parse an array - pull side
sub ParseArrayPull($$$)
# we allocate enough to pull the elements
if (defined $e->{CONFORMANT_SIZE}) {
$alloc_size = $e->{CONFORMANT_SIZE};
-
+ check_null_pointer($size);
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";
}
# non fixed arrays encode the size just before the array
- pidl "\t{\n";
- pidl "\t\tuint32 _array_size;\n";
- pidl "\t\tNDR_CHECK(ndr_pull_uint32(ndr, &_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\treturn ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %u should be %u\", _array_size, $size);\n";
- pidl "\t\t} else { $size = _array_size; }\n";
- pidl "\t}\n";
+ pidl "\t\tNDR_CHECK(ndr_pull_array_size(ndr, &$var_prefix$e->{NAME}));\n";
+ $alloc_size = "ndr_get_array_size(ndr, &$var_prefix$e->{NAME})";
}
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_SIZE(ndr, $var_prefix$e->{NAME}, MAX(1, $alloc_size), sizeof($var_prefix$e->{NAME}\[0]));\n";
+ pidl "\t\tNDR_ALLOC_N(ndr, $var_prefix$e->{NAME}, $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_SIZE(ndr, $var_prefix$e->{NAME}, MAX(1, $alloc_size), sizeof($var_prefix$e->{NAME}\[0]));\n";
+ pidl "\t\tNDR_ALLOC_N(ndr, $var_prefix$e->{NAME}, $alloc_size);\n";
pidl "\t}\n";
}
}
- pidl "\t{\n";
-
if (my $length = util::has_property($e, "length_is")) {
- $length = find_size_var($e, $length, $var_prefix);
- pidl "\t\tuint32 _offset, _length;\n";
- pidl "\t\tNDR_CHECK(ndr_pull_uint32(ndr, &_offset));\n";
- pidl "\t\tNDR_CHECK(ndr_pull_uint32(ndr, &_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";
+ pidl "\t\tNDR_CHECK(ndr_pull_array_length(ndr, &$var_prefix$e->{NAME}));\n";
+ $size = "ndr_get_array_length(ndr, &$var_prefix$e->{NAME})";
}
+ check_null_pointer($size);
if (util::is_scalar_type($e->{TYPE})) {
pidl "\t\tNDR_CHECK(ndr_pull_array_$e->{TYPE}(ndr, $ndr_flags, $var_prefix$e->{NAME}, $size));\n";
} else {
pidl "\t\tNDR_CHECK(ndr_pull_array(ndr, $ndr_flags, (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 (util::has_property($e, "relative")) {
- pidl "\tNDR_CHECK(ndr_push_relative(ndr, NDR_SCALARS, $var_prefix$e->{NAME}, (ndr_push_const_fn_t) ndr_push_$e->{TYPE}));\n";
+ pidl "\tNDR_CHECK(ndr_push_relative1(ndr, $var_prefix$e->{NAME}));\n";
} elsif (util::is_inline_array($e)) {
ParseArrayPush($e, "r->", "NDR_SCALARS");
} elsif (util::need_wire_pointer($e)) {
return;
}
- if (util::has_direct_buffers($e)) {
+ if (my $value = util::has_property($e, "value")) {
+ pidl "\tif (ndr->flags & LIBNDR_PRINT_SET_VALUES) {\n";
+ pidl "\t\t$cprefix$var_prefix$e->{NAME} = $value;\n";
+ pidl "\t}\n";
+ }
+
+ if (util::is_fixed_array($e)) {
+ ParseElementPrintBuffer($e, $var_prefix);
+ } elsif (util::has_direct_buffers($e)) {
pidl "\tndr_print_ptr(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME});\n";
pidl "\tndr->depth++;\n";
ParseElementPrintBuffer($e, $var_prefix);
my $cprefix = util::c_pull_prefix($e);
my $utype = $structs{$e->{TYPE}};
+
+ check_null_pointer($switch_var);
+
if (!defined $utype ||
!util::has_property($utype->{DATA}, "nodiscriminant")) {
my $e2 = find_sibling($e, $switch);
} 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}\");\t\t} else { $switch_var = _level; }\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";
}
my $sub_size = util::has_property($e, "subcontext");
if (defined $sub_size) {
- pidl "\tNDR_CHECK(ndr_pull_subcontext_union_fn(ndr, $sub_size, $switch_var, $cprefix$var_prefix$e->{NAME}, (ndr_pull_union_fn_t) ndr_pull_$e->{TYPE}));\n";
+ pidl "\tif (($ndr_flags) & NDR_SCALARS) {\n";
+ pidl "\t\tNDR_CHECK(ndr_pull_subcontext_union_fn(ndr, $sub_size, $switch_var, $cprefix$var_prefix$e->{NAME}, (ndr_pull_union_fn_t) ndr_pull_$e->{TYPE}));\n";
+ pidl "\t}\n";
} else {
pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));\n";
}
my $switch_var = find_size_var($e, $switch, $var_prefix);
my $cprefix = util::c_push_prefix($e);
+ check_null_pointer($switch_var);
+
my $utype = $structs{$e->{TYPE}};
if (!defined $utype ||
!util::has_property($utype->{DATA}, "nodiscriminant")) {
my $sub_size = util::has_property($e, "subcontext");
if (defined $sub_size) {
- pidl "\tNDR_CHECK(ndr_push_subcontext_union_fn(ndr, $sub_size, $switch_var, $cprefix$var_prefix$e->{NAME}, (ndr_push_union_fn_t) ndr_push_$e->{TYPE}));\n";
+ pidl "\tif(($ndr_flags) & NDR_SCALARS) {\n";
+ pidl "\t\tNDR_CHECK(ndr_push_subcontext_union_fn(ndr, $sub_size, $switch_var, $cprefix$var_prefix$e->{NAME}, (ndr_push_union_fn_t) ndr_push_$e->{TYPE}));\n";
+ pidl "\t}\n";
} else {
pidl "\tNDR_CHECK(ndr_push_$e->{TYPE}(ndr, $ndr_flags, $switch_var, $cprefix$var_prefix$e->{NAME}));\n";
}
my $switch_var = find_size_var($e, $switch, $var_prefix);
my $cprefix = util::c_push_prefix($e);
+ check_null_pointer($switch_var);
+
pidl "\tndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $switch_var, $cprefix$var_prefix$e->{NAME});\n";
}
start_flags($e);
- if (util::has_property($e, "relative")) {
- pidl "\tNDR_CHECK(ndr_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)) {
+ if (util::is_inline_array($e)) {
ParseArrayPull($e, "r->", "NDR_SCALARS");
} elsif (util::need_wire_pointer($e)) {
- pidl "\tNDR_CHECK(ndr_pull_uint32(ndr, &_ptr_$e->{NAME}));\n";
+ pidl "\tNDR_CHECK(ndr_pull_ptr(ndr, &_ptr_$e->{NAME}));\n";
pidl "\tif (_ptr_$e->{NAME}) {\n";
pidl "\t\tNDR_ALLOC(ndr, $var_prefix$e->{NAME});\n";
+ if (util::has_property($e, "relative")) {
+ pidl "\t\tNDR_CHECK(ndr_pull_relative1(ndr, $var_prefix$e->{NAME}, _ptr_$e->{NAME}));";
+ }
pidl "\t} else {\n";
pidl "\t\t$var_prefix$e->{NAME} = NULL;\n";
pidl "\t}\n";
} else {
pidl "\tNDR_CHECK(ndr_pull_$e->{TYPE}(ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));\n";
}
+ if (my $range = util::has_property($e, "range")) {
+ my ($low, $high) = split(/ /, $range, 2);
+ pidl "\tif ($var_prefix$e->{NAME} < $low || $var_prefix$e->{NAME} > $high) {\n";
+ pidl "\t\treturn ndr_pull_error(ndr, NDR_ERR_RANGE, \"value out of range\");\n\t}\n";
+ }
end_flags($e);
}
if (util::need_wire_pointer($e)) {
pidl "\tif ($var_prefix$e->{NAME}) {\n";
+ if (util::has_property($e, "relative")) {
+ pidl "\t\tNDR_CHECK(ndr_push_relative2(ndr, $var_prefix$e->{NAME}));\n";
+ }
}
- if (util::has_property($e, "relative")) {
- pidl "\tNDR_CHECK(ndr_push_relative(ndr, NDR_BUFFERS, $cprefix$var_prefix$e->{NAME}, (ndr_push_const_fn_t) ndr_push_$e->{TYPE}));\n";
- } elsif (util::is_inline_array($e)) {
+ if (util::is_inline_array($e)) {
ParseArrayPush($e, "r->", "NDR_BUFFERS");
} elsif (util::array_size($e)) {
ParseArrayPush($e, "r->", "NDR_SCALARS|NDR_BUFFERS");
}
if (util::array_size($e)) {
- ParseArrayPrint($e, $var_prefix);
+ ParseArrayPrint($e, $var_prefix)
} elsif (my $switch = util::has_property($e, "switch_is")) {
ParseElementPrintSwitch($e, $var_prefix, $switch);
} else {
return;
}
- if (util::has_property($e, "relative")) {
- return;
- }
-
start_flags($e);
if (util::need_wire_pointer($e)) {
pidl "\tif ($var_prefix$e->{NAME}) {\n";
+ if (util::has_property($e, "relative")) {
+ pidl "\t\tstruct ndr_pull_save _relative_save;\n";
+ pidl "\t\tndr_pull_save(ndr, &_relative_save);\n";
+ pidl "\t\tNDR_CHECK(ndr_pull_relative2(ndr, $var_prefix$e->{NAME}));\n";
+ }
}
if (util::is_inline_array($e)) {
}
if (util::need_wire_pointer($e)) {
+ if (util::has_property($e, "relative")) {
+ pidl "\t\tndr_pull_restore(ndr, &_relative_save);\n";
+ }
pidl "\t}\n";
}
sub ParseStructPush($)
{
my($struct) = shift;
- my $conform_e;
if (! defined $struct->{ELEMENTS}) {
return;
if (defined $e->{ARRAY_LEN} && $e->{ARRAY_LEN} eq "*") {
my $size = find_size_var($e, util::array_size($e), "r->");
$e->{CONFORMANT_SIZE} = $size;
- $conform_e = $e;
+ check_null_pointer($size);
pidl "\tNDR_CHECK(ndr_push_uint32(ndr, $size));\n";
}
+ if (defined $e->{TYPE} && $e->{TYPE} eq "string"
+ && util::property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) {
+ pidl "\tNDR_CHECK(ndr_push_uint32(ndr, ndr_string_array_size(ndr, r->$e->{NAME})));\n";
+ }
+
pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
pidl "\tNDR_CHECK(ndr_push_struct_start(ndr));\n";
return;
}
+ start_flags($struct);
+
pidl "\tndr->depth++;\n";
foreach my $e (@{$struct->{ELEMENTS}}) {
ParseElementPrintScalar($e, "r->");
}
pidl "\tndr->depth--;\n";
+
+ end_flags($struct);
}
#####################################################################
return;
}
- start_flags($struct);
-
# see if the structure contains a conformant array. If it
# does, then it must be the last element of the structure, and
# we need to pull the conformant length early, as it fits on
my $e = $struct->{ELEMENTS}[-1];
if (defined $e->{ARRAY_LEN} && $e->{ARRAY_LEN} eq "*") {
$conform_e = $e;
- pidl "\tuint32 _conformant_size;\n";
+ }
+
+ if (defined $e->{TYPE} && $e->{TYPE} eq "string"
+ && util::property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) {
+ $conform_e = $e;
+ }
+
+ if (defined $conform_e) {
+ $conform_e = $e;
+ pidl "\tuint32_t _conformant_size;\n";
$conform_e->{CONFORMANT_SIZE} = "_conformant_size";
}
# declare any internal pointers we need
foreach my $e (@{$struct->{ELEMENTS}}) {
- if (util::need_wire_pointer($e) &&
- !util::has_property($e, "relative")) {
- pidl "\tuint32 _ptr_$e->{NAME};\n";
+ if (util::need_wire_pointer($e)) {
+ pidl "\tuint32_t _ptr_$e->{NAME};\n";
}
}
+ start_flags($struct);
+
pidl "\tif (!(ndr_flags & NDR_SCALARS)) goto buffers;\n";
pidl "\tNDR_CHECK(ndr_pull_struct_start(ndr));\n";
ParseElementPullBuffer($e, "r->", "NDR_BUFFERS");
}
+ foreach my $e (@{$struct->{ELEMENTS}}) {
+ CheckArraySizes($e, "r->");
+ }
+
pidl "\tndr_pull_struct_end(ndr);\n";
pidl "done:\n";
end_flags($struct);
}
+#####################################################################
+# calculate size of ndr struct
+sub ParseStructNdrSize($)
+{
+ my $t = shift;
+ my $static = fn_prefix($t);
+ my $sizevar;
+
+ pidl $static . "size_t ndr_size_$t->{NAME}(int ret, const struct $t->{NAME} *r, int flags)\n";
+ pidl "{\n";
+
+ if (util::has_property($t->{DATA}, "flag")) {
+ pidl "\tflags = flags | " . $t->{DATA}->{PROPERTIES}->{flag} . ";\n";
+ }
+
+ pidl "\tif(!r) return 0;\n";
+
+ pidl "\tret = NDR_SIZE_ALIGN(ret, " . struct_alignment($t->{DATA}) . ", flags);\n";
+
+ for my $e (@{$t->{DATA}->{ELEMENTS}}) {
+ my $switch = "";
+
+ if (util::has_property($e, "subcontext")) {
+ pidl "\tret += $e->{PROPERTIES}->{subcontext}; /* Subcontext length */\n";
+ }
+
+ if (util::has_property($e, "switch_is")) {
+ $switch = ", r->$e->{PROPERTIES}->{switch_is}";
+ }
+
+ if ($e->{POINTERS} > 0) {
+ pidl "\tret = ndr_size_ptr(ret, &r->$e->{NAME}, flags); \n";
+ } elsif (util::is_inline_array($e)) {
+ $sizevar = find_size_var($e, util::array_size($e), "r->");
+ check_null_pointer($sizevar);
+ pidl "\t{\n";
+ pidl "\t\tint i;\n";
+ pidl "\t\tfor(i = 0; i < $sizevar; i++) {\n";
+ pidl "\t\t\tret = ndr_size_$e->{TYPE}(ret, &r->" . $e->{NAME} . "[i], flags);\n";
+ pidl "\t\t}\n";
+ pidl "\t}\n";
+ } else {
+ pidl "\tret = ndr_size_$e->{TYPE}(ret, &r->$e->{NAME}$switch, flags); \n";
+ }
+ }
+
+ # Add lengths of relative members
+ for my $e (@{$t->{DATA}->{ELEMENTS}}) {
+ next unless (util::has_property($e, "relative"));
+
+ pidl "\tif (r->$e->{NAME}) {\n";
+ pidl "\t\tret = ndr_size_$e->{TYPE}(ret, r->$e->{NAME}, flags); \n";
+ pidl "\t}\n";
+ }
+
+ pidl "\treturn ret;\n";
+ pidl "}\n\n";
+}
#####################################################################
# parse a union - push side
my $e = shift;
my $have_default = 0;
+ start_flags($e);
+
pidl "\tswitch (level) {\n";
foreach my $el (@{$e->{DATA}}) {
if ($el->{CASE} eq "default") {
pidl "\tdefault:\n\t\tndr_print_bad_level(ndr, name, level);\n";
}
pidl "\t}\n";
+
+ end_flags($e);
}
#####################################################################
if ($el->{TYPE} eq "UNION_ELEMENT") {
my $e2 = $el->{DATA};
if ($e2->{POINTERS}) {
- pidl "\t\tuint32 _ptr_$e2->{NAME};\n";
+ pidl "\t\tuint32_t _ptr_$e2->{NAME};\n";
}
ParseElementPullScalar($el->{DATA}, "r->", "NDR_SCALARS");
}
end_flags($e);
}
+#####################################################################
+# calculate size of ndr union
+
+sub ParseUnionNdrSize($)
+{
+ my $t = shift;
+ my $static = fn_prefix($t);
+
+ pidl $static . "size_t ndr_size_$t->{NAME}(int ret, const union $t->{NAME} *data, uint16 level, int flags)\n";
+ pidl "{\n";
+ if (util::has_property($t->{DATA}, "flag")) {
+ pidl "\tflags = flags | " . $t->{DATA}->{PROPERTIES}->{flag} . ";\n";
+ }
+ pidl "\tif(!data) return 0;\n\n";
+
+ pidl "\tret = NDR_SIZE_ALIGN(ret, " . union_alignment($t->{DATA}) . ", flags);\n";
+
+ pidl "\tswitch(level) {\n";
+
+ for my $e (@{$t->{DATA}->{DATA}}) {
+ if ($e->{TYPE} eq "UNION_ELEMENT") {
+
+ if ($e->{CASE} eq "default") {
+ pidl "\t\tdefault:";
+ } else {
+ pidl "\t\tcase $e->{CASE}:";
+ }
+
+ pidl " return ndr_size_$e->{DATA}->{TYPE}(ret, &data->$e->{DATA}->{NAME}, flags); \n";
+
+ }
+ }
+ pidl "\t}\n";
+ pidl "\treturn ret;\n";
+ pidl "}\n\n";
+}
+
#####################################################################
# parse a type
sub ParseTypePush($)
my($e) = shift;
my $static = fn_prefix($e);
- if (! $needed{"push_$e->{NAME}"}) {
+ if (! needed::is_needed("push_$e->{NAME}")) {
# print "push_$e->{NAME} not needed\n";
return;
}
if ($e->{DATA}->{TYPE} eq "STRUCT") {
- pidl "$static" . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, struct $e->{NAME} *r)";
+ pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, struct $e->{NAME} *r)";
pidl "\n{\n";
ParseTypePush($e->{DATA});
pidl "\treturn NT_STATUS_OK;\n";
}
if ($e->{DATA}->{TYPE} eq "UNION") {
- pidl "$static" . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, uint16 level, union $e->{NAME} *r)";
+ pidl $static . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, int level, union $e->{NAME} *r)";
pidl "\n{\n";
ParseTypePush($e->{DATA});
pidl "\treturn NT_STATUS_OK;\n";
my($e) = shift;
my $static = fn_prefix($e);
- if (! $needed{"pull_$e->{NAME}"}) {
+ if (! needed::is_needed("pull_$e->{NAME}")) {
# print "pull_$e->{NAME} not needed\n";
return;
}
if ($e->{DATA}->{TYPE} eq "STRUCT") {
- pidl "$static" . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, struct $e->{NAME} *r)";
+ pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, struct $e->{NAME} *r)";
pidl "\n{\n";
ParseTypePull($e->{DATA});
pidl "\treturn NT_STATUS_OK;\n";
}
if ($e->{DATA}->{TYPE} eq "UNION") {
- pidl "$static" . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, uint16 level, union $e->{NAME} *r)";
+ pidl $static . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, int level, union $e->{NAME} *r)";
pidl "\n{\n";
ParseTypePull($e->{DATA});
pidl "\treturn NT_STATUS_OK;\n";
}
if ($e->{DATA}->{TYPE} eq "UNION") {
- pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, uint16 level, union $e->{NAME} *r)";
+ pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, int level, union $e->{NAME} *r)";
pidl "\n{\n";
pidl "\tndr_print_union(ndr, name, level, \"$e->{NAME}\");\n";
ParseTypePrint($e->{DATA});
}
}
+#####################################################################
+## calculate the size of a structure
+sub ParseTypedefNdrSize($)
+{
+ my($t) = shift;
+ if (! needed::is_needed("ndr_size_$t->{NAME}")) {
+ return;
+ }
+
+ ($t->{DATA}->{TYPE} eq "STRUCT") &&
+ ParseStructNdrSize($t);
+
+ ($t->{DATA}->{TYPE} eq "UNION") &&
+ ParseUnionNdrSize($t);
+
+}
+
#####################################################################
# parse a function - print side
sub ParseFunctionPrint($)
pidl "\n{\n";
pidl "\tndr_print_struct(ndr, name, \"$fn->{NAME}\");\n";
pidl "\tndr->depth++;\n";
-
+
+ pidl "\tif (flags & NDR_SET_VALUES) {\n";
+ pidl "\t\tndr->flags |= LIBNDR_PRINT_SET_VALUES;\n";
+ pidl "\t}\n";
+
pidl "\tif (flags & NDR_IN) {\n";
pidl "\t\tndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");\n";
pidl "\tndr->depth++;\n";
if (util::array_size($e)) {
if (util::need_wire_pointer($e)) {
pidl "\tNDR_CHECK(ndr_push_ptr(ndr, r->$inout.$e->{NAME}));\n";
+ pidl "\tif (r->$inout.$e->{NAME}) {\n";
+ ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
+ pidl "\t}\n";
+ } else {
+ ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
}
- pidl "\tif (r->$inout.$e->{NAME}) {\n";
- ParseArrayPush($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
- pidl "\t}\n";
} else {
ParseElementPushScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
if ($e->{POINTERS}) {
sub ParseFunctionPush($)
{
my($fn) = shift;
+ my $static = fn_prefix($fn);
- pidl "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
+ pidl $static . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
pidl "\n\tif (!(flags & NDR_IN)) goto ndr_out;\n\n";
+
foreach my $e (@{$fn->{DATA}}) {
if (util::has_property($e, "in")) {
ParseFunctionElementPush($e, "in");
pidl "\nndr_out:\n";
pidl "\tif (!(flags & NDR_OUT)) goto done;\n\n";
+
foreach my $e (@{$fn->{DATA}}) {
if (util::has_property($e, "out")) {
ParseFunctionElementPush($e, "out");
if (util::array_size($e)) {
if (util::need_wire_pointer($e)) {
- pidl "\tNDR_CHECK(ndr_pull_uint32(ndr, &_ptr_$e->{NAME}));\n";
+ pidl "\tNDR_CHECK(ndr_pull_ptr(ndr, &_ptr_$e->{NAME}));\n";
+ pidl "\tr->$inout.$e->{NAME} = NULL;\n";
pidl "\tif (_ptr_$e->{NAME}) {\n";
- } elsif ($inout eq "in" && util::has_property($e, "ref")) {
- pidl "\t{\n";
- } else {
+ } elsif ($inout eq "out" && util::has_property($e, "ref")) {
pidl "\tif (r->$inout.$e->{NAME}) {\n";
+ } else {
+ pidl "\t{\n";
}
ParseArrayPull($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
pidl "\t}\n";
}
}
+
+############################################################
+# 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.");
+ check_null_pointer($size);
+ pidl "\tNDR_ALLOC_N(ndr, r->out.$e->{NAME}, $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);
# pull function args
- pidl "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
+ pidl $static . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)\n{\n";
# declare any internal pointers we need
foreach my $e (@{$fn->{DATA}}) {
if (util::need_wire_pointer($e)) {
- pidl "\tuint32 _ptr_$e->{NAME};\n";
+ pidl "\tuint32_t _ptr_$e->{NAME};\n";
}
}
pidl "\n\tif (!(flags & NDR_IN)) goto ndr_out;\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;
+ }
+ }
+
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);
+ }
+ }
+
+ foreach my $e (@{$fn->{DATA}}) {
+ if (util::has_property($e, "in")) {
+ CheckArraySizes($e, "r->in.");
+ }
}
pidl "\nndr_out:\n";
pidl "\tif (!(flags & NDR_OUT)) goto done;\n\n";
+
foreach my $e (@{$fn->{DATA}}) {
if (util::has_property($e, "out")) {
ParseFunctionElementPull($e, "out");
}
}
+ foreach my $e (@{$fn->{DATA}}) {
+ if (util::has_property($e, "out")) {
+ CheckArraySizes($e, "r->out.");
+ }
+ }
+
if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
pidl "\tNDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, &r->out.result));\n";
}
sub FunctionTable($)
{
my($interface) = shift;
- my($data) = $interface->{DATA};
+ my($data) = $interface->{INHERITED_DATA};
my $count = 0;
+ my $uname = uc $interface->{NAME};
foreach my $d (@{$data}) {
if ($d->{TYPE} eq "FUNCTION") { $count++; }
}
+ return if ($count == 0);
- pidl "static const struct dcerpc_interface_call calls[] = {\n";
+ pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {\n";
foreach my $d (@{$data}) {
if ($d->{TYPE} eq "FUNCTION") {
pidl "\t{\n";
}
pidl "\t{ NULL, 0, NULL, NULL }\n};\n\n";
- pidl "\nstruct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {\"$interface->{NAME}\", $count,calls};\n\n";
-}
+ # If no endpoint is set, default to the interface name as a named pipe
+ if (! defined $interface->{PROPERTIES}->{endpoint}) {
+ $interface->{PROPERTIES}->{endpoint} = "\"ncacn_np:[\\\\pipe\\\\" . $interface->{NAME} . "]\"";
+ }
+
+ my @e = split / /, $interface->{PROPERTIES}->{endpoint};
+ my $endpoint_count = $#e + 1;
+
+ pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {\n";
+ foreach my $ep (@e) {
+ pidl "\t$ep, \n";
+ }
+ pidl "};\n\n";
+
+ pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {\n";
+ pidl "\t$endpoint_count, $interface->{NAME}\_endpoint_strings\n";
+ pidl "};\n\n";
+ pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {\n";
+ pidl "\t\"$interface->{NAME}\",\n";
+ pidl "\tDCERPC_$uname\_UUID,\n";
+ pidl "\tDCERPC_$uname\_VERSION,\n";
+ pidl "\tDCERPC_$uname\_HELPSTRING,\n";
+ pidl "\t$count,\n";
+ pidl "\t$interface->{NAME}\_calls,\n";
+ pidl "\t&$interface->{NAME}\_endpoints\n";
+ pidl "};\n\n";
+
+ pidl "static NTSTATUS dcerpc_ndr_$interface->{NAME}_init(void)\n";
+ pidl "{\n";
+ pidl "\treturn librpc_register_interface(&dcerpc_table_$interface->{NAME});\n";
+ pidl "}\n\n";
+}
#####################################################################
# parse the interface definitions
}
}
-
+ foreach my $d (@{$data}) {
+ ($d->{TYPE} eq "TYPEDEF") &&
+ ParseTypedefNdrSize($d);
+ }
foreach my $d (@{$data}) {
($d->{TYPE} eq "TYPEDEF") &&
}
FunctionTable($interface);
-
}
-sub NeededFunction($)
+sub RegistrationFunction($$)
{
- my $fn = shift;
- $needed{"pull_$fn->{NAME}"} = 1;
- $needed{"push_$fn->{NAME}"} = 1;
- foreach my $e (@{$fn->{DATA}}) {
- $e->{PARENT} = $fn;
- $needed{"pull_$e->{TYPE}"} = 1;
- $needed{"push_$e->{TYPE}"} = 1;
- }
-}
-
-sub NeededTypedef($)
-{
- my $t = shift;
- if (util::has_property($t->{DATA}, "public")) {
- $needed{"pull_$t->{NAME}"} = 1;
- $needed{"push_$t->{NAME}"} = 1;
- }
- if ($t->{DATA}->{TYPE} eq "STRUCT") {
- for my $e (@{$t->{DATA}->{ELEMENTS}}) {
- $e->{PARENT} = $t->{DATA};
- if ($needed{"pull_$t->{NAME}"}) {
- $needed{"pull_$e->{TYPE}"} = 1;
- }
- if ($needed{"push_$t->{NAME}"}) {
- $needed{"push_$e->{TYPE}"} = 1;
- }
+ my $idl = shift;
+ my $filename = shift;
+
+ $filename =~ /.*\/ndr_(.*).c/;
+ my $basename = $1;
+ pidl "NTSTATUS dcerpc_$basename\_init(void)\n";
+ pidl "{\n";
+ pidl "\tNTSTATUS status = NT_STATUS_OK;\n";
+ foreach my $interface (@{$idl}) {
+ next if $interface->{TYPE} ne "INTERFACE";
+
+ my $data = $interface->{INHERITED_DATA};
+ my $count = 0;
+ foreach my $d (@{$data}) {
+ if ($d->{TYPE} eq "FUNCTION") { $count++; }
}
- }
- 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;
- }
- if ($needed{"push_$t->{NAME}"}) {
- $needed{"push_$e->{DATA}->{TYPE}"} = 1;
- }
- }
- }
- }
-}
-#####################################################################
-# work out what parse functions are needed
-sub BuildNeeded($)
-{
- my($interface) = shift;
- my($data) = $interface->{DATA};
- foreach my $d (@{$data}) {
- ($d->{TYPE} eq "FUNCTION") &&
- NeededFunction($d);
- }
- foreach my $d (reverse @{$data}) {
- ($d->{TYPE} eq "TYPEDEF") &&
- NeededTypedef($d);
+ next if ($count == 0);
+
+ pidl "\tstatus = dcerpc_ndr_$interface->{NAME}_init();\n";
+ pidl "\tif (NT_STATUS_IS_ERR(status)) {\n";
+ pidl "\t\treturn status;\n";
+ pidl "\t}\n\n";
}
+ pidl "\treturn status;\n";
+ pidl "}\n\n";
}
#####################################################################
{
my($idl) = shift;
my($filename) = shift;
+ my $h_filename = $filename;
+
+ if ($h_filename =~ /(.*)\.c/) {
+ $h_filename = "$1.h";
+ }
- open(IDL, ">$filename") || die "can't open $filename";
+ open(OUT, ">$filename") || die "can't open $filename";
pidl "/* parser auto-generated by pidl */\n\n";
- pidl "#include \"includes.h\"\n\n";
+ pidl "#include \"includes.h\"\n";
+ pidl "#include \"$h_filename\"\n\n";
+
foreach my $x (@{$idl}) {
if ($x->{TYPE} eq "INTERFACE") {
- BuildNeeded($x);
+ needed::BuildNeeded($x);
ParseInterface($x);
}
}
- close(IDL);
+
+ RegistrationFunction($idl, $filename);
+
+ close(OUT);
}
1;
git.samba.org / samba.git / blobdiff