Debian Codegraph @

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

raw
1 ###################################################
2 # Samba4 NDR parser generator for IDL structures
3 # Copyright [email protected] 2000-2003
4 # Copyright [email protected] 2001
5 # Copyright [email protected] 2004-2006
6 # released under the GNU GPL
7
8 package Parse::Pidl::Samba4::NDR::Parser;
9 use parent Parse::Pidl::Base;
10
11 require Exporter;
12 push @ISA, qw(Exporter);
13 @EXPORT_OK = qw(check_null_pointer NeededFunction NeededElement NeededType $res NeededInterface TypeFunctionName ParseElementPrint);
14
15 use strict;
16 use warnings;
17 use Parse::Pidl::Typelist qw(hasType getType mapTypeName mapTypeSpecifier typeHasBody);
18 use Parse::Pidl::Util qw(has_property
19 ParseExpr
20 ParseExprExt
21 print_uuid
22 unmake_str
23 parse_int
24 parse_range);
25 use Parse::Pidl::CUtil qw(get_pointer_to get_value_of get_array_element);
26 use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred ContainsPipe is_charset_array);
27 use Parse::Pidl::Samba4 qw(is_intree choose_header ArrayDynamicallyAllocated);
28 use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv);
29 use Parse::Pidl qw(warning);
30
31 use vars qw($VERSION);
32 $VERSION = '0.01';
33
34 # list of known types
35 my %typefamily;
36
37 sub new($$) {
38 my ($class) = @_;
39 my $self = { res => "", res_hdr => "", deferred => [], tabs => "", defer_tabs => "" };
40 bless($self, $class);
41 }
42
43 sub get_typefamily($)
44 {
45 my $n = shift;
46 return $typefamily{$n};
47 }
48
49 sub append_prefix($$)
50 {
51 my ($e, $var_name) = @_;
52 my $pointers = 0;
53 my $arrays = 0;
54
55 foreach my $l (@{$e->{LEVELS}}) {
56 if ($l->{TYPE} eq "POINTER") {
57 $pointers++;
58 } elsif ($l->{TYPE} eq "ARRAY") {
59 $arrays++;
60 if (($pointers == 0) and
61 (not $l->{IS_FIXED}) and
62 (not $l->{IS_INLINE})) {
63 return get_value_of($var_name);
64 }
65 } elsif ($l->{TYPE} eq "DATA") {
66 if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
67 return get_value_of($var_name) unless ($pointers or $arrays);
68 }
69 }
70 }
71
72 return $var_name;
73 }
74
75 sub has_fast_array($$)
76 {
77 my ($e,$l) = @_;
78
79 return 0 if ($l->{TYPE} ne "ARRAY");
80
81 my $nl = GetNextLevel($e,$l);
82 return 0 unless ($nl->{TYPE} eq "DATA");
83 return 0 unless (hasType($nl->{DATA_TYPE}));
84
85 my $t = getType($nl->{DATA_TYPE});
86
87 # Only uint8 has a fast array function at the moment
88 return ($t->{NAME} eq "uint8");
89 }
90
91 sub is_public_struct
92 {
93 my ($d) = @_;
94 if (!has_property($d, "public")) {
95 return 0;
96 }
97 my $t = $d;
98 if ($d->{TYPE} eq "TYPEDEF") {
99 $t = $d->{DATA};
100 }
101 return $t->{TYPE} eq "STRUCT";
102 }
103
104 ####################################
105 # defer() is like pidl(), but adds to
106 # a deferred buffer which is then added to the
107 # output buffer at the end of the structure/union/function
108 # This is needed to cope with code that must be pushed back
109 # to the end of a block of elements
110 sub defer_indent($) { my ($self) = @_; $self->{defer_tabs}.="\t"; }
111 sub defer_deindent($) { my ($self) = @_; $self->{defer_tabs}=substr($self->{defer_tabs}, 0, -1); }
112
113 sub defer($$)
114 {
115 my ($self, $d) = @_;
116 if ($d) {
117 push(@{$self->{deferred}}, $self->{defer_tabs}.$d);
118 }
119 }
120
121 ########################################
122 # add the deferred content to the current
123 # output
124 sub add_deferred($)
125 {
126 my ($self) = @_;
127 $self->pidl($_) foreach (@{$self->{deferred}});
128 $self->{deferred} = [];
129 $self->{defer_tabs} = "";
130 }
131
132 #####################################################################
133 # declare a function public or static, depending on its attributes
134 sub fn_declare($$$$)
135 {
136 my ($self,$type,$fn,$decl) = @_;
137
138 if (has_property($fn, "no$type")) {
139 $self->pidl_hdr("$decl;");
140 return 0;
141 }
142
143 if (has_property($fn, "public")) {
144 $self->pidl_hdr("$decl;");
145 $self->pidl("_PUBLIC_ $decl");
146 } else {
147 $self->pidl("static $decl");
148 }
149
150 return 1;
151 }
152
153 ###################################################################
154 # setup any special flags for an element or structure
155 sub start_flags($$$)
156 {
157 my ($self, $e, $ndr) = @_;
158 my $flags = has_property($e, "flag");
159 if (defined $flags) {
160 $self->pidl("{");
161 $self->indent;
162 $self->pidl("libndr_flags _flags_save_$e->{TYPE} = $ndr->flags;");
163 $self->pidl("ndr_set_flags(&$ndr->flags, $flags);");
164 }
165 }
166
167 ###################################################################
168 # end any special flags for an element or structure
169 sub end_flags($$$)
170 {
171 my ($self, $e, $ndr) = @_;
172 my $flags = has_property($e, "flag");
173 if (defined $flags) {
174 $self->pidl("$ndr->flags = _flags_save_$e->{TYPE};");
175 $self->deindent;
176 $self->pidl("}");
177 }
178 }
179
180 #####################################################################
181 # parse the data of an array - push side
182 sub ParseArrayPushHeader($$$$$$)
183 {
184 my ($self,$e,$l,$ndr,$var_name,$env) = @_;
185
186 my $size;
187 my $length;
188
189 if ($l->{IS_ZERO_TERMINATED}) {
190 if (has_property($e, "charset")) {
191 $size = $length = "ndr_charset_length($var_name, CH_$e->{PROPERTIES}->{charset})";
192 } else {
193 $size = $length = "ndr_string_length($var_name, sizeof(*$var_name))";
194 }
195 if (defined($l->{SIZE_IS})) {
196 $size = ParseExpr($l->{SIZE_IS}, $env, $e);
197 }
198 if (defined($l->{LENGTH_IS})) {
199 $length = ParseExpr($l->{LENGTH_IS}, $env, $e);
200 }
201 } else {
202 $size = ParseExpr($l->{SIZE_IS}, $env, $e);
203 $length = ParseExpr($l->{LENGTH_IS}, $env, $e);
204 }
205
206 if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) {
207 $self->pidl("NDR_CHECK(ndr_push_uint3264($ndr, NDR_SCALARS, $size));");
208 }
209
210 if ($l->{IS_VARYING}) {
211 $self->pidl("NDR_CHECK(ndr_push_uint3264($ndr, NDR_SCALARS, 0));"); # array offset
212 $self->pidl("NDR_CHECK(ndr_push_uint3264($ndr, NDR_SCALARS, $length));");
213 }
214
215 return $length;
216 }
217
218 sub check_fully_dereferenced($$)
219 {
220 my ($element, $env) = @_;
221
222 return sub ($) {
223 my $origvar = shift;
224 my $check = 0;
225
226 # Figure out the number of pointers in $ptr
227 my $expandedvar = $origvar;
228 $expandedvar =~ s/^(\**)//;
229 my $ptr = $1;
230
231 my $var = undef;
232 foreach (keys %$env) {
233 if ($env->{$_} eq $expandedvar) {
234 $var = $_;
235 last;
236 }
237 }
238
239 return($origvar) unless (defined($var));
240 my $e;
241 foreach (@{$element->{PARENT}->{ELEMENTS}}) {
242 if ($_->{NAME} eq $var) {
243 $e = $_;
244 last;
245 }
246 }
247
248 $e or die("Environment doesn't match siblings");
249
250 # See if pointer at pointer level $level
251 # needs to be checked.
252 my $nump = 0;
253 foreach (@{$e->{LEVELS}}) {
254 if ($_->{TYPE} eq "POINTER") {
255 $nump = $_->{POINTER_INDEX}+1;
256 }
257 }
258 warning($element->{ORIGINAL}, "Got pointer for `$e->{NAME}', expected fully dereferenced variable") if ($nump > length($ptr));
259 return ($origvar);
260 }
261 }
262
263 sub check_null_pointer($$$$)
264 {
265 my ($element, $env, $print_fn, $return) = @_;
266
267 return sub ($) {
268 my $expandedvar = shift;
269 my $check = 0;
270
271 # Figure out the number of pointers in $ptr
272 $expandedvar =~ s/^(\**)//;
273 my $ptr = $1;
274
275 my $var = undef;
276 foreach (keys %$env) {
277 if ($env->{$_} eq $expandedvar) {
278 $var = $_;
279 last;
280 }
281 }
282
283 if (defined($var)) {
284 my $e;
285 # lookup ptr in $e
286 foreach (@{$element->{PARENT}->{ELEMENTS}}) {
287 if ($_->{NAME} eq $var) {
288 $e = $_;
289 last;
290 }
291 }
292
293 $e or die("Environment doesn't match siblings");
294
295 # See if pointer at pointer level $level
296 # needs to be checked.
297 foreach my $l (@{$e->{LEVELS}}) {
298 if ($l->{TYPE} eq "POINTER" and
299 $l->{POINTER_INDEX} == length($ptr)) {
300 # No need to check ref pointers
301 $check = ($l->{POINTER_TYPE} ne "ref");
302 last;
303 }
304
305 if ($l->{TYPE} eq "DATA") {
306 warning($element, "too much dereferences for `$var'");
307 }
308 }
309 } else {
310 warning($element, "unknown dereferenced expression `$expandedvar'");
311 $check = 1;
312 }
313
314 $print_fn->("if ($ptr$expandedvar == NULL) $return") if $check;
315 }
316 }
317
318 sub is_deferred_switch_non_empty($)
319 {
320 # 1 if there needs to be a deferred branch in an ndr_pull/push,
321 # 0 otherwise.
322 my ($e) = @_;
323 my $have_default = 0;
324 foreach my $el (@{$e->{ELEMENTS}}) {
325 if ($el->{CASE} eq "default") {
326 $have_default = 1;
327 }
328 if ($el->{TYPE} ne "EMPTY") {
329 if (ContainsDeferred($el, $el->{LEVELS}[0])) {
330 return 1;
331 }
332 }
333 }
334 return ! $have_default;
335 }
336
337 sub ParseArrayPullGetSize($$$$$$)
338 {
339 my ($self,$e,$l,$ndr,$var_name,$env) = @_;
340
341 my $size;
342
343 my $array_size = "size_$e->{NAME}_$l->{LEVEL_INDEX}";
344
345 if ($l->{IS_CONFORMANT} and (defined($l->{SIZE_IS}) or not $l->{IS_ZERO_TERMINATED})) {
346 $self->pidl("NDR_CHECK(ndr_get_array_size($ndr, (void*)" . get_pointer_to($var_name) . ", &$array_size));");
347
348 } elsif ($l->{IS_CONFORMANT}) {
349 # This will be the last use of the array_size token
350 $self->pidl("NDR_CHECK(ndr_steal_array_size($ndr, (void*)" . get_pointer_to($var_name) . ", &$array_size));");
351
352 } elsif ($l->{IS_ZERO_TERMINATED} and $l->{SIZE_IS} == 0 and $l->{LENGTH_IS} == 0) { # Noheader arrays
353 $size = "ndr_get_string_size($ndr, sizeof(*$var_name))";
354 $self->pidl("$array_size = $size;");
355
356 } else {
357 $size = ParseExprExt($l->{SIZE_IS}, $env, $e->{ORIGINAL},
358 check_null_pointer($e, $env, sub { $self->pidl(shift); },
359 "return ndr_pull_error($ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for size_is()\");"),
360 check_fully_dereferenced($e, $env));
361 $self->pidl("$array_size = $size;");
362 }
363
364 if (my $range = has_property($e, "range")) {
365 my ($low, $high) = parse_range($range);
366 if ($low < 0) {
367 warning(0, "$low is invalid for the range of an array size");
368 }
369 if ($low == 0) {
370 $self->pidl("if ($array_size > $high) {");
371 } else {
372 $self->pidl("if ($array_size < $low || $array_size > $high) {");
373 }
374 $self->pidl("\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value (%\"PRIu32\") out of range (%\"PRIu32\" - %\"PRIu32\")\", $array_size, (uint32_t)($low), (uint32_t)($high));");
375
376 $self->pidl("}");
377 }
378
379 return $array_size;
380 }
381
382 #####################################################################
383 # parse an array - pull side
384 sub ParseArrayPullGetLength($$$$$$;$)
385 {
386 my ($self,$e,$l,$ndr,$var_name,$env,$array_size) = @_;
387
388 if (not defined($array_size)) {
389 $array_size = $self->ParseArrayPullGetSize($e, $l, $ndr, $var_name, $env);
390 }
391
392 if (not $l->{IS_VARYING}) {
393 return $array_size;
394 }
395
396 my $array_length = "length_$e->{NAME}_$l->{LEVEL_INDEX}";
397 if ($l->{IS_VARYING} and (defined($l->{LENGTH_IS}) or not $l->{IS_ZERO_TERMINATED})) {
398 $self->pidl("NDR_CHECK(ndr_get_array_length($ndr, (void*)" . get_pointer_to($var_name) . ", &$array_length));");
399 } else {
400 # This will be the last use of the array_length token
401 $self->pidl("NDR_CHECK(ndr_steal_array_length($ndr, (void*)" . get_pointer_to($var_name) . ", &$array_length));");
402 }
403
404 if (my $range = has_property($e, "range")) {
405 my ($low, $high) = parse_range($range);
406 if ($low < 0) {
407 warning(0, "$low is invalid for the range of an array size");
408 }
409 if ($low == 0) {
410 $self->pidl("if ($array_length > $high) {");
411 } else {
412 $self->pidl("if ($array_length < $low || $array_length > $high) {");
413 }
414 $self->pidl("\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value (%\"PRIu32\") out of range (%\"PRIu32\" - %\"PRIu32\")\", $array_length, (uint32_t)($low), (uint32_t)($high));");
415 $self->pidl("}");
416 }
417
418 return $array_length;
419 }
420
421 #####################################################################
422 # parse an array - pull side
423 sub ParseArrayPullHeader($$$$$$)
424 {
425 my ($self,$e,$l,$ndr,$var_name,$env) = @_;
426
427 if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) {
428 $self->pidl("NDR_CHECK(ndr_pull_array_size($ndr, " . get_pointer_to($var_name) . "));");
429 }
430
431 if ($l->{IS_VARYING}) {
432 $self->pidl("NDR_CHECK(ndr_pull_array_length($ndr, " . get_pointer_to($var_name) . "));");
433 }
434
435 my $array_size = $self->ParseArrayPullGetSize($e, $l, $ndr, $var_name, $env);
436 my $array_length = $self->ParseArrayPullGetLength($e, $l, $ndr, $var_name, $env, $array_size);
437
438 if ($array_length ne $array_size) {
439 $self->pidl("if ($array_length > $array_size) {");
440 $self->indent;
441 $self->pidl("return ndr_pull_error($ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %\"PRIu32\": should exceed array length %\"PRIu32\"\", $array_size, $array_length);");
442 $self->deindent;
443 $self->pidl("}");
444 }
445
446 if ($l->{IS_CONFORMANT} and (defined($l->{SIZE_IS}) or not $l->{IS_ZERO_TERMINATED})) {
447 $self->defer("if ($var_name) {");
448 $self->defer_indent;
449 my $size = ParseExprExt($l->{SIZE_IS}, $env, $e->{ORIGINAL},
450 check_null_pointer($e, $env, sub { $self->defer(shift); },
451 "return ndr_pull_error($ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for size_is()\");"),
452 check_fully_dereferenced($e, $env));
453 if (ContainsDeferred($e, $l)) {
454 # We will be needing the array_size token in
455 # the NDR_BUFFERS call, so don't steal it now
456 $self->defer("NDR_CHECK(ndr_check_array_size($ndr, (void*)" . get_pointer_to($var_name) . ", $size));");
457 } else {
458 # This will be deferred until after the last ndr_get_array_size()
459 $self->defer("NDR_CHECK(ndr_check_steal_array_size($ndr, (void*)" . get_pointer_to($var_name) . ", $size));");
460 }
461 $self->defer_deindent;
462 $self->defer("}");
463 }
464
465 if ($l->{IS_VARYING} and (defined($l->{LENGTH_IS}) or not $l->{IS_ZERO_TERMINATED})) {
466 $self->defer("if ($var_name) {");
467 $self->defer_indent;
468 my $length = ParseExprExt($l->{LENGTH_IS}, $env, $e->{ORIGINAL},
469 check_null_pointer($e, $env, sub { $self->defer(shift); },
470 "return ndr_pull_error($ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for length_is()\");"),
471 check_fully_dereferenced($e, $env));
472 # This will be deferred until after the last ndr_get_array_length()
473 $self->defer("NDR_CHECK(ndr_check_steal_array_length($ndr, (void*)" . get_pointer_to($var_name) . ", $length));");
474 $self->defer_deindent;
475 $self->defer("}");
476 }
477
478 if (ArrayDynamicallyAllocated($e,$l) and not is_charset_array($e,$l)) {
479 $self->AllocateArrayLevel($e,$l,$ndr,$var_name,$array_size);
480 }
481
482 return $array_length;
483 }
484
485 sub compression_alg($$$)
486 {
487 my ($e, $l, $env) = @_;
488 my ($alg, $clen, $dlen) = split(/,/, $l->{COMPRESSION});
489
490 return ParseExpr($alg, $env, $e->{ORIGINAL});
491 }
492
493 sub compression_clen($$$)
494 {
495 my ($e, $l, $env) = @_;
496 my ($alg, $clen, $dlen) = split(/,/, $l->{COMPRESSION});
497
498 return ParseExpr($clen, $env, $e->{ORIGINAL});
499 }
500
501 sub compression_dlen($$$)
502 {
503 my ($e,$l,$env) = @_;
504 my ($alg, $clen, $dlen) = split(/,/, $l->{COMPRESSION});
505
506 return ParseExpr($dlen, $env, $e->{ORIGINAL});
507 }
508
509 sub ParseCompressionPushStart($$$$$)
510 {
511 my ($self,$e,$l,$ndr,$env) = @_;
512 my $comndr = "$ndr\_compressed";
513 my $alg = compression_alg($e, $l, $env);
514
515 $self->pidl("{");
516 $self->indent;
517 $self->pidl("struct ndr_push *$comndr;");
518 $self->pidl("NDR_CHECK(ndr_push_compression_state_init($ndr, $alg));");
519 $self->pidl("NDR_CHECK(ndr_push_compression_start($ndr, &$comndr));");
520
521 return $comndr;
522 }
523
524 sub ParseCompressionPushEnd($$$$$)
525 {
526 my ($self,$e,$l,$ndr,$env) = @_;
527 my $comndr = "$ndr\_compressed";
528 my $alg = compression_alg($e, $l, $env);
529
530 $self->pidl("NDR_CHECK(ndr_push_compression_end($ndr, $comndr));");
531 $self->pidl("TALLOC_FREE($ndr->cstate);");
532 $self->deindent;
533 $self->pidl("}");
534 }
535
536 sub ParseCompressionPullStart($$$$$)
537 {
538 my ($self,$e,$l,$ndr,$env) = @_;
539 my $comndr = "$ndr\_compressed";
540 my $alg = compression_alg($e, $l, $env);
541 my $dlen = compression_dlen($e, $l, $env);
542 my $clen = compression_clen($e, $l, $env);
543
544 $self->pidl("{");
545 $self->indent;
546 $self->pidl("struct ndr_pull *$comndr;");
547 $self->pidl("NDR_CHECK(ndr_pull_compression_start($ndr, &$comndr, $alg, $dlen, $clen));");
548
549 return $comndr;
550 }
551
552 sub ParseCompressionPullEnd($$$$$)
553 {
554 my ($self,$e,$l,$ndr,$env) = @_;
555 my $comndr = "$ndr\_compressed";
556 my $alg = compression_alg($e, $l, $env);
557 my $dlen = compression_dlen($e, $l, $env);
558
559 $self->pidl("NDR_CHECK(ndr_pull_compression_end($ndr, $comndr, $alg, $dlen));");
560 $self->deindent;
561 $self->pidl("}");
562 }
563
564 sub ParseSubcontextPushStart($$$$$)
565 {
566 my ($self,$e,$l,$ndr,$env) = @_;
567 my $subndr = "_ndr_$e->{NAME}";
568 my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e->{ORIGINAL});
569
570 $self->pidl("{");
571 $self->indent;
572 $self->pidl("struct ndr_push *$subndr;");
573 $self->pidl("NDR_CHECK(ndr_push_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, $subcontext_size));");
574
575 if (defined $l->{COMPRESSION}) {
576 $subndr = $self->ParseCompressionPushStart($e, $l, $subndr, $env);
577 }
578
579 return $subndr;
580 }
581
582 sub ParseSubcontextPushEnd($$$$$)
583 {
584 my ($self,$e,$l,$ndr,$env) = @_;
585 my $subndr = "_ndr_$e->{NAME}";
586 my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e->{ORIGINAL});
587
588 if (defined $l->{COMPRESSION}) {
589 $self->ParseCompressionPushEnd($e, $l, $subndr, $env);
590 }
591
592 $self->pidl("NDR_CHECK(ndr_push_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));");
593 $self->deindent;
594 $self->pidl("}");
595 }
596
597 sub ParseSubcontextPullStart($$$$$)
598 {
599 my ($self,$e,$l,$ndr,$env) = @_;
600 my $subndr = "_ndr_$e->{NAME}";
601 my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e->{ORIGINAL});
602
603 $self->pidl("{");
604 $self->indent;
605 $self->pidl("struct ndr_pull *$subndr;");
606 $self->pidl("ssize_t sub_size = $subcontext_size;");
607 $self->pidl("NDR_CHECK(ndr_pull_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, sub_size));");
608
609 if (defined $l->{COMPRESSION}) {
610 $subndr = $self->ParseCompressionPullStart($e, $l, $subndr, $env);
611 }
612
613 return $subndr;
614 }
615
616 sub ParseSubcontextPullEnd($$$$$)
617 {
618 my ($self,$e,$l,$ndr,$env) = @_;
619 my $subndr = "_ndr_$e->{NAME}";
620 my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e->{ORIGINAL});
621
622 if (defined $l->{COMPRESSION}) {
623 $self->ParseCompressionPullEnd($e, $l, $subndr, $env);
624 }
625
626 $self->pidl("NDR_CHECK(ndr_pull_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, sub_size));");
627 $self->deindent;
628 $self->pidl("}");
629 }
630
631 sub ParseElementPushLevel
632 {
633 my ($self,$e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_;
634
635 my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred);
636
637 if ($l->{TYPE} eq "ARRAY" and ($l->{IS_CONFORMANT} or $l->{IS_VARYING})) {
638 $var_name = get_pointer_to($var_name);
639 }
640
641 if (defined($ndr_flags)) {
642 if ($l->{TYPE} eq "SUBCONTEXT") {
643 my $subndr = $self->ParseSubcontextPushStart($e, $l, $ndr, $env);
644 $self->ParseElementPushLevel($e, GetNextLevel($e, $l), $subndr, $var_name, $env, 1, 1);
645 $self->ParseSubcontextPushEnd($e, $l, $ndr, $env);
646 } elsif ($l->{TYPE} eq "POINTER") {
647 $self->ParsePtrPush($e, $l, $ndr, $var_name);
648 } elsif ($l->{TYPE} eq "ARRAY") {
649 my $length = $self->ParseArrayPushHeader($e, $l, $ndr, $var_name, $env);
650
651 my $nl = GetNextLevel($e, $l);
652
653 # Allow speedups for arrays of scalar types
654 if (is_charset_array($e,$l)) {
655 if ($l->{IS_TO_NULL}) {
656 $self->pidl("NDR_CHECK(ndr_push_charset_to_null($ndr, $ndr_flags, $var_name, $length, sizeof(" . mapTypeName($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));");
657 } else {
658 $self->pidl("NDR_CHECK(ndr_push_charset($ndr, $ndr_flags, $var_name, $length, sizeof(" . mapTypeName($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));");
659 }
660 return;
661 } elsif (has_fast_array($e,$l)) {
662 $self->pidl("NDR_CHECK(ndr_push_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));");
663 return;
664 }
665 } elsif ($l->{TYPE} eq "DATA") {
666 $self->ParseDataPush($e, $l, $ndr, $var_name, $primitives, $deferred);
667 } elsif ($l->{TYPE} eq "TYPEDEF") {
668 $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($self, $e->{DATA}, $ndr, $var_name);
669 }
670 }
671
672 if ($l->{TYPE} eq "POINTER" and $l->{POINTER_TYPE} eq "ignore") {
673 $self->pidl("/* [ignore] '$e->{NAME}' */");
674 } elsif ($l->{TYPE} eq "POINTER" and $deferred) {
675 my $rel_var_name = $var_name;
676 if ($l->{POINTER_TYPE} ne "ref") {
677 $self->pidl("if ($var_name) {");
678 $self->indent;
679 if ($l->{POINTER_TYPE} eq "relative") {
680 $self->pidl("NDR_CHECK(ndr_push_relative_ptr2_start($ndr, $rel_var_name));");
681 }
682 if ($l->{POINTER_TYPE} eq "relative_short") {
683 $self->pidl("NDR_CHECK(ndr_push_short_relative_ptr2($ndr, $var_name));");
684 }
685 }
686 $var_name = get_value_of($var_name);
687 $self->ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 1);
688
689 if ($l->{POINTER_TYPE} ne "ref") {
690 if ($l->{POINTER_TYPE} eq "relative") {
691 $self->pidl("NDR_CHECK(ndr_push_relative_ptr2_end($ndr, $rel_var_name));");
692 }
693 $self->deindent;
694 $self->pidl("}");
695 }
696 } elsif ($l->{TYPE} eq "ARRAY" and not has_fast_array($e,$l) and
697 not is_charset_array($e, $l)) {
698 my $length = ParseExpr($l->{LENGTH_IS}, $env, $e->{ORIGINAL});
699 my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
700
701 my $array_pointless = ($length eq "0");
702
703 if ($array_pointless) {
704 warning($e->{ORIGINAL}, "pointless array `$e->{NAME}' will always have size 0");
705 }
706
707 $var_name = get_array_element($var_name, $counter);
708
709 if ((($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) and not $array_pointless) {
710 $self->pidl("for ($counter = 0; $counter < ($length); $counter++) {");
711 $self->indent;
712 $self->ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 0);
713 $self->deindent;
714 $self->pidl("}");
715 }
716
717 if ($deferred and ContainsDeferred($e, $l) and not $array_pointless) {
718 $self->pidl("for ($counter = 0; $counter < ($length); $counter++) {");
719 $self->indent;
720 $self->ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 0, 1);
721 $self->deindent;
722 $self->pidl("}");
723 }
724 } elsif ($l->{TYPE} eq "SWITCH") {
725 my $nl = GetNextLevel($e,$l);
726 my $needs_deferred_switch = is_deferred_switch_non_empty($nl);
727
728 # Avoid setting a switch value if it will not be
729 # consumed again in the NDR_BUFFERS pull
730 if ($needs_deferred_switch or !$deferred) {
731 $self->ParseSwitchPush($e, $l, $ndr, $var_name, $env);
732 }
733 $self->ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, $primitives, $deferred);
734 }
735 }
736
737 #####################################################################
738 # parse scalars in a structure element
739 sub ParseElementPush($$$$$$)
740 {
741 my ($self,$e,$ndr,$env,$primitives,$deferred) = @_;
742 my $subndr = undef;
743
744 my $var_name = $env->{$e->{NAME}};
745
746 if (has_property($e, "skip") or has_property($e, "skip_noinit")) {
747 $self->pidl("/* [skip] '$var_name' */");
748 return;
749 }
750
751 return if ContainsPipe($e, $e->{LEVELS}[0]);
752
753 return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0]));
754
755 # Representation type is different from transmit_as
756 if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}) {
757 $self->pidl("{");
758 $self->indent;
759 my $transmit_name = "_transmit_$e->{NAME}";
760 $self->pidl(mapTypeName($e->{TYPE}) ." $transmit_name;");
761 $self->pidl("NDR_CHECK(ndr_$e->{REPRESENTATION_TYPE}_to_$e->{TYPE}($var_name, " . get_pointer_to($transmit_name) . "));");
762 $var_name = $transmit_name;
763 }
764
765 $var_name = append_prefix($e, $var_name);
766
767 $self->start_flags($e, $ndr);
768
769 if (defined(my $value = has_property($e, "value"))) {
770 $var_name = ParseExpr($value, $env, $e->{ORIGINAL});
771 }
772
773 $self->ParseElementPushLevel($e, $e->{LEVELS}[0], $ndr, $var_name, $env, $primitives, $deferred);
774
775 $self->end_flags($e, $ndr);
776
777 if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}) {
778 $self->deindent;
779 $self->pidl("}");
780 }
781 }
782
783 #####################################################################
784 # parse a pointer in a struct element or function
785 sub ParsePtrPush($$$$$)
786 {
787 my ($self,$e,$l,$ndr,$var_name) = @_;
788
789 if ($l->{POINTER_TYPE} eq "ref") {
790 if ($l->{LEVEL_INDEX} > 0) {
791 $self->pidl("if ($var_name == NULL) {");
792 $self->indent;
793 $self->pidl("return ndr_push_error($ndr, NDR_ERR_INVALID_POINTER, \"NULL [ref] pointer\");");
794 $self->deindent;
795 $self->pidl("}");
796 }
797 if ($l->{LEVEL} eq "EMBEDDED") {
798 $self->pidl("NDR_CHECK(ndr_push_ref_ptr(ndr)); /* $var_name */");
799 }
800 } elsif ($l->{POINTER_TYPE} eq "relative") {
801 $self->pidl("NDR_CHECK(ndr_push_relative_ptr1($ndr, $var_name));");
802 } elsif ($l->{POINTER_TYPE} eq "relative_short") {
803 $self->pidl("NDR_CHECK(ndr_push_short_relative_ptr1($ndr, $var_name));");
804 } elsif ($l->{POINTER_TYPE} eq "unique") {
805 $self->pidl("NDR_CHECK(ndr_push_unique_ptr($ndr, $var_name));");
806 } elsif ($l->{POINTER_TYPE} eq "full") {
807 $self->pidl("NDR_CHECK(ndr_push_full_ptr($ndr, $var_name));");
808 } elsif ($l->{POINTER_TYPE} eq "ignore") {
809 # We don't want this pointer to appear on the wire at all
810 $self->pidl("NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));");
811 } else {
812 die("Unhandled pointer type $l->{POINTER_TYPE}");
813 }
814 }
815
816 sub need_pointer_to($$$)
817 {
818 my ($e, $l, $scalar_only) = @_;
819
820 my $t;
821 if (ref($l->{DATA_TYPE})) {
822 $t = "$l->{DATA_TYPE}->{TYPE}_$l->{DATA_TYPE}->{NAME}";
823 } else {
824 $t = $l->{DATA_TYPE};
825 }
826
827 if (not Parse::Pidl::Typelist::is_scalar($t)) {
828 return 1 if $scalar_only;
829 }
830
831 my $arrays = 0;
832
833 foreach my $tl (@{$e->{LEVELS}}) {
834 last if $l == $tl;
835 if ($tl->{TYPE} eq "ARRAY") {
836 $arrays++;
837 }
838 }
839
840 if (Parse::Pidl::Typelist::scalar_is_reference($t)) {
841 return 1 unless $arrays;
842 }
843
844 return 0;
845 }
846
847 sub ParseDataPrint($$$$$)
848 {
849 my ($self, $e, $l, $ndr, $var_name) = @_;
850
851 if (not ref($l->{DATA_TYPE}) or defined($l->{DATA_TYPE}->{NAME})) {
852
853 if (need_pointer_to($e, $l, 1)) {
854 $var_name = get_pointer_to($var_name);
855 }
856
857 $self->pidl(TypeFunctionName("ndr_print", $l->{DATA_TYPE})."($ndr, \"$e->{NAME}\", $var_name);");
858 } else {
859 $self->ParseTypePrint($l->{DATA_TYPE}, $ndr, $var_name);
860 }
861 }
862
863 #####################################################################
864 # print scalars in a structure element
865 sub ParseElementPrint($$$$$)
866 {
867 my($self, $e, $ndr, $var_name, $env) = @_;
868
869 return if (has_property($e, "noprint"));
870 my $cur_depth = 0;
871 my $ignore_depth = 0xFFFF;
872
873 $self->start_flags($e, $ndr);
874 if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}) {
875 $self->pidl("ndr_print_$e->{REPRESENTATION_TYPE}($ndr, \"$e->{NAME}\", $var_name);");
876 $self->end_flags($e, $ndr);
877 return;
878 }
879
880 $var_name = append_prefix($e, $var_name);
881
882 if (defined(my $value = has_property($e, "value"))) {
883 $var_name = "($ndr->flags & LIBNDR_PRINT_SET_VALUES)?" . ParseExpr($value,$env, $e->{ORIGINAL}) . ":$var_name";
884 }
885
886 foreach my $l (@{$e->{LEVELS}}) {
887 $cur_depth += 1;
888
889 if ($cur_depth > $ignore_depth) {
890 next;
891 }
892
893 if ($l->{TYPE} eq "POINTER") {
894 $self->pidl("ndr_print_ptr($ndr, \"$e->{NAME}\", $var_name);");
895 if ($l->{POINTER_TYPE} eq "ignore") {
896 $self->pidl("/* [ignore] '$e->{NAME}' */");
897 $ignore_depth = $cur_depth;
898 last;
899 }
900 $self->pidl("$ndr->depth++;");
901 if ($l->{POINTER_TYPE} ne "ref") {
902 $self->pidl("if ($var_name) {");
903 $self->indent;
904 }
905 $var_name = get_value_of($var_name);
906 } elsif ($l->{TYPE} eq "ARRAY") {
907 my $length;
908
909 if ($l->{IS_CONFORMANT} or $l->{IS_VARYING}) {
910 $var_name = get_pointer_to($var_name);
911 }
912
913 if ($l->{IS_ZERO_TERMINATED} and not defined($l->{LENGTH_IS})) {
914 $length = "ndr_string_length($var_name, sizeof(*$var_name))";
915 } else {
916 $length = ParseExprExt($l->{LENGTH_IS}, $env, $e->{ORIGINAL},
917 check_null_pointer($e, $env, sub { $self->pidl(shift); }, "return;"), check_fully_dereferenced($e, $env));
918 }
919
920 if (is_charset_array($e,$l)) {
921 $self->pidl("ndr_print_string($ndr, \"$e->{NAME}\", $var_name);");
922 last;
923 } elsif (has_fast_array($e, $l)) {
924 my $nl = GetNextLevel($e, $l);
925 $self->pidl("ndr_print_array_$nl->{DATA_TYPE}($ndr, \"$e->{NAME}\", $var_name, $length);");
926 last;
927 } else {
928 my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
929
930 $self->pidl("$ndr->print($ndr, \"%s: ARRAY(%\"PRIu32\")\", \"$e->{NAME}\", (uint32_t)($length));");
931 $self->pidl("$ndr->depth++;");
932 $self->pidl("for ($counter = 0; $counter < ($length); $counter++) {");
933 $self->indent;
934
935 $var_name = get_array_element($var_name, $counter);
936 }
937 } elsif ($l->{TYPE} eq "DATA") {
938 $self->ParseDataPrint($e, $l, $ndr, $var_name);
939 } elsif ($l->{TYPE} eq "SWITCH") {
940 my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e->{ORIGINAL},
941 check_null_pointer($e, $env, sub { $self->pidl(shift); }, "return;"), check_fully_dereferenced($e, $env));
942 $self->pidl("ndr_print_set_switch_value($ndr, " . get_pointer_to($var_name) . ", $switch_var);");
943 }
944 }
945
946 foreach my $l (reverse @{$e->{LEVELS}}) {
947 $cur_depth -= 1;
948
949 if ($cur_depth > $ignore_depth) {
950 next;
951 }
952
953 if ($l->{TYPE} eq "POINTER") {
954 if ($l->{POINTER_TYPE} eq "ignore") {
955 next;
956 }
957
958 if ($l->{POINTER_TYPE} ne "ref") {
959 $self->deindent;
960 $self->pidl("}");
961 }
962 $self->pidl("$ndr->depth--;");
963 } elsif (($l->{TYPE} eq "ARRAY")
964 and not is_charset_array($e,$l)
965 and not has_fast_array($e,$l)) {
966 $self->deindent;
967 $self->pidl("}");
968 $self->pidl("$ndr->depth--;");
969 }
970 }
971
972 $self->end_flags($e, $ndr);
973 }
974
975 #####################################################################
976 # parse scalars in a structure element - pull size
977 sub ParseSwitchPull($$$$$$)
978 {
979 my($self,$e,$l,$ndr,$var_name,$env) = @_;
980 my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e->{ORIGINAL},
981 check_null_pointer($e, $env, sub { $self->pidl(shift); },
982 "return ndr_pull_error($ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for switch_is()\");"),
983 check_fully_dereferenced($e, $env));
984
985 $var_name = get_pointer_to($var_name);
986 $self->pidl("NDR_CHECK(ndr_pull_set_switch_value($ndr, $var_name, $switch_var));");
987 }
988
989 #####################################################################
990 # push switch element
991 sub ParseSwitchPush($$$$$$)
992 {
993 my($self,$e,$l,$ndr,$var_name,$env) = @_;
994 my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e->{ORIGINAL},
995 check_null_pointer($e, $env, sub { $self->pidl(shift); },
996 "return ndr_push_error($ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for switch_is()\");"),
997 check_fully_dereferenced($e, $env));
998
999 $var_name = get_pointer_to($var_name);
1000 $self->pidl("NDR_CHECK(ndr_push_set_switch_value($ndr, $var_name, $switch_var));");
1001 }
1002
1003 sub ParseDataPull($$$$$$$)
1004 {
1005 my ($self,$e,$l,$ndr,$var_name,$primitives,$deferred) = @_;
1006
1007 if (not ref($l->{DATA_TYPE}) or defined($l->{DATA_TYPE}->{NAME})) {
1008
1009 my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred);
1010
1011 if (need_pointer_to($e, $l, 0)) {
1012 $var_name = get_pointer_to($var_name);
1013 }
1014
1015 $var_name = get_pointer_to($var_name);
1016
1017 if (my $depth = has_property($e, "max_recursion")) {
1018 my $d = parse_int($depth);
1019 $self->pidl("NDR_RECURSION_CHECK($ndr, $d);");
1020 }
1021 $self->pidl("NDR_CHECK(".TypeFunctionName("ndr_pull", $l->{DATA_TYPE})."($ndr, $ndr_flags, $var_name));");
1022 if (has_property($e, "max_recursion")) {
1023 $self->pidl("NDR_RECURSION_UNWIND($ndr);");
1024 }
1025
1026 my $pl = GetPrevLevel($e, $l);
1027
1028 my $range = has_property($e, "range");
1029 if ($range and (not $pl or $pl->{TYPE} ne "ARRAY")) {
1030 $var_name = get_value_of($var_name);
1031 my $signed = Parse::Pidl::Typelist::is_signed($l->{DATA_TYPE});
1032 my ($low, $high) = parse_range($range);
1033 if ($low < 0 and not $signed) {
1034 warning(0, "$low is invalid for the range of an unsigned type");
1035 }
1036 if ($low == 0 and not $signed) {
1037 $self->pidl("if ($var_name > $high) {");
1038 } else {
1039 $self->pidl("if ($var_name < $low || $var_name > $high) {");
1040 }
1041
1042 my $data_type = mapTypeName($l->{DATA_TYPE});
1043 my $fmt = mapTypeSpecifier($data_type);
1044
1045 if (!defined($fmt)) {
1046 if (getType($l->{DATA_TYPE})->{DATA}->{TYPE} eq "ENUM") {
1047 $data_type = "int";
1048 $fmt = "d";
1049 } else {
1050 die("Format ($data_type) not supported");
1051 }
1052 }
1053
1054 $self->pidl("\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value (%$fmt) out of range (%$fmt - %$fmt)\", ($data_type)($var_name), ($data_type)($low), ($data_type)($high));");
1055 $self->pidl("}");
1056 }
1057 } else {
1058 $self->ParseTypePull($l->{DATA_TYPE}, $ndr, $var_name, $primitives, $deferred);
1059 }
1060 }
1061
1062 sub ParseDataPush($$$$$$$)
1063 {
1064 my ($self,$e,$l,$ndr,$var_name,$primitives,$deferred) = @_;
1065
1066 if (not ref($l->{DATA_TYPE}) or defined($l->{DATA_TYPE}->{NAME})) {
1067
1068 my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred);
1069
1070 # strings are passed by value rather than reference
1071 if (need_pointer_to($e, $l, 1)) {
1072 $var_name = get_pointer_to($var_name);
1073 }
1074
1075 $self->pidl("NDR_CHECK(".TypeFunctionName("ndr_push", $l->{DATA_TYPE})."($ndr, $ndr_flags, $var_name));");
1076 } else {
1077 $self->ParseTypePush($l->{DATA_TYPE}, $ndr, $var_name, $primitives, $deferred);
1078 }
1079 }
1080
1081 sub CalcNdrFlags($$$)
1082 {
1083 my ($l,$primitives,$deferred) = @_;
1084
1085 my $scalars = 0;
1086 my $buffers = 0;
1087
1088 # Add NDR_SCALARS if this one is deferred
1089 # and deferreds may be pushed
1090 $scalars = 1 if ($l->{IS_DEFERRED} and $deferred);
1091
1092 # Add NDR_SCALARS if this one is not deferred and
1093 # primitives may be pushed
1094 $scalars = 1 if (!$l->{IS_DEFERRED} and $primitives);
1095
1096 # Add NDR_BUFFERS if this one contains deferred stuff
1097 # and deferreds may be pushed
1098 $buffers = 1 if ($l->{CONTAINS_DEFERRED} and $deferred);
1099
1100 return "NDR_SCALARS|NDR_BUFFERS" if ($scalars and $buffers);
1101 return "NDR_SCALARS" if ($scalars);
1102 return "NDR_BUFFERS" if ($buffers);
1103 return undef;
1104 }
1105
1106 sub ParseMemCtxPullFlags($$$$)
1107 {
1108 my ($self, $e, $l) = @_;
1109
1110 return undef unless ($l->{TYPE} eq "POINTER" or $l->{TYPE} eq "ARRAY");
1111 return undef if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ignore"));
1112
1113 return undef unless ($l->{TYPE} ne "ARRAY" or ArrayDynamicallyAllocated($e,$l));
1114 return undef if has_fast_array($e, $l);
1115 return undef if is_charset_array($e, $l);
1116
1117 my $mem_flags = "0";
1118
1119 if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) {
1120 my $nl = GetNextLevel($e, $l);
1121 return undef if ($nl->{TYPE} eq "PIPE");
1122 return undef if ($nl->{TYPE} eq "ARRAY");
1123 return undef if (($nl->{TYPE} eq "DATA") and (Parse::Pidl::Typelist::is_string_type($nl->{DATA_TYPE})));
1124
1125 if ($l->{LEVEL} eq "TOP") {
1126 $mem_flags = "LIBNDR_FLAG_REF_ALLOC";
1127 }
1128 }
1129
1130 return $mem_flags;
1131 }
1132
1133 sub ParseMemCtxPullStart($$$$$)
1134 {
1135 my ($self, $e, $l, $ndr, $ptr_name) = @_;
1136
1137 my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}";
1138 my $mem_c_ctx = $ptr_name;
1139 my $mem_c_flags = $self->ParseMemCtxPullFlags($e, $l);
1140
1141 return unless defined($mem_c_flags);
1142
1143 $self->pidl("$mem_r_ctx = NDR_PULL_GET_MEM_CTX($ndr);");
1144 $self->pidl("NDR_PULL_SET_MEM_CTX($ndr, $mem_c_ctx, $mem_c_flags);");
1145 }
1146
1147 sub ParseMemCtxPullEnd($$$$)
1148 {
1149 my ($self, $e, $l, $ndr) = @_;
1150
1151 my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}";
1152 my $mem_r_flags = $self->ParseMemCtxPullFlags($e, $l);
1153
1154 return unless defined($mem_r_flags);
1155
1156 $self->pidl("NDR_PULL_SET_MEM_CTX($ndr, $mem_r_ctx, $mem_r_flags);");
1157 }
1158
1159 sub CheckStringTerminator($$$$$)
1160 {
1161 my ($self,$ndr,$e,$l,$length) = @_;
1162 my $nl = GetNextLevel($e, $l);
1163
1164 # Make sure last element is zero!
1165 $self->pidl("NDR_CHECK(ndr_check_string_terminator($ndr, $length, sizeof($nl->{DATA_TYPE}_t)));");
1166 }
1167
1168 sub ParseElementPullLevel
1169 {
1170 my($self,$e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_;
1171
1172 my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred);
1173 my $array_length = undef;
1174
1175 if (has_property($e, "skip") or has_property($e, "skip_noinit")) {
1176 $self->pidl("/* [skip] '$var_name' */");
1177 if (not has_property($e, "skip_noinit")) {
1178 $self->pidl("NDR_ZERO_STRUCT($var_name);");
1179 }
1180 return;
1181 }
1182
1183 if ($l->{TYPE} eq "ARRAY" and ($l->{IS_VARYING} or $l->{IS_CONFORMANT})) {
1184 $var_name = get_pointer_to($var_name);
1185 }
1186
1187 # Only pull something if there's actually something to be pulled
1188 if (defined($ndr_flags)) {
1189 if ($l->{TYPE} eq "SUBCONTEXT") {
1190 my $subndr = $self->ParseSubcontextPullStart($e, $l, $ndr, $env);
1191 $self->ParseElementPullLevel($e, GetNextLevel($e,$l), $subndr, $var_name, $env, 1, 1);
1192 $self->ParseSubcontextPullEnd($e, $l, $ndr, $env);
1193 } elsif ($l->{TYPE} eq "ARRAY") {
1194 my $length = $self->ParseArrayPullHeader($e, $l, $ndr, $var_name, $env);
1195 $array_length = $length;
1196
1197 my $nl = GetNextLevel($e, $l);
1198
1199 if (is_charset_array($e,$l)) {
1200 if ($l->{IS_ZERO_TERMINATED}) {
1201 $self->CheckStringTerminator($ndr, $e, $l, $length);
1202 }
1203 if ($l->{IS_TO_NULL}) {
1204 $self->pidl("NDR_CHECK(ndr_pull_charset_to_null($ndr, $ndr_flags, ".get_pointer_to($var_name).", $length, sizeof(" . mapTypeName($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));");
1205 } else {
1206 $self->pidl("NDR_CHECK(ndr_pull_charset($ndr, $ndr_flags, ".get_pointer_to($var_name).", $length, sizeof(" . mapTypeName($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));");
1207 }
1208 return;
1209 } elsif (has_fast_array($e, $l)) {
1210 if ($l->{IS_ZERO_TERMINATED}) {
1211 $self->CheckStringTerminator($ndr,$e,$l,$length);
1212 }
1213 $self->pidl("NDR_CHECK(ndr_pull_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));");
1214 return;
1215 }
1216 } elsif ($l->{TYPE} eq "POINTER") {
1217 $self->ParsePtrPull($e, $l, $ndr, $var_name);
1218 } elsif ($l->{TYPE} eq "DATA") {
1219 $self->ParseDataPull($e, $l, $ndr, $var_name, $primitives, $deferred);
1220 } elsif ($l->{TYPE} eq "TYPEDEF") {
1221 $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($self, $e->{DATA}, $ndr, $var_name);
1222 }
1223 }
1224
1225 # add additional constructions
1226 if ($l->{TYPE} eq "POINTER" and $l->{POINTER_TYPE} eq "ignore") {
1227 $self->pidl("/* [ignore] '$e->{NAME}' */");
1228 } elsif ($l->{TYPE} eq "POINTER" and $deferred) {
1229 if ($l->{POINTER_TYPE} ne "ref") {
1230 $self->pidl("if ($var_name) {");
1231 $self->indent;
1232
1233 if ($l->{POINTER_TYPE} eq "relative" or $l->{POINTER_TYPE} eq "relative_short") {
1234 $self->pidl("uint32_t _relative_save_offset;");
1235 $self->pidl("_relative_save_offset = $ndr->offset;");
1236 $self->pidl("NDR_CHECK(ndr_pull_relative_ptr2($ndr, $var_name));");
1237 }
1238 }
1239
1240 $self->ParseMemCtxPullStart($e, $l, $ndr, $var_name);
1241
1242 $var_name = get_value_of($var_name);
1243 $self->ParseElementPullLevel($e, GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 1);
1244
1245 $self->ParseMemCtxPullEnd($e, $l, $ndr);
1246
1247 if ($l->{POINTER_TYPE} ne "ref") {
1248 if ($l->{POINTER_TYPE} eq "relative" or $l->{POINTER_TYPE} eq "relative_short") {
1249 $self->pidl("if ($ndr->offset > $ndr->relative_highest_offset) {");
1250 $self->indent;
1251 $self->pidl("$ndr->relative_highest_offset = $ndr->offset;");
1252 $self->deindent;
1253 $self->pidl("}");
1254 $self->pidl("$ndr->offset = _relative_save_offset;");
1255 }
1256 $self->deindent;
1257 $self->pidl("}");
1258 }
1259 } elsif ($l->{TYPE} eq "ARRAY" and
1260 not has_fast_array($e,$l) and not is_charset_array($e, $l)) {
1261 my $length = $array_length;
1262 my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
1263 my $array_name = $var_name;
1264
1265 if (not defined($length)) {
1266 $length = $self->ParseArrayPullGetLength($e, $l, $ndr, $var_name, $env);
1267 }
1268
1269 $var_name = get_array_element($var_name, $counter);
1270
1271 $self->ParseMemCtxPullStart($e, $l, $ndr, $array_name);
1272
1273 if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) {
1274 my $nl = GetNextLevel($e,$l);
1275
1276 if ($l->{IS_ZERO_TERMINATED}) {
1277 $self->CheckStringTerminator($ndr,$e,$l,$length);
1278 }
1279
1280 $self->pidl("for ($counter = 0; $counter < ($length); $counter++) {");
1281 $self->indent;
1282 $self->ParseElementPullLevel($e, $nl, $ndr, $var_name, $env, 1, 0);
1283 $self->deindent;
1284 $self->pidl("}");
1285 }
1286
1287 if ($deferred and ContainsDeferred($e, $l)) {
1288 $self->pidl("for ($counter = 0; $counter < ($length); $counter++) {");
1289 $self->defer("for ($counter = 0; $counter < ($length); $counter++) {");
1290 $self->defer_indent;
1291 $self->indent;
1292 $self->ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 0, 1);
1293 $self->deindent;
1294 $self->defer_deindent;
1295 $self->pidl("}");
1296 $self->defer("}");
1297 }
1298
1299 $self->ParseMemCtxPullEnd($e, $l, $ndr);
1300
1301 } elsif ($l->{TYPE} eq "SWITCH") {
1302 my $nl = GetNextLevel($e,$l);
1303 my $needs_deferred_switch = is_deferred_switch_non_empty($nl);
1304
1305 # Avoid setting a switch value if it will not be
1306 # consumed again in the NDR_BUFFERS pull
1307 if ($needs_deferred_switch or !$deferred) {
1308 $self->ParseSwitchPull($e, $l, $ndr, $var_name, $env);
1309 }
1310 $self->ParseElementPullLevel($e, $nl, $ndr, $var_name, $env, $primitives, $deferred);
1311 }
1312 }
1313
1314 #####################################################################
1315 # parse scalars in a structure element - pull size
1316 sub ParseElementPull($$$$$$)
1317 {
1318 my($self,$e,$ndr,$env,$primitives,$deferred) = @_;
1319
1320 my $var_name = $env->{$e->{NAME}};
1321 my $represent_name;
1322 my $transmit_name;
1323
1324 return if ContainsPipe($e, $e->{LEVELS}[0]);
1325
1326 return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0]));
1327
1328 if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}) {
1329 $self->pidl("{");
1330 $self->indent;
1331 $represent_name = $var_name;
1332 $transmit_name = "_transmit_$e->{NAME}";
1333 $var_name = $transmit_name;
1334 $self->pidl(mapTypeName($e->{TYPE})." $var_name;");
1335 }
1336
1337 $var_name = append_prefix($e, $var_name);
1338
1339 $self->start_flags($e, $ndr);
1340
1341 $self->ParseElementPullLevel($e,$e->{LEVELS}[0],$ndr,$var_name,$env,$primitives,$deferred);
1342
1343 $self->end_flags($e, $ndr);
1344
1345 # Representation type is different from transmit_as
1346 if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}) {
1347 $self->pidl("NDR_CHECK(ndr_$e->{TYPE}_to_$e->{REPRESENTATION_TYPE}($transmit_name, ".get_pointer_to($represent_name)."));");
1348 $self->deindent;
1349 $self->pidl("}");
1350 }
1351 }
1352
1353 #####################################################################
1354 # parse a pointer in a struct element or function
1355 sub ParsePtrPull($$$$$)
1356 {
1357 my($self, $e,$l,$ndr,$var_name) = @_;
1358
1359 my $nl = GetNextLevel($e, $l);
1360 my $next_is_array = ($nl->{TYPE} eq "ARRAY");
1361 my $next_is_string = (($nl->{TYPE} eq "DATA") and
1362 (Parse::Pidl::Typelist::is_string_type($nl->{DATA_TYPE})));
1363
1364 if ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP") {
1365
1366 if (!$next_is_array and !$next_is_string) {
1367 $self->pidl("if ($ndr->flags & LIBNDR_FLAG_REF_ALLOC) {");
1368 $self->pidl("\tNDR_PULL_ALLOC($ndr, $var_name);");
1369 $self->pidl("}");
1370 }
1371
1372 return;
1373 } elsif ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "EMBEDDED") {
1374 $self->pidl("NDR_CHECK(ndr_pull_ref_ptr($ndr, &_ptr_$e->{NAME}));");
1375 } elsif (($l->{POINTER_TYPE} eq "unique") or
1376 ($l->{POINTER_TYPE} eq "relative") or
1377 ($l->{POINTER_TYPE} eq "full")) {
1378 $self->pidl("NDR_CHECK(ndr_pull_generic_ptr($ndr, &_ptr_$e->{NAME}));");
1379 } elsif ($l->{POINTER_TYPE} eq "relative_short") {
1380 $self->pidl("NDR_CHECK(ndr_pull_relative_ptr_short($ndr, &_ptr_$e->{NAME}));");
1381 } elsif ($l->{POINTER_TYPE} eq "ignore") {
1382 #We want to consume the pointer bytes, but ignore the pointer value
1383 $self->pidl("NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &_ptr_$e->{NAME}));");
1384 $self->pidl("_ptr_$e->{NAME} = 0;");
1385 } else {
1386 die("Unhandled pointer type $l->{POINTER_TYPE}");
1387 }
1388
1389 $self->pidl("if (_ptr_$e->{NAME}) {");
1390 $self->indent;
1391
1392 if ($l->{POINTER_TYPE} eq "ignore") {
1393 # Don't do anything, we don't want to do the
1394 # allocation, as we forced it to NULL just above, and
1395 # we may not know the declared type anyway.
1396 } else {
1397 # Don't do this for arrays, they're allocated at the actual level
1398 # of the array
1399 unless ($next_is_array or $next_is_string) {
1400 $self->pidl("NDR_PULL_ALLOC($ndr, $var_name);");
1401 } else {
1402 # FIXME: Yes, this is nasty.
1403 # We allocate an array twice
1404 # - once just to indicate that it's there,
1405 # - then the real allocation...
1406 $self->pidl("NDR_PULL_ALLOC($ndr, $var_name);");
1407 }
1408 }
1409
1410 #$self->pidl("memset($var_name, 0, sizeof($var_name));");
1411 if ($l->{POINTER_TYPE} eq "relative" or $l->{POINTER_TYPE} eq "relative_short") {
1412 $self->pidl("NDR_CHECK(ndr_pull_relative_ptr1($ndr, $var_name, _ptr_$e->{NAME}));");
1413 }
1414 $self->deindent;
1415 $self->pidl("} else {");
1416 $self->pidl("\t$var_name = NULL;");
1417 $self->pidl("}");
1418 }
1419
1420 sub CheckRefPtrs($$$$)
1421 {
1422 my ($self,$e,$ndr,$env) = @_;
1423
1424 return if ContainsPipe($e, $e->{LEVELS}[0]);
1425 return if ($e->{LEVELS}[0]->{TYPE} ne "POINTER");
1426 return if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref");
1427
1428 my $var_name = $env->{$e->{NAME}};
1429 $var_name = append_prefix($e, $var_name);
1430
1431 $self->pidl("if ($var_name == NULL) {");
1432 $self->indent;
1433 $self->pidl("return ndr_push_error($ndr, NDR_ERR_INVALID_POINTER, \"NULL [ref] pointer\");");
1434 $self->deindent;
1435 $self->pidl("}");
1436 }
1437
1438 sub ParseStructPushPrimitives($$$$$)
1439 {
1440 my ($self, $struct, $ndr, $varname, $env) = @_;
1441
1442 $self->CheckRefPtrs($_, $ndr, $env) foreach (@{$struct->{ELEMENTS}});
1443
1444 # see if the structure contains a conformant array. If it
1445 # does, then it must be the last element of the structure, and
1446 # we need to push the conformant length early, as it fits on
1447 # the wire before the structure (and even before the structure
1448 # alignment)
1449 if (defined($struct->{SURROUNDING_ELEMENT})) {
1450 my $e = $struct->{SURROUNDING_ELEMENT};
1451
1452 if (defined($e->{LEVELS}[0]) and
1453 $e->{LEVELS}[0]->{TYPE} eq "ARRAY") {
1454 my $size;
1455
1456 if ($e->{LEVELS}[0]->{IS_ZERO_TERMINATED}) {
1457 if (has_property($e, "charset")) {
1458 $size = "ndr_charset_length($varname->$e->{NAME}, CH_$e->{PROPERTIES}->{charset})";
1459 } else {
1460 $size = "ndr_string_length($varname->$e->{NAME}, sizeof(*$varname->$e->{NAME}))";
1461 }
1462 if (defined($e->{LEVELS}[0]->{SIZE_IS})) {
1463 $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env, $e->{ORIGINAL});
1464 }
1465 } else {
1466 $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env, $e->{ORIGINAL});
1467 }
1468
1469 $self->pidl("NDR_CHECK(ndr_push_uint3264($ndr, NDR_SCALARS, $size));");
1470 } else {
1471 $self->pidl("NDR_CHECK(ndr_push_uint3264($ndr, NDR_SCALARS, ndr_string_array_size($ndr, $varname->$e->{NAME})));");
1472 }
1473 }
1474
1475 $self->pidl("NDR_CHECK(ndr_push_align($ndr, $struct->{ALIGN}));");
1476
1477 if (defined($struct->{PROPERTIES}{relative_base})) {
1478 # set the current offset as base for relative pointers
1479 # and store it based on the toplevel struct/union
1480 $self->pidl("NDR_CHECK(ndr_push_setup_relative_base_offset1($ndr, $varname, $ndr->offset));");
1481 }
1482
1483 $self->ParseElementPush($_, $ndr, $env, 1, 0) foreach (@{$struct->{ELEMENTS}});
1484
1485 $self->pidl("NDR_CHECK(ndr_push_trailer_align($ndr, $struct->{ALIGN}));");
1486 }
1487
1488 sub ParseStructPushDeferred($$$$)
1489 {
1490 my ($self, $struct, $ndr, $varname, $env) = @_;
1491 if (defined($struct->{PROPERTIES}{relative_base})) {
1492 # retrieve the current offset as base for relative pointers
1493 # based on the toplevel struct/union
1494 $self->pidl("NDR_CHECK(ndr_push_setup_relative_base_offset2($ndr, $varname));");
1495 }
1496 $self->ParseElementPush($_, $ndr, $env, 0, 1) foreach (@{$struct->{ELEMENTS}});
1497 }
1498
1499 #####################################################################
1500 # parse a struct
1501 sub ParseStructPush($$$$)
1502 {
1503 my ($self, $struct, $ndr, $varname) = @_;
1504
1505 return unless defined($struct->{ELEMENTS});
1506
1507 my $env = GenerateStructEnv($struct, $varname);
1508
1509 EnvSubstituteValue($env, $struct);
1510
1511 $self->DeclareArrayVariablesNoZero($_, $env) foreach (@{$struct->{ELEMENTS}});
1512
1513 $self->start_flags($struct, $ndr);
1514
1515 $self->pidl("NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);");
1516 $self->pidl("if (ndr_flags & NDR_SCALARS) {");
1517 $self->indent;
1518 $self->ParseStructPushPrimitives($struct, $ndr, $varname, $env);
1519 $self->deindent;
1520 $self->pidl("}");
1521
1522 $self->pidl("if (ndr_flags & NDR_BUFFERS) {");
1523 $self->indent;
1524 $self->ParseStructPushDeferred($struct, $ndr, $varname, $env);
1525 $self->deindent;
1526 $self->pidl("}");
1527
1528 $self->end_flags($struct, $ndr);
1529 }
1530
1531 #####################################################################
1532 # generate a push function for an enum
1533 sub ParseEnumPush($$$$)
1534 {
1535 my($self,$enum,$ndr,$varname) = @_;
1536 my($type_fn) = $enum->{BASE_TYPE};
1537
1538 $self->start_flags($enum, $ndr);
1539 $self->pidl("NDR_CHECK(ndr_push_enum_$type_fn($ndr, NDR_SCALARS, $varname));");
1540 $self->end_flags($enum, $ndr);
1541 }
1542
1543 #####################################################################
1544 # generate a pull function for an enum
1545 sub ParseEnumPull($$$$)
1546 {
1547 my($self,$enum,$ndr,$varname) = @_;
1548 my($type_fn) = $enum->{BASE_TYPE};
1549 my($type_v_decl) = mapTypeName($type_fn);
1550
1551 $self->pidl("$type_v_decl v;");
1552 $self->start_flags($enum, $ndr);
1553 $self->pidl("NDR_CHECK(ndr_pull_enum_$type_fn($ndr, NDR_SCALARS, &v));");
1554 $self->pidl("*$varname = v;");
1555
1556 $self->end_flags($enum, $ndr);
1557 }
1558
1559 #####################################################################
1560 # generate a print function for an enum
1561 sub ParseEnumPrint($$$$$)
1562 {
1563 my($self,$enum,$ndr,$name,$varname) = @_;
1564
1565 $self->pidl("const char *val = NULL;");
1566 $self->pidl("");
1567
1568 $self->start_flags($enum, $ndr);
1569
1570 $self->pidl("switch ($varname) {");
1571 $self->indent;
1572 my $els = \@{$enum->{ELEMENTS}};
1573 foreach my $i (0 .. $#{$els}) {
1574 my $e = ${$els}[$i];
1575 chomp $e;
1576 if ($e =~ /^(.*)=/) {
1577 $e = $1;
1578 }
1579 $self->pidl("case $e: val = \"$e\"; break;");
1580 }
1581
1582 $self->deindent;
1583 $self->pidl("}");
1584
1585 $self->pidl("ndr_print_enum($ndr, name, \"$enum->{TYPE}\", val, $varname);");
1586
1587 $self->end_flags($enum, $ndr);
1588 }
1589
1590 sub DeclEnum($$$$)
1591 {
1592 my ($e,$t,$name,$varname) = @_;
1593 return "enum $name " .
1594 ($t eq "pull"?"*":"") . $varname;
1595 }
1596
1597 $typefamily{ENUM} = {
1598 DECL => \&DeclEnum,
1599 PUSH_FN_BODY => \&ParseEnumPush,
1600 PULL_FN_BODY => \&ParseEnumPull,
1601 PRINT_FN_BODY => \&ParseEnumPrint,
1602 };
1603
1604 #####################################################################
1605 # generate a push function for a bitmap
1606 sub ParseBitmapPush($$$$)
1607 {
1608 my($self,$bitmap,$ndr,$varname) = @_;
1609 my($type_fn) = $bitmap->{BASE_TYPE};
1610
1611 $self->start_flags($bitmap, $ndr);
1612
1613 $self->pidl("NDR_CHECK(ndr_push_$type_fn($ndr, NDR_SCALARS, $varname));");
1614
1615 $self->end_flags($bitmap, $ndr);
1616 }
1617
1618 #####################################################################
1619 # generate a pull function for an bitmap
1620 sub ParseBitmapPull($$$$)
1621 {
1622 my($self,$bitmap,$ndr,$varname) = @_;
1623 my $type_fn = $bitmap->{BASE_TYPE};
1624 my($type_decl) = mapTypeName($bitmap->{BASE_TYPE});
1625
1626 $self->pidl("$type_decl v;");
1627 $self->start_flags($bitmap, $ndr);
1628 $self->pidl("NDR_CHECK(ndr_pull_$type_fn($ndr, NDR_SCALARS, &v));");
1629 $self->pidl("*$varname = v;");
1630
1631 $self->end_flags($bitmap, $ndr);
1632 }
1633
1634 #####################################################################
1635 # generate a print function for an bitmap
1636 sub ParseBitmapPrintElement($$$$$$)
1637 {
1638 my($self,$e,$bitmap,$ndr,$name,$varname) = @_;
1639 my($type_decl) = mapTypeName($bitmap->{BASE_TYPE});
1640 my($type_fn) = $bitmap->{BASE_TYPE};
1641 my($flag);
1642
1643 if ($e =~ /^(\w+) .*$/) {
1644 $flag = "$1";
1645 } else {
1646 die "Bitmap: \"$name\" invalid Flag: \"$e\"";
1647 }
1648
1649 $self->pidl("ndr_print_bitmap_flag($ndr, sizeof($type_decl), \"$flag\", $flag, $varname);");
1650 }
1651
1652 #####################################################################
1653 # generate a print function for an bitmap
1654 sub ParseBitmapPrint($$$$$)
1655 {
1656 my($self,$bitmap,$ndr,$name,$varname) = @_;
1657 my($type_decl) = mapTypeName($bitmap->{TYPE});
1658 my($type_fn) = $bitmap->{BASE_TYPE};
1659
1660 $self->start_flags($bitmap, $ndr);
1661
1662 $self->pidl("ndr_print_$type_fn($ndr, name, $varname);");
1663
1664 $self->pidl("$ndr->depth++;");
1665 foreach my $e (@{$bitmap->{ELEMENTS}}) {
1666 $self->ParseBitmapPrintElement($e, $bitmap, $ndr, $name, $varname);
1667 }
1668 $self->pidl("$ndr->depth--;");
1669
1670 $self->end_flags($bitmap, $ndr);
1671 }
1672
1673 sub DeclBitmap($$$$)
1674 {
1675 my ($e,$t,$name,$varname) = @_;
1676 return mapTypeName(Parse::Pidl::Typelist::bitmap_type_fn($e)) .
1677 ($t eq "pull"?" *":" ") . $varname;
1678 }
1679
1680 $typefamily{BITMAP} = {
1681 DECL => \&DeclBitmap,
1682 PUSH_FN_BODY => \&ParseBitmapPush,
1683 PULL_FN_BODY => \&ParseBitmapPull,
1684 PRINT_FN_BODY => \&ParseBitmapPrint,
1685 };
1686
1687 #####################################################################
1688 # generate a struct print function
1689 sub ParseStructPrint($$$$$)
1690 {
1691 my($self,$struct,$ndr,$name,$varname) = @_;
1692
1693 return unless defined $struct->{ELEMENTS};
1694
1695 my $env = GenerateStructEnv($struct, $varname);
1696
1697 $self->DeclareArrayVariables($_) foreach (@{$struct->{ELEMENTS}});
1698
1699 $self->pidl("ndr_print_struct($ndr, name, \"$name\");");
1700 $self->pidl("if (r == NULL) { ndr_print_null($ndr); return; }");
1701
1702 $self->start_flags($struct, $ndr);
1703
1704 $self->pidl("$ndr->depth++;");
1705
1706 $self->ParseElementPrint($_, $ndr, $env->{$_->{NAME}}, $env)
1707 foreach (@{$struct->{ELEMENTS}});
1708 $self->pidl("$ndr->depth--;");
1709
1710 $self->end_flags($struct, $ndr);
1711 }
1712
1713 sub DeclarePtrVariables($$)
1714 {
1715 my ($self,$e) = @_;
1716
1717 if (has_property($e, "skip") or has_property($e, "skip_noinit")) {
1718 return;
1719 }
1720
1721 foreach my $l (@{$e->{LEVELS}}) {
1722 my $size = 32;
1723 if ($l->{TYPE} eq "POINTER" and
1724 not ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP")) {
1725 if ($l->{POINTER_TYPE} eq "relative_short") {
1726 $size = 16;
1727 }
1728 $self->pidl("uint${size}_t _ptr_$e->{NAME};");
1729 last;
1730 }
1731 }
1732 }
1733
1734 sub DeclareArrayVariables($$;$)
1735 {
1736 my ($self,$e,$pull) = @_;
1737
1738 if (has_property($e, "skip") or has_property($e, "skip_noinit")) {
1739 return;
1740 }
1741
1742 foreach my $l (@{$e->{LEVELS}}) {
1743 next if ($l->{TYPE} ne "ARRAY");
1744 if (defined($pull)) {
1745 $self->pidl("uint32_t size_$e->{NAME}_$l->{LEVEL_INDEX} = 0;");
1746 if ($l->{IS_VARYING}) {
1747 $self->pidl("uint32_t length_$e->{NAME}_$l->{LEVEL_INDEX} = 0;");
1748 }
1749 }
1750 next if has_fast_array($e,$l);
1751 next if is_charset_array($e,$l);
1752 $self->pidl("uint32_t cntr_$e->{NAME}_$l->{LEVEL_INDEX};");
1753 }
1754 }
1755
1756 sub DeclareArrayVariablesNoZero($$$)
1757 {
1758 my ($self,$e,$env) = @_;
1759
1760 if (has_property($e, "skip") or has_property($e, "skip_noinit")) {
1761 return;
1762 }
1763
1764 foreach my $l (@{$e->{LEVELS}}) {
1765 next if ($l->{TYPE} ne "ARRAY");
1766 next if has_fast_array($e,$l);
1767 next if is_charset_array($e,$l);
1768 my $length = ParseExpr($l->{LENGTH_IS}, $env, $e->{ORIGINAL});
1769 if ($length eq "0") {
1770 warning($e->{ORIGINAL}, "pointless array cntr: 'cntr_$e->{NAME}_$l->{LEVEL_INDEX}': length=$length");
1771 } else {
1772 $self->pidl("uint32_t cntr_$e->{NAME}_$l->{LEVEL_INDEX};");
1773 }
1774 }
1775 }
1776
1777 sub DeclareMemCtxVariables($$)
1778 {
1779 my ($self,$e) = @_;
1780
1781 if (has_property($e, "skip") or has_property($e, "skip_noinit")) {
1782 return;
1783 }
1784
1785 foreach my $l (@{$e->{LEVELS}}) {
1786 my $mem_flags = $self->ParseMemCtxPullFlags($e, $l);
1787
1788 if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ignore")) {
1789 last;
1790 }
1791
1792 if (defined($mem_flags)) {
1793 $self->pidl("TALLOC_CTX *_mem_save_$e->{NAME}_$l->{LEVEL_INDEX} = NULL;");
1794 }
1795 }
1796 }
1797
1798 sub ParseStructPullPrimitives($$$$$)
1799 {
1800 my($self,$struct,$ndr,$varname,$env) = @_;
1801
1802 if (defined $struct->{SURROUNDING_ELEMENT}) {
1803 $self->pidl("NDR_CHECK(ndr_pull_array_size($ndr, &$varname->$struct->{SURROUNDING_ELEMENT}->{NAME}));");
1804 }
1805
1806 $self->pidl("NDR_CHECK(ndr_pull_align($ndr, $struct->{ALIGN}));");
1807
1808 if (defined($struct->{PROPERTIES}{relative_base})) {
1809 # set the current offset as base for relative pointers
1810 # and store it based on the toplevel struct/union
1811 $self->pidl("NDR_CHECK(ndr_pull_setup_relative_base_offset1($ndr, $varname, $ndr->offset));");
1812 }
1813
1814 $self->ParseElementPull($_, $ndr, $env, 1, 0) foreach (@{$struct->{ELEMENTS}});
1815
1816 $self->add_deferred();
1817
1818 $self->pidl("NDR_CHECK(ndr_pull_trailer_align($ndr, $struct->{ALIGN}));");
1819 }
1820
1821 sub ParseStructPullDeferred($$$$$)
1822 {
1823 my ($self,$struct,$ndr,$varname,$env) = @_;
1824
1825 if (defined($struct->{PROPERTIES}{relative_base})) {
1826 # retrieve the current offset as base for relative pointers
1827 # based on the toplevel struct/union
1828 $self->pidl("NDR_CHECK(ndr_pull_setup_relative_base_offset2($ndr, $varname));");
1829 }
1830 foreach my $e (@{$struct->{ELEMENTS}}) {
1831 $self->ParseElementPull($e, $ndr, $env, 0, 1);
1832 }
1833
1834 $self->add_deferred();
1835 }
1836
1837 #####################################################################
1838 # parse a struct - pull side
1839 sub ParseStructPull($$$$)
1840 {
1841 my($self,$struct,$ndr,$varname) = @_;
1842
1843 return unless defined $struct->{ELEMENTS};
1844
1845 # declare any internal pointers we need
1846 foreach my $e (@{$struct->{ELEMENTS}}) {
1847 $self->DeclarePtrVariables($e);
1848 $self->DeclareArrayVariables($e, "pull");
1849 $self->DeclareMemCtxVariables($e);
1850 }
1851
1852 $self->start_flags($struct, $ndr);
1853
1854 my $env = GenerateStructEnv($struct, $varname);
1855
1856 $self->pidl("NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);");
1857 $self->pidl("if (ndr_flags & NDR_SCALARS) {");
1858 $self->indent;
1859 $self->ParseStructPullPrimitives($struct,$ndr,$varname,$env);
1860 $self->deindent;
1861 $self->pidl("}");
1862 $self->pidl("if (ndr_flags & NDR_BUFFERS) {");
1863 $self->indent;
1864 $self->ParseStructPullDeferred($struct,$ndr,$varname,$env);
1865 $self->deindent;
1866 $self->pidl("}");
1867
1868 $self->end_flags($struct, $ndr);
1869 }
1870
1871 #####################################################################
1872 # calculate size of ndr struct
1873 sub ParseStructNdrSize($$$$)
1874 {
1875 my ($self,$t, $name, $varname) = @_;
1876 my $sizevar;
1877
1878 if (my $flags = has_property($t, "flag")) {
1879 $self->pidl("flags |= $flags;");
1880 }
1881 $self->pidl("return ndr_size_struct($varname, flags, (ndr_push_flags_fn_t)ndr_push_$name);");
1882 }
1883
1884 sub DeclStruct($$$$)
1885 {
1886 my ($e,$t,$name,$varname) = @_;
1887 if ($t eq "base") {
1888 return "struct $name $varname";
1889 }
1890 return ($t ne "pull"?"const ":"") . "struct $name *$varname";
1891 }
1892
1893 sub ArgsStructNdrSize($$$)
1894 {
1895 my ($d, $name, $varname) = @_;
1896 return "const struct $name *$varname, libndr_flags flags";
1897 }
1898
1899 $typefamily{STRUCT} = {
1900 PUSH_FN_BODY => \&ParseStructPush,
1901 DECL => \&DeclStruct,
1902 PULL_FN_BODY => \&ParseStructPull,
1903 PRINT_FN_BODY => \&ParseStructPrint,
1904 SIZE_FN_BODY => \&ParseStructNdrSize,
1905 SIZE_FN_ARGS => \&ArgsStructNdrSize,
1906 };
1907
1908 #####################################################################
1909 # calculate size of ndr struct
1910 sub ParseUnionNdrSize($$$)
1911 {
1912 my ($self, $t, $name, $varname) = @_;
1913 my $sizevar;
1914
1915 if (my $flags = has_property($t, "flag")) {
1916 $self->pidl("flags |= $flags;");
1917 }
1918
1919 $self->pidl("return ndr_size_union($varname, flags, level, (ndr_push_flags_fn_t)ndr_push_$name);");
1920 }
1921
1922 sub ParseUnionPushPrimitives($$$$)
1923 {
1924 my ($self, $e, $ndr ,$varname) = @_;
1925
1926 my $have_default = 0;
1927
1928 if (defined($e->{SWITCH_TYPE})) {
1929 if (defined($e->{ALIGN})) {
1930 $self->pidl("NDR_CHECK(ndr_push_union_align($ndr, $e->{ALIGN}));");
1931 }
1932
1933 $self->pidl("NDR_CHECK(ndr_push_$e->{SWITCH_TYPE}($ndr, NDR_SCALARS, level));");
1934 }
1935
1936 if (defined($e->{ALIGN})) {
1937 if ($e->{IS_MS_UNION}) {
1938 $self->pidl("/* ms_union is always aligned to the largest union arm*/");
1939 $self->pidl("NDR_CHECK(ndr_push_align($ndr, $e->{ALIGN}));");
1940 } else {
1941 $self->pidl("NDR_CHECK(ndr_push_union_align($ndr, $e->{ALIGN}));");
1942 }
1943 }
1944
1945 $self->pidl("switch (level) {");
1946 $self->indent;
1947 foreach my $el (@{$e->{ELEMENTS}}) {
1948 if ($el->{CASE} eq "default") {
1949 $have_default = 1;
1950 }
1951 $self->pidl("$el->{CASE}: {");
1952
1953 if ($el->{TYPE} ne "EMPTY") {
1954 $self->indent;
1955 if (defined($e->{PROPERTIES}{relative_base})) {
1956 $self->pidl("NDR_CHECK(ndr_push_align($ndr, $el->{ALIGN}));");
1957 # set the current offset as base for relative pointers
1958 # and store it based on the toplevel struct/union
1959 $self->pidl("NDR_CHECK(ndr_push_setup_relative_base_offset1($ndr, $varname, $ndr->offset));");
1960 }
1961 $self->DeclareArrayVariables($el);
1962 my $el_env = {$el->{NAME} => "$varname->$el->{NAME}"};
1963 $self->CheckRefPtrs($el, $ndr, $el_env);
1964 $self->ParseElementPush($el, $ndr, $el_env, 1, 0);
1965 $self->deindent;
1966 }
1967 $self->pidl("break; }");
1968 $self->pidl("");
1969 }
1970 if (! $have_default) {
1971 $self->pidl("default:");
1972 $self->pidl("\treturn ndr_push_error($ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %\"PRIu32, level);");
1973 }
1974 $self->deindent;
1975 $self->pidl("}");
1976 }
1977
1978 sub ParseUnionPushDeferred($$$$)
1979 {
1980 my ($self,$e,$ndr,$varname) = @_;
1981
1982 my $have_default = 0;
1983
1984 if (defined($e->{PROPERTIES}{relative_base})) {
1985 # retrieve the current offset as base for relative pointers
1986 # based on the toplevel struct/union
1987 $self->pidl("NDR_CHECK(ndr_push_setup_relative_base_offset2($ndr, $varname));");
1988 }
1989 $self->pidl("switch (level) {");
1990 $self->indent;
1991 foreach my $el (@{$e->{ELEMENTS}}) {
1992 if ($el->{CASE} eq "default") {
1993 $have_default = 1;
1994 }
1995
1996 $self->pidl("$el->{CASE}:");
1997 if ($el->{TYPE} ne "EMPTY") {
1998 $self->indent;
1999 $self->ParseElementPush($el, $ndr, {$el->{NAME} => "$varname->$el->{NAME}"}, 0, 1);
2000 $self->deindent;
2001 }
2002 $self->pidl("break;");
2003 $self->pidl("");
2004 }
2005 if (! $have_default) {
2006 $self->pidl("default:");
2007 $self->pidl("\treturn ndr_push_error($ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %\"PRIu32, level);");
2008 }
2009 $self->deindent;
2010 $self->pidl("}");
2011 }
2012
2013 #####################################################################
2014 # parse a union - push side
2015 sub ParseUnionPush($$$$)
2016 {
2017 my ($self,$e,$ndr,$varname) = @_;
2018 my $have_default = 0;
2019
2020 $self->pidl("uint32_t level;");
2021 $self->start_flags($e, $ndr);
2022
2023 $self->pidl("NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);");
2024 $self->pidl("if (ndr_flags & NDR_SCALARS) {");
2025 $self->indent;
2026 $self->pidl("/* This token is not used again (except perhaps below in the NDR_BUFFERS case) */");
2027 $self->pidl("NDR_CHECK(ndr_push_steal_switch_value($ndr, $varname, &level));");
2028
2029 $self->ParseUnionPushPrimitives($e, $ndr, $varname);
2030 $self->deindent;
2031 $self->pidl("}");
2032 if (is_deferred_switch_non_empty($e)) {
2033 $self->pidl("if (ndr_flags & NDR_BUFFERS) {");
2034 $self->indent;
2035 # In case we had ndr_flags of NDR_SCALERS|NDR_BUFFERS
2036 $self->pidl("if (!(ndr_flags & NDR_SCALARS)) {");
2037 $self->indent;
2038 $self->pidl("/* We didn't get it above, and the token is not needed after this. */");
2039 $self->pidl("NDR_CHECK(ndr_push_steal_switch_value($ndr, $varname, &level));");
2040 $self->deindent;
2041 $self->pidl("}");
2042 $self->ParseUnionPushDeferred($e, $ndr, $varname);
2043 $self->deindent;
2044 $self->pidl("}");
2045 }
2046 $self->end_flags($e, $ndr);
2047 }
2048
2049 #####################################################################
2050 # print a union
2051 sub ParseUnionPrint($$$$$)
2052 {
2053 my ($self,$e,$ndr,$name,$varname) = @_;
2054 my $have_default = 0;
2055
2056 $self->pidl("uint32_t level;");
2057 foreach my $el (@{$e->{ELEMENTS}}) {
2058 $self->DeclareArrayVariables($el);
2059 }
2060
2061 $self->start_flags($e, $ndr);
2062
2063 $self->pidl("level = ndr_print_steal_switch_value($ndr, $varname);");
2064
2065 $self->pidl("ndr_print_union($ndr, name, level, \"$name\");");
2066
2067 $self->pidl("switch (level) {");
2068 $self->indent;
2069 foreach my $el (@{$e->{ELEMENTS}}) {
2070 if ($el->{CASE} eq "default") {
2071 $have_default = 1;
2072 }
2073 $self->pidl("$el->{CASE}:");
2074 if ($el->{TYPE} ne "EMPTY") {
2075 $self->indent;
2076 $self->ParseElementPrint($el, $ndr, "$varname->$el->{NAME}", {});
2077 $self->deindent;
2078 }
2079 $self->pidl("break;");
2080 $self->pidl("");
2081 }
2082 if (! $have_default) {
2083 $self->pidl("default:");
2084 $self->pidl("\tndr_print_bad_level($ndr, name, level);");
2085 }
2086 $self->deindent;
2087 $self->pidl("}");
2088
2089 $self->end_flags($e, $ndr);
2090 }
2091
2092 sub ParseUnionPullPrimitives($$$$$)
2093 {
2094 my ($self,$e,$ndr,$varname,$switch_type) = @_;
2095 my $have_default = 0;
2096
2097
2098 if (defined($switch_type)) {
2099 if (defined($e->{ALIGN})) {
2100 $self->pidl("NDR_CHECK(ndr_pull_union_align($ndr, $e->{ALIGN}));");
2101 }
2102
2103 my $data_type = mapTypeName($switch_type);
2104 my $fmt = mapTypeSpecifier($data_type);
2105
2106 if (!defined($fmt)) {
2107 $data_type = "int";
2108 $fmt = "%d";
2109 }
2110
2111 $self->pidl("NDR_CHECK(ndr_pull_$switch_type($ndr, NDR_SCALARS, &_level));");
2112 $self->pidl("if (_level != level) {");
2113 $self->pidl("\treturn ndr_pull_error($ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %$fmt for $varname at \%s\", ($data_type)_level, __location__);");
2114 $self->pidl("}");
2115 }
2116
2117 if (defined($e->{ALIGN})) {
2118 if ($e->{IS_MS_UNION}) {
2119 $self->pidl("/* ms_union is always aligned to the largest union arm*/");
2120 $self->pidl("NDR_CHECK(ndr_pull_align($ndr, $e->{ALIGN}));");
2121 } else {
2122 $self->pidl("NDR_CHECK(ndr_pull_union_align($ndr, $e->{ALIGN}));");
2123 }
2124 }
2125
2126 $self->pidl("switch (level) {");
2127 $self->indent;
2128 foreach my $el (@{$e->{ELEMENTS}}) {
2129 if ($el->{CASE} eq "default") {
2130 $have_default = 1;
2131 }
2132 $self->pidl("$el->{CASE}: {");
2133
2134 if ($el->{TYPE} ne "EMPTY") {
2135 $self->indent;
2136 if (defined($e->{PROPERTIES}{relative_base})) {
2137 $self->pidl("NDR_CHECK(ndr_pull_align($ndr, $el->{ALIGN}));");
2138 # set the current offset as base for relative pointers
2139 # and store it based on the toplevel struct/union
2140 $self->pidl("NDR_CHECK(ndr_pull_setup_relative_base_offset1($ndr, $varname, $ndr->offset));");
2141 }
2142 $self->ParseElementPull($el, $ndr, {$el->{NAME} => "$varname->$el->{NAME}"}, 1, 0);
2143 $self->deindent;
2144 }
2145 $self->pidl("break; }");
2146 $self->pidl("");
2147 }
2148 if (! $have_default) {
2149 $self->pidl("default:");
2150 $self->pidl("\treturn ndr_pull_error($ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %\"PRIu32\" at %s\", level, __location__);");
2151 }
2152 $self->deindent;
2153 $self->pidl("}");
2154 }
2155
2156 sub ParseUnionPullDeferred($$$$)
2157 {
2158 my ($self,$e,$ndr,$varname) = @_;
2159 my $have_default = 0;
2160
2161 $self->pidl("switch (level) {");
2162 $self->indent;
2163 foreach my $el (@{$e->{ELEMENTS}}) {
2164 if ($el->{CASE} eq "default") {
2165 $have_default = 1;
2166 }
2167
2168 $self->pidl("$el->{CASE}:");
2169 if ($el->{TYPE} ne "EMPTY") {
2170 $self->indent;
2171 if (defined($e->{PROPERTIES}{relative_base})) {
2172 # retrieve the current offset as base for relative pointers
2173 # based on the toplevel struct/union
2174 $self->pidl("NDR_CHECK(ndr_pull_setup_relative_base_offset2($ndr, $varname));");
2175 }
2176 $self->ParseElementPull($el, $ndr, {$el->{NAME} => "$varname->$el->{NAME}"}, 0, 1);
2177 $self->deindent;
2178 }
2179 $self->pidl("break;");
2180 $self->pidl("");
2181 }
2182 if (! $have_default) {
2183 $self->pidl("default:");
2184 $self->pidl("\treturn ndr_pull_error($ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %\"PRIu32\" at %s\", level, __location__);");
2185 }
2186 $self->deindent;
2187 $self->pidl("}");
2188
2189
2190 }
2191
2192 #####################################################################
2193 # parse a union - pull side
2194 sub ParseUnionPull($$$$)
2195 {
2196 my ($self,$e,$ndr,$varname) = @_;
2197 my $switch_type = $e->{SWITCH_TYPE};
2198 my $needs_deferred_switch = is_deferred_switch_non_empty($e);
2199 $self->pidl("uint32_t level;");
2200 if (defined($switch_type)) {
2201 if (Parse::Pidl::Typelist::typeIs($switch_type, "ENUM")) {
2202 $switch_type = Parse::Pidl::Typelist::enum_type_fn(getType($switch_type)->{DATA});
2203 }
2204 $self->pidl(mapTypeName($switch_type) . " _level;");
2205 }
2206
2207 my %double_cases = ();
2208 foreach my $el (@{$e->{ELEMENTS}}) {
2209 next if ($el->{TYPE} eq "EMPTY");
2210 next if ($double_cases{"$el->{NAME}"});
2211 $self->DeclareMemCtxVariables($el);
2212 $self->DeclarePtrVariables($el);
2213 $self->DeclareArrayVariables($el, "pull");
2214 $double_cases{"$el->{NAME}"} = 1;
2215 }
2216
2217 $self->start_flags($e, $ndr);
2218
2219 $self->pidl("NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);");
2220 $self->pidl("if (ndr_flags & NDR_SCALARS) {");
2221 $self->indent;
2222 $self->pidl("/* This token is not used again (except perhaps below in the NDR_BUFFERS case) */");
2223 $self->pidl("NDR_CHECK(ndr_pull_steal_switch_value($ndr, $varname, &level));");
2224 $self->ParseUnionPullPrimitives($e,$ndr,$varname,$switch_type);
2225 $self->deindent;
2226 $self->pidl("}");
2227 if ($needs_deferred_switch) {
2228 $self->pidl("if (ndr_flags & NDR_BUFFERS) {");
2229 $self->indent;
2230 # In case we had ndr_flags of NDR_SCALERS|NDR_BUFFERS
2231 $self->pidl("if (!(ndr_flags & NDR_SCALARS)) {");
2232 $self->indent;
2233 $self->pidl("/* We didn't get it above, and the token is not needed after this. */");
2234 $self->pidl("NDR_CHECK(ndr_pull_steal_switch_value($ndr, $varname, &level));");
2235 $self->deindent;
2236 $self->pidl("}");
2237 $self->ParseUnionPullDeferred($e,$ndr,$varname);
2238 $self->deindent;
2239 $self->pidl("}");
2240 }
2241 $self->add_deferred();
2242
2243 $self->end_flags($e, $ndr);
2244 }
2245
2246 sub DeclUnion($$$$)
2247 {
2248 my ($e,$t,$name,$varname) = @_;
2249 if ($t eq "base") {
2250 return "union $name $varname";
2251 }
2252 return ($t ne "pull"?"const ":"") . "union $name *$varname";
2253 }
2254
2255 sub ArgsUnionNdrSize($$)
2256 {
2257 my ($d,$name) = @_;
2258 return "const union $name *r, uint32_t level, libndr_flags flags";
2259 }
2260
2261 $typefamily{UNION} = {
2262 PUSH_FN_BODY => \&ParseUnionPush,
2263 DECL => \&DeclUnion,
2264 PULL_FN_BODY => \&ParseUnionPull,
2265 PRINT_FN_BODY => \&ParseUnionPrint,
2266 SIZE_FN_ARGS => \&ArgsUnionNdrSize,
2267 SIZE_FN_BODY => \&ParseUnionNdrSize,
2268 };
2269
2270 #####################################################################
2271 # parse a typedef - push side
2272 sub ParseTypedefPush($$$$)
2273 {
2274 my($self,$e,$ndr,$varname) = @_;
2275
2276 my $env;
2277
2278 $env->{$e->{NAME}} = $varname;
2279
2280 $self->ParseElementPushLevel($e, $e->{LEVELS}[0], $ndr, $varname, $env, 1, 1);
2281 }
2282
2283 #####################################################################
2284 # parse a typedef - pull side
2285 sub ParseTypedefPull($$$$)
2286 {
2287 my($self,$e,$ndr,$varname) = @_;
2288
2289 my $env;
2290
2291 $env->{$e->{NAME}} = $varname;
2292
2293 $self->ParseElementPullLevel($e, $e->{LEVELS}[0], $ndr, $varname, $env, 1, 1);
2294 }
2295
2296 #####################################################################
2297 # parse a typedef - print side
2298 sub ParseTypedefPrint($$$$$)
2299 {
2300 my($self,$e,$ndr,$name,$varname) = @_;
2301
2302 $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($self, $e->{DATA}, $ndr, $name, $varname);
2303 }
2304
2305 #####################################################################
2306 ## calculate the size of a structure
2307 sub ParseTypedefNdrSize($$$$)
2308 {
2309 my($self,$t,$name,$varname) = @_;
2310
2311 $typefamily{$t->{DATA}->{TYPE}}->{SIZE_FN_BODY}->($self, $t->{DATA}, $name, $varname);
2312 }
2313
2314 sub DeclTypedef($$$$)
2315 {
2316 my ($e, $t, $name, $varname) = @_;
2317
2318 return $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e->{DATA}, $t, $name, $varname);
2319 }
2320
2321 sub ArgsTypedefNdrSize($$$)
2322 {
2323 my ($d, $name, $varname) = @_;
2324 return $typefamily{$d->{DATA}->{TYPE}}->{SIZE_FN_ARGS}->($d->{DATA}, $name, $varname);
2325 }
2326
2327 $typefamily{TYPEDEF} = {
2328 PUSH_FN_BODY => \&ParseTypedefPush,
2329 DECL => \&DeclTypedef,
2330 PULL_FN_BODY => \&ParseTypedefPull,
2331 PRINT_FN_BODY => \&ParseTypedefPrint,
2332 SIZE_FN_ARGS => \&ArgsTypedefNdrSize,
2333 SIZE_FN_BODY => \&ParseTypedefNdrSize,
2334 };
2335
2336 sub ParsePipePushChunk($$)
2337 {
2338 my ($self, $t) = @_;
2339
2340 my $pipe = $t;
2341 $pipe = $t->{DATA} if ($t->{TYPE} eq "TYPEDEF");
2342 my $struct = $pipe->{DATA};
2343
2344 my $name = "$struct->{NAME}";
2345 my $ndr = "ndr";
2346 my $varname = "r";
2347
2348 my $args = $typefamily{$struct->{TYPE}}->{DECL}->($struct, "push", $name, $varname);
2349
2350 $self->fn_declare("push", $struct, "enum ndr_err_code ndr_push_$name(struct ndr_push *$ndr, ndr_flags_type ndr_flags, $args)") or return;
2351
2352 return if has_property($t, "nopush");
2353
2354 $self->pidl("{");
2355 $self->indent;
2356
2357 $self->ParseStructPush($struct, $ndr, $varname);
2358 $self->pidl("");
2359
2360 $self->pidl("NDR_CHECK(ndr_push_pipe_chunk_trailer(ndr, ndr_flags, $varname->count));");
2361 $self->pidl("");
2362
2363 $self->pidl("return NDR_ERR_SUCCESS;");
2364 $self->deindent;
2365 $self->pidl("}");
2366 $self->pidl("");
2367 }
2368
2369 sub ParsePipePullChunk($$)
2370 {
2371 my ($self, $t) = @_;
2372
2373 my $pipe = $t;
2374 $pipe = $t->{DATA} if ($t->{TYPE} eq "TYPEDEF");
2375 my $struct = $pipe->{DATA};
2376
2377 my $name = "$struct->{NAME}";
2378 my $ndr = "ndr";
2379 my $varname = "r";
2380
2381 my $args = $typefamily{$struct->{TYPE}}->{DECL}->($struct, "pull", $name, $varname);
2382
2383 $self->fn_declare("pull", $struct, "enum ndr_err_code ndr_pull_$name(struct ndr_pull *$ndr, ndr_flags_type ndr_flags, $args)") or return;
2384
2385 return if has_property($struct, "nopull");
2386
2387 $self->pidl("{");
2388 $self->indent;
2389
2390 $self->ParseStructPull($struct, $ndr, $varname);
2391 $self->pidl("");
2392
2393 $self->pidl("NDR_CHECK(ndr_check_pipe_chunk_trailer($ndr, ndr_flags, $varname->count));");
2394 $self->pidl("");
2395
2396 $self->pidl("return NDR_ERR_SUCCESS;");
2397 $self->deindent;
2398 $self->pidl("}");
2399 $self->pidl("");
2400 }
2401
2402 sub ParsePipePrintChunk($$)
2403 {
2404 my ($self, $t) = @_;
2405
2406 my $pipe = $t;
2407 $pipe = $t->{DATA} if ($t->{TYPE} eq "TYPEDEF");
2408 my $struct = $pipe->{DATA};
2409
2410 my $name = "$struct->{NAME}";
2411 my $ndr = "ndr";
2412 my $varname = "r";
2413
2414 my $args = $typefamily{$struct->{TYPE}}->{DECL}->($struct, "print", $name, $varname);
2415
2416 $self->pidl_hdr("void ndr_print_$name(struct ndr_print *ndr, const char *name, $args);");
2417
2418 return if (has_property($t, "noprint"));
2419
2420 $self->pidl("_PUBLIC_ void ndr_print_$name(struct ndr_print *$ndr, const char *name, $args)");
2421 $self->pidl("{");
2422 $self->indent;
2423 $self->ParseTypePrint($struct, $ndr, $varname);
2424 $self->deindent;
2425 $self->pidl("}");
2426 $self->pidl("");
2427 }
2428
2429 #####################################################################
2430 # parse a function - print side
2431 sub ParseFunctionPrint($$)
2432 {
2433 my($self, $fn) = @_;
2434 my $ndr = "ndr";
2435
2436 $self->pidl_hdr("void ndr_print_$fn->{NAME}(struct ndr_print *$ndr, const char *name, ndr_flags_type flags, const struct $fn->{NAME} *r);");
2437
2438 return if has_property($fn, "noprint");
2439
2440 $self->pidl("_PUBLIC_ void ndr_print_$fn->{NAME}(struct ndr_print *$ndr, const char *name, ndr_flags_type flags, const struct $fn->{NAME} *r)");
2441 $self->pidl("{");
2442 $self->indent;
2443
2444 foreach my $e (@{$fn->{ELEMENTS}}) {
2445 $self->DeclareArrayVariables($e);
2446 }
2447
2448 $self->pidl("ndr_print_struct($ndr, name, \"$fn->{NAME}\");");
2449 $self->pidl("if (r == NULL) { ndr_print_null($ndr); return; }");
2450 $self->pidl("$ndr->depth++;");
2451
2452 $self->pidl("if (flags & NDR_SET_VALUES) {");
2453 $self->pidl("\t$ndr->flags |= LIBNDR_PRINT_SET_VALUES;");
2454 $self->pidl("}");
2455
2456 $self->pidl("if (flags & NDR_IN) {");
2457 $self->indent;
2458 $self->pidl("ndr_print_struct($ndr, \"in\", \"$fn->{NAME}\");");
2459 $self->pidl("$ndr->depth++;");
2460
2461 my $env = GenerateFunctionInEnv($fn);
2462
2463 foreach my $e (@{$fn->{ELEMENTS}}) {
2464 if (grep(/in/,@{$e->{DIRECTION}})) {
2465 $self->ParseElementPrint($e, $ndr, $env->{$e->{NAME}}, $env);
2466 }
2467 }
2468 $self->pidl("$ndr->depth--;");
2469 $self->deindent;
2470 $self->pidl("}");
2471
2472 $self->pidl("if (flags & NDR_OUT) {");
2473 $self->indent;
2474 $self->pidl("ndr_print_struct($ndr, \"out\", \"$fn->{NAME}\");");
2475 $self->pidl("$ndr->depth++;");
2476
2477 $env = GenerateFunctionOutEnv($fn);
2478 foreach my $e (@{$fn->{ELEMENTS}}) {
2479 if (grep(/out/,@{$e->{DIRECTION}})) {
2480 $self->ParseElementPrint($e, $ndr, $env->{$e->{NAME}}, $env);
2481 }
2482 }
2483 if ($fn->{RETURN_TYPE}) {
2484 $self->pidl("ndr_print_$fn->{RETURN_TYPE}($ndr, \"result\", r->out.result);");
2485 }
2486 $self->pidl("$ndr->depth--;");
2487 $self->deindent;
2488 $self->pidl("}");
2489
2490 $self->pidl("$ndr->depth--;");
2491 $self->deindent;
2492 $self->pidl("}");
2493 $self->pidl("");
2494 }
2495
2496 #####################################################################
2497 # parse a function
2498 sub ParseFunctionPush($$)
2499 {
2500 my($self, $fn) = @_;
2501 my $ndr = "ndr";
2502
2503 $self->fn_declare("push", $fn, "enum ndr_err_code ndr_push_$fn->{NAME}(struct ndr_push *$ndr, ndr_flags_type flags, const struct $fn->{NAME} *r)") or return;
2504
2505 return if has_property($fn, "nopush");
2506
2507 $self->pidl("{");
2508 $self->indent;
2509
2510 foreach my $e (@{$fn->{ELEMENTS}}) {
2511 $self->DeclareArrayVariables($e);
2512 }
2513
2514 $self->pidl("NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);");
2515
2516 $self->pidl("if (flags & NDR_IN) {");
2517 $self->indent;
2518
2519 my $env = GenerateFunctionInEnv($fn);
2520
2521 EnvSubstituteValue($env, $fn);
2522
2523 foreach my $e (@{$fn->{ELEMENTS}}) {
2524 if (grep(/in/,@{$e->{DIRECTION}})) {
2525 $self->CheckRefPtrs($e, $ndr, $env);
2526 }
2527 }
2528
2529 foreach my $e (@{$fn->{ELEMENTS}}) {
2530 if (grep(/in/,@{$e->{DIRECTION}})) {
2531 $self->ParseElementPush($e, $ndr, $env, 1, 1);
2532 }
2533 }
2534
2535 $self->deindent;
2536 $self->pidl("}");
2537
2538 $self->pidl("if (flags & NDR_OUT) {");
2539 $self->indent;
2540
2541 $env = GenerateFunctionOutEnv($fn);
2542 EnvSubstituteValue($env, $fn);
2543
2544 foreach my $e (@{$fn->{ELEMENTS}}) {
2545 if (grep(/out/,@{$e->{DIRECTION}})) {
2546 $self->CheckRefPtrs($e, $ndr, $env);
2547 }
2548 }
2549
2550 foreach my $e (@{$fn->{ELEMENTS}}) {
2551 if (grep(/out/,@{$e->{DIRECTION}})) {
2552 $self->ParseElementPush($e, $ndr, $env, 1, 1);
2553 }
2554 }
2555
2556 if ($fn->{RETURN_TYPE}) {
2557 $self->pidl("NDR_CHECK(ndr_push_$fn->{RETURN_TYPE}($ndr, NDR_SCALARS, r->out.result));");
2558 }
2559
2560 $self->deindent;
2561 $self->pidl("}");
2562 $self->pidl("return NDR_ERR_SUCCESS;");
2563 $self->deindent;
2564 $self->pidl("}");
2565 $self->pidl("");
2566 }
2567
2568 sub AllocateArrayLevel($$$$$$)
2569 {
2570 my ($self,$e,$l,$ndr,$var,$size) = @_;
2571
2572 my $pl = GetPrevLevel($e, $l);
2573 if (defined($pl) and
2574 $pl->{TYPE} eq "POINTER" and
2575 $pl->{POINTER_TYPE} eq "ref"
2576 and not $l->{IS_ZERO_TERMINATED}) {
2577 $self->pidl("if ($ndr->flags & LIBNDR_FLAG_REF_ALLOC) {");
2578 $self->pidl("\tNDR_PULL_ALLOC_N($ndr, $var, $size);");
2579 $self->pidl("}");
2580 if (grep(/in/,@{$e->{DIRECTION}}) and
2581 grep(/out/,@{$e->{DIRECTION}})) {
2582 $self->pidl("memcpy(r->out.$e->{NAME}, r->in.$e->{NAME}, ($size) * sizeof(*r->in.$e->{NAME}));");
2583 }
2584 return;
2585 }
2586
2587 $self->pidl("NDR_PULL_ALLOC_N($ndr, $var, $size);");
2588 }
2589
2590 #####################################################################
2591 # parse a function
2592 sub ParseFunctionPull($$)
2593 {
2594 my($self,$fn) = @_;
2595 my $ndr = "ndr";
2596
2597 # pull function args
2598 $self->fn_declare("pull", $fn, "enum ndr_err_code ndr_pull_$fn->{NAME}(struct ndr_pull *$ndr, ndr_flags_type flags, struct $fn->{NAME} *r)") or return;
2599
2600 $self->pidl("{");
2601 $self->indent;
2602
2603 # declare any internal pointers we need
2604 foreach my $e (@{$fn->{ELEMENTS}}) {
2605 $self->DeclarePtrVariables($e);
2606 $self->DeclareArrayVariables($e, "pull");
2607 }
2608
2609 my %double_cases = ();
2610 foreach my $e (@{$fn->{ELEMENTS}}) {
2611 next if ($e->{TYPE} eq "EMPTY");
2612 next if ($double_cases{"$e->{NAME}"});
2613 $self->DeclareMemCtxVariables($e);
2614 $double_cases{"$e->{NAME}"} = 1;
2615 }
2616
2617 $self->pidl("NDR_PULL_CHECK_FN_FLAGS(ndr, flags);");
2618
2619 $self->pidl("if (flags & NDR_IN) {");
2620 $self->indent;
2621
2622 # auto-init the out section of a structure. I originally argued that
2623 # this was a bad idea as it hides bugs, but coping correctly
2624 # with initialisation and not wiping ref vars is turning
2625 # out to be too tricky (tridge)
2626 foreach my $e (@{$fn->{ELEMENTS}}) {
2627 next unless grep(/out/, @{$e->{DIRECTION}});
2628 $self->pidl("NDR_ZERO_STRUCT(r->out);");
2629 $self->pidl("");
2630 last;
2631 }
2632
2633 my $env = GenerateFunctionInEnv($fn);
2634
2635 foreach my $e (@{$fn->{ELEMENTS}}) {
2636 next unless (grep(/in/, @{$e->{DIRECTION}}));
2637 $self->ParseElementPull($e, $ndr, $env, 1, 1);
2638 }
2639
2640 # allocate the "simple" out ref variables. FIXME: Shouldn't this have it's
2641 # own flag rather than be in NDR_IN ?
2642
2643 foreach my $e (@{$fn->{ELEMENTS}}) {
2644 next unless (grep(/out/, @{$e->{DIRECTION}}));
2645 next unless ($e->{LEVELS}[0]->{TYPE} eq "POINTER" and
2646 $e->{LEVELS}[0]->{POINTER_TYPE} eq "ref");
2647 next if (($e->{LEVELS}[1]->{TYPE} eq "DATA") and
2648 (Parse::Pidl::Typelist::is_string_type($e->{LEVELS}[1]->{DATA_TYPE})));
2649 next if ($e->{LEVELS}[1]->{TYPE} eq "PIPE");
2650 next if (($e->{LEVELS}[1]->{TYPE} eq "ARRAY")
2651 and $e->{LEVELS}[1]->{IS_ZERO_TERMINATED});
2652
2653 if ($e->{LEVELS}[1]->{TYPE} eq "ARRAY") {
2654 my $size = ParseExprExt($e->{LEVELS}[1]->{SIZE_IS}, $env, $e->{ORIGINAL},
2655 check_null_pointer($e, $env, sub { $self->pidl(shift); },
2656 "return ndr_pull_error($ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for size_is()\");"),
2657 check_fully_dereferenced($e, $env));
2658 $self->pidl("NDR_PULL_ALLOC_N($ndr, r->out.$e->{NAME}, $size);");
2659
2660 if (grep(/in/, @{$e->{DIRECTION}})) {
2661 $self->pidl("memcpy(r->out.$e->{NAME}, r->in.$e->{NAME}, ($size) * sizeof(*r->in.$e->{NAME}));");
2662 } else {
2663 $self->pidl("memset(r->out.$e->{NAME}, 0, ($size) * sizeof(*r->out.$e->{NAME}));");
2664 }
2665 } elsif ($e->{LEVELS}[1]->{TYPE} eq "ARRAY") {
2666 if (grep(/in/, @{$e->{DIRECTION}})) {
2667 $self->pidl("r->out.$e->{NAME} = r->in.$e->{NAME};");
2668 } else {
2669 $self->pidl("r->out.$e->{NAME} = NULL;");
2670 }
2671 } else {
2672 $self->pidl("NDR_PULL_ALLOC($ndr, r->out.$e->{NAME});");
2673
2674 if (grep(/in/, @{$e->{DIRECTION}})) {
2675 $self->pidl("*r->out.$e->{NAME} = *r->in.$e->{NAME};");
2676 } else {
2677 $self->pidl("NDR_ZERO_STRUCTP(r->out.$e->{NAME});");
2678 }
2679 }
2680 }
2681
2682 $self->add_deferred();
2683 $self->deindent;
2684 $self->pidl("}");
2685
2686 $self->pidl("if (flags & NDR_OUT) {");
2687 $self->indent;
2688
2689 $self->pidl("#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION");
2690
2691 # This is for fuzzers of ndr_pull where the out elements refer to
2692 # in elements in size_is or length_is.
2693 #
2694 # Not actually very harmful but also not useful outside a fuzzer
2695 foreach my $e (@{$fn->{ELEMENTS}}) {
2696 next unless (grep(/in/, @{$e->{DIRECTION}}));
2697 next unless ($e->{LEVELS}[0]->{TYPE} eq "POINTER" and
2698 $e->{LEVELS}[0]->{POINTER_TYPE} eq "ref");
2699 next if (($e->{LEVELS}[1]->{TYPE} eq "DATA") and
2700 (Parse::Pidl::Typelist::is_string_type($e->{LEVELS}[1]->{DATA_TYPE})));
2701 next if ($e->{LEVELS}[1]->{TYPE} eq "PIPE");
2702 next if ($e->{LEVELS}[1]->{TYPE} eq "ARRAY");
2703
2704 $self->pidl("if (r->in.$e->{NAME} == NULL) {");
2705 $self->indent;
2706 $self->pidl("NDR_PULL_ALLOC($ndr, r->in.$e->{NAME});");
2707 $self->pidl("NDR_ZERO_STRUCTP(r->in.$e->{NAME});");
2708 $self->deindent;
2709 $self->pidl("}");
2710 }
2711
2712 $self->pidl("#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */");
2713
2714 $env = GenerateFunctionOutEnv($fn);
2715 foreach my $e (@{$fn->{ELEMENTS}}) {
2716 next unless grep(/out/, @{$e->{DIRECTION}});
2717 $self->ParseElementPull($e, $ndr, $env, 1, 1);
2718 }
2719
2720 if ($fn->{RETURN_TYPE}) {
2721 $self->pidl("NDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}($ndr, NDR_SCALARS, &r->out.result));");
2722 }
2723
2724 $self->add_deferred();
2725 $self->deindent;
2726 $self->pidl("}");
2727
2728 $self->pidl("return NDR_ERR_SUCCESS;");
2729 $self->deindent;
2730 $self->pidl("}");
2731 $self->pidl("");
2732 }
2733
2734 sub AuthServiceStruct($$$)
2735 {
2736 my ($self, $ifacename, $authservice) = @_;
2737 my @a = split /,/, $authservice;
2738 my $authservice_count = $#a + 1;
2739
2740 $self->pidl("static const char * const $ifacename\_authservice_strings[] = {");
2741 foreach my $ap (@a) {
2742 $self->pidl("\t$ap, ");
2743 }
2744 $self->pidl("};");
2745 $self->pidl("");
2746
2747 $self->pidl("static const struct ndr_interface_string_array $ifacename\_authservices = {");
2748 $self->pidl("\t.count\t= $authservice_count,");
2749 $self->pidl("\t.names\t= $ifacename\_authservice_strings");
2750 $self->pidl("};");
2751 $self->pidl("");
2752 }
2753
2754 sub ParseGeneratePipeArray($$$)
2755 {
2756 my ($self, $fn, $direction) = @_;
2757
2758 $self->pidl("static const struct ndr_interface_call_pipe $fn->{NAME}\_$direction\_pipes[] = {");
2759 $self->indent;
2760
2761 foreach my $e (@{$fn->{ELEMENTS}}) {
2762 next unless ContainsPipe($e, $e->{LEVELS}[0]);
2763 next unless (grep(/$direction/, @{$e->{DIRECTION}}));
2764
2765 my $cname = "$e->{TYPE}_chunk";
2766
2767 $self->pidl("{");
2768 $self->indent;
2769 $self->pidl("\"$direction.$e->{NAME}\",");
2770 $self->pidl("\"$cname\",");
2771 $self->pidl("sizeof(struct $cname),");
2772 $self->pidl("(ndr_push_flags_fn_t) ndr_push_$cname,");
2773 $self->pidl("(ndr_pull_flags_fn_t) ndr_pull_$cname,");
2774 $self->pidl("(ndr_print_fn_t) ndr_print_$cname,");
2775 $self->deindent;
2776 $self->pidl("},");
2777 }
2778 $self->pidl("{ .name = NULL }");
2779 $self->deindent;
2780 $self->pidl("};");
2781 $self->pidl("");
2782 }
2783
2784 sub FunctionCallPipes($$)
2785 {
2786 my ($self, $d) = @_;
2787 return if not defined($d->{OPNUM});
2788
2789 my $in_pipes = 0;
2790 my $out_pipes = 0;
2791
2792 foreach my $e (@{$d->{ELEMENTS}}) {
2793 next unless ContainsPipe($e, $e->{LEVELS}[0]);
2794
2795 if (grep(/in/, @{$e->{DIRECTION}})) {
2796 $in_pipes++;
2797 }
2798 if (grep(/out/, @{$e->{DIRECTION}})) {
2799 $out_pipes++;
2800 }
2801 }
2802
2803 if ($in_pipes) {
2804 $self->ParseGeneratePipeArray($d, "in");
2805 }
2806
2807 if ($out_pipes) {
2808 $self->ParseGeneratePipeArray($d, "out");
2809 }
2810 }
2811
2812 sub FunctionCallEntry($$)
2813 {
2814 my ($self, $d) = @_;
2815 return 0 if not defined($d->{OPNUM});
2816
2817 my $in_pipes = 0;
2818 my $out_pipes = 0;
2819
2820 foreach my $e (@{$d->{ELEMENTS}}) {
2821 next unless ContainsPipe($e, $e->{LEVELS}[0]);
2822
2823 if (grep(/in/, @{$e->{DIRECTION}})) {
2824 $in_pipes++;
2825 }
2826 if (grep(/out/, @{$e->{DIRECTION}})) {
2827 $out_pipes++;
2828 }
2829 }
2830
2831 my $in_pipes_ptr = "NULL";
2832 my $out_pipes_ptr = "NULL";
2833
2834 if ($in_pipes) {
2835 $in_pipes_ptr = "$d->{NAME}_in_pipes";
2836 }
2837
2838 if ($out_pipes) {
2839 $out_pipes_ptr = "$d->{NAME}_out_pipes";
2840 }
2841
2842 $self->pidl("\t{");
2843 $self->pidl("\t\t\"$d->{NAME}\",");
2844 $self->pidl("\t\tsizeof(struct $d->{NAME}),");
2845 $self->pidl("\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},");
2846 $self->pidl("\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},");
2847 $self->pidl("\t\t(ndr_print_function_t) ndr_print_$d->{NAME},");
2848 $self->pidl("\t\t{ $in_pipes, $in_pipes_ptr },");
2849 $self->pidl("\t\t{ $out_pipes, $out_pipes_ptr },");
2850 $self->pidl("\t},");
2851 return 1;
2852 }
2853
2854 sub StructEntry($$)
2855 {
2856 my ($self, $d) = @_;
2857 my $type_decl = $typefamily{$d->{TYPE}}->{DECL}->($d, "base", $d->{NAME}, "");
2858
2859 $self->pidl("\t{");
2860 $self->pidl("\t\t.name = \"$d->{NAME}\",");
2861 $self->pidl("\t\t.struct_size = sizeof($type_decl),");
2862 $self->pidl("\t\t.ndr_push = (ndr_push_flags_fn_t) ndr_push_$d->{NAME},");
2863 $self->pidl("\t\t.ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},");
2864 $self->pidl("\t\t.ndr_print = (ndr_print_function_t) ndr_print_flags_$d->{NAME},");
2865 $self->pidl("\t},");
2866 return 1;
2867 }
2868
2869 #####################################################################
2870 # produce a function call table
2871 sub FunctionTable($$)
2872 {
2873 my($self,$interface) = @_;
2874 my $count = 0;
2875 my $count_public_structs = 0;
2876 my $uname = uc $interface->{NAME};
2877
2878 foreach my $d (@{$interface->{TYPES}}) {
2879 next unless (is_public_struct($d));
2880 $count_public_structs += 1;
2881 }
2882 return if ($#{$interface->{FUNCTIONS}}+1 == 0 and
2883 $count_public_structs == 0);
2884
2885 foreach my $d (@{$interface->{INHERITED_FUNCTIONS}},@{$interface->{FUNCTIONS}}) {
2886 $self->FunctionCallPipes($d);
2887 }
2888
2889 $self->pidl("static const struct ndr_interface_public_struct $interface->{NAME}\_public_structs[] = {");
2890
2891 foreach my $d (@{$interface->{TYPES}}) {
2892 next unless (is_public_struct($d));
2893 $self->StructEntry($d);
2894 }
2895 $self->pidl("\t{ .name = NULL }");
2896 $self->pidl("};");
2897 $self->pidl("");
2898
2899 $self->pidl("static const struct ndr_interface_call $interface->{NAME}\_calls[] = {");
2900
2901 foreach my $d (@{$interface->{INHERITED_FUNCTIONS}},@{$interface->{FUNCTIONS}}) {
2902 $count += $self->FunctionCallEntry($d);
2903 }
2904 $self->pidl("\t{ .name = NULL }");
2905 $self->pidl("};");
2906 $self->pidl("");
2907
2908 $self->pidl("static const char * const $interface->{NAME}\_endpoint_strings[] = {");
2909 foreach my $ep (@{$interface->{ENDPOINTS}}) {
2910 $self->pidl("\t$ep, ");
2911 }
2912 my $endpoint_count = $#{$interface->{ENDPOINTS}}+1;
2913
2914 $self->pidl("};");
2915 $self->pidl("");
2916
2917 $self->pidl("static const struct ndr_interface_string_array $interface->{NAME}\_endpoints = {");
2918 $self->pidl("\t.count\t= $endpoint_count,");
2919 $self->pidl("\t.names\t= $interface->{NAME}\_endpoint_strings");
2920 $self->pidl("};");
2921 $self->pidl("");
2922
2923 if (! defined $interface->{PROPERTIES}->{authservice}) {
2924 $interface->{PROPERTIES}->{authservice} = "\"host\"";
2925 }
2926
2927 $self->AuthServiceStruct($interface->{NAME},
2928 $interface->{PROPERTIES}->{authservice});
2929
2930 $self->pidl("\nconst struct ndr_interface_table ndr_table_$interface->{NAME} = {");
2931 $self->pidl("\t.name\t\t= \"$interface->{NAME}\",");
2932 if (defined $interface->{PROPERTIES}->{uuid}) {
2933 $self->pidl("\t.syntax_id\t= {");
2934 $self->pidl("\t\t" . print_uuid($interface->{UUID}) .",");
2935 $self->pidl("\t\tNDR_$uname\_VERSION");
2936 $self->pidl("\t},");
2937 $self->pidl("\t.helpstring\t= NDR_$uname\_HELPSTRING,");
2938 }
2939 $self->pidl("\t.num_calls\t= $count,");
2940 $self->pidl("\t.calls\t\t= $interface->{NAME}\_calls,");
2941 $self->pidl("\t.num_public_structs\t= $count_public_structs,");
2942 $self->pidl("\t.public_structs\t\t= $interface->{NAME}\_public_structs,");
2943 $self->pidl("\t.endpoints\t= &$interface->{NAME}\_endpoints,");
2944 $self->pidl("\t.authservices\t= &$interface->{NAME}\_authservices");
2945 $self->pidl("};");
2946 $self->pidl("");
2947
2948 }
2949
2950 #####################################################################
2951 # generate include statements for imported idl files
2952 sub HeaderImport
2953 {
2954 my $self = shift;
2955 my @imports = @_;
2956 foreach (@imports) {
2957 $_ = unmake_str($_);
2958 s/\.idl$//;
2959 $self->pidl(choose_header("librpc/gen_ndr/ndr_$_\.h", "gen_ndr/ndr_$_.h"));
2960 }
2961 }
2962
2963 #####################################################################
2964 # generate include statements for included header files
2965 sub HeaderInclude
2966 {
2967 my $self = shift;
2968 my @includes = @_;
2969 foreach (@includes) {
2970 $self->pidl_hdr("#include $_");
2971 }
2972 }
2973
2974 #####################################################################
2975 # generate prototypes and defines for the interface definitions
2976 # FIXME: these prototypes are for the DCE/RPC client functions, not the
2977 # NDR parser and so do not belong here, technically speaking
2978 sub HeaderInterface($$$)
2979 {
2980 my($self,$interface,$needed) = @_;
2981
2982 my $count = 0;
2983
2984 if ($needed->{"compression"}) {
2985 $self->pidl(choose_header("librpc/ndr/ndr_compression.h", "ndr/compression.h"));
2986 }
2987
2988 if (has_property($interface, "object")) {
2989 $self->pidl(choose_header("librpc/gen_ndr/ndr_orpc.h", "ndr/orpc.h"));
2990 }
2991
2992 if (defined $interface->{PROPERTIES}->{helper}) {
2993 $self->HeaderInclude(split /,/, $interface->{PROPERTIES}->{helper});
2994 }
2995
2996 if (defined $interface->{PROPERTIES}->{uuid}) {
2997 my $name = uc $interface->{NAME};
2998 $self->pidl_hdr("#define NDR_$name\_UUID " .
2999 Parse::Pidl::Util::make_str(lc($interface->{UUID})));
3000
3001 $self->pidl_hdr("#define NDR_$name\_VERSION $interface->{VERSION}");
3002
3003 $self->pidl_hdr("#define NDR_$name\_NAME \"$interface->{NAME}\"");
3004
3005 if(!defined $interface->{PROPERTIES}->{helpstring}) { $interface->{PROPERTIES}->{helpstring} = "NULL"; }
3006 $self->pidl_hdr("#define NDR_$name\_HELPSTRING $interface->{PROPERTIES}->{helpstring}");
3007 }
3008
3009 my $count_public_structs = 0;
3010 foreach my $d (@{$interface->{TYPES}}) {
3011 next unless (has_property($d, "public"));
3012 $count_public_structs += 1;
3013 }
3014 if ($#{$interface->{FUNCTIONS}}+1 > 0 or
3015 $count_public_structs > 0) {
3016 $self->pidl_hdr("extern const struct ndr_interface_table ndr_table_$interface->{NAME};");
3017 }
3018
3019 foreach (@{$interface->{FUNCTIONS}}) {
3020 next if has_property($_, "noopnum");
3021 next if grep(/^$_->{NAME}$/,@{$interface->{INHERITED_FUNCTIONS}});
3022 my $u_name = uc $_->{NAME};
3023
3024 my $val = sprintf("0x%02x", $count);
3025 if (defined($interface->{BASE})) {
3026 $val .= " + NDR_" . uc $interface->{BASE} . "_CALL_COUNT";
3027 }
3028
3029 $self->pidl_hdr("#define NDR_$u_name ($val)");
3030
3031 $self->pidl_hdr("");
3032 $count++;
3033 }
3034
3035 my $val = $count;
3036
3037 if (defined($interface->{BASE})) {
3038 $val .= " + NDR_" . uc $interface->{BASE} . "_CALL_COUNT";
3039 }
3040
3041 $self->pidl_hdr("#define NDR_" . uc $interface->{NAME} . "_CALL_COUNT ($val)");
3042
3043 }
3044
3045 sub ParseTypePush($$$$$$)
3046 {
3047 my ($self,$e, $ndr, $varname, $primitives, $deferred) = @_;
3048
3049 # save the old relative_base_offset
3050 $self->pidl("uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset($ndr);") if defined(has_property($e, "relative_base"));
3051 $typefamily{$e->{TYPE}}->{PUSH_FN_BODY}->($self, $e, $ndr, $varname);
3052 # restore the old relative_base_offset
3053 $self->pidl("ndr_push_restore_relative_base_offset($ndr, _save_relative_base_offset);") if defined(has_property($e, "relative_base"));
3054 }
3055
3056 sub ParseTypePushFunction($$$)
3057 {
3058 my ($self, $e, $varname) = @_;
3059 my $ndr = "ndr";
3060
3061 my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "push", $e->{NAME}, $varname);
3062
3063 $self->fn_declare("push", $e, "enum ndr_err_code ".TypeFunctionName("ndr_push", $e)."(struct ndr_push *$ndr, ndr_flags_type ndr_flags, $args)") or return;
3064
3065 $self->pidl("{");
3066 $self->indent;
3067 $self->ParseTypePush($e, $ndr, $varname, 1, 1);
3068 $self->pidl("return NDR_ERR_SUCCESS;");
3069 $self->deindent;
3070 $self->pidl("}");
3071 $self->pidl("");;
3072 }
3073
3074 sub ParseTypePull($$$$$$)
3075 {
3076 my ($self, $e, $ndr, $varname, $primitives, $deferred) = @_;
3077
3078 # save the old relative_base_offset
3079 $self->pidl("uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset($ndr);") if defined(has_property($e, "relative_base"));
3080 $typefamily{$e->{TYPE}}->{PULL_FN_BODY}->($self, $e, $ndr, $varname);
3081 # restore the old relative_base_offset
3082 $self->pidl("ndr_pull_restore_relative_base_offset($ndr, _save_relative_base_offset);") if defined(has_property($e, "relative_base"));
3083 }
3084
3085 sub ParseTypePullFunction($$)
3086 {
3087 my ($self, $e, $varname) = @_;
3088 my $ndr = "ndr";
3089
3090 my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "pull", $e->{NAME}, $varname);
3091
3092 $self->fn_declare("pull", $e, "enum ndr_err_code ".TypeFunctionName("ndr_pull", $e)."(struct ndr_pull *$ndr, ndr_flags_type ndr_flags, $args)") or return;
3093
3094 $self->pidl("{");
3095 $self->indent;
3096 $self->ParseTypePull($e, $ndr, $varname, 1, 1);
3097 $self->pidl("return NDR_ERR_SUCCESS;");
3098 $self->deindent;
3099 $self->pidl("}");
3100 $self->pidl("");
3101 }
3102
3103 sub ParseTypePrint($$$$)
3104 {
3105 my ($self, $e, $ndr, $varname) = @_;
3106
3107 $typefamily{$e->{TYPE}}->{PRINT_FN_BODY}->($self, $e, $ndr, $e->{NAME}, $varname);
3108 }
3109
3110 sub ParseTypePrintFunction($$$)
3111 {
3112 my ($self, $e, $varname) = @_;
3113 my $ndr = "ndr";
3114
3115 my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "print", $e->{NAME}, $varname);
3116
3117 $self->pidl_hdr("void ".TypeFunctionName("ndr_print", $e)."(struct ndr_print *ndr, const char *name, $args);");
3118
3119 if (is_public_struct($e)) {
3120 $self->pidl("static void ".TypeFunctionName("ndr_print_flags", $e).
3121 "(struct ndr_print *$ndr, const char *name, ndr_flags_type unused, $args)"
3122 );
3123 $self->pidl("{");
3124 $self->indent;
3125 $self->pidl(TypeFunctionName("ndr_print", $e)."($ndr, name, $varname);");
3126 $self->deindent;
3127 $self->pidl("}");
3128 $self->pidl("");
3129 }
3130
3131 return if (has_property($e, "noprint"));
3132
3133 $self->pidl("_PUBLIC_ void ".TypeFunctionName("ndr_print", $e)."(struct ndr_print *$ndr, const char *name, $args)");
3134 $self->pidl("{");
3135 $self->indent;
3136 $self->ParseTypePrint($e, $ndr, $varname);
3137 $self->deindent;
3138 $self->pidl("}");
3139 $self->pidl("");
3140 }
3141
3142 sub ParseTypeNdrSize($$)
3143 {
3144 my ($self,$t) = @_;
3145
3146 my $varname = "r";
3147 my $tf = $typefamily{$t->{TYPE}};
3148 my $args = $tf->{SIZE_FN_ARGS}->($t, $t->{NAME}, $varname);
3149
3150 $self->fn_declare("size", $t, "size_t ndr_size_$t->{NAME}($args)") or return;
3151
3152 $self->pidl("{");
3153 $self->indent;
3154 $typefamily{$t->{TYPE}}->{SIZE_FN_BODY}->($self,$t, $t->{NAME}, $varname);
3155 $self->deindent;
3156 $self->pidl("}");
3157 $self->pidl("");
3158 }
3159
3160 #####################################################################
3161 # parse the interface definitions
3162 sub ParseInterface($$$)
3163 {
3164 my($self,$interface,$needed) = @_;
3165
3166 $self->pidl_hdr("#ifndef _HEADER_NDR_$interface->{NAME}");
3167 $self->pidl_hdr("#define _HEADER_NDR_$interface->{NAME}");
3168
3169 $self->pidl_hdr("");
3170
3171 $self->HeaderInterface($interface, $needed);
3172
3173 # Typedefs
3174 foreach my $d (@{$interface->{TYPES}}) {
3175 if (Parse::Pidl::Typelist::typeIs($d, "PIPE")) {
3176 ($needed->{TypeFunctionName("ndr_push", $d)}) &&
3177 $self->ParsePipePushChunk($d);
3178 ($needed->{TypeFunctionName("ndr_pull", $d)}) &&
3179 $self->ParsePipePullChunk($d);
3180 ($needed->{TypeFunctionName("ndr_print", $d)}) &&
3181 $self->ParsePipePrintChunk($d);
3182
3183 $needed->{TypeFunctionName("ndr_pull", $d)} = 0;
3184 $needed->{TypeFunctionName("ndr_push", $d)} = 0;
3185 $needed->{TypeFunctionName("ndr_print", $d)} = 0;
3186 next;
3187 }
3188
3189 next unless(typeHasBody($d));
3190
3191 ($needed->{TypeFunctionName("ndr_push", $d)}) && $self->ParseTypePushFunction($d, "r");
3192 ($needed->{TypeFunctionName("ndr_pull", $d)}) && $self->ParseTypePullFunction($d, "r");
3193 ($needed->{TypeFunctionName("ndr_print", $d)}) && $self->ParseTypePrintFunction($d, "r");
3194
3195 # Make sure we don't generate a function twice...
3196 $needed->{TypeFunctionName("ndr_push", $d)} =
3197 $needed->{TypeFunctionName("ndr_pull", $d)} =
3198 $needed->{TypeFunctionName("ndr_print", $d)} = 0;
3199
3200 ($needed->{"ndr_size_$d->{NAME}"}) && $self->ParseTypeNdrSize($d);
3201 }
3202
3203 # Functions
3204 foreach my $d (@{$interface->{FUNCTIONS}}) {
3205 ($needed->{"ndr_push_$d->{NAME}"}) && $self->ParseFunctionPush($d);
3206 ($needed->{"ndr_pull_$d->{NAME}"}) && $self->ParseFunctionPull($d);
3207 ($needed->{"ndr_print_$d->{NAME}"}) && $self->ParseFunctionPrint($d);
3208 }
3209
3210 # Allow compilation of generated files where replacement functions
3211 # for structures declared nopull/nopush have not been provided.
3212 #
3213 # This makes sense when only the print functions are used
3214 #
3215 # Otherwise the ndr_table XXX will reference these
3216
3217 $self->pidl("#ifndef SKIP_NDR_TABLE_$interface->{NAME}");
3218 $self->FunctionTable($interface);
3219 $self->pidl("#endif /* SKIP_NDR_TABLE_$interface->{NAME} */");
3220
3221 $self->pidl_hdr("#endif /* _HEADER_NDR_$interface->{NAME} */");
3222 }
3223
3224 sub GenerateIncludes($)
3225 {
3226 my ($self) = @_;
3227 if (is_intree()) {
3228 $self->pidl("#include \"replace.h\"");
3229 } else {
3230 $self->pidl("#ifndef _GNU_SOURCE");
3231 $self->pidl("#define _GNU_SOURCE");
3232 $self->pidl("#endif");
3233 $self->pidl("#include <stdint.h>");
3234 $self->pidl("#include <stdlib.h>");
3235 $self->pidl("#include <stdio.h>");
3236 $self->pidl("#include <stdbool.h>");
3237 $self->pidl("#include <stdarg.h>");
3238 $self->pidl("#include <string.h>");
3239 }
3240 }
3241
3242 #####################################################################
3243 # parse a parsed IDL structure back into an IDL file
3244 sub Parse($$$$)
3245 {
3246 my($self, $ndr,$gen_header,$ndr_header) = @_;
3247
3248 $self->pidl_hdr("/* header auto-generated by pidl */");
3249 $self->pidl_hdr("");
3250 $self->pidl_hdr(choose_header("librpc/ndr/libndr.h", "ndr.h"));
3251 $self->pidl_hdr("#include \"$gen_header\"") if ($gen_header);
3252 $self->pidl_hdr("");
3253
3254 $self->pidl("/* parser auto-generated by pidl */");
3255 $self->pidl("");
3256 $self->GenerateIncludes();
3257 $self->pidl("#include \"$ndr_header\"") if ($ndr_header);
3258 $self->pidl("");
3259
3260 my %needed = ();
3261
3262 foreach (@{$ndr}) {
3263 ($_->{TYPE} eq "INTERFACE") && NeededInterface($_, \%needed);
3264 }
3265
3266 foreach (@{$ndr}) {
3267 ($_->{TYPE} eq "INTERFACE") && $self->ParseInterface($_, \%needed);
3268 ($_->{TYPE} eq "IMPORT") && $self->HeaderImport(@{$_->{PATHS}});
3269 ($_->{TYPE} eq "INCLUDE") && $self->HeaderInclude(@{$_->{PATHS}});
3270 }
3271
3272 return ($self->{res_hdr}, $self->{res});
3273 }
3274
3275 sub NeededElement($$$)
3276 {
3277 my ($e, $dir, $needed) = @_;
3278
3279 return if ($e->{TYPE} eq "EMPTY");
3280
3281 return if (ref($e->{TYPE}) eq "HASH" and
3282 not defined($e->{TYPE}->{NAME}));
3283
3284 my ($t, $rt);
3285 if (ref($e->{TYPE}) eq "HASH") {
3286 $t = $e->{TYPE}->{TYPE}."_".$e->{TYPE}->{NAME};
3287 } else {
3288 $t = $e->{TYPE};
3289 }
3290
3291 if (ref($e->{REPRESENTATION_TYPE}) eq "HASH") {
3292 $rt = $e->{REPRESENTATION_TYPE}->{TYPE}."_".$e->{REPRESENTATION_TYPE}->{NAME};
3293 } else {
3294 $rt = $e->{REPRESENTATION_TYPE};
3295 }
3296
3297 die ("$e->{NAME} $t, $rt FOO") unless ($rt ne "");
3298
3299 my @fn = ();
3300 if ($dir eq "print") {
3301 push(@fn, TypeFunctionName("ndr_print", $e->{REPRESENTATION_TYPE}));
3302 } elsif ($dir eq "pull") {
3303 push (@fn, TypeFunctionName("ndr_pull", $e->{TYPE}));
3304 push (@fn, "ndr_$t\_to_$rt")
3305 if ($rt ne $t);
3306 } elsif ($dir eq "push") {
3307 push (@fn, TypeFunctionName("ndr_push", $e->{TYPE}));
3308 push (@fn, "ndr_$rt\_to_$t")
3309 if ($rt ne $t);
3310 } else {
3311 die("invalid direction `$dir'");
3312 }
3313
3314 foreach (@fn) {
3315 unless (defined($needed->{$_})) {
3316 $needed->{$_} = 1;
3317 }
3318 }
3319 }
3320
3321 sub NeededFunction($$)
3322 {
3323 my ($fn,$needed) = @_;
3324 $needed->{"ndr_pull_$fn->{NAME}"} = 1;
3325 $needed->{"ndr_push_$fn->{NAME}"} = 1;
3326 $needed->{"ndr_print_$fn->{NAME}"} = 1;
3327 foreach my $e (@{$fn->{ELEMENTS}}) {
3328 $e->{PARENT} = $fn;
3329 NeededElement($e, $_, $needed) foreach ("pull", "push", "print");
3330 }
3331 }
3332
3333 sub NeededType($$$)
3334 {
3335 sub NeededType($$$);
3336 my ($t,$needed,$req) = @_;
3337
3338 NeededType($t->{DATA}, $needed, $req) if ($t->{TYPE} eq "TYPEDEF");
3339 NeededType($t->{DATA}, $needed, $req) if ($t->{TYPE} eq "PIPE");
3340
3341 if ($t->{TYPE} eq "STRUCT" or $t->{TYPE} eq "UNION") {
3342 return unless defined($t->{ELEMENTS});
3343 for my $e (@{$t->{ELEMENTS}}) {
3344 $e->{PARENT} = $t;
3345 if (has_property($e, "compression")) {
3346 $needed->{"compression"} = 1;
3347 }
3348 NeededElement($e, $req, $needed);
3349 NeededType($e->{TYPE}, $needed, $req) if (ref($e->{TYPE}) eq "HASH");
3350 }
3351 }
3352 }
3353
3354 #####################################################################
3355 # work out what parse functions are needed
3356 sub NeededInterface($$)
3357 {
3358 my ($interface,$needed) = @_;
3359 NeededFunction($_, $needed) foreach (@{$interface->{FUNCTIONS}});
3360 foreach (reverse @{$interface->{TYPES}}) {
3361
3362 if (has_property($_, "public")) {
3363 $needed->{TypeFunctionName("ndr_pull", $_)} = $needed->{TypeFunctionName("ndr_push", $_)} =
3364 $needed->{TypeFunctionName("ndr_print", $_)} = 1;
3365 }
3366
3367 NeededType($_, $needed, "pull") if ($needed->{TypeFunctionName("ndr_pull", $_)});
3368 NeededType($_, $needed, "push") if ($needed->{TypeFunctionName("ndr_push", $_)});
3369 NeededType($_, $needed, "print") if ($needed->{TypeFunctionName("ndr_print", $_)});
3370 if (has_property($_, "gensize")) {
3371 $needed->{"ndr_size_$_->{NAME}"} = 1;
3372 }
3373 }
3374 }
3375
3376 sub TypeFunctionName($$)
3377 {
3378 my ($prefix, $t) = @_;
3379
3380 return "$prefix\_$t->{NAME}" if (ref($t) eq "HASH" and
3381 $t->{TYPE} eq "TYPEDEF");
3382 return "$prefix\_$t->{TYPE}_$t->{NAME}" if (ref($t) eq "HASH");
3383 return "$prefix\_$t";
3384 }
3385
3386 1;