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