77482685b7d9f8d2c0badf96351748356753d811
[kai/samba.git] / source / pidl / lib / Parse / Pidl / Samba4 / NDR / Parser.pm
1 ###################################################
2 # Samba4 NDR parser generator for IDL structures
3 # Copyright tridge@samba.org 2000-2003
4 # Copyright tpot@samba.org 2001
5 # Copyright jelmer@samba.org 2004-2006
6 # released under the GNU GPL
7
8 package Parse::Pidl::Samba4::NDR::Parser;
9
10 use strict;
11 use Parse::Pidl::Typelist qw(hasType getType mapType);
12 use Parse::Pidl::Util qw(has_property ParseExpr print_uuid);
13 use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred);
14 use Parse::Pidl::Samba4 qw(is_intree choose_header);
15
16 use vars qw($VERSION);
17 $VERSION = '0.01';
18
19 # list of known types
20 my %typefamily;
21
22 sub get_typefamily($)
23 {
24         my $n = shift;
25         return $typefamily{$n};
26 }
27
28 sub append_prefix($$)
29 {
30         my ($e, $var_name) = @_;
31         my $pointers = 0;
32
33         foreach my $l (@{$e->{LEVELS}}) {
34                 if ($l->{TYPE} eq "POINTER") {
35                         $pointers++;
36                 } elsif ($l->{TYPE} eq "ARRAY") {
37                         if (($pointers == 0) and 
38                             (not $l->{IS_FIXED}) and
39                             (not $l->{IS_INLINE})) {
40                                 return get_value_of($var_name); 
41                         }
42                 } elsif ($l->{TYPE} eq "DATA") {
43                         if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
44                                 return get_value_of($var_name) unless ($pointers);
45                         }
46                 }
47         }
48         
49         return $var_name;
50 }
51
52 sub has_fast_array($$)
53 {
54         my ($e,$l) = @_;
55
56         return 0 if ($l->{TYPE} ne "ARRAY");
57
58         my $nl = GetNextLevel($e,$l);
59         return 0 unless ($nl->{TYPE} eq "DATA");
60         return 0 unless (hasType($nl->{DATA_TYPE}));
61
62         my $t = getType($nl->{DATA_TYPE});
63
64         # Only uint8 and string have fast array functions at the moment
65         return ($t->{NAME} eq "uint8") or ($t->{NAME} eq "string");
66 }
67
68 sub is_charset_array($$)
69 {
70         my ($e,$l) = @_;
71
72         return 0 if ($l->{TYPE} ne "ARRAY");
73
74         my $nl = GetNextLevel($e,$l);
75
76         return 0 unless ($nl->{TYPE} eq "DATA");
77
78         return has_property($e, "charset");
79 }
80
81 sub get_pointer_to($)
82 {
83         my $var_name = shift;
84         
85         if ($var_name =~ /^\*(.*)$/) {
86                 return $1;
87         } elsif ($var_name =~ /^\&(.*)$/) {
88                 return "&($var_name)";
89         } else {
90                 return "&$var_name";
91         }
92 }
93
94 sub get_value_of($)
95 {
96         my $var_name = shift;
97
98         if ($var_name =~ /^\&(.*)$/) {
99                 return $1;
100         } else {
101                 return "*$var_name";
102         }
103 }
104
105 my $res;
106 my $deferred = [];
107 my $tabs = "";
108
109 ####################################
110 # pidl() is our basic output routine
111 sub pidl($)
112 {
113         my $d = shift;
114         if ($d) {
115                 $res .= $tabs;
116                 $res .= $d;
117         }
118         $res .="\n";
119 }
120
121 my $res_hdr;
122
123 sub pidl_hdr ($) { my $d = shift; $res_hdr .= "$d\n"; }
124
125 ####################################
126 # defer() is like pidl(), but adds to 
127 # a deferred buffer which is then added to the 
128 # output buffer at the end of the structure/union/function
129 # This is needed to cope with code that must be pushed back
130 # to the end of a block of elements
131 my $defer_tabs = "";
132 sub defer_indent() { $defer_tabs.="\t"; }
133 sub defer_deindent() { $defer_tabs=substr($defer_tabs, 0, -1); }
134
135 sub defer($)
136 {
137         my $d = shift;
138         if ($d) {
139                 push(@$deferred, $defer_tabs.$d);
140         }
141 }
142
143 ########################################
144 # add the deferred content to the current
145 # output
146 sub add_deferred()
147 {
148         pidl $_ foreach (@$deferred);
149         $deferred = [];
150         $defer_tabs = "";
151 }
152
153 sub indent()
154 {
155         $tabs .= "\t";
156 }
157
158 sub deindent()
159 {
160         $tabs = substr($tabs, 0, -1);
161 }
162
163 #####################################################################
164 # check that a variable we get from ParseExpr isn't a null pointer
165 sub check_null_pointer($)
166 {
167         my $size = shift;
168         if ($size =~ /^\*/) {
169                 my $size2 = substr($size, 1);
170                 pidl "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;";
171         }
172 }
173
174 #####################################################################
175 # check that a variable we get from ParseExpr isn't a null pointer, 
176 # putting the check at the end of the structure/function
177 sub check_null_pointer_deferred($)
178 {
179         my $size = shift;
180         if ($size =~ /^\*/) {
181                 my $size2 = substr($size, 1);
182                 defer "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;";
183         }
184 }
185
186 #####################################################################
187 # check that a variable we get from ParseExpr isn't a null pointer
188 # void return varient
189 sub check_null_pointer_void($)
190 {
191         my $size = shift;
192         if ($size =~ /^\*/) {
193                 my $size2 = substr($size, 1);
194                 pidl "if ($size2 == NULL) return;";
195         }
196 }
197
198 #####################################################################
199 # declare a function public or static, depending on its attributes
200 sub fn_declare($$$)
201 {
202         my ($type,$fn,$decl) = @_;
203
204         if (has_property($fn, "no$type")) {
205                 pidl_hdr "$decl;";
206                 return 0;
207         }
208
209         if (has_property($fn, "public")) {
210                 pidl_hdr "$decl;";
211                 pidl "_PUBLIC_ $decl";
212         } else {
213                 pidl "static $decl";
214         }
215
216         return 1;
217 }
218
219 ###################################################################
220 # setup any special flags for an element or structure
221 sub start_flags($)
222 {
223         my $e = shift;
224         my $flags = has_property($e, "flag");
225         if (defined $flags) {
226                 pidl "{";
227                 indent;
228                 pidl "uint32_t _flags_save_$e->{TYPE} = ndr->flags;";
229                 pidl "ndr_set_flags(&ndr->flags, $flags);";
230         }
231 }
232
233 ###################################################################
234 # end any special flags for an element or structure
235 sub end_flags($)
236 {
237         my $e = shift;
238         my $flags = has_property($e, "flag");
239         if (defined $flags) {
240                 pidl "ndr->flags = _flags_save_$e->{TYPE};";
241                 deindent;
242                 pidl "}";
243         }
244 }
245
246 sub GenerateStructEnv($)
247 {
248         my $x = shift;
249         my %env;
250
251         foreach my $e (@{$x->{ELEMENTS}}) {
252                 $env{$e->{NAME}} = "r->$e->{NAME}";
253         }
254
255         $env{"this"} = "r";
256
257         return \%env;
258 }
259
260 sub EnvSubstituteValue($$)
261 {
262         my ($env,$s) = @_;
263
264         # Substitute the value() values in the env
265         foreach my $e (@{$s->{ELEMENTS}}) {
266                 next unless (my $v = has_property($e, "value"));
267                 
268                 $env->{$e->{NAME}} = ParseExpr($v, $env);
269         }
270
271         return $env;
272 }
273
274 sub GenerateFunctionInEnv($)
275 {
276         my $fn = shift;
277         my %env;
278
279         foreach my $e (@{$fn->{ELEMENTS}}) {
280                 if (grep (/in/, @{$e->{DIRECTION}})) {
281                         $env{$e->{NAME}} = "r->in.$e->{NAME}";
282                 }
283         }
284
285         return \%env;
286 }
287
288 sub GenerateFunctionOutEnv($)
289 {
290         my $fn = shift;
291         my %env;
292
293         foreach my $e (@{$fn->{ELEMENTS}}) {
294                 if (grep (/out/, @{$e->{DIRECTION}})) {
295                         $env{$e->{NAME}} = "r->out.$e->{NAME}";
296                 } elsif (grep (/in/, @{$e->{DIRECTION}})) {
297                         $env{$e->{NAME}} = "r->in.$e->{NAME}";
298                 }
299         }
300
301         return \%env;
302 }
303
304 #####################################################################
305 # parse the data of an array - push side
306 sub ParseArrayPushHeader($$$$$)
307 {
308         my ($e,$l,$ndr,$var_name,$env) = @_;
309
310         my $size;
311         my $length;
312
313         if ($l->{IS_ZERO_TERMINATED}) {
314                 if (has_property($e, "charset")) {
315                         $size = $length = "ndr_charset_length($var_name, CH_$e->{PROPERTIES}->{charset})";
316                 } else {
317                         $size = $length = "ndr_string_length($var_name, sizeof(*$var_name))";
318                 }
319         } else {
320                 $size = ParseExpr($l->{SIZE_IS}, $env);
321                 $length = ParseExpr($l->{LENGTH_IS}, $env);
322         }
323
324         if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) {
325                 pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $size));";
326         }
327         
328         if ($l->{IS_VARYING}) {
329                 pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, 0));";  # array offset
330                 pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $length));";
331         } 
332
333         return $length;
334 }
335
336 #####################################################################
337 # parse an array - pull side
338 sub ParseArrayPullHeader($$$$$)
339 {
340         my ($e,$l,$ndr,$var_name,$env) = @_;
341
342         my $length;
343         my $size;
344
345         if ($l->{IS_CONFORMANT}) {
346                 $length = $size = "ndr_get_array_size($ndr, " . get_pointer_to($var_name) . ")";
347         } elsif ($l->{IS_ZERO_TERMINATED}) { # Noheader arrays
348                 $length = $size = "ndr_get_string_size($ndr, sizeof(*$var_name))";
349         } else {
350                 $length = $size = ParseExpr($l->{SIZE_IS}, $env);
351         }
352
353         if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) {
354                 pidl "NDR_CHECK(ndr_pull_array_size(ndr, " . get_pointer_to($var_name) . "));";
355         }
356
357
358         if ($l->{IS_VARYING}) {
359                 pidl "NDR_CHECK(ndr_pull_array_length($ndr, " . get_pointer_to($var_name) . "));";
360                 $length = "ndr_get_array_length($ndr, " . get_pointer_to($var_name) .")";
361         }
362
363         check_null_pointer($length);
364
365         if ($length ne $size) {
366                 pidl "if ($length > $size) {";
367                 indent;
368                 pidl "return ndr_pull_error($ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %u should exceed array length %u\", $size, $length);";
369                 deindent;
370                 pidl "}";
371         }
372
373         if ($l->{IS_CONFORMANT} and not $l->{IS_ZERO_TERMINATED}) {
374                 my $size = ParseExpr($l->{SIZE_IS}, $env);
375                 defer "if ($var_name) {";
376                 defer_indent;
377                 check_null_pointer_deferred($size);
378                 defer "NDR_CHECK(ndr_check_array_size(ndr, (void*)" . get_pointer_to($var_name) . ", $size));";
379                 defer_deindent;
380                 defer "}";
381         }
382
383         if ($l->{IS_VARYING} and not $l->{IS_ZERO_TERMINATED}) {
384                 my $length = ParseExpr($l->{LENGTH_IS}, $env);
385                 defer "if ($var_name) {";
386                 defer_indent;
387                 check_null_pointer_deferred($length);
388                 defer "NDR_CHECK(ndr_check_array_length(ndr, (void*)" . get_pointer_to($var_name) . ", $length));";
389                 defer_deindent;
390                 defer "}"
391         }
392
393         if (not $l->{IS_FIXED} and not is_charset_array($e, $l)) {
394                 AllocateArrayLevel($e,$l,$ndr,$env,$size);
395         }
396
397         return $length;
398 }
399
400 sub compression_alg($$)
401 {
402         my ($e,$l) = @_;
403         my $compression = $l->{COMPRESSION};
404         my ($alg, $clen, $dlen) = split(/ /, $compression);
405
406         return $alg;
407 }
408
409 sub compression_clen($$$)
410 {
411         my ($e,$l,$env) = @_;
412         my $compression = $l->{COMPRESSION};
413         my ($alg, $clen, $dlen) = split(/ /, $compression);
414
415         return ParseExpr($clen, $env);
416 }
417
418 sub compression_dlen($$$)
419 {
420         my ($e,$l,$env) = @_;
421         my $compression = $l->{COMPRESSION};
422         my ($alg, $clen, $dlen) = split(/ /, $compression);
423
424         return ParseExpr($dlen, $env);
425 }
426
427 sub ParseCompressionPushStart($$$$)
428 {
429         my ($e,$l,$ndr,$env) = @_;
430         my $comndr = "$ndr\_compressed";
431         my $alg = compression_alg($e, $l);
432         my $dlen = compression_dlen($e, $l, $env);
433
434         pidl "{";
435         indent;
436         pidl "struct ndr_push *$comndr;";
437         pidl "NDR_CHECK(ndr_push_compression_start($ndr, &$comndr, $alg, $dlen));";
438
439         return $comndr;
440 }
441
442 sub ParseCompressionPushEnd($$$$)
443 {
444         my ($e,$l,$ndr,$env) = @_;
445         my $comndr = "$ndr\_compressed";
446         my $alg = compression_alg($e, $l);
447         my $dlen = compression_dlen($e, $l, $env);
448
449         pidl "NDR_CHECK(ndr_push_compression_end($ndr, $comndr, $alg, $dlen));";
450         deindent;
451         pidl "}";
452 }
453
454 sub ParseCompressionPullStart($$$$)
455 {
456         my ($e,$l,$ndr,$env) = @_;
457         my $comndr = "$ndr\_compressed";
458         my $alg = compression_alg($e, $l);
459         my $dlen = compression_dlen($e, $l, $env);
460
461         pidl "{";
462         indent;
463         pidl "struct ndr_pull *$comndr;";
464         pidl "NDR_CHECK(ndr_pull_compression_start($ndr, &$comndr, $alg, $dlen));";
465
466         return $comndr;
467 }
468
469 sub ParseCompressionPullEnd($$$$)
470 {
471         my ($e,$l,$ndr,$env) = @_;
472         my $comndr = "$ndr\_compressed";
473         my $alg = compression_alg($e, $l);
474         my $dlen = compression_dlen($e, $l, $env);
475
476         pidl "NDR_CHECK(ndr_pull_compression_end($ndr, $comndr, $alg, $dlen));";
477         deindent;
478         pidl "}";
479 }
480
481 sub ParseSubcontextPushStart($$$$)
482 {
483         my ($e,$l,$ndr,$env) = @_;
484         my $subndr = "_ndr_$e->{NAME}";
485         my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env);
486
487         pidl "{";
488         indent;
489         pidl "struct ndr_push *$subndr;";
490         pidl "NDR_CHECK(ndr_push_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, $subcontext_size));";
491
492         if (defined $l->{COMPRESSION}) {
493                 $subndr = ParseCompressionPushStart($e, $l, $subndr, $env);
494         }
495
496         return $subndr;
497 }
498
499 sub ParseSubcontextPushEnd($$$$)
500 {
501         my ($e,$l,$ndr,$env) = @_;
502         my $subndr = "_ndr_$e->{NAME}";
503         my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env);
504
505         if (defined $l->{COMPRESSION}) {
506                 ParseCompressionPushEnd($e, $l, $subndr, $env);
507         }
508
509         pidl "NDR_CHECK(ndr_push_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));";
510         deindent;
511         pidl "}";
512 }
513
514 sub ParseSubcontextPullStart($$$$)
515 {
516         my ($e,$l,$ndr,$env) = @_;
517         my $subndr = "_ndr_$e->{NAME}";
518         my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env);
519
520         pidl "{";
521         indent;
522         pidl "struct ndr_pull *$subndr;";
523         pidl "NDR_CHECK(ndr_pull_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, $subcontext_size));";
524
525         if (defined $l->{COMPRESSION}) {
526                 $subndr = ParseCompressionPullStart($e, $l, $subndr, $env);
527         }
528
529         return $subndr;
530 }
531
532 sub ParseSubcontextPullEnd($$$$)
533 {
534         my ($e,$l,$ndr,$env) = @_;
535         my $subndr = "_ndr_$e->{NAME}";
536         my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env);
537
538         if (defined $l->{COMPRESSION}) {
539                 ParseCompressionPullEnd($e, $l, $subndr, $env);
540         }
541
542         pidl "NDR_CHECK(ndr_pull_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));";
543         deindent;
544         pidl "}";
545 }
546
547 sub ParseElementPushLevel
548 {
549         my ($e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_;
550
551         my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred);
552
553         if ($l->{TYPE} eq "ARRAY" and ($l->{IS_CONFORMANT} or $l->{IS_VARYING})) {
554                 $var_name = get_pointer_to($var_name);
555         }
556
557         if (defined($ndr_flags)) {
558                 if ($l->{TYPE} eq "SUBCONTEXT") {
559                         my $subndr = ParseSubcontextPushStart($e, $l, $ndr, $env);
560                         ParseElementPushLevel($e, GetNextLevel($e, $l), $subndr, $var_name, $env, 1, 1);
561                         ParseSubcontextPushEnd($e, $l, $ndr, $env);
562                 } elsif ($l->{TYPE} eq "POINTER") {
563                         ParsePtrPush($e, $l, $var_name);
564                 } elsif ($l->{TYPE} eq "ARRAY") {
565                         my $length = ParseArrayPushHeader($e, $l, $ndr, $var_name, $env); 
566
567                         my $nl = GetNextLevel($e, $l);
568
569                         # Allow speedups for arrays of scalar types
570                         if (is_charset_array($e,$l)) {
571                                 pidl "NDR_CHECK(ndr_push_charset($ndr, $ndr_flags, $var_name, $length, sizeof(" . mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));";
572                                 return;
573                         } elsif (has_fast_array($e,$l)) {
574                                 pidl "NDR_CHECK(ndr_push_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));";
575                                 return;
576                         } 
577                 } elsif ($l->{TYPE} eq "SWITCH") {
578                         ParseSwitchPush($e, $l, $ndr, $var_name, $ndr_flags, $env);
579                 } elsif ($l->{TYPE} eq "DATA") {
580                         ParseDataPush($e, $l, $ndr, $var_name, $ndr_flags);
581                 }
582         }
583
584         if ($l->{TYPE} eq "POINTER" and $deferred) {
585                 if ($l->{POINTER_TYPE} ne "ref") {
586                         pidl "if ($var_name) {";
587                         indent;
588                         if ($l->{POINTER_TYPE} eq "relative") {
589                                 pidl "NDR_CHECK(ndr_push_relative_ptr2(ndr, $var_name));";
590                         }
591                 }
592                 if ($l->{POINTER_TYPE} ne "ref" or has_property($e, "keepref")) {
593                         $var_name = get_value_of($var_name);
594                 }
595                 ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 1);
596
597                 if ($l->{POINTER_TYPE} ne "ref") {
598                         deindent;
599                         pidl "}";
600                 }
601         } elsif ($l->{TYPE} eq "ARRAY" and not has_fast_array($e,$l) and
602                 not is_charset_array($e, $l)) {
603                 my $length = ParseExpr($l->{LENGTH_IS}, $env);
604                 my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
605
606                 $var_name = $var_name . "[$counter]";
607
608                 if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) {
609                         pidl "for ($counter = 0; $counter < $length; $counter++) {";
610                         indent;
611                         ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 0);
612                         deindent;
613                         pidl "}";
614                 }
615
616                 if ($deferred and ContainsDeferred($e, $l)) {
617                         pidl "for ($counter = 0; $counter < $length; $counter++) {";
618                         indent;
619                         ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 0, 1);
620                         deindent;
621                         pidl "}";
622                 }       
623         } elsif ($l->{TYPE} eq "SWITCH") {
624                 ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, $primitives, $deferred);
625         }
626 }
627
628 #####################################################################
629 # parse scalars in a structure element
630 sub ParseElementPush($$$$$$)
631 {
632         my ($e,$ndr,$var_prefix,$env,$primitives,$deferred) = @_;
633         my $subndr = undef;
634
635         my $var_name = $var_prefix.$e->{NAME};
636
637         return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0]));
638
639         # Representation type is different from transmit_as
640         if ($e->{REPRESENTATION_TYPE}) {
641                 pidl "{";
642                 indent;
643                 my $transmit_name = "_transmit_$e->{NAME}";
644                 pidl mapType($e->{TYPE}) ." $transmit_name;";
645                 pidl "NDR_CHECK(ndr_$e->{REPRESENTATION_TYPE}_to_$e->{TYPE}($var_name, " . get_pointer_to($transmit_name) . "));";
646                 $var_name = $transmit_name;
647         }
648
649         $var_name = append_prefix($e, $var_name);
650
651         start_flags($e);
652
653         if (my $value = has_property($e, "value")) {
654                 $var_name = ParseExpr($value, $env);
655         }
656
657         ParseElementPushLevel($e, $e->{LEVELS}[0], $ndr, $var_name, $env, $primitives, $deferred);
658
659         end_flags($e);
660
661         if ($e->{REPRESENTATION_TYPE}) {
662                 deindent;
663                 pidl "}";
664         }
665 }
666
667 #####################################################################
668 # parse a pointer in a struct element or function
669 sub ParsePtrPush($$$)
670 {
671         my ($e,$l,$var_name) = @_;
672
673         if ($l->{POINTER_TYPE} eq "ref") {
674                 if (has_property($e, "keepref")) {
675                         check_null_pointer(get_value_of($var_name));
676                 }
677                 if ($l->{LEVEL} eq "EMBEDDED") {
678                         pidl "NDR_CHECK(ndr_push_ref_ptr(ndr));";
679                 }
680         } elsif ($l->{POINTER_TYPE} eq "relative") {
681                 pidl "NDR_CHECK(ndr_push_relative_ptr1(ndr, $var_name));";
682         } elsif ($l->{POINTER_TYPE} eq "unique") {
683                 pidl "NDR_CHECK(ndr_push_unique_ptr(ndr, $var_name));";
684         } elsif ($l->{POINTER_TYPE} eq "sptr") {
685                 pidl "NDR_CHECK(ndr_push_sptr_ptr(ndr, $var_name));";
686         } else {
687                 die("Unhandled pointer type $l->{POINTER_TYPE}");
688         }
689 }
690
691 #####################################################################
692 # print scalars in a structure element
693 sub ParseElementPrint($$$)
694 {
695         my($e,$var_name,$env) = @_;
696
697         return if (has_property($e, "noprint"));
698
699         if ($e->{REPRESENTATION_TYPE}) {
700                 pidl "ndr_print_$e->{REPRESENTATION_TYPE}(ndr, \"$e->{NAME}\", $var_name);";
701                 return;
702         }
703
704         $var_name = append_prefix($e, $var_name);
705
706         if (my $value = has_property($e, "value")) {
707                 $var_name = "(ndr->flags & LIBNDR_PRINT_SET_VALUES)?" . ParseExpr($value,$env) . ":$var_name";
708         }
709
710         foreach my $l (@{$e->{LEVELS}}) {
711                 if ($l->{TYPE} eq "POINTER") {
712                         if ($l->{POINTER_TYPE} ne "ref" or has_property($e, "keepref")) {
713                         pidl "ndr_print_ptr(ndr, \"$e->{NAME}\", $var_name);";
714                         pidl "ndr->depth++;";
715                                 if ($l->{POINTER_TYPE} ne "ref") {
716                                         pidl "if ($var_name) {";
717                                         indent;
718                                 }
719                                 $var_name = get_value_of($var_name);
720                         }
721                 } elsif ($l->{TYPE} eq "ARRAY") {
722                         my $length;
723
724                         if ($l->{IS_CONFORMANT} or $l->{IS_VARYING}) {
725                                 $var_name = get_pointer_to($var_name); 
726                         }
727                         
728                         if ($l->{IS_ZERO_TERMINATED}) {
729                                 $length = "ndr_string_length($var_name, sizeof(*$var_name))";
730                         } else {
731                                 $length = ParseExpr($l->{LENGTH_IS}, $env);
732                         }
733
734                         if (is_charset_array($e,$l)) {
735                                 pidl "ndr_print_string(ndr, \"$e->{NAME}\", $var_name);";
736                                 last;
737                         } elsif (has_fast_array($e, $l)) {
738                                 my $nl = GetNextLevel($e, $l);
739                                 pidl "ndr_print_array_$nl->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name, $length);";
740                                 last;
741                         } else {
742                                 my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
743
744                                 pidl "ndr->print(ndr, \"\%s: ARRAY(\%d)\", \"$e->{NAME}\", $length);";
745                                 pidl 'ndr->depth++;';
746                                 pidl "for ($counter=0;$counter<$length;$counter++) {";
747                                 indent;
748                                 pidl "char *idx_$l->{LEVEL_INDEX}=NULL;";
749                                 pidl "asprintf(&idx_$l->{LEVEL_INDEX}, \"[\%d]\", $counter);";
750                                 pidl "if (idx_$l->{LEVEL_INDEX}) {";
751                                 indent;
752
753                                 $var_name = $var_name . "[$counter]";
754                         }
755                 } elsif ($l->{TYPE} eq "DATA") {
756                         if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
757                                 $var_name = get_pointer_to($var_name);
758                         }
759                         pidl "ndr_print_$l->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name);";
760                 } elsif ($l->{TYPE} eq "SWITCH") {
761                         my $switch_var = ParseExpr($l->{SWITCH_IS}, $env);
762                         check_null_pointer_void($switch_var);
763                         pidl "ndr_print_set_switch_value(ndr, " . get_pointer_to($var_name) . ", $switch_var);";
764                 } 
765         }
766
767         foreach my $l (reverse @{$e->{LEVELS}}) {
768                 if ($l->{TYPE} eq "POINTER") {
769                         if ($l->{POINTER_TYPE} ne "ref" or has_property($e, "keepref")) {
770                                 if ($l->{POINTER_TYPE} ne "ref") {
771                                         deindent;
772                                         pidl "}";
773                                 }
774                                 pidl "ndr->depth--;";
775                         }
776                 } elsif (($l->{TYPE} eq "ARRAY")
777                         and not is_charset_array($e,$l)
778                         and not has_fast_array($e,$l)) {
779                         pidl "free(idx_$l->{LEVEL_INDEX});";
780                         deindent;
781                         pidl "}";
782                         deindent;
783                         pidl "}";
784                         pidl "ndr->depth--;";
785                 }
786         }
787 }
788
789 #####################################################################
790 # parse scalars in a structure element - pull size
791 sub ParseSwitchPull($$$$$$)
792 {
793         my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_;
794         my $switch_var = ParseExpr($l->{SWITCH_IS}, $env);
795
796         check_null_pointer($switch_var);
797
798         $var_name = get_pointer_to($var_name);
799         pidl "NDR_CHECK(ndr_pull_set_switch_value($ndr, $var_name, $switch_var));";
800 }
801
802 #####################################################################
803 # push switch element
804 sub ParseSwitchPush($$$$$$)
805 {
806         my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_;
807         my $switch_var = ParseExpr($l->{SWITCH_IS}, $env);
808
809         check_null_pointer($switch_var);
810         $var_name = get_pointer_to($var_name);
811         pidl "NDR_CHECK(ndr_push_set_switch_value($ndr, $var_name, $switch_var));";
812 }
813
814 sub ParseDataPull($$$$$)
815 {
816         my ($e,$l,$ndr,$var_name,$ndr_flags) = @_;
817
818         if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
819                 $var_name = get_pointer_to($var_name);
820         }
821
822         $var_name = get_pointer_to($var_name);
823
824         pidl "NDR_CHECK(ndr_pull_$l->{DATA_TYPE}($ndr, $ndr_flags, $var_name));";
825
826         if (my $range = has_property($e, "range")) {
827                 $var_name = get_value_of($var_name);
828                 my ($low, $high) = split(/ /, $range, 2);
829                 pidl "if ($var_name < $low || $var_name > $high) {";
830                 pidl "\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value out of range\");";
831                 pidl "}";
832         }
833 }
834
835 sub ParseDataPush($$$$$)
836 {
837         my ($e,$l,$ndr,$var_name,$ndr_flags) = @_;
838
839         # strings are passed by value rather then reference
840         if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
841                 $var_name = get_pointer_to($var_name);
842         }
843
844         pidl "NDR_CHECK(ndr_push_$l->{DATA_TYPE}($ndr, $ndr_flags, $var_name));";
845 }
846
847 sub CalcNdrFlags($$$)
848 {
849         my ($l,$primitives,$deferred) = @_;
850
851         my $scalars = 0;
852         my $buffers = 0;
853
854         # Add NDR_SCALARS if this one is deferred 
855         # and deferreds may be pushed
856         $scalars = 1 if ($l->{IS_DEFERRED} and $deferred);
857
858         # Add NDR_SCALARS if this one is not deferred and 
859         # primitives may be pushed
860         $scalars = 1 if (!$l->{IS_DEFERRED} and $primitives);
861         
862         # Add NDR_BUFFERS if this one contains deferred stuff
863         # and deferreds may be pushed
864         $buffers = 1 if ($l->{CONTAINS_DEFERRED} and $deferred);
865
866         return "NDR_SCALARS|NDR_BUFFERS" if ($scalars and $buffers);
867         return "NDR_SCALARS" if ($scalars);
868         return "NDR_BUFFERS" if ($buffers);
869         return undef;
870 }
871
872 sub ParseMemCtxPullStart($$$)
873 {
874         my $e = shift;
875         my $l = shift;
876         my $ptr_name = shift;
877
878         my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}";
879         my $mem_c_ctx = $ptr_name;
880         my $mem_c_flags = "0";
881
882         return if ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED});
883
884         if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) {
885                 my $nl = GetNextLevel($e, $l);
886                 my $next_is_array = ($nl->{TYPE} eq "ARRAY");
887                 my $next_is_string = (($nl->{TYPE} eq "DATA") and 
888                                         ($nl->{DATA_TYPE} eq "string"));
889                 if ($next_is_array or $next_is_string or not has_property($e, "keepref")) {
890                         return;
891                 } else {
892                         $mem_c_flags = "LIBNDR_FLAG_REF_ALLOC";
893                 }
894         }
895
896         pidl "$mem_r_ctx = NDR_PULL_GET_MEM_CTX(ndr);";
897         pidl "NDR_PULL_SET_MEM_CTX(ndr, $mem_c_ctx, $mem_c_flags);";
898 }
899
900 sub ParseMemCtxPullEnd($$)
901 {
902         my $e = shift;
903         my $l = shift;
904
905         my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}";
906         my $mem_r_flags = "0";
907
908         return if ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED});
909
910         if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) {
911                 my $nl = GetNextLevel($e, $l);
912                 my $next_is_array = ($nl->{TYPE} eq "ARRAY");
913                 my $next_is_string = (($nl->{TYPE} eq "DATA") and 
914                                         ($nl->{DATA_TYPE} eq "string"));
915                 if ($next_is_array or $next_is_string or not has_property($e, "keepref")) {
916                         return;
917                 } else {
918                         $mem_r_flags = "LIBNDR_FLAG_REF_ALLOC";
919                 }
920         }
921
922         pidl "NDR_PULL_SET_MEM_CTX(ndr, $mem_r_ctx, $mem_r_flags);";
923 }
924
925 sub CheckStringTerminator($$$$)
926 {
927         my ($ndr,$e,$l,$length) = @_;
928         my $nl = GetNextLevel($e, $l);
929
930         # Make sure last element is zero!
931         pidl "NDR_CHECK(ndr_check_string_terminator($ndr, $length, sizeof($nl->{DATA_TYPE}_t)));";
932 }
933
934 sub ParseElementPullLevel
935 {
936         my($e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_;
937
938         my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred);
939
940         if ($l->{TYPE} eq "ARRAY" and ($l->{IS_VARYING} or $l->{IS_CONFORMANT})) {
941                 $var_name = get_pointer_to($var_name);
942         }
943
944         # Only pull something if there's actually something to be pulled
945         if (defined($ndr_flags)) {
946                 if ($l->{TYPE} eq "SUBCONTEXT") {
947                         my $subndr = ParseSubcontextPullStart($e, $l, $ndr, $env);
948                         ParseElementPullLevel($e, GetNextLevel($e,$l), $subndr, $var_name, $env, 1, 1);
949                         ParseSubcontextPullEnd($e, $l, $ndr, $env);
950                 } elsif ($l->{TYPE} eq "ARRAY") {
951                         my $length = ParseArrayPullHeader($e, $l, $ndr, $var_name, $env);
952
953                         my $nl = GetNextLevel($e, $l);
954
955                         if (is_charset_array($e,$l)) {
956                                 if ($l->{IS_ZERO_TERMINATED}) {
957                                         CheckStringTerminator($ndr, $e, $l, $length);
958                                 }
959                                 pidl "NDR_CHECK(ndr_pull_charset($ndr, $ndr_flags, ".get_pointer_to($var_name).", $length, sizeof(" . mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));";
960                                 return;
961                         } elsif (has_fast_array($e, $l)) {
962                                 if ($l->{IS_ZERO_TERMINATED}) {
963                                         CheckStringTerminator($ndr,$e,$l,$length);
964                                 }
965                                 pidl "NDR_CHECK(ndr_pull_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));";
966                                 return;
967                         }
968                 } elsif ($l->{TYPE} eq "POINTER") {
969                         ParsePtrPull($e, $l, $ndr, $var_name);
970                 } elsif ($l->{TYPE} eq "SWITCH") {
971                         ParseSwitchPull($e, $l, $ndr, $var_name, $ndr_flags, $env);
972                 } elsif ($l->{TYPE} eq "DATA") {
973                         ParseDataPull($e, $l, $ndr, $var_name, $ndr_flags);
974                 }
975         }
976
977         # add additional constructions
978         if ($l->{TYPE} eq "POINTER" and $deferred) {
979                 if ($l->{POINTER_TYPE} ne "ref") {
980                         pidl "if ($var_name) {";
981                         indent;
982
983                         if ($l->{POINTER_TYPE} eq "relative") {
984                                 pidl "struct ndr_pull_save _relative_save;";
985                                 pidl "ndr_pull_save(ndr, &_relative_save);";
986                                 pidl "NDR_CHECK(ndr_pull_relative_ptr2(ndr, $var_name));";
987                         }
988                 }
989
990                 ParseMemCtxPullStart($e,$l, $var_name);
991
992                 if ($l->{POINTER_TYPE} ne "ref" or has_property($e, "keepref")) {
993                         $var_name = get_value_of($var_name);
994                 }
995                 ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 1);
996
997                 ParseMemCtxPullEnd($e,$l);
998
999                 if ($l->{POINTER_TYPE} ne "ref") {
1000                         if ($l->{POINTER_TYPE} eq "relative") {
1001                                 pidl "ndr_pull_restore(ndr, &_relative_save);";
1002                         }
1003                         deindent;
1004                         pidl "}";
1005                 }
1006         } elsif ($l->{TYPE} eq "ARRAY" and 
1007                         not has_fast_array($e,$l) and not is_charset_array($e, $l)) {
1008                 my $length = ParseExpr($l->{LENGTH_IS}, $env);
1009                 my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
1010                 my $array_name = $var_name;
1011
1012                 $var_name = $var_name . "[$counter]";
1013
1014                 ParseMemCtxPullStart($e,$l, $array_name);
1015
1016                 if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) {
1017                         my $nl = GetNextLevel($e,$l);
1018
1019                         if ($l->{IS_ZERO_TERMINATED}) {
1020                                 CheckStringTerminator($ndr,$e,$l,$length);
1021                         }
1022
1023                         pidl "for ($counter = 0; $counter < $length; $counter++) {";
1024                         indent;
1025                         ParseElementPullLevel($e, $nl, $ndr, $var_name, $env, 1, 0);
1026                         deindent;
1027                         pidl "}";
1028                 }
1029
1030                 if ($deferred and ContainsDeferred($e, $l)) {
1031                         pidl "for ($counter = 0; $counter < $length; $counter++) {";
1032                         indent;
1033                         ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 0, 1);
1034                         deindent;
1035                         pidl "}";
1036                 }
1037
1038                 ParseMemCtxPullEnd($e,$l);
1039
1040         } elsif ($l->{TYPE} eq "SWITCH") {
1041                 ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, $primitives, $deferred);
1042         }
1043 }
1044
1045 #####################################################################
1046 # parse scalars in a structure element - pull size
1047 sub ParseElementPull($$$$$$)
1048 {
1049         my($e,$ndr,$var_prefix,$env,$primitives,$deferred) = @_;
1050
1051         my $var_name = $var_prefix.$e->{NAME};
1052         my $represent_name;
1053         my $transmit_name;
1054
1055         return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0]));
1056
1057         if ($e->{REPRESENTATION_TYPE}) {
1058                 pidl "{";
1059                 indent;
1060                 $represent_name = $var_name;
1061                 $transmit_name = "_transmit_$e->{NAME}";
1062                 $var_name = $transmit_name;
1063                 pidl mapType($e->{TYPE})." $var_name;";
1064         }
1065
1066         $var_name = append_prefix($e, $var_name);
1067
1068         start_flags($e);
1069
1070         ParseElementPullLevel($e,$e->{LEVELS}[0],$ndr,$var_name,$env,$primitives,$deferred);
1071
1072         end_flags($e);
1073
1074         # Representation type is different from transmit_as
1075         if ($e->{REPRESENTATION_TYPE}) {
1076                 pidl "NDR_CHECK(ndr_$e->{TYPE}_to_$e->{REPRESENTATION_TYPE}($transmit_name, ".get_pointer_to($represent_name)."));";
1077                 deindent;
1078                 pidl "}";
1079         }
1080 }
1081
1082 #####################################################################
1083 # parse a pointer in a struct element or function
1084 sub ParsePtrPull($$$$)
1085 {
1086         my($e,$l,$ndr,$var_name) = @_;
1087
1088         my $nl = GetNextLevel($e, $l);
1089         my $next_is_array = ($nl->{TYPE} eq "ARRAY");
1090         my $next_is_string = (($nl->{TYPE} eq "DATA") and 
1091                                                  ($nl->{DATA_TYPE} eq "string"));
1092
1093         if ($l->{POINTER_TYPE} eq "ref") {
1094                 if ($l->{LEVEL} eq "EMBEDDED") {
1095                         pidl "NDR_CHECK(ndr_pull_ref_ptr($ndr, &_ptr_$e->{NAME}));";
1096                 }
1097
1098                 if (!$next_is_array and !$next_is_string and 
1099                         has_property($e, "keepref")) {
1100                         pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
1101                         pidl "\tNDR_PULL_ALLOC($ndr, $var_name);"; 
1102                         pidl "}";
1103                 }
1104                 
1105                 return;
1106         } elsif (($l->{POINTER_TYPE} eq "unique") or 
1107                  ($l->{POINTER_TYPE} eq "relative") or
1108                  ($l->{POINTER_TYPE} eq "sptr")) {
1109                 pidl "NDR_CHECK(ndr_pull_generic_ptr($ndr, &_ptr_$e->{NAME}));";
1110                 pidl "if (_ptr_$e->{NAME}) {";
1111                 indent;
1112         } else {
1113                 die("Unhandled pointer type $l->{POINTER_TYPE}");
1114         }
1115
1116         # Don't do this for arrays, they're allocated at the actual level 
1117         # of the array
1118         unless ($next_is_array or $next_is_string) { 
1119                 pidl "NDR_PULL_ALLOC($ndr, $var_name);"; 
1120         } else {
1121                 # FIXME: Yes, this is nasty.
1122                 # We allocate an array twice
1123                 # - once just to indicate that it's there,
1124                 # - then the real allocation...
1125                 pidl "NDR_PULL_ALLOC_SIZE($ndr, $var_name, 1);";
1126         }
1127
1128         #pidl "memset($var_name, 0, sizeof($var_name));";
1129         if ($l->{POINTER_TYPE} eq "relative") {
1130                 pidl "NDR_CHECK(ndr_pull_relative_ptr1($ndr, $var_name, _ptr_$e->{NAME}));";
1131         }
1132         deindent;
1133         pidl "} else {";
1134         pidl "\t$var_name = NULL;";
1135         pidl "}";
1136 }
1137
1138 #####################################################################
1139 # parse a struct
1140 sub ParseStructPush($$)
1141 {
1142         my($struct,$name) = @_;
1143         
1144         return unless defined($struct->{ELEMENTS});
1145
1146         my $env = GenerateStructEnv($struct);
1147
1148         EnvSubstituteValue($env, $struct);
1149
1150         # save the old relative_base_offset
1151         pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined($struct->{PROPERTIES}{relative_base});
1152
1153         foreach my $e (@{$struct->{ELEMENTS}}) { 
1154                 DeclareArrayVariables($e);
1155         }
1156
1157         start_flags($struct);
1158
1159         # see if the structure contains a conformant array. If it
1160         # does, then it must be the last element of the structure, and
1161         # we need to push the conformant length early, as it fits on
1162         # the wire before the structure (and even before the structure
1163         # alignment)
1164         if (defined($struct->{SURROUNDING_ELEMENT})) {
1165                 my $e = $struct->{SURROUNDING_ELEMENT};
1166
1167                 if (defined($e->{LEVELS}[0]) and 
1168                         $e->{LEVELS}[0]->{TYPE} eq "ARRAY") {
1169                         my $size;
1170                         
1171                         if ($e->{LEVELS}[0]->{IS_ZERO_TERMINATED}) {
1172                                 if (has_property($e, "charset")) {
1173                                         $size = "ndr_charset_length(r->$e->{NAME}, CH_$e->{PROPERTIES}->{charset})";
1174                                 } else {
1175                                         $size = "ndr_string_length(r->$e->{NAME}, sizeof(*r->$e->{NAME}))";
1176                                 }
1177                         } else {
1178                                 $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env);
1179                         }
1180
1181                         pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));";
1182                 } else {
1183                         pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, r->$e->{NAME})));";
1184                 }
1185         }
1186
1187         pidl "if (ndr_flags & NDR_SCALARS) {";
1188         indent;
1189
1190         pidl "NDR_CHECK(ndr_push_align(ndr, $struct->{ALIGN}));";
1191
1192         if (defined($struct->{PROPERTIES}{relative_base})) {
1193                 # set the current offset as base for relative pointers
1194                 # and store it based on the toplevel struct/union
1195                 pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));";
1196         }
1197
1198         foreach my $e (@{$struct->{ELEMENTS}}) {
1199                 ParseElementPush($e, "ndr", "r->", $env, 1, 0);
1200         }       
1201
1202         deindent;
1203         pidl "}";
1204
1205         pidl "if (ndr_flags & NDR_BUFFERS) {";
1206         indent;
1207         if (defined($struct->{PROPERTIES}{relative_base})) {
1208                 # retrieve the current offset as base for relative pointers
1209                 # based on the toplevel struct/union
1210                 pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));";
1211         }
1212         foreach my $e (@{$struct->{ELEMENTS}}) {
1213                 ParseElementPush($e, "ndr", "r->", $env, 0, 1);
1214         }
1215
1216         deindent;
1217         pidl "}";
1218
1219         end_flags($struct);
1220         # restore the old relative_base_offset
1221         pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($struct->{PROPERTIES}{relative_base});
1222 }
1223
1224 #####################################################################
1225 # generate a push function for an enum
1226 sub ParseEnumPush($$)
1227 {
1228         my($enum,$name) = @_;
1229         my($type_fn) = $enum->{BASE_TYPE};
1230
1231         start_flags($enum);
1232         pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));";
1233         end_flags($enum);
1234 }
1235
1236 #####################################################################
1237 # generate a pull function for an enum
1238 sub ParseEnumPull($$)
1239 {
1240         my($enum,$name) = @_;
1241         my($type_fn) = $enum->{BASE_TYPE};
1242         my($type_v_decl) = mapType($type_fn);
1243
1244         pidl "$type_v_decl v;";
1245         start_flags($enum);
1246         pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));";
1247         pidl "*r = v;";
1248
1249         end_flags($enum);
1250 }
1251
1252 #####################################################################
1253 # generate a print function for an enum
1254 sub ParseEnumPrint($$)
1255 {
1256         my($enum,$name) = @_;
1257
1258         pidl "const char *val = NULL;";
1259         pidl "";
1260
1261         start_flags($enum);
1262
1263         pidl "switch (r) {";
1264         indent;
1265         my $els = \@{$enum->{ELEMENTS}};
1266         foreach my $i (0 .. $#{$els}) {
1267                 my $e = ${$els}[$i];
1268                 chomp $e;
1269                 if ($e =~ /^(.*)=/) {
1270                         $e = $1;
1271                 }
1272                 pidl "case $e: val = \"$e\"; break;";
1273         }
1274
1275         deindent;
1276         pidl "}";
1277         
1278         pidl "ndr_print_enum(ndr, name, \"$enum->{TYPE}\", val, r);";
1279
1280         end_flags($enum);
1281 }
1282
1283 sub DeclEnum($)
1284 {
1285         my ($e,$t) = @_;
1286         return "enum $e->{NAME} " . 
1287                 ($t eq "pull"?"*":"") . "r";
1288 }
1289
1290 $typefamily{ENUM} = {
1291         DECL => \&DeclEnum,
1292         PUSH_FN_BODY => \&ParseEnumPush,
1293         PULL_FN_BODY => \&ParseEnumPull,
1294         PRINT_FN_BODY => \&ParseEnumPrint,
1295 };
1296
1297 #####################################################################
1298 # generate a push function for a bitmap
1299 sub ParseBitmapPush($$)
1300 {
1301         my($bitmap,$name) = @_;
1302         my($type_fn) = $bitmap->{BASE_TYPE};
1303
1304         start_flags($bitmap);
1305
1306         pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));";
1307
1308         end_flags($bitmap);
1309 }
1310
1311 #####################################################################
1312 # generate a pull function for an bitmap
1313 sub ParseBitmapPull($$)
1314 {
1315         my($bitmap,$name) = @_;
1316         my $type_fn = $bitmap->{BASE_TYPE};
1317         my($type_decl) = mapType($bitmap->{BASE_TYPE});
1318
1319         pidl "$type_decl v;";
1320         start_flags($bitmap);
1321         pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));";
1322         pidl "*r = v;";
1323
1324         end_flags($bitmap);
1325 }
1326
1327 #####################################################################
1328 # generate a print function for an bitmap
1329 sub ParseBitmapPrintElement($$$)
1330 {
1331         my($e,$bitmap,$name) = @_;
1332         my($type_decl) = mapType($bitmap->{BASE_TYPE});
1333         my($type_fn) = $bitmap->{BASE_TYPE};
1334         my($flag);
1335
1336         if ($e =~ /^(\w+) .*$/) {
1337                 $flag = "$1";
1338         } else {
1339                 die "Bitmap: \"$name\" invalid Flag: \"$e\"";
1340         }
1341
1342         pidl "ndr_print_bitmap_flag(ndr, sizeof($type_decl), \"$flag\", $flag, r);";
1343 }
1344
1345 #####################################################################
1346 # generate a print function for an bitmap
1347 sub ParseBitmapPrint($$)
1348 {
1349         my($bitmap,$name) = @_;
1350         my($type_decl) = mapType($bitmap->{TYPE});
1351         my($type_fn) = $bitmap->{BASE_TYPE};
1352
1353         start_flags($bitmap);
1354
1355         pidl "ndr_print_$type_fn(ndr, name, r);";
1356
1357         pidl "ndr->depth++;";
1358         foreach my $e (@{$bitmap->{ELEMENTS}}) {
1359                 ParseBitmapPrintElement($e, $bitmap, $name);
1360         }
1361         pidl "ndr->depth--;";
1362
1363         end_flags($bitmap);
1364 }
1365
1366 sub DeclBitmap($$)
1367 {
1368         my ($e,$t) = @_;
1369         return mapType(Parse::Pidl::Typelist::bitmap_type_fn($e->{DATA})) . 
1370                 ($t eq "pull"?" *":" ") . "r";
1371 }
1372
1373 $typefamily{BITMAP} = {
1374         DECL => \&DeclBitmap,
1375         PUSH_FN_BODY => \&ParseBitmapPush,
1376         PULL_FN_BODY => \&ParseBitmapPull,
1377         PRINT_FN_BODY => \&ParseBitmapPrint,
1378 };
1379
1380 #####################################################################
1381 # generate a struct print function
1382 sub ParseStructPrint($$)
1383 {
1384         my($struct,$name) = @_;
1385
1386         return unless defined $struct->{ELEMENTS};
1387
1388         my $env = GenerateStructEnv($struct);
1389
1390         EnvSubstituteValue($env, $struct);
1391
1392         DeclareArrayVariables($_) foreach (@{$struct->{ELEMENTS}});
1393
1394         pidl "ndr_print_struct(ndr, name, \"$name\");";
1395
1396         start_flags($struct);
1397
1398         pidl "ndr->depth++;";
1399         
1400         ParseElementPrint($_, "r->$_->{NAME}", $env) foreach (@{$struct->{ELEMENTS}});
1401         pidl "ndr->depth--;";
1402
1403         end_flags($struct);
1404 }
1405
1406 sub DeclarePtrVariables($)
1407 {
1408         my $e = shift;
1409         foreach my $l (@{$e->{LEVELS}}) {
1410                 if ($l->{TYPE} eq "POINTER" and 
1411                         not ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP")) {
1412                         pidl "uint32_t _ptr_$e->{NAME};";
1413                         last;
1414                 }
1415         }
1416 }
1417
1418 sub DeclareArrayVariables($)
1419 {
1420         my $e = shift;
1421
1422         foreach my $l (@{$e->{LEVELS}}) {
1423                 next if has_fast_array($e,$l);
1424                 next if is_charset_array($e,$l);
1425                 if ($l->{TYPE} eq "ARRAY") {
1426                         pidl "uint32_t cntr_$e->{NAME}_$l->{LEVEL_INDEX};";
1427                 }
1428         }
1429 }
1430
1431 sub need_decl_mem_ctx($$)
1432 {
1433         my ($e,$l) = @_;
1434
1435         return 0 if has_fast_array($e,$l);
1436         return 0 if is_charset_array($e,$l);
1437         return 1 if (($l->{TYPE} eq "ARRAY") and not $l->{IS_FIXED});
1438
1439         if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) {
1440                 my $nl = GetNextLevel($e, $l);
1441                 my $next_is_array = ($nl->{TYPE} eq "ARRAY");
1442                 my $next_is_string = (($nl->{TYPE} eq "DATA") and 
1443                                         ($nl->{DATA_TYPE} eq "string"));
1444                 return 0 if ($next_is_array or $next_is_string or not has_property($e, "keepref"));
1445         }
1446         return 1 if ($l->{TYPE} eq "POINTER");
1447
1448         return 0;
1449 }
1450
1451 sub DeclareMemCtxVariables($)
1452 {
1453         my $e = shift;
1454         foreach my $l (@{$e->{LEVELS}}) {
1455                 if (need_decl_mem_ctx($e, $l)) {
1456                         pidl "TALLOC_CTX *_mem_save_$e->{NAME}_$l->{LEVEL_INDEX};";
1457                 }
1458         }
1459 }
1460
1461 #####################################################################
1462 # parse a struct - pull side
1463 sub ParseStructPull($$)
1464 {
1465         my($struct,$name) = @_;
1466
1467         return unless defined $struct->{ELEMENTS};
1468
1469         my $env = GenerateStructEnv($struct);
1470
1471         # declare any internal pointers we need
1472         foreach my $e (@{$struct->{ELEMENTS}}) {
1473                 DeclarePtrVariables($e);
1474                 DeclareArrayVariables($e);
1475                 DeclareMemCtxVariables($e);
1476         }
1477
1478         # save the old relative_base_offset
1479         pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined($struct->{PROPERTIES}{relative_base});
1480
1481         start_flags($struct);
1482
1483         pidl "if (ndr_flags & NDR_SCALARS) {";
1484         indent;
1485
1486         if (defined $struct->{SURROUNDING_ELEMENT}) {
1487                 pidl "NDR_CHECK(ndr_pull_array_size(ndr, &r->$struct->{SURROUNDING_ELEMENT}->{NAME}));";
1488         }
1489
1490         pidl "NDR_CHECK(ndr_pull_align(ndr, $struct->{ALIGN}));";
1491
1492         if (defined($struct->{PROPERTIES}{relative_base})) {
1493                 # set the current offset as base for relative pointers
1494                 # and store it based on the toplevel struct/union
1495                 pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));";
1496         }
1497
1498         foreach my $e (@{$struct->{ELEMENTS}}) {
1499                 ParseElementPull($e, "ndr", "r->", $env, 1, 0);
1500         }       
1501
1502         add_deferred();
1503
1504         deindent;
1505         pidl "}";
1506         pidl "if (ndr_flags & NDR_BUFFERS) {";
1507         indent;
1508         if (defined($struct->{PROPERTIES}{relative_base})) {
1509                 # retrieve the current offset as base for relative pointers
1510                 # based on the toplevel struct/union
1511                 pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));";
1512         }
1513         foreach my $e (@{$struct->{ELEMENTS}}) {
1514                 ParseElementPull($e, "ndr", "r->", $env, 0, 1);
1515         }
1516
1517         add_deferred();
1518
1519         deindent;
1520         pidl "}";
1521
1522         end_flags($struct);
1523         # restore the old relative_base_offset
1524         pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($struct->{PROPERTIES}{relative_base});
1525 }
1526
1527 #####################################################################
1528 # calculate size of ndr struct
1529 sub ParseStructNdrSize($)
1530 {
1531         my $t = shift;
1532         my $sizevar;
1533
1534         if (my $flags = has_property($t, "flag")) {
1535                 pidl "flags |= $flags;";
1536         }
1537         pidl "return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});";
1538 }
1539
1540 sub DeclStruct($)
1541 {
1542         my ($e,$t) = @_;
1543         return ($t ne "pull"?"const ":"") . "struct $e->{NAME} *r";
1544 }
1545
1546 sub ArgsStructNdrSize($)
1547 {
1548         my $d = shift;
1549         return "const struct $d->{NAME} *r, int flags";
1550 }
1551
1552 $typefamily{STRUCT} = {
1553         PUSH_FN_BODY => \&ParseStructPush,
1554         DECL => \&DeclStruct,
1555         PULL_FN_BODY => \&ParseStructPull,
1556         PRINT_FN_BODY => \&ParseStructPrint,
1557         SIZE_FN_BODY => \&ParseStructNdrSize,
1558         SIZE_FN_ARGS => \&ArgsStructNdrSize,
1559 };
1560
1561 #####################################################################
1562 # calculate size of ndr struct
1563 sub ParseUnionNdrSize($)
1564 {
1565         my $t = shift;
1566         my $sizevar;
1567
1568         if (my $flags = has_property($t, "flag")) {
1569                 pidl "flags |= $flags;";
1570         }
1571
1572         pidl "return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});";
1573 }
1574
1575 #####################################################################
1576 # parse a union - push side
1577 sub ParseUnionPush($$)
1578 {
1579         my ($e,$name) = @_;
1580         my $have_default = 0;
1581
1582         # save the old relative_base_offset
1583         pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined($e->{PROPERTIES}{relative_base});
1584         pidl "int level;";
1585
1586         start_flags($e);
1587
1588         pidl "level = ndr_push_get_switch_value(ndr, r);";
1589
1590         pidl "if (ndr_flags & NDR_SCALARS) {";
1591         indent;
1592
1593         if (defined($e->{SWITCH_TYPE})) {
1594                 pidl "NDR_CHECK(ndr_push_$e->{SWITCH_TYPE}(ndr, NDR_SCALARS, level));";
1595         }
1596
1597         pidl "switch (level) {";
1598         indent;
1599         foreach my $el (@{$e->{ELEMENTS}}) {
1600                 if ($el->{CASE} eq "default") {
1601                         $have_default = 1;
1602                 }
1603                 pidl "$el->{CASE}:";
1604
1605                 if ($el->{TYPE} ne "EMPTY") {
1606                         indent;
1607                         if (defined($e->{PROPERTIES}{relative_base})) {
1608                                 pidl "NDR_CHECK(ndr_push_align(ndr, $el->{ALIGN}));";
1609                                 # set the current offset as base for relative pointers
1610                                 # and store it based on the toplevel struct/union
1611                                 pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));";
1612                         }
1613                         DeclareArrayVariables($el);
1614                         ParseElementPush($el, "ndr", "r->", {}, 1, 0);
1615                         deindent;
1616                 }
1617                 pidl "break;";
1618                 pidl "";
1619         }
1620         if (! $have_default) {
1621                 pidl "default:";
1622                 pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
1623         }
1624         deindent;
1625         pidl "}";
1626         deindent;
1627         pidl "}";
1628         pidl "if (ndr_flags & NDR_BUFFERS) {";
1629         indent;
1630         if (defined($e->{PROPERTIES}{relative_base})) {
1631                 # retrieve the current offset as base for relative pointers
1632                 # based on the toplevel struct/union
1633                 pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));";
1634         }
1635         pidl "switch (level) {";
1636         indent;
1637         foreach my $el (@{$e->{ELEMENTS}}) {
1638                 pidl "$el->{CASE}:";
1639                 if ($el->{TYPE} ne "EMPTY") {
1640                         indent;
1641                         ParseElementPush($el, "ndr", "r->", {}, 0, 1);
1642                         deindent;
1643                 }
1644                 pidl "break;";
1645                 pidl "";
1646         }
1647         if (! $have_default) {
1648                 pidl "default:";
1649                 pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
1650         }
1651         deindent;
1652         pidl "}";
1653
1654         deindent;
1655         pidl "}";
1656         end_flags($e);
1657         # restore the old relative_base_offset
1658         pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($e->{PROPERTIES}{relative_base});
1659 }
1660
1661 #####################################################################
1662 # print a union
1663 sub ParseUnionPrint($$)
1664 {
1665         my ($e,$name) = @_;
1666         my $have_default = 0;
1667
1668         pidl "int level;";
1669         foreach my $el (@{$e->{ELEMENTS}}) {
1670                 DeclareArrayVariables($el);
1671         }
1672
1673         start_flags($e);
1674
1675         pidl "level = ndr_print_get_switch_value(ndr, r);";
1676
1677         pidl "ndr_print_union(ndr, name, level, \"$name\");";
1678
1679         pidl "switch (level) {";
1680         indent;
1681         foreach my $el (@{$e->{ELEMENTS}}) {
1682                 if ($el->{CASE} eq "default") {
1683                         $have_default = 1;
1684                 }
1685                 pidl "$el->{CASE}:";
1686                 if ($el->{TYPE} ne "EMPTY") {
1687                         indent;
1688                         ParseElementPrint($el, "r->$el->{NAME}", {});
1689                         deindent;
1690                 }
1691                 pidl "break;";
1692                 pidl "";
1693         }
1694         if (! $have_default) {
1695                 pidl "default:";
1696                 pidl "\tndr_print_bad_level(ndr, name, level);";
1697         }
1698         deindent;
1699         pidl "}";
1700
1701         end_flags($e);
1702 }
1703
1704 #####################################################################
1705 # parse a union - pull side
1706 sub ParseUnionPull($$)
1707 {
1708         my ($e,$name) = @_;
1709         my $have_default = 0;
1710         my $switch_type = $e->{SWITCH_TYPE};
1711
1712         # save the old relative_base_offset
1713         pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined($e->{PROPERTIES}{relative_base});
1714         pidl "int level;";
1715         if (defined($switch_type)) {
1716                 if (Parse::Pidl::Typelist::typeIs($switch_type, "ENUM")) {
1717                         $switch_type = Parse::Pidl::Typelist::enum_type_fn(getType($switch_type));
1718                 }
1719                 pidl mapType($switch_type) . " _level;";
1720         }
1721
1722         my %double_cases = ();
1723         foreach my $el (@{$e->{ELEMENTS}}) {
1724                 next if ($el->{TYPE} eq "EMPTY");
1725                 next if ($double_cases{"$el->{NAME}"});
1726                 DeclareMemCtxVariables($el);
1727                 $double_cases{"$el->{NAME}"} = 1;
1728         }
1729
1730         start_flags($e);
1731
1732         pidl "level = ndr_pull_get_switch_value(ndr, r);";
1733
1734         pidl "if (ndr_flags & NDR_SCALARS) {";
1735         indent;
1736
1737         if (defined($switch_type)) {
1738                 pidl "NDR_CHECK(ndr_pull_$switch_type(ndr, NDR_SCALARS, &_level));";
1739                 pidl "if (_level != level) {"; 
1740                 pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u for $name\", _level);";
1741                 pidl "}";
1742         }
1743
1744         pidl "switch (level) {";
1745         indent;
1746         foreach my $el (@{$e->{ELEMENTS}}) {
1747                 if ($el->{CASE} eq "default") {
1748                         $have_default = 1;
1749                 } 
1750                 pidl "$el->{CASE}: {";
1751
1752                 if ($el->{TYPE} ne "EMPTY") {
1753                         indent;
1754                         DeclarePtrVariables($el);
1755                         DeclareArrayVariables($el);
1756                         if (defined($e->{PROPERTIES}{relative_base})) {
1757                                 pidl "NDR_CHECK(ndr_pull_align(ndr, $el->{ALIGN}));";
1758                                 # set the current offset as base for relative pointers
1759                                 # and store it based on the toplevel struct/union
1760                                 pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));";
1761                         }
1762                         ParseElementPull($el, "ndr", "r->", {}, 1, 0);
1763                         deindent;
1764                 }
1765                 pidl "break; }";
1766                 pidl "";
1767         }
1768         if (! $have_default) {
1769                 pidl "default:";
1770                 pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
1771         }
1772         deindent;
1773         pidl "}";
1774         deindent;
1775         pidl "}";
1776         pidl "if (ndr_flags & NDR_BUFFERS) {";
1777         indent;
1778         if (defined($e->{PROPERTIES}{relative_base})) {
1779                 # retrieve the current offset as base for relative pointers
1780                 # based on the toplevel struct/union
1781                 pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));";
1782         }
1783         pidl "switch (level) {";
1784         indent;
1785         foreach my $el (@{$e->{ELEMENTS}}) {
1786                 pidl "$el->{CASE}:";
1787                 if ($el->{TYPE} ne "EMPTY") {
1788                         indent;
1789                         ParseElementPull($el, "ndr", "r->", {}, 0, 1);
1790                         deindent;
1791                 }
1792                 pidl "break;";
1793                 pidl "";
1794         }
1795         if (! $have_default) {
1796                 pidl "default:";
1797                 pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
1798         }
1799         deindent;
1800         pidl "}";
1801
1802         deindent;
1803         pidl "}";
1804
1805         add_deferred();
1806
1807         end_flags($e);
1808         # restore the old relative_base_offset
1809         pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($e->{PROPERTIES}{relative_base});
1810 }
1811
1812 sub DeclUnion($$)
1813 {
1814         my ($e,$t) = @_;
1815         return ($t ne "pull"?"const ":"") . "union $e->{NAME} *r";
1816 }
1817
1818 sub ArgsUnionNdrSize($)
1819 {
1820         my $d = shift;
1821         return "const union $d->{NAME} *r, uint32_t level, int flags";
1822 }
1823
1824 $typefamily{UNION} = {
1825         PUSH_FN_BODY => \&ParseUnionPush,
1826         DECL => \&DeclUnion,
1827         PULL_FN_BODY => \&ParseUnionPull,
1828         PRINT_FN_BODY => \&ParseUnionPrint,
1829         SIZE_FN_ARGS => \&ArgsUnionNdrSize,
1830         SIZE_FN_BODY => \&ParseUnionNdrSize,
1831 };
1832         
1833 #####################################################################
1834 # parse a typedef - push side
1835 sub ParseTypedefPush($)
1836 {
1837         my($e) = shift;
1838
1839         my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"push");
1840         fn_declare("push", $e, "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $args)") or return;
1841
1842         pidl "{";
1843         indent;
1844         $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($e->{DATA}, $e->{NAME});
1845         pidl "return NT_STATUS_OK;";
1846         deindent;
1847         pidl "}";
1848         pidl "";;
1849 }
1850
1851 #####################################################################
1852 # parse a typedef - pull side
1853 sub ParseTypedefPull($)
1854 {
1855         my($e) = shift;
1856
1857         my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"pull");
1858
1859         fn_declare("pull", $e, "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, $args)") or return;
1860
1861         pidl "{";
1862         indent;
1863         $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA}, $e->{NAME});
1864         pidl "return NT_STATUS_OK;";
1865         deindent;
1866         pidl "}";
1867         pidl "";
1868 }
1869
1870 #####################################################################
1871 # parse a typedef - print side
1872 sub ParseTypedefPrint($)
1873 {
1874         my($e) = shift;
1875
1876         my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"print");
1877
1878         pidl_hdr "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args);";
1879
1880         return if (has_property($e, "noprint"));
1881
1882         pidl "_PUBLIC_ void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)";
1883         pidl "{";
1884         indent;
1885         $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA}, $e->{NAME});
1886         deindent;
1887         pidl "}";
1888         pidl "";
1889 }
1890
1891 #####################################################################
1892 ## calculate the size of a structure
1893 sub ParseTypedefNdrSize($)
1894 {
1895         my($t) = shift;
1896
1897         my $tf = $typefamily{$t->{DATA}->{TYPE}};
1898         my $args = $tf->{SIZE_FN_ARGS}->($t);
1899
1900         fn_declare("size", $t, "size_t ndr_size_$t->{NAME}($args)") or return;
1901
1902         pidl "{";
1903         indent;
1904         $typefamily{$t->{DATA}->{TYPE}}->{SIZE_FN_BODY}->($t);
1905         deindent;
1906         pidl "}";
1907         pidl "";
1908 }
1909
1910 #####################################################################
1911 # parse a function - print side
1912 sub ParseFunctionPrint($)
1913 {
1914         my($fn) = shift;
1915
1916         pidl_hdr "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r);";
1917
1918         return if has_property($fn, "noprint");
1919
1920         pidl "_PUBLIC_ void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r)";
1921         pidl "{";
1922         indent;
1923
1924         foreach my $e (@{$fn->{ELEMENTS}}) {
1925                 DeclareArrayVariables($e);
1926         }
1927
1928         pidl "ndr_print_struct(ndr, name, \"$fn->{NAME}\");";
1929         pidl "ndr->depth++;";
1930
1931         pidl "if (flags & NDR_SET_VALUES) {";
1932         pidl "\tndr->flags |= LIBNDR_PRINT_SET_VALUES;";
1933         pidl "}";
1934
1935         pidl "if (flags & NDR_IN) {";
1936         indent;
1937         pidl "ndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");";
1938         pidl "ndr->depth++;";
1939
1940         my $env = GenerateFunctionInEnv($fn);
1941         EnvSubstituteValue($env, $fn);
1942
1943         foreach my $e (@{$fn->{ELEMENTS}}) {
1944                 if (grep(/in/,@{$e->{DIRECTION}})) {
1945                         ParseElementPrint($e, "r->in.$e->{NAME}", $env);
1946                 }
1947         }
1948         pidl "ndr->depth--;";
1949         deindent;
1950         pidl "}";
1951         
1952         pidl "if (flags & NDR_OUT) {";
1953         indent;
1954         pidl "ndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");";
1955         pidl "ndr->depth++;";
1956
1957         $env = GenerateFunctionOutEnv($fn);
1958         foreach my $e (@{$fn->{ELEMENTS}}) {
1959                 if (grep(/out/,@{$e->{DIRECTION}})) {
1960                         ParseElementPrint($e, "r->out.$e->{NAME}", $env);
1961                 }
1962         }
1963         if ($fn->{RETURN_TYPE}) {
1964                 pidl "ndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", r->out.result);";
1965         }
1966         pidl "ndr->depth--;";
1967         deindent;
1968         pidl "}";
1969         
1970         pidl "ndr->depth--;";
1971         deindent;
1972         pidl "}";
1973         pidl "";
1974 }
1975
1976 #####################################################################
1977 # parse a function
1978 sub ParseFunctionPush($)
1979
1980         my($fn) = shift;
1981
1982         fn_declare("push", $fn, "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, const struct $fn->{NAME} *r)") or return;
1983
1984         return if has_property($fn, "nopush");
1985
1986         pidl "{";
1987         indent;
1988
1989         foreach my $e (@{$fn->{ELEMENTS}}) { 
1990                 DeclareArrayVariables($e);
1991         }
1992
1993         pidl "if (flags & NDR_IN) {";
1994         indent;
1995
1996         my $env = GenerateFunctionInEnv($fn);
1997
1998         EnvSubstituteValue($env, $fn);
1999
2000         foreach my $e (@{$fn->{ELEMENTS}}) {
2001                 if (grep(/in/,@{$e->{DIRECTION}})) {
2002                         ParseElementPush($e, "ndr", "r->in.", $env, 1, 1);
2003                 }
2004         }
2005
2006         deindent;
2007         pidl "}";
2008
2009         pidl "if (flags & NDR_OUT) {";
2010         indent;
2011
2012         $env = GenerateFunctionOutEnv($fn);
2013         foreach my $e (@{$fn->{ELEMENTS}}) {
2014                 if (grep(/out/,@{$e->{DIRECTION}})) {
2015                         ParseElementPush($e, "ndr", "r->out.", $env, 1, 1);
2016                 }
2017         }
2018
2019         if ($fn->{RETURN_TYPE}) {
2020                 pidl "NDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, r->out.result));";
2021         }
2022     
2023         deindent;
2024         pidl "}";
2025         pidl "return NT_STATUS_OK;";
2026         deindent;
2027         pidl "}";
2028         pidl "";
2029 }
2030
2031 sub AllocateArrayLevel($$$$$)
2032 {
2033         my ($e,$l,$ndr,$env,$size) = @_;
2034
2035         my $var = ParseExpr($e->{NAME}, $env);
2036
2037         check_null_pointer($size);
2038         my $pl = GetPrevLevel($e, $l);
2039         if (defined($pl) and 
2040             $pl->{TYPE} eq "POINTER" and 
2041             $pl->{POINTER_TYPE} eq "ref"
2042             and not $l->{IS_ZERO_TERMINATED}) {
2043                 pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
2044                 pidl "\tNDR_PULL_ALLOC_N($ndr, $var, $size);";
2045                 pidl "}";
2046                 if (grep(/in/,@{$e->{DIRECTION}}) and
2047                     grep(/out/,@{$e->{DIRECTION}})) {
2048                         pidl "memcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));";
2049                 }
2050                 return;
2051         }
2052
2053         pidl "NDR_PULL_ALLOC_N($ndr, $var, $size);";
2054 }
2055
2056 #####################################################################
2057 # parse a function
2058 sub ParseFunctionPull($)
2059
2060         my($fn) = shift;
2061
2062         # pull function args
2063         fn_declare("pull", $fn, "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)") or return;
2064
2065         pidl "{";
2066         indent;
2067
2068         # declare any internal pointers we need
2069         foreach my $e (@{$fn->{ELEMENTS}}) { 
2070                 DeclarePtrVariables($e);
2071                 DeclareArrayVariables($e);
2072         }
2073
2074         my %double_cases = ();
2075         foreach my $e (@{$fn->{ELEMENTS}}) {
2076                 next if ($e->{TYPE} eq "EMPTY");
2077                 next if ($double_cases{"$e->{NAME}"});
2078                 DeclareMemCtxVariables($e);
2079                 $double_cases{"$e->{NAME}"} = 1;
2080         }
2081
2082         pidl "if (flags & NDR_IN) {";
2083         indent;
2084
2085         # auto-init the out section of a structure. I originally argued that
2086         # this was a bad idea as it hides bugs, but coping correctly
2087         # with initialisation and not wiping ref vars is turning
2088         # out to be too tricky (tridge)
2089         foreach my $e (@{$fn->{ELEMENTS}}) {
2090                 next unless grep(/out/, @{$e->{DIRECTION}});
2091                 pidl "ZERO_STRUCT(r->out);";
2092                 pidl "";
2093                 last;
2094         }
2095
2096         my $env = GenerateFunctionInEnv($fn);
2097
2098         foreach my $e (@{$fn->{ELEMENTS}}) {
2099                 next unless (grep(/in/, @{$e->{DIRECTION}}));
2100                 ParseElementPull($e, "ndr", "r->in.", $env, 1, 1);
2101         }
2102
2103         # allocate the "simple" out ref variables. FIXME: Shouldn't this have it's
2104         # own flag rather then be in NDR_IN ?
2105
2106         foreach my $e (@{$fn->{ELEMENTS}}) {
2107                 next unless (grep(/out/, @{$e->{DIRECTION}}));
2108                 next unless ($e->{LEVELS}[0]->{TYPE} eq "POINTER" and 
2109                              $e->{LEVELS}[0]->{POINTER_TYPE} eq "ref");
2110                 next unless has_property($e, "keepref");
2111                 next if (($e->{LEVELS}[1]->{TYPE} eq "DATA") and 
2112                                  ($e->{LEVELS}[1]->{DATA_TYPE} eq "string"));
2113                 next if (($e->{LEVELS}[1]->{TYPE} eq "ARRAY") 
2114                         and   $e->{LEVELS}[1]->{IS_ZERO_TERMINATED});
2115
2116                 if ($e->{LEVELS}[1]->{TYPE} eq "ARRAY") {
2117                         my $size = ParseExpr($e->{LEVELS}[1]->{SIZE_IS}, $env);
2118                         check_null_pointer($size);
2119                         
2120                         pidl "NDR_PULL_ALLOC_N(ndr, r->out.$e->{NAME}, $size);";
2121
2122                         if (grep(/in/, @{$e->{DIRECTION}})) {
2123                                 pidl "memcpy(r->out.$e->{NAME}, r->in.$e->{NAME}, $size * sizeof(*r->in.$e->{NAME}));";
2124                         } else {
2125                                 pidl "memset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));";
2126                         }
2127                 } else {
2128                         pidl "NDR_PULL_ALLOC(ndr, r->out.$e->{NAME});";
2129                 
2130                         if (grep(/in/, @{$e->{DIRECTION}})) {
2131                                 pidl "*r->out.$e->{NAME} = *r->in.$e->{NAME};";
2132                         } else {
2133                                 pidl "ZERO_STRUCTP(r->out.$e->{NAME});";
2134                         }
2135                 }
2136         }
2137
2138         add_deferred();
2139         deindent;
2140         pidl "}";
2141         
2142         pidl "if (flags & NDR_OUT) {";
2143         indent;
2144
2145         $env = GenerateFunctionOutEnv($fn);
2146         foreach my $e (@{$fn->{ELEMENTS}}) {
2147                 next unless grep(/out/, @{$e->{DIRECTION}});
2148                 ParseElementPull($e, "ndr", "r->out.", $env, 1, 1);
2149         }
2150
2151         if ($fn->{RETURN_TYPE}) {
2152                 pidl "NDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, &r->out.result));";
2153         }
2154
2155         add_deferred();
2156         deindent;
2157         pidl "}";
2158
2159         pidl "return NT_STATUS_OK;";
2160         deindent;
2161         pidl "}";
2162         pidl "";
2163 }
2164
2165 #####################################################################
2166 # produce a function call table
2167 sub FunctionTable($)
2168 {
2169         my($interface) = shift;
2170         my $count = 0;
2171         my $uname = uc $interface->{NAME};
2172
2173         return if ($#{$interface->{FUNCTIONS}}+1 == 0);
2174         return unless defined ($interface->{PROPERTIES}->{uuid});
2175
2176         pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {";
2177         foreach my $d (@{$interface->{FUNCTIONS}}) {
2178                 next if not defined($d->{OPNUM});
2179                 pidl "\t{";
2180                 pidl "\t\t\"$d->{NAME}\",";
2181                 pidl "\t\tsizeof(struct $d->{NAME}),";
2182                 pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},";
2183                 pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},";
2184                 pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME},";
2185                 pidl "\t\t".($d->{ASYNC}?"True":"False").",";
2186                 pidl "\t},";
2187                 $count++;
2188         }
2189         pidl "\t{ NULL, 0, NULL, NULL, NULL, False }";
2190         pidl "};";
2191         pidl "";
2192
2193         pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {";
2194         foreach my $ep (@{$interface->{ENDPOINTS}}) {
2195                 pidl "\t$ep, ";
2196         }
2197         my $endpoint_count = $#{$interface->{ENDPOINTS}}+1;
2198         
2199         pidl "};";
2200         pidl "";
2201
2202         pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {";
2203         pidl "\t.count\t= $endpoint_count,";
2204         pidl "\t.names\t= $interface->{NAME}\_endpoint_strings";
2205         pidl "};";
2206         pidl "";
2207
2208         if (! defined $interface->{PROPERTIES}->{authservice}) {
2209                 $interface->{PROPERTIES}->{authservice} = "\"host\"";
2210         }
2211
2212         my @a = split / /, $interface->{PROPERTIES}->{authservice};
2213         my $authservice_count = $#a + 1;
2214
2215         pidl "static const char * const $interface->{NAME}\_authservice_strings[] = {";
2216         foreach my $ap (@a) {
2217                 pidl "\t$ap, ";
2218         }
2219         pidl "};";
2220         pidl "";
2221
2222         pidl "static const struct dcerpc_authservice_list $interface->{NAME}\_authservices = {";
2223         pidl "\t.count\t= $endpoint_count,";
2224         pidl "\t.names\t= $interface->{NAME}\_authservice_strings";
2225         pidl "};";
2226         pidl "";
2227
2228         pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {";
2229         pidl "\t.name\t\t= \"$interface->{NAME}\",";
2230         pidl "\t.syntax_id\t= {";
2231         pidl "\t\t" . print_uuid($interface->{UUID}) .",";
2232         pidl "\t\tDCERPC_$uname\_VERSION";
2233         pidl "\t},";
2234         pidl "\t.helpstring\t= DCERPC_$uname\_HELPSTRING,";
2235         pidl "\t.num_calls\t= $count,";
2236         pidl "\t.calls\t\t= $interface->{NAME}\_calls,";
2237         pidl "\t.endpoints\t= &$interface->{NAME}\_endpoints,";
2238         pidl "\t.authservices\t= &$interface->{NAME}\_authservices";
2239         pidl "};";
2240         pidl "";
2241
2242 }
2243
2244 #####################################################################
2245 # generate prototypes and defines for the interface definitions
2246 # FIXME: these prototypes are for the DCE/RPC client functions, not the 
2247 # NDR parser and so do not belong here, technically speaking
2248 sub HeaderInterface($)
2249 {
2250         my($interface) = shift;
2251
2252         my $count = 0;
2253
2254         pidl_hdr choose_header("librpc/ndr/libndr.h", "ndr.h");
2255
2256         if (has_property($interface, "object")) {
2257                 pidl choose_header("librpc/gen_ndr/ndr_orpc.h", "ndr/orpc.h");
2258         }
2259
2260         if (defined $interface->{PROPERTIES}->{depends}) {
2261                 my @d = split / /, $interface->{PROPERTIES}->{depends};
2262                 foreach my $i (@d) {
2263                         pidl choose_header("librpc/gen_ndr/ndr_$i\.h", "gen_ndr/ndr_$i.h");
2264                 }
2265         }
2266
2267         if (defined $interface->{PROPERTIES}->{helper}) {
2268                 foreach (split / /, $interface->{PROPERTIES}->{helper}) {
2269                         pidl_hdr "#include $_";
2270                 }
2271         }
2272
2273         if (defined $interface->{PROPERTIES}->{uuid}) {
2274                 my $name = uc $interface->{NAME};
2275                 pidl_hdr "#define DCERPC_$name\_UUID " . 
2276                 Parse::Pidl::Util::make_str(lc($interface->{PROPERTIES}->{uuid}));
2277
2278                 if(!defined $interface->{PROPERTIES}->{version}) { $interface->{PROPERTIES}->{version} = "0.0"; }
2279                 pidl_hdr "#define DCERPC_$name\_VERSION $interface->{PROPERTIES}->{version}";
2280
2281                 pidl_hdr "#define DCERPC_$name\_NAME \"$interface->{NAME}\"";
2282
2283                 if(!defined $interface->{PROPERTIES}->{helpstring}) { $interface->{PROPERTIES}->{helpstring} = "NULL"; }
2284                 pidl_hdr "#define DCERPC_$name\_HELPSTRING $interface->{PROPERTIES}->{helpstring}";
2285
2286                 pidl_hdr "extern const struct dcerpc_interface_table dcerpc_table_$interface->{NAME};";
2287                 pidl_hdr "NTSTATUS dcerpc_server_$interface->{NAME}_init(void);";
2288         }
2289
2290         foreach (@{$interface->{FUNCTIONS}}) {
2291                 next if has_property($_, "noopnum");
2292                 next if grep(/$_->{NAME}/,@{$interface->{INHERITED_FUNCTIONS}});
2293                 my $u_name = uc $_->{NAME};
2294         
2295                 my $val = sprintf("0x%02x", $count);
2296                 if (defined($interface->{BASE})) {
2297                         $val .= " + DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT";
2298                 }
2299                 
2300                 pidl_hdr "#define DCERPC_$u_name ($val)";
2301
2302                 pidl_hdr "";
2303                 $count++;
2304         }
2305
2306         my $val = $count;
2307
2308         if (defined($interface->{BASE})) {
2309                 $val .= " + DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT";
2310         }
2311
2312         pidl_hdr "#define DCERPC_" . uc $interface->{NAME} . "_CALL_COUNT ($val)";
2313
2314 }
2315
2316 #####################################################################
2317 # parse the interface definitions
2318 sub ParseInterface($$)
2319 {
2320         my($interface,$needed) = @_;
2321
2322         pidl_hdr "#ifndef _HEADER_NDR_$interface->{NAME}";
2323         pidl_hdr "#define _HEADER_NDR_$interface->{NAME}";
2324
2325         pidl_hdr "";
2326
2327         if ($needed->{"compression"}) {
2328                 pidl choose_header("librpc/ndr/ndr_compression.h", "ndr/compression.h");
2329         }
2330
2331         HeaderInterface($interface);
2332
2333         # Typedefs
2334         foreach my $d (@{$interface->{TYPES}}) {
2335                 ($needed->{"push_$d->{NAME}"}) && ParseTypedefPush($d);
2336                 ($needed->{"pull_$d->{NAME}"}) && ParseTypedefPull($d);
2337                 ($needed->{"print_$d->{NAME}"}) && ParseTypedefPrint($d);
2338
2339                 # Make sure we don't generate a function twice...
2340                 $needed->{"push_$d->{NAME}"} = $needed->{"pull_$d->{NAME}"} = 
2341                         $needed->{"print_$d->{NAME}"} = 0;
2342
2343                 ($needed->{"ndr_size_$d->{NAME}"}) && ParseTypedefNdrSize($d);
2344         }
2345
2346         # Functions
2347         foreach my $d (@{$interface->{FUNCTIONS}}) {
2348                 ($needed->{"push_$d->{NAME}"}) && ParseFunctionPush($d);
2349                 ($needed->{"pull_$d->{NAME}"}) && ParseFunctionPull($d);
2350                 ($needed->{"print_$d->{NAME}"}) && ParseFunctionPrint($d);
2351
2352                 # Make sure we don't generate a function twice...
2353                 $needed->{"push_$d->{NAME}"} = $needed->{"pull_$d->{NAME}"} = 
2354                         $needed->{"print_$d->{NAME}"} = 0;
2355         }
2356
2357         FunctionTable($interface);
2358
2359         pidl_hdr "#endif /* _HEADER_NDR_$interface->{NAME} */";
2360 }
2361
2362 #####################################################################
2363 # parse a parsed IDL structure back into an IDL file
2364 sub Parse($$$)
2365 {
2366         my($ndr,$gen_header,$ndr_header) = @_;
2367
2368         $tabs = "";
2369         $res = "";
2370
2371         $res_hdr = "";
2372         pidl_hdr "/* header auto-generated by pidl */";
2373         pidl_hdr "";
2374         pidl_hdr "#include \"$gen_header\"" if ($gen_header);
2375         pidl_hdr "";
2376
2377         pidl "/* parser auto-generated by pidl */";
2378         pidl "";
2379         if (is_intree()) {
2380                 pidl "#include \"includes.h\"";
2381         } else {
2382                 pidl "#define _GNU_SOURCE";
2383                 pidl "#include <stdint.h>";
2384                 pidl "#include <stdlib.h>";
2385                 pidl "#include <stdio.h>";
2386                 pidl "#include <stdbool.h>";
2387                 pidl "#include <stdarg.h>";
2388                 pidl "#include <string.h>";
2389         }
2390         pidl choose_header("libcli/util/nterr.h", "core/nterr.h");
2391         pidl choose_header("librpc/gen_ndr/ndr_misc.h", "gen_ndr/ndr_misc.h");
2392         pidl choose_header("librpc/gen_ndr/ndr_dcerpc.h", "gen_ndr/ndr_dcerpc.h");
2393         pidl "#include \"$ndr_header\"" if ($ndr_header);
2394         pidl choose_header("librpc/rpc/dcerpc.h", "dcerpc.h"); #FIXME: This shouldn't be here!
2395         pidl "";
2396
2397         my %needed = ();
2398
2399         foreach (@{$ndr}) {
2400                 ($_->{TYPE} eq "INTERFACE") && NeededInterface($_, \%needed);
2401         }
2402
2403         foreach (@{$ndr}) {
2404                 ($_->{TYPE} eq "INTERFACE") && ParseInterface($_, \%needed);
2405         }
2406
2407         return ($res_hdr, $res);
2408 }
2409
2410 sub NeededFunction($$)
2411 {
2412         my ($fn,$needed) = @_;
2413         $needed->{"pull_$fn->{NAME}"} = 1;
2414         $needed->{"push_$fn->{NAME}"} = 1;
2415         $needed->{"print_$fn->{NAME}"} = 1;
2416         foreach my $e (@{$fn->{ELEMENTS}}) {
2417                 $e->{PARENT} = $fn;
2418                 unless(defined($needed->{"pull_$e->{TYPE}"})) {
2419                         $needed->{"pull_$e->{TYPE}"} = 1;
2420                 }
2421                 unless(defined($needed->{"push_$e->{TYPE}"})) {
2422                         $needed->{"push_$e->{TYPE}"} = 1;
2423                 }
2424                 unless(defined($needed->{"print_$e->{TYPE}"})) {
2425                         $needed->{"print_$e->{TYPE}"} = 1;
2426                 }
2427         }
2428 }
2429
2430 sub NeededTypedef($$)
2431 {
2432         my ($t,$needed) = @_;
2433         if (has_property($t, "public")) {
2434                 $needed->{"pull_$t->{NAME}"} = 1;
2435                 $needed->{"push_$t->{NAME}"} = 1;
2436                 $needed->{"print_$t->{NAME}"} = 1;
2437         }
2438
2439         if ($t->{DATA}->{TYPE} eq "STRUCT" or $t->{DATA}->{TYPE} eq "UNION") {
2440                 if (has_property($t, "gensize")) {
2441                         $needed->{"ndr_size_$t->{NAME}"} = 1;
2442                 }
2443
2444                 for my $e (@{$t->{DATA}->{ELEMENTS}}) {
2445                         $e->{PARENT} = $t->{DATA};
2446                         if (has_property($e, "compression")) { 
2447                                 $needed->{"compression"} = 1;
2448                         }
2449                         if ($needed->{"pull_$t->{NAME}"} and
2450                                 not defined($needed->{"pull_$e->{TYPE}"})) {
2451                                 $needed->{"pull_$e->{TYPE}"} = 1;
2452                         }
2453                         if ($needed->{"push_$t->{NAME}"} and
2454                                 not defined($needed->{"push_$e->{TYPE}"})) {
2455                                 $needed->{"push_$e->{TYPE}"} = 1;
2456                         }
2457                         if ($needed->{"print_$t->{NAME}"} and 
2458                                 not defined($needed->{"print_$e->{TYPE}"})) {
2459                                 $needed->{"print_$e->{TYPE}"} = 1;
2460                         }
2461                 }
2462         }
2463 }
2464
2465 #####################################################################
2466 # work out what parse functions are needed
2467 sub NeededInterface($$)
2468 {
2469         my ($interface,$needed) = @_;
2470         NeededFunction($_, $needed) foreach (@{$interface->{FUNCTIONS}});
2471         NeededTypedef($_, $needed) foreach (reverse @{$interface->{TYPES}});
2472 }
2473
2474 1;