diff options
Diffstat (limited to 'source4/build/pidl/ndr.pm')
| -rw-r--r-- | source4/build/pidl/ndr.pm | 2275 |
1 files changed, 0 insertions, 2275 deletions
diff --git a/source4/build/pidl/ndr.pm b/source4/build/pidl/ndr.pm deleted file mode 100644 index fde9f05d2f..0000000000 --- a/source4/build/pidl/ndr.pm +++ /dev/null @@ -1,2275 +0,0 @@ -################################################### -# Samba4 NDR parser generator for IDL structures -# Copyright tridge@samba.org 2000-2003 -# Copyright tpot@samba.org 2001 -# Copyright jelmer@samba.org 2004-2005 -# released under the GNU GPL - -package NdrParser; - -use strict; -use needed; -use typelist; - -# list of known types -my %typefamily; - -sub get_typefamily($) -{ - my $n = shift; - return $typefamily{$n}; -} - -my %scalar_alignments = -( - "char" => 1, - "int8" => 1, - "uint8" => 1, - "short" => 2, - "wchar_t" => 2, - "int16" => 2, - "uint16" => 2, - "long" => 4, - "int32" => 4, - "uint32" => 4, - "dlong" => 4, - "udlong" => 4, - "udlongr" => 4, - "NTTIME" => 4, - "NTTIME_1sec" => 4, - "time_t" => 4, - "DATA_BLOB" => 4, - "error_status_t" => 4, - "WERROR" => 4, - "NTSTATUS" => 4, - "boolean32" => 4, - "unsigned32" => 4, - "ipv4address" => 4, - "hyper" => 8, - "NTTIME_hyper" => 8 -); - -$typefamily{SCALAR} = { - ALIGN => sub { - my $t = shift; - return $scalar_alignments{$t->{NAME}}; - } -}; - -sub is_scalar_type($) -{ - my $type = shift; - - return 0 unless typelist::hasType($type); - - if (my $dt = typelist::getType($type)->{DATA}->{TYPE}) { - return 1 if ($dt eq "SCALAR" or $dt eq "ENUM" or $dt eq "BITMAP"); - } - - return 0; -} - -sub pointer_type($) -{ - my $e = shift; - - return undef unless $e->{POINTERS}; - - return "ref" if (util::has_property($e, "ref")); - return "ptr" if (util::has_property($e, "ptr")); - return "unique" if (util::has_property($e, "unique")); - return "relative" if (util::has_property($e, "relative")); - return "ignore" if (util::has_property($e, "ignore")); - - return undef; -} - -# return 1 if this is a fixed array -sub is_fixed_array($) -{ - my $e = shift; - my $len = $e->{"ARRAY_LEN"}; - return 1 if (defined $len && util::is_constant($len)); - return 0; -} - -# return 1 if this is a conformant array -sub is_conformant_array($) -{ - my $e = shift; - return 1 if (util::has_property($e, "size_is")); - return 0; -} - -# return 1 if this is a inline array -sub is_inline_array($) -{ - my $e = shift; - my $len = $e->{"ARRAY_LEN"}; - if (is_fixed_array($e) || - defined $len && $len ne "*") { - return 1; - } - return 0; -} - -# return 1 if this is a varying array -sub is_varying_array($) -{ - my $e = shift; - return util::has_property($e, "length_is"); -} - -# return 1 if this is a surrounding array (sometimes -# referred to as an embedded array). Can only occur as -# the last element in a struct and can not contain any pointers. -sub is_surrounding_array($) -{ - my $e = shift; - - return ($e->{POINTERS} == 0 - and defined $e->{ARRAY_LEN} - and $e->{ARRAY_LEN} eq "*" - and $e == $e->{PARENT}->{ELEMENTS}[-1] - and $e->{PARENT}->{TYPE} ne "FUNCTION"); -} - -sub array_type($) -{ - my $e = shift; - - return "conformant-varying" if (is_varying_array($e) and is_conformant_array($e)); - return "conformant" if (is_varying_array($e)); - return "varying" if (is_varying_array($e)); - return "inline" if (is_inline_array($e)); - return "fixed" if (is_fixed_array($e)); - - return undef; -} - -# determine if an element needs a reference pointer on the wire -# in its NDR representation -sub need_wire_pointer($) -{ - my $e = shift; - - my $n = $e->{POINTERS}; - my $pt = pointer_type($e); - - # Top level "ref" pointers do not have a referrent identifier - if ( defined($pt) - and $pt eq "ref" - and $e->{PARENT}->{TYPE} eq "FUNCTION") - { - $n--; - } - - return $n; -} - -# determine if an element needs a "buffers" section in NDR -sub need_buffers_section($) -{ - my $e = shift; - if (!can_contain_deferred($e) && - !util::array_size($e)) { - return 0; - } - return 1; -} - -# see if a variable needs to be allocated by the NDR subsystem on pull -sub need_alloc($) -{ - my $e = shift; - - return 0 if (util::has_property($e, "ref") && $e->{PARENT}->{TYPE} eq "FUNCTION"); - return 1 if ($e->{POINTERS} || util::array_size($e)); - return 0; -} - -# Prefix to get the actual value of a variable -sub c_ptr_prefix($) -{ - my $e = shift; - my $pointers = ""; - foreach my $i (need_wire_pointer($e)..$e->{POINTERS}-1) { $pointers.="*"; } - return $pointers; -} - -# determine the C prefix used to refer to a variable when passing to a push -# function. This will be '*' for pointers to scalar types, '' for scalar -# types and normal pointers and '&' for pass-by-reference structures -sub c_push_prefix($) -{ - my $e = shift; - - my $ret = ""; - - if ($e->{TYPE} =~ "string") { - $ret = ""; - } elsif (is_scalar_type($e->{TYPE}) and $e->{POINTERS} and - !util::array_size($e)) { - $ret .="*"; - } elsif (!is_scalar_type($e->{TYPE}) && - !$e->{POINTERS} && - !util::array_size($e)) { - return "&"; - } - - foreach my $i (2..$e->{POINTERS}) { $ret.="*"; } - - return $ret; -} - -# determine the C prefix used to refer to a variable when passing to a pull -# return '&' or '' -sub c_pull_prefix($) -{ - my $e = shift; - - if (!$e->{POINTERS} && !util::array_size($e)) { - return "&"; - } - - if ($e->{TYPE} =~ "string") { - return "&"; - } - - my $ret = ""; - foreach my $i (2..$e->{POINTERS}) { $ret.="*"; } - return $ret; -} -my $res = ""; -my $tabs = ""; -sub pidl($) -{ - my $d = shift; - if ($d) { - $res .= $tabs; - $res .= $d; - } - $res .="\n"; -} - -sub indent() -{ - $tabs .= "\t"; -} - -sub deindent() -{ - $tabs = substr($tabs, 0, -1); -} - -#################################################################### -# work out the name of a size_is() variable -sub ParseExpr($$$) -{ - my($e) = shift; - my($size) = shift; - my($var_prefix) = shift; - - my($fn) = $e->{PARENT}; - - return $size if (util::is_constant($size)); - - return $size if ($size =~ /ndr->|\(/); - - my $prefix = ""; - - if ($size =~ /\*(.*)/) { - $size = $1; - $prefix = "*"; - } - - if ($fn->{TYPE} ne "FUNCTION") { - return $prefix . "r->$size"; - } - - my $e2 = util::find_sibling($e, $size); - - die("Invalid sibling '$size'") unless defined($e2); - - if (util::has_property($e2, "in") && util::has_property($e2, "out")) { - return $prefix . "$var_prefix$size"; - } - - if (util::has_property($e2, "in")) { - return $prefix . "r->in.$size"; - } - - if (util::has_property($e2, "out")) { - return $prefix . "r->out.$size"; - } - - die "invalid variable in $size for element $e->{NAME} in $fn->{NAME}\n"; -} - -##################################################################### -# check that a variable we get from ParseExpr isn't a null pointer -sub check_null_pointer($) -{ - my $size = shift; - if ($size =~ /^\*/) { - my $size2 = substr($size, 1); - pidl "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;"; - } -} - -##################################################################### -# check that a variable we get from ParseExpr isn't a null pointer -# void return varient -sub check_null_pointer_void($) -{ - my $size = shift; - if ($size =~ /^\*/) { - my $size2 = substr($size, 1); - pidl "if ($size2 == NULL) return;"; - } -} - -##################################################################### -# work out is a parse function should be declared static or not -sub fn_prefix($) -{ - my $fn = shift; - - if ($fn->{TYPE} eq "TYPEDEF" or - $fn->{TYPE} eq "FUNCTION") { - return "" if (util::has_property($fn, "public")); - } - - return "static "; -} - -################################################################### -# setup any special flags for an element or structure -sub start_flags($) -{ - my $e = shift; - my $flags = util::has_property($e, "flag"); - if (defined $flags) { - pidl "{ uint32_t _flags_save_$e->{TYPE} = ndr->flags;"; - pidl "ndr_set_flags(&ndr->flags, $flags);"; - } -} - -################################################################### -# end any special flags for an element or structure -sub end_flags($) -{ - my $e = shift; - my $flags = util::has_property($e, "flag"); - if (defined $flags) { - pidl "ndr->flags = _flags_save_$e->{TYPE};\n\t}"; - } -} - -##################################################################### -# work out the correct alignment for a structure or union -sub find_largest_alignment($) -{ - my $s = shift; - - my $align = 1; - for my $e (@{$s->{ELEMENTS}}) { - my $a = 1; - - if (need_wire_pointer($e)) { - $a = 4; - } else { - $a = align_type($e->{TYPE}); - } - - $align = $a if ($align < $a); - } - - return $align; -} - -##################################################################### -# align a type -sub align_type -{ - my $e = shift; - - unless (typelist::hasType($e)) { - # it must be an external type - all we can do is guess - # print "Warning: assuming alignment of unknown type '$e' is 4\n"; - return 4; - } - - my $dt = typelist::getType($e)->{DATA}; - - my $tmp = $typefamily{$dt->{TYPE}}->{ALIGN}->($dt); - return $tmp; -} - -##################################################################### -# see if a type contains any deferred data -sub can_contain_deferred -{ - my $e = shift; - - return 1 if ($e->{POINTERS}); - return 0 if (is_scalar_type($e->{TYPE})); - return 0 if (util::has_property($e, "subcontext")); - return 1 unless (typelist::hasType($e->{TYPE})); # assume the worst - - my $type = typelist::getType($e->{TYPE}); - - foreach my $x (@{$type->{DATA}->{ELEMENTS}}) { - return 1 if (can_contain_deferred ($x)); - } - - return 0; -} - -##################################################################### -# parse array preceding data - push side -sub ParseArrayPushPreceding($$$) -{ - my $e = shift; - my $var_prefix = shift; - my $ndr_flags = shift; - - my $size = ParseExpr($e, util::array_size($e), $var_prefix); - - if (!is_inline_array($e)) { - # we need to emit the array size - pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));"; - } -} - -##################################################################### -# parse the data of an array - push side -sub ParseArrayPush($$$$) -{ - my $e = shift; - my $ndr = shift; - my $var_prefix = shift; - my $ndr_flags = shift; - my $cprefix = c_push_prefix($e); - - my $size = ParseExpr($e, util::array_size($e), $var_prefix); - - # See whether the array size has been pushed yet - if (!is_surrounding_array($e)) { - ParseArrayPushPreceding($e, $var_prefix, $ndr_flags); - } - - if (is_varying_array($e)) { - my $length = util::has_property($e, "length_is"); - $length = ParseExpr($e, $length, $var_prefix); - pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, 0));"; - pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $length));"; - $size = $length; - } - - if (is_scalar_type($e->{TYPE})) { - pidl "NDR_CHECK(ndr_push_array_$e->{TYPE}($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}, $size));"; - } else { - pidl "NDR_CHECK(ndr_push_array($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}, sizeof($cprefix$var_prefix$e->{NAME}\[0]), $size, (ndr_push_flags_fn_t)ndr_push_$e->{TYPE}));"; - } -} - -##################################################################### -# print an array -sub ParseArrayPrint($$) -{ - my $e = shift; - my $var_prefix = shift; - my $size = ParseExpr($e, util::array_size($e), $var_prefix); - my $cprefix = c_push_prefix($e); - - if (is_varying_array($e)) { - $size = ParseExpr($e, util::has_property($e, "length_is"), $var_prefix); - } - - if (is_scalar_type($e->{TYPE})) { - pidl "ndr_print_array_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME}, $size);"; - } else { - pidl "ndr_print_array(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME}, sizeof($cprefix$var_prefix$e->{NAME}\[0]), $size, (ndr_print_fn_t)ndr_print_$e->{TYPE});"; - } -} - -##################################################################### -# check the size_is and length_is constraints -sub CheckArraySizes($$) -{ - my $e = shift; - my $var_prefix = shift; - - if (is_conformant_array($e)) { - my $size = ParseExpr($e, util::array_size($e), $var_prefix); - pidl "if ($var_prefix$e->{NAME}) {"; - indent; - check_null_pointer($size); - pidl "NDR_CHECK(ndr_check_array_size(ndr, (void*)&$var_prefix$e->{NAME}, $size));"; - deindent; - pidl "}"; - } - - if (is_varying_array($e)) { - my $length = util::has_property($e, "length_is"); - $length = ParseExpr($e, $length, $var_prefix); - pidl "if ($var_prefix$e->{NAME}) {"; - indent; - check_null_pointer($length); - pidl "NDR_CHECK(ndr_check_array_length(ndr, (void*)&$var_prefix$e->{NAME}, $length));"; - deindent; - pidl "}" - } -} - -sub ParseArrayPullPreceding($$$) -{ - my $e = shift; - my $var_prefix = shift; - my $ndr_flags = shift; - - if (!is_inline_array($e)) { - # non fixed arrays encode the size just before the array - pidl "NDR_CHECK(ndr_pull_array_size(ndr, &$var_prefix$e->{NAME}));"; - } -} - -##################################################################### -# parse an array - pull side -sub ParseArrayPull($$$$) -{ - my $e = shift; - my $ndr = shift; - my $var_prefix = shift; - my $ndr_flags = shift; - - my $cprefix = c_pull_prefix($e); - my $length = ParseExpr($e, util::array_size($e), $var_prefix); - my $size = $length; - - if (is_conformant_array($e)) { - $length = $size = "ndr_get_array_size($ndr, &$var_prefix$e->{NAME})"; - } - - # if this is a conformant array then we use that size to allocate, and make sure - # we allocate enough to pull the elements - if (!is_inline_array($e) and not is_surrounding_array($e)) { - if ($var_prefix =~ /^r->out/ && $length =~ /^\*r->in/) { - my $length2 = substr($length, 1); - pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { NDR_ALLOC($ndr, $length2); }"; - } - - ParseArrayPullPreceding($e, $var_prefix, $ndr_flags); - } - - if (is_varying_array($e)) { - pidl "NDR_CHECK(ndr_pull_array_length($ndr, &$var_prefix$e->{NAME}));"; - $length = "ndr_get_array_length($ndr, &$var_prefix$e->{NAME})"; - } - - check_null_pointer($length); - - if ($length ne $size) { - pidl "if ($length > $size) {"; - indent; - pidl "return ndr_pull_error($ndr, NDR_ERR_CONFORMANT_SIZE, \"Bad conformant size %u should be %u\", $size, $length);"; - deindent; - pidl "}"; - } - - if ((need_alloc($e) && !is_fixed_array($e)) || - ($var_prefix eq "r->in." && util::has_property($e, "ref"))) { - if (!is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") { - pidl "NDR_ALLOC_N($ndr, $var_prefix$e->{NAME}, $size);"; - } - } - - if (($var_prefix eq "r->out." && util::has_property($e, "ref"))) { - if (!is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") { - pidl "if ($ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"; - pidl "\tNDR_ALLOC_N($ndr, $var_prefix$e->{NAME}, $size);"; - pidl "}"; - } - } - - if (is_scalar_type($e->{TYPE})) { - pidl "NDR_CHECK(ndr_pull_array_$e->{TYPE}($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}, $length));"; - } else { - pidl "NDR_CHECK(ndr_pull_array($ndr, $ndr_flags, (void **)$cprefix$var_prefix$e->{NAME}, sizeof($cprefix$var_prefix$e->{NAME}\[0]), $length, (ndr_pull_flags_fn_t)ndr_pull_$e->{TYPE}));"; - } -} - -sub ParseSubcontextPushStart($$) -{ - my $e = shift; - my $ndr_flags = shift; - - pidl "if (($ndr_flags) & NDR_SCALARS) {"; - indent; - pidl "struct ndr_push *_ndr_$e->{NAME};"; - pidl ""; - pidl "_ndr_$e->{NAME} = ndr_push_init_ctx(ndr);"; - pidl "if (!_ndr_$e->{NAME}) return NT_STATUS_NO_MEMORY;"; - pidl "_ndr_$e->{NAME}->flags = ndr->flags;"; - pidl ""; - - return "_ndr_$e->{NAME}"; -} - -sub ParseSubcontextPushEnd($) -{ - my $e = shift; - my $header_size = util::has_property($e, "subcontext"); - my $size_is = util::has_property($e, "subcontext_size"); - - if (not defined($size_is)) { - $size_is = "-1"; - } - - pidl "NDR_CHECK(ndr_push_subcontext_header(ndr, $header_size, $size_is, _ndr_$e->{NAME}));"; - pidl "NDR_CHECK(ndr_push_bytes(ndr, _ndr_$e->{NAME}->data, _ndr_$e->{NAME}->offset));"; - deindent; - pidl "}"; -} - -sub ParseSubcontextPullStart($$) -{ - my $e = shift; - my $ndr_flags = shift; - my $header_size = util::has_property($e, "subcontext"); - my $size_is = util::has_property($e, "subcontext_size"); - - if (not defined($size_is)) { - $size_is = "-1"; - } - - pidl "if (($ndr_flags) & NDR_SCALARS) {"; - indent; - pidl "struct ndr_pull *_ndr_$e->{NAME};"; - pidl "NDR_ALLOC(ndr, _ndr_$e->{NAME});"; - pidl "NDR_CHECK(ndr_pull_subcontext_header(ndr, $header_size, $size_is, _ndr_$e->{NAME}));"; - return "_ndr_$e->{NAME}"; -} - -sub ParseSubcontextPullEnd($) -{ - my $e = shift; - my $header_size = util::has_property($e, "subcontext"); - my $size_is = util::has_property($e, "subcontext_size"); - - my $advance; - if (defined ($size_is)) { - $advance = "$size_is"; - } elsif ($header_size) { - $advance = "_ndr_$e->{NAME}->data_size"; - } else { - $advance = "_ndr_$e->{NAME}->offset"; - } - pidl "NDR_CHECK(ndr_pull_advance(ndr, $advance));"; - deindent; - pidl "}"; -} - -##################################################################### -# parse scalars in a structure element -sub ParseElementPushScalar($$$) -{ - my($e) = shift; - my($var_prefix) = shift; - my($ndr_flags) = shift; - my $cprefix = c_push_prefix($e); - my $ptr_prefix = c_ptr_prefix($e); - my $sub_size = util::has_property($e, "subcontext"); - my $ndr = "ndr"; - - start_flags($e); - - if (my $value = util::has_property($e, "value")) { - pidl "$cprefix$var_prefix$e->{NAME} = $value;"; - } - - if (defined $sub_size and $e->{POINTERS} == 0) { - $ndr = ParseSubcontextPushStart($e, "NDR_SCALARS"); - } - - if (need_wire_pointer($e)) { - ParsePtrPush($e, $ptr_prefix.$var_prefix); - } elsif (is_inline_array($e)) { - ParseArrayPush($e, $ndr, "r->", "NDR_SCALARS"); - } elsif (need_alloc($e)) { - # no scalar component - } else { - if (my $switch = util::has_property($e, "switch_is")) { - ParseSwitchPush($e, $ndr, $var_prefix, $ndr_flags, $switch); - } - - pidl "NDR_CHECK(ndr_push_$e->{TYPE}($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));"; - } - - if (defined $sub_size and $e->{POINTERS} == 0) { - ParseSubcontextPushEnd($e); - } - - end_flags($e); -} - -##################################################################### -# parse a pointer in a struct element or function -sub ParsePtrPush($$) -{ - my $e = shift; - my $var_prefix = shift; - - if (util::has_property($e, "ref")) { - pidl "NDR_CHECK(ndr_push_ref_ptr(ndr, $var_prefix$e->{NAME}));"; - } elsif (util::has_property($e, "relative")) { - pidl "NDR_CHECK(ndr_push_relative_ptr1(ndr, $var_prefix$e->{NAME}));"; - } else { - pidl "NDR_CHECK(ndr_push_unique_ptr(ndr, $var_prefix$e->{NAME}));"; - } -} - -##################################################################### -# print scalars in a structure element -sub ParseElementPrint($$) -{ - my($e) = shift; - my($var_prefix) = shift; - my $cprefix = c_push_prefix($e); - my $ptr_prefix = c_ptr_prefix($e); - - return if (util::has_property($e, "noprint")); - - if (my $value = util::has_property($e, "value")) { - pidl "if (ndr->flags & LIBNDR_PRINT_SET_VALUES) {"; - pidl "\t$cprefix$var_prefix$e->{NAME} = $value;"; - pidl "}"; - } - - my $l = $e->{POINTERS}; - $l++ if (util::array_size($e) and $l == 0 and !is_fixed_array($e)); - - foreach my $i (1..$l) { - pidl "ndr_print_ptr(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME});"; - pidl "ndr->depth++;"; - if ($i > $l-need_wire_pointer($e)) { - pidl "if ($ptr_prefix$var_prefix$e->{NAME}) {"; - indent; - } - } - - if (util::array_size($e)) { - ParseArrayPrint($e, $var_prefix) - } elsif (my $switch = util::has_property($e, "switch_is")) { - my $switch_var = ParseExpr($e, $switch, $var_prefix); - check_null_pointer_void($switch_var); - - pidl "ndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $switch_var, $cprefix$var_prefix$e->{NAME});"; - } else { - pidl "ndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});"; - } - - foreach my $i (1..$l) { - if ($i > $l-need_wire_pointer($e)) { - deindent; - pidl "}"; - } - pidl "ndr->depth--;"; - } -} - -##################################################################### -# parse scalars in a structure element - pull size -sub ParseSwitchPull($$$$$) -{ - my($e) = shift; - my $ndr = shift; - my($var_prefix) = shift; - my($ndr_flags) = shift; - my $switch = shift; - my $switch_var = ParseExpr($e, $switch, $var_prefix); - - my $cprefix = c_pull_prefix($e); - - my $utype = typelist::getType($e->{TYPE}); - - check_null_pointer($switch_var); - - pidl "NDR_CHECK(ndr_pull_set_switch_value($ndr, $cprefix$var_prefix$e->{NAME}, $switch_var));"; - -} - -##################################################################### -# push switch element -sub ParseSwitchPush($$$$$) -{ - my($e) = shift; - my $ndr = shift; - my($var_prefix) = shift; - my($ndr_flags) = shift; - my $switch = shift; - my $switch_var = ParseExpr($e, $switch, $var_prefix); - my $cprefix = c_push_prefix($e); - - check_null_pointer($switch_var); - - pidl "NDR_CHECK(ndr_push_set_switch_value($ndr, $cprefix$var_prefix$e->{NAME}, $switch_var));"; - -} - -##################################################################### -# parse scalars in a structure element - pull size -sub ParseElementPullScalar($$$) -{ - my($e) = shift; - my($var_prefix) = shift; - my($ndr_flags) = shift; - my $cprefix = c_pull_prefix($e); - my $ptr_prefix = c_ptr_prefix($e); - my $sub_size = util::has_property($e, "subcontext"); - my $ndr = "ndr"; - - start_flags($e); - - if (defined $sub_size && $e->{POINTERS} == 0) { - $ndr = ParseSubcontextPullStart($e, $ndr_flags); - $ndr_flags = "NDR_SCALARS|NDR_BUFFERS"; - } - - if (is_inline_array($e)) { - ParseArrayPull($e, $ndr, "r->", "NDR_SCALARS"); - } elsif (need_wire_pointer($e)) { - ParsePtrPull($e, $ptr_prefix.$var_prefix); - } elsif (is_surrounding_array($e)) { - } else { - if (my $switch = util::has_property($e, "switch_is")) { - ParseSwitchPull($e, $ndr, $var_prefix, $ndr_flags, $switch); - } - - pidl "NDR_CHECK(ndr_pull_$e->{TYPE}($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));"; - } - - if (my $range = util::has_property($e, "range")) { - my ($low, $high) = split(/ /, $range, 2); - pidl "if ($var_prefix$e->{NAME} < $low || $var_prefix$e->{NAME} > $high) {"; - pidl "\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value out of range\");"; - pidl "}"; - } - - if (defined $sub_size && $e->{POINTERS} == 0) { - ParseSubcontextPullEnd($e); - } - - end_flags($e); -} - -##################################################################### -# parse a pointer in a struct element or function -sub ParsePtrPull($$) -{ - my($e) = shift; - my($var_prefix) = shift; - - if (util::has_property($e, "ref")) { - pidl "NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_$e->{NAME}));"; - } else { - pidl "NDR_CHECK(ndr_pull_unique_ptr(ndr, &_ptr_$e->{NAME}));"; - } - pidl "if (_ptr_$e->{NAME}) {"; - indent; - pidl "NDR_ALLOC(ndr, $var_prefix$e->{NAME});"; - if (util::has_property($e, "relative")) { - pidl "NDR_CHECK(ndr_pull_relative_ptr1(ndr, $var_prefix$e->{NAME}, _ptr_$e->{NAME}));"; - } - deindent; - pidl "} else {"; - pidl "\t$var_prefix$e->{NAME} = NULL;"; - pidl "}"; -} - -##################################################################### -# parse buffers in a structure element -sub ParseElementPushBuffer($$) -{ - my($e) = shift; - my($var_prefix) = shift; - my $cprefix = c_push_prefix($e); - my $sub_size = util::has_property($e, "subcontext"); - my $ndr = "ndr"; - - return unless (need_buffers_section($e)); - - start_flags($e); - - my $pointers = c_ptr_prefix($e); - for my $i (1..need_wire_pointer($e)) { - if ($i > 1) { - ParsePtrPush($e,$pointers.$var_prefix); - } - pidl "if ($pointers$var_prefix$e->{NAME}) {"; - indent; - $pointers.="*"; - } - - if (util::has_property($e, "relative")) { - pidl "NDR_CHECK(ndr_push_relative_ptr2(ndr, $var_prefix$e->{NAME}));"; - } - - my $ndr_flags = "NDR_BUFFERS"; - if ($e->{POINTERS} || (util::array_size($e) && !is_inline_array($e))) - { - $ndr_flags="NDR_SCALARS|$ndr_flags" - } - - if (defined $sub_size) { - $ndr = ParseSubcontextPushStart($e, $ndr_flags); - $ndr_flags = "NDR_SCALARS|NDR_BUFFERS"; - } - - if (util::array_size($e)) { - ParseArrayPush($e, $ndr, "r->", $ndr_flags); - } else { - if (my $switch = util::has_property($e, "switch_is")) { - ParseSwitchPush($e, $ndr, $var_prefix, $ndr_flags, $switch); - } - - pidl "NDR_CHECK(ndr_push_$e->{TYPE}($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));"; - } - - if (defined $sub_size) { - ParseSubcontextPushEnd($e); - } - - for my $i (1..need_wire_pointer($e)) { - deindent; - pidl "}"; - } - - end_flags($e); -} - -##################################################################### -# parse buffers in a structure element - pull side -sub ParseElementPullBuffer($$) -{ - my($e) = shift; - my($var_prefix) = shift; - my $cprefix = c_pull_prefix($e); - my $sub_size = util::has_property($e, "subcontext"); - my $ndr = "ndr"; - - return unless (need_buffers_section($e)); - - start_flags($e); - - my $pointers = c_ptr_prefix($e); - for my $i (1..need_wire_pointer($e)) { - if ($i > 1) { - ParsePtrPull($e,$pointers.$var_prefix); - } - pidl "if ($pointers$var_prefix$e->{NAME}) {"; - indent; - $pointers.="*"; - } - - if (util::has_property($e, "relative")) { - pidl "struct ndr_pull_save _relative_save;"; - pidl "ndr_pull_save(ndr, &_relative_save);"; - pidl "NDR_CHECK(ndr_pull_relative_ptr2(ndr, $var_prefix$e->{NAME}));"; - } - - my $ndr_flags = "NDR_BUFFERS"; - if ($e->{POINTERS} || (util::array_size($e) && !is_inline_array($e))) - { - $ndr_flags="NDR_SCALARS|$ndr_flags" - } - - if (defined $sub_size) { - $ndr = ParseSubcontextPullStart($e, $ndr_flags); - $ndr_flags = "NDR_SCALARS|NDR_BUFFERS"; - } - - if (util::array_size($e)) { - ParseArrayPull($e, $ndr, "r->", $ndr_flags); - } else { - if (my $switch = util::has_property($e, "switch_is")) { - ParseSwitchPull($e, $ndr, $var_prefix, $ndr_flags, $switch); - } - - pidl "NDR_CHECK(ndr_pull_$e->{TYPE}($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));"; - } - - if (defined $sub_size) { - ParseSubcontextPullEnd($e); - } - - if (util::has_property($e, "relative")) { - pidl "ndr_pull_restore(ndr, &_relative_save);"; - } - - for my $i (1..need_wire_pointer($e)) { - deindent; - pidl "}"; - } - - end_flags($e); -} - -##################################################################### -# parse a struct -sub ParseStructPush($) -{ - my($struct) = shift; - - return unless defined($struct->{ELEMENTS}); - - 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 push the conformant length early, as it fits on - # the wire before the structure (and even before the structure - # alignment) - my $e = $struct->{ELEMENTS}[-1]; - if (is_conformant_array($e) and is_surrounding_array($e)) { - ParseArrayPushPreceding($e, "r->", "NDR_SCALARS"); - } - - if (defined $e->{TYPE} && $e->{TYPE} eq "string" - && util::property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) { - pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, r->$e->{NAME})));"; - } - - pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;"; - - pidl "NDR_CHECK(ndr_push_struct_start(ndr));"; - - my $align = find_largest_alignment($struct); - pidl "NDR_CHECK(ndr_push_align(ndr, $align));"; - - foreach my $e (@{$struct->{ELEMENTS}}) { - ParseElementPushScalar($e, "r->", "NDR_SCALARS"); - } - - pidl "buffers:"; - pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;"; - foreach my $e (@{$struct->{ELEMENTS}}) { - ParseElementPushBuffer($e, "r->"); - } - - pidl "ndr_push_struct_end(ndr);"; - - pidl "done:"; - - end_flags($struct); -} - -##################################################################### -# generate a push function for an enum -sub ParseEnumPush($) -{ - my($enum) = shift; - my($type_fn) = typelist::enum_type_fn($enum); - - start_flags($enum); - - pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));"; - - end_flags($enum); -} - -##################################################################### -# generate a pull function for an enum -sub ParseEnumPull($) -{ - my($enum) = shift; - my($type_fn) = typelist::enum_type_fn($enum); - my($type_v_decl) = typelist::mapScalarType(typelist::enum_type_fn($enum)); - - pidl "$type_v_decl v;"; - start_flags($enum); - pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));"; - pidl "*r = v;"; - - end_flags($enum); -} - -##################################################################### -# generate a print function for an enum -sub ParseEnumPrint($) -{ - my($enum) = shift; - - pidl "const char *val = NULL;"; - pidl ""; - - start_flags($enum); - - pidl "switch (r) {"; - indent; - my $els = \@{$enum->{ELEMENTS}}; - foreach my $i (0 .. $#{$els}) { - my $e = ${$els}[$i]; - chomp $e; - if ($e =~ /^(.*)=/) { - $e = $1; - } - pidl "case $e: val = \"$e\"; break;"; - } - - deindent; - pidl "}"; - - pidl "ndr_print_enum(ndr, name, \"$enum->{TYPE}\", val, r);"; - - end_flags($enum); -} - -sub ArgsEnumPush($) -{ - my $e = shift; - return "struct ndr_push *ndr, int ndr_flags, enum $e->{NAME} r"; -} - -sub ArgsEnumPrint($) -{ - my $e = shift; - return "struct ndr_print *ndr, const char *name, enum $e->{NAME} r"; -} - -sub ArgsEnumPull($) -{ - my $e = shift; - return "struct ndr_pull *ndr, int ndr_flags, enum $e->{NAME} *r"; -} - -$typefamily{ENUM} = { - PUSH_FN_BODY => \&ParseEnumPush, - PUSH_FN_ARGS => \&ArgsEnumPush, - PULL_FN_BODY => \&ParseEnumPull, - PULL_FN_ARGS => \&ArgsEnumPull, - PRINT_FN_BODY => \&ParseEnumPrint, - PRINT_FN_ARGS => \&ArgsEnumPrint, - ALIGN => sub { return align_type(typelist::enum_type_fn(shift)); } -}; - -##################################################################### -# generate a push function for a bitmap -sub ParseBitmapPush($) -{ - my($bitmap) = shift; - my($type_fn) = typelist::bitmap_type_fn($bitmap); - - start_flags($bitmap); - - pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));"; - - end_flags($bitmap); -} - -##################################################################### -# generate a pull function for an bitmap -sub ParseBitmapPull($) -{ - my($bitmap) = shift; - my($type_fn) = typelist::bitmap_type_fn($bitmap); - my($type_decl) = typelist::mapType($bitmap); - - pidl "$type_decl v;"; - start_flags($bitmap); - pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));"; - pidl "*r = v;"; - - end_flags($bitmap); -} - -##################################################################### -# generate a print function for an bitmap -sub ParseBitmapPrintElement($$) -{ - my($e) = shift; - my($bitmap) = shift; - my($type_decl) = typelist::mapType($bitmap); - my($type_fn) = typelist::bitmap_type_fn($bitmap); - my($name) = $bitmap->{PARENT}->{NAME}; - my($flag); - - if ($e =~ /^(\w+) .*$/) { - $flag = "$1"; - } else { - die "Bitmap: \"$name\" invalid Flag: \"$e\""; - } - - pidl "ndr_print_bitmap_flag(ndr, sizeof($type_decl), \"$flag\", $flag, r);"; -} - -##################################################################### -# generate a print function for an bitmap -sub ParseBitmapPrint($) -{ - my($bitmap) = shift; - my($type_decl) = typelist::mapType($bitmap); - my($type_fn) = typelist::bitmap_type_fn($bitmap); - - start_flags($bitmap); - - pidl "ndr_print_$type_fn(ndr, name, r);"; - - pidl "ndr->depth++;"; - foreach my $e (@{$bitmap->{ELEMENTS}}) { - ParseBitmapPrintElement($e, $bitmap); - } - pidl "ndr->depth--;"; - - end_flags($bitmap); -} - -sub ArgsBitmapPush($) -{ - my $e = shift; - my $type_decl = typelist::mapType($e->{DATA}); - return "struct ndr_push *ndr, int ndr_flags, $type_decl r"; -} - -sub ArgsBitmapPrint($) -{ - my $e = shift; - my $type_decl = typelist::mapType($e->{DATA}); - return "struct ndr_print *ndr, const char *name, $type_decl r"; -} - -sub ArgsBitmapPull($) -{ - my $e = shift; - my $type_decl = typelist::mapType($e->{DATA}); - return "struct ndr_pull *ndr, int ndr_flags, $type_decl *r"; -} - -$typefamily{BITMAP} = { - PUSH_FN_BODY => \&ParseBitmapPush, - PUSH_FN_ARGS => \&ArgsBitmapPush, - PULL_FN_BODY => \&ParseBitmapPull, - PULL_FN_ARGS => \&ArgsBitmapPull, - PRINT_FN_BODY => \&ParseBitmapPrint, - PRINT_FN_ARGS => \&ArgsBitmapPrint, - ALIGN => sub { return align_type(typelist::bitmap_type_fn(shift)); } -}; - -##################################################################### -# generate a struct print function -sub ParseStructPrint($) -{ - my($struct) = shift; - my($name) = $struct->{PARENT}->{NAME}; - - return unless defined $struct->{ELEMENTS}; - - pidl "ndr_print_struct(ndr, name, \"$name\");"; - - start_flags($struct); - - pidl "ndr->depth++;"; - foreach my $e (@{$struct->{ELEMENTS}}) { - ParseElementPrint($e, "r->"); - } - pidl "ndr->depth--;"; - - end_flags($struct); -} - -##################################################################### -# parse a struct - pull side -sub ParseStructPull($) -{ - my($struct) = shift; - my $conform_e; - - return unless defined $struct->{ELEMENTS}; - - # 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 - # the wire before the structure (and even before the structure - # alignment) - my $e = $struct->{ELEMENTS}[-1]; - if (is_conformant_array($e) and is_surrounding_array($e)) { - $conform_e = $e; - } - - if (defined $e->{TYPE} && $e->{TYPE} eq "string" - && util::property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) { - $conform_e = $e; - } - - # declare any internal pointers we need - foreach my $e (@{$struct->{ELEMENTS}}) { - if (need_wire_pointer($e)) { - pidl "uint32_t _ptr_$e->{NAME};"; - } - } - - start_flags($struct); - - pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;"; - - pidl "NDR_CHECK(ndr_pull_struct_start(ndr));"; - - if (defined $conform_e) { - ParseArrayPullPreceding($conform_e, "r->", "NDR_SCALARS"); - } - - my $align = find_largest_alignment($struct); - pidl "NDR_CHECK(ndr_pull_align(ndr, $align));"; - - foreach my $e (@{$struct->{ELEMENTS}}) { - ParseElementPullScalar($e, "r->", "NDR_SCALARS"); - } - - pidl "buffers:\n"; - pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;"; - foreach my $e (@{$struct->{ELEMENTS}}) { - ParseElementPullBuffer($e, "r->"); - } - - foreach my $e (@{$struct->{ELEMENTS}}) { - CheckArraySizes($e, "r->"); - } - - pidl "ndr_pull_struct_end(ndr);"; - - pidl "done:"; - - end_flags($struct); -} - -##################################################################### -# calculate size of ndr struct -sub ParseStructNdrSize($) -{ - my $t = shift; - my $static = fn_prefix($t); - my $sizevar; - - if (my $flags = util::has_property($t, "flag")) { - pidl "flags |= $flags;"; - } - pidl "return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});"; -} - -sub ArgsStructPush($) -{ - my $e = shift; - return "struct ndr_push *ndr, int ndr_flags, struct $e->{NAME} *r"; -} - -sub ArgsStructPrint($) -{ - my $e = shift; - return "struct ndr_print *ndr, const char *name, struct $e->{NAME} *r"; -} - -sub ArgsStructPull($) -{ - my $e = shift; - return "struct ndr_pull *ndr, int ndr_flags, struct $e->{NAME} *r"; -} - -sub ArgsStructNdrSize($) -{ - my $d = shift; - return "const struct $d->{NAME} *r, int flags"; -} - -$typefamily{STRUCT} = { - PUSH_FN_BODY => \&ParseStructPush, - PUSH_FN_ARGS => \&ArgsStructPush, - PULL_FN_BODY => \&ParseStructPull, - PULL_FN_ARGS => \&ArgsStructPull, - PRINT_FN_BODY => \&ParseStructPrint, - PRINT_FN_ARGS => \&ArgsStructPrint, - SIZE_FN_BODY => \&ParseStructNdrSize, - SIZE_FN_ARGS => \&ArgsStructNdrSize, - ALIGN => \&find_largest_alignment -}; - -##################################################################### -# calculate size of ndr struct -sub ParseUnionNdrSize($) -{ - my $t = shift; - my $static = fn_prefix($t); - my $sizevar; - - if (my $flags = util::has_property($t, "flag")) { - pidl "flags |= $flags;"; - } - pidl "return ndr_size_union(r, flags, level, (ndr_push_union_fn_t)ndr_push_$t->{NAME});"; -} - -##################################################################### -# parse a union - push side -sub ParseUnionPush($) -{ - my $e = shift; - my $have_default = 0; - - pidl "int level;"; - - start_flags($e); - - pidl "level = ndr_push_get_switch_value(ndr, r);"; - - pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;"; - - if (!util::has_property($e, "nodiscriminant")) { - my $switch_type = util::has_property($e, "switch_type"); - $switch_type = "uint32" unless (defined ($switch_type)); - pidl "NDR_CHECK(ndr_push_$switch_type(ndr, NDR_SCALARS, level));"; - } - - pidl "NDR_CHECK(ndr_push_struct_start(ndr));"; - -# my $align = union_alignment($e); -# pidl "NDR_CHECK(ndr_push_align(ndr, $align));"; - - pidl "switch (level) {"; - indent; - foreach my $el (@{$e->{ELEMENTS}}) { - if (util::has_property($el, "default")) { - pidl "default:"; - $have_default = 1; - } else { - pidl "case $el->{PROPERTIES}->{case}:"; - - } - if ($el->{TYPE} ne "EMPTY") { - indent; - ParseElementPushScalar($el, "r->", "NDR_SCALARS"); - deindent; - } - pidl "break;"; - pidl ""; - } - if (! $have_default) { - pidl "default:"; - pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; - } - deindent; - pidl "}"; - pidl "buffers:"; - pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;"; - pidl "switch (level) {"; - indent; - foreach my $el (@{$e->{ELEMENTS}}) { - if (util::has_property($el, "default")) { - pidl "default:"; - } else { - pidl "case $el->{PROPERTIES}->{case}:"; - } - if ($el->{TYPE} ne "EMPTY") { - indent; - ParseElementPushBuffer($el, "r->"); - deindent; - } - pidl "break;"; - pidl ""; - } - if (! $have_default) { - pidl "default:"; - pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; - } - deindent; - pidl "}"; - pidl "ndr_push_struct_end(ndr);"; - pidl "done:"; - end_flags($e); -} - -##################################################################### -# print a union -sub ParseUnionPrint($) -{ - my $e = shift; - my $have_default = 0; - my($name) = $e->{PARENT}->{NAME}; - - pidl "ndr_print_union(ndr, name, level, \"$name\");"; - start_flags($e); - - pidl "switch (level) {"; - indent; - foreach my $el (@{$e->{ELEMENTS}}) { - if (util::has_property($el, "default")) { - $have_default = 1; - pidl "default:"; - } else { - pidl "case $el->{PROPERTIES}->{case}:"; - } - if ($el->{TYPE} ne "EMPTY") { - indent; - ParseElementPrint($el, "r->"); - deindent; - } - pidl "break;"; - pidl ""; - } - if (! $have_default) { - pidl "default:"; - pidl "\tndr_print_bad_level(ndr, name, level);"; - } - deindent; - pidl "}"; - - end_flags($e); -} - -##################################################################### -# parse a union - pull side -sub ParseUnionPull($) -{ - my $e = shift; - my $have_default = 0; - my $switch_type = util::has_property($e, "switch_type"); - $switch_type = "uint32" unless defined($switch_type); - - pidl "int level;"; - if (!util::has_property($e, "nodiscriminant")) { - if (typelist::typeIs($switch_type, "ENUM")) { - $switch_type = typelist::enum_type_fn(typelist::getType($switch_type)); - } - pidl typelist::mapScalarType($switch_type) . " _level;"; - } - - start_flags($e); - - pidl "level = ndr_pull_get_switch_value(ndr, r);"; - - pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;"; - - if (!util::has_property($e, "nodiscriminant")) { - pidl "NDR_CHECK(ndr_pull_$switch_type(ndr, NDR_SCALARS, &_level));"; - pidl "if (_level != level) {"; - pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u for $e->{PARENT}->{NAME}\", _level);"; - pidl "}"; - } - - pidl "NDR_CHECK(ndr_pull_struct_start(ndr));"; - -# my $align = union_alignment($e); -# pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n"; - - pidl "switch (level) {"; - indent; - foreach my $el (@{$e->{ELEMENTS}}) { - if (util::has_property($el, "default")) { - pidl "default: {"; - $have_default = 1; - } else { - pidl "case $el->{PROPERTIES}->{case}: {"; - } - if ($el->{TYPE} ne "EMPTY") { - indent; - if ($el->{POINTERS}) { - pidl "uint32_t _ptr_$el->{NAME};"; - } - ParseElementPullScalar($el, "r->", "NDR_SCALARS"); - deindent; - } - pidl "break; }"; - pidl ""; - } - if (! $have_default) { - pidl "default:"; - pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; - } - deindent; - pidl "}"; - pidl "buffers:"; - pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;"; - pidl "switch (level) {"; - indent; - foreach my $el (@{$e->{ELEMENTS}}) { - if (util::has_property($el, "default")) { - pidl "default:"; - } else { - pidl "case $el->{PROPERTIES}->{case}:"; - } - if ($el->{TYPE} ne "EMPTY") { - indent; - ParseElementPullBuffer($el, "r->"); - deindent; - } - pidl "break;"; - pidl ""; - } - if (! $have_default) { - pidl "default:"; - pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; - } - deindent; - pidl "}"; - pidl "ndr_pull_struct_end(ndr);"; - pidl "done:"; - end_flags($e); -} - -sub ArgsUnionPush($) -{ - my $e = shift; - return "struct ndr_push *ndr, int ndr_flags, union $e->{NAME} *r"; -} - -sub ArgsUnionPrint($) -{ - my $e = shift; - return "struct ndr_print *ndr, const char *name, int level, union $e->{NAME} *r"; -} - -sub ArgsUnionPull($) -{ - my $e = shift; - return "struct ndr_pull *ndr, int ndr_flags, union $e->{NAME} *r"; -} - -sub ArgsUnionNdrSize($) -{ - my $d = shift; - return "const union $d->{NAME} *r, uint32_t level, int flags"; -} - -$typefamily{UNION} = { - PUSH_FN_BODY => \&ParseUnionPush, - PUSH_FN_ARGS => \&ArgsUnionPush, - PULL_FN_BODY => \&ParseUnionPull, - PULL_FN_ARGS => \&ArgsUnionPull, - PRINT_FN_BODY => \&ParseUnionPrint, - PRINT_FN_ARGS => \&ArgsUnionPrint, - SIZE_FN_ARGS => \&ArgsUnionNdrSize, - SIZE_FN_BODY => \&ParseUnionNdrSize, - ALIGN => \&find_largest_alignment -}; - -##################################################################### -# parse a typedef - push side -sub ParseTypedefPush($) -{ - my($e) = shift; - my $static = fn_prefix($e); - - return unless needed::is_needed("push_$e->{NAME}"); - - my $args = $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_ARGS}->($e); - pidl $static . "NTSTATUS ndr_push_$e->{NAME}($args)"; - - pidl "{"; - indent; - $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($e->{DATA}); - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}"; - pidl "";; -} - - -##################################################################### -# parse a typedef - pull side -sub ParseTypedefPull($) -{ - my($e) = shift; - my $static = fn_prefix($e); - - return unless needed::is_needed("pull_$e->{NAME}"); - - my $args = $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_ARGS}->($e); - - pidl $static . "NTSTATUS ndr_pull_$e->{NAME}($args)"; - - pidl "{"; - indent; - $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA}); - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}"; - pidl ""; -} - -##################################################################### -# parse a typedef - print side -sub ParseTypedefPrint($) -{ - my($e) = shift; - - my $args = $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_ARGS}->($e); - - return unless !util::has_property($e, "noprint"); - - pidl "void ndr_print_$e->{NAME}($args)"; - pidl "{"; - indent; - $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA}); - deindent; - pidl "}"; -} - -##################################################################### -## calculate the size of a structure -sub ParseTypedefNdrSize($) -{ - my($t) = shift; - - return unless needed::is_needed("ndr_size_$t->{NAME}"); - - my $tf = $typefamily{$t->{DATA}->{TYPE}}; - my $args = $tf->{SIZE_FN_ARGS}->($t); - - pidl "size_t ndr_size_$t->{NAME}($args)"; - pidl "{"; - indent; - $typefamily{$t->{DATA}->{TYPE}}->{SIZE_FN_BODY}->($t); - deindent; - pidl "}"; - pidl ""; -} - -##################################################################### -# parse a function - print side -sub ParseFunctionPrint($) -{ - my($fn) = shift; - - return unless !util::has_property($fn, "noprint"); - - pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, struct $fn->{NAME} *r)"; - pidl "{"; - indent; - pidl "ndr_print_struct(ndr, name, \"$fn->{NAME}\");"; - pidl "ndr->depth++;"; - - pidl "if (flags & NDR_SET_VALUES) {"; - pidl "\tndr->flags |= LIBNDR_PRINT_SET_VALUES;"; - pidl "}"; - - pidl "if (flags & NDR_IN) {"; - indent; - pidl "ndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");"; - pidl "ndr->depth++;"; - - foreach my $e (@{$fn->{ELEMENTS}}) { - if (util::has_property($e, "in")) { - ParseElementPrint($e, "r->in."); - } - } - pidl "ndr->depth--;"; - deindent; - pidl "}"; - - pidl "if (flags & NDR_OUT) {"; - indent; - pidl "ndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");"; - pidl "ndr->depth++;"; - foreach my $e (@{$fn->{ELEMENTS}}) { - if (util::has_property($e, "out")) { - ParseElementPrint($e, "r->out."); - } - } - if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") { - my $cprefix = "&"; - $cprefix = "" if (is_scalar_type($fn->{RETURN_TYPE})) ; # FIXME: Should really use util::c_push_prefix here - pidl "ndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", $cprefix"."r->out.result);"; - } - pidl "ndr->depth--;"; - deindent; - pidl "}"; - - pidl "ndr->depth--;"; - deindent; - pidl "}"; - pidl ""; -} - -##################################################################### -# parse a function element -sub ParseFunctionElementPush($$) -{ - my $e = shift; - my $inout = shift; - - if (util::array_size($e)) { - if (need_wire_pointer($e)) { - ParsePtrPush($e, "r->$inout."); - pidl "if (r->$inout.$e->{NAME}) {"; - indent; - ParseArrayPush($e, "ndr", "r->$inout.", "NDR_SCALARS|NDR_BUFFERS"); - deindent; - pidl "}"; - } else { - ParseArrayPush($e, "ndr", "r->$inout.", "NDR_SCALARS|NDR_BUFFERS"); - } - } else { - ParseElementPushScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS"); - if (need_wire_pointer($e)) { - ParseElementPushBuffer($e, "r->$inout."); - } - } -} - -##################################################################### -# parse a function -sub ParseFunctionPush($) -{ - my($fn) = shift; - my $static = fn_prefix($fn); - - return unless !util::has_property($fn, "nopush"); - - pidl $static . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, struct $fn->{NAME} *r)"; - pidl "{"; - indent; - - pidl "if (!(flags & NDR_IN)) goto ndr_out;"; - pidl ""; - - foreach my $e (@{$fn->{ELEMENTS}}) { - if (util::has_property($e, "in")) { - if (util::has_property($e, "ref")) { - check_null_pointer("*r->in.$e->{NAME}"); - } - ParseFunctionElementPush($e, "in"); - } - } - - pidl "ndr_out:"; - pidl "if (!(flags & NDR_OUT)) goto done;"; - pidl ""; - - foreach my $e (@{$fn->{ELEMENTS}}) { - if (util::has_property($e, "out")) { - if (util::has_property($e, "ref")) { - check_null_pointer("*r->out.$e->{NAME}"); - } - ParseFunctionElementPush($e, "out"); - } - } - - if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") { - pidl "NDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, r->out.result));"; - } - - pidl "done:"; - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}"; - pidl ""; -} - -##################################################################### -# parse a function element -sub ParseFunctionElementPull($$) -{ - my $e = shift; - my $inout = shift; - - if (util::array_size($e)) { - if (need_wire_pointer($e)) { - pidl "NDR_CHECK(ndr_pull_unique_ptr(ndr, &_ptr_$e->{NAME}));"; - pidl "r->$inout.$e->{NAME} = NULL;"; - pidl "if (_ptr_$e->{NAME}) {"; - indent; - } elsif ($inout eq "out" && util::has_property($e, "ref")) { - pidl "if (r->$inout.$e->{NAME}) {"; - indent; - } - - ParseArrayPull($e, "ndr", "r->$inout.", "NDR_SCALARS|NDR_BUFFERS"); - - if (need_wire_pointer($e) or ($inout eq "out" and util::has_property($e, "ref"))) { - deindent; - pidl "}"; - } - } else { - if ($inout eq "out" && util::has_property($e, "ref")) { - pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"; - pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});"; - pidl "}"; - } - - if ($inout eq "in" && util::has_property($e, "ref")) { - pidl "NDR_ALLOC(ndr, r->in.$e->{NAME});"; - } - - ParseElementPullScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS"); - if (need_wire_pointer($e)) { - ParseElementPullBuffer($e, "r->$inout."); - } - } -} - -############################################################ -# 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 "NDR_ALLOC(ndr, r->out.$e->{NAME});"; - if (util::has_property($e, "in")) { - pidl "*r->out.$e->{NAME} = *r->in.$e->{NAME};"; - } else { - pidl "ZERO_STRUCTP(r->out.$e->{NAME});"; - } - return; - } - - # its an array - my $size = ParseExpr($e, $asize, "r->out."); - check_null_pointer($size); - pidl "NDR_ALLOC_N(ndr, r->out.$e->{NAME}, $size);"; - if (util::has_property($e, "in")) { - pidl "memcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));"; - } else { - pidl "memset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));"; - } -} - -##################################################################### -# parse a function -sub ParseFunctionPull($) -{ - my($fn) = shift; - my $static = fn_prefix($fn); - - return unless !util::has_property($fn, "nopull"); - - # pull function args - pidl $static . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)"; - pidl "{"; - indent; - - # declare any internal pointers we need - foreach my $e (@{$fn->{ELEMENTS}}) { - if (need_wire_pointer($e)) { - pidl "uint32_t _ptr_$e->{NAME};"; - } - } - - pidl "if (!(flags & NDR_IN)) goto ndr_out;"; - pidl ""; - - # 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->{ELEMENTS}}) { - if (util::has_property($e, "out")) { - pidl "ZERO_STRUCT(r->out);"; - pidl ""; - last; - } - } - - foreach my $e (@{$fn->{ELEMENTS}}) { - 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->{ELEMENTS}}) { - if (util::has_property($e, "in")) { - CheckArraySizes($e, "r->in."); - } - } - - pidl "ndr_out:"; - pidl "if (!(flags & NDR_OUT)) goto done;"; - pidl ""; - - foreach my $e (@{$fn->{ELEMENTS}}) { - if (util::has_property($e, "out")) { - ParseFunctionElementPull($e, "out"); - } - } - - foreach my $e (@{$fn->{ELEMENTS}}) { - if (util::has_property($e, "out")) { - CheckArraySizes($e, "r->out."); - } - } - - if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") { - pidl "NDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, &r->out.result));"; - } - - pidl "done:"; - pidl ""; - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}"; - pidl ""; -} - -##################################################################### -# produce a function call table -sub FunctionTable($) -{ - my($interface) = shift; - 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 $interface->{NAME}\_calls[] = {"; - foreach my $d (@{$data}) { - if ($d->{TYPE} eq "FUNCTION") { - pidl "\t{"; - pidl "\t\t\"$d->{NAME}\","; - pidl "\t\tsizeof(struct $d->{NAME}),"; - pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},"; - pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},"; - pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME}"; - pidl "\t},"; - } - } - pidl "\t{ NULL, 0, NULL, NULL, NULL }"; - pidl "};"; - pidl ""; - - # 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[] = {"; - foreach my $ep (@e) { - pidl "\t$ep, "; - } - pidl "};"; - pidl ""; - - pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {"; - pidl "\t.count\t= $endpoint_count,"; - pidl "\t.names\t= $interface->{NAME}\_endpoint_strings"; - pidl "};"; - pidl ""; - - if (! defined $interface->{PROPERTIES}->{authservice}) { - $interface->{PROPERTIES}->{authservice} = "\"host\""; - } - - my @a = split / /, $interface->{PROPERTIES}->{authservice}; - my $authservice_count = $#a + 1; - - pidl "static const char * const $interface->{NAME}\_authservice_strings[] = {"; - foreach my $ap (@a) { - pidl "\t$ap, "; - } - pidl "};"; - pidl ""; - - pidl "static const struct dcerpc_authservice_list $interface->{NAME}\_authservices = {"; - pidl "\t.count\t= $endpoint_count,"; - pidl "\t.names\t= $interface->{NAME}\_authservice_strings"; - pidl "};"; - pidl ""; - - pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {"; - pidl "\t.name\t\t= \"$interface->{NAME}\","; - pidl "\t.uuid\t\t= DCERPC_$uname\_UUID,"; - pidl "\t.if_version\t= DCERPC_$uname\_VERSION,"; - pidl "\t.helpstring\t= DCERPC_$uname\_HELPSTRING,"; - pidl "\t.num_calls\t= $count,"; - pidl "\t.calls\t\t= $interface->{NAME}\_calls,"; - pidl "\t.endpoints\t= &$interface->{NAME}\_endpoints,"; - pidl "\t.authservices\t= &$interface->{NAME}\_authservices"; - pidl "};"; - pidl ""; - - pidl "static NTSTATUS dcerpc_ndr_$interface->{NAME}_init(void)"; - pidl "{"; - pidl "\treturn librpc_register_interface(&dcerpc_table_$interface->{NAME});"; - pidl "}"; - pidl ""; -} - -##################################################################### -# parse the interface definitions -sub ParseInterface($) -{ - my($interface) = shift; - my($data) = $interface->{DATA}; - - # Push functions - foreach my $d (@{$data}) { - ($d->{TYPE} eq "TYPEDEF") && - ParseTypedefPush($d); - ($d->{TYPE} eq "FUNCTION") && - ParseFunctionPush($d); - } - - # Pull functions - foreach my $d (@{$data}) { - ($d->{TYPE} eq "TYPEDEF") && - ParseTypedefPull($d); - ($d->{TYPE} eq "FUNCTION") && - ParseFunctionPull($d); - } - - # Print functions - foreach my $d (@{$data}) { - ($d->{TYPE} eq "TYPEDEF") && - ParseTypedefPrint($d); - ($d->{TYPE} eq "FUNCTION") && - ParseFunctionPrint($d); - } - - # Size functions - foreach my $d (@{$data}) { - ($d->{TYPE} eq "TYPEDEF") && - ParseTypedefNdrSize($d); - } - - FunctionTable($interface); -} - -sub RegistrationFunction($$) -{ - my $idl = shift; - my $filename = shift; - - $filename =~ /.*\/ndr_(.*).c/; - my $basename = $1; - pidl "NTSTATUS dcerpc_$basename\_init(void)"; - pidl "{"; - indent; - pidl "NTSTATUS status = NT_STATUS_OK;"; - 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++; } - } - - next if ($count == 0); - - pidl "status = dcerpc_ndr_$interface->{NAME}_init();"; - pidl "if (NT_STATUS_IS_ERR(status)) {"; - pidl "\treturn status;"; - pidl "}"; - pidl ""; - } - pidl "return status;"; - deindent; - pidl "}"; - pidl ""; -} - -sub CheckPointerTypes($$) -{ - my $s = shift; - my $default = shift; - - foreach my $e (@{$s->{ELEMENTS}}) { - if ($e->{POINTERS}) { - if (not defined(pointer_type($e))) { - $e->{PROPERTIES}->{$default} = 1; - } - - if (pointer_type($e) eq "ptr") { - print "Warning: ptr is not supported by pidl yet\n"; - } - } - } -} - -sub LoadInterface($) -{ - my $x = shift; - - if (not util::has_property($x, "pointer_default")) { - # MIDL defaults to "ptr" in DCE compatible mode (/osf) - # and "unique" in Microsoft Extensions mode (default) - $x->{PROPERTIES}->{pointer_default} = "unique"; - } - - foreach my $d (@{$x->{DATA}}) { - if (($d->{TYPE} eq "DECLARE") or ($d->{TYPE} eq "TYPEDEF")) { - if ($d->{DATA}->{TYPE} eq "STRUCT" or $d->{DATA}->{TYPE} eq "UNION") { - CheckPointerTypes($d->{DATA}, $x->{PROPERTIES}->{pointer_default}); - } - - if (defined($d->{PROPERTIES}) && !defined($d->{DATA}->{PROPERTIES})) { - $d->{DATA}->{PROPERTIES} = $d->{PROPERTIES}; - } - } - if ($d->{TYPE} eq "FUNCTION") { - CheckPointerTypes($d, - $x->{PROPERTIES}->{pointer_default} # MIDL defaults to "ref" - ); - } - } -} - -sub Load($) -{ - my $idl = shift; - - foreach my $x (@{$idl}) { - LoadInterface($x); - } -} - -##################################################################### -# parse a parsed IDL structure back into an IDL file -sub Parse($$) -{ - my($idl) = shift; - my($filename) = shift; - my $h_filename = $filename; - $res = ""; - - Load($idl); - - if ($h_filename =~ /(.*)\.c/) { - $h_filename = "$1.h"; - } - - pidl "/* parser auto-generated by pidl */"; - pidl ""; - pidl "#include \"includes.h\""; - pidl "#include \"$h_filename\""; - pidl ""; - - foreach my $x (@{$idl}) { - if ($x->{TYPE} eq "INTERFACE") { - needed::BuildNeeded($x); - ParseInterface($x); - } - } - - RegistrationFunction($idl, $filename); - - return $res; -} - -1; |