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