source4/build/pidl/ndr.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-2005
   6 # released under the GNU GPL
   7
   8 package NdrParser;
   9
  10 use strict;
  11 use needed;
  12 use typelist;
  13
  14 # list of known types
  15 my %typefamily;
  16
  17 sub get_typefamily($)
  18 {
  19         my $n = shift;
  20         return $typefamily{$n};
  21 }
  22
  23 my %scalar_alignments =
  24 (
  25      "char"           => 1,
  26      "int8"           => 1,
  27      "uint8"          => 1,
  28      "short"          => 2,
  29      "wchar_t"        => 2,
  30      "int16"          => 2,
  31      "uint16"         => 2,
  32      "long"           => 4,
  33      "int32"          => 4,
  34      "uint32"         => 4,
  35      "dlong"          => 4,
  36      "udlong"         => 4,
  37      "udlongr"        => 4,
  38      "NTTIME"         => 4,
  39      "NTTIME_1sec"    => 4,
  40      "time_t"         => 4,
  41      "DATA_BLOB"      => 4,
  42      "error_status_t" => 4,
  43      "WERROR"         => 4,
  44          "NTSTATUS"       => 4,
  45      "boolean32"      => 4,
  46      "unsigned32"     => 4,
  47      "ipv4address"    => 4,
  48      "hyper"          => 8,
  49      "NTTIME_hyper"   => 8
  50 );
  51
  52 $typefamily{SCALAR} = {
  53         ALIGN => sub {
  54                 my $t = shift;
  55                 return $scalar_alignments{$t->{NAME}};
  56         }
  57 };
  58
  59 sub is_scalar_type($)
  60 {
  61     my $type = shift;
  62
  63         return 0 unless typelist::hasType($type);
  64
  65         if (my $dt = typelist::getType($type)->{DATA}->{TYPE}) {
  66                 return 1 if ($dt eq "SCALAR" or $dt eq "ENUM" or $dt eq "BITMAP");
  67         }
  68
  69     return 0;
  70 }
  71
  72 sub pointer_type($)
  73 {
  74         my $e = shift;
  75
  76         return undef unless $e->{POINTERS};
  77
  78         return "ref" if (util::has_property($e, "ref"));
  79         return "ptr" if (util::has_property($e, "ptr"));
  80         return "unique" if (util::has_property($e, "unique"));
  81         return "relative" if (util::has_property($e, "relative"));
  82         return "ignore" if (util::has_property($e, "ignore"));
  83
  84         return undef;
  85 }
  86
  87 # return 1 if this is a fixed array
  88 sub is_fixed_array($)
  89 {
  90         my $e = shift;
  91         my $len = $e->{"ARRAY_LEN"};
  92         return 1 if (defined $len && util::is_constant($len));
  93         return 0;
  94 }
  95
  96 # return 1 if this is a conformant array
  97 sub is_conformant_array($)
  98 {
  99         my $e = shift;
 100         return 1 if (util::has_property($e, "size_is"));
 101         return 0;
 102 }
 103
 104 # return 1 if this is a inline array
 105 sub is_inline_array($)
 106 {
 107         my $e = shift;
 108         my $len = $e->{"ARRAY_LEN"};
 109         if (is_fixed_array($e) ||
 110             defined $len && $len ne "*") {
 111                 return 1;
 112         }
 113         return 0;
 114 }
 115
 116 # return 1 if this is a varying array
 117 sub is_varying_array($)
 118 {
 119         my $e = shift;
 120         return util::has_property($e, "length_is");
 121 }
 122
 123 # return 1 if this is a surrounding array (sometimes
 124 # referred to as an embedded array). Can only occur as
 125 # the last element in a struct and can not contain any pointers.
 126 sub is_surrounding_array($)
 127 {
 128         my $e = shift;
 129
 130         return ($e->{POINTERS} == 0
 131                 and defined $e->{ARRAY_LEN}
 132                 and     $e->{ARRAY_LEN} eq "*"
 133                 and $e == $e->{PARENT}->{ELEMENTS}[-1]
 134                 and $e->{PARENT}->{TYPE} ne "FUNCTION");
 135 }
 136
 137 sub array_type($)
 138 {
 139         my $e = shift;
 140
 141         return "conformant-varying" if (is_varying_array($e) and is_conformant_array($e));
 142         return "conformant" if (is_varying_array($e));
 143         return "varying" if (is_varying_array($e));
 144         return "inline" if (is_inline_array($e));
 145         return "fixed" if (is_fixed_array($e));
 146
 147         return undef;
 148 }
 149
 150 # determine if an element needs a reference pointer on the wire
 151 # in its NDR representation
 152 sub need_wire_pointer($)
 153 {
 154         my $e = shift;
 155
 156         my $n = $e->{POINTERS};
 157         my $pt = pointer_type($e);
 158
 159         # Top level "ref" pointers do not have a referrent identifier
 160         if (    defined($pt)
 161                 and $pt eq "ref"
 162                 and $e->{PARENT}->{TYPE} eq "FUNCTION")
 163         {
 164                 $n--;
 165         }
 166
 167         return $n;
 168 }
 169
 170 # determine if an element needs a "buffers" section in NDR
 171 sub need_buffers_section($)
 172 {
 173         my $e = shift;
 174         if (!can_contain_deferred($e) &&
 175             !util::array_size($e)) {
 176                 return 0;
 177         }
 178         return 1;
 179 }
 180
 181 # see if a variable needs to be allocated by the NDR subsystem on pull
 182 sub need_alloc($)
 183 {
 184         my $e = shift;
 185
 186         return 0 if (util::has_property($e, "ref") && $e->{PARENT}->{TYPE} eq "FUNCTION");
 187         return 1 if ($e->{POINTERS} || util::array_size($e));
 188         return 0;
 189 }
 190
 191 # Prefix to get the actual value of a variable
 192 sub c_ptr_prefix($)
 193 {
 194         my $e = shift;
 195         my $pointers = "";
 196         foreach my $i (need_wire_pointer($e)..$e->{POINTERS}-1) { $pointers.="*"; }
 197         return $pointers;
 198 }
 199
 200 # determine the C prefix used to refer to a variable when passing to a push
 201 # function. This will be '*' for pointers to scalar types, '' for scalar
 202 # types and normal pointers and '&' for pass-by-reference structures
 203 sub c_push_prefix($)
 204 {
 205         my $e = shift;
 206
 207         my $ret = "";
 208
 209         if ($e->{TYPE} =~ "string") {
 210                 $ret = "";
 211         } elsif (is_scalar_type($e->{TYPE}) and $e->{POINTERS} and
 212                 !util::array_size($e)) {
 213                 $ret .="*";
 214         } elsif (!is_scalar_type($e->{TYPE}) &&
 215             !$e->{POINTERS} &&
 216             !util::array_size($e)) {
 217                 return "&";
 218         }
 219
 220         foreach my $i (2..$e->{POINTERS}) { $ret.="*"; }
 221
 222         return $ret;
 223 }
 224
 225 # determine the C prefix used to refer to a variable when passing to a pull
 226 # return '&' or ''
 227 sub c_pull_prefix($)
 228 {
 229         my $e = shift;
 230
 231         if (!$e->{POINTERS} && !util::array_size($e)) {
 232                 return "&";
 233         }
 234
 235         if ($e->{TYPE} =~ "string") {
 236                 return "&";
 237         }
 238
 239         my $ret = "";
 240         foreach my $i (2..$e->{POINTERS}) { $ret.="*"; }
 241         return $ret;
 242 }
 243 my $res = "";
 244 my $tabs = "";
 245 sub pidl($)
 246 {
 247         my $d = shift;
 248         if ($d) {
 249                 $res .= $tabs;
 250                 $res .= $d;
 251         }
 252         $res .="\n";
 253 }
 254
 255 sub indent()
 256 {
 257         $tabs .= "\t";
 258 }
 259
 260 sub deindent()
 261 {
 262         $tabs = substr($tabs, 0, -1);
 263 }
 264
 265 ####################################################################
 266 # work out the name of a size_is() variable
 267 sub ParseExpr($$$)
 268 {
 269         my($e) = shift;
 270         my($size) = shift;
 271         my($var_prefix) = shift;
 272
 273         my($fn) = $e->{PARENT};
 274
 275         return $size if (util::is_constant($size));
 276
 277         return $size if ($size =~ /ndr->|\(/);
 278
 279         my $prefix = "";
 280
 281         if ($size =~ /\*(.*)/) {
 282                 $size = $1;
 283                 $prefix = "*";
 284         }
 285
 286         if ($fn->{TYPE} ne "FUNCTION") {
 287                 return $prefix . "r->$size";
 288         }
 289
 290         my $e2 = util::find_sibling($e, $size);
 291
 292         die("Invalid sibling '$size'") unless defined($e2);
 293
 294         if (util::has_property($e2, "in") && util::has_property($e2, "out")) {
 295                 return $prefix . "$var_prefix$size";
 296         }
 297
 298         if (util::has_property($e2, "in")) {
 299                 return $prefix . "r->in.$size";
 300         }
 301
 302         if (util::has_property($e2, "out")) {
 303                 return $prefix . "r->out.$size";
 304         }
 305
 306         die "invalid variable in $size for element $e->{NAME} in $fn->{NAME}\n";
 307 }
 308
 309 #####################################################################
 310 # check that a variable we get from ParseExpr isn't a null pointer
 311 sub check_null_pointer($)
 312 {
 313         my $size = shift;
 314         if ($size =~ /^\*/) {
 315                 my $size2 = substr($size, 1);
 316                 pidl "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;";
 317         }
 318 }
 319
 320 #####################################################################
 321 # check that a variable we get from ParseExpr isn't a null pointer
 322 # void return varient
 323 sub check_null_pointer_void($)
 324 {
 325         my $size = shift;
 326         if ($size =~ /^\*/) {
 327                 my $size2 = substr($size, 1);
 328                 pidl "if ($size2 == NULL) return;";
 329         }
 330 }
 331
 332 #####################################################################
 333 # work out is a parse function should be declared static or not
 334 sub fn_prefix($)
 335 {
 336         my $fn = shift;
 337
 338         if ($fn->{TYPE} eq "TYPEDEF" or
 339             $fn->{TYPE} eq "FUNCTION") {
 340                 return "" if (util::has_property($fn, "public"));
 341         }
 342
 343         return "static ";
 344 }
 345
 346 ###################################################################
 347 # setup any special flags for an element or structure
 348 sub start_flags($)
 349 {
 350         my $e = shift;
 351         my $flags = util::has_property($e, "flag");
 352         if (defined $flags) {
 353                 pidl "{ uint32_t _flags_save_$e->{TYPE} = ndr->flags;";
 354                 pidl "ndr_set_flags(&ndr->flags, $flags);";
 355         }
 356 }
 357
 358 ###################################################################
 359 # end any special flags for an element or structure
 360 sub end_flags($)
 361 {
 362         my $e = shift;
 363         my $flags = util::has_property($e, "flag");
 364         if (defined $flags) {
 365                 pidl "ndr->flags = _flags_save_$e->{TYPE};\n\t}";
 366         }
 367 }
 368
 369 #####################################################################
 370 # work out the correct alignment for a structure or union
 371 sub find_largest_alignment($)
 372 {
 373         my $s = shift;
 374
 375         my $align = 1;
 376         for my $e (@{$s->{ELEMENTS}}) {
 377                 my $a = 1;
 378
 379                 if (need_wire_pointer($e)) {
 380                         $a = 4;
 381                 } else {
 382                         $a = align_type($e->{TYPE});
 383                 }
 384
 385                 $align = $a if ($align < $a);
 386         }
 387
 388         return $align;
 389 }
 390
 391 #####################################################################
 392 # align a type
 393 sub align_type
 394 {
 395         my $e = shift;
 396
 397         unless (typelist::hasType($e)) {
 398             # it must be an external type - all we can do is guess
 399                 # print "Warning: assuming alignment of unknown type '$e' is 4\n";
 400             return 4;
 401         }
 402
 403         my $dt = typelist::getType($e)->{DATA};
 404
 405         my $tmp = $typefamily{$dt->{TYPE}}->{ALIGN}->($dt);
 406         return $tmp;
 407 }
 408
 409 #####################################################################
 410 # see if a type contains any deferred data
 411 sub can_contain_deferred
 412 {
 413         my $e = shift;
 414
 415         return 1 if ($e->{POINTERS});
 416         return 0 if (is_scalar_type($e->{TYPE}));
 417         return 0 if (util::has_property($e, "subcontext"));
 418         return 1 unless (typelist::hasType($e->{TYPE})); # assume the worst
 419
 420         my $type = typelist::getType($e->{TYPE});
 421
 422         foreach my $x (@{$type->{DATA}->{ELEMENTS}}) {
 423                 return 1 if (can_contain_deferred ($x));
 424         }
 425
 426         return 0;
 427 }
 428
 429 #####################################################################
 430 # parse array preceding data - push side
 431 sub ParseArrayPushPreceding($$$)
 432 {
 433         my $e = shift;
 434         my $var_prefix = shift;
 435         my $ndr_flags = shift;
 436
 437         my $size = ParseExpr($e, util::array_size($e), $var_prefix);
 438
 439         if (!is_inline_array($e)) {
 440                 # we need to emit the array size
 441                 pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));";
 442         }
 443 }
 444
 445 #####################################################################
 446 # parse the data of an array - push side
 447 sub ParseArrayPush($$$$)
 448 {
 449         my $e = shift;
 450         my $ndr = shift;
 451         my $var_prefix = shift;
 452         my $ndr_flags = shift;
 453         my $cprefix = c_push_prefix($e);
 454
 455         my $size = ParseExpr($e, util::array_size($e), $var_prefix);
 456
 457         # See whether the array size has been pushed yet
 458         if (!is_surrounding_array($e)) {
 459                 ParseArrayPushPreceding($e, $var_prefix, $ndr_flags);
 460         }
 461
 462         if (is_varying_array($e)) {
 463                 my $length = util::has_property($e, "length_is");
 464                 $length = ParseExpr($e, $length, $var_prefix);
 465                 pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, 0));";
 466                 pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $length));";
 467                 $size = $length;
 468         }
 469
 470         if (is_scalar_type($e->{TYPE})) {
 471                 pidl "NDR_CHECK(ndr_push_array_$e->{TYPE}($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}, $size));";
 472         } else {
 473                 pidl "NDR_CHECK(ndr_push_array($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}, sizeof($cprefix$var_prefix$e->{NAME}\[0]), $size, (ndr_push_flags_fn_t)ndr_push_$e->{TYPE}));";
 474         }
 475 }
 476
 477 #####################################################################
 478 # print an array
 479 sub ParseArrayPrint($$)
 480 {
 481         my $e = shift;
 482         my $var_prefix = shift;
 483         my $size = ParseExpr($e, util::array_size($e), $var_prefix);
 484         my $cprefix = c_push_prefix($e);
 485
 486         if (is_varying_array($e)) {
 487                 $size = ParseExpr($e, util::has_property($e, "length_is"), $var_prefix);
 488         }
 489
 490         if (is_scalar_type($e->{TYPE})) {
 491                 pidl "ndr_print_array_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME}, $size);";
 492         } else {
 493                 pidl "ndr_print_array(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME}, sizeof($cprefix$var_prefix$e->{NAME}\[0]), $size, (ndr_print_fn_t)ndr_print_$e->{TYPE});";
 494         }
 495 }
 496
 497 #####################################################################
 498 # check the size_is and length_is constraints
 499 sub CheckArraySizes($$)
 500 {
 501         my $e = shift;
 502         my $var_prefix = shift;
 503
 504         if (is_conformant_array($e)) {
 505                 my $size = ParseExpr($e, util::array_size($e), $var_prefix);
 506                 pidl "if ($var_prefix$e->{NAME}) {";
 507                 indent;
 508                 check_null_pointer($size);
 509                 pidl "NDR_CHECK(ndr_check_array_size(ndr, (void*)&$var_prefix$e->{NAME}, $size));";
 510                 deindent;
 511                 pidl "}";
 512         }
 513
 514         if (is_varying_array($e)) {
 515                 my $length = util::has_property($e, "length_is");
 516                 $length = ParseExpr($e, $length, $var_prefix);
 517                 pidl "if ($var_prefix$e->{NAME}) {";
 518                 indent;
 519                 check_null_pointer($length);
 520                 pidl "NDR_CHECK(ndr_check_array_length(ndr, (void*)&$var_prefix$e->{NAME}, $length));";
 521                 deindent;
 522                 pidl "}"
 523         }
 524 }
 525
 526 sub ParseArrayPullPreceding($$$)
 527 {
 528         my $e = shift;
 529         my $var_prefix = shift;
 530         my $ndr_flags = shift;
 531
 532         if (!is_inline_array($e)) {
 533                 # non fixed arrays encode the size just before the array
 534                 pidl "NDR_CHECK(ndr_pull_array_size(ndr, &$var_prefix$e->{NAME}));";
 535         }
 536 }
 537
 538 #####################################################################
 539 # parse an array - pull side
 540 sub ParseArrayPull($$$$)
 541 {
 542         my $e = shift;
 543         my $ndr = shift;
 544         my $var_prefix = shift;
 545         my $ndr_flags = shift;
 546
 547         my $cprefix = c_pull_prefix($e);
 548         my $length = ParseExpr($e, util::array_size($e), $var_prefix);
 549         my $size = $length;
 550
 551         if (is_conformant_array($e)) {
 552                 $length = $size = "ndr_get_array_size($ndr, &$var_prefix$e->{NAME})";
 553         }
 554
 555         # if this is a conformant array then we use that size to allocate, and make sure
 556         # we allocate enough to pull the elements
 557         if (!is_inline_array($e) and not is_surrounding_array($e)) {
 558                 if ($var_prefix =~ /^r->out/ && $length =~ /^\*r->in/) {
 559                         my $length2 = substr($length, 1);
 560                         pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { NDR_ALLOC($ndr, $length2); }";
 561                 }
 562
 563                 ParseArrayPullPreceding($e, $var_prefix, $ndr_flags);
 564         }
 565
 566         if (is_varying_array($e)) {
 567                 pidl "NDR_CHECK(ndr_pull_array_length($ndr, &$var_prefix$e->{NAME}));";
 568                 $length = "ndr_get_array_length($ndr, &$var_prefix$e->{NAME})";
 569         }
 570
 571         check_null_pointer($length);
 572
 573         if ($length ne $size) {
 574                 pidl "if ($length > $size) {";
 575                 indent;
 576                 pidl "return ndr_pull_error($ndr, NDR_ERR_CONFORMANT_SIZE, \"Bad conformant size %u should be %u\", $size, $length);";
 577                 deindent;
 578                 pidl "}";
 579         }
 580
 581         if ((need_alloc($e) && !is_fixed_array($e)) ||
 582             ($var_prefix eq "r->in." && util::has_property($e, "ref"))) {
 583                 if (!is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
 584                         pidl "NDR_ALLOC_N($ndr, $var_prefix$e->{NAME}, $size);";
 585                 }
 586         }
 587
 588         if (($var_prefix eq "r->out." && util::has_property($e, "ref"))) {
 589                 if (!is_inline_array($e) || $ndr_flags eq "NDR_SCALARS") {
 590                         pidl "if ($ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
 591                         pidl "\tNDR_ALLOC_N($ndr, $var_prefix$e->{NAME}, $size);";
 592                         pidl "}";
 593                 }
 594         }
 595
 596         if (is_scalar_type($e->{TYPE})) {
 597                 pidl "NDR_CHECK(ndr_pull_array_$e->{TYPE}($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}, $length));";
 598         } else {
 599                 pidl "NDR_CHECK(ndr_pull_array($ndr, $ndr_flags, (void **)$cprefix$var_prefix$e->{NAME}, sizeof($cprefix$var_prefix$e->{NAME}\[0]), $length, (ndr_pull_flags_fn_t)ndr_pull_$e->{TYPE}));";
 600         }
 601 }
 602
 603 sub ParseSubcontextPushStart($$)
 604 {
 605         my $e = shift;
 606         my $ndr_flags = shift;
 607
 608         pidl "if (($ndr_flags) & NDR_SCALARS) {";
 609         indent;
 610         pidl "struct ndr_push *_ndr_$e->{NAME};";
 611         pidl "";
 612         pidl "_ndr_$e->{NAME} = ndr_push_init_ctx(ndr);";
 613         pidl "if (!_ndr_$e->{NAME}) return NT_STATUS_NO_MEMORY;";
 614         pidl "_ndr_$e->{NAME}->flags = ndr->flags;";
 615         pidl "";
 616
 617         return "_ndr_$e->{NAME}";
 618 }
 619
 620 sub ParseSubcontextPushEnd($)
 621 {
 622         my $e = shift;
 623         my $header_size = util::has_property($e, "subcontext");
 624         my $size_is = util::has_property($e, "subcontext_size");
 625
 626         if (not defined($size_is)) {
 627                 $size_is = "-1";
 628         }
 629
 630         pidl "NDR_CHECK(ndr_push_subcontext_header(ndr, $header_size, $size_is, _ndr_$e->{NAME}));";
 631         pidl "NDR_CHECK(ndr_push_bytes(ndr, _ndr_$e->{NAME}->data, _ndr_$e->{NAME}->offset));";
 632         deindent;
 633         pidl "}";
 634 }
 635
 636 sub ParseSubcontextPullStart($$)
 637 {
 638         my $e = shift;
 639         my $ndr_flags = shift;
 640         my $header_size = util::has_property($e, "subcontext");
 641         my $size_is = util::has_property($e, "subcontext_size");
 642
 643         if (not defined($size_is)) {
 644                 $size_is = "-1";
 645         }
 646
 647         pidl "if (($ndr_flags) & NDR_SCALARS) {";
 648         indent;
 649         pidl "struct ndr_pull *_ndr_$e->{NAME};";
 650         pidl "NDR_ALLOC(ndr, _ndr_$e->{NAME});";
 651         pidl "NDR_CHECK(ndr_pull_subcontext_header(ndr, $header_size, $size_is, _ndr_$e->{NAME}));";
 652         return "_ndr_$e->{NAME}";
 653 }
 654
 655 sub ParseSubcontextPullEnd($)
 656 {
 657         my $e = shift;
 658         my $header_size = util::has_property($e, "subcontext");
 659         my $size_is = util::has_property($e, "subcontext_size");
 660
 661         my $advance;
 662         if (defined ($size_is)) {
 663                 $advance = "$size_is";
 664         } elsif ($header_size) {
 665                 $advance = "_ndr_$e->{NAME}->data_size";
 666         } else {
 667                 $advance = "_ndr_$e->{NAME}->offset";
 668         }
 669         pidl "NDR_CHECK(ndr_pull_advance(ndr, $advance));";
 670         deindent;
 671         pidl "}";
 672 }
 673
 674 #####################################################################
 675 # parse scalars in a structure element
 676 sub ParseElementPushScalar($$$)
 677 {
 678         my($e) = shift;
 679         my($var_prefix) = shift;
 680         my($ndr_flags) = shift;
 681         my $cprefix = c_push_prefix($e);
 682         my $ptr_prefix = c_ptr_prefix($e);
 683         my $sub_size = util::has_property($e, "subcontext");
 684         my $ndr = "ndr";
 685
 686         start_flags($e);
 687
 688         if (my $value = util::has_property($e, "value")) {
 689                 pidl "$cprefix$var_prefix$e->{NAME} = $value;";
 690         }
 691
 692         if (defined $sub_size and $e->{POINTERS} == 0) {
 693                 $ndr = ParseSubcontextPushStart($e, "NDR_SCALARS");
 694         }
 695
 696         if (need_wire_pointer($e)) {
 697                 ParsePtrPush($e, $ptr_prefix.$var_prefix);
 698         } elsif (is_inline_array($e)) {
 699                 ParseArrayPush($e, $ndr, "r->", "NDR_SCALARS");
 700         } elsif (need_alloc($e)) {
 701                 # no scalar component
 702         } else {
 703                 if (my $switch = util::has_property($e, "switch_is")) {
 704                         ParseSwitchPush($e, $ndr, $var_prefix, $ndr_flags, $switch);
 705                 }
 706
 707                 pidl "NDR_CHECK(ndr_push_$e->{TYPE}($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));";
 708         }
 709
 710         if (defined $sub_size and $e->{POINTERS} == 0) {
 711                 ParseSubcontextPushEnd($e);
 712         }
 713
 714         end_flags($e);
 715 }
 716
 717 #####################################################################
 718 # parse a pointer in a struct element or function
 719 sub ParsePtrPush($$)
 720 {
 721         my $e = shift;
 722         my $var_prefix = shift;
 723
 724         if (util::has_property($e, "ref")) {
 725                 pidl "NDR_CHECK(ndr_push_ref_ptr(ndr, $var_prefix$e->{NAME}));";
 726         } elsif (util::has_property($e, "relative")) {
 727                 pidl "NDR_CHECK(ndr_push_relative_ptr1(ndr, $var_prefix$e->{NAME}));";
 728         } else {
 729                 pidl "NDR_CHECK(ndr_push_unique_ptr(ndr, $var_prefix$e->{NAME}));";
 730         }
 731 }
 732
 733 #####################################################################
 734 # print scalars in a structure element
 735 sub ParseElementPrint($$)
 736 {
 737         my($e) = shift;
 738         my($var_prefix) = shift;
 739         my $cprefix = c_push_prefix($e);
 740         my $ptr_prefix = c_ptr_prefix($e);
 741
 742         return if (util::has_property($e, "noprint"));
 743
 744         if (my $value = util::has_property($e, "value")) {
 745                 pidl "if (ndr->flags & LIBNDR_PRINT_SET_VALUES) {";
 746                 pidl "\t$cprefix$var_prefix$e->{NAME} = $value;";
 747                 pidl "}";
 748         }
 749
 750         my $l = $e->{POINTERS};
 751         $l++ if (util::array_size($e) and $l == 0 and !is_fixed_array($e));
 752
 753         foreach my $i (1..$l) {
 754                 pidl "ndr_print_ptr(ndr, \"$e->{NAME}\", $var_prefix$e->{NAME});";
 755                 pidl "ndr->depth++;";
 756                 if ($i > $l-need_wire_pointer($e)) {
 757                         pidl "if ($ptr_prefix$var_prefix$e->{NAME}) {";
 758                         indent;
 759                 }
 760         }
 761
 762         if (util::array_size($e)) {
 763                 ParseArrayPrint($e, $var_prefix)
 764         } elsif (my $switch = util::has_property($e, "switch_is")) {
 765                 my $switch_var = ParseExpr($e, $switch, $var_prefix);
 766                 check_null_pointer_void($switch_var);
 767
 768                 pidl "ndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $switch_var, $cprefix$var_prefix$e->{NAME});";
 769         } else {
 770                 pidl "ndr_print_$e->{TYPE}(ndr, \"$e->{NAME}\", $cprefix$var_prefix$e->{NAME});";
 771         }
 772
 773         foreach my $i (1..$l) {
 774                 if ($i > $l-need_wire_pointer($e)) {
 775                         deindent;
 776                         pidl "}";
 777                 }
 778                 pidl "ndr->depth--;";
 779         }
 780 }
 781
 782 #####################################################################
 783 # parse scalars in a structure element - pull size
 784 sub ParseSwitchPull($$$$$)
 785 {
 786         my($e) = shift;
 787         my $ndr = shift;
 788         my($var_prefix) = shift;
 789         my($ndr_flags) = shift;
 790         my $switch = shift;
 791         my $switch_var = ParseExpr($e, $switch, $var_prefix);
 792
 793         my $cprefix = c_pull_prefix($e);
 794
 795         my $utype = typelist::getType($e->{TYPE});
 796
 797         check_null_pointer($switch_var);
 798
 799         pidl "NDR_CHECK(ndr_pull_set_switch_value($ndr, $cprefix$var_prefix$e->{NAME}, $switch_var));";
 800
 801 }
 802
 803 #####################################################################
 804 # push switch element
 805 sub ParseSwitchPush($$$$$)
 806 {
 807         my($e) = shift;
 808         my $ndr = shift;
 809         my($var_prefix) = shift;
 810         my($ndr_flags) = shift;
 811         my $switch = shift;
 812         my $switch_var = ParseExpr($e, $switch, $var_prefix);
 813         my $cprefix = c_push_prefix($e);
 814
 815         check_null_pointer($switch_var);
 816
 817         pidl "NDR_CHECK(ndr_push_set_switch_value($ndr, $cprefix$var_prefix$e->{NAME}, $switch_var));";
 818
 819 }
 820
 821 #####################################################################
 822 # parse scalars in a structure element - pull size
 823 sub ParseElementPullScalar($$$)
 824 {
 825         my($e) = shift;
 826         my($var_prefix) = shift;
 827         my($ndr_flags) = shift;
 828         my $cprefix = c_pull_prefix($e);
 829         my $ptr_prefix = c_ptr_prefix($e);
 830         my $sub_size = util::has_property($e, "subcontext");
 831         my $ndr = "ndr";
 832
 833         start_flags($e);
 834
 835         if (defined $sub_size && $e->{POINTERS} == 0) {
 836                 $ndr = ParseSubcontextPullStart($e, $ndr_flags);
 837                 $ndr_flags = "NDR_SCALARS|NDR_BUFFERS";
 838         }
 839
 840         if (is_inline_array($e)) {
 841                 ParseArrayPull($e, $ndr, "r->", "NDR_SCALARS");
 842         } elsif (need_wire_pointer($e)) {
 843                 ParsePtrPull($e, $ptr_prefix.$var_prefix);
 844         } elsif (is_surrounding_array($e)) {
 845         } else {
 846                 if (my $switch = util::has_property($e, "switch_is")) {
 847                         ParseSwitchPull($e, $ndr, $var_prefix, $ndr_flags, $switch);
 848                 }
 849
 850                 pidl "NDR_CHECK(ndr_pull_$e->{TYPE}($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));";
 851         }
 852
 853         if (my $range = util::has_property($e, "range")) {
 854                 my ($low, $high) = split(/ /, $range, 2);
 855                 pidl "if ($var_prefix$e->{NAME} < $low || $var_prefix$e->{NAME} > $high) {";
 856                 pidl "\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value out of range\");";
 857                 pidl "}";
 858         }
 859
 860         if (defined $sub_size && $e->{POINTERS} == 0) {
 861                 ParseSubcontextPullEnd($e);
 862         }
 863
 864         end_flags($e);
 865 }
 866
 867 #####################################################################
 868 # parse a pointer in a struct element or function
 869 sub ParsePtrPull($$)
 870 {
 871         my($e) = shift;
 872         my($var_prefix) = shift;
 873
 874         if (util::has_property($e, "ref")) {
 875                 pidl "NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_$e->{NAME}));";
 876         } else {
 877                 pidl "NDR_CHECK(ndr_pull_unique_ptr(ndr, &_ptr_$e->{NAME}));";
 878         }
 879         pidl "if (_ptr_$e->{NAME}) {";
 880         indent;
 881         pidl "NDR_ALLOC(ndr, $var_prefix$e->{NAME});";
 882         if (util::has_property($e, "relative")) {
 883                 pidl "NDR_CHECK(ndr_pull_relative_ptr1(ndr, $var_prefix$e->{NAME}, _ptr_$e->{NAME}));";
 884         }
 885         deindent;
 886         pidl "} else {";
 887         pidl "\t$var_prefix$e->{NAME} = NULL;";
 888         pidl "}";
 889 }
 890
 891 #####################################################################
 892 # parse buffers in a structure element
 893 sub ParseElementPushBuffer($$)
 894 {
 895         my($e) = shift;
 896         my($var_prefix) = shift;
 897         my $cprefix = c_push_prefix($e);
 898         my $sub_size = util::has_property($e, "subcontext");
 899         my $ndr = "ndr";
 900
 901         return unless (need_buffers_section($e));
 902
 903         start_flags($e);
 904
 905         my $pointers = c_ptr_prefix($e);
 906         for my $i (1..need_wire_pointer($e)) {
 907                 if ($i > 1) {
 908                         ParsePtrPush($e,$pointers.$var_prefix);
 909                 }
 910                 pidl "if ($pointers$var_prefix$e->{NAME}) {";
 911                 indent;
 912                 $pointers.="*";
 913         }
 914
 915         if (util::has_property($e, "relative")) {
 916                 pidl "NDR_CHECK(ndr_push_relative_ptr2(ndr, $var_prefix$e->{NAME}));";
 917         }
 918
 919         my $ndr_flags = "NDR_BUFFERS";
 920         if ($e->{POINTERS} || (util::array_size($e) && !is_inline_array($e)))
 921         {
 922                 $ndr_flags="NDR_SCALARS|$ndr_flags"
 923         }
 924
 925         if (defined $sub_size) {
 926                 $ndr = ParseSubcontextPushStart($e, $ndr_flags);
 927                 $ndr_flags = "NDR_SCALARS|NDR_BUFFERS";
 928         }
 929
 930         if (util::array_size($e)) {
 931                 ParseArrayPush($e, $ndr, "r->", $ndr_flags);
 932         } else {
 933                 if (my $switch = util::has_property($e, "switch_is")) {
 934                         ParseSwitchPush($e, $ndr, $var_prefix, $ndr_flags, $switch);
 935                 }
 936
 937                 pidl "NDR_CHECK(ndr_push_$e->{TYPE}($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));";
 938         }
 939
 940         if (defined $sub_size) {
 941                 ParseSubcontextPushEnd($e);
 942         }
 943
 944         for my $i (1..need_wire_pointer($e)) {
 945                 deindent;
 946                 pidl "}";
 947         }
 948
 949         end_flags($e);
 950 }
 951
 952 #####################################################################
 953 # parse buffers in a structure element - pull side
 954 sub ParseElementPullBuffer($$)
 955 {
 956         my($e) = shift;
 957         my($var_prefix) = shift;
 958         my $cprefix = c_pull_prefix($e);
 959         my $sub_size = util::has_property($e, "subcontext");
 960         my $ndr = "ndr";
 961
 962         return unless (need_buffers_section($e));
 963
 964         start_flags($e);
 965
 966         my $pointers = c_ptr_prefix($e);
 967         for my $i (1..need_wire_pointer($e)) {
 968                 if ($i > 1) {
 969                         ParsePtrPull($e,$pointers.$var_prefix);
 970                 }
 971                 pidl "if ($pointers$var_prefix$e->{NAME}) {";
 972                 indent;
 973                 $pointers.="*";
 974         }
 975
 976         if (util::has_property($e, "relative")) {
 977                 pidl "struct ndr_pull_save _relative_save;";
 978                 pidl "ndr_pull_save(ndr, &_relative_save);";
 979                 pidl "NDR_CHECK(ndr_pull_relative_ptr2(ndr, $var_prefix$e->{NAME}));";
 980         }
 981
 982         my $ndr_flags = "NDR_BUFFERS";
 983         if ($e->{POINTERS} || (util::array_size($e) && !is_inline_array($e)))
 984         {
 985                 $ndr_flags="NDR_SCALARS|$ndr_flags"
 986         }
 987
 988         if (defined $sub_size) {
 989                 $ndr = ParseSubcontextPullStart($e, $ndr_flags);
 990                 $ndr_flags = "NDR_SCALARS|NDR_BUFFERS";
 991         }
 992
 993         if (util::array_size($e)) {
 994                 ParseArrayPull($e, $ndr, "r->", $ndr_flags);
 995         } else {
 996                 if (my $switch = util::has_property($e, "switch_is")) {
 997                         ParseSwitchPull($e, $ndr, $var_prefix, $ndr_flags, $switch);
 998                 }
 999
1000                 pidl "NDR_CHECK(ndr_pull_$e->{TYPE}($ndr, $ndr_flags, $cprefix$var_prefix$e->{NAME}));";
1001         }
1002
1003         if (defined $sub_size) {
1004                 ParseSubcontextPullEnd($e);
1005         }
1006
1007         if (util::has_property($e, "relative")) {
1008                 pidl "ndr_pull_restore(ndr, &_relative_save);";
1009         }
1010
1011         for my $i (1..need_wire_pointer($e)) {
1012                 deindent;
1013                 pidl "}";
1014         }
1015
1016         end_flags($e);
1017 }
1018
1019 #####################################################################
1020 # parse a struct
1021 sub ParseStructPush($)
1022 {
1023         my($struct) = shift;
1024
1025         return unless defined($struct->{ELEMENTS});
1026
1027         start_flags($struct);
1028
1029         # see if the structure contains a conformant array. If it
1030         # does, then it must be the last element of the structure, and
1031         # we need to push the conformant length early, as it fits on
1032         # the wire before the structure (and even before the structure
1033         # alignment)
1034         my $e = $struct->{ELEMENTS}[-1];
1035         if (is_conformant_array($e) and is_surrounding_array($e)) {
1036                 ParseArrayPushPreceding($e, "r->", "NDR_SCALARS");
1037         }
1038
1039         if (defined $e->{TYPE} && $e->{TYPE} eq "string"
1040             &&  util::property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) {
1041                 pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, r->$e->{NAME})));";
1042         }
1043
1044         pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;";
1045
1046         pidl "NDR_CHECK(ndr_push_struct_start(ndr));";
1047
1048         my $align = find_largest_alignment($struct);
1049         pidl "NDR_CHECK(ndr_push_align(ndr, $align));";
1050
1051         foreach my $e (@{$struct->{ELEMENTS}}) {
1052                 ParseElementPushScalar($e, "r->", "NDR_SCALARS");
1053         }
1054
1055         pidl "buffers:";
1056         pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;";
1057         foreach my $e (@{$struct->{ELEMENTS}}) {
1058                 ParseElementPushBuffer($e, "r->");
1059         }
1060
1061         pidl "ndr_push_struct_end(ndr);";
1062
1063         pidl "done:";
1064
1065         end_flags($struct);
1066 }
1067
1068 #####################################################################
1069 # generate a push function for an enum
1070 sub ParseEnumPush($)
1071 {
1072         my($enum) = shift;
1073         my($type_fn) = typelist::enum_type_fn($enum);
1074
1075         start_flags($enum);
1076
1077         pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));";
1078
1079         end_flags($enum);
1080 }
1081
1082 #####################################################################
1083 # generate a pull function for an enum
1084 sub ParseEnumPull($)
1085 {
1086         my($enum) = shift;
1087         my($type_fn) = typelist::enum_type_fn($enum);
1088         my($type_v_decl) = typelist::mapScalarType(typelist::enum_type_fn($enum));
1089
1090         pidl "$type_v_decl v;";
1091         start_flags($enum);
1092         pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));";
1093         pidl "*r = v;";
1094
1095         end_flags($enum);
1096 }
1097
1098 #####################################################################
1099 # generate a print function for an enum
1100 sub ParseEnumPrint($)
1101 {
1102         my($enum) = shift;
1103
1104         pidl "const char *val = NULL;";
1105         pidl "";
1106
1107         start_flags($enum);
1108
1109         pidl "switch (r) {";
1110         indent;
1111         my $els = \@{$enum->{ELEMENTS}};
1112         foreach my $i (0 .. $#{$els}) {
1113                 my $e = ${$els}[$i];
1114                 chomp $e;
1115                 if ($e =~ /^(.*)=/) {
1116                         $e = $1;
1117                 }
1118                 pidl "case $e: val = \"$e\"; break;";
1119         }
1120
1121         deindent;
1122         pidl "}";
1123
1124         pidl "ndr_print_enum(ndr, name, \"$enum->{TYPE}\", val, r);";
1125
1126         end_flags($enum);
1127 }
1128
1129 sub ArgsEnumPush($)
1130 {
1131         my $e = shift;
1132         return "struct ndr_push *ndr, int ndr_flags, enum $e->{NAME} r";
1133 }
1134
1135 sub ArgsEnumPrint($)
1136 {
1137         my $e = shift;
1138         return "struct ndr_print *ndr, const char *name, enum $e->{NAME} r";
1139 }
1140
1141 sub ArgsEnumPull($)
1142 {
1143         my $e = shift;
1144         return "struct ndr_pull *ndr, int ndr_flags, enum $e->{NAME} *r";
1145 }
1146
1147 $typefamily{ENUM} = {
1148         PUSH_FN_BODY => \&ParseEnumPush,
1149         PUSH_FN_ARGS => \&ArgsEnumPush,
1150         PULL_FN_BODY => \&ParseEnumPull,
1151         PULL_FN_ARGS => \&ArgsEnumPull,
1152         PRINT_FN_BODY => \&ParseEnumPrint,
1153         PRINT_FN_ARGS => \&ArgsEnumPrint,
1154         ALIGN => sub { return align_type(typelist::enum_type_fn(shift)); }
1155 };
1156
1157 #####################################################################
1158 # generate a push function for a bitmap
1159 sub ParseBitmapPush($)
1160 {
1161         my($bitmap) = shift;
1162         my($type_fn) = typelist::bitmap_type_fn($bitmap);
1163
1164         start_flags($bitmap);
1165
1166         pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));";
1167
1168         end_flags($bitmap);
1169 }
1170
1171 #####################################################################
1172 # generate a pull function for an bitmap
1173 sub ParseBitmapPull($)
1174 {
1175         my($bitmap) = shift;
1176         my($type_fn) = typelist::bitmap_type_fn($bitmap);
1177         my($type_decl) = typelist::mapType($bitmap);
1178
1179         pidl "$type_decl v;";
1180         start_flags($bitmap);
1181         pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));";
1182         pidl "*r = v;";
1183
1184         end_flags($bitmap);
1185 }
1186
1187 #####################################################################
1188 # generate a print function for an bitmap
1189 sub ParseBitmapPrintElement($$)
1190 {
1191         my($e) = shift;
1192         my($bitmap) = shift;
1193         my($type_decl) = typelist::mapType($bitmap);
1194         my($type_fn) = typelist::bitmap_type_fn($bitmap);
1195         my($name) = $bitmap->{PARENT}->{NAME};
1196         my($flag);
1197
1198         if ($e =~ /^(\w+) .*$/) {
1199                 $flag = "$1";
1200         } else {
1201                 die "Bitmap: \"$name\" invalid Flag: \"$e\"";
1202         }
1203
1204         pidl "ndr_print_bitmap_flag(ndr, sizeof($type_decl), \"$flag\", $flag, r);";
1205 }
1206
1207 #####################################################################
1208 # generate a print function for an bitmap
1209 sub ParseBitmapPrint($)
1210 {
1211         my($bitmap) = shift;
1212         my($type_decl) = typelist::mapType($bitmap);
1213         my($type_fn) = typelist::bitmap_type_fn($bitmap);
1214
1215         start_flags($bitmap);
1216
1217         pidl "ndr_print_$type_fn(ndr, name, r);";
1218
1219         pidl "ndr->depth++;";
1220         foreach my $e (@{$bitmap->{ELEMENTS}}) {
1221                 ParseBitmapPrintElement($e, $bitmap);
1222         }
1223         pidl "ndr->depth--;";
1224
1225         end_flags($bitmap);
1226 }
1227
1228 sub ArgsBitmapPush($)
1229 {
1230         my $e = shift;
1231         my $type_decl = typelist::mapType($e->{DATA});
1232         return "struct ndr_push *ndr, int ndr_flags, $type_decl r";
1233 }
1234
1235 sub ArgsBitmapPrint($)
1236 {
1237         my $e = shift;
1238         my $type_decl = typelist::mapType($e->{DATA});
1239         return "struct ndr_print *ndr, const char *name, $type_decl r";
1240 }
1241
1242 sub ArgsBitmapPull($)
1243 {
1244         my $e = shift;
1245         my $type_decl = typelist::mapType($e->{DATA});
1246         return "struct ndr_pull *ndr, int ndr_flags, $type_decl *r";
1247 }
1248
1249 $typefamily{BITMAP} = {
1250         PUSH_FN_BODY => \&ParseBitmapPush,
1251         PUSH_FN_ARGS => \&ArgsBitmapPush,
1252         PULL_FN_BODY => \&ParseBitmapPull,
1253         PULL_FN_ARGS => \&ArgsBitmapPull,
1254         PRINT_FN_BODY => \&ParseBitmapPrint,
1255         PRINT_FN_ARGS => \&ArgsBitmapPrint,
1256         ALIGN => sub { return align_type(typelist::bitmap_type_fn(shift)); }
1257 };
1258
1259 #####################################################################
1260 # generate a struct print function
1261 sub ParseStructPrint($)
1262 {
1263         my($struct) = shift;
1264         my($name) = $struct->{PARENT}->{NAME};
1265
1266         return unless defined $struct->{ELEMENTS};
1267
1268         pidl "ndr_print_struct(ndr, name, \"$name\");";
1269
1270         start_flags($struct);
1271
1272         pidl "ndr->depth++;";
1273         foreach my $e (@{$struct->{ELEMENTS}}) {
1274                 ParseElementPrint($e, "r->");
1275         }
1276         pidl "ndr->depth--;";
1277
1278         end_flags($struct);
1279 }
1280
1281 #####################################################################
1282 # parse a struct - pull side
1283 sub ParseStructPull($)
1284 {
1285         my($struct) = shift;
1286         my $conform_e;
1287
1288         return unless defined $struct->{ELEMENTS};
1289
1290         # see if the structure contains a conformant array. If it
1291         # does, then it must be the last element of the structure, and
1292         # we need to pull the conformant length early, as it fits on
1293         # the wire before the structure (and even before the structure
1294         # alignment)
1295         my $e = $struct->{ELEMENTS}[-1];
1296         if (is_conformant_array($e) and is_surrounding_array($e)) {
1297                 $conform_e = $e;
1298         }
1299
1300         if (defined $e->{TYPE} && $e->{TYPE} eq "string"
1301             &&  util::property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) {
1302                 $conform_e = $e;
1303         }
1304
1305         # declare any internal pointers we need
1306         foreach my $e (@{$struct->{ELEMENTS}}) {
1307                 if (need_wire_pointer($e)) {
1308                         pidl "uint32_t _ptr_$e->{NAME};";
1309                 }
1310         }
1311
1312         start_flags($struct);
1313
1314         pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;";
1315
1316         pidl "NDR_CHECK(ndr_pull_struct_start(ndr));";
1317
1318         if (defined $conform_e) {
1319                 ParseArrayPullPreceding($conform_e, "r->", "NDR_SCALARS");
1320         }
1321
1322         my $align = find_largest_alignment($struct);
1323         pidl "NDR_CHECK(ndr_pull_align(ndr, $align));";
1324
1325         foreach my $e (@{$struct->{ELEMENTS}}) {
1326                 ParseElementPullScalar($e, "r->", "NDR_SCALARS");
1327         }
1328
1329         pidl "buffers:\n";
1330         pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;";
1331         foreach my $e (@{$struct->{ELEMENTS}}) {
1332                 ParseElementPullBuffer($e, "r->");
1333         }
1334
1335         foreach my $e (@{$struct->{ELEMENTS}}) {
1336                 CheckArraySizes($e, "r->");
1337         }
1338
1339         pidl "ndr_pull_struct_end(ndr);";
1340
1341         pidl "done:";
1342
1343         end_flags($struct);
1344 }
1345
1346 #####################################################################
1347 # calculate size of ndr struct
1348 sub ParseStructNdrSize($)
1349 {
1350         my $t = shift;
1351         my $static = fn_prefix($t);
1352         my $sizevar;
1353
1354         if (my $flags = util::has_property($t, "flag")) {
1355                 pidl "flags |= $flags;";
1356         }
1357         pidl "return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});";
1358 }
1359
1360 sub ArgsStructPush($)
1361 {
1362         my $e = shift;
1363         return "struct ndr_push *ndr, int ndr_flags, struct $e->{NAME} *r";
1364 }
1365
1366 sub ArgsStructPrint($)
1367 {
1368         my $e = shift;
1369         return "struct ndr_print *ndr, const char *name, struct $e->{NAME} *r";
1370 }
1371
1372 sub ArgsStructPull($)
1373 {
1374         my $e = shift;
1375         return "struct ndr_pull *ndr, int ndr_flags, struct $e->{NAME} *r";
1376 }
1377
1378 sub ArgsStructNdrSize($)
1379 {
1380         my $d = shift;
1381         return "const struct $d->{NAME} *r, int flags";
1382 }
1383
1384 $typefamily{STRUCT} = {
1385         PUSH_FN_BODY => \&ParseStructPush,
1386         PUSH_FN_ARGS => \&ArgsStructPush,
1387         PULL_FN_BODY => \&ParseStructPull,
1388         PULL_FN_ARGS => \&ArgsStructPull,
1389         PRINT_FN_BODY => \&ParseStructPrint,
1390         PRINT_FN_ARGS => \&ArgsStructPrint,
1391         SIZE_FN_BODY => \&ParseStructNdrSize,
1392         SIZE_FN_ARGS => \&ArgsStructNdrSize,
1393         ALIGN => \&find_largest_alignment
1394 };
1395
1396 #####################################################################
1397 # calculate size of ndr struct
1398 sub ParseUnionNdrSize($)
1399 {
1400         my $t = shift;
1401         my $static = fn_prefix($t);
1402         my $sizevar;
1403
1404         if (my $flags = util::has_property($t, "flag")) {
1405                 pidl "flags |= $flags;";
1406         }
1407         pidl "return ndr_size_union(r, flags, level, (ndr_push_union_fn_t)ndr_push_$t->{NAME});";
1408 }
1409
1410 #####################################################################
1411 # parse a union - push side
1412 sub ParseUnionPush($)
1413 {
1414         my $e = shift;
1415         my $have_default = 0;
1416
1417         pidl "int level;";
1418
1419         start_flags($e);
1420
1421         pidl "level = ndr_push_get_switch_value(ndr, r);";
1422
1423         pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;";
1424
1425         if (!util::has_property($e, "nodiscriminant")) {
1426                 my $switch_type = util::has_property($e, "switch_type");
1427                 $switch_type = "uint32" unless  (defined ($switch_type));
1428                 pidl "NDR_CHECK(ndr_push_$switch_type(ndr, NDR_SCALARS, level));";
1429         }
1430
1431         pidl "NDR_CHECK(ndr_push_struct_start(ndr));";
1432
1433 #       my $align = union_alignment($e);
1434 #       pidl "NDR_CHECK(ndr_push_align(ndr, $align));";
1435
1436         pidl "switch (level) {";
1437         indent;
1438         foreach my $el (@{$e->{ELEMENTS}}) {
1439                 if (util::has_property($el, "default")) {
1440                         pidl "default:";
1441                         $have_default = 1;
1442                 } else {
1443                         pidl "case $el->{PROPERTIES}->{case}:";
1444
1445                 }
1446                 if ($el->{TYPE} ne "EMPTY") {
1447                         indent;
1448                         ParseElementPushScalar($el, "r->", "NDR_SCALARS");
1449                         deindent;
1450                 }
1451                 pidl "break;";
1452                 pidl "";
1453         }
1454         if (! $have_default) {
1455                 pidl "default:";
1456                 pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
1457         }
1458         deindent;
1459         pidl "}";
1460         pidl "buffers:";
1461         pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;";
1462         pidl "switch (level) {";
1463         indent;
1464         foreach my $el (@{$e->{ELEMENTS}}) {
1465                 if (util::has_property($el, "default")) {
1466                         pidl "default:";
1467                 } else {
1468                         pidl "case $el->{PROPERTIES}->{case}:";
1469                 }
1470                 if ($el->{TYPE} ne "EMPTY") {
1471                         indent;
1472                         ParseElementPushBuffer($el, "r->");
1473                         deindent;
1474                 }
1475                 pidl "break;";
1476                 pidl "";
1477         }
1478         if (! $have_default) {
1479                 pidl "default:";
1480                 pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
1481         }
1482         deindent;
1483         pidl "}";
1484         pidl "ndr_push_struct_end(ndr);";
1485         pidl "done:";
1486         end_flags($e);
1487 }
1488
1489 #####################################################################
1490 # print a union
1491 sub ParseUnionPrint($)
1492 {
1493         my $e = shift;
1494         my $have_default = 0;
1495         my($name) = $e->{PARENT}->{NAME};
1496
1497         pidl "ndr_print_union(ndr, name, level, \"$name\");";
1498         start_flags($e);
1499
1500         pidl "switch (level) {";
1501         indent;
1502         foreach my $el (@{$e->{ELEMENTS}}) {
1503                 if (util::has_property($el, "default")) {
1504                         $have_default = 1;
1505                         pidl "default:";
1506                 } else {
1507                         pidl "case $el->{PROPERTIES}->{case}:";
1508                 }
1509                 if ($el->{TYPE} ne "EMPTY") {
1510                         indent;
1511                         ParseElementPrint($el, "r->");
1512                         deindent;
1513                 }
1514                 pidl "break;";
1515                 pidl "";
1516         }
1517         if (! $have_default) {
1518                 pidl "default:";
1519                 pidl "\tndr_print_bad_level(ndr, name, level);";
1520         }
1521         deindent;
1522         pidl "}";
1523
1524         end_flags($e);
1525 }
1526
1527 #####################################################################
1528 # parse a union - pull side
1529 sub ParseUnionPull($)
1530 {
1531         my $e = shift;
1532         my $have_default = 0;
1533         my $switch_type = util::has_property($e, "switch_type");
1534         $switch_type = "uint32" unless defined($switch_type);
1535
1536         pidl "int level;";
1537         if (!util::has_property($e, "nodiscriminant")) {
1538                 if (typelist::typeIs($switch_type, "ENUM")) {
1539                         $switch_type = typelist::enum_type_fn(typelist::getType($switch_type));
1540                 }
1541                 pidl typelist::mapScalarType($switch_type) . " _level;";
1542         }
1543
1544         start_flags($e);
1545
1546         pidl "level = ndr_pull_get_switch_value(ndr, r);";
1547
1548         pidl "if (!(ndr_flags & NDR_SCALARS)) goto buffers;";
1549
1550         if (!util::has_property($e, "nodiscriminant")) {
1551                 pidl "NDR_CHECK(ndr_pull_$switch_type(ndr, NDR_SCALARS, &_level));";
1552                 pidl "if (_level != level) {";
1553                 pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u for $e->{PARENT}->{NAME}\", _level);";
1554                 pidl "}";
1555         }
1556
1557         pidl "NDR_CHECK(ndr_pull_struct_start(ndr));";
1558
1559 #       my $align = union_alignment($e);
1560 #       pidl "\tNDR_CHECK(ndr_pull_align(ndr, $align));\n";
1561
1562         pidl "switch (level) {";
1563         indent;
1564         foreach my $el (@{$e->{ELEMENTS}}) {
1565                 if (util::has_property($el, "default")) {
1566                         pidl "default: {";
1567                         $have_default = 1;
1568                 } else {
1569                         pidl "case $el->{PROPERTIES}->{case}: {";
1570                 }
1571                 if ($el->{TYPE} ne "EMPTY") {
1572                         indent;
1573                         if ($el->{POINTERS}) {
1574                                 pidl "uint32_t _ptr_$el->{NAME};";
1575                         }
1576                         ParseElementPullScalar($el, "r->", "NDR_SCALARS");
1577                         deindent;
1578                 }
1579                 pidl "break; }";
1580                 pidl "";
1581         }
1582         if (! $have_default) {
1583                 pidl "default:";
1584                 pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
1585         }
1586         deindent;
1587         pidl "}";
1588         pidl "buffers:";
1589         pidl "if (!(ndr_flags & NDR_BUFFERS)) goto done;";
1590         pidl "switch (level) {";
1591         indent;
1592         foreach my $el (@{$e->{ELEMENTS}}) {
1593                 if (util::has_property($el, "default")) {
1594                         pidl "default:";
1595                 } else {
1596                         pidl "case $el->{PROPERTIES}->{case}:";
1597                 }
1598                 if ($el->{TYPE} ne "EMPTY") {
1599                         indent;
1600                         ParseElementPullBuffer($el, "r->");
1601                         deindent;
1602                 }
1603                 pidl "break;";
1604                 pidl "";
1605         }
1606         if (! $have_default) {
1607                 pidl "default:";
1608                 pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
1609         }
1610         deindent;
1611         pidl "}";
1612         pidl "ndr_pull_struct_end(ndr);";
1613         pidl "done:";
1614         end_flags($e);
1615 }
1616
1617 sub ArgsUnionPush($)
1618 {
1619         my $e = shift;
1620         return "struct ndr_push *ndr, int ndr_flags, union $e->{NAME} *r";
1621 }
1622
1623 sub ArgsUnionPrint($)
1624 {
1625         my $e = shift;
1626         return "struct ndr_print *ndr, const char *name, int level, union $e->{NAME} *r";
1627 }
1628
1629 sub ArgsUnionPull($)
1630 {
1631         my $e = shift;
1632         return "struct ndr_pull *ndr, int ndr_flags, union $e->{NAME} *r";
1633 }
1634
1635 sub ArgsUnionNdrSize($)
1636 {
1637         my $d = shift;
1638         return "const union $d->{NAME} *r, uint32_t level, int flags";
1639 }
1640
1641 $typefamily{UNION} = {
1642         PUSH_FN_BODY => \&ParseUnionPush,
1643         PUSH_FN_ARGS => \&ArgsUnionPush,
1644         PULL_FN_BODY => \&ParseUnionPull,
1645         PULL_FN_ARGS => \&ArgsUnionPull,
1646         PRINT_FN_BODY => \&ParseUnionPrint,
1647         PRINT_FN_ARGS => \&ArgsUnionPrint,
1648         SIZE_FN_ARGS => \&ArgsUnionNdrSize,
1649         SIZE_FN_BODY => \&ParseUnionNdrSize,
1650         ALIGN => \&find_largest_alignment
1651 };
1652
1653 #####################################################################
1654 # parse a typedef - push side
1655 sub ParseTypedefPush($)
1656 {
1657         my($e) = shift;
1658         my $static = fn_prefix($e);
1659
1660         return unless needed::is_needed("push_$e->{NAME}");
1661
1662         my $args = $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_ARGS}->($e);
1663         pidl $static . "NTSTATUS ndr_push_$e->{NAME}($args)";
1664
1665         pidl "{";
1666         indent;
1667         $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($e->{DATA});
1668         pidl "return NT_STATUS_OK;";
1669         deindent;
1670         pidl "}";
1671         pidl "";;
1672 }
1673
1674
1675 #####################################################################
1676 # parse a typedef - pull side
1677 sub ParseTypedefPull($)
1678 {
1679         my($e) = shift;
1680         my $static = fn_prefix($e);
1681
1682         return unless needed::is_needed("pull_$e->{NAME}");
1683
1684         my $args = $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_ARGS}->($e);
1685
1686         pidl $static . "NTSTATUS ndr_pull_$e->{NAME}($args)";
1687
1688         pidl "{";
1689         indent;
1690         $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA});
1691         pidl "return NT_STATUS_OK;";
1692         deindent;
1693         pidl "}";
1694         pidl "";
1695 }
1696
1697 #####################################################################
1698 # parse a typedef - print side
1699 sub ParseTypedefPrint($)
1700 {
1701         my($e) = shift;
1702
1703         my $args = $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_ARGS}->($e);
1704
1705         return unless !util::has_property($e, "noprint");
1706
1707         pidl "void ndr_print_$e->{NAME}($args)";
1708         pidl "{";
1709         indent;
1710         $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA});
1711         deindent;
1712         pidl "}";
1713 }
1714
1715 #####################################################################
1716 ## calculate the size of a structure
1717 sub ParseTypedefNdrSize($)
1718 {
1719         my($t) = shift;
1720
1721         return unless needed::is_needed("ndr_size_$t->{NAME}");
1722
1723         my $tf = $typefamily{$t->{DATA}->{TYPE}};
1724         my $args = $tf->{SIZE_FN_ARGS}->($t);
1725
1726         pidl "size_t ndr_size_$t->{NAME}($args)";
1727         pidl "{";
1728         indent;
1729         $typefamily{$t->{DATA}->{TYPE}}->{SIZE_FN_BODY}->($t);
1730         deindent;
1731         pidl "}";
1732         pidl "";
1733 }
1734
1735 #####################################################################
1736 # parse a function - print side
1737 sub ParseFunctionPrint($)
1738 {
1739         my($fn) = shift;
1740
1741         return unless !util::has_property($fn, "noprint");
1742
1743         pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, struct $fn->{NAME} *r)";
1744         pidl "{";
1745         indent;
1746         pidl "ndr_print_struct(ndr, name, \"$fn->{NAME}\");";
1747         pidl "ndr->depth++;";
1748
1749         pidl "if (flags & NDR_SET_VALUES) {";
1750         pidl "\tndr->flags |= LIBNDR_PRINT_SET_VALUES;";
1751         pidl "}";
1752
1753         pidl "if (flags & NDR_IN) {";
1754         indent;
1755         pidl "ndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");";
1756         pidl "ndr->depth++;";
1757
1758         foreach my $e (@{$fn->{ELEMENTS}}) {
1759                 if (util::has_property($e, "in")) {
1760                         ParseElementPrint($e, "r->in.");
1761                 }
1762         }
1763         pidl "ndr->depth--;";
1764         deindent;
1765         pidl "}";
1766
1767         pidl "if (flags & NDR_OUT) {";
1768         indent;
1769         pidl "ndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");";
1770         pidl "ndr->depth++;";
1771         foreach my $e (@{$fn->{ELEMENTS}}) {
1772                 if (util::has_property($e, "out")) {
1773                         ParseElementPrint($e, "r->out.");
1774                 }
1775         }
1776         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1777                 my $cprefix = "&";
1778                 $cprefix = "" if (is_scalar_type($fn->{RETURN_TYPE})) ; # FIXME: Should really use util::c_push_prefix here
1779                 pidl "ndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", $cprefix"."r->out.result);";
1780         }
1781         pidl "ndr->depth--;";
1782         deindent;
1783         pidl "}";
1784
1785         pidl "ndr->depth--;";
1786         deindent;
1787         pidl "}";
1788         pidl "";
1789 }
1790
1791 #####################################################################
1792 # parse a function element
1793 sub ParseFunctionElementPush($$)
1794 {
1795         my $e = shift;
1796         my $inout = shift;
1797
1798         if (util::array_size($e)) {
1799                 if (need_wire_pointer($e)) {
1800                         ParsePtrPush($e, "r->$inout.");
1801                         pidl "if (r->$inout.$e->{NAME}) {";
1802                         indent;
1803                         ParseArrayPush($e, "ndr", "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1804                         deindent;
1805                         pidl "}";
1806                 } else {
1807                         ParseArrayPush($e, "ndr", "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1808                 }
1809         } else {
1810                 ParseElementPushScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1811                 if (need_wire_pointer($e)) {
1812                         ParseElementPushBuffer($e, "r->$inout.");
1813                 }
1814         }
1815 }
1816
1817 #####################################################################
1818 # parse a function
1819 sub ParseFunctionPush($)
1820 {
1821         my($fn) = shift;
1822         my $static = fn_prefix($fn);
1823
1824         return unless !util::has_property($fn, "nopush");
1825
1826         pidl $static . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, struct $fn->{NAME} *r)";
1827         pidl "{";
1828         indent;
1829
1830         pidl "if (!(flags & NDR_IN)) goto ndr_out;";
1831         pidl "";
1832
1833         foreach my $e (@{$fn->{ELEMENTS}}) {
1834                 if (util::has_property($e, "in")) {
1835                         if (util::has_property($e, "ref")) {
1836                                 check_null_pointer("*r->in.$e->{NAME}");
1837                         }
1838                         ParseFunctionElementPush($e, "in");
1839                 }
1840         }
1841
1842         pidl "ndr_out:";
1843         pidl "if (!(flags & NDR_OUT)) goto done;";
1844         pidl "";
1845
1846         foreach my $e (@{$fn->{ELEMENTS}}) {
1847                 if (util::has_property($e, "out")) {
1848                         if (util::has_property($e, "ref")) {
1849                                 check_null_pointer("*r->out.$e->{NAME}");
1850                         }
1851                         ParseFunctionElementPush($e, "out");
1852                 }
1853         }
1854
1855         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
1856                 pidl "NDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, r->out.result));";
1857         }
1858
1859         pidl "done:";
1860         pidl "return NT_STATUS_OK;";
1861         deindent;
1862         pidl "}";
1863         pidl "";
1864 }
1865
1866 #####################################################################
1867 # parse a function element
1868 sub ParseFunctionElementPull($$)
1869 {
1870         my $e = shift;
1871         my $inout = shift;
1872
1873         if (util::array_size($e)) {
1874                 if (need_wire_pointer($e)) {
1875                         pidl "NDR_CHECK(ndr_pull_unique_ptr(ndr, &_ptr_$e->{NAME}));";
1876                         pidl "r->$inout.$e->{NAME} = NULL;";
1877                         pidl "if (_ptr_$e->{NAME}) {";
1878                         indent;
1879                 } elsif ($inout eq "out" && util::has_property($e, "ref")) {
1880                         pidl "if (r->$inout.$e->{NAME}) {";
1881                         indent;
1882                 }
1883
1884                 ParseArrayPull($e, "ndr", "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1885
1886                 if (need_wire_pointer($e) or ($inout eq "out" and util::has_property($e, "ref"))) {
1887                         deindent;
1888                         pidl "}";
1889                 }
1890         } else {
1891                 if ($inout eq "out" && util::has_property($e, "ref")) {
1892                         pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
1893                         pidl "\tNDR_ALLOC(ndr, r->out.$e->{NAME});";
1894                         pidl "}";
1895                 }
1896
1897                 if ($inout eq "in" && util::has_property($e, "ref")) {
1898                         pidl "NDR_ALLOC(ndr, r->in.$e->{NAME});";
1899                 }
1900
1901                 ParseElementPullScalar($e, "r->$inout.", "NDR_SCALARS|NDR_BUFFERS");
1902                 if (need_wire_pointer($e)) {
1903                         ParseElementPullBuffer($e, "r->$inout.");
1904                 }
1905         }
1906 }
1907
1908 ############################################################
1909 # allocate ref variables
1910 sub AllocateRefVars($)
1911 {
1912         my $e = shift;
1913         my $asize = util::array_size($e);
1914
1915         # note that if the variable is also an "in"
1916         # variable then we copy the initial value from
1917         # the in side
1918
1919         if (!defined $asize) {
1920                 # its a simple variable
1921                 pidl "NDR_ALLOC(ndr, r->out.$e->{NAME});";
1922                 if (util::has_property($e, "in")) {
1923                         pidl "*r->out.$e->{NAME} = *r->in.$e->{NAME};";
1924                 } else {
1925                         pidl "ZERO_STRUCTP(r->out.$e->{NAME});";
1926                 }
1927                 return;
1928         }
1929
1930         # its an array
1931         my $size = ParseExpr($e, $asize, "r->out.");
1932         check_null_pointer($size);
1933         pidl "NDR_ALLOC_N(ndr, r->out.$e->{NAME}, $size);";
1934         if (util::has_property($e, "in")) {
1935                 pidl "memcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));";
1936         } else {
1937                 pidl "memset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));";
1938         }
1939 }
1940
1941 #####################################################################
1942 # parse a function
1943 sub ParseFunctionPull($)
1944 {
1945         my($fn) = shift;
1946         my $static = fn_prefix($fn);
1947
1948         return unless !util::has_property($fn, "nopull");
1949
1950         # pull function args
1951         pidl $static . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)";
1952         pidl "{";
1953         indent;
1954
1955         # declare any internal pointers we need
1956         foreach my $e (@{$fn->{ELEMENTS}}) {
1957                 if (need_wire_pointer($e)) {
1958                         pidl "uint32_t _ptr_$e->{NAME};";
1959                 }
1960         }
1961
1962         pidl "if (!(flags & NDR_IN)) goto ndr_out;";
1963         pidl "";
1964
1965         # auto-init the out section of a structure. I originally argued that
1966         # this was a bad idea as it hides bugs, but coping correctly
1967         # with initialisation and not wiping ref vars is turning
1968         # out to be too tricky (tridge)
1969         foreach my $e (@{$fn->{ELEMENTS}}) {
1970                 if (util::has_property($e, "out")) {
1971                         pidl "ZERO_STRUCT(r->out);";
1972                         pidl "";
1973                         last;
1974                 }
1975         }
1976
1977         foreach my $e (@{$fn->{ELEMENTS}}) {
1978                 if (util::has_property($e, "in")) {
1979                         ParseFunctionElementPull($e, "in");
1980                 }
1981                 # we need to allocate any reference output variables, so that
1982                 # a dcerpc backend can be sure they are non-null
1983                 if (util::has_property($e, "out") && util::has_property($e, "ref")) {
1984                         AllocateRefVars($e);
1985                 }
1986         }
1987
1988         foreach my $e (@{$fn->{ELEMENTS}}) {
1989                 if (util::has_property($e, "in")) {
1990                         CheckArraySizes($e, "r->in.");
1991                 }
1992         }
1993
1994         pidl "ndr_out:";
1995         pidl "if (!(flags & NDR_OUT)) goto done;";
1996         pidl "";
1997
1998         foreach my $e (@{$fn->{ELEMENTS}}) {
1999                 if (util::has_property($e, "out")) {
2000                         ParseFunctionElementPull($e, "out");
2001                 }
2002         }
2003
2004         foreach my $e (@{$fn->{ELEMENTS}}) {
2005                 if (util::has_property($e, "out")) {
2006                         CheckArraySizes($e, "r->out.");
2007                 }
2008         }
2009
2010         if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
2011                 pidl "NDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, &r->out.result));";
2012         }
2013
2014         pidl "done:";
2015         pidl "";
2016         pidl "return NT_STATUS_OK;";
2017         deindent;
2018         pidl "}";
2019         pidl "";
2020 }
2021
2022 #####################################################################
2023 # produce a function call table
2024 sub FunctionTable($)
2025 {
2026         my($interface) = shift;
2027         my($data) = $interface->{INHERITED_DATA};
2028         my $count = 0;
2029         my $uname = uc $interface->{NAME};
2030
2031         foreach my $d (@{$data}) {
2032                 if ($d->{TYPE} eq "FUNCTION") { $count++; }
2033         }
2034
2035         return if ($count == 0);
2036
2037         pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {";
2038         foreach my $d (@{$data}) {
2039                 if ($d->{TYPE} eq "FUNCTION") {
2040                         pidl "\t{";
2041                         pidl "\t\t\"$d->{NAME}\",";
2042                         pidl "\t\tsizeof(struct $d->{NAME}),";
2043                         pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},";
2044                         pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},";
2045                         pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME}";
2046                         pidl "\t},";
2047                 }
2048         }
2049         pidl "\t{ NULL, 0, NULL, NULL, NULL }";
2050         pidl "};";
2051         pidl "";
2052
2053         # If no endpoint is set, default to the interface name as a named pipe
2054         if (! defined $interface->{PROPERTIES}->{endpoint}) {
2055                 $interface->{PROPERTIES}->{endpoint} = "\"ncacn_np:[\\\\pipe\\\\" . $interface->{NAME} . "]\"";
2056         }
2057
2058         my @e = split / /, $interface->{PROPERTIES}->{endpoint};
2059         my $endpoint_count = $#e + 1;
2060
2061         pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {";
2062         foreach my $ep (@e) {
2063                 pidl "\t$ep, ";
2064         }
2065         pidl "};";
2066         pidl "";
2067
2068         pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {";
2069         pidl "\t.count\t= $endpoint_count,";
2070         pidl "\t.names\t= $interface->{NAME}\_endpoint_strings";
2071         pidl "};";
2072         pidl "";
2073
2074         if (! defined $interface->{PROPERTIES}->{authservice}) {
2075                 $interface->{PROPERTIES}->{authservice} = "\"host\"";
2076         }
2077
2078         my @a = split / /, $interface->{PROPERTIES}->{authservice};
2079         my $authservice_count = $#a + 1;
2080
2081         pidl "static const char * const $interface->{NAME}\_authservice_strings[] = {";
2082         foreach my $ap (@a) {
2083                 pidl "\t$ap, ";
2084         }
2085         pidl "};";
2086         pidl "";
2087
2088         pidl "static const struct dcerpc_authservice_list $interface->{NAME}\_authservices = {";
2089         pidl "\t.count\t= $endpoint_count,";
2090         pidl "\t.names\t= $interface->{NAME}\_authservice_strings";
2091         pidl "};";
2092         pidl "";
2093
2094         pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {";
2095         pidl "\t.name\t\t= \"$interface->{NAME}\",";
2096         pidl "\t.uuid\t\t= DCERPC_$uname\_UUID,";
2097         pidl "\t.if_version\t= DCERPC_$uname\_VERSION,";
2098         pidl "\t.helpstring\t= DCERPC_$uname\_HELPSTRING,";
2099         pidl "\t.num_calls\t= $count,";
2100         pidl "\t.calls\t\t= $interface->{NAME}\_calls,";
2101         pidl "\t.endpoints\t= &$interface->{NAME}\_endpoints,";
2102         pidl "\t.authservices\t= &$interface->{NAME}\_authservices";
2103         pidl "};";
2104         pidl "";
2105
2106         pidl "static NTSTATUS dcerpc_ndr_$interface->{NAME}_init(void)";
2107         pidl "{";
2108         pidl "\treturn librpc_register_interface(&dcerpc_table_$interface->{NAME});";
2109         pidl "}";
2110         pidl "";
2111 }
2112
2113 #####################################################################
2114 # parse the interface definitions
2115 sub ParseInterface($)
2116 {
2117         my($interface) = shift;
2118         my($data) = $interface->{DATA};
2119
2120         # Push functions
2121         foreach my $d (@{$data}) {
2122                 ($d->{TYPE} eq "TYPEDEF") &&
2123                     ParseTypedefPush($d);
2124                 ($d->{TYPE} eq "FUNCTION") &&
2125                     ParseFunctionPush($d);
2126         }
2127
2128         # Pull functions
2129         foreach my $d (@{$data}) {
2130                 ($d->{TYPE} eq "TYPEDEF") &&
2131                     ParseTypedefPull($d);
2132                 ($d->{TYPE} eq "FUNCTION") &&
2133                     ParseFunctionPull($d);
2134         }
2135
2136         # Print functions
2137         foreach my $d (@{$data}) {
2138                 ($d->{TYPE} eq "TYPEDEF") &&
2139                         ParseTypedefPrint($d);
2140                 ($d->{TYPE} eq "FUNCTION") &&
2141                         ParseFunctionPrint($d);
2142         }
2143
2144         # Size functions
2145         foreach my $d (@{$data}) {
2146                 ($d->{TYPE} eq "TYPEDEF") &&
2147                         ParseTypedefNdrSize($d);
2148         }
2149
2150         FunctionTable($interface);
2151 }
2152
2153 sub RegistrationFunction($$)
2154 {
2155         my $idl = shift;
2156         my $filename = shift;
2157
2158         $filename =~ /.*\/ndr_(.*).c/;
2159         my $basename = $1;
2160         pidl "NTSTATUS dcerpc_$basename\_init(void)";
2161         pidl "{";
2162         indent;
2163         pidl "NTSTATUS status = NT_STATUS_OK;";
2164         foreach my $interface (@{$idl}) {
2165                 next if $interface->{TYPE} ne "INTERFACE";
2166
2167                 my $data = $interface->{INHERITED_DATA};
2168                 my $count = 0;
2169                 foreach my $d (@{$data}) {
2170                         if ($d->{TYPE} eq "FUNCTION") { $count++; }
2171                 }
2172
2173                 next if ($count == 0);
2174
2175                 pidl "status = dcerpc_ndr_$interface->{NAME}_init();";
2176                 pidl "if (NT_STATUS_IS_ERR(status)) {";
2177                 pidl "\treturn status;";
2178                 pidl "}";
2179                 pidl "";
2180         }
2181         pidl "return status;";
2182         deindent;
2183         pidl "}";
2184         pidl "";
2185 }
2186
2187 sub CheckPointerTypes($$)
2188 {
2189         my $s = shift;
2190         my $default = shift;
2191
2192         foreach my $e (@{$s->{ELEMENTS}}) {
2193                 if ($e->{POINTERS}) {
2194                         if (not defined(pointer_type($e))) {
2195                                 $e->{PROPERTIES}->{$default} = 1;
2196                         }
2197
2198                         if (pointer_type($e) eq "ptr") {
2199                                 print "Warning: ptr is not supported by pidl yet\n";
2200                         }
2201                 }
2202         }
2203 }
2204
2205 sub LoadInterface($)
2206 {
2207         my $x = shift;
2208
2209         if (not util::has_property($x, "pointer_default")) {
2210                 # MIDL defaults to "ptr" in DCE compatible mode (/osf)
2211                 # and "unique" in Microsoft Extensions mode (default)
2212                 $x->{PROPERTIES}->{pointer_default} = "unique";
2213         }
2214
2215         foreach my $d (@{$x->{DATA}}) {
2216                 if (($d->{TYPE} eq "DECLARE") or ($d->{TYPE} eq "TYPEDEF")) {
2217                         if ($d->{DATA}->{TYPE} eq "STRUCT" or $d->{DATA}->{TYPE} eq "UNION") {
2218                                 CheckPointerTypes($d->{DATA}, $x->{PROPERTIES}->{pointer_default});
2219                         }
2220
2221                         if (defined($d->{PROPERTIES}) && !defined($d->{DATA}->{PROPERTIES})) {
2222                                 $d->{DATA}->{PROPERTIES} = $d->{PROPERTIES};
2223                         }
2224                 }
2225                 if ($d->{TYPE} eq "FUNCTION") {
2226                         CheckPointerTypes($d,
2227                                 $x->{PROPERTIES}->{pointer_default}  # MIDL defaults to "ref"
2228                         );
2229                 }
2230         }
2231 }
2232
2233 sub Load($)
2234 {
2235         my $idl = shift;
2236
2237         foreach my $x (@{$idl}) {
2238                 LoadInterface($x);
2239         }
2240 }
2241
2242 #####################################################################
2243 # parse a parsed IDL structure back into an IDL file
2244 sub Parse($$)
2245 {
2246         my($idl) = shift;
2247         my($filename) = shift;
2248         my $h_filename = $filename;
2249         $res = "";
2250
2251         Load($idl);
2252
2253         if ($h_filename =~ /(.*)\.c/) {
2254                 $h_filename = "$1.h";
2255         }
2256
2257         pidl "/* parser auto-generated by pidl */";
2258         pidl "";
2259         pidl "#include \"includes.h\"";
2260         pidl "#include \"$h_filename\"";
2261         pidl "";
2262
2263         foreach my $x (@{$idl}) {
2264                 if ($x->{TYPE} eq "INTERFACE") {
2265                         needed::BuildNeeded($x);
2266                         ParseInterface($x);
2267                 }
2268         }
2269
2270         RegistrationFunction($idl, $filename);
2271
2272         return $res;
2273 }
2274
2275 1;