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