librpc/gen_ndr/srv_spoolss.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * server auto-generated by pidl. DO NOT MODIFY!
   4  */
   5
   6 #include "includes.h"
   7 #include "../librpc/gen_ndr/srv_spoolss.h"
   8
   9 static bool api_spoolss_EnumPrinters(pipes_struct *p)
  10 {
  11         const struct ndr_interface_call *call;
  12         struct ndr_pull *pull;
  13         struct ndr_push *push;
  14         enum ndr_err_code ndr_err;
  15         DATA_BLOB blob;
  16         struct spoolss_EnumPrinters *r;
  17
  18         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPRINTERS];
  19
  20         r = talloc(talloc_tos(), struct spoolss_EnumPrinters);
  21         if (r == NULL) {
  22                 return false;
  23         }
  24
  25         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
  26                 talloc_free(r);
  27                 return false;
  28         }
  29
  30         pull = ndr_pull_init_blob(&blob, r, NULL);
  31         if (pull == NULL) {
  32                 talloc_free(r);
  33                 return false;
  34         }
  35
  36         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
  37         ndr_err = call->ndr_pull(pull, NDR_IN, r);
  38         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  39                 talloc_free(r);
  40                 return false;
  41         }
  42
  43         if (DEBUGLEVEL >= 10) {
  44                 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinters, r);
  45         }
  46
  47         ZERO_STRUCT(r->out);
  48         r->out.count = talloc_zero(r, uint32_t);
  49         if (r->out.count == NULL) {
  50                 talloc_free(r);
  51                 return false;
  52         }
  53
  54         r->out.info = talloc_zero(r, union spoolss_PrinterInfo *);
  55         if (r->out.info == NULL) {
  56                 talloc_free(r);
  57                 return false;
  58         }
  59
  60         r->out.needed = talloc_zero(r, uint32_t);
  61         if (r->out.needed == NULL) {
  62                 talloc_free(r);
  63                 return false;
  64         }
  65
  66         r->out.result = _spoolss_EnumPrinters(p, r);
  67
  68         if (p->rng_fault_state) {
  69                 talloc_free(r);
  70                 /* Return true here, srv_pipe_hnd.c will take care */
  71                 return true;
  72         }
  73
  74         if (DEBUGLEVEL >= 10) {
  75                 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinters, r);
  76         }
  77
  78         push = ndr_push_init_ctx(r, NULL);
  79         if (push == NULL) {
  80                 talloc_free(r);
  81                 return false;
  82         }
  83
  84         ndr_err = call->ndr_push(push, NDR_OUT, r);
  85         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  86                 talloc_free(r);
  87                 return false;
  88         }
  89
  90         blob = ndr_push_blob(push);
  91         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
  92                 talloc_free(r);
  93                 return false;
  94         }
  95
  96         talloc_free(r);
  97
  98         return true;
  99 }
 100
 101 static bool api_spoolss_OpenPrinter(pipes_struct *p)
 102 {
 103         const struct ndr_interface_call *call;
 104         struct ndr_pull *pull;
 105         struct ndr_push *push;
 106         enum ndr_err_code ndr_err;
 107         DATA_BLOB blob;
 108         struct spoolss_OpenPrinter *r;
 109
 110         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_OPENPRINTER];
 111
 112         r = talloc(talloc_tos(), struct spoolss_OpenPrinter);
 113         if (r == NULL) {
 114                 return false;
 115         }
 116
 117         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 118                 talloc_free(r);
 119                 return false;
 120         }
 121
 122         pull = ndr_pull_init_blob(&blob, r, NULL);
 123         if (pull == NULL) {
 124                 talloc_free(r);
 125                 return false;
 126         }
 127
 128         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 129         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 130         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 131                 talloc_free(r);
 132                 return false;
 133         }
 134
 135         if (DEBUGLEVEL >= 10) {
 136                 NDR_PRINT_IN_DEBUG(spoolss_OpenPrinter, r);
 137         }
 138
 139         ZERO_STRUCT(r->out);
 140         r->out.handle = talloc_zero(r, struct policy_handle);
 141         if (r->out.handle == NULL) {
 142                 talloc_free(r);
 143                 return false;
 144         }
 145
 146         r->out.result = _spoolss_OpenPrinter(p, r);
 147
 148         if (p->rng_fault_state) {
 149                 talloc_free(r);
 150                 /* Return true here, srv_pipe_hnd.c will take care */
 151                 return true;
 152         }
 153
 154         if (DEBUGLEVEL >= 10) {
 155                 NDR_PRINT_OUT_DEBUG(spoolss_OpenPrinter, r);
 156         }
 157
 158         push = ndr_push_init_ctx(r, NULL);
 159         if (push == NULL) {
 160                 talloc_free(r);
 161                 return false;
 162         }
 163
 164         ndr_err = call->ndr_push(push, NDR_OUT, r);
 165         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 166                 talloc_free(r);
 167                 return false;
 168         }
 169
 170         blob = ndr_push_blob(push);
 171         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 172                 talloc_free(r);
 173                 return false;
 174         }
 175
 176         talloc_free(r);
 177
 178         return true;
 179 }
 180
 181 static bool api_spoolss_SetJob(pipes_struct *p)
 182 {
 183         const struct ndr_interface_call *call;
 184         struct ndr_pull *pull;
 185         struct ndr_push *push;
 186         enum ndr_err_code ndr_err;
 187         DATA_BLOB blob;
 188         struct spoolss_SetJob *r;
 189
 190         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_SETJOB];
 191
 192         r = talloc(talloc_tos(), struct spoolss_SetJob);
 193         if (r == NULL) {
 194                 return false;
 195         }
 196
 197         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 198                 talloc_free(r);
 199                 return false;
 200         }
 201
 202         pull = ndr_pull_init_blob(&blob, r, NULL);
 203         if (pull == NULL) {
 204                 talloc_free(r);
 205                 return false;
 206         }
 207
 208         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 209         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 210         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 211                 talloc_free(r);
 212                 return false;
 213         }
 214
 215         if (DEBUGLEVEL >= 10) {
 216                 NDR_PRINT_IN_DEBUG(spoolss_SetJob, r);
 217         }
 218
 219         r->out.result = _spoolss_SetJob(p, r);
 220
 221         if (p->rng_fault_state) {
 222                 talloc_free(r);
 223                 /* Return true here, srv_pipe_hnd.c will take care */
 224                 return true;
 225         }
 226
 227         if (DEBUGLEVEL >= 10) {
 228                 NDR_PRINT_OUT_DEBUG(spoolss_SetJob, r);
 229         }
 230
 231         push = ndr_push_init_ctx(r, NULL);
 232         if (push == NULL) {
 233                 talloc_free(r);
 234                 return false;
 235         }
 236
 237         ndr_err = call->ndr_push(push, NDR_OUT, r);
 238         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 239                 talloc_free(r);
 240                 return false;
 241         }
 242
 243         blob = ndr_push_blob(push);
 244         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 245                 talloc_free(r);
 246                 return false;
 247         }
 248
 249         talloc_free(r);
 250
 251         return true;
 252 }
 253
 254 static bool api_spoolss_GetJob(pipes_struct *p)
 255 {
 256         const struct ndr_interface_call *call;
 257         struct ndr_pull *pull;
 258         struct ndr_push *push;
 259         enum ndr_err_code ndr_err;
 260         DATA_BLOB blob;
 261         struct spoolss_GetJob *r;
 262
 263         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETJOB];
 264
 265         r = talloc(talloc_tos(), struct spoolss_GetJob);
 266         if (r == NULL) {
 267                 return false;
 268         }
 269
 270         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 271                 talloc_free(r);
 272                 return false;
 273         }
 274
 275         pull = ndr_pull_init_blob(&blob, r, NULL);
 276         if (pull == NULL) {
 277                 talloc_free(r);
 278                 return false;
 279         }
 280
 281         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 282         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 283         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 284                 talloc_free(r);
 285                 return false;
 286         }
 287
 288         if (DEBUGLEVEL >= 10) {
 289                 NDR_PRINT_IN_DEBUG(spoolss_GetJob, r);
 290         }
 291
 292         ZERO_STRUCT(r->out);
 293         r->out.info = talloc_zero(r, union spoolss_JobInfo);
 294         if (r->out.info == NULL) {
 295                 talloc_free(r);
 296                 return false;
 297         }
 298
 299         r->out.needed = talloc_zero(r, uint32_t);
 300         if (r->out.needed == NULL) {
 301                 talloc_free(r);
 302                 return false;
 303         }
 304
 305         r->out.result = _spoolss_GetJob(p, r);
 306
 307         if (p->rng_fault_state) {
 308                 talloc_free(r);
 309                 /* Return true here, srv_pipe_hnd.c will take care */
 310                 return true;
 311         }
 312
 313         if (DEBUGLEVEL >= 10) {
 314                 NDR_PRINT_OUT_DEBUG(spoolss_GetJob, r);
 315         }
 316
 317         push = ndr_push_init_ctx(r, NULL);
 318         if (push == NULL) {
 319                 talloc_free(r);
 320                 return false;
 321         }
 322
 323         ndr_err = call->ndr_push(push, NDR_OUT, r);
 324         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 325                 talloc_free(r);
 326                 return false;
 327         }
 328
 329         blob = ndr_push_blob(push);
 330         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 331                 talloc_free(r);
 332                 return false;
 333         }
 334
 335         talloc_free(r);
 336
 337         return true;
 338 }
 339
 340 static bool api_spoolss_EnumJobs(pipes_struct *p)
 341 {
 342         const struct ndr_interface_call *call;
 343         struct ndr_pull *pull;
 344         struct ndr_push *push;
 345         enum ndr_err_code ndr_err;
 346         DATA_BLOB blob;
 347         struct spoolss_EnumJobs *r;
 348
 349         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMJOBS];
 350
 351         r = talloc(talloc_tos(), struct spoolss_EnumJobs);
 352         if (r == NULL) {
 353                 return false;
 354         }
 355
 356         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 357                 talloc_free(r);
 358                 return false;
 359         }
 360
 361         pull = ndr_pull_init_blob(&blob, r, NULL);
 362         if (pull == NULL) {
 363                 talloc_free(r);
 364                 return false;
 365         }
 366
 367         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 368         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 369         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 370                 talloc_free(r);
 371                 return false;
 372         }
 373
 374         if (DEBUGLEVEL >= 10) {
 375                 NDR_PRINT_IN_DEBUG(spoolss_EnumJobs, r);
 376         }
 377
 378         ZERO_STRUCT(r->out);
 379         r->out.count = talloc_zero(r, uint32_t);
 380         if (r->out.count == NULL) {
 381                 talloc_free(r);
 382                 return false;
 383         }
 384
 385         r->out.info = talloc_zero(r, union spoolss_JobInfo *);
 386         if (r->out.info == NULL) {
 387                 talloc_free(r);
 388                 return false;
 389         }
 390
 391         r->out.needed = talloc_zero(r, uint32_t);
 392         if (r->out.needed == NULL) {
 393                 talloc_free(r);
 394                 return false;
 395         }
 396
 397         r->out.result = _spoolss_EnumJobs(p, r);
 398
 399         if (p->rng_fault_state) {
 400                 talloc_free(r);
 401                 /* Return true here, srv_pipe_hnd.c will take care */
 402                 return true;
 403         }
 404
 405         if (DEBUGLEVEL >= 10) {
 406                 NDR_PRINT_OUT_DEBUG(spoolss_EnumJobs, r);
 407         }
 408
 409         push = ndr_push_init_ctx(r, NULL);
 410         if (push == NULL) {
 411                 talloc_free(r);
 412                 return false;
 413         }
 414
 415         ndr_err = call->ndr_push(push, NDR_OUT, r);
 416         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 417                 talloc_free(r);
 418                 return false;
 419         }
 420
 421         blob = ndr_push_blob(push);
 422         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 423                 talloc_free(r);
 424                 return false;
 425         }
 426
 427         talloc_free(r);
 428
 429         return true;
 430 }
 431
 432 static bool api_spoolss_AddPrinter(pipes_struct *p)
 433 {
 434         const struct ndr_interface_call *call;
 435         struct ndr_pull *pull;
 436         struct ndr_push *push;
 437         enum ndr_err_code ndr_err;
 438         DATA_BLOB blob;
 439         struct spoolss_AddPrinter *r;
 440
 441         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTER];
 442
 443         r = talloc(talloc_tos(), struct spoolss_AddPrinter);
 444         if (r == NULL) {
 445                 return false;
 446         }
 447
 448         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 449                 talloc_free(r);
 450                 return false;
 451         }
 452
 453         pull = ndr_pull_init_blob(&blob, r, NULL);
 454         if (pull == NULL) {
 455                 talloc_free(r);
 456                 return false;
 457         }
 458
 459         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 460         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 461         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 462                 talloc_free(r);
 463                 return false;
 464         }
 465
 466         if (DEBUGLEVEL >= 10) {
 467                 NDR_PRINT_IN_DEBUG(spoolss_AddPrinter, r);
 468         }
 469
 470         r->out.result = _spoolss_AddPrinter(p, r);
 471
 472         if (p->rng_fault_state) {
 473                 talloc_free(r);
 474                 /* Return true here, srv_pipe_hnd.c will take care */
 475                 return true;
 476         }
 477
 478         if (DEBUGLEVEL >= 10) {
 479                 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinter, r);
 480         }
 481
 482         push = ndr_push_init_ctx(r, NULL);
 483         if (push == NULL) {
 484                 talloc_free(r);
 485                 return false;
 486         }
 487
 488         ndr_err = call->ndr_push(push, NDR_OUT, r);
 489         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 490                 talloc_free(r);
 491                 return false;
 492         }
 493
 494         blob = ndr_push_blob(push);
 495         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 496                 talloc_free(r);
 497                 return false;
 498         }
 499
 500         talloc_free(r);
 501
 502         return true;
 503 }
 504
 505 static bool api_spoolss_DeletePrinter(pipes_struct *p)
 506 {
 507         const struct ndr_interface_call *call;
 508         struct ndr_pull *pull;
 509         struct ndr_push *push;
 510         enum ndr_err_code ndr_err;
 511         DATA_BLOB blob;
 512         struct spoolss_DeletePrinter *r;
 513
 514         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTER];
 515
 516         r = talloc(talloc_tos(), struct spoolss_DeletePrinter);
 517         if (r == NULL) {
 518                 return false;
 519         }
 520
 521         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 522                 talloc_free(r);
 523                 return false;
 524         }
 525
 526         pull = ndr_pull_init_blob(&blob, r, NULL);
 527         if (pull == NULL) {
 528                 talloc_free(r);
 529                 return false;
 530         }
 531
 532         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 533         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 534         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 535                 talloc_free(r);
 536                 return false;
 537         }
 538
 539         if (DEBUGLEVEL >= 10) {
 540                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinter, r);
 541         }
 542
 543         r->out.result = _spoolss_DeletePrinter(p, r);
 544
 545         if (p->rng_fault_state) {
 546                 talloc_free(r);
 547                 /* Return true here, srv_pipe_hnd.c will take care */
 548                 return true;
 549         }
 550
 551         if (DEBUGLEVEL >= 10) {
 552                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinter, r);
 553         }
 554
 555         push = ndr_push_init_ctx(r, NULL);
 556         if (push == NULL) {
 557                 talloc_free(r);
 558                 return false;
 559         }
 560
 561         ndr_err = call->ndr_push(push, NDR_OUT, r);
 562         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 563                 talloc_free(r);
 564                 return false;
 565         }
 566
 567         blob = ndr_push_blob(push);
 568         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 569                 talloc_free(r);
 570                 return false;
 571         }
 572
 573         talloc_free(r);
 574
 575         return true;
 576 }
 577
 578 static bool api_spoolss_SetPrinter(pipes_struct *p)
 579 {
 580         const struct ndr_interface_call *call;
 581         struct ndr_pull *pull;
 582         struct ndr_push *push;
 583         enum ndr_err_code ndr_err;
 584         DATA_BLOB blob;
 585         struct spoolss_SetPrinter *r;
 586
 587         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_SETPRINTER];
 588
 589         r = talloc(talloc_tos(), struct spoolss_SetPrinter);
 590         if (r == NULL) {
 591                 return false;
 592         }
 593
 594         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 595                 talloc_free(r);
 596                 return false;
 597         }
 598
 599         pull = ndr_pull_init_blob(&blob, r, NULL);
 600         if (pull == NULL) {
 601                 talloc_free(r);
 602                 return false;
 603         }
 604
 605         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 606         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 607         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 608                 talloc_free(r);
 609                 return false;
 610         }
 611
 612         if (DEBUGLEVEL >= 10) {
 613                 NDR_PRINT_IN_DEBUG(spoolss_SetPrinter, r);
 614         }
 615
 616         r->out.result = _spoolss_SetPrinter(p, r);
 617
 618         if (p->rng_fault_state) {
 619                 talloc_free(r);
 620                 /* Return true here, srv_pipe_hnd.c will take care */
 621                 return true;
 622         }
 623
 624         if (DEBUGLEVEL >= 10) {
 625                 NDR_PRINT_OUT_DEBUG(spoolss_SetPrinter, r);
 626         }
 627
 628         push = ndr_push_init_ctx(r, NULL);
 629         if (push == NULL) {
 630                 talloc_free(r);
 631                 return false;
 632         }
 633
 634         ndr_err = call->ndr_push(push, NDR_OUT, r);
 635         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 636                 talloc_free(r);
 637                 return false;
 638         }
 639
 640         blob = ndr_push_blob(push);
 641         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 642                 talloc_free(r);
 643                 return false;
 644         }
 645
 646         talloc_free(r);
 647
 648         return true;
 649 }
 650
 651 static bool api_spoolss_GetPrinter(pipes_struct *p)
 652 {
 653         const struct ndr_interface_call *call;
 654         struct ndr_pull *pull;
 655         struct ndr_push *push;
 656         enum ndr_err_code ndr_err;
 657         DATA_BLOB blob;
 658         struct spoolss_GetPrinter *r;
 659
 660         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTER];
 661
 662         r = talloc(talloc_tos(), struct spoolss_GetPrinter);
 663         if (r == NULL) {
 664                 return false;
 665         }
 666
 667         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 668                 talloc_free(r);
 669                 return false;
 670         }
 671
 672         pull = ndr_pull_init_blob(&blob, r, NULL);
 673         if (pull == NULL) {
 674                 talloc_free(r);
 675                 return false;
 676         }
 677
 678         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 679         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 680         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 681                 talloc_free(r);
 682                 return false;
 683         }
 684
 685         if (DEBUGLEVEL >= 10) {
 686                 NDR_PRINT_IN_DEBUG(spoolss_GetPrinter, r);
 687         }
 688
 689         ZERO_STRUCT(r->out);
 690         r->out.info = talloc_zero(r, union spoolss_PrinterInfo);
 691         if (r->out.info == NULL) {
 692                 talloc_free(r);
 693                 return false;
 694         }
 695
 696         r->out.needed = talloc_zero(r, uint32_t);
 697         if (r->out.needed == NULL) {
 698                 talloc_free(r);
 699                 return false;
 700         }
 701
 702         r->out.result = _spoolss_GetPrinter(p, r);
 703
 704         if (p->rng_fault_state) {
 705                 talloc_free(r);
 706                 /* Return true here, srv_pipe_hnd.c will take care */
 707                 return true;
 708         }
 709
 710         if (DEBUGLEVEL >= 10) {
 711                 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinter, r);
 712         }
 713
 714         push = ndr_push_init_ctx(r, NULL);
 715         if (push == NULL) {
 716                 talloc_free(r);
 717                 return false;
 718         }
 719
 720         ndr_err = call->ndr_push(push, NDR_OUT, r);
 721         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 722                 talloc_free(r);
 723                 return false;
 724         }
 725
 726         blob = ndr_push_blob(push);
 727         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 728                 talloc_free(r);
 729                 return false;
 730         }
 731
 732         talloc_free(r);
 733
 734         return true;
 735 }
 736
 737 static bool api_spoolss_AddPrinterDriver(pipes_struct *p)
 738 {
 739         const struct ndr_interface_call *call;
 740         struct ndr_pull *pull;
 741         struct ndr_push *push;
 742         enum ndr_err_code ndr_err;
 743         DATA_BLOB blob;
 744         struct spoolss_AddPrinterDriver *r;
 745
 746         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTERDRIVER];
 747
 748         r = talloc(talloc_tos(), struct spoolss_AddPrinterDriver);
 749         if (r == NULL) {
 750                 return false;
 751         }
 752
 753         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 754                 talloc_free(r);
 755                 return false;
 756         }
 757
 758         pull = ndr_pull_init_blob(&blob, r, NULL);
 759         if (pull == NULL) {
 760                 talloc_free(r);
 761                 return false;
 762         }
 763
 764         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 765         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 766         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 767                 talloc_free(r);
 768                 return false;
 769         }
 770
 771         if (DEBUGLEVEL >= 10) {
 772                 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterDriver, r);
 773         }
 774
 775         r->out.result = _spoolss_AddPrinterDriver(p, r);
 776
 777         if (p->rng_fault_state) {
 778                 talloc_free(r);
 779                 /* Return true here, srv_pipe_hnd.c will take care */
 780                 return true;
 781         }
 782
 783         if (DEBUGLEVEL >= 10) {
 784                 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterDriver, r);
 785         }
 786
 787         push = ndr_push_init_ctx(r, NULL);
 788         if (push == NULL) {
 789                 talloc_free(r);
 790                 return false;
 791         }
 792
 793         ndr_err = call->ndr_push(push, NDR_OUT, r);
 794         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 795                 talloc_free(r);
 796                 return false;
 797         }
 798
 799         blob = ndr_push_blob(push);
 800         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 801                 talloc_free(r);
 802                 return false;
 803         }
 804
 805         talloc_free(r);
 806
 807         return true;
 808 }
 809
 810 static bool api_spoolss_EnumPrinterDrivers(pipes_struct *p)
 811 {
 812         const struct ndr_interface_call *call;
 813         struct ndr_pull *pull;
 814         struct ndr_push *push;
 815         enum ndr_err_code ndr_err;
 816         DATA_BLOB blob;
 817         struct spoolss_EnumPrinterDrivers *r;
 818
 819         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPRINTERDRIVERS];
 820
 821         r = talloc(talloc_tos(), struct spoolss_EnumPrinterDrivers);
 822         if (r == NULL) {
 823                 return false;
 824         }
 825
 826         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 827                 talloc_free(r);
 828                 return false;
 829         }
 830
 831         pull = ndr_pull_init_blob(&blob, r, NULL);
 832         if (pull == NULL) {
 833                 talloc_free(r);
 834                 return false;
 835         }
 836
 837         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 838         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 839         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 840                 talloc_free(r);
 841                 return false;
 842         }
 843
 844         if (DEBUGLEVEL >= 10) {
 845                 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterDrivers, r);
 846         }
 847
 848         ZERO_STRUCT(r->out);
 849         r->out.count = talloc_zero(r, uint32_t);
 850         if (r->out.count == NULL) {
 851                 talloc_free(r);
 852                 return false;
 853         }
 854
 855         r->out.info = talloc_zero(r, union spoolss_DriverInfo *);
 856         if (r->out.info == NULL) {
 857                 talloc_free(r);
 858                 return false;
 859         }
 860
 861         r->out.needed = talloc_zero(r, uint32_t);
 862         if (r->out.needed == NULL) {
 863                 talloc_free(r);
 864                 return false;
 865         }
 866
 867         r->out.result = _spoolss_EnumPrinterDrivers(p, r);
 868
 869         if (p->rng_fault_state) {
 870                 talloc_free(r);
 871                 /* Return true here, srv_pipe_hnd.c will take care */
 872                 return true;
 873         }
 874
 875         if (DEBUGLEVEL >= 10) {
 876                 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterDrivers, r);
 877         }
 878
 879         push = ndr_push_init_ctx(r, NULL);
 880         if (push == NULL) {
 881                 talloc_free(r);
 882                 return false;
 883         }
 884
 885         ndr_err = call->ndr_push(push, NDR_OUT, r);
 886         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 887                 talloc_free(r);
 888                 return false;
 889         }
 890
 891         blob = ndr_push_blob(push);
 892         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 893                 talloc_free(r);
 894                 return false;
 895         }
 896
 897         talloc_free(r);
 898
 899         return true;
 900 }
 901
 902 static bool api_spoolss_GetPrinterDriver(pipes_struct *p)
 903 {
 904         const struct ndr_interface_call *call;
 905         struct ndr_pull *pull;
 906         struct ndr_push *push;
 907         enum ndr_err_code ndr_err;
 908         DATA_BLOB blob;
 909         struct spoolss_GetPrinterDriver *r;
 910
 911         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTERDRIVER];
 912
 913         r = talloc(talloc_tos(), struct spoolss_GetPrinterDriver);
 914         if (r == NULL) {
 915                 return false;
 916         }
 917
 918         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 919                 talloc_free(r);
 920                 return false;
 921         }
 922
 923         pull = ndr_pull_init_blob(&blob, r, NULL);
 924         if (pull == NULL) {
 925                 talloc_free(r);
 926                 return false;
 927         }
 928
 929         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 930         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 931         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 932                 talloc_free(r);
 933                 return false;
 934         }
 935
 936         if (DEBUGLEVEL >= 10) {
 937                 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriver, r);
 938         }
 939
 940         r->out.result = _spoolss_GetPrinterDriver(p, r);
 941
 942         if (p->rng_fault_state) {
 943                 talloc_free(r);
 944                 /* Return true here, srv_pipe_hnd.c will take care */
 945                 return true;
 946         }
 947
 948         if (DEBUGLEVEL >= 10) {
 949                 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriver, r);
 950         }
 951
 952         push = ndr_push_init_ctx(r, NULL);
 953         if (push == NULL) {
 954                 talloc_free(r);
 955                 return false;
 956         }
 957
 958         ndr_err = call->ndr_push(push, NDR_OUT, r);
 959         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 960                 talloc_free(r);
 961                 return false;
 962         }
 963
 964         blob = ndr_push_blob(push);
 965         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 966                 talloc_free(r);
 967                 return false;
 968         }
 969
 970         talloc_free(r);
 971
 972         return true;
 973 }
 974
 975 static bool api_spoolss_GetPrinterDriverDirectory(pipes_struct *p)
 976 {
 977         const struct ndr_interface_call *call;
 978         struct ndr_pull *pull;
 979         struct ndr_push *push;
 980         enum ndr_err_code ndr_err;
 981         DATA_BLOB blob;
 982         struct spoolss_GetPrinterDriverDirectory *r;
 983
 984         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY];
 985
 986         r = talloc(talloc_tos(), struct spoolss_GetPrinterDriverDirectory);
 987         if (r == NULL) {
 988                 return false;
 989         }
 990
 991         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 992                 talloc_free(r);
 993                 return false;
 994         }
 995
 996         pull = ndr_pull_init_blob(&blob, r, NULL);
 997         if (pull == NULL) {
 998                 talloc_free(r);
 999                 return false;
1000         }
1001
1002         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1003         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1004         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1005                 talloc_free(r);
1006                 return false;
1007         }
1008
1009         if (DEBUGLEVEL >= 10) {
1010                 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriverDirectory, r);
1011         }
1012
1013         ZERO_STRUCT(r->out);
1014         r->out.info = talloc_zero(r, union spoolss_DriverDirectoryInfo);
1015         if (r->out.info == NULL) {
1016                 talloc_free(r);
1017                 return false;
1018         }
1019
1020         r->out.needed = talloc_zero(r, uint32_t);
1021         if (r->out.needed == NULL) {
1022                 talloc_free(r);
1023                 return false;
1024         }
1025
1026         r->out.result = _spoolss_GetPrinterDriverDirectory(p, r);
1027
1028         if (p->rng_fault_state) {
1029                 talloc_free(r);
1030                 /* Return true here, srv_pipe_hnd.c will take care */
1031                 return true;
1032         }
1033
1034         if (DEBUGLEVEL >= 10) {
1035                 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriverDirectory, r);
1036         }
1037
1038         push = ndr_push_init_ctx(r, NULL);
1039         if (push == NULL) {
1040                 talloc_free(r);
1041                 return false;
1042         }
1043
1044         ndr_err = call->ndr_push(push, NDR_OUT, r);
1045         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1046                 talloc_free(r);
1047                 return false;
1048         }
1049
1050         blob = ndr_push_blob(push);
1051         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1052                 talloc_free(r);
1053                 return false;
1054         }
1055
1056         talloc_free(r);
1057
1058         return true;
1059 }
1060
1061 static bool api_spoolss_DeletePrinterDriver(pipes_struct *p)
1062 {
1063         const struct ndr_interface_call *call;
1064         struct ndr_pull *pull;
1065         struct ndr_push *push;
1066         enum ndr_err_code ndr_err;
1067         DATA_BLOB blob;
1068         struct spoolss_DeletePrinterDriver *r;
1069
1070         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERDRIVER];
1071
1072         r = talloc(talloc_tos(), struct spoolss_DeletePrinterDriver);
1073         if (r == NULL) {
1074                 return false;
1075         }
1076
1077         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1078                 talloc_free(r);
1079                 return false;
1080         }
1081
1082         pull = ndr_pull_init_blob(&blob, r, NULL);
1083         if (pull == NULL) {
1084                 talloc_free(r);
1085                 return false;
1086         }
1087
1088         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1089         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1090         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1091                 talloc_free(r);
1092                 return false;
1093         }
1094
1095         if (DEBUGLEVEL >= 10) {
1096                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDriver, r);
1097         }
1098
1099         r->out.result = _spoolss_DeletePrinterDriver(p, r);
1100
1101         if (p->rng_fault_state) {
1102                 talloc_free(r);
1103                 /* Return true here, srv_pipe_hnd.c will take care */
1104                 return true;
1105         }
1106
1107         if (DEBUGLEVEL >= 10) {
1108                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDriver, r);
1109         }
1110
1111         push = ndr_push_init_ctx(r, NULL);
1112         if (push == NULL) {
1113                 talloc_free(r);
1114                 return false;
1115         }
1116
1117         ndr_err = call->ndr_push(push, NDR_OUT, r);
1118         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1119                 talloc_free(r);
1120                 return false;
1121         }
1122
1123         blob = ndr_push_blob(push);
1124         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1125                 talloc_free(r);
1126                 return false;
1127         }
1128
1129         talloc_free(r);
1130
1131         return true;
1132 }
1133
1134 static bool api_spoolss_AddPrintProcessor(pipes_struct *p)
1135 {
1136         const struct ndr_interface_call *call;
1137         struct ndr_pull *pull;
1138         struct ndr_push *push;
1139         enum ndr_err_code ndr_err;
1140         DATA_BLOB blob;
1141         struct spoolss_AddPrintProcessor *r;
1142
1143         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTPROCESSOR];
1144
1145         r = talloc(talloc_tos(), struct spoolss_AddPrintProcessor);
1146         if (r == NULL) {
1147                 return false;
1148         }
1149
1150         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1151                 talloc_free(r);
1152                 return false;
1153         }
1154
1155         pull = ndr_pull_init_blob(&blob, r, NULL);
1156         if (pull == NULL) {
1157                 talloc_free(r);
1158                 return false;
1159         }
1160
1161         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1162         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1163         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1164                 talloc_free(r);
1165                 return false;
1166         }
1167
1168         if (DEBUGLEVEL >= 10) {
1169                 NDR_PRINT_IN_DEBUG(spoolss_AddPrintProcessor, r);
1170         }
1171
1172         r->out.result = _spoolss_AddPrintProcessor(p, r);
1173
1174         if (p->rng_fault_state) {
1175                 talloc_free(r);
1176                 /* Return true here, srv_pipe_hnd.c will take care */
1177                 return true;
1178         }
1179
1180         if (DEBUGLEVEL >= 10) {
1181                 NDR_PRINT_OUT_DEBUG(spoolss_AddPrintProcessor, r);
1182         }
1183
1184         push = ndr_push_init_ctx(r, NULL);
1185         if (push == NULL) {
1186                 talloc_free(r);
1187                 return false;
1188         }
1189
1190         ndr_err = call->ndr_push(push, NDR_OUT, r);
1191         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1192                 talloc_free(r);
1193                 return false;
1194         }
1195
1196         blob = ndr_push_blob(push);
1197         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1198                 talloc_free(r);
1199                 return false;
1200         }
1201
1202         talloc_free(r);
1203
1204         return true;
1205 }
1206
1207 static bool api_spoolss_EnumPrintProcessors(pipes_struct *p)
1208 {
1209         const struct ndr_interface_call *call;
1210         struct ndr_pull *pull;
1211         struct ndr_push *push;
1212         enum ndr_err_code ndr_err;
1213         DATA_BLOB blob;
1214         struct spoolss_EnumPrintProcessors *r;
1215
1216         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPRINTPROCESSORS];
1217
1218         r = talloc(talloc_tos(), struct spoolss_EnumPrintProcessors);
1219         if (r == NULL) {
1220                 return false;
1221         }
1222
1223         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1224                 talloc_free(r);
1225                 return false;
1226         }
1227
1228         pull = ndr_pull_init_blob(&blob, r, NULL);
1229         if (pull == NULL) {
1230                 talloc_free(r);
1231                 return false;
1232         }
1233
1234         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1235         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1236         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1237                 talloc_free(r);
1238                 return false;
1239         }
1240
1241         if (DEBUGLEVEL >= 10) {
1242                 NDR_PRINT_IN_DEBUG(spoolss_EnumPrintProcessors, r);
1243         }
1244
1245         ZERO_STRUCT(r->out);
1246         r->out.count = talloc_zero(r, uint32_t);
1247         if (r->out.count == NULL) {
1248                 talloc_free(r);
1249                 return false;
1250         }
1251
1252         r->out.info = talloc_zero(r, union spoolss_PrintProcessorInfo *);
1253         if (r->out.info == NULL) {
1254                 talloc_free(r);
1255                 return false;
1256         }
1257
1258         r->out.needed = talloc_zero(r, uint32_t);
1259         if (r->out.needed == NULL) {
1260                 talloc_free(r);
1261                 return false;
1262         }
1263
1264         r->out.result = _spoolss_EnumPrintProcessors(p, r);
1265
1266         if (p->rng_fault_state) {
1267                 talloc_free(r);
1268                 /* Return true here, srv_pipe_hnd.c will take care */
1269                 return true;
1270         }
1271
1272         if (DEBUGLEVEL >= 10) {
1273                 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrintProcessors, r);
1274         }
1275
1276         push = ndr_push_init_ctx(r, NULL);
1277         if (push == NULL) {
1278                 talloc_free(r);
1279                 return false;
1280         }
1281
1282         ndr_err = call->ndr_push(push, NDR_OUT, r);
1283         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1284                 talloc_free(r);
1285                 return false;
1286         }
1287
1288         blob = ndr_push_blob(push);
1289         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1290                 talloc_free(r);
1291                 return false;
1292         }
1293
1294         talloc_free(r);
1295
1296         return true;
1297 }
1298
1299 static bool api_spoolss_GetPrintProcessorDirectory(pipes_struct *p)
1300 {
1301         const struct ndr_interface_call *call;
1302         struct ndr_pull *pull;
1303         struct ndr_push *push;
1304         enum ndr_err_code ndr_err;
1305         DATA_BLOB blob;
1306         struct spoolss_GetPrintProcessorDirectory *r;
1307
1308         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY];
1309
1310         r = talloc(talloc_tos(), struct spoolss_GetPrintProcessorDirectory);
1311         if (r == NULL) {
1312                 return false;
1313         }
1314
1315         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1316                 talloc_free(r);
1317                 return false;
1318         }
1319
1320         pull = ndr_pull_init_blob(&blob, r, NULL);
1321         if (pull == NULL) {
1322                 talloc_free(r);
1323                 return false;
1324         }
1325
1326         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1327         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1328         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1329                 talloc_free(r);
1330                 return false;
1331         }
1332
1333         if (DEBUGLEVEL >= 10) {
1334                 NDR_PRINT_IN_DEBUG(spoolss_GetPrintProcessorDirectory, r);
1335         }
1336
1337         ZERO_STRUCT(r->out);
1338         r->out.info = talloc_zero(r, union spoolss_PrintProcessorDirectoryInfo);
1339         if (r->out.info == NULL) {
1340                 talloc_free(r);
1341                 return false;
1342         }
1343
1344         r->out.needed = talloc_zero(r, uint32_t);
1345         if (r->out.needed == NULL) {
1346                 talloc_free(r);
1347                 return false;
1348         }
1349
1350         r->out.result = _spoolss_GetPrintProcessorDirectory(p, r);
1351
1352         if (p->rng_fault_state) {
1353                 talloc_free(r);
1354                 /* Return true here, srv_pipe_hnd.c will take care */
1355                 return true;
1356         }
1357
1358         if (DEBUGLEVEL >= 10) {
1359                 NDR_PRINT_OUT_DEBUG(spoolss_GetPrintProcessorDirectory, r);
1360         }
1361
1362         push = ndr_push_init_ctx(r, NULL);
1363         if (push == NULL) {
1364                 talloc_free(r);
1365                 return false;
1366         }
1367
1368         ndr_err = call->ndr_push(push, NDR_OUT, r);
1369         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1370                 talloc_free(r);
1371                 return false;
1372         }
1373
1374         blob = ndr_push_blob(push);
1375         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1376                 talloc_free(r);
1377                 return false;
1378         }
1379
1380         talloc_free(r);
1381
1382         return true;
1383 }
1384
1385 static bool api_spoolss_StartDocPrinter(pipes_struct *p)
1386 {
1387         const struct ndr_interface_call *call;
1388         struct ndr_pull *pull;
1389         struct ndr_push *push;
1390         enum ndr_err_code ndr_err;
1391         DATA_BLOB blob;
1392         struct spoolss_StartDocPrinter *r;
1393
1394         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_STARTDOCPRINTER];
1395
1396         r = talloc(talloc_tos(), struct spoolss_StartDocPrinter);
1397         if (r == NULL) {
1398                 return false;
1399         }
1400
1401         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1402                 talloc_free(r);
1403                 return false;
1404         }
1405
1406         pull = ndr_pull_init_blob(&blob, r, NULL);
1407         if (pull == NULL) {
1408                 talloc_free(r);
1409                 return false;
1410         }
1411
1412         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1413         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1414         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1415                 talloc_free(r);
1416                 return false;
1417         }
1418
1419         if (DEBUGLEVEL >= 10) {
1420                 NDR_PRINT_IN_DEBUG(spoolss_StartDocPrinter, r);
1421         }
1422
1423         ZERO_STRUCT(r->out);
1424         r->out.job_id = talloc_zero(r, uint32_t);
1425         if (r->out.job_id == NULL) {
1426                 talloc_free(r);
1427                 return false;
1428         }
1429
1430         r->out.result = _spoolss_StartDocPrinter(p, r);
1431
1432         if (p->rng_fault_state) {
1433                 talloc_free(r);
1434                 /* Return true here, srv_pipe_hnd.c will take care */
1435                 return true;
1436         }
1437
1438         if (DEBUGLEVEL >= 10) {
1439                 NDR_PRINT_OUT_DEBUG(spoolss_StartDocPrinter, r);
1440         }
1441
1442         push = ndr_push_init_ctx(r, NULL);
1443         if (push == NULL) {
1444                 talloc_free(r);
1445                 return false;
1446         }
1447
1448         ndr_err = call->ndr_push(push, NDR_OUT, r);
1449         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1450                 talloc_free(r);
1451                 return false;
1452         }
1453
1454         blob = ndr_push_blob(push);
1455         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1456                 talloc_free(r);
1457                 return false;
1458         }
1459
1460         talloc_free(r);
1461
1462         return true;
1463 }
1464
1465 static bool api_spoolss_StartPagePrinter(pipes_struct *p)
1466 {
1467         const struct ndr_interface_call *call;
1468         struct ndr_pull *pull;
1469         struct ndr_push *push;
1470         enum ndr_err_code ndr_err;
1471         DATA_BLOB blob;
1472         struct spoolss_StartPagePrinter *r;
1473
1474         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_STARTPAGEPRINTER];
1475
1476         r = talloc(talloc_tos(), struct spoolss_StartPagePrinter);
1477         if (r == NULL) {
1478                 return false;
1479         }
1480
1481         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1482                 talloc_free(r);
1483                 return false;
1484         }
1485
1486         pull = ndr_pull_init_blob(&blob, r, NULL);
1487         if (pull == NULL) {
1488                 talloc_free(r);
1489                 return false;
1490         }
1491
1492         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1493         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1494         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1495                 talloc_free(r);
1496                 return false;
1497         }
1498
1499         if (DEBUGLEVEL >= 10) {
1500                 NDR_PRINT_IN_DEBUG(spoolss_StartPagePrinter, r);
1501         }
1502
1503         r->out.result = _spoolss_StartPagePrinter(p, r);
1504
1505         if (p->rng_fault_state) {
1506                 talloc_free(r);
1507                 /* Return true here, srv_pipe_hnd.c will take care */
1508                 return true;
1509         }
1510
1511         if (DEBUGLEVEL >= 10) {
1512                 NDR_PRINT_OUT_DEBUG(spoolss_StartPagePrinter, r);
1513         }
1514
1515         push = ndr_push_init_ctx(r, NULL);
1516         if (push == NULL) {
1517                 talloc_free(r);
1518                 return false;
1519         }
1520
1521         ndr_err = call->ndr_push(push, NDR_OUT, r);
1522         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1523                 talloc_free(r);
1524                 return false;
1525         }
1526
1527         blob = ndr_push_blob(push);
1528         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1529                 talloc_free(r);
1530                 return false;
1531         }
1532
1533         talloc_free(r);
1534
1535         return true;
1536 }
1537
1538 static bool api_spoolss_WritePrinter(pipes_struct *p)
1539 {
1540         const struct ndr_interface_call *call;
1541         struct ndr_pull *pull;
1542         struct ndr_push *push;
1543         enum ndr_err_code ndr_err;
1544         DATA_BLOB blob;
1545         struct spoolss_WritePrinter *r;
1546
1547         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_WRITEPRINTER];
1548
1549         r = talloc(talloc_tos(), struct spoolss_WritePrinter);
1550         if (r == NULL) {
1551                 return false;
1552         }
1553
1554         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1555                 talloc_free(r);
1556                 return false;
1557         }
1558
1559         pull = ndr_pull_init_blob(&blob, r, NULL);
1560         if (pull == NULL) {
1561                 talloc_free(r);
1562                 return false;
1563         }
1564
1565         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1566         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1567         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1568                 talloc_free(r);
1569                 return false;
1570         }
1571
1572         if (DEBUGLEVEL >= 10) {
1573                 NDR_PRINT_IN_DEBUG(spoolss_WritePrinter, r);
1574         }
1575
1576         ZERO_STRUCT(r->out);
1577         r->out.num_written = talloc_zero(r, uint32_t);
1578         if (r->out.num_written == NULL) {
1579                 talloc_free(r);
1580                 return false;
1581         }
1582
1583         r->out.result = _spoolss_WritePrinter(p, r);
1584
1585         if (p->rng_fault_state) {
1586                 talloc_free(r);
1587                 /* Return true here, srv_pipe_hnd.c will take care */
1588                 return true;
1589         }
1590
1591         if (DEBUGLEVEL >= 10) {
1592                 NDR_PRINT_OUT_DEBUG(spoolss_WritePrinter, r);
1593         }
1594
1595         push = ndr_push_init_ctx(r, NULL);
1596         if (push == NULL) {
1597                 talloc_free(r);
1598                 return false;
1599         }
1600
1601         ndr_err = call->ndr_push(push, NDR_OUT, r);
1602         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1603                 talloc_free(r);
1604                 return false;
1605         }
1606
1607         blob = ndr_push_blob(push);
1608         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1609                 talloc_free(r);
1610                 return false;
1611         }
1612
1613         talloc_free(r);
1614
1615         return true;
1616 }
1617
1618 static bool api_spoolss_EndPagePrinter(pipes_struct *p)
1619 {
1620         const struct ndr_interface_call *call;
1621         struct ndr_pull *pull;
1622         struct ndr_push *push;
1623         enum ndr_err_code ndr_err;
1624         DATA_BLOB blob;
1625         struct spoolss_EndPagePrinter *r;
1626
1627         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENDPAGEPRINTER];
1628
1629         r = talloc(talloc_tos(), struct spoolss_EndPagePrinter);
1630         if (r == NULL) {
1631                 return false;
1632         }
1633
1634         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1635                 talloc_free(r);
1636                 return false;
1637         }
1638
1639         pull = ndr_pull_init_blob(&blob, r, NULL);
1640         if (pull == NULL) {
1641                 talloc_free(r);
1642                 return false;
1643         }
1644
1645         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1646         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1647         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1648                 talloc_free(r);
1649                 return false;
1650         }
1651
1652         if (DEBUGLEVEL >= 10) {
1653                 NDR_PRINT_IN_DEBUG(spoolss_EndPagePrinter, r);
1654         }
1655
1656         r->out.result = _spoolss_EndPagePrinter(p, r);
1657
1658         if (p->rng_fault_state) {
1659                 talloc_free(r);
1660                 /* Return true here, srv_pipe_hnd.c will take care */
1661                 return true;
1662         }
1663
1664         if (DEBUGLEVEL >= 10) {
1665                 NDR_PRINT_OUT_DEBUG(spoolss_EndPagePrinter, r);
1666         }
1667
1668         push = ndr_push_init_ctx(r, NULL);
1669         if (push == NULL) {
1670                 talloc_free(r);
1671                 return false;
1672         }
1673
1674         ndr_err = call->ndr_push(push, NDR_OUT, r);
1675         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1676                 talloc_free(r);
1677                 return false;
1678         }
1679
1680         blob = ndr_push_blob(push);
1681         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1682                 talloc_free(r);
1683                 return false;
1684         }
1685
1686         talloc_free(r);
1687
1688         return true;
1689 }
1690
1691 static bool api_spoolss_AbortPrinter(pipes_struct *p)
1692 {
1693         const struct ndr_interface_call *call;
1694         struct ndr_pull *pull;
1695         struct ndr_push *push;
1696         enum ndr_err_code ndr_err;
1697         DATA_BLOB blob;
1698         struct spoolss_AbortPrinter *r;
1699
1700         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ABORTPRINTER];
1701
1702         r = talloc(talloc_tos(), struct spoolss_AbortPrinter);
1703         if (r == NULL) {
1704                 return false;
1705         }
1706
1707         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1708                 talloc_free(r);
1709                 return false;
1710         }
1711
1712         pull = ndr_pull_init_blob(&blob, r, NULL);
1713         if (pull == NULL) {
1714                 talloc_free(r);
1715                 return false;
1716         }
1717
1718         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1719         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1720         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1721                 talloc_free(r);
1722                 return false;
1723         }
1724
1725         if (DEBUGLEVEL >= 10) {
1726                 NDR_PRINT_IN_DEBUG(spoolss_AbortPrinter, r);
1727         }
1728
1729         r->out.result = _spoolss_AbortPrinter(p, r);
1730
1731         if (p->rng_fault_state) {
1732                 talloc_free(r);
1733                 /* Return true here, srv_pipe_hnd.c will take care */
1734                 return true;
1735         }
1736
1737         if (DEBUGLEVEL >= 10) {
1738                 NDR_PRINT_OUT_DEBUG(spoolss_AbortPrinter, r);
1739         }
1740
1741         push = ndr_push_init_ctx(r, NULL);
1742         if (push == NULL) {
1743                 talloc_free(r);
1744                 return false;
1745         }
1746
1747         ndr_err = call->ndr_push(push, NDR_OUT, r);
1748         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1749                 talloc_free(r);
1750                 return false;
1751         }
1752
1753         blob = ndr_push_blob(push);
1754         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1755                 talloc_free(r);
1756                 return false;
1757         }
1758
1759         talloc_free(r);
1760
1761         return true;
1762 }
1763
1764 static bool api_spoolss_ReadPrinter(pipes_struct *p)
1765 {
1766         const struct ndr_interface_call *call;
1767         struct ndr_pull *pull;
1768         struct ndr_push *push;
1769         enum ndr_err_code ndr_err;
1770         DATA_BLOB blob;
1771         struct spoolss_ReadPrinter *r;
1772
1773         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_READPRINTER];
1774
1775         r = talloc(talloc_tos(), struct spoolss_ReadPrinter);
1776         if (r == NULL) {
1777                 return false;
1778         }
1779
1780         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1781                 talloc_free(r);
1782                 return false;
1783         }
1784
1785         pull = ndr_pull_init_blob(&blob, r, NULL);
1786         if (pull == NULL) {
1787                 talloc_free(r);
1788                 return false;
1789         }
1790
1791         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1792         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1793         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1794                 talloc_free(r);
1795                 return false;
1796         }
1797
1798         if (DEBUGLEVEL >= 10) {
1799                 NDR_PRINT_IN_DEBUG(spoolss_ReadPrinter, r);
1800         }
1801
1802         ZERO_STRUCT(r->out);
1803         r->out.data = talloc_zero_array(r, uint8_t, r->in.data_size);
1804         if (r->out.data == NULL) {
1805                 talloc_free(r);
1806                 return false;
1807         }
1808
1809         r->out._data_size = talloc_zero(r, uint32_t);
1810         if (r->out._data_size == NULL) {
1811                 talloc_free(r);
1812                 return false;
1813         }
1814
1815         r->out.result = _spoolss_ReadPrinter(p, r);
1816
1817         if (p->rng_fault_state) {
1818                 talloc_free(r);
1819                 /* Return true here, srv_pipe_hnd.c will take care */
1820                 return true;
1821         }
1822
1823         if (DEBUGLEVEL >= 10) {
1824                 NDR_PRINT_OUT_DEBUG(spoolss_ReadPrinter, r);
1825         }
1826
1827         push = ndr_push_init_ctx(r, NULL);
1828         if (push == NULL) {
1829                 talloc_free(r);
1830                 return false;
1831         }
1832
1833         ndr_err = call->ndr_push(push, NDR_OUT, r);
1834         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1835                 talloc_free(r);
1836                 return false;
1837         }
1838
1839         blob = ndr_push_blob(push);
1840         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1841                 talloc_free(r);
1842                 return false;
1843         }
1844
1845         talloc_free(r);
1846
1847         return true;
1848 }
1849
1850 static bool api_spoolss_EndDocPrinter(pipes_struct *p)
1851 {
1852         const struct ndr_interface_call *call;
1853         struct ndr_pull *pull;
1854         struct ndr_push *push;
1855         enum ndr_err_code ndr_err;
1856         DATA_BLOB blob;
1857         struct spoolss_EndDocPrinter *r;
1858
1859         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENDDOCPRINTER];
1860
1861         r = talloc(talloc_tos(), struct spoolss_EndDocPrinter);
1862         if (r == NULL) {
1863                 return false;
1864         }
1865
1866         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1867                 talloc_free(r);
1868                 return false;
1869         }
1870
1871         pull = ndr_pull_init_blob(&blob, r, NULL);
1872         if (pull == NULL) {
1873                 talloc_free(r);
1874                 return false;
1875         }
1876
1877         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1878         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1879         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1880                 talloc_free(r);
1881                 return false;
1882         }
1883
1884         if (DEBUGLEVEL >= 10) {
1885                 NDR_PRINT_IN_DEBUG(spoolss_EndDocPrinter, r);
1886         }
1887
1888         r->out.result = _spoolss_EndDocPrinter(p, r);
1889
1890         if (p->rng_fault_state) {
1891                 talloc_free(r);
1892                 /* Return true here, srv_pipe_hnd.c will take care */
1893                 return true;
1894         }
1895
1896         if (DEBUGLEVEL >= 10) {
1897                 NDR_PRINT_OUT_DEBUG(spoolss_EndDocPrinter, r);
1898         }
1899
1900         push = ndr_push_init_ctx(r, NULL);
1901         if (push == NULL) {
1902                 talloc_free(r);
1903                 return false;
1904         }
1905
1906         ndr_err = call->ndr_push(push, NDR_OUT, r);
1907         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1908                 talloc_free(r);
1909                 return false;
1910         }
1911
1912         blob = ndr_push_blob(push);
1913         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1914                 talloc_free(r);
1915                 return false;
1916         }
1917
1918         talloc_free(r);
1919
1920         return true;
1921 }
1922
1923 static bool api_spoolss_AddJob(pipes_struct *p)
1924 {
1925         const struct ndr_interface_call *call;
1926         struct ndr_pull *pull;
1927         struct ndr_push *push;
1928         enum ndr_err_code ndr_err;
1929         DATA_BLOB blob;
1930         struct spoolss_AddJob *r;
1931
1932         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDJOB];
1933
1934         r = talloc(talloc_tos(), struct spoolss_AddJob);
1935         if (r == NULL) {
1936                 return false;
1937         }
1938
1939         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1940                 talloc_free(r);
1941                 return false;
1942         }
1943
1944         pull = ndr_pull_init_blob(&blob, r, NULL);
1945         if (pull == NULL) {
1946                 talloc_free(r);
1947                 return false;
1948         }
1949
1950         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1951         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1952         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1953                 talloc_free(r);
1954                 return false;
1955         }
1956
1957         if (DEBUGLEVEL >= 10) {
1958                 NDR_PRINT_IN_DEBUG(spoolss_AddJob, r);
1959         }
1960
1961         ZERO_STRUCT(r->out);
1962         r->out.buffer = r->in.buffer;
1963         r->out.needed = talloc_zero(r, uint32_t);
1964         if (r->out.needed == NULL) {
1965                 talloc_free(r);
1966                 return false;
1967         }
1968
1969         r->out.result = _spoolss_AddJob(p, r);
1970
1971         if (p->rng_fault_state) {
1972                 talloc_free(r);
1973                 /* Return true here, srv_pipe_hnd.c will take care */
1974                 return true;
1975         }
1976
1977         if (DEBUGLEVEL >= 10) {
1978                 NDR_PRINT_OUT_DEBUG(spoolss_AddJob, r);
1979         }
1980
1981         push = ndr_push_init_ctx(r, NULL);
1982         if (push == NULL) {
1983                 talloc_free(r);
1984                 return false;
1985         }
1986
1987         ndr_err = call->ndr_push(push, NDR_OUT, r);
1988         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1989                 talloc_free(r);
1990                 return false;
1991         }
1992
1993         blob = ndr_push_blob(push);
1994         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1995                 talloc_free(r);
1996                 return false;
1997         }
1998
1999         talloc_free(r);
2000
2001         return true;
2002 }
2003
2004 static bool api_spoolss_ScheduleJob(pipes_struct *p)
2005 {
2006         const struct ndr_interface_call *call;
2007         struct ndr_pull *pull;
2008         struct ndr_push *push;
2009         enum ndr_err_code ndr_err;
2010         DATA_BLOB blob;
2011         struct spoolss_ScheduleJob *r;
2012
2013         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_SCHEDULEJOB];
2014
2015         r = talloc(talloc_tos(), struct spoolss_ScheduleJob);
2016         if (r == NULL) {
2017                 return false;
2018         }
2019
2020         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2021                 talloc_free(r);
2022                 return false;
2023         }
2024
2025         pull = ndr_pull_init_blob(&blob, r, NULL);
2026         if (pull == NULL) {
2027                 talloc_free(r);
2028                 return false;
2029         }
2030
2031         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2032         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2033         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2034                 talloc_free(r);
2035                 return false;
2036         }
2037
2038         if (DEBUGLEVEL >= 10) {
2039                 NDR_PRINT_IN_DEBUG(spoolss_ScheduleJob, r);
2040         }
2041
2042         r->out.result = _spoolss_ScheduleJob(p, r);
2043
2044         if (p->rng_fault_state) {
2045                 talloc_free(r);
2046                 /* Return true here, srv_pipe_hnd.c will take care */
2047                 return true;
2048         }
2049
2050         if (DEBUGLEVEL >= 10) {
2051                 NDR_PRINT_OUT_DEBUG(spoolss_ScheduleJob, r);
2052         }
2053
2054         push = ndr_push_init_ctx(r, NULL);
2055         if (push == NULL) {
2056                 talloc_free(r);
2057                 return false;
2058         }
2059
2060         ndr_err = call->ndr_push(push, NDR_OUT, r);
2061         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2062                 talloc_free(r);
2063                 return false;
2064         }
2065
2066         blob = ndr_push_blob(push);
2067         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2068                 talloc_free(r);
2069                 return false;
2070         }
2071
2072         talloc_free(r);
2073
2074         return true;
2075 }
2076
2077 static bool api_spoolss_GetPrinterData(pipes_struct *p)
2078 {
2079         const struct ndr_interface_call *call;
2080         struct ndr_pull *pull;
2081         struct ndr_push *push;
2082         enum ndr_err_code ndr_err;
2083         DATA_BLOB blob;
2084         struct spoolss_GetPrinterData *r;
2085
2086         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTERDATA];
2087
2088         r = talloc(talloc_tos(), struct spoolss_GetPrinterData);
2089         if (r == NULL) {
2090                 return false;
2091         }
2092
2093         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2094                 talloc_free(r);
2095                 return false;
2096         }
2097
2098         pull = ndr_pull_init_blob(&blob, r, NULL);
2099         if (pull == NULL) {
2100                 talloc_free(r);
2101                 return false;
2102         }
2103
2104         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2105         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2106         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2107                 talloc_free(r);
2108                 return false;
2109         }
2110
2111         if (DEBUGLEVEL >= 10) {
2112                 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterData, r);
2113         }
2114
2115         ZERO_STRUCT(r->out);
2116         r->out.type = talloc_zero(r, enum winreg_Type);
2117         if (r->out.type == NULL) {
2118                 talloc_free(r);
2119                 return false;
2120         }
2121
2122         r->out.data = talloc_zero(r, union spoolss_PrinterData);
2123         if (r->out.data == NULL) {
2124                 talloc_free(r);
2125                 return false;
2126         }
2127
2128         r->out.needed = talloc_zero(r, uint32_t);
2129         if (r->out.needed == NULL) {
2130                 talloc_free(r);
2131                 return false;
2132         }
2133
2134         r->out.result = _spoolss_GetPrinterData(p, r);
2135
2136         if (p->rng_fault_state) {
2137                 talloc_free(r);
2138                 /* Return true here, srv_pipe_hnd.c will take care */
2139                 return true;
2140         }
2141
2142         if (DEBUGLEVEL >= 10) {
2143                 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterData, r);
2144         }
2145
2146         push = ndr_push_init_ctx(r, NULL);
2147         if (push == NULL) {
2148                 talloc_free(r);
2149                 return false;
2150         }
2151
2152         ndr_err = call->ndr_push(push, NDR_OUT, r);
2153         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2154                 talloc_free(r);
2155                 return false;
2156         }
2157
2158         blob = ndr_push_blob(push);
2159         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2160                 talloc_free(r);
2161                 return false;
2162         }
2163
2164         talloc_free(r);
2165
2166         return true;
2167 }
2168
2169 static bool api_spoolss_SetPrinterData(pipes_struct *p)
2170 {
2171         const struct ndr_interface_call *call;
2172         struct ndr_pull *pull;
2173         struct ndr_push *push;
2174         enum ndr_err_code ndr_err;
2175         DATA_BLOB blob;
2176         struct spoolss_SetPrinterData *r;
2177
2178         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_SETPRINTERDATA];
2179
2180         r = talloc(talloc_tos(), struct spoolss_SetPrinterData);
2181         if (r == NULL) {
2182                 return false;
2183         }
2184
2185         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2186                 talloc_free(r);
2187                 return false;
2188         }
2189
2190         pull = ndr_pull_init_blob(&blob, r, NULL);
2191         if (pull == NULL) {
2192                 talloc_free(r);
2193                 return false;
2194         }
2195
2196         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2197         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2198         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2199                 talloc_free(r);
2200                 return false;
2201         }
2202
2203         if (DEBUGLEVEL >= 10) {
2204                 NDR_PRINT_IN_DEBUG(spoolss_SetPrinterData, r);
2205         }
2206
2207         r->out.result = _spoolss_SetPrinterData(p, r);
2208
2209         if (p->rng_fault_state) {
2210                 talloc_free(r);
2211                 /* Return true here, srv_pipe_hnd.c will take care */
2212                 return true;
2213         }
2214
2215         if (DEBUGLEVEL >= 10) {
2216                 NDR_PRINT_OUT_DEBUG(spoolss_SetPrinterData, r);
2217         }
2218
2219         push = ndr_push_init_ctx(r, NULL);
2220         if (push == NULL) {
2221                 talloc_free(r);
2222                 return false;
2223         }
2224
2225         ndr_err = call->ndr_push(push, NDR_OUT, r);
2226         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2227                 talloc_free(r);
2228                 return false;
2229         }
2230
2231         blob = ndr_push_blob(push);
2232         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2233                 talloc_free(r);
2234                 return false;
2235         }
2236
2237         talloc_free(r);
2238
2239         return true;
2240 }
2241
2242 static bool api_spoolss_WaitForPrinterChange(pipes_struct *p)
2243 {
2244         const struct ndr_interface_call *call;
2245         struct ndr_pull *pull;
2246         struct ndr_push *push;
2247         enum ndr_err_code ndr_err;
2248         DATA_BLOB blob;
2249         struct spoolss_WaitForPrinterChange *r;
2250
2251         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_WAITFORPRINTERCHANGE];
2252
2253         r = talloc(talloc_tos(), struct spoolss_WaitForPrinterChange);
2254         if (r == NULL) {
2255                 return false;
2256         }
2257
2258         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2259                 talloc_free(r);
2260                 return false;
2261         }
2262
2263         pull = ndr_pull_init_blob(&blob, r, NULL);
2264         if (pull == NULL) {
2265                 talloc_free(r);
2266                 return false;
2267         }
2268
2269         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2270         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2271         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2272                 talloc_free(r);
2273                 return false;
2274         }
2275
2276         if (DEBUGLEVEL >= 10) {
2277                 NDR_PRINT_IN_DEBUG(spoolss_WaitForPrinterChange, r);
2278         }
2279
2280         r->out.result = _spoolss_WaitForPrinterChange(p, r);
2281
2282         if (p->rng_fault_state) {
2283                 talloc_free(r);
2284                 /* Return true here, srv_pipe_hnd.c will take care */
2285                 return true;
2286         }
2287
2288         if (DEBUGLEVEL >= 10) {
2289                 NDR_PRINT_OUT_DEBUG(spoolss_WaitForPrinterChange, r);
2290         }
2291
2292         push = ndr_push_init_ctx(r, NULL);
2293         if (push == NULL) {
2294                 talloc_free(r);
2295                 return false;
2296         }
2297
2298         ndr_err = call->ndr_push(push, NDR_OUT, r);
2299         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2300                 talloc_free(r);
2301                 return false;
2302         }
2303
2304         blob = ndr_push_blob(push);
2305         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2306                 talloc_free(r);
2307                 return false;
2308         }
2309
2310         talloc_free(r);
2311
2312         return true;
2313 }
2314
2315 static bool api_spoolss_ClosePrinter(pipes_struct *p)
2316 {
2317         const struct ndr_interface_call *call;
2318         struct ndr_pull *pull;
2319         struct ndr_push *push;
2320         enum ndr_err_code ndr_err;
2321         DATA_BLOB blob;
2322         struct spoolss_ClosePrinter *r;
2323
2324         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_CLOSEPRINTER];
2325
2326         r = talloc(talloc_tos(), struct spoolss_ClosePrinter);
2327         if (r == NULL) {
2328                 return false;
2329         }
2330
2331         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2332                 talloc_free(r);
2333                 return false;
2334         }
2335
2336         pull = ndr_pull_init_blob(&blob, r, NULL);
2337         if (pull == NULL) {
2338                 talloc_free(r);
2339                 return false;
2340         }
2341
2342         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2343         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2344         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2345                 talloc_free(r);
2346                 return false;
2347         }
2348
2349         if (DEBUGLEVEL >= 10) {
2350                 NDR_PRINT_IN_DEBUG(spoolss_ClosePrinter, r);
2351         }
2352
2353         ZERO_STRUCT(r->out);
2354         r->out.handle = r->in.handle;
2355         r->out.result = _spoolss_ClosePrinter(p, r);
2356
2357         if (p->rng_fault_state) {
2358                 talloc_free(r);
2359                 /* Return true here, srv_pipe_hnd.c will take care */
2360                 return true;
2361         }
2362
2363         if (DEBUGLEVEL >= 10) {
2364                 NDR_PRINT_OUT_DEBUG(spoolss_ClosePrinter, r);
2365         }
2366
2367         push = ndr_push_init_ctx(r, NULL);
2368         if (push == NULL) {
2369                 talloc_free(r);
2370                 return false;
2371         }
2372
2373         ndr_err = call->ndr_push(push, NDR_OUT, r);
2374         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2375                 talloc_free(r);
2376                 return false;
2377         }
2378
2379         blob = ndr_push_blob(push);
2380         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2381                 talloc_free(r);
2382                 return false;
2383         }
2384
2385         talloc_free(r);
2386
2387         return true;
2388 }
2389
2390 static bool api_spoolss_AddForm(pipes_struct *p)
2391 {
2392         const struct ndr_interface_call *call;
2393         struct ndr_pull *pull;
2394         struct ndr_push *push;
2395         enum ndr_err_code ndr_err;
2396         DATA_BLOB blob;
2397         struct spoolss_AddForm *r;
2398
2399         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDFORM];
2400
2401         r = talloc(talloc_tos(), struct spoolss_AddForm);
2402         if (r == NULL) {
2403                 return false;
2404         }
2405
2406         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2407                 talloc_free(r);
2408                 return false;
2409         }
2410
2411         pull = ndr_pull_init_blob(&blob, r, NULL);
2412         if (pull == NULL) {
2413                 talloc_free(r);
2414                 return false;
2415         }
2416
2417         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2418         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2419         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2420                 talloc_free(r);
2421                 return false;
2422         }
2423
2424         if (DEBUGLEVEL >= 10) {
2425                 NDR_PRINT_IN_DEBUG(spoolss_AddForm, r);
2426         }
2427
2428         r->out.result = _spoolss_AddForm(p, r);
2429
2430         if (p->rng_fault_state) {
2431                 talloc_free(r);
2432                 /* Return true here, srv_pipe_hnd.c will take care */
2433                 return true;
2434         }
2435
2436         if (DEBUGLEVEL >= 10) {
2437                 NDR_PRINT_OUT_DEBUG(spoolss_AddForm, r);
2438         }
2439
2440         push = ndr_push_init_ctx(r, NULL);
2441         if (push == NULL) {
2442                 talloc_free(r);
2443                 return false;
2444         }
2445
2446         ndr_err = call->ndr_push(push, NDR_OUT, r);
2447         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2448                 talloc_free(r);
2449                 return false;
2450         }
2451
2452         blob = ndr_push_blob(push);
2453         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2454                 talloc_free(r);
2455                 return false;
2456         }
2457
2458         talloc_free(r);
2459
2460         return true;
2461 }
2462
2463 static bool api_spoolss_DeleteForm(pipes_struct *p)
2464 {
2465         const struct ndr_interface_call *call;
2466         struct ndr_pull *pull;
2467         struct ndr_push *push;
2468         enum ndr_err_code ndr_err;
2469         DATA_BLOB blob;
2470         struct spoolss_DeleteForm *r;
2471
2472         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEFORM];
2473
2474         r = talloc(talloc_tos(), struct spoolss_DeleteForm);
2475         if (r == NULL) {
2476                 return false;
2477         }
2478
2479         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2480                 talloc_free(r);
2481                 return false;
2482         }
2483
2484         pull = ndr_pull_init_blob(&blob, r, NULL);
2485         if (pull == NULL) {
2486                 talloc_free(r);
2487                 return false;
2488         }
2489
2490         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2491         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2492         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2493                 talloc_free(r);
2494                 return false;
2495         }
2496
2497         if (DEBUGLEVEL >= 10) {
2498                 NDR_PRINT_IN_DEBUG(spoolss_DeleteForm, r);
2499         }
2500
2501         r->out.result = _spoolss_DeleteForm(p, r);
2502
2503         if (p->rng_fault_state) {
2504                 talloc_free(r);
2505                 /* Return true here, srv_pipe_hnd.c will take care */
2506                 return true;
2507         }
2508
2509         if (DEBUGLEVEL >= 10) {
2510                 NDR_PRINT_OUT_DEBUG(spoolss_DeleteForm, r);
2511         }
2512
2513         push = ndr_push_init_ctx(r, NULL);
2514         if (push == NULL) {
2515                 talloc_free(r);
2516                 return false;
2517         }
2518
2519         ndr_err = call->ndr_push(push, NDR_OUT, r);
2520         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2521                 talloc_free(r);
2522                 return false;
2523         }
2524
2525         blob = ndr_push_blob(push);
2526         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2527                 talloc_free(r);
2528                 return false;
2529         }
2530
2531         talloc_free(r);
2532
2533         return true;
2534 }
2535
2536 static bool api_spoolss_GetForm(pipes_struct *p)
2537 {
2538         const struct ndr_interface_call *call;
2539         struct ndr_pull *pull;
2540         struct ndr_push *push;
2541         enum ndr_err_code ndr_err;
2542         DATA_BLOB blob;
2543         struct spoolss_GetForm *r;
2544
2545         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETFORM];
2546
2547         r = talloc(talloc_tos(), struct spoolss_GetForm);
2548         if (r == NULL) {
2549                 return false;
2550         }
2551
2552         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2553                 talloc_free(r);
2554                 return false;
2555         }
2556
2557         pull = ndr_pull_init_blob(&blob, r, NULL);
2558         if (pull == NULL) {
2559                 talloc_free(r);
2560                 return false;
2561         }
2562
2563         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2564         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2565         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2566                 talloc_free(r);
2567                 return false;
2568         }
2569
2570         if (DEBUGLEVEL >= 10) {
2571                 NDR_PRINT_IN_DEBUG(spoolss_GetForm, r);
2572         }
2573
2574         ZERO_STRUCT(r->out);
2575         r->out.info = talloc_zero(r, union spoolss_FormInfo);
2576         if (r->out.info == NULL) {
2577                 talloc_free(r);
2578                 return false;
2579         }
2580
2581         r->out.needed = talloc_zero(r, uint32_t);
2582         if (r->out.needed == NULL) {
2583                 talloc_free(r);
2584                 return false;
2585         }
2586
2587         r->out.result = _spoolss_GetForm(p, r);
2588
2589         if (p->rng_fault_state) {
2590                 talloc_free(r);
2591                 /* Return true here, srv_pipe_hnd.c will take care */
2592                 return true;
2593         }
2594
2595         if (DEBUGLEVEL >= 10) {
2596                 NDR_PRINT_OUT_DEBUG(spoolss_GetForm, r);
2597         }
2598
2599         push = ndr_push_init_ctx(r, NULL);
2600         if (push == NULL) {
2601                 talloc_free(r);
2602                 return false;
2603         }
2604
2605         ndr_err = call->ndr_push(push, NDR_OUT, r);
2606         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2607                 talloc_free(r);
2608                 return false;
2609         }
2610
2611         blob = ndr_push_blob(push);
2612         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2613                 talloc_free(r);
2614                 return false;
2615         }
2616
2617         talloc_free(r);
2618
2619         return true;
2620 }
2621
2622 static bool api_spoolss_SetForm(pipes_struct *p)
2623 {
2624         const struct ndr_interface_call *call;
2625         struct ndr_pull *pull;
2626         struct ndr_push *push;
2627         enum ndr_err_code ndr_err;
2628         DATA_BLOB blob;
2629         struct spoolss_SetForm *r;
2630
2631         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_SETFORM];
2632
2633         r = talloc(talloc_tos(), struct spoolss_SetForm);
2634         if (r == NULL) {
2635                 return false;
2636         }
2637
2638         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2639                 talloc_free(r);
2640                 return false;
2641         }
2642
2643         pull = ndr_pull_init_blob(&blob, r, NULL);
2644         if (pull == NULL) {
2645                 talloc_free(r);
2646                 return false;
2647         }
2648
2649         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2650         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2651         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2652                 talloc_free(r);
2653                 return false;
2654         }
2655
2656         if (DEBUGLEVEL >= 10) {
2657                 NDR_PRINT_IN_DEBUG(spoolss_SetForm, r);
2658         }
2659
2660         r->out.result = _spoolss_SetForm(p, r);
2661
2662         if (p->rng_fault_state) {
2663                 talloc_free(r);
2664                 /* Return true here, srv_pipe_hnd.c will take care */
2665                 return true;
2666         }
2667
2668         if (DEBUGLEVEL >= 10) {
2669                 NDR_PRINT_OUT_DEBUG(spoolss_SetForm, r);
2670         }
2671
2672         push = ndr_push_init_ctx(r, NULL);
2673         if (push == NULL) {
2674                 talloc_free(r);
2675                 return false;
2676         }
2677
2678         ndr_err = call->ndr_push(push, NDR_OUT, r);
2679         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2680                 talloc_free(r);
2681                 return false;
2682         }
2683
2684         blob = ndr_push_blob(push);
2685         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2686                 talloc_free(r);
2687                 return false;
2688         }
2689
2690         talloc_free(r);
2691
2692         return true;
2693 }
2694
2695 static bool api_spoolss_EnumForms(pipes_struct *p)
2696 {
2697         const struct ndr_interface_call *call;
2698         struct ndr_pull *pull;
2699         struct ndr_push *push;
2700         enum ndr_err_code ndr_err;
2701         DATA_BLOB blob;
2702         struct spoolss_EnumForms *r;
2703
2704         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMFORMS];
2705
2706         r = talloc(talloc_tos(), struct spoolss_EnumForms);
2707         if (r == NULL) {
2708                 return false;
2709         }
2710
2711         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2712                 talloc_free(r);
2713                 return false;
2714         }
2715
2716         pull = ndr_pull_init_blob(&blob, r, NULL);
2717         if (pull == NULL) {
2718                 talloc_free(r);
2719                 return false;
2720         }
2721
2722         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2723         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2724         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2725                 talloc_free(r);
2726                 return false;
2727         }
2728
2729         if (DEBUGLEVEL >= 10) {
2730                 NDR_PRINT_IN_DEBUG(spoolss_EnumForms, r);
2731         }
2732
2733         ZERO_STRUCT(r->out);
2734         r->out.count = talloc_zero(r, uint32_t);
2735         if (r->out.count == NULL) {
2736                 talloc_free(r);
2737                 return false;
2738         }
2739
2740         r->out.info = talloc_zero(r, union spoolss_FormInfo *);
2741         if (r->out.info == NULL) {
2742                 talloc_free(r);
2743                 return false;
2744         }
2745
2746         r->out.needed = talloc_zero(r, uint32_t);
2747         if (r->out.needed == NULL) {
2748                 talloc_free(r);
2749                 return false;
2750         }
2751
2752         r->out.result = _spoolss_EnumForms(p, r);
2753
2754         if (p->rng_fault_state) {
2755                 talloc_free(r);
2756                 /* Return true here, srv_pipe_hnd.c will take care */
2757                 return true;
2758         }
2759
2760         if (DEBUGLEVEL >= 10) {
2761                 NDR_PRINT_OUT_DEBUG(spoolss_EnumForms, r);
2762         }
2763
2764         push = ndr_push_init_ctx(r, NULL);
2765         if (push == NULL) {
2766                 talloc_free(r);
2767                 return false;
2768         }
2769
2770         ndr_err = call->ndr_push(push, NDR_OUT, r);
2771         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2772                 talloc_free(r);
2773                 return false;
2774         }
2775
2776         blob = ndr_push_blob(push);
2777         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2778                 talloc_free(r);
2779                 return false;
2780         }
2781
2782         talloc_free(r);
2783
2784         return true;
2785 }
2786
2787 static bool api_spoolss_EnumPorts(pipes_struct *p)
2788 {
2789         const struct ndr_interface_call *call;
2790         struct ndr_pull *pull;
2791         struct ndr_push *push;
2792         enum ndr_err_code ndr_err;
2793         DATA_BLOB blob;
2794         struct spoolss_EnumPorts *r;
2795
2796         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPORTS];
2797
2798         r = talloc(talloc_tos(), struct spoolss_EnumPorts);
2799         if (r == NULL) {
2800                 return false;
2801         }
2802
2803         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2804                 talloc_free(r);
2805                 return false;
2806         }
2807
2808         pull = ndr_pull_init_blob(&blob, r, NULL);
2809         if (pull == NULL) {
2810                 talloc_free(r);
2811                 return false;
2812         }
2813
2814         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2815         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2816         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2817                 talloc_free(r);
2818                 return false;
2819         }
2820
2821         if (DEBUGLEVEL >= 10) {
2822                 NDR_PRINT_IN_DEBUG(spoolss_EnumPorts, r);
2823         }
2824
2825         ZERO_STRUCT(r->out);
2826         r->out.count = talloc_zero(r, uint32_t);
2827         if (r->out.count == NULL) {
2828                 talloc_free(r);
2829                 return false;
2830         }
2831
2832         r->out.info = talloc_zero(r, union spoolss_PortInfo *);
2833         if (r->out.info == NULL) {
2834                 talloc_free(r);
2835                 return false;
2836         }
2837
2838         r->out.needed = talloc_zero(r, uint32_t);
2839         if (r->out.needed == NULL) {
2840                 talloc_free(r);
2841                 return false;
2842         }
2843
2844         r->out.result = _spoolss_EnumPorts(p, r);
2845
2846         if (p->rng_fault_state) {
2847                 talloc_free(r);
2848                 /* Return true here, srv_pipe_hnd.c will take care */
2849                 return true;
2850         }
2851
2852         if (DEBUGLEVEL >= 10) {
2853                 NDR_PRINT_OUT_DEBUG(spoolss_EnumPorts, r);
2854         }
2855
2856         push = ndr_push_init_ctx(r, NULL);
2857         if (push == NULL) {
2858                 talloc_free(r);
2859                 return false;
2860         }
2861
2862         ndr_err = call->ndr_push(push, NDR_OUT, r);
2863         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2864                 talloc_free(r);
2865                 return false;
2866         }
2867
2868         blob = ndr_push_blob(push);
2869         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2870                 talloc_free(r);
2871                 return false;
2872         }
2873
2874         talloc_free(r);
2875
2876         return true;
2877 }
2878
2879 static bool api_spoolss_EnumMonitors(pipes_struct *p)
2880 {
2881         const struct ndr_interface_call *call;
2882         struct ndr_pull *pull;
2883         struct ndr_push *push;
2884         enum ndr_err_code ndr_err;
2885         DATA_BLOB blob;
2886         struct spoolss_EnumMonitors *r;
2887
2888         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMMONITORS];
2889
2890         r = talloc(talloc_tos(), struct spoolss_EnumMonitors);
2891         if (r == NULL) {
2892                 return false;
2893         }
2894
2895         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2896                 talloc_free(r);
2897                 return false;
2898         }
2899
2900         pull = ndr_pull_init_blob(&blob, r, NULL);
2901         if (pull == NULL) {
2902                 talloc_free(r);
2903                 return false;
2904         }
2905
2906         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2907         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2908         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2909                 talloc_free(r);
2910                 return false;
2911         }
2912
2913         if (DEBUGLEVEL >= 10) {
2914                 NDR_PRINT_IN_DEBUG(spoolss_EnumMonitors, r);
2915         }
2916
2917         ZERO_STRUCT(r->out);
2918         r->out.count = talloc_zero(r, uint32_t);
2919         if (r->out.count == NULL) {
2920                 talloc_free(r);
2921                 return false;
2922         }
2923
2924         r->out.info = talloc_zero(r, union spoolss_MonitorInfo *);
2925         if (r->out.info == NULL) {
2926                 talloc_free(r);
2927                 return false;
2928         }
2929
2930         r->out.needed = talloc_zero(r, uint32_t);
2931         if (r->out.needed == NULL) {
2932                 talloc_free(r);
2933                 return false;
2934         }
2935
2936         r->out.result = _spoolss_EnumMonitors(p, r);
2937
2938         if (p->rng_fault_state) {
2939                 talloc_free(r);
2940                 /* Return true here, srv_pipe_hnd.c will take care */
2941                 return true;
2942         }
2943
2944         if (DEBUGLEVEL >= 10) {
2945                 NDR_PRINT_OUT_DEBUG(spoolss_EnumMonitors, r);
2946         }
2947
2948         push = ndr_push_init_ctx(r, NULL);
2949         if (push == NULL) {
2950                 talloc_free(r);
2951                 return false;
2952         }
2953
2954         ndr_err = call->ndr_push(push, NDR_OUT, r);
2955         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2956                 talloc_free(r);
2957                 return false;
2958         }
2959
2960         blob = ndr_push_blob(push);
2961         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2962                 talloc_free(r);
2963                 return false;
2964         }
2965
2966         talloc_free(r);
2967
2968         return true;
2969 }
2970
2971 static bool api_spoolss_AddPort(pipes_struct *p)
2972 {
2973         const struct ndr_interface_call *call;
2974         struct ndr_pull *pull;
2975         struct ndr_push *push;
2976         enum ndr_err_code ndr_err;
2977         DATA_BLOB blob;
2978         struct spoolss_AddPort *r;
2979
2980         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPORT];
2981
2982         r = talloc(talloc_tos(), struct spoolss_AddPort);
2983         if (r == NULL) {
2984                 return false;
2985         }
2986
2987         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2988                 talloc_free(r);
2989                 return false;
2990         }
2991
2992         pull = ndr_pull_init_blob(&blob, r, NULL);
2993         if (pull == NULL) {
2994                 talloc_free(r);
2995                 return false;
2996         }
2997
2998         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2999         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3000         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3001                 talloc_free(r);
3002                 return false;
3003         }
3004
3005         if (DEBUGLEVEL >= 10) {
3006                 NDR_PRINT_IN_DEBUG(spoolss_AddPort, r);
3007         }
3008
3009         r->out.result = _spoolss_AddPort(p, r);
3010
3011         if (p->rng_fault_state) {
3012                 talloc_free(r);
3013                 /* Return true here, srv_pipe_hnd.c will take care */
3014                 return true;
3015         }
3016
3017         if (DEBUGLEVEL >= 10) {
3018                 NDR_PRINT_OUT_DEBUG(spoolss_AddPort, r);
3019         }
3020
3021         push = ndr_push_init_ctx(r, NULL);
3022         if (push == NULL) {
3023                 talloc_free(r);
3024                 return false;
3025         }
3026
3027         ndr_err = call->ndr_push(push, NDR_OUT, r);
3028         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3029                 talloc_free(r);
3030                 return false;
3031         }
3032
3033         blob = ndr_push_blob(push);
3034         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3035                 talloc_free(r);
3036                 return false;
3037         }
3038
3039         talloc_free(r);
3040
3041         return true;
3042 }
3043
3044 static bool api_spoolss_ConfigurePort(pipes_struct *p)
3045 {
3046         const struct ndr_interface_call *call;
3047         struct ndr_pull *pull;
3048         struct ndr_push *push;
3049         enum ndr_err_code ndr_err;
3050         DATA_BLOB blob;
3051         struct spoolss_ConfigurePort *r;
3052
3053         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_CONFIGUREPORT];
3054
3055         r = talloc(talloc_tos(), struct spoolss_ConfigurePort);
3056         if (r == NULL) {
3057                 return false;
3058         }
3059
3060         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3061                 talloc_free(r);
3062                 return false;
3063         }
3064
3065         pull = ndr_pull_init_blob(&blob, r, NULL);
3066         if (pull == NULL) {
3067                 talloc_free(r);
3068                 return false;
3069         }
3070
3071         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3072         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3073         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3074                 talloc_free(r);
3075                 return false;
3076         }
3077
3078         if (DEBUGLEVEL >= 10) {
3079                 NDR_PRINT_IN_DEBUG(spoolss_ConfigurePort, r);
3080         }
3081
3082         r->out.result = _spoolss_ConfigurePort(p, r);
3083
3084         if (p->rng_fault_state) {
3085                 talloc_free(r);
3086                 /* Return true here, srv_pipe_hnd.c will take care */
3087                 return true;
3088         }
3089
3090         if (DEBUGLEVEL >= 10) {
3091                 NDR_PRINT_OUT_DEBUG(spoolss_ConfigurePort, r);
3092         }
3093
3094         push = ndr_push_init_ctx(r, NULL);
3095         if (push == NULL) {
3096                 talloc_free(r);
3097                 return false;
3098         }
3099
3100         ndr_err = call->ndr_push(push, NDR_OUT, r);
3101         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3102                 talloc_free(r);
3103                 return false;
3104         }
3105
3106         blob = ndr_push_blob(push);
3107         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3108                 talloc_free(r);
3109                 return false;
3110         }
3111
3112         talloc_free(r);
3113
3114         return true;
3115 }
3116
3117 static bool api_spoolss_DeletePort(pipes_struct *p)
3118 {
3119         const struct ndr_interface_call *call;
3120         struct ndr_pull *pull;
3121         struct ndr_push *push;
3122         enum ndr_err_code ndr_err;
3123         DATA_BLOB blob;
3124         struct spoolss_DeletePort *r;
3125
3126         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPORT];
3127
3128         r = talloc(talloc_tos(), struct spoolss_DeletePort);
3129         if (r == NULL) {
3130                 return false;
3131         }
3132
3133         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3134                 talloc_free(r);
3135                 return false;
3136         }
3137
3138         pull = ndr_pull_init_blob(&blob, r, NULL);
3139         if (pull == NULL) {
3140                 talloc_free(r);
3141                 return false;
3142         }
3143
3144         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3145         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3146         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3147                 talloc_free(r);
3148                 return false;
3149         }
3150
3151         if (DEBUGLEVEL >= 10) {
3152                 NDR_PRINT_IN_DEBUG(spoolss_DeletePort, r);
3153         }
3154
3155         r->out.result = _spoolss_DeletePort(p, r);
3156
3157         if (p->rng_fault_state) {
3158                 talloc_free(r);
3159                 /* Return true here, srv_pipe_hnd.c will take care */
3160                 return true;
3161         }
3162
3163         if (DEBUGLEVEL >= 10) {
3164                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePort, r);
3165         }
3166
3167         push = ndr_push_init_ctx(r, NULL);
3168         if (push == NULL) {
3169                 talloc_free(r);
3170                 return false;
3171         }
3172
3173         ndr_err = call->ndr_push(push, NDR_OUT, r);
3174         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3175                 talloc_free(r);
3176                 return false;
3177         }
3178
3179         blob = ndr_push_blob(push);
3180         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3181                 talloc_free(r);
3182                 return false;
3183         }
3184
3185         talloc_free(r);
3186
3187         return true;
3188 }
3189
3190 static bool api_spoolss_CreatePrinterIC(pipes_struct *p)
3191 {
3192         const struct ndr_interface_call *call;
3193         struct ndr_pull *pull;
3194         struct ndr_push *push;
3195         enum ndr_err_code ndr_err;
3196         DATA_BLOB blob;
3197         struct spoolss_CreatePrinterIC *r;
3198
3199         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_CREATEPRINTERIC];
3200
3201         r = talloc(talloc_tos(), struct spoolss_CreatePrinterIC);
3202         if (r == NULL) {
3203                 return false;
3204         }
3205
3206         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3207                 talloc_free(r);
3208                 return false;
3209         }
3210
3211         pull = ndr_pull_init_blob(&blob, r, NULL);
3212         if (pull == NULL) {
3213                 talloc_free(r);
3214                 return false;
3215         }
3216
3217         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3218         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3219         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3220                 talloc_free(r);
3221                 return false;
3222         }
3223
3224         if (DEBUGLEVEL >= 10) {
3225                 NDR_PRINT_IN_DEBUG(spoolss_CreatePrinterIC, r);
3226         }
3227
3228         r->out.result = _spoolss_CreatePrinterIC(p, r);
3229
3230         if (p->rng_fault_state) {
3231                 talloc_free(r);
3232                 /* Return true here, srv_pipe_hnd.c will take care */
3233                 return true;
3234         }
3235
3236         if (DEBUGLEVEL >= 10) {
3237                 NDR_PRINT_OUT_DEBUG(spoolss_CreatePrinterIC, r);
3238         }
3239
3240         push = ndr_push_init_ctx(r, NULL);
3241         if (push == NULL) {
3242                 talloc_free(r);
3243                 return false;
3244         }
3245
3246         ndr_err = call->ndr_push(push, NDR_OUT, r);
3247         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3248                 talloc_free(r);
3249                 return false;
3250         }
3251
3252         blob = ndr_push_blob(push);
3253         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3254                 talloc_free(r);
3255                 return false;
3256         }
3257
3258         talloc_free(r);
3259
3260         return true;
3261 }
3262
3263 static bool api_spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p)
3264 {
3265         const struct ndr_interface_call *call;
3266         struct ndr_pull *pull;
3267         struct ndr_push *push;
3268         enum ndr_err_code ndr_err;
3269         DATA_BLOB blob;
3270         struct spoolss_PlayGDIScriptOnPrinterIC *r;
3271
3272         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC];
3273
3274         r = talloc(talloc_tos(), struct spoolss_PlayGDIScriptOnPrinterIC);
3275         if (r == NULL) {
3276                 return false;
3277         }
3278
3279         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3280                 talloc_free(r);
3281                 return false;
3282         }
3283
3284         pull = ndr_pull_init_blob(&blob, r, NULL);
3285         if (pull == NULL) {
3286                 talloc_free(r);
3287                 return false;
3288         }
3289
3290         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3291         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3292         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3293                 talloc_free(r);
3294                 return false;
3295         }
3296
3297         if (DEBUGLEVEL >= 10) {
3298                 NDR_PRINT_IN_DEBUG(spoolss_PlayGDIScriptOnPrinterIC, r);
3299         }
3300
3301         r->out.result = _spoolss_PlayGDIScriptOnPrinterIC(p, r);
3302
3303         if (p->rng_fault_state) {
3304                 talloc_free(r);
3305                 /* Return true here, srv_pipe_hnd.c will take care */
3306                 return true;
3307         }
3308
3309         if (DEBUGLEVEL >= 10) {
3310                 NDR_PRINT_OUT_DEBUG(spoolss_PlayGDIScriptOnPrinterIC, r);
3311         }
3312
3313         push = ndr_push_init_ctx(r, NULL);
3314         if (push == NULL) {
3315                 talloc_free(r);
3316                 return false;
3317         }
3318
3319         ndr_err = call->ndr_push(push, NDR_OUT, r);
3320         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3321                 talloc_free(r);
3322                 return false;
3323         }
3324
3325         blob = ndr_push_blob(push);
3326         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3327                 talloc_free(r);
3328                 return false;
3329         }
3330
3331         talloc_free(r);
3332
3333         return true;
3334 }
3335
3336 static bool api_spoolss_DeletePrinterIC(pipes_struct *p)
3337 {
3338         const struct ndr_interface_call *call;
3339         struct ndr_pull *pull;
3340         struct ndr_push *push;
3341         enum ndr_err_code ndr_err;
3342         DATA_BLOB blob;
3343         struct spoolss_DeletePrinterIC *r;
3344
3345         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERIC];
3346
3347         r = talloc(talloc_tos(), struct spoolss_DeletePrinterIC);
3348         if (r == NULL) {
3349                 return false;
3350         }
3351
3352         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3353                 talloc_free(r);
3354                 return false;
3355         }
3356
3357         pull = ndr_pull_init_blob(&blob, r, NULL);
3358         if (pull == NULL) {
3359                 talloc_free(r);
3360                 return false;
3361         }
3362
3363         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3364         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3365         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3366                 talloc_free(r);
3367                 return false;
3368         }
3369
3370         if (DEBUGLEVEL >= 10) {
3371                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterIC, r);
3372         }
3373
3374         r->out.result = _spoolss_DeletePrinterIC(p, r);
3375
3376         if (p->rng_fault_state) {
3377                 talloc_free(r);
3378                 /* Return true here, srv_pipe_hnd.c will take care */
3379                 return true;
3380         }
3381
3382         if (DEBUGLEVEL >= 10) {
3383                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterIC, r);
3384         }
3385
3386         push = ndr_push_init_ctx(r, NULL);
3387         if (push == NULL) {
3388                 talloc_free(r);
3389                 return false;
3390         }
3391
3392         ndr_err = call->ndr_push(push, NDR_OUT, r);
3393         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3394                 talloc_free(r);
3395                 return false;
3396         }
3397
3398         blob = ndr_push_blob(push);
3399         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3400                 talloc_free(r);
3401                 return false;
3402         }
3403
3404         talloc_free(r);
3405
3406         return true;
3407 }
3408
3409 static bool api_spoolss_AddPrinterConnection(pipes_struct *p)
3410 {
3411         const struct ndr_interface_call *call;
3412         struct ndr_pull *pull;
3413         struct ndr_push *push;
3414         enum ndr_err_code ndr_err;
3415         DATA_BLOB blob;
3416         struct spoolss_AddPrinterConnection *r;
3417
3418         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTERCONNECTION];
3419
3420         r = talloc(talloc_tos(), struct spoolss_AddPrinterConnection);
3421         if (r == NULL) {
3422                 return false;
3423         }
3424
3425         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3426                 talloc_free(r);
3427                 return false;
3428         }
3429
3430         pull = ndr_pull_init_blob(&blob, r, NULL);
3431         if (pull == NULL) {
3432                 talloc_free(r);
3433                 return false;
3434         }
3435
3436         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3437         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3438         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3439                 talloc_free(r);
3440                 return false;
3441         }
3442
3443         if (DEBUGLEVEL >= 10) {
3444                 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterConnection, r);
3445         }
3446
3447         r->out.result = _spoolss_AddPrinterConnection(p, r);
3448
3449         if (p->rng_fault_state) {
3450                 talloc_free(r);
3451                 /* Return true here, srv_pipe_hnd.c will take care */
3452                 return true;
3453         }
3454
3455         if (DEBUGLEVEL >= 10) {
3456                 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterConnection, r);
3457         }
3458
3459         push = ndr_push_init_ctx(r, NULL);
3460         if (push == NULL) {
3461                 talloc_free(r);
3462                 return false;
3463         }
3464
3465         ndr_err = call->ndr_push(push, NDR_OUT, r);
3466         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3467                 talloc_free(r);
3468                 return false;
3469         }
3470
3471         blob = ndr_push_blob(push);
3472         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3473                 talloc_free(r);
3474                 return false;
3475         }
3476
3477         talloc_free(r);
3478
3479         return true;
3480 }
3481
3482 static bool api_spoolss_DeletePrinterConnection(pipes_struct *p)
3483 {
3484         const struct ndr_interface_call *call;
3485         struct ndr_pull *pull;
3486         struct ndr_push *push;
3487         enum ndr_err_code ndr_err;
3488         DATA_BLOB blob;
3489         struct spoolss_DeletePrinterConnection *r;
3490
3491         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERCONNECTION];
3492
3493         r = talloc(talloc_tos(), struct spoolss_DeletePrinterConnection);
3494         if (r == NULL) {
3495                 return false;
3496         }
3497
3498         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3499                 talloc_free(r);
3500                 return false;
3501         }
3502
3503         pull = ndr_pull_init_blob(&blob, r, NULL);
3504         if (pull == NULL) {
3505                 talloc_free(r);
3506                 return false;
3507         }
3508
3509         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3510         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3511         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3512                 talloc_free(r);
3513                 return false;
3514         }
3515
3516         if (DEBUGLEVEL >= 10) {
3517                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterConnection, r);
3518         }
3519
3520         r->out.result = _spoolss_DeletePrinterConnection(p, r);
3521
3522         if (p->rng_fault_state) {
3523                 talloc_free(r);
3524                 /* Return true here, srv_pipe_hnd.c will take care */
3525                 return true;
3526         }
3527
3528         if (DEBUGLEVEL >= 10) {
3529                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterConnection, r);
3530         }
3531
3532         push = ndr_push_init_ctx(r, NULL);
3533         if (push == NULL) {
3534                 talloc_free(r);
3535                 return false;
3536         }
3537
3538         ndr_err = call->ndr_push(push, NDR_OUT, r);
3539         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3540                 talloc_free(r);
3541                 return false;
3542         }
3543
3544         blob = ndr_push_blob(push);
3545         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3546                 talloc_free(r);
3547                 return false;
3548         }
3549
3550         talloc_free(r);
3551
3552         return true;
3553 }
3554
3555 static bool api_spoolss_PrinterMessageBox(pipes_struct *p)
3556 {
3557         const struct ndr_interface_call *call;
3558         struct ndr_pull *pull;
3559         struct ndr_push *push;
3560         enum ndr_err_code ndr_err;
3561         DATA_BLOB blob;
3562         struct spoolss_PrinterMessageBox *r;
3563
3564         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_PRINTERMESSAGEBOX];
3565
3566         r = talloc(talloc_tos(), struct spoolss_PrinterMessageBox);
3567         if (r == NULL) {
3568                 return false;
3569         }
3570
3571         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3572                 talloc_free(r);
3573                 return false;
3574         }
3575
3576         pull = ndr_pull_init_blob(&blob, r, NULL);
3577         if (pull == NULL) {
3578                 talloc_free(r);
3579                 return false;
3580         }
3581
3582         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3583         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3584         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3585                 talloc_free(r);
3586                 return false;
3587         }
3588
3589         if (DEBUGLEVEL >= 10) {
3590                 NDR_PRINT_IN_DEBUG(spoolss_PrinterMessageBox, r);
3591         }
3592
3593         r->out.result = _spoolss_PrinterMessageBox(p, r);
3594
3595         if (p->rng_fault_state) {
3596                 talloc_free(r);
3597                 /* Return true here, srv_pipe_hnd.c will take care */
3598                 return true;
3599         }
3600
3601         if (DEBUGLEVEL >= 10) {
3602                 NDR_PRINT_OUT_DEBUG(spoolss_PrinterMessageBox, r);
3603         }
3604
3605         push = ndr_push_init_ctx(r, NULL);
3606         if (push == NULL) {
3607                 talloc_free(r);
3608                 return false;
3609         }
3610
3611         ndr_err = call->ndr_push(push, NDR_OUT, r);
3612         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3613                 talloc_free(r);
3614                 return false;
3615         }
3616
3617         blob = ndr_push_blob(push);
3618         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3619                 talloc_free(r);
3620                 return false;
3621         }
3622
3623         talloc_free(r);
3624
3625         return true;
3626 }
3627
3628 static bool api_spoolss_AddMonitor(pipes_struct *p)
3629 {
3630         const struct ndr_interface_call *call;
3631         struct ndr_pull *pull;
3632         struct ndr_push *push;
3633         enum ndr_err_code ndr_err;
3634         DATA_BLOB blob;
3635         struct spoolss_AddMonitor *r;
3636
3637         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDMONITOR];
3638
3639         r = talloc(talloc_tos(), struct spoolss_AddMonitor);
3640         if (r == NULL) {
3641                 return false;
3642         }
3643
3644         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3645                 talloc_free(r);
3646                 return false;
3647         }
3648
3649         pull = ndr_pull_init_blob(&blob, r, NULL);
3650         if (pull == NULL) {
3651                 talloc_free(r);
3652                 return false;
3653         }
3654
3655         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3656         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3657         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3658                 talloc_free(r);
3659                 return false;
3660         }
3661
3662         if (DEBUGLEVEL >= 10) {
3663                 NDR_PRINT_IN_DEBUG(spoolss_AddMonitor, r);
3664         }
3665
3666         r->out.result = _spoolss_AddMonitor(p, r);
3667
3668         if (p->rng_fault_state) {
3669                 talloc_free(r);
3670                 /* Return true here, srv_pipe_hnd.c will take care */
3671                 return true;
3672         }
3673
3674         if (DEBUGLEVEL >= 10) {
3675                 NDR_PRINT_OUT_DEBUG(spoolss_AddMonitor, r);
3676         }
3677
3678         push = ndr_push_init_ctx(r, NULL);
3679         if (push == NULL) {
3680                 talloc_free(r);
3681                 return false;
3682         }
3683
3684         ndr_err = call->ndr_push(push, NDR_OUT, r);
3685         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3686                 talloc_free(r);
3687                 return false;
3688         }
3689
3690         blob = ndr_push_blob(push);
3691         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3692                 talloc_free(r);
3693                 return false;
3694         }
3695
3696         talloc_free(r);
3697
3698         return true;
3699 }
3700
3701 static bool api_spoolss_DeleteMonitor(pipes_struct *p)
3702 {
3703         const struct ndr_interface_call *call;
3704         struct ndr_pull *pull;
3705         struct ndr_push *push;
3706         enum ndr_err_code ndr_err;
3707         DATA_BLOB blob;
3708         struct spoolss_DeleteMonitor *r;
3709
3710         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEMONITOR];
3711
3712         r = talloc(talloc_tos(), struct spoolss_DeleteMonitor);
3713         if (r == NULL) {
3714                 return false;
3715         }
3716
3717         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3718                 talloc_free(r);
3719                 return false;
3720         }
3721
3722         pull = ndr_pull_init_blob(&blob, r, NULL);
3723         if (pull == NULL) {
3724                 talloc_free(r);
3725                 return false;
3726         }
3727
3728         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3729         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3730         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3731                 talloc_free(r);
3732                 return false;
3733         }
3734
3735         if (DEBUGLEVEL >= 10) {
3736                 NDR_PRINT_IN_DEBUG(spoolss_DeleteMonitor, r);
3737         }
3738
3739         r->out.result = _spoolss_DeleteMonitor(p, r);
3740
3741         if (p->rng_fault_state) {
3742                 talloc_free(r);
3743                 /* Return true here, srv_pipe_hnd.c will take care */
3744                 return true;
3745         }
3746
3747         if (DEBUGLEVEL >= 10) {
3748                 NDR_PRINT_OUT_DEBUG(spoolss_DeleteMonitor, r);
3749         }
3750
3751         push = ndr_push_init_ctx(r, NULL);
3752         if (push == NULL) {
3753                 talloc_free(r);
3754                 return false;
3755         }
3756
3757         ndr_err = call->ndr_push(push, NDR_OUT, r);
3758         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3759                 talloc_free(r);
3760                 return false;
3761         }
3762
3763         blob = ndr_push_blob(push);
3764         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3765                 talloc_free(r);
3766                 return false;
3767         }
3768
3769         talloc_free(r);
3770
3771         return true;
3772 }
3773
3774 static bool api_spoolss_DeletePrintProcessor(pipes_struct *p)
3775 {
3776         const struct ndr_interface_call *call;
3777         struct ndr_pull *pull;
3778         struct ndr_push *push;
3779         enum ndr_err_code ndr_err;
3780         DATA_BLOB blob;
3781         struct spoolss_DeletePrintProcessor *r;
3782
3783         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTPROCESSOR];
3784
3785         r = talloc(talloc_tos(), struct spoolss_DeletePrintProcessor);
3786         if (r == NULL) {
3787                 return false;
3788         }
3789
3790         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3791                 talloc_free(r);
3792                 return false;
3793         }
3794
3795         pull = ndr_pull_init_blob(&blob, r, NULL);
3796         if (pull == NULL) {
3797                 talloc_free(r);
3798                 return false;
3799         }
3800
3801         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3802         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3803         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3804                 talloc_free(r);
3805                 return false;
3806         }
3807
3808         if (DEBUGLEVEL >= 10) {
3809                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrintProcessor, r);
3810         }
3811
3812         r->out.result = _spoolss_DeletePrintProcessor(p, r);
3813
3814         if (p->rng_fault_state) {
3815                 talloc_free(r);
3816                 /* Return true here, srv_pipe_hnd.c will take care */
3817                 return true;
3818         }
3819
3820         if (DEBUGLEVEL >= 10) {
3821                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrintProcessor, r);
3822         }
3823
3824         push = ndr_push_init_ctx(r, NULL);
3825         if (push == NULL) {
3826                 talloc_free(r);
3827                 return false;
3828         }
3829
3830         ndr_err = call->ndr_push(push, NDR_OUT, r);
3831         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3832                 talloc_free(r);
3833                 return false;
3834         }
3835
3836         blob = ndr_push_blob(push);
3837         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3838                 talloc_free(r);
3839                 return false;
3840         }
3841
3842         talloc_free(r);
3843
3844         return true;
3845 }
3846
3847 static bool api_spoolss_AddPrintProvidor(pipes_struct *p)
3848 {
3849         const struct ndr_interface_call *call;
3850         struct ndr_pull *pull;
3851         struct ndr_push *push;
3852         enum ndr_err_code ndr_err;
3853         DATA_BLOB blob;
3854         struct spoolss_AddPrintProvidor *r;
3855
3856         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTPROVIDOR];
3857
3858         r = talloc(talloc_tos(), struct spoolss_AddPrintProvidor);
3859         if (r == NULL) {
3860                 return false;
3861         }
3862
3863         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3864                 talloc_free(r);
3865                 return false;
3866         }
3867
3868         pull = ndr_pull_init_blob(&blob, r, NULL);
3869         if (pull == NULL) {
3870                 talloc_free(r);
3871                 return false;
3872         }
3873
3874         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3875         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3876         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3877                 talloc_free(r);
3878                 return false;
3879         }
3880
3881         if (DEBUGLEVEL >= 10) {
3882                 NDR_PRINT_IN_DEBUG(spoolss_AddPrintProvidor, r);
3883         }
3884
3885         r->out.result = _spoolss_AddPrintProvidor(p, r);
3886
3887         if (p->rng_fault_state) {
3888                 talloc_free(r);
3889                 /* Return true here, srv_pipe_hnd.c will take care */
3890                 return true;
3891         }
3892
3893         if (DEBUGLEVEL >= 10) {
3894                 NDR_PRINT_OUT_DEBUG(spoolss_AddPrintProvidor, r);
3895         }
3896
3897         push = ndr_push_init_ctx(r, NULL);
3898         if (push == NULL) {
3899                 talloc_free(r);
3900                 return false;
3901         }
3902
3903         ndr_err = call->ndr_push(push, NDR_OUT, r);
3904         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3905                 talloc_free(r);
3906                 return false;
3907         }
3908
3909         blob = ndr_push_blob(push);
3910         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3911                 talloc_free(r);
3912                 return false;
3913         }
3914
3915         talloc_free(r);
3916
3917         return true;
3918 }
3919
3920 static bool api_spoolss_DeletePrintProvidor(pipes_struct *p)
3921 {
3922         const struct ndr_interface_call *call;
3923         struct ndr_pull *pull;
3924         struct ndr_push *push;
3925         enum ndr_err_code ndr_err;
3926         DATA_BLOB blob;
3927         struct spoolss_DeletePrintProvidor *r;
3928
3929         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTPROVIDOR];
3930
3931         r = talloc(talloc_tos(), struct spoolss_DeletePrintProvidor);
3932         if (r == NULL) {
3933                 return false;
3934         }
3935
3936         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3937                 talloc_free(r);
3938                 return false;
3939         }
3940
3941         pull = ndr_pull_init_blob(&blob, r, NULL);
3942         if (pull == NULL) {
3943                 talloc_free(r);
3944                 return false;
3945         }
3946
3947         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3948         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3949         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3950                 talloc_free(r);
3951                 return false;
3952         }
3953
3954         if (DEBUGLEVEL >= 10) {
3955                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrintProvidor, r);
3956         }
3957
3958         r->out.result = _spoolss_DeletePrintProvidor(p, r);
3959
3960         if (p->rng_fault_state) {
3961                 talloc_free(r);
3962                 /* Return true here, srv_pipe_hnd.c will take care */
3963                 return true;
3964         }
3965
3966         if (DEBUGLEVEL >= 10) {
3967                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrintProvidor, r);
3968         }
3969
3970         push = ndr_push_init_ctx(r, NULL);
3971         if (push == NULL) {
3972                 talloc_free(r);
3973                 return false;
3974         }
3975
3976         ndr_err = call->ndr_push(push, NDR_OUT, r);
3977         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3978                 talloc_free(r);
3979                 return false;
3980         }
3981
3982         blob = ndr_push_blob(push);
3983         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3984                 talloc_free(r);
3985                 return false;
3986         }
3987
3988         talloc_free(r);
3989
3990         return true;
3991 }
3992
3993 static bool api_spoolss_EnumPrintProcDataTypes(pipes_struct *p)
3994 {
3995         const struct ndr_interface_call *call;
3996         struct ndr_pull *pull;
3997         struct ndr_push *push;
3998         enum ndr_err_code ndr_err;
3999         DATA_BLOB blob;
4000         struct spoolss_EnumPrintProcDataTypes *r;
4001
4002         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPRINTPROCDATATYPES];
4003
4004         r = talloc(talloc_tos(), struct spoolss_EnumPrintProcDataTypes);
4005         if (r == NULL) {
4006                 return false;
4007         }
4008
4009         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4010                 talloc_free(r);
4011                 return false;
4012         }
4013
4014         pull = ndr_pull_init_blob(&blob, r, NULL);
4015         if (pull == NULL) {
4016                 talloc_free(r);
4017                 return false;
4018         }
4019
4020         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4021         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4022         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4023                 talloc_free(r);
4024                 return false;
4025         }
4026
4027         if (DEBUGLEVEL >= 10) {
4028                 NDR_PRINT_IN_DEBUG(spoolss_EnumPrintProcDataTypes, r);
4029         }
4030
4031         ZERO_STRUCT(r->out);
4032         r->out.count = talloc_zero(r, uint32_t);
4033         if (r->out.count == NULL) {
4034                 talloc_free(r);
4035                 return false;
4036         }
4037
4038         r->out.info = talloc_zero(r, union spoolss_PrintProcDataTypesInfo *);
4039         if (r->out.info == NULL) {
4040                 talloc_free(r);
4041                 return false;
4042         }
4043
4044         r->out.needed = talloc_zero(r, uint32_t);
4045         if (r->out.needed == NULL) {
4046                 talloc_free(r);
4047                 return false;
4048         }
4049
4050         r->out.result = _spoolss_EnumPrintProcDataTypes(p, r);
4051
4052         if (p->rng_fault_state) {
4053                 talloc_free(r);
4054                 /* Return true here, srv_pipe_hnd.c will take care */
4055                 return true;
4056         }
4057
4058         if (DEBUGLEVEL >= 10) {
4059                 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrintProcDataTypes, r);
4060         }
4061
4062         push = ndr_push_init_ctx(r, NULL);
4063         if (push == NULL) {
4064                 talloc_free(r);
4065                 return false;
4066         }
4067
4068         ndr_err = call->ndr_push(push, NDR_OUT, r);
4069         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4070                 talloc_free(r);
4071                 return false;
4072         }
4073
4074         blob = ndr_push_blob(push);
4075         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4076                 talloc_free(r);
4077                 return false;
4078         }
4079
4080         talloc_free(r);
4081
4082         return true;
4083 }
4084
4085 static bool api_spoolss_ResetPrinter(pipes_struct *p)
4086 {
4087         const struct ndr_interface_call *call;
4088         struct ndr_pull *pull;
4089         struct ndr_push *push;
4090         enum ndr_err_code ndr_err;
4091         DATA_BLOB blob;
4092         struct spoolss_ResetPrinter *r;
4093
4094         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_RESETPRINTER];
4095
4096         r = talloc(talloc_tos(), struct spoolss_ResetPrinter);
4097         if (r == NULL) {
4098                 return false;
4099         }
4100
4101         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4102                 talloc_free(r);
4103                 return false;
4104         }
4105
4106         pull = ndr_pull_init_blob(&blob, r, NULL);
4107         if (pull == NULL) {
4108                 talloc_free(r);
4109                 return false;
4110         }
4111
4112         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4113         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4114         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4115                 talloc_free(r);
4116                 return false;
4117         }
4118
4119         if (DEBUGLEVEL >= 10) {
4120                 NDR_PRINT_IN_DEBUG(spoolss_ResetPrinter, r);
4121         }
4122
4123         r->out.result = _spoolss_ResetPrinter(p, r);
4124
4125         if (p->rng_fault_state) {
4126                 talloc_free(r);
4127                 /* Return true here, srv_pipe_hnd.c will take care */
4128                 return true;
4129         }
4130
4131         if (DEBUGLEVEL >= 10) {
4132                 NDR_PRINT_OUT_DEBUG(spoolss_ResetPrinter, r);
4133         }
4134
4135         push = ndr_push_init_ctx(r, NULL);
4136         if (push == NULL) {
4137                 talloc_free(r);
4138                 return false;
4139         }
4140
4141         ndr_err = call->ndr_push(push, NDR_OUT, r);
4142         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4143                 talloc_free(r);
4144                 return false;
4145         }
4146
4147         blob = ndr_push_blob(push);
4148         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4149                 talloc_free(r);
4150                 return false;
4151         }
4152
4153         talloc_free(r);
4154
4155         return true;
4156 }
4157
4158 static bool api_spoolss_GetPrinterDriver2(pipes_struct *p)
4159 {
4160         const struct ndr_interface_call *call;
4161         struct ndr_pull *pull;
4162         struct ndr_push *push;
4163         enum ndr_err_code ndr_err;
4164         DATA_BLOB blob;
4165         struct spoolss_GetPrinterDriver2 *r;
4166
4167         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTERDRIVER2];
4168
4169         r = talloc(talloc_tos(), struct spoolss_GetPrinterDriver2);
4170         if (r == NULL) {
4171                 return false;
4172         }
4173
4174         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4175                 talloc_free(r);
4176                 return false;
4177         }
4178
4179         pull = ndr_pull_init_blob(&blob, r, NULL);
4180         if (pull == NULL) {
4181                 talloc_free(r);
4182                 return false;
4183         }
4184
4185         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4186         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4187         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4188                 talloc_free(r);
4189                 return false;
4190         }
4191
4192         if (DEBUGLEVEL >= 10) {
4193                 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriver2, r);
4194         }
4195
4196         ZERO_STRUCT(r->out);
4197         r->out.info = talloc_zero(r, union spoolss_DriverInfo);
4198         if (r->out.info == NULL) {
4199                 talloc_free(r);
4200                 return false;
4201         }
4202
4203         r->out.needed = talloc_zero(r, uint32_t);
4204         if (r->out.needed == NULL) {
4205                 talloc_free(r);
4206                 return false;
4207         }
4208
4209         r->out.server_major_version = talloc_zero(r, uint32_t);
4210         if (r->out.server_major_version == NULL) {
4211                 talloc_free(r);
4212                 return false;
4213         }
4214
4215         r->out.server_minor_version = talloc_zero(r, uint32_t);
4216         if (r->out.server_minor_version == NULL) {
4217                 talloc_free(r);
4218                 return false;
4219         }
4220
4221         r->out.result = _spoolss_GetPrinterDriver2(p, r);
4222
4223         if (p->rng_fault_state) {
4224                 talloc_free(r);
4225                 /* Return true here, srv_pipe_hnd.c will take care */
4226                 return true;
4227         }
4228
4229         if (DEBUGLEVEL >= 10) {
4230                 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriver2, r);
4231         }
4232
4233         push = ndr_push_init_ctx(r, NULL);
4234         if (push == NULL) {
4235                 talloc_free(r);
4236                 return false;
4237         }
4238
4239         ndr_err = call->ndr_push(push, NDR_OUT, r);
4240         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4241                 talloc_free(r);
4242                 return false;
4243         }
4244
4245         blob = ndr_push_blob(push);
4246         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4247                 talloc_free(r);
4248                 return false;
4249         }
4250
4251         talloc_free(r);
4252
4253         return true;
4254 }
4255
4256 static bool api_spoolss_FindFirstPrinterChangeNotification(pipes_struct *p)
4257 {
4258         const struct ndr_interface_call *call;
4259         struct ndr_pull *pull;
4260         struct ndr_push *push;
4261         enum ndr_err_code ndr_err;
4262         DATA_BLOB blob;
4263         struct spoolss_FindFirstPrinterChangeNotification *r;
4264
4265         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION];
4266
4267         r = talloc(talloc_tos(), struct spoolss_FindFirstPrinterChangeNotification);
4268         if (r == NULL) {
4269                 return false;
4270         }
4271
4272         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4273                 talloc_free(r);
4274                 return false;
4275         }
4276
4277         pull = ndr_pull_init_blob(&blob, r, NULL);
4278         if (pull == NULL) {
4279                 talloc_free(r);
4280                 return false;
4281         }
4282
4283         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4284         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4285         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4286                 talloc_free(r);
4287                 return false;
4288         }
4289
4290         if (DEBUGLEVEL >= 10) {
4291                 NDR_PRINT_IN_DEBUG(spoolss_FindFirstPrinterChangeNotification, r);
4292         }
4293
4294         r->out.result = _spoolss_FindFirstPrinterChangeNotification(p, r);
4295
4296         if (p->rng_fault_state) {
4297                 talloc_free(r);
4298                 /* Return true here, srv_pipe_hnd.c will take care */
4299                 return true;
4300         }
4301
4302         if (DEBUGLEVEL >= 10) {
4303                 NDR_PRINT_OUT_DEBUG(spoolss_FindFirstPrinterChangeNotification, r);
4304         }
4305
4306         push = ndr_push_init_ctx(r, NULL);
4307         if (push == NULL) {
4308                 talloc_free(r);
4309                 return false;
4310         }
4311
4312         ndr_err = call->ndr_push(push, NDR_OUT, r);
4313         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4314                 talloc_free(r);
4315                 return false;
4316         }
4317
4318         blob = ndr_push_blob(push);
4319         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4320                 talloc_free(r);
4321                 return false;
4322         }
4323
4324         talloc_free(r);
4325
4326         return true;
4327 }
4328
4329 static bool api_spoolss_FindNextPrinterChangeNotification(pipes_struct *p)
4330 {
4331         const struct ndr_interface_call *call;
4332         struct ndr_pull *pull;
4333         struct ndr_push *push;
4334         enum ndr_err_code ndr_err;
4335         DATA_BLOB blob;
4336         struct spoolss_FindNextPrinterChangeNotification *r;
4337
4338         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION];
4339
4340         r = talloc(talloc_tos(), struct spoolss_FindNextPrinterChangeNotification);
4341         if (r == NULL) {
4342                 return false;
4343         }
4344
4345         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4346                 talloc_free(r);
4347                 return false;
4348         }
4349
4350         pull = ndr_pull_init_blob(&blob, r, NULL);
4351         if (pull == NULL) {
4352                 talloc_free(r);
4353                 return false;
4354         }
4355
4356         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4357         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4358         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4359                 talloc_free(r);
4360                 return false;
4361         }
4362
4363         if (DEBUGLEVEL >= 10) {
4364                 NDR_PRINT_IN_DEBUG(spoolss_FindNextPrinterChangeNotification, r);
4365         }
4366
4367         r->out.result = _spoolss_FindNextPrinterChangeNotification(p, r);
4368
4369         if (p->rng_fault_state) {
4370                 talloc_free(r);
4371                 /* Return true here, srv_pipe_hnd.c will take care */
4372                 return true;
4373         }
4374
4375         if (DEBUGLEVEL >= 10) {
4376                 NDR_PRINT_OUT_DEBUG(spoolss_FindNextPrinterChangeNotification, r);
4377         }
4378
4379         push = ndr_push_init_ctx(r, NULL);
4380         if (push == NULL) {
4381                 talloc_free(r);
4382                 return false;
4383         }
4384
4385         ndr_err = call->ndr_push(push, NDR_OUT, r);
4386         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4387                 talloc_free(r);
4388                 return false;
4389         }
4390
4391         blob = ndr_push_blob(push);
4392         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4393                 talloc_free(r);
4394                 return false;
4395         }
4396
4397         talloc_free(r);
4398
4399         return true;
4400 }
4401
4402 static bool api_spoolss_FindClosePrinterNotify(pipes_struct *p)
4403 {
4404         const struct ndr_interface_call *call;
4405         struct ndr_pull *pull;
4406         struct ndr_push *push;
4407         enum ndr_err_code ndr_err;
4408         DATA_BLOB blob;
4409         struct spoolss_FindClosePrinterNotify *r;
4410
4411         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY];
4412
4413         r = talloc(talloc_tos(), struct spoolss_FindClosePrinterNotify);
4414         if (r == NULL) {
4415                 return false;
4416         }
4417
4418         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4419                 talloc_free(r);
4420                 return false;
4421         }
4422
4423         pull = ndr_pull_init_blob(&blob, r, NULL);
4424         if (pull == NULL) {
4425                 talloc_free(r);
4426                 return false;
4427         }
4428
4429         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4430         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4431         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4432                 talloc_free(r);
4433                 return false;
4434         }
4435
4436         if (DEBUGLEVEL >= 10) {
4437                 NDR_PRINT_IN_DEBUG(spoolss_FindClosePrinterNotify, r);
4438         }
4439
4440         r->out.result = _spoolss_FindClosePrinterNotify(p, r);
4441
4442         if (p->rng_fault_state) {
4443                 talloc_free(r);
4444                 /* Return true here, srv_pipe_hnd.c will take care */
4445                 return true;
4446         }
4447
4448         if (DEBUGLEVEL >= 10) {
4449                 NDR_PRINT_OUT_DEBUG(spoolss_FindClosePrinterNotify, r);
4450         }
4451
4452         push = ndr_push_init_ctx(r, NULL);
4453         if (push == NULL) {
4454                 talloc_free(r);
4455                 return false;
4456         }
4457
4458         ndr_err = call->ndr_push(push, NDR_OUT, r);
4459         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4460                 talloc_free(r);
4461                 return false;
4462         }
4463
4464         blob = ndr_push_blob(push);
4465         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4466                 talloc_free(r);
4467                 return false;
4468         }
4469
4470         talloc_free(r);
4471
4472         return true;
4473 }
4474
4475 static bool api_spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p)
4476 {
4477         const struct ndr_interface_call *call;
4478         struct ndr_pull *pull;
4479         struct ndr_push *push;
4480         enum ndr_err_code ndr_err;
4481         DATA_BLOB blob;
4482         struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r;
4483
4484         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD];
4485
4486         r = talloc(talloc_tos(), struct spoolss_RouterFindFirstPrinterChangeNotificationOld);
4487         if (r == NULL) {
4488                 return false;
4489         }
4490
4491         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4492                 talloc_free(r);
4493                 return false;
4494         }
4495
4496         pull = ndr_pull_init_blob(&blob, r, NULL);
4497         if (pull == NULL) {
4498                 talloc_free(r);
4499                 return false;
4500         }
4501
4502         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4503         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4504         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4505                 talloc_free(r);
4506                 return false;
4507         }
4508
4509         if (DEBUGLEVEL >= 10) {
4510                 NDR_PRINT_IN_DEBUG(spoolss_RouterFindFirstPrinterChangeNotificationOld, r);
4511         }
4512
4513         r->out.result = _spoolss_RouterFindFirstPrinterChangeNotificationOld(p, r);
4514
4515         if (p->rng_fault_state) {
4516                 talloc_free(r);
4517                 /* Return true here, srv_pipe_hnd.c will take care */
4518                 return true;
4519         }
4520
4521         if (DEBUGLEVEL >= 10) {
4522                 NDR_PRINT_OUT_DEBUG(spoolss_RouterFindFirstPrinterChangeNotificationOld, r);
4523         }
4524
4525         push = ndr_push_init_ctx(r, NULL);
4526         if (push == NULL) {
4527                 talloc_free(r);
4528                 return false;
4529         }
4530
4531         ndr_err = call->ndr_push(push, NDR_OUT, r);
4532         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4533                 talloc_free(r);
4534                 return false;
4535         }
4536
4537         blob = ndr_push_blob(push);
4538         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4539                 talloc_free(r);
4540                 return false;
4541         }
4542
4543         talloc_free(r);
4544
4545         return true;
4546 }
4547
4548 static bool api_spoolss_ReplyOpenPrinter(pipes_struct *p)
4549 {
4550         const struct ndr_interface_call *call;
4551         struct ndr_pull *pull;
4552         struct ndr_push *push;
4553         enum ndr_err_code ndr_err;
4554         DATA_BLOB blob;
4555         struct spoolss_ReplyOpenPrinter *r;
4556
4557         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_REPLYOPENPRINTER];
4558
4559         r = talloc(talloc_tos(), struct spoolss_ReplyOpenPrinter);
4560         if (r == NULL) {
4561                 return false;
4562         }
4563
4564         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4565                 talloc_free(r);
4566                 return false;
4567         }
4568
4569         pull = ndr_pull_init_blob(&blob, r, NULL);
4570         if (pull == NULL) {
4571                 talloc_free(r);
4572                 return false;
4573         }
4574
4575         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4576         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4577         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4578                 talloc_free(r);
4579                 return false;
4580         }
4581
4582         if (DEBUGLEVEL >= 10) {
4583                 NDR_PRINT_IN_DEBUG(spoolss_ReplyOpenPrinter, r);
4584         }
4585
4586         ZERO_STRUCT(r->out);
4587         r->out.handle = talloc_zero(r, struct policy_handle);
4588         if (r->out.handle == NULL) {
4589                 talloc_free(r);
4590                 return false;
4591         }
4592
4593         r->out.result = _spoolss_ReplyOpenPrinter(p, r);
4594
4595         if (p->rng_fault_state) {
4596                 talloc_free(r);
4597                 /* Return true here, srv_pipe_hnd.c will take care */
4598                 return true;
4599         }
4600
4601         if (DEBUGLEVEL >= 10) {
4602                 NDR_PRINT_OUT_DEBUG(spoolss_ReplyOpenPrinter, r);
4603         }
4604
4605         push = ndr_push_init_ctx(r, NULL);
4606         if (push == NULL) {
4607                 talloc_free(r);
4608                 return false;
4609         }
4610
4611         ndr_err = call->ndr_push(push, NDR_OUT, r);
4612         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4613                 talloc_free(r);
4614                 return false;
4615         }
4616
4617         blob = ndr_push_blob(push);
4618         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4619                 talloc_free(r);
4620                 return false;
4621         }
4622
4623         talloc_free(r);
4624
4625         return true;
4626 }
4627
4628 static bool api_spoolss_RouterReplyPrinter(pipes_struct *p)
4629 {
4630         const struct ndr_interface_call *call;
4631         struct ndr_pull *pull;
4632         struct ndr_push *push;
4633         enum ndr_err_code ndr_err;
4634         DATA_BLOB blob;
4635         struct spoolss_RouterReplyPrinter *r;
4636
4637         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ROUTERREPLYPRINTER];
4638
4639         r = talloc(talloc_tos(), struct spoolss_RouterReplyPrinter);
4640         if (r == NULL) {
4641                 return false;
4642         }
4643
4644         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4645                 talloc_free(r);
4646                 return false;
4647         }
4648
4649         pull = ndr_pull_init_blob(&blob, r, NULL);
4650         if (pull == NULL) {
4651                 talloc_free(r);
4652                 return false;
4653         }
4654
4655         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4656         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4657         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4658                 talloc_free(r);
4659                 return false;
4660         }
4661
4662         if (DEBUGLEVEL >= 10) {
4663                 NDR_PRINT_IN_DEBUG(spoolss_RouterReplyPrinter, r);
4664         }
4665
4666         r->out.result = _spoolss_RouterReplyPrinter(p, r);
4667
4668         if (p->rng_fault_state) {
4669                 talloc_free(r);
4670                 /* Return true here, srv_pipe_hnd.c will take care */
4671                 return true;
4672         }
4673
4674         if (DEBUGLEVEL >= 10) {
4675                 NDR_PRINT_OUT_DEBUG(spoolss_RouterReplyPrinter, r);
4676         }
4677
4678         push = ndr_push_init_ctx(r, NULL);
4679         if (push == NULL) {
4680                 talloc_free(r);
4681                 return false;
4682         }
4683
4684         ndr_err = call->ndr_push(push, NDR_OUT, r);
4685         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4686                 talloc_free(r);
4687                 return false;
4688         }
4689
4690         blob = ndr_push_blob(push);
4691         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4692                 talloc_free(r);
4693                 return false;
4694         }
4695
4696         talloc_free(r);
4697
4698         return true;
4699 }
4700
4701 static bool api_spoolss_ReplyClosePrinter(pipes_struct *p)
4702 {
4703         const struct ndr_interface_call *call;
4704         struct ndr_pull *pull;
4705         struct ndr_push *push;
4706         enum ndr_err_code ndr_err;
4707         DATA_BLOB blob;
4708         struct spoolss_ReplyClosePrinter *r;
4709
4710         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_REPLYCLOSEPRINTER];
4711
4712         r = talloc(talloc_tos(), struct spoolss_ReplyClosePrinter);
4713         if (r == NULL) {
4714                 return false;
4715         }
4716
4717         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4718                 talloc_free(r);
4719                 return false;
4720         }
4721
4722         pull = ndr_pull_init_blob(&blob, r, NULL);
4723         if (pull == NULL) {
4724                 talloc_free(r);
4725                 return false;
4726         }
4727
4728         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4729         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4730         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4731                 talloc_free(r);
4732                 return false;
4733         }
4734
4735         if (DEBUGLEVEL >= 10) {
4736                 NDR_PRINT_IN_DEBUG(spoolss_ReplyClosePrinter, r);
4737         }
4738
4739         ZERO_STRUCT(r->out);
4740         r->out.handle = r->in.handle;
4741         r->out.result = _spoolss_ReplyClosePrinter(p, r);
4742
4743         if (p->rng_fault_state) {
4744                 talloc_free(r);
4745                 /* Return true here, srv_pipe_hnd.c will take care */
4746                 return true;
4747         }
4748
4749         if (DEBUGLEVEL >= 10) {
4750                 NDR_PRINT_OUT_DEBUG(spoolss_ReplyClosePrinter, r);
4751         }
4752
4753         push = ndr_push_init_ctx(r, NULL);
4754         if (push == NULL) {
4755                 talloc_free(r);
4756                 return false;
4757         }
4758
4759         ndr_err = call->ndr_push(push, NDR_OUT, r);
4760         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4761                 talloc_free(r);
4762                 return false;
4763         }
4764
4765         blob = ndr_push_blob(push);
4766         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4767                 talloc_free(r);
4768                 return false;
4769         }
4770
4771         talloc_free(r);
4772
4773         return true;
4774 }
4775
4776 static bool api_spoolss_AddPortEx(pipes_struct *p)
4777 {
4778         const struct ndr_interface_call *call;
4779         struct ndr_pull *pull;
4780         struct ndr_push *push;
4781         enum ndr_err_code ndr_err;
4782         DATA_BLOB blob;
4783         struct spoolss_AddPortEx *r;
4784
4785         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPORTEX];
4786
4787         r = talloc(talloc_tos(), struct spoolss_AddPortEx);
4788         if (r == NULL) {
4789                 return false;
4790         }
4791
4792         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4793                 talloc_free(r);
4794                 return false;
4795         }
4796
4797         pull = ndr_pull_init_blob(&blob, r, NULL);
4798         if (pull == NULL) {
4799                 talloc_free(r);
4800                 return false;
4801         }
4802
4803         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4804         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4805         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4806                 talloc_free(r);
4807                 return false;
4808         }
4809
4810         if (DEBUGLEVEL >= 10) {
4811                 NDR_PRINT_IN_DEBUG(spoolss_AddPortEx, r);
4812         }
4813
4814         r->out.result = _spoolss_AddPortEx(p, r);
4815
4816         if (p->rng_fault_state) {
4817                 talloc_free(r);
4818                 /* Return true here, srv_pipe_hnd.c will take care */
4819                 return true;
4820         }
4821
4822         if (DEBUGLEVEL >= 10) {
4823                 NDR_PRINT_OUT_DEBUG(spoolss_AddPortEx, r);
4824         }
4825
4826         push = ndr_push_init_ctx(r, NULL);
4827         if (push == NULL) {
4828                 talloc_free(r);
4829                 return false;
4830         }
4831
4832         ndr_err = call->ndr_push(push, NDR_OUT, r);
4833         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4834                 talloc_free(r);
4835                 return false;
4836         }
4837
4838         blob = ndr_push_blob(push);
4839         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4840                 talloc_free(r);
4841                 return false;
4842         }
4843
4844         talloc_free(r);
4845
4846         return true;
4847 }
4848
4849 static bool api_spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p)
4850 {
4851         const struct ndr_interface_call *call;
4852         struct ndr_pull *pull;
4853         struct ndr_push *push;
4854         enum ndr_err_code ndr_err;
4855         DATA_BLOB blob;
4856         struct spoolss_RouterFindFirstPrinterChangeNotification *r;
4857
4858         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION];
4859
4860         r = talloc(talloc_tos(), struct spoolss_RouterFindFirstPrinterChangeNotification);
4861         if (r == NULL) {
4862                 return false;
4863         }
4864
4865         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4866                 talloc_free(r);
4867                 return false;
4868         }
4869
4870         pull = ndr_pull_init_blob(&blob, r, NULL);
4871         if (pull == NULL) {
4872                 talloc_free(r);
4873                 return false;
4874         }
4875
4876         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4877         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4878         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4879                 talloc_free(r);
4880                 return false;
4881         }
4882
4883         if (DEBUGLEVEL >= 10) {
4884                 NDR_PRINT_IN_DEBUG(spoolss_RouterFindFirstPrinterChangeNotification, r);
4885         }
4886
4887         r->out.result = _spoolss_RouterFindFirstPrinterChangeNotification(p, r);
4888
4889         if (p->rng_fault_state) {
4890                 talloc_free(r);
4891                 /* Return true here, srv_pipe_hnd.c will take care */
4892                 return true;
4893         }
4894
4895         if (DEBUGLEVEL >= 10) {
4896                 NDR_PRINT_OUT_DEBUG(spoolss_RouterFindFirstPrinterChangeNotification, r);
4897         }
4898
4899         push = ndr_push_init_ctx(r, NULL);
4900         if (push == NULL) {
4901                 talloc_free(r);
4902                 return false;
4903         }
4904
4905         ndr_err = call->ndr_push(push, NDR_OUT, r);
4906         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4907                 talloc_free(r);
4908                 return false;
4909         }
4910
4911         blob = ndr_push_blob(push);
4912         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4913                 talloc_free(r);
4914                 return false;
4915         }
4916
4917         talloc_free(r);
4918
4919         return true;
4920 }
4921
4922 static bool api_spoolss_SpoolerInit(pipes_struct *p)
4923 {
4924         const struct ndr_interface_call *call;
4925         struct ndr_pull *pull;
4926         struct ndr_push *push;
4927         enum ndr_err_code ndr_err;
4928         DATA_BLOB blob;
4929         struct spoolss_SpoolerInit *r;
4930
4931         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_SPOOLERINIT];
4932
4933         r = talloc(talloc_tos(), struct spoolss_SpoolerInit);
4934         if (r == NULL) {
4935                 return false;
4936         }
4937
4938         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4939                 talloc_free(r);
4940                 return false;
4941         }
4942
4943         pull = ndr_pull_init_blob(&blob, r, NULL);
4944         if (pull == NULL) {
4945                 talloc_free(r);
4946                 return false;
4947         }
4948
4949         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4950         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4951         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4952                 talloc_free(r);
4953                 return false;
4954         }
4955
4956         if (DEBUGLEVEL >= 10) {
4957                 NDR_PRINT_IN_DEBUG(spoolss_SpoolerInit, r);
4958         }
4959
4960         r->out.result = _spoolss_SpoolerInit(p, r);
4961
4962         if (p->rng_fault_state) {
4963                 talloc_free(r);
4964                 /* Return true here, srv_pipe_hnd.c will take care */
4965                 return true;
4966         }
4967
4968         if (DEBUGLEVEL >= 10) {
4969                 NDR_PRINT_OUT_DEBUG(spoolss_SpoolerInit, r);
4970         }
4971
4972         push = ndr_push_init_ctx(r, NULL);
4973         if (push == NULL) {
4974                 talloc_free(r);
4975                 return false;
4976         }
4977
4978         ndr_err = call->ndr_push(push, NDR_OUT, r);
4979         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4980                 talloc_free(r);
4981                 return false;
4982         }
4983
4984         blob = ndr_push_blob(push);
4985         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4986                 talloc_free(r);
4987                 return false;
4988         }
4989
4990         talloc_free(r);
4991
4992         return true;
4993 }
4994
4995 static bool api_spoolss_ResetPrinterEx(pipes_struct *p)
4996 {
4997         const struct ndr_interface_call *call;
4998         struct ndr_pull *pull;
4999         struct ndr_push *push;
5000         enum ndr_err_code ndr_err;
5001         DATA_BLOB blob;
5002         struct spoolss_ResetPrinterEx *r;
5003
5004         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_RESETPRINTEREX];
5005
5006         r = talloc(talloc_tos(), struct spoolss_ResetPrinterEx);
5007         if (r == NULL) {
5008                 return false;
5009         }
5010
5011         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5012                 talloc_free(r);
5013                 return false;
5014         }
5015
5016         pull = ndr_pull_init_blob(&blob, r, NULL);
5017         if (pull == NULL) {
5018                 talloc_free(r);
5019                 return false;
5020         }
5021
5022         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5023         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5024         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5025                 talloc_free(r);
5026                 return false;
5027         }
5028
5029         if (DEBUGLEVEL >= 10) {
5030                 NDR_PRINT_IN_DEBUG(spoolss_ResetPrinterEx, r);
5031         }
5032
5033         r->out.result = _spoolss_ResetPrinterEx(p, r);
5034
5035         if (p->rng_fault_state) {
5036                 talloc_free(r);
5037                 /* Return true here, srv_pipe_hnd.c will take care */
5038                 return true;
5039         }
5040
5041         if (DEBUGLEVEL >= 10) {
5042                 NDR_PRINT_OUT_DEBUG(spoolss_ResetPrinterEx, r);
5043         }
5044
5045         push = ndr_push_init_ctx(r, NULL);
5046         if (push == NULL) {
5047                 talloc_free(r);
5048                 return false;
5049         }
5050
5051         ndr_err = call->ndr_push(push, NDR_OUT, r);
5052         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5053                 talloc_free(r);
5054                 return false;
5055         }
5056
5057         blob = ndr_push_blob(push);
5058         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5059                 talloc_free(r);
5060                 return false;
5061         }
5062
5063         talloc_free(r);
5064
5065         return true;
5066 }
5067
5068 static bool api_spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct *p)
5069 {
5070         const struct ndr_interface_call *call;
5071         struct ndr_pull *pull;
5072         struct ndr_push *push;
5073         enum ndr_err_code ndr_err;
5074         DATA_BLOB blob;
5075         struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r;
5076
5077         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX];
5078
5079         r = talloc(talloc_tos(), struct spoolss_RemoteFindFirstPrinterChangeNotifyEx);
5080         if (r == NULL) {
5081                 return false;
5082         }
5083
5084         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5085                 talloc_free(r);
5086                 return false;
5087         }
5088
5089         pull = ndr_pull_init_blob(&blob, r, NULL);
5090         if (pull == NULL) {
5091                 talloc_free(r);
5092                 return false;
5093         }
5094
5095         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5096         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5097         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5098                 talloc_free(r);
5099                 return false;
5100         }
5101
5102         if (DEBUGLEVEL >= 10) {
5103                 NDR_PRINT_IN_DEBUG(spoolss_RemoteFindFirstPrinterChangeNotifyEx, r);
5104         }
5105
5106         r->out.result = _spoolss_RemoteFindFirstPrinterChangeNotifyEx(p, r);
5107
5108         if (p->rng_fault_state) {
5109                 talloc_free(r);
5110                 /* Return true here, srv_pipe_hnd.c will take care */
5111                 return true;
5112         }
5113
5114         if (DEBUGLEVEL >= 10) {
5115                 NDR_PRINT_OUT_DEBUG(spoolss_RemoteFindFirstPrinterChangeNotifyEx, r);
5116         }
5117
5118         push = ndr_push_init_ctx(r, NULL);
5119         if (push == NULL) {
5120                 talloc_free(r);
5121                 return false;
5122         }
5123
5124         ndr_err = call->ndr_push(push, NDR_OUT, r);
5125         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5126                 talloc_free(r);
5127                 return false;
5128         }
5129
5130         blob = ndr_push_blob(push);
5131         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5132                 talloc_free(r);
5133                 return false;
5134         }
5135
5136         talloc_free(r);
5137
5138         return true;
5139 }
5140
5141 static bool api_spoolss_RouterReplyPrinterEx(pipes_struct *p)
5142 {
5143         const struct ndr_interface_call *call;
5144         struct ndr_pull *pull;
5145         struct ndr_push *push;
5146         enum ndr_err_code ndr_err;
5147         DATA_BLOB blob;
5148         struct spoolss_RouterReplyPrinterEx *r;
5149
5150         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ROUTERREPLYPRINTEREX];
5151
5152         r = talloc(talloc_tos(), struct spoolss_RouterReplyPrinterEx);
5153         if (r == NULL) {
5154                 return false;
5155         }
5156
5157         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5158                 talloc_free(r);
5159                 return false;
5160         }
5161
5162         pull = ndr_pull_init_blob(&blob, r, NULL);
5163         if (pull == NULL) {
5164                 talloc_free(r);
5165                 return false;
5166         }
5167
5168         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5169         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5170         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5171                 talloc_free(r);
5172                 return false;
5173         }
5174
5175         if (DEBUGLEVEL >= 10) {
5176                 NDR_PRINT_IN_DEBUG(spoolss_RouterReplyPrinterEx, r);
5177         }
5178
5179         ZERO_STRUCT(r->out);
5180         r->out.reply_result = talloc_zero(r, uint32_t);
5181         if (r->out.reply_result == NULL) {
5182                 talloc_free(r);
5183                 return false;
5184         }
5185
5186         r->out.result = _spoolss_RouterReplyPrinterEx(p, r);
5187
5188         if (p->rng_fault_state) {
5189                 talloc_free(r);
5190                 /* Return true here, srv_pipe_hnd.c will take care */
5191                 return true;
5192         }
5193
5194         if (DEBUGLEVEL >= 10) {
5195                 NDR_PRINT_OUT_DEBUG(spoolss_RouterReplyPrinterEx, r);
5196         }
5197
5198         push = ndr_push_init_ctx(r, NULL);
5199         if (push == NULL) {
5200                 talloc_free(r);
5201                 return false;
5202         }
5203
5204         ndr_err = call->ndr_push(push, NDR_OUT, r);
5205         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5206                 talloc_free(r);
5207                 return false;
5208         }
5209
5210         blob = ndr_push_blob(push);
5211         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5212                 talloc_free(r);
5213                 return false;
5214         }
5215
5216         talloc_free(r);
5217
5218         return true;
5219 }
5220
5221 static bool api_spoolss_RouterRefreshPrinterChangeNotify(pipes_struct *p)
5222 {
5223         const struct ndr_interface_call *call;
5224         struct ndr_pull *pull;
5225         struct ndr_push *push;
5226         enum ndr_err_code ndr_err;
5227         DATA_BLOB blob;
5228         struct spoolss_RouterRefreshPrinterChangeNotify *r;
5229
5230         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY];
5231
5232         r = talloc(talloc_tos(), struct spoolss_RouterRefreshPrinterChangeNotify);
5233         if (r == NULL) {
5234                 return false;
5235         }
5236
5237         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5238                 talloc_free(r);
5239                 return false;
5240         }
5241
5242         pull = ndr_pull_init_blob(&blob, r, NULL);
5243         if (pull == NULL) {
5244                 talloc_free(r);
5245                 return false;
5246         }
5247
5248         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5249         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5250         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5251                 talloc_free(r);
5252                 return false;
5253         }
5254
5255         if (DEBUGLEVEL >= 10) {
5256                 NDR_PRINT_IN_DEBUG(spoolss_RouterRefreshPrinterChangeNotify, r);
5257         }
5258
5259         ZERO_STRUCT(r->out);
5260         r->out.info = talloc_zero(r, struct spoolss_NotifyInfo *);
5261         if (r->out.info == NULL) {
5262                 talloc_free(r);
5263                 return false;
5264         }
5265
5266         r->out.result = _spoolss_RouterRefreshPrinterChangeNotify(p, r);
5267
5268         if (p->rng_fault_state) {
5269                 talloc_free(r);
5270                 /* Return true here, srv_pipe_hnd.c will take care */
5271                 return true;
5272         }
5273
5274         if (DEBUGLEVEL >= 10) {
5275                 NDR_PRINT_OUT_DEBUG(spoolss_RouterRefreshPrinterChangeNotify, r);
5276         }
5277
5278         push = ndr_push_init_ctx(r, NULL);
5279         if (push == NULL) {
5280                 talloc_free(r);
5281                 return false;
5282         }
5283
5284         ndr_err = call->ndr_push(push, NDR_OUT, r);
5285         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5286                 talloc_free(r);
5287                 return false;
5288         }
5289
5290         blob = ndr_push_blob(push);
5291         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5292                 talloc_free(r);
5293                 return false;
5294         }
5295
5296         talloc_free(r);
5297
5298         return true;
5299 }
5300
5301 static bool api_spoolss_44(pipes_struct *p)
5302 {
5303         const struct ndr_interface_call *call;
5304         struct ndr_pull *pull;
5305         struct ndr_push *push;
5306         enum ndr_err_code ndr_err;
5307         DATA_BLOB blob;
5308         struct spoolss_44 *r;
5309
5310         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_44];
5311
5312         r = talloc(talloc_tos(), struct spoolss_44);
5313         if (r == NULL) {
5314                 return false;
5315         }
5316
5317         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5318                 talloc_free(r);
5319                 return false;
5320         }
5321
5322         pull = ndr_pull_init_blob(&blob, r, NULL);
5323         if (pull == NULL) {
5324                 talloc_free(r);
5325                 return false;
5326         }
5327
5328         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5329         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5330         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5331                 talloc_free(r);
5332                 return false;
5333         }
5334
5335         if (DEBUGLEVEL >= 10) {
5336                 NDR_PRINT_IN_DEBUG(spoolss_44, r);
5337         }
5338
5339         r->out.result = _spoolss_44(p, r);
5340
5341         if (p->rng_fault_state) {
5342                 talloc_free(r);
5343                 /* Return true here, srv_pipe_hnd.c will take care */
5344                 return true;
5345         }
5346
5347         if (DEBUGLEVEL >= 10) {
5348                 NDR_PRINT_OUT_DEBUG(spoolss_44, r);
5349         }
5350
5351         push = ndr_push_init_ctx(r, NULL);
5352         if (push == NULL) {
5353                 talloc_free(r);
5354                 return false;
5355         }
5356
5357         ndr_err = call->ndr_push(push, NDR_OUT, r);
5358         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5359                 talloc_free(r);
5360                 return false;
5361         }
5362
5363         blob = ndr_push_blob(push);
5364         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5365                 talloc_free(r);
5366                 return false;
5367         }
5368
5369         talloc_free(r);
5370
5371         return true;
5372 }
5373
5374 static bool api_spoolss_OpenPrinterEx(pipes_struct *p)
5375 {
5376         const struct ndr_interface_call *call;
5377         struct ndr_pull *pull;
5378         struct ndr_push *push;
5379         enum ndr_err_code ndr_err;
5380         DATA_BLOB blob;
5381         struct spoolss_OpenPrinterEx *r;
5382
5383         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_OPENPRINTEREX];
5384
5385         r = talloc(talloc_tos(), struct spoolss_OpenPrinterEx);
5386         if (r == NULL) {
5387                 return false;
5388         }
5389
5390         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5391                 talloc_free(r);
5392                 return false;
5393         }
5394
5395         pull = ndr_pull_init_blob(&blob, r, NULL);
5396         if (pull == NULL) {
5397                 talloc_free(r);
5398                 return false;
5399         }
5400
5401         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5402         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5403         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5404                 talloc_free(r);
5405                 return false;
5406         }
5407
5408         if (DEBUGLEVEL >= 10) {
5409                 NDR_PRINT_IN_DEBUG(spoolss_OpenPrinterEx, r);
5410         }
5411
5412         ZERO_STRUCT(r->out);
5413         r->out.handle = talloc_zero(r, struct policy_handle);
5414         if (r->out.handle == NULL) {
5415                 talloc_free(r);
5416                 return false;
5417         }
5418
5419         r->out.result = _spoolss_OpenPrinterEx(p, r);
5420
5421         if (p->rng_fault_state) {
5422                 talloc_free(r);
5423                 /* Return true here, srv_pipe_hnd.c will take care */
5424                 return true;
5425         }
5426
5427         if (DEBUGLEVEL >= 10) {
5428                 NDR_PRINT_OUT_DEBUG(spoolss_OpenPrinterEx, r);
5429         }
5430
5431         push = ndr_push_init_ctx(r, NULL);
5432         if (push == NULL) {
5433                 talloc_free(r);
5434                 return false;
5435         }
5436
5437         ndr_err = call->ndr_push(push, NDR_OUT, r);
5438         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5439                 talloc_free(r);
5440                 return false;
5441         }
5442
5443         blob = ndr_push_blob(push);
5444         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5445                 talloc_free(r);
5446                 return false;
5447         }
5448
5449         talloc_free(r);
5450
5451         return true;
5452 }
5453
5454 static bool api_spoolss_AddPrinterEx(pipes_struct *p)
5455 {
5456         const struct ndr_interface_call *call;
5457         struct ndr_pull *pull;
5458         struct ndr_push *push;
5459         enum ndr_err_code ndr_err;
5460         DATA_BLOB blob;
5461         struct spoolss_AddPrinterEx *r;
5462
5463         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTEREX];
5464
5465         r = talloc(talloc_tos(), struct spoolss_AddPrinterEx);
5466         if (r == NULL) {
5467                 return false;
5468         }
5469
5470         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5471                 talloc_free(r);
5472                 return false;
5473         }
5474
5475         pull = ndr_pull_init_blob(&blob, r, NULL);
5476         if (pull == NULL) {
5477                 talloc_free(r);
5478                 return false;
5479         }
5480
5481         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5482         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5483         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5484                 talloc_free(r);
5485                 return false;
5486         }
5487
5488         if (DEBUGLEVEL >= 10) {
5489                 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterEx, r);
5490         }
5491
5492         ZERO_STRUCT(r->out);
5493         r->out.handle = talloc_zero(r, struct policy_handle);
5494         if (r->out.handle == NULL) {
5495                 talloc_free(r);
5496                 return false;
5497         }
5498
5499         r->out.result = _spoolss_AddPrinterEx(p, r);
5500
5501         if (p->rng_fault_state) {
5502                 talloc_free(r);
5503                 /* Return true here, srv_pipe_hnd.c will take care */
5504                 return true;
5505         }
5506
5507         if (DEBUGLEVEL >= 10) {
5508                 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterEx, r);
5509         }
5510
5511         push = ndr_push_init_ctx(r, NULL);
5512         if (push == NULL) {
5513                 talloc_free(r);
5514                 return false;
5515         }
5516
5517         ndr_err = call->ndr_push(push, NDR_OUT, r);
5518         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5519                 talloc_free(r);
5520                 return false;
5521         }
5522
5523         blob = ndr_push_blob(push);
5524         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5525                 talloc_free(r);
5526                 return false;
5527         }
5528
5529         talloc_free(r);
5530
5531         return true;
5532 }
5533
5534 static bool api_spoolss_47(pipes_struct *p)
5535 {
5536         const struct ndr_interface_call *call;
5537         struct ndr_pull *pull;
5538         struct ndr_push *push;
5539         enum ndr_err_code ndr_err;
5540         DATA_BLOB blob;
5541         struct spoolss_47 *r;
5542
5543         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_47];
5544
5545         r = talloc(talloc_tos(), struct spoolss_47);
5546         if (r == NULL) {
5547                 return false;
5548         }
5549
5550         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5551                 talloc_free(r);
5552                 return false;
5553         }
5554
5555         pull = ndr_pull_init_blob(&blob, r, NULL);
5556         if (pull == NULL) {
5557                 talloc_free(r);
5558                 return false;
5559         }
5560
5561         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5562         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5563         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5564                 talloc_free(r);
5565                 return false;
5566         }
5567
5568         if (DEBUGLEVEL >= 10) {
5569                 NDR_PRINT_IN_DEBUG(spoolss_47, r);
5570         }
5571
5572         r->out.result = _spoolss_47(p, r);
5573
5574         if (p->rng_fault_state) {
5575                 talloc_free(r);
5576                 /* Return true here, srv_pipe_hnd.c will take care */
5577                 return true;
5578         }
5579
5580         if (DEBUGLEVEL >= 10) {
5581                 NDR_PRINT_OUT_DEBUG(spoolss_47, r);
5582         }
5583
5584         push = ndr_push_init_ctx(r, NULL);
5585         if (push == NULL) {
5586                 talloc_free(r);
5587                 return false;
5588         }
5589
5590         ndr_err = call->ndr_push(push, NDR_OUT, r);
5591         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5592                 talloc_free(r);
5593                 return false;
5594         }
5595
5596         blob = ndr_push_blob(push);
5597         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5598                 talloc_free(r);
5599                 return false;
5600         }
5601
5602         talloc_free(r);
5603
5604         return true;
5605 }
5606
5607 static bool api_spoolss_EnumPrinterData(pipes_struct *p)
5608 {
5609         const struct ndr_interface_call *call;
5610         struct ndr_pull *pull;
5611         struct ndr_push *push;
5612         enum ndr_err_code ndr_err;
5613         DATA_BLOB blob;
5614         struct spoolss_EnumPrinterData *r;
5615
5616         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPRINTERDATA];
5617
5618         r = talloc(talloc_tos(), struct spoolss_EnumPrinterData);
5619         if (r == NULL) {
5620                 return false;
5621         }
5622
5623         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5624                 talloc_free(r);
5625                 return false;
5626         }
5627
5628         pull = ndr_pull_init_blob(&blob, r, NULL);
5629         if (pull == NULL) {
5630                 talloc_free(r);
5631                 return false;
5632         }
5633
5634         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5635         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5636         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5637                 talloc_free(r);
5638                 return false;
5639         }
5640
5641         if (DEBUGLEVEL >= 10) {
5642                 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterData, r);
5643         }
5644
5645         ZERO_STRUCT(r->out);
5646         r->out.value_name = talloc_zero_array(r, const char, r->in.value_offered / 2);
5647         if (r->out.value_name == NULL) {
5648                 talloc_free(r);
5649                 return false;
5650         }
5651
5652         r->out.value_needed = talloc_zero(r, uint32_t);
5653         if (r->out.value_needed == NULL) {
5654                 talloc_free(r);
5655                 return false;
5656         }
5657
5658         r->out.type = talloc_zero(r, enum winreg_Type);
5659         if (r->out.type == NULL) {
5660                 talloc_free(r);
5661                 return false;
5662         }
5663
5664         r->out.data = talloc_zero_array(r, uint8_t, r->in.data_offered);
5665         if (r->out.data == NULL) {
5666                 talloc_free(r);
5667                 return false;
5668         }
5669
5670         r->out.data_needed = talloc_zero(r, uint32_t);
5671         if (r->out.data_needed == NULL) {
5672                 talloc_free(r);
5673                 return false;
5674         }
5675
5676         r->out.result = _spoolss_EnumPrinterData(p, r);
5677
5678         if (p->rng_fault_state) {
5679                 talloc_free(r);
5680                 /* Return true here, srv_pipe_hnd.c will take care */
5681                 return true;
5682         }
5683
5684         if (DEBUGLEVEL >= 10) {
5685                 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterData, r);
5686         }
5687
5688         push = ndr_push_init_ctx(r, NULL);
5689         if (push == NULL) {
5690                 talloc_free(r);
5691                 return false;
5692         }
5693
5694         ndr_err = call->ndr_push(push, NDR_OUT, r);
5695         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5696                 talloc_free(r);
5697                 return false;
5698         }
5699
5700         blob = ndr_push_blob(push);
5701         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5702                 talloc_free(r);
5703                 return false;
5704         }
5705
5706         talloc_free(r);
5707
5708         return true;
5709 }
5710
5711 static bool api_spoolss_DeletePrinterData(pipes_struct *p)
5712 {
5713         const struct ndr_interface_call *call;
5714         struct ndr_pull *pull;
5715         struct ndr_push *push;
5716         enum ndr_err_code ndr_err;
5717         DATA_BLOB blob;
5718         struct spoolss_DeletePrinterData *r;
5719
5720         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERDATA];
5721
5722         r = talloc(talloc_tos(), struct spoolss_DeletePrinterData);
5723         if (r == NULL) {
5724                 return false;
5725         }
5726
5727         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5728                 talloc_free(r);
5729                 return false;
5730         }
5731
5732         pull = ndr_pull_init_blob(&blob, r, NULL);
5733         if (pull == NULL) {
5734                 talloc_free(r);
5735                 return false;
5736         }
5737
5738         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5739         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5740         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5741                 talloc_free(r);
5742                 return false;
5743         }
5744
5745         if (DEBUGLEVEL >= 10) {
5746                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterData, r);
5747         }
5748
5749         r->out.result = _spoolss_DeletePrinterData(p, r);
5750
5751         if (p->rng_fault_state) {
5752                 talloc_free(r);
5753                 /* Return true here, srv_pipe_hnd.c will take care */
5754                 return true;
5755         }
5756
5757         if (DEBUGLEVEL >= 10) {
5758                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterData, r);
5759         }
5760
5761         push = ndr_push_init_ctx(r, NULL);
5762         if (push == NULL) {
5763                 talloc_free(r);
5764                 return false;
5765         }
5766
5767         ndr_err = call->ndr_push(push, NDR_OUT, r);
5768         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5769                 talloc_free(r);
5770                 return false;
5771         }
5772
5773         blob = ndr_push_blob(push);
5774         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5775                 talloc_free(r);
5776                 return false;
5777         }
5778
5779         talloc_free(r);
5780
5781         return true;
5782 }
5783
5784 static bool api_spoolss_4a(pipes_struct *p)
5785 {
5786         const struct ndr_interface_call *call;
5787         struct ndr_pull *pull;
5788         struct ndr_push *push;
5789         enum ndr_err_code ndr_err;
5790         DATA_BLOB blob;
5791         struct spoolss_4a *r;
5792
5793         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_4A];
5794
5795         r = talloc(talloc_tos(), struct spoolss_4a);
5796         if (r == NULL) {
5797                 return false;
5798         }
5799
5800         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5801                 talloc_free(r);
5802                 return false;
5803         }
5804
5805         pull = ndr_pull_init_blob(&blob, r, NULL);
5806         if (pull == NULL) {
5807                 talloc_free(r);
5808                 return false;
5809         }
5810
5811         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5812         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5813         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5814                 talloc_free(r);
5815                 return false;
5816         }
5817
5818         if (DEBUGLEVEL >= 10) {
5819                 NDR_PRINT_IN_DEBUG(spoolss_4a, r);
5820         }
5821
5822         r->out.result = _spoolss_4a(p, r);
5823
5824         if (p->rng_fault_state) {
5825                 talloc_free(r);
5826                 /* Return true here, srv_pipe_hnd.c will take care */
5827                 return true;
5828         }
5829
5830         if (DEBUGLEVEL >= 10) {
5831                 NDR_PRINT_OUT_DEBUG(spoolss_4a, r);
5832         }
5833
5834         push = ndr_push_init_ctx(r, NULL);
5835         if (push == NULL) {
5836                 talloc_free(r);
5837                 return false;
5838         }
5839
5840         ndr_err = call->ndr_push(push, NDR_OUT, r);
5841         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5842                 talloc_free(r);
5843                 return false;
5844         }
5845
5846         blob = ndr_push_blob(push);
5847         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5848                 talloc_free(r);
5849                 return false;
5850         }
5851
5852         talloc_free(r);
5853
5854         return true;
5855 }
5856
5857 static bool api_spoolss_4b(pipes_struct *p)
5858 {
5859         const struct ndr_interface_call *call;
5860         struct ndr_pull *pull;
5861         struct ndr_push *push;
5862         enum ndr_err_code ndr_err;
5863         DATA_BLOB blob;
5864         struct spoolss_4b *r;
5865
5866         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_4B];
5867
5868         r = talloc(talloc_tos(), struct spoolss_4b);
5869         if (r == NULL) {
5870                 return false;
5871         }
5872
5873         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5874                 talloc_free(r);
5875                 return false;
5876         }
5877
5878         pull = ndr_pull_init_blob(&blob, r, NULL);
5879         if (pull == NULL) {
5880                 talloc_free(r);
5881                 return false;
5882         }
5883
5884         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5885         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5886         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5887                 talloc_free(r);
5888                 return false;
5889         }
5890
5891         if (DEBUGLEVEL >= 10) {
5892                 NDR_PRINT_IN_DEBUG(spoolss_4b, r);
5893         }
5894
5895         r->out.result = _spoolss_4b(p, r);
5896
5897         if (p->rng_fault_state) {
5898                 talloc_free(r);
5899                 /* Return true here, srv_pipe_hnd.c will take care */
5900                 return true;
5901         }
5902
5903         if (DEBUGLEVEL >= 10) {
5904                 NDR_PRINT_OUT_DEBUG(spoolss_4b, r);
5905         }
5906
5907         push = ndr_push_init_ctx(r, NULL);
5908         if (push == NULL) {
5909                 talloc_free(r);
5910                 return false;
5911         }
5912
5913         ndr_err = call->ndr_push(push, NDR_OUT, r);
5914         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5915                 talloc_free(r);
5916                 return false;
5917         }
5918
5919         blob = ndr_push_blob(push);
5920         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5921                 talloc_free(r);
5922                 return false;
5923         }
5924
5925         talloc_free(r);
5926
5927         return true;
5928 }
5929
5930 static bool api_spoolss_4c(pipes_struct *p)
5931 {
5932         const struct ndr_interface_call *call;
5933         struct ndr_pull *pull;
5934         struct ndr_push *push;
5935         enum ndr_err_code ndr_err;
5936         DATA_BLOB blob;
5937         struct spoolss_4c *r;
5938
5939         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_4C];
5940
5941         r = talloc(talloc_tos(), struct spoolss_4c);
5942         if (r == NULL) {
5943                 return false;
5944         }
5945
5946         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5947                 talloc_free(r);
5948                 return false;
5949         }
5950
5951         pull = ndr_pull_init_blob(&blob, r, NULL);
5952         if (pull == NULL) {
5953                 talloc_free(r);
5954                 return false;
5955         }
5956
5957         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5958         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5959         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5960                 talloc_free(r);
5961                 return false;
5962         }
5963
5964         if (DEBUGLEVEL >= 10) {
5965                 NDR_PRINT_IN_DEBUG(spoolss_4c, r);
5966         }
5967
5968         r->out.result = _spoolss_4c(p, r);
5969
5970         if (p->rng_fault_state) {
5971                 talloc_free(r);
5972                 /* Return true here, srv_pipe_hnd.c will take care */
5973                 return true;
5974         }
5975
5976         if (DEBUGLEVEL >= 10) {
5977                 NDR_PRINT_OUT_DEBUG(spoolss_4c, r);
5978         }
5979
5980         push = ndr_push_init_ctx(r, NULL);
5981         if (push == NULL) {
5982                 talloc_free(r);
5983                 return false;
5984         }
5985
5986         ndr_err = call->ndr_push(push, NDR_OUT, r);
5987         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5988                 talloc_free(r);
5989                 return false;
5990         }
5991
5992         blob = ndr_push_blob(push);
5993         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5994                 talloc_free(r);
5995                 return false;
5996         }
5997
5998         talloc_free(r);
5999
6000         return true;
6001 }
6002
6003 static bool api_spoolss_SetPrinterDataEx(pipes_struct *p)
6004 {
6005         const struct ndr_interface_call *call;
6006         struct ndr_pull *pull;
6007         struct ndr_push *push;
6008         enum ndr_err_code ndr_err;
6009         DATA_BLOB blob;
6010         struct spoolss_SetPrinterDataEx *r;
6011
6012         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_SETPRINTERDATAEX];
6013
6014         r = talloc(talloc_tos(), struct spoolss_SetPrinterDataEx);
6015         if (r == NULL) {
6016                 return false;
6017         }
6018
6019         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6020                 talloc_free(r);
6021                 return false;
6022         }
6023
6024         pull = ndr_pull_init_blob(&blob, r, NULL);
6025         if (pull == NULL) {
6026                 talloc_free(r);
6027                 return false;
6028         }
6029
6030         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6031         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6032         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6033                 talloc_free(r);
6034                 return false;
6035         }
6036
6037         if (DEBUGLEVEL >= 10) {
6038                 NDR_PRINT_IN_DEBUG(spoolss_SetPrinterDataEx, r);
6039         }
6040
6041         r->out.result = _spoolss_SetPrinterDataEx(p, r);
6042
6043         if (p->rng_fault_state) {
6044                 talloc_free(r);
6045                 /* Return true here, srv_pipe_hnd.c will take care */
6046                 return true;
6047         }
6048
6049         if (DEBUGLEVEL >= 10) {
6050                 NDR_PRINT_OUT_DEBUG(spoolss_SetPrinterDataEx, r);
6051         }
6052
6053         push = ndr_push_init_ctx(r, NULL);
6054         if (push == NULL) {
6055                 talloc_free(r);
6056                 return false;
6057         }
6058
6059         ndr_err = call->ndr_push(push, NDR_OUT, r);
6060         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6061                 talloc_free(r);
6062                 return false;
6063         }
6064
6065         blob = ndr_push_blob(push);
6066         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6067                 talloc_free(r);
6068                 return false;
6069         }
6070
6071         talloc_free(r);
6072
6073         return true;
6074 }
6075
6076 static bool api_spoolss_GetPrinterDataEx(pipes_struct *p)
6077 {
6078         const struct ndr_interface_call *call;
6079         struct ndr_pull *pull;
6080         struct ndr_push *push;
6081         enum ndr_err_code ndr_err;
6082         DATA_BLOB blob;
6083         struct spoolss_GetPrinterDataEx *r;
6084
6085         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTERDATAEX];
6086
6087         r = talloc(talloc_tos(), struct spoolss_GetPrinterDataEx);
6088         if (r == NULL) {
6089                 return false;
6090         }
6091
6092         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6093                 talloc_free(r);
6094                 return false;
6095         }
6096
6097         pull = ndr_pull_init_blob(&blob, r, NULL);
6098         if (pull == NULL) {
6099                 talloc_free(r);
6100                 return false;
6101         }
6102
6103         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6104         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6105         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6106                 talloc_free(r);
6107                 return false;
6108         }
6109
6110         if (DEBUGLEVEL >= 10) {
6111                 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDataEx, r);
6112         }
6113
6114         ZERO_STRUCT(r->out);
6115         r->out.type = talloc_zero(r, enum winreg_Type);
6116         if (r->out.type == NULL) {
6117                 talloc_free(r);
6118                 return false;
6119         }
6120
6121         r->out.buffer = talloc_zero_array(r, uint8_t, r->in.offered);
6122         if (r->out.buffer == NULL) {
6123                 talloc_free(r);
6124                 return false;
6125         }
6126
6127         r->out.needed = talloc_zero(r, uint32_t);
6128         if (r->out.needed == NULL) {
6129                 talloc_free(r);
6130                 return false;
6131         }
6132
6133         r->out.result = _spoolss_GetPrinterDataEx(p, r);
6134
6135         if (p->rng_fault_state) {
6136                 talloc_free(r);
6137                 /* Return true here, srv_pipe_hnd.c will take care */
6138                 return true;
6139         }
6140
6141         if (DEBUGLEVEL >= 10) {
6142                 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDataEx, r);
6143         }
6144
6145         push = ndr_push_init_ctx(r, NULL);
6146         if (push == NULL) {
6147                 talloc_free(r);
6148                 return false;
6149         }
6150
6151         ndr_err = call->ndr_push(push, NDR_OUT, r);
6152         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6153                 talloc_free(r);
6154                 return false;
6155         }
6156
6157         blob = ndr_push_blob(push);
6158         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6159                 talloc_free(r);
6160                 return false;
6161         }
6162
6163         talloc_free(r);
6164
6165         return true;
6166 }
6167
6168 static bool api_spoolss_EnumPrinterDataEx(pipes_struct *p)
6169 {
6170         const struct ndr_interface_call *call;
6171         struct ndr_pull *pull;
6172         struct ndr_push *push;
6173         enum ndr_err_code ndr_err;
6174         DATA_BLOB blob;
6175         struct spoolss_EnumPrinterDataEx *r;
6176
6177         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPRINTERDATAEX];
6178
6179         r = talloc(talloc_tos(), struct spoolss_EnumPrinterDataEx);
6180         if (r == NULL) {
6181                 return false;
6182         }
6183
6184         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6185                 talloc_free(r);
6186                 return false;
6187         }
6188
6189         pull = ndr_pull_init_blob(&blob, r, NULL);
6190         if (pull == NULL) {
6191                 talloc_free(r);
6192                 return false;
6193         }
6194
6195         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6196         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6197         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6198                 talloc_free(r);
6199                 return false;
6200         }
6201
6202         if (DEBUGLEVEL >= 10) {
6203                 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterDataEx, r);
6204         }
6205
6206         ZERO_STRUCT(r->out);
6207         r->out.buffer = talloc_zero_array(r, uint8_t, r->in.offered);
6208         if (r->out.buffer == NULL) {
6209                 talloc_free(r);
6210                 return false;
6211         }
6212
6213         r->out.needed = talloc_zero(r, uint32_t);
6214         if (r->out.needed == NULL) {
6215                 talloc_free(r);
6216                 return false;
6217         }
6218
6219         r->out.count = talloc_zero(r, uint32_t);
6220         if (r->out.count == NULL) {
6221                 talloc_free(r);
6222                 return false;
6223         }
6224
6225         r->out.result = _spoolss_EnumPrinterDataEx(p, r);
6226
6227         if (p->rng_fault_state) {
6228                 talloc_free(r);
6229                 /* Return true here, srv_pipe_hnd.c will take care */
6230                 return true;
6231         }
6232
6233         if (DEBUGLEVEL >= 10) {
6234                 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterDataEx, r);
6235         }
6236
6237         push = ndr_push_init_ctx(r, NULL);
6238         if (push == NULL) {
6239                 talloc_free(r);
6240                 return false;
6241         }
6242
6243         ndr_err = call->ndr_push(push, NDR_OUT, r);
6244         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6245                 talloc_free(r);
6246                 return false;
6247         }
6248
6249         blob = ndr_push_blob(push);
6250         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6251                 talloc_free(r);
6252                 return false;
6253         }
6254
6255         talloc_free(r);
6256
6257         return true;
6258 }
6259
6260 static bool api_spoolss_EnumPrinterKey(pipes_struct *p)
6261 {
6262         const struct ndr_interface_call *call;
6263         struct ndr_pull *pull;
6264         struct ndr_push *push;
6265         enum ndr_err_code ndr_err;
6266         DATA_BLOB blob;
6267         struct spoolss_EnumPrinterKey *r;
6268
6269         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPRINTERKEY];
6270
6271         r = talloc(talloc_tos(), struct spoolss_EnumPrinterKey);
6272         if (r == NULL) {
6273                 return false;
6274         }
6275
6276         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6277                 talloc_free(r);
6278                 return false;
6279         }
6280
6281         pull = ndr_pull_init_blob(&blob, r, NULL);
6282         if (pull == NULL) {
6283                 talloc_free(r);
6284                 return false;
6285         }
6286
6287         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6288         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6289         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6290                 talloc_free(r);
6291                 return false;
6292         }
6293
6294         if (DEBUGLEVEL >= 10) {
6295                 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterKey, r);
6296         }
6297
6298         ZERO_STRUCT(r->out);
6299         r->out.key_buffer = talloc_zero_array(r, uint16_t, r->in.key_buffer_size / 2);
6300         if (r->out.key_buffer == NULL) {
6301                 talloc_free(r);
6302                 return false;
6303         }
6304
6305         r->out.needed = talloc_zero(r, uint32_t);
6306         if (r->out.needed == NULL) {
6307                 talloc_free(r);
6308                 return false;
6309         }
6310
6311         r->out.result = _spoolss_EnumPrinterKey(p, r);
6312
6313         if (p->rng_fault_state) {
6314                 talloc_free(r);
6315                 /* Return true here, srv_pipe_hnd.c will take care */
6316                 return true;
6317         }
6318
6319         if (DEBUGLEVEL >= 10) {
6320                 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterKey, r);
6321         }
6322
6323         push = ndr_push_init_ctx(r, NULL);
6324         if (push == NULL) {
6325                 talloc_free(r);
6326                 return false;
6327         }
6328
6329         ndr_err = call->ndr_push(push, NDR_OUT, r);
6330         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6331                 talloc_free(r);
6332                 return false;
6333         }
6334
6335         blob = ndr_push_blob(push);
6336         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6337                 talloc_free(r);
6338                 return false;
6339         }
6340
6341         talloc_free(r);
6342
6343         return true;
6344 }
6345
6346 static bool api_spoolss_DeletePrinterDataEx(pipes_struct *p)
6347 {
6348         const struct ndr_interface_call *call;
6349         struct ndr_pull *pull;
6350         struct ndr_push *push;
6351         enum ndr_err_code ndr_err;
6352         DATA_BLOB blob;
6353         struct spoolss_DeletePrinterDataEx *r;
6354
6355         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERDATAEX];
6356
6357         r = talloc(talloc_tos(), struct spoolss_DeletePrinterDataEx);
6358         if (r == NULL) {
6359                 return false;
6360         }
6361
6362         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6363                 talloc_free(r);
6364                 return false;
6365         }
6366
6367         pull = ndr_pull_init_blob(&blob, r, NULL);
6368         if (pull == NULL) {
6369                 talloc_free(r);
6370                 return false;
6371         }
6372
6373         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6374         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6375         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6376                 talloc_free(r);
6377                 return false;
6378         }
6379
6380         if (DEBUGLEVEL >= 10) {
6381                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDataEx, r);
6382         }
6383
6384         r->out.result = _spoolss_DeletePrinterDataEx(p, r);
6385
6386         if (p->rng_fault_state) {
6387                 talloc_free(r);
6388                 /* Return true here, srv_pipe_hnd.c will take care */
6389                 return true;
6390         }
6391
6392         if (DEBUGLEVEL >= 10) {
6393                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDataEx, r);
6394         }
6395
6396         push = ndr_push_init_ctx(r, NULL);
6397         if (push == NULL) {
6398                 talloc_free(r);
6399                 return false;
6400         }
6401
6402         ndr_err = call->ndr_push(push, NDR_OUT, r);
6403         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6404                 talloc_free(r);
6405                 return false;
6406         }
6407
6408         blob = ndr_push_blob(push);
6409         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6410                 talloc_free(r);
6411                 return false;
6412         }
6413
6414         talloc_free(r);
6415
6416         return true;
6417 }
6418
6419 static bool api_spoolss_DeletePrinterKey(pipes_struct *p)
6420 {
6421         const struct ndr_interface_call *call;
6422         struct ndr_pull *pull;
6423         struct ndr_push *push;
6424         enum ndr_err_code ndr_err;
6425         DATA_BLOB blob;
6426         struct spoolss_DeletePrinterKey *r;
6427
6428         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERKEY];
6429
6430         r = talloc(talloc_tos(), struct spoolss_DeletePrinterKey);
6431         if (r == NULL) {
6432                 return false;
6433         }
6434
6435         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6436                 talloc_free(r);
6437                 return false;
6438         }
6439
6440         pull = ndr_pull_init_blob(&blob, r, NULL);
6441         if (pull == NULL) {
6442                 talloc_free(r);
6443                 return false;
6444         }
6445
6446         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6447         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6448         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6449                 talloc_free(r);
6450                 return false;
6451         }
6452
6453         if (DEBUGLEVEL >= 10) {
6454                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterKey, r);
6455         }
6456
6457         r->out.result = _spoolss_DeletePrinterKey(p, r);
6458
6459         if (p->rng_fault_state) {
6460                 talloc_free(r);
6461                 /* Return true here, srv_pipe_hnd.c will take care */
6462                 return true;
6463         }
6464
6465         if (DEBUGLEVEL >= 10) {
6466                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterKey, r);
6467         }
6468
6469         push = ndr_push_init_ctx(r, NULL);
6470         if (push == NULL) {
6471                 talloc_free(r);
6472                 return false;
6473         }
6474
6475         ndr_err = call->ndr_push(push, NDR_OUT, r);
6476         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6477                 talloc_free(r);
6478                 return false;
6479         }
6480
6481         blob = ndr_push_blob(push);
6482         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6483                 talloc_free(r);
6484                 return false;
6485         }
6486
6487         talloc_free(r);
6488
6489         return true;
6490 }
6491
6492 static bool api_spoolss_53(pipes_struct *p)
6493 {
6494         const struct ndr_interface_call *call;
6495         struct ndr_pull *pull;
6496         struct ndr_push *push;
6497         enum ndr_err_code ndr_err;
6498         DATA_BLOB blob;
6499         struct spoolss_53 *r;
6500
6501         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_53];
6502
6503         r = talloc(talloc_tos(), struct spoolss_53);
6504         if (r == NULL) {
6505                 return false;
6506         }
6507
6508         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6509                 talloc_free(r);
6510                 return false;
6511         }
6512
6513         pull = ndr_pull_init_blob(&blob, r, NULL);
6514         if (pull == NULL) {
6515                 talloc_free(r);
6516                 return false;
6517         }
6518
6519         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6520         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6521         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6522                 talloc_free(r);
6523                 return false;
6524         }
6525
6526         if (DEBUGLEVEL >= 10) {
6527                 NDR_PRINT_IN_DEBUG(spoolss_53, r);
6528         }
6529
6530         r->out.result = _spoolss_53(p, r);
6531
6532         if (p->rng_fault_state) {
6533                 talloc_free(r);
6534                 /* Return true here, srv_pipe_hnd.c will take care */
6535                 return true;
6536         }
6537
6538         if (DEBUGLEVEL >= 10) {
6539                 NDR_PRINT_OUT_DEBUG(spoolss_53, r);
6540         }
6541
6542         push = ndr_push_init_ctx(r, NULL);
6543         if (push == NULL) {
6544                 talloc_free(r);
6545                 return false;
6546         }
6547
6548         ndr_err = call->ndr_push(push, NDR_OUT, r);
6549         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6550                 talloc_free(r);
6551                 return false;
6552         }
6553
6554         blob = ndr_push_blob(push);
6555         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6556                 talloc_free(r);
6557                 return false;
6558         }
6559
6560         talloc_free(r);
6561
6562         return true;
6563 }
6564
6565 static bool api_spoolss_DeletePrinterDriverEx(pipes_struct *p)
6566 {
6567         const struct ndr_interface_call *call;
6568         struct ndr_pull *pull;
6569         struct ndr_push *push;
6570         enum ndr_err_code ndr_err;
6571         DATA_BLOB blob;
6572         struct spoolss_DeletePrinterDriverEx *r;
6573
6574         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERDRIVEREX];
6575
6576         r = talloc(talloc_tos(), struct spoolss_DeletePrinterDriverEx);
6577         if (r == NULL) {
6578                 return false;
6579         }
6580
6581         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6582                 talloc_free(r);
6583                 return false;
6584         }
6585
6586         pull = ndr_pull_init_blob(&blob, r, NULL);
6587         if (pull == NULL) {
6588                 talloc_free(r);
6589                 return false;
6590         }
6591
6592         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6593         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6594         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6595                 talloc_free(r);
6596                 return false;
6597         }
6598
6599         if (DEBUGLEVEL >= 10) {
6600                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDriverEx, r);
6601         }
6602
6603         r->out.result = _spoolss_DeletePrinterDriverEx(p, r);
6604
6605         if (p->rng_fault_state) {
6606                 talloc_free(r);
6607                 /* Return true here, srv_pipe_hnd.c will take care */
6608                 return true;
6609         }
6610
6611         if (DEBUGLEVEL >= 10) {
6612                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDriverEx, r);
6613         }
6614
6615         push = ndr_push_init_ctx(r, NULL);
6616         if (push == NULL) {
6617                 talloc_free(r);
6618                 return false;
6619         }
6620
6621         ndr_err = call->ndr_push(push, NDR_OUT, r);
6622         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6623                 talloc_free(r);
6624                 return false;
6625         }
6626
6627         blob = ndr_push_blob(push);
6628         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6629                 talloc_free(r);
6630                 return false;
6631         }
6632
6633         talloc_free(r);
6634
6635         return true;
6636 }
6637
6638 static bool api_spoolss_55(pipes_struct *p)
6639 {
6640         const struct ndr_interface_call *call;
6641         struct ndr_pull *pull;
6642         struct ndr_push *push;
6643         enum ndr_err_code ndr_err;
6644         DATA_BLOB blob;
6645         struct spoolss_55 *r;
6646
6647         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_55];
6648
6649         r = talloc(talloc_tos(), struct spoolss_55);
6650         if (r == NULL) {
6651                 return false;
6652         }
6653
6654         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6655                 talloc_free(r);
6656                 return false;
6657         }
6658
6659         pull = ndr_pull_init_blob(&blob, r, NULL);
6660         if (pull == NULL) {
6661                 talloc_free(r);
6662                 return false;
6663         }
6664
6665         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6666         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6667         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6668                 talloc_free(r);
6669                 return false;
6670         }
6671
6672         if (DEBUGLEVEL >= 10) {
6673                 NDR_PRINT_IN_DEBUG(spoolss_55, r);
6674         }
6675
6676         r->out.result = _spoolss_55(p, r);
6677
6678         if (p->rng_fault_state) {
6679                 talloc_free(r);
6680                 /* Return true here, srv_pipe_hnd.c will take care */
6681                 return true;
6682         }
6683
6684         if (DEBUGLEVEL >= 10) {
6685                 NDR_PRINT_OUT_DEBUG(spoolss_55, r);
6686         }
6687
6688         push = ndr_push_init_ctx(r, NULL);
6689         if (push == NULL) {
6690                 talloc_free(r);
6691                 return false;
6692         }
6693
6694         ndr_err = call->ndr_push(push, NDR_OUT, r);
6695         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6696                 talloc_free(r);
6697                 return false;
6698         }
6699
6700         blob = ndr_push_blob(push);
6701         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6702                 talloc_free(r);
6703                 return false;
6704         }
6705
6706         talloc_free(r);
6707
6708         return true;
6709 }
6710
6711 static bool api_spoolss_56(pipes_struct *p)
6712 {
6713         const struct ndr_interface_call *call;
6714         struct ndr_pull *pull;
6715         struct ndr_push *push;
6716         enum ndr_err_code ndr_err;
6717         DATA_BLOB blob;
6718         struct spoolss_56 *r;
6719
6720         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_56];
6721
6722         r = talloc(talloc_tos(), struct spoolss_56);
6723         if (r == NULL) {
6724                 return false;
6725         }
6726
6727         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6728                 talloc_free(r);
6729                 return false;
6730         }
6731
6732         pull = ndr_pull_init_blob(&blob, r, NULL);
6733         if (pull == NULL) {
6734                 talloc_free(r);
6735                 return false;
6736         }
6737
6738         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6739         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6740         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6741                 talloc_free(r);
6742                 return false;
6743         }
6744
6745         if (DEBUGLEVEL >= 10) {
6746                 NDR_PRINT_IN_DEBUG(spoolss_56, r);
6747         }
6748
6749         r->out.result = _spoolss_56(p, r);
6750
6751         if (p->rng_fault_state) {
6752                 talloc_free(r);
6753                 /* Return true here, srv_pipe_hnd.c will take care */
6754                 return true;
6755         }
6756
6757         if (DEBUGLEVEL >= 10) {
6758                 NDR_PRINT_OUT_DEBUG(spoolss_56, r);
6759         }
6760
6761         push = ndr_push_init_ctx(r, NULL);
6762         if (push == NULL) {
6763                 talloc_free(r);
6764                 return false;
6765         }
6766
6767         ndr_err = call->ndr_push(push, NDR_OUT, r);
6768         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6769                 talloc_free(r);
6770                 return false;
6771         }
6772
6773         blob = ndr_push_blob(push);
6774         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6775                 talloc_free(r);
6776                 return false;
6777         }
6778
6779         talloc_free(r);
6780
6781         return true;
6782 }
6783
6784 static bool api_spoolss_57(pipes_struct *p)
6785 {
6786         const struct ndr_interface_call *call;
6787         struct ndr_pull *pull;
6788         struct ndr_push *push;
6789         enum ndr_err_code ndr_err;
6790         DATA_BLOB blob;
6791         struct spoolss_57 *r;
6792
6793         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_57];
6794
6795         r = talloc(talloc_tos(), struct spoolss_57);
6796         if (r == NULL) {
6797                 return false;
6798         }
6799
6800         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6801                 talloc_free(r);
6802                 return false;
6803         }
6804
6805         pull = ndr_pull_init_blob(&blob, r, NULL);
6806         if (pull == NULL) {
6807                 talloc_free(r);
6808                 return false;
6809         }
6810
6811         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6812         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6813         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6814                 talloc_free(r);
6815                 return false;
6816         }
6817
6818         if (DEBUGLEVEL >= 10) {
6819                 NDR_PRINT_IN_DEBUG(spoolss_57, r);
6820         }
6821
6822         r->out.result = _spoolss_57(p, r);
6823
6824         if (p->rng_fault_state) {
6825                 talloc_free(r);
6826                 /* Return true here, srv_pipe_hnd.c will take care */
6827                 return true;
6828         }
6829
6830         if (DEBUGLEVEL >= 10) {
6831                 NDR_PRINT_OUT_DEBUG(spoolss_57, r);
6832         }
6833
6834         push = ndr_push_init_ctx(r, NULL);
6835         if (push == NULL) {
6836                 talloc_free(r);
6837                 return false;
6838         }
6839
6840         ndr_err = call->ndr_push(push, NDR_OUT, r);
6841         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6842                 talloc_free(r);
6843                 return false;
6844         }
6845
6846         blob = ndr_push_blob(push);
6847         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6848                 talloc_free(r);
6849                 return false;
6850         }
6851
6852         talloc_free(r);
6853
6854         return true;
6855 }
6856
6857 static bool api_spoolss_XcvData(pipes_struct *p)
6858 {
6859         const struct ndr_interface_call *call;
6860         struct ndr_pull *pull;
6861         struct ndr_push *push;
6862         enum ndr_err_code ndr_err;
6863         DATA_BLOB blob;
6864         struct spoolss_XcvData *r;
6865
6866         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_XCVDATA];
6867
6868         r = talloc(talloc_tos(), struct spoolss_XcvData);
6869         if (r == NULL) {
6870                 return false;
6871         }
6872
6873         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6874                 talloc_free(r);
6875                 return false;
6876         }
6877
6878         pull = ndr_pull_init_blob(&blob, r, NULL);
6879         if (pull == NULL) {
6880                 talloc_free(r);
6881                 return false;
6882         }
6883
6884         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6885         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6886         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6887                 talloc_free(r);
6888                 return false;
6889         }
6890
6891         if (DEBUGLEVEL >= 10) {
6892                 NDR_PRINT_IN_DEBUG(spoolss_XcvData, r);
6893         }
6894
6895         ZERO_STRUCT(r->out);
6896         r->out.status_code = r->in.status_code;
6897         r->out.out_data = talloc_zero_array(r, uint8_t, r->in.out_data_size);
6898         if (r->out.out_data == NULL) {
6899                 talloc_free(r);
6900                 return false;
6901         }
6902
6903         r->out.needed = talloc_zero(r, uint32_t);
6904         if (r->out.needed == NULL) {
6905                 talloc_free(r);
6906                 return false;
6907         }
6908
6909         r->out.result = _spoolss_XcvData(p, r);
6910
6911         if (p->rng_fault_state) {
6912                 talloc_free(r);
6913                 /* Return true here, srv_pipe_hnd.c will take care */
6914                 return true;
6915         }
6916
6917         if (DEBUGLEVEL >= 10) {
6918                 NDR_PRINT_OUT_DEBUG(spoolss_XcvData, r);
6919         }
6920
6921         push = ndr_push_init_ctx(r, NULL);
6922         if (push == NULL) {
6923                 talloc_free(r);
6924                 return false;
6925         }
6926
6927         ndr_err = call->ndr_push(push, NDR_OUT, r);
6928         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6929                 talloc_free(r);
6930                 return false;
6931         }
6932
6933         blob = ndr_push_blob(push);
6934         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6935                 talloc_free(r);
6936                 return false;
6937         }
6938
6939         talloc_free(r);
6940
6941         return true;
6942 }
6943
6944 static bool api_spoolss_AddPrinterDriverEx(pipes_struct *p)
6945 {
6946         const struct ndr_interface_call *call;
6947         struct ndr_pull *pull;
6948         struct ndr_push *push;
6949         enum ndr_err_code ndr_err;
6950         DATA_BLOB blob;
6951         struct spoolss_AddPrinterDriverEx *r;
6952
6953         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTERDRIVEREX];
6954
6955         r = talloc(talloc_tos(), struct spoolss_AddPrinterDriverEx);
6956         if (r == NULL) {
6957                 return false;
6958         }
6959
6960         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6961                 talloc_free(r);
6962                 return false;
6963         }
6964
6965         pull = ndr_pull_init_blob(&blob, r, NULL);
6966         if (pull == NULL) {
6967                 talloc_free(r);
6968                 return false;
6969         }
6970
6971         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6972         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6973         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6974                 talloc_free(r);
6975                 return false;
6976         }
6977
6978         if (DEBUGLEVEL >= 10) {
6979                 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterDriverEx, r);
6980         }
6981
6982         r->out.result = _spoolss_AddPrinterDriverEx(p, r);
6983
6984         if (p->rng_fault_state) {
6985                 talloc_free(r);
6986                 /* Return true here, srv_pipe_hnd.c will take care */
6987                 return true;
6988         }
6989
6990         if (DEBUGLEVEL >= 10) {
6991                 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterDriverEx, r);
6992         }
6993
6994         push = ndr_push_init_ctx(r, NULL);
6995         if (push == NULL) {
6996                 talloc_free(r);
6997                 return false;
6998         }
6999
7000         ndr_err = call->ndr_push(push, NDR_OUT, r);
7001         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7002                 talloc_free(r);
7003                 return false;
7004         }
7005
7006         blob = ndr_push_blob(push);
7007         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7008                 talloc_free(r);
7009                 return false;
7010         }
7011
7012         talloc_free(r);
7013
7014         return true;
7015 }
7016
7017 static bool api_spoolss_5a(pipes_struct *p)
7018 {
7019         const struct ndr_interface_call *call;
7020         struct ndr_pull *pull;
7021         struct ndr_push *push;
7022         enum ndr_err_code ndr_err;
7023         DATA_BLOB blob;
7024         struct spoolss_5a *r;
7025
7026         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5A];
7027
7028         r = talloc(talloc_tos(), struct spoolss_5a);
7029         if (r == NULL) {
7030                 return false;
7031         }
7032
7033         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7034                 talloc_free(r);
7035                 return false;
7036         }
7037
7038         pull = ndr_pull_init_blob(&blob, r, NULL);
7039         if (pull == NULL) {
7040                 talloc_free(r);
7041                 return false;
7042         }
7043
7044         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7045         ndr_err = call->ndr_pull(pull, NDR_IN, r);
7046         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7047                 talloc_free(r);
7048                 return false;
7049         }
7050
7051         if (DEBUGLEVEL >= 10) {
7052                 NDR_PRINT_IN_DEBUG(spoolss_5a, r);
7053         }
7054
7055         r->out.result = _spoolss_5a(p, r);
7056
7057         if (p->rng_fault_state) {
7058                 talloc_free(r);
7059                 /* Return true here, srv_pipe_hnd.c will take care */
7060                 return true;
7061         }
7062
7063         if (DEBUGLEVEL >= 10) {
7064                 NDR_PRINT_OUT_DEBUG(spoolss_5a, r);
7065         }
7066
7067         push = ndr_push_init_ctx(r, NULL);
7068         if (push == NULL) {
7069                 talloc_free(r);
7070                 return false;
7071         }
7072
7073         ndr_err = call->ndr_push(push, NDR_OUT, r);
7074         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7075                 talloc_free(r);
7076                 return false;
7077         }
7078
7079         blob = ndr_push_blob(push);
7080         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7081                 talloc_free(r);
7082                 return false;
7083         }
7084
7085         talloc_free(r);
7086
7087         return true;
7088 }
7089
7090 static bool api_spoolss_5b(pipes_struct *p)
7091 {
7092         const struct ndr_interface_call *call;
7093         struct ndr_pull *pull;
7094         struct ndr_push *push;
7095         enum ndr_err_code ndr_err;
7096         DATA_BLOB blob;
7097         struct spoolss_5b *r;
7098
7099         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5B];
7100
7101         r = talloc(talloc_tos(), struct spoolss_5b);
7102         if (r == NULL) {
7103                 return false;
7104         }
7105
7106         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7107                 talloc_free(r);
7108                 return false;
7109         }
7110
7111         pull = ndr_pull_init_blob(&blob, r, NULL);
7112         if (pull == NULL) {
7113                 talloc_free(r);
7114                 return false;
7115         }
7116
7117         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7118         ndr_err = call->ndr_pull(pull, NDR_IN, r);
7119         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7120                 talloc_free(r);
7121                 return false;
7122         }
7123
7124         if (DEBUGLEVEL >= 10) {
7125                 NDR_PRINT_IN_DEBUG(spoolss_5b, r);
7126         }
7127
7128         r->out.result = _spoolss_5b(p, r);
7129
7130         if (p->rng_fault_state) {
7131                 talloc_free(r);
7132                 /* Return true here, srv_pipe_hnd.c will take care */
7133                 return true;
7134         }
7135
7136         if (DEBUGLEVEL >= 10) {
7137                 NDR_PRINT_OUT_DEBUG(spoolss_5b, r);
7138         }
7139
7140         push = ndr_push_init_ctx(r, NULL);
7141         if (push == NULL) {
7142                 talloc_free(r);
7143                 return false;
7144         }
7145
7146         ndr_err = call->ndr_push(push, NDR_OUT, r);
7147         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7148                 talloc_free(r);
7149                 return false;
7150         }
7151
7152         blob = ndr_push_blob(push);
7153         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7154                 talloc_free(r);
7155                 return false;
7156         }
7157
7158         talloc_free(r);
7159
7160         return true;
7161 }
7162
7163 static bool api_spoolss_5c(pipes_struct *p)
7164 {
7165         const struct ndr_interface_call *call;
7166         struct ndr_pull *pull;
7167         struct ndr_push *push;
7168         enum ndr_err_code ndr_err;
7169         DATA_BLOB blob;
7170         struct spoolss_5c *r;
7171
7172         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5C];
7173
7174         r = talloc(talloc_tos(), struct spoolss_5c);
7175         if (r == NULL) {
7176                 return false;
7177         }
7178
7179         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7180                 talloc_free(r);
7181                 return false;
7182         }
7183
7184         pull = ndr_pull_init_blob(&blob, r, NULL);
7185         if (pull == NULL) {
7186                 talloc_free(r);
7187                 return false;
7188         }
7189
7190         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7191         ndr_err = call->ndr_pull(pull, NDR_IN, r);
7192         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7193                 talloc_free(r);
7194                 return false;
7195         }
7196
7197         if (DEBUGLEVEL >= 10) {
7198                 NDR_PRINT_IN_DEBUG(spoolss_5c, r);
7199         }
7200
7201         r->out.result = _spoolss_5c(p, r);
7202
7203         if (p->rng_fault_state) {
7204                 talloc_free(r);
7205                 /* Return true here, srv_pipe_hnd.c will take care */
7206                 return true;
7207         }
7208
7209         if (DEBUGLEVEL >= 10) {
7210                 NDR_PRINT_OUT_DEBUG(spoolss_5c, r);
7211         }
7212
7213         push = ndr_push_init_ctx(r, NULL);
7214         if (push == NULL) {
7215                 talloc_free(r);
7216                 return false;
7217         }
7218
7219         ndr_err = call->ndr_push(push, NDR_OUT, r);
7220         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7221                 talloc_free(r);
7222                 return false;
7223         }
7224
7225         blob = ndr_push_blob(push);
7226         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7227                 talloc_free(r);
7228                 return false;
7229         }
7230
7231         talloc_free(r);
7232
7233         return true;
7234 }
7235
7236 static bool api_spoolss_5d(pipes_struct *p)
7237 {
7238         const struct ndr_interface_call *call;
7239         struct ndr_pull *pull;
7240         struct ndr_push *push;
7241         enum ndr_err_code ndr_err;
7242         DATA_BLOB blob;
7243         struct spoolss_5d *r;
7244
7245         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5D];
7246
7247         r = talloc(talloc_tos(), struct spoolss_5d);
7248         if (r == NULL) {
7249                 return false;
7250         }
7251
7252         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7253                 talloc_free(r);
7254                 return false;
7255         }
7256
7257         pull = ndr_pull_init_blob(&blob, r, NULL);
7258         if (pull == NULL) {
7259                 talloc_free(r);
7260                 return false;
7261         }
7262
7263         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7264         ndr_err = call->ndr_pull(pull, NDR_IN, r);
7265         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7266                 talloc_free(r);
7267                 return false;
7268         }
7269
7270         if (DEBUGLEVEL >= 10) {
7271                 NDR_PRINT_IN_DEBUG(spoolss_5d, r);
7272         }
7273
7274         r->out.result = _spoolss_5d(p, r);
7275
7276         if (p->rng_fault_state) {
7277                 talloc_free(r);
7278                 /* Return true here, srv_pipe_hnd.c will take care */
7279                 return true;
7280         }
7281
7282         if (DEBUGLEVEL >= 10) {
7283                 NDR_PRINT_OUT_DEBUG(spoolss_5d, r);
7284         }
7285
7286         push = ndr_push_init_ctx(r, NULL);
7287         if (push == NULL) {
7288                 talloc_free(r);
7289                 return false;
7290         }
7291
7292         ndr_err = call->ndr_push(push, NDR_OUT, r);
7293         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7294                 talloc_free(r);
7295                 return false;
7296         }
7297
7298         blob = ndr_push_blob(push);
7299         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7300                 talloc_free(r);
7301                 return false;
7302         }
7303
7304         talloc_free(r);
7305
7306         return true;
7307 }
7308
7309 static bool api_spoolss_5e(pipes_struct *p)
7310 {
7311         const struct ndr_interface_call *call;
7312         struct ndr_pull *pull;
7313         struct ndr_push *push;
7314         enum ndr_err_code ndr_err;
7315         DATA_BLOB blob;
7316         struct spoolss_5e *r;
7317
7318         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5E];
7319
7320         r = talloc(talloc_tos(), struct spoolss_5e);
7321         if (r == NULL) {
7322                 return false;
7323         }
7324
7325         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7326                 talloc_free(r);
7327                 return false;
7328         }
7329
7330         pull = ndr_pull_init_blob(&blob, r, NULL);
7331         if (pull == NULL) {
7332                 talloc_free(r);
7333                 return false;
7334         }
7335
7336         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7337         ndr_err = call->ndr_pull(pull, NDR_IN, r);
7338         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7339                 talloc_free(r);
7340                 return false;
7341         }
7342
7343         if (DEBUGLEVEL >= 10) {
7344                 NDR_PRINT_IN_DEBUG(spoolss_5e, r);
7345         }
7346
7347         r->out.result = _spoolss_5e(p, r);
7348
7349         if (p->rng_fault_state) {
7350                 talloc_free(r);
7351                 /* Return true here, srv_pipe_hnd.c will take care */
7352                 return true;
7353         }
7354
7355         if (DEBUGLEVEL >= 10) {
7356                 NDR_PRINT_OUT_DEBUG(spoolss_5e, r);
7357         }
7358
7359         push = ndr_push_init_ctx(r, NULL);
7360         if (push == NULL) {
7361                 talloc_free(r);
7362                 return false;
7363         }
7364
7365         ndr_err = call->ndr_push(push, NDR_OUT, r);
7366         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7367                 talloc_free(r);
7368                 return false;
7369         }
7370
7371         blob = ndr_push_blob(push);
7372         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7373                 talloc_free(r);
7374                 return false;
7375         }
7376
7377         talloc_free(r);
7378
7379         return true;
7380 }
7381
7382 static bool api_spoolss_5f(pipes_struct *p)
7383 {
7384         const struct ndr_interface_call *call;
7385         struct ndr_pull *pull;
7386         struct ndr_push *push;
7387         enum ndr_err_code ndr_err;
7388         DATA_BLOB blob;
7389         struct spoolss_5f *r;
7390
7391         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5F];
7392
7393         r = talloc(talloc_tos(), struct spoolss_5f);
7394         if (r == NULL) {
7395                 return false;
7396         }
7397
7398         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7399                 talloc_free(r);
7400                 return false;
7401         }
7402
7403         pull = ndr_pull_init_blob(&blob, r, NULL);
7404         if (pull == NULL) {
7405                 talloc_free(r);
7406                 return false;
7407         }
7408
7409         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7410         ndr_err = call->ndr_pull(pull, NDR_IN, r);
7411         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7412                 talloc_free(r);
7413                 return false;
7414         }
7415
7416         if (DEBUGLEVEL >= 10) {
7417                 NDR_PRINT_IN_DEBUG(spoolss_5f, r);
7418         }
7419
7420         r->out.result = _spoolss_5f(p, r);
7421
7422         if (p->rng_fault_state) {
7423                 talloc_free(r);
7424                 /* Return true here, srv_pipe_hnd.c will take care */
7425                 return true;
7426         }
7427
7428         if (DEBUGLEVEL >= 10) {
7429                 NDR_PRINT_OUT_DEBUG(spoolss_5f, r);
7430         }
7431
7432         push = ndr_push_init_ctx(r, NULL);
7433         if (push == NULL) {
7434                 talloc_free(r);
7435                 return false;
7436         }
7437
7438         ndr_err = call->ndr_push(push, NDR_OUT, r);
7439         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7440                 talloc_free(r);
7441                 return false;
7442         }
7443
7444         blob = ndr_push_blob(push);
7445         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7446                 talloc_free(r);
7447                 return false;
7448         }
7449
7450         talloc_free(r);
7451
7452         return true;
7453 }
7454
7455
7456 /* Tables */
7457 static struct api_struct api_spoolss_cmds[] =
7458 {
7459         {"SPOOLSS_ENUMPRINTERS", NDR_SPOOLSS_ENUMPRINTERS, api_spoolss_EnumPrinters},
7460         {"SPOOLSS_OPENPRINTER", NDR_SPOOLSS_OPENPRINTER, api_spoolss_OpenPrinter},
7461         {"SPOOLSS_SETJOB", NDR_SPOOLSS_SETJOB, api_spoolss_SetJob},
7462         {"SPOOLSS_GETJOB", NDR_SPOOLSS_GETJOB, api_spoolss_GetJob},
7463         {"SPOOLSS_ENUMJOBS", NDR_SPOOLSS_ENUMJOBS, api_spoolss_EnumJobs},
7464         {"SPOOLSS_ADDPRINTER", NDR_SPOOLSS_ADDPRINTER, api_spoolss_AddPrinter},
7465         {"SPOOLSS_DELETEPRINTER", NDR_SPOOLSS_DELETEPRINTER, api_spoolss_DeletePrinter},
7466         {"SPOOLSS_SETPRINTER", NDR_SPOOLSS_SETPRINTER, api_spoolss_SetPrinter},
7467         {"SPOOLSS_GETPRINTER", NDR_SPOOLSS_GETPRINTER, api_spoolss_GetPrinter},
7468         {"SPOOLSS_ADDPRINTERDRIVER", NDR_SPOOLSS_ADDPRINTERDRIVER, api_spoolss_AddPrinterDriver},
7469         {"SPOOLSS_ENUMPRINTERDRIVERS", NDR_SPOOLSS_ENUMPRINTERDRIVERS, api_spoolss_EnumPrinterDrivers},
7470         {"SPOOLSS_GETPRINTERDRIVER", NDR_SPOOLSS_GETPRINTERDRIVER, api_spoolss_GetPrinterDriver},
7471         {"SPOOLSS_GETPRINTERDRIVERDIRECTORY", NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY, api_spoolss_GetPrinterDriverDirectory},
7472         {"SPOOLSS_DELETEPRINTERDRIVER", NDR_SPOOLSS_DELETEPRINTERDRIVER, api_spoolss_DeletePrinterDriver},
7473         {"SPOOLSS_ADDPRINTPROCESSOR", NDR_SPOOLSS_ADDPRINTPROCESSOR, api_spoolss_AddPrintProcessor},
7474         {"SPOOLSS_ENUMPRINTPROCESSORS", NDR_SPOOLSS_ENUMPRINTPROCESSORS, api_spoolss_EnumPrintProcessors},
7475         {"SPOOLSS_GETPRINTPROCESSORDIRECTORY", NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY, api_spoolss_GetPrintProcessorDirectory},
7476         {"SPOOLSS_STARTDOCPRINTER", NDR_SPOOLSS_STARTDOCPRINTER, api_spoolss_StartDocPrinter},
7477         {"SPOOLSS_STARTPAGEPRINTER", NDR_SPOOLSS_STARTPAGEPRINTER, api_spoolss_StartPagePrinter},
7478         {"SPOOLSS_WRITEPRINTER", NDR_SPOOLSS_WRITEPRINTER, api_spoolss_WritePrinter},
7479         {"SPOOLSS_ENDPAGEPRINTER", NDR_SPOOLSS_ENDPAGEPRINTER, api_spoolss_EndPagePrinter},
7480         {"SPOOLSS_ABORTPRINTER", NDR_SPOOLSS_ABORTPRINTER, api_spoolss_AbortPrinter},
7481         {"SPOOLSS_READPRINTER", NDR_SPOOLSS_READPRINTER, api_spoolss_ReadPrinter},
7482         {"SPOOLSS_ENDDOCPRINTER", NDR_SPOOLSS_ENDDOCPRINTER, api_spoolss_EndDocPrinter},
7483         {"SPOOLSS_ADDJOB", NDR_SPOOLSS_ADDJOB, api_spoolss_AddJob},
7484         {"SPOOLSS_SCHEDULEJOB", NDR_SPOOLSS_SCHEDULEJOB, api_spoolss_ScheduleJob},
7485         {"SPOOLSS_GETPRINTERDATA", NDR_SPOOLSS_GETPRINTERDATA, api_spoolss_GetPrinterData},
7486         {"SPOOLSS_SETPRINTERDATA", NDR_SPOOLSS_SETPRINTERDATA, api_spoolss_SetPrinterData},
7487         {"SPOOLSS_WAITFORPRINTERCHANGE", NDR_SPOOLSS_WAITFORPRINTERCHANGE, api_spoolss_WaitForPrinterChange},
7488         {"SPOOLSS_CLOSEPRINTER", NDR_SPOOLSS_CLOSEPRINTER, api_spoolss_ClosePrinter},
7489         {"SPOOLSS_ADDFORM", NDR_SPOOLSS_ADDFORM, api_spoolss_AddForm},
7490         {"SPOOLSS_DELETEFORM", NDR_SPOOLSS_DELETEFORM, api_spoolss_DeleteForm},
7491         {"SPOOLSS_GETFORM", NDR_SPOOLSS_GETFORM, api_spoolss_GetForm},
7492         {"SPOOLSS_SETFORM", NDR_SPOOLSS_SETFORM, api_spoolss_SetForm},
7493         {"SPOOLSS_ENUMFORMS", NDR_SPOOLSS_ENUMFORMS, api_spoolss_EnumForms},
7494         {"SPOOLSS_ENUMPORTS", NDR_SPOOLSS_ENUMPORTS, api_spoolss_EnumPorts},
7495         {"SPOOLSS_ENUMMONITORS", NDR_SPOOLSS_ENUMMONITORS, api_spoolss_EnumMonitors},
7496         {"SPOOLSS_ADDPORT", NDR_SPOOLSS_ADDPORT, api_spoolss_AddPort},
7497         {"SPOOLSS_CONFIGUREPORT", NDR_SPOOLSS_CONFIGUREPORT, api_spoolss_ConfigurePort},
7498         {"SPOOLSS_DELETEPORT", NDR_SPOOLSS_DELETEPORT, api_spoolss_DeletePort},
7499         {"SPOOLSS_CREATEPRINTERIC", NDR_SPOOLSS_CREATEPRINTERIC, api_spoolss_CreatePrinterIC},
7500         {"SPOOLSS_PLAYGDISCRIPTONPRINTERIC", NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC, api_spoolss_PlayGDIScriptOnPrinterIC},
7501         {"SPOOLSS_DELETEPRINTERIC", NDR_SPOOLSS_DELETEPRINTERIC, api_spoolss_DeletePrinterIC},
7502         {"SPOOLSS_ADDPRINTERCONNECTION", NDR_SPOOLSS_ADDPRINTERCONNECTION, api_spoolss_AddPrinterConnection},
7503         {"SPOOLSS_DELETEPRINTERCONNECTION", NDR_SPOOLSS_DELETEPRINTERCONNECTION, api_spoolss_DeletePrinterConnection},
7504         {"SPOOLSS_PRINTERMESSAGEBOX", NDR_SPOOLSS_PRINTERMESSAGEBOX, api_spoolss_PrinterMessageBox},
7505         {"SPOOLSS_ADDMONITOR", NDR_SPOOLSS_ADDMONITOR, api_spoolss_AddMonitor},
7506         {"SPOOLSS_DELETEMONITOR", NDR_SPOOLSS_DELETEMONITOR, api_spoolss_DeleteMonitor},
7507         {"SPOOLSS_DELETEPRINTPROCESSOR", NDR_SPOOLSS_DELETEPRINTPROCESSOR, api_spoolss_DeletePrintProcessor},
7508         {"SPOOLSS_ADDPRINTPROVIDOR", NDR_SPOOLSS_ADDPRINTPROVIDOR, api_spoolss_AddPrintProvidor},
7509         {"SPOOLSS_DELETEPRINTPROVIDOR", NDR_SPOOLSS_DELETEPRINTPROVIDOR, api_spoolss_DeletePrintProvidor},
7510         {"SPOOLSS_ENUMPRINTPROCDATATYPES", NDR_SPOOLSS_ENUMPRINTPROCDATATYPES, api_spoolss_EnumPrintProcDataTypes},
7511         {"SPOOLSS_RESETPRINTER", NDR_SPOOLSS_RESETPRINTER, api_spoolss_ResetPrinter},
7512         {"SPOOLSS_GETPRINTERDRIVER2", NDR_SPOOLSS_GETPRINTERDRIVER2, api_spoolss_GetPrinterDriver2},
7513         {"SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION", NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION, api_spoolss_FindFirstPrinterChangeNotification},
7514         {"SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION", NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION, api_spoolss_FindNextPrinterChangeNotification},
7515         {"SPOOLSS_FINDCLOSEPRINTERNOTIFY", NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY, api_spoolss_FindClosePrinterNotify},
7516         {"SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD", NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD, api_spoolss_RouterFindFirstPrinterChangeNotificationOld},
7517         {"SPOOLSS_REPLYOPENPRINTER", NDR_SPOOLSS_REPLYOPENPRINTER, api_spoolss_ReplyOpenPrinter},
7518         {"SPOOLSS_ROUTERREPLYPRINTER", NDR_SPOOLSS_ROUTERREPLYPRINTER, api_spoolss_RouterReplyPrinter},
7519         {"SPOOLSS_REPLYCLOSEPRINTER", NDR_SPOOLSS_REPLYCLOSEPRINTER, api_spoolss_ReplyClosePrinter},
7520         {"SPOOLSS_ADDPORTEX", NDR_SPOOLSS_ADDPORTEX, api_spoolss_AddPortEx},
7521         {"SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION", NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION, api_spoolss_RouterFindFirstPrinterChangeNotification},
7522         {"SPOOLSS_SPOOLERINIT", NDR_SPOOLSS_SPOOLERINIT, api_spoolss_SpoolerInit},
7523         {"SPOOLSS_RESETPRINTEREX", NDR_SPOOLSS_RESETPRINTEREX, api_spoolss_ResetPrinterEx},
7524         {"SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX", NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX, api_spoolss_RemoteFindFirstPrinterChangeNotifyEx},
7525         {"SPOOLSS_ROUTERREPLYPRINTEREX", NDR_SPOOLSS_ROUTERREPLYPRINTEREX, api_spoolss_RouterReplyPrinterEx},
7526         {"SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY", NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY, api_spoolss_RouterRefreshPrinterChangeNotify},
7527         {"SPOOLSS_44", NDR_SPOOLSS_44, api_spoolss_44},
7528         {"SPOOLSS_OPENPRINTEREX", NDR_SPOOLSS_OPENPRINTEREX, api_spoolss_OpenPrinterEx},
7529         {"SPOOLSS_ADDPRINTEREX", NDR_SPOOLSS_ADDPRINTEREX, api_spoolss_AddPrinterEx},
7530         {"SPOOLSS_47", NDR_SPOOLSS_47, api_spoolss_47},
7531         {"SPOOLSS_ENUMPRINTERDATA", NDR_SPOOLSS_ENUMPRINTERDATA, api_spoolss_EnumPrinterData},
7532         {"SPOOLSS_DELETEPRINTERDATA", NDR_SPOOLSS_DELETEPRINTERDATA, api_spoolss_DeletePrinterData},
7533         {"SPOOLSS_4A", NDR_SPOOLSS_4A, api_spoolss_4a},
7534         {"SPOOLSS_4B", NDR_SPOOLSS_4B, api_spoolss_4b},
7535         {"SPOOLSS_4C", NDR_SPOOLSS_4C, api_spoolss_4c},
7536         {"SPOOLSS_SETPRINTERDATAEX", NDR_SPOOLSS_SETPRINTERDATAEX, api_spoolss_SetPrinterDataEx},
7537         {"SPOOLSS_GETPRINTERDATAEX", NDR_SPOOLSS_GETPRINTERDATAEX, api_spoolss_GetPrinterDataEx},
7538         {"SPOOLSS_ENUMPRINTERDATAEX", NDR_SPOOLSS_ENUMPRINTERDATAEX, api_spoolss_EnumPrinterDataEx},
7539         {"SPOOLSS_ENUMPRINTERKEY", NDR_SPOOLSS_ENUMPRINTERKEY, api_spoolss_EnumPrinterKey},
7540         {"SPOOLSS_DELETEPRINTERDATAEX", NDR_SPOOLSS_DELETEPRINTERDATAEX, api_spoolss_DeletePrinterDataEx},
7541         {"SPOOLSS_DELETEPRINTERKEY", NDR_SPOOLSS_DELETEPRINTERKEY, api_spoolss_DeletePrinterKey},
7542         {"SPOOLSS_53", NDR_SPOOLSS_53, api_spoolss_53},
7543         {"SPOOLSS_DELETEPRINTERDRIVEREX", NDR_SPOOLSS_DELETEPRINTERDRIVEREX, api_spoolss_DeletePrinterDriverEx},
7544         {"SPOOLSS_55", NDR_SPOOLSS_55, api_spoolss_55},
7545         {"SPOOLSS_56", NDR_SPOOLSS_56, api_spoolss_56},
7546         {"SPOOLSS_57", NDR_SPOOLSS_57, api_spoolss_57},
7547         {"SPOOLSS_XCVDATA", NDR_SPOOLSS_XCVDATA, api_spoolss_XcvData},
7548         {"SPOOLSS_ADDPRINTERDRIVEREX", NDR_SPOOLSS_ADDPRINTERDRIVEREX, api_spoolss_AddPrinterDriverEx},
7549         {"SPOOLSS_5A", NDR_SPOOLSS_5A, api_spoolss_5a},
7550         {"SPOOLSS_5B", NDR_SPOOLSS_5B, api_spoolss_5b},
7551         {"SPOOLSS_5C", NDR_SPOOLSS_5C, api_spoolss_5c},
7552         {"SPOOLSS_5D", NDR_SPOOLSS_5D, api_spoolss_5d},
7553         {"SPOOLSS_5E", NDR_SPOOLSS_5E, api_spoolss_5e},
7554         {"SPOOLSS_5F", NDR_SPOOLSS_5F, api_spoolss_5f},
7555 };
7556
7557 void spoolss_get_pipe_fns(struct api_struct **fns, int *n_fns)
7558 {
7559         *fns = api_spoolss_cmds;
7560         *n_fns = sizeof(api_spoolss_cmds) / sizeof(struct api_struct);
7561 }
7562
7563 NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r)
7564 {
7565         if (cli->pipes_struct == NULL) {
7566                 return NT_STATUS_INVALID_PARAMETER;
7567         }
7568
7569         switch (opnum)
7570         {
7571                 case NDR_SPOOLSS_ENUMPRINTERS: {
7572                         struct spoolss_EnumPrinters *r = (struct spoolss_EnumPrinters *)_r;
7573                         ZERO_STRUCT(r->out);
7574                         r->out.count = talloc_zero(mem_ctx, uint32_t);
7575                         if (r->out.count == NULL) {
7576                         return NT_STATUS_NO_MEMORY;
7577                         }
7578
7579                         r->out.info = talloc_zero(mem_ctx, union spoolss_PrinterInfo *);
7580                         if (r->out.info == NULL) {
7581                         return NT_STATUS_NO_MEMORY;
7582                         }
7583
7584                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7585                         if (r->out.needed == NULL) {
7586                         return NT_STATUS_NO_MEMORY;
7587                         }
7588
7589                         r->out.result = _spoolss_EnumPrinters(cli->pipes_struct, r);
7590                         return NT_STATUS_OK;
7591                 }
7592
7593                 case NDR_SPOOLSS_OPENPRINTER: {
7594                         struct spoolss_OpenPrinter *r = (struct spoolss_OpenPrinter *)_r;
7595                         ZERO_STRUCT(r->out);
7596                         r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
7597                         if (r->out.handle == NULL) {
7598                         return NT_STATUS_NO_MEMORY;
7599                         }
7600
7601                         r->out.result = _spoolss_OpenPrinter(cli->pipes_struct, r);
7602                         return NT_STATUS_OK;
7603                 }
7604
7605                 case NDR_SPOOLSS_SETJOB: {
7606                         struct spoolss_SetJob *r = (struct spoolss_SetJob *)_r;
7607                         r->out.result = _spoolss_SetJob(cli->pipes_struct, r);
7608                         return NT_STATUS_OK;
7609                 }
7610
7611                 case NDR_SPOOLSS_GETJOB: {
7612                         struct spoolss_GetJob *r = (struct spoolss_GetJob *)_r;
7613                         ZERO_STRUCT(r->out);
7614                         r->out.info = talloc_zero(mem_ctx, union spoolss_JobInfo);
7615                         if (r->out.info == NULL) {
7616                         return NT_STATUS_NO_MEMORY;
7617                         }
7618
7619                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7620                         if (r->out.needed == NULL) {
7621                         return NT_STATUS_NO_MEMORY;
7622                         }
7623
7624                         r->out.result = _spoolss_GetJob(cli->pipes_struct, r);
7625                         return NT_STATUS_OK;
7626                 }
7627
7628                 case NDR_SPOOLSS_ENUMJOBS: {
7629                         struct spoolss_EnumJobs *r = (struct spoolss_EnumJobs *)_r;
7630                         ZERO_STRUCT(r->out);
7631                         r->out.count = talloc_zero(mem_ctx, uint32_t);
7632                         if (r->out.count == NULL) {
7633                         return NT_STATUS_NO_MEMORY;
7634                         }
7635
7636                         r->out.info = talloc_zero(mem_ctx, union spoolss_JobInfo *);
7637                         if (r->out.info == NULL) {
7638                         return NT_STATUS_NO_MEMORY;
7639                         }
7640
7641                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7642                         if (r->out.needed == NULL) {
7643                         return NT_STATUS_NO_MEMORY;
7644                         }
7645
7646                         r->out.result = _spoolss_EnumJobs(cli->pipes_struct, r);
7647                         return NT_STATUS_OK;
7648                 }
7649
7650                 case NDR_SPOOLSS_ADDPRINTER: {
7651                         struct spoolss_AddPrinter *r = (struct spoolss_AddPrinter *)_r;
7652                         r->out.result = _spoolss_AddPrinter(cli->pipes_struct, r);
7653                         return NT_STATUS_OK;
7654                 }
7655
7656                 case NDR_SPOOLSS_DELETEPRINTER: {
7657                         struct spoolss_DeletePrinter *r = (struct spoolss_DeletePrinter *)_r;
7658                         r->out.result = _spoolss_DeletePrinter(cli->pipes_struct, r);
7659                         return NT_STATUS_OK;
7660                 }
7661
7662                 case NDR_SPOOLSS_SETPRINTER: {
7663                         struct spoolss_SetPrinter *r = (struct spoolss_SetPrinter *)_r;
7664                         r->out.result = _spoolss_SetPrinter(cli->pipes_struct, r);
7665                         return NT_STATUS_OK;
7666                 }
7667
7668                 case NDR_SPOOLSS_GETPRINTER: {
7669                         struct spoolss_GetPrinter *r = (struct spoolss_GetPrinter *)_r;
7670                         ZERO_STRUCT(r->out);
7671                         r->out.info = talloc_zero(mem_ctx, union spoolss_PrinterInfo);
7672                         if (r->out.info == NULL) {
7673                         return NT_STATUS_NO_MEMORY;
7674                         }
7675
7676                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7677                         if (r->out.needed == NULL) {
7678                         return NT_STATUS_NO_MEMORY;
7679                         }
7680
7681                         r->out.result = _spoolss_GetPrinter(cli->pipes_struct, r);
7682                         return NT_STATUS_OK;
7683                 }
7684
7685                 case NDR_SPOOLSS_ADDPRINTERDRIVER: {
7686                         struct spoolss_AddPrinterDriver *r = (struct spoolss_AddPrinterDriver *)_r;
7687                         r->out.result = _spoolss_AddPrinterDriver(cli->pipes_struct, r);
7688                         return NT_STATUS_OK;
7689                 }
7690
7691                 case NDR_SPOOLSS_ENUMPRINTERDRIVERS: {
7692                         struct spoolss_EnumPrinterDrivers *r = (struct spoolss_EnumPrinterDrivers *)_r;
7693                         ZERO_STRUCT(r->out);
7694                         r->out.count = talloc_zero(mem_ctx, uint32_t);
7695                         if (r->out.count == NULL) {
7696                         return NT_STATUS_NO_MEMORY;
7697                         }
7698
7699                         r->out.info = talloc_zero(mem_ctx, union spoolss_DriverInfo *);
7700                         if (r->out.info == NULL) {
7701                         return NT_STATUS_NO_MEMORY;
7702                         }
7703
7704                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7705                         if (r->out.needed == NULL) {
7706                         return NT_STATUS_NO_MEMORY;
7707                         }
7708
7709                         r->out.result = _spoolss_EnumPrinterDrivers(cli->pipes_struct, r);
7710                         return NT_STATUS_OK;
7711                 }
7712
7713                 case NDR_SPOOLSS_GETPRINTERDRIVER: {
7714                         struct spoolss_GetPrinterDriver *r = (struct spoolss_GetPrinterDriver *)_r;
7715                         r->out.result = _spoolss_GetPrinterDriver(cli->pipes_struct, r);
7716                         return NT_STATUS_OK;
7717                 }
7718
7719                 case NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY: {
7720                         struct spoolss_GetPrinterDriverDirectory *r = (struct spoolss_GetPrinterDriverDirectory *)_r;
7721                         ZERO_STRUCT(r->out);
7722                         r->out.info = talloc_zero(mem_ctx, union spoolss_DriverDirectoryInfo);
7723                         if (r->out.info == NULL) {
7724                         return NT_STATUS_NO_MEMORY;
7725                         }
7726
7727                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7728                         if (r->out.needed == NULL) {
7729                         return NT_STATUS_NO_MEMORY;
7730                         }
7731
7732                         r->out.result = _spoolss_GetPrinterDriverDirectory(cli->pipes_struct, r);
7733                         return NT_STATUS_OK;
7734                 }
7735
7736                 case NDR_SPOOLSS_DELETEPRINTERDRIVER: {
7737                         struct spoolss_DeletePrinterDriver *r = (struct spoolss_DeletePrinterDriver *)_r;
7738                         r->out.result = _spoolss_DeletePrinterDriver(cli->pipes_struct, r);
7739                         return NT_STATUS_OK;
7740                 }
7741
7742                 case NDR_SPOOLSS_ADDPRINTPROCESSOR: {
7743                         struct spoolss_AddPrintProcessor *r = (struct spoolss_AddPrintProcessor *)_r;
7744                         r->out.result = _spoolss_AddPrintProcessor(cli->pipes_struct, r);
7745                         return NT_STATUS_OK;
7746                 }
7747
7748                 case NDR_SPOOLSS_ENUMPRINTPROCESSORS: {
7749                         struct spoolss_EnumPrintProcessors *r = (struct spoolss_EnumPrintProcessors *)_r;
7750                         ZERO_STRUCT(r->out);
7751                         r->out.count = talloc_zero(mem_ctx, uint32_t);
7752                         if (r->out.count == NULL) {
7753                         return NT_STATUS_NO_MEMORY;
7754                         }
7755
7756                         r->out.info = talloc_zero(mem_ctx, union spoolss_PrintProcessorInfo *);
7757                         if (r->out.info == NULL) {
7758                         return NT_STATUS_NO_MEMORY;
7759                         }
7760
7761                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7762                         if (r->out.needed == NULL) {
7763                         return NT_STATUS_NO_MEMORY;
7764                         }
7765
7766                         r->out.result = _spoolss_EnumPrintProcessors(cli->pipes_struct, r);
7767                         return NT_STATUS_OK;
7768                 }
7769
7770                 case NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY: {
7771                         struct spoolss_GetPrintProcessorDirectory *r = (struct spoolss_GetPrintProcessorDirectory *)_r;
7772                         ZERO_STRUCT(r->out);
7773                         r->out.info = talloc_zero(mem_ctx, union spoolss_PrintProcessorDirectoryInfo);
7774                         if (r->out.info == NULL) {
7775                         return NT_STATUS_NO_MEMORY;
7776                         }
7777
7778                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7779                         if (r->out.needed == NULL) {
7780                         return NT_STATUS_NO_MEMORY;
7781                         }
7782
7783                         r->out.result = _spoolss_GetPrintProcessorDirectory(cli->pipes_struct, r);
7784                         return NT_STATUS_OK;
7785                 }
7786
7787                 case NDR_SPOOLSS_STARTDOCPRINTER: {
7788                         struct spoolss_StartDocPrinter *r = (struct spoolss_StartDocPrinter *)_r;
7789                         ZERO_STRUCT(r->out);
7790                         r->out.job_id = talloc_zero(mem_ctx, uint32_t);
7791                         if (r->out.job_id == NULL) {
7792                         return NT_STATUS_NO_MEMORY;
7793                         }
7794
7795                         r->out.result = _spoolss_StartDocPrinter(cli->pipes_struct, r);
7796                         return NT_STATUS_OK;
7797                 }
7798
7799                 case NDR_SPOOLSS_STARTPAGEPRINTER: {
7800                         struct spoolss_StartPagePrinter *r = (struct spoolss_StartPagePrinter *)_r;
7801                         r->out.result = _spoolss_StartPagePrinter(cli->pipes_struct, r);
7802                         return NT_STATUS_OK;
7803                 }
7804
7805                 case NDR_SPOOLSS_WRITEPRINTER: {
7806                         struct spoolss_WritePrinter *r = (struct spoolss_WritePrinter *)_r;
7807                         ZERO_STRUCT(r->out);
7808                         r->out.num_written = talloc_zero(mem_ctx, uint32_t);
7809                         if (r->out.num_written == NULL) {
7810                         return NT_STATUS_NO_MEMORY;
7811                         }
7812
7813                         r->out.result = _spoolss_WritePrinter(cli->pipes_struct, r);
7814                         return NT_STATUS_OK;
7815                 }
7816
7817                 case NDR_SPOOLSS_ENDPAGEPRINTER: {
7818                         struct spoolss_EndPagePrinter *r = (struct spoolss_EndPagePrinter *)_r;
7819                         r->out.result = _spoolss_EndPagePrinter(cli->pipes_struct, r);
7820                         return NT_STATUS_OK;
7821                 }
7822
7823                 case NDR_SPOOLSS_ABORTPRINTER: {
7824                         struct spoolss_AbortPrinter *r = (struct spoolss_AbortPrinter *)_r;
7825                         r->out.result = _spoolss_AbortPrinter(cli->pipes_struct, r);
7826                         return NT_STATUS_OK;
7827                 }
7828
7829                 case NDR_SPOOLSS_READPRINTER: {
7830                         struct spoolss_ReadPrinter *r = (struct spoolss_ReadPrinter *)_r;
7831                         ZERO_STRUCT(r->out);
7832                         r->out.data = talloc_zero_array(mem_ctx, uint8_t, r->in.data_size);
7833                         if (r->out.data == NULL) {
7834                         return NT_STATUS_NO_MEMORY;
7835                         }
7836
7837                         r->out._data_size = talloc_zero(mem_ctx, uint32_t);
7838                         if (r->out._data_size == NULL) {
7839                         return NT_STATUS_NO_MEMORY;
7840                         }
7841
7842                         r->out.result = _spoolss_ReadPrinter(cli->pipes_struct, r);
7843                         return NT_STATUS_OK;
7844                 }
7845
7846                 case NDR_SPOOLSS_ENDDOCPRINTER: {
7847                         struct spoolss_EndDocPrinter *r = (struct spoolss_EndDocPrinter *)_r;
7848                         r->out.result = _spoolss_EndDocPrinter(cli->pipes_struct, r);
7849                         return NT_STATUS_OK;
7850                 }
7851
7852                 case NDR_SPOOLSS_ADDJOB: {
7853                         struct spoolss_AddJob *r = (struct spoolss_AddJob *)_r;
7854                         ZERO_STRUCT(r->out);
7855                         r->out.buffer = r->in.buffer;
7856                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7857                         if (r->out.needed == NULL) {
7858                         return NT_STATUS_NO_MEMORY;
7859                         }
7860
7861                         r->out.result = _spoolss_AddJob(cli->pipes_struct, r);
7862                         return NT_STATUS_OK;
7863                 }
7864
7865                 case NDR_SPOOLSS_SCHEDULEJOB: {
7866                         struct spoolss_ScheduleJob *r = (struct spoolss_ScheduleJob *)_r;
7867                         r->out.result = _spoolss_ScheduleJob(cli->pipes_struct, r);
7868                         return NT_STATUS_OK;
7869                 }
7870
7871                 case NDR_SPOOLSS_GETPRINTERDATA: {
7872                         struct spoolss_GetPrinterData *r = (struct spoolss_GetPrinterData *)_r;
7873                         ZERO_STRUCT(r->out);
7874                         r->out.type = talloc_zero(mem_ctx, enum winreg_Type);
7875                         if (r->out.type == NULL) {
7876                         return NT_STATUS_NO_MEMORY;
7877                         }
7878
7879                         r->out.data = talloc_zero(mem_ctx, union spoolss_PrinterData);
7880                         if (r->out.data == NULL) {
7881                         return NT_STATUS_NO_MEMORY;
7882                         }
7883
7884                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7885                         if (r->out.needed == NULL) {
7886                         return NT_STATUS_NO_MEMORY;
7887                         }
7888
7889                         r->out.result = _spoolss_GetPrinterData(cli->pipes_struct, r);
7890                         return NT_STATUS_OK;
7891                 }
7892
7893                 case NDR_SPOOLSS_SETPRINTERDATA: {
7894                         struct spoolss_SetPrinterData *r = (struct spoolss_SetPrinterData *)_r;
7895                         r->out.result = _spoolss_SetPrinterData(cli->pipes_struct, r);
7896                         return NT_STATUS_OK;
7897                 }
7898
7899                 case NDR_SPOOLSS_WAITFORPRINTERCHANGE: {
7900                         struct spoolss_WaitForPrinterChange *r = (struct spoolss_WaitForPrinterChange *)_r;
7901                         r->out.result = _spoolss_WaitForPrinterChange(cli->pipes_struct, r);
7902                         return NT_STATUS_OK;
7903                 }
7904
7905                 case NDR_SPOOLSS_CLOSEPRINTER: {
7906                         struct spoolss_ClosePrinter *r = (struct spoolss_ClosePrinter *)_r;
7907                         ZERO_STRUCT(r->out);
7908                         r->out.handle = r->in.handle;
7909                         r->out.result = _spoolss_ClosePrinter(cli->pipes_struct, r);
7910                         return NT_STATUS_OK;
7911                 }
7912
7913                 case NDR_SPOOLSS_ADDFORM: {
7914                         struct spoolss_AddForm *r = (struct spoolss_AddForm *)_r;
7915                         r->out.result = _spoolss_AddForm(cli->pipes_struct, r);
7916                         return NT_STATUS_OK;
7917                 }
7918
7919                 case NDR_SPOOLSS_DELETEFORM: {
7920                         struct spoolss_DeleteForm *r = (struct spoolss_DeleteForm *)_r;
7921                         r->out.result = _spoolss_DeleteForm(cli->pipes_struct, r);
7922                         return NT_STATUS_OK;
7923                 }
7924
7925                 case NDR_SPOOLSS_GETFORM: {
7926                         struct spoolss_GetForm *r = (struct spoolss_GetForm *)_r;
7927                         ZERO_STRUCT(r->out);
7928                         r->out.info = talloc_zero(mem_ctx, union spoolss_FormInfo);
7929                         if (r->out.info == NULL) {
7930                         return NT_STATUS_NO_MEMORY;
7931                         }
7932
7933                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7934                         if (r->out.needed == NULL) {
7935                         return NT_STATUS_NO_MEMORY;
7936                         }
7937
7938                         r->out.result = _spoolss_GetForm(cli->pipes_struct, r);
7939                         return NT_STATUS_OK;
7940                 }
7941
7942                 case NDR_SPOOLSS_SETFORM: {
7943                         struct spoolss_SetForm *r = (struct spoolss_SetForm *)_r;
7944                         r->out.result = _spoolss_SetForm(cli->pipes_struct, r);
7945                         return NT_STATUS_OK;
7946                 }
7947
7948                 case NDR_SPOOLSS_ENUMFORMS: {
7949                         struct spoolss_EnumForms *r = (struct spoolss_EnumForms *)_r;
7950                         ZERO_STRUCT(r->out);
7951                         r->out.count = talloc_zero(mem_ctx, uint32_t);
7952                         if (r->out.count == NULL) {
7953                         return NT_STATUS_NO_MEMORY;
7954                         }
7955
7956                         r->out.info = talloc_zero(mem_ctx, union spoolss_FormInfo *);
7957                         if (r->out.info == NULL) {
7958                         return NT_STATUS_NO_MEMORY;
7959                         }
7960
7961                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7962                         if (r->out.needed == NULL) {
7963                         return NT_STATUS_NO_MEMORY;
7964                         }
7965
7966                         r->out.result = _spoolss_EnumForms(cli->pipes_struct, r);
7967                         return NT_STATUS_OK;
7968                 }
7969
7970                 case NDR_SPOOLSS_ENUMPORTS: {
7971                         struct spoolss_EnumPorts *r = (struct spoolss_EnumPorts *)_r;
7972                         ZERO_STRUCT(r->out);
7973                         r->out.count = talloc_zero(mem_ctx, uint32_t);
7974                         if (r->out.count == NULL) {
7975                         return NT_STATUS_NO_MEMORY;
7976                         }
7977
7978                         r->out.info = talloc_zero(mem_ctx, union spoolss_PortInfo *);
7979                         if (r->out.info == NULL) {
7980                         return NT_STATUS_NO_MEMORY;
7981                         }
7982
7983                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7984                         if (r->out.needed == NULL) {
7985                         return NT_STATUS_NO_MEMORY;
7986                         }
7987
7988                         r->out.result = _spoolss_EnumPorts(cli->pipes_struct, r);
7989                         return NT_STATUS_OK;
7990                 }
7991
7992                 case NDR_SPOOLSS_ENUMMONITORS: {
7993                         struct spoolss_EnumMonitors *r = (struct spoolss_EnumMonitors *)_r;
7994                         ZERO_STRUCT(r->out);
7995                         r->out.count = talloc_zero(mem_ctx, uint32_t);
7996                         if (r->out.count == NULL) {
7997                         return NT_STATUS_NO_MEMORY;
7998                         }
7999
8000                         r->out.info = talloc_zero(mem_ctx, union spoolss_MonitorInfo *);
8001                         if (r->out.info == NULL) {
8002                         return NT_STATUS_NO_MEMORY;
8003                         }
8004
8005                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
8006                         if (r->out.needed == NULL) {
8007                         return NT_STATUS_NO_MEMORY;
8008                         }
8009
8010                         r->out.result = _spoolss_EnumMonitors(cli->pipes_struct, r);
8011                         return NT_STATUS_OK;
8012                 }
8013
8014                 case NDR_SPOOLSS_ADDPORT: {
8015                         struct spoolss_AddPort *r = (struct spoolss_AddPort *)_r;
8016                         r->out.result = _spoolss_AddPort(cli->pipes_struct, r);
8017                         return NT_STATUS_OK;
8018                 }
8019
8020                 case NDR_SPOOLSS_CONFIGUREPORT: {
8021                         struct spoolss_ConfigurePort *r = (struct spoolss_ConfigurePort *)_r;
8022                         r->out.result = _spoolss_ConfigurePort(cli->pipes_struct, r);
8023                         return NT_STATUS_OK;
8024                 }
8025
8026                 case NDR_SPOOLSS_DELETEPORT: {
8027                         struct spoolss_DeletePort *r = (struct spoolss_DeletePort *)_r;
8028                         r->out.result = _spoolss_DeletePort(cli->pipes_struct, r);
8029                         return NT_STATUS_OK;
8030                 }
8031
8032                 case NDR_SPOOLSS_CREATEPRINTERIC: {
8033                         struct spoolss_CreatePrinterIC *r = (struct spoolss_CreatePrinterIC *)_r;
8034                         r->out.result = _spoolss_CreatePrinterIC(cli->pipes_struct, r);
8035                         return NT_STATUS_OK;
8036                 }
8037
8038                 case NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC: {
8039                         struct spoolss_PlayGDIScriptOnPrinterIC *r = (struct spoolss_PlayGDIScriptOnPrinterIC *)_r;
8040                         r->out.result = _spoolss_PlayGDIScriptOnPrinterIC(cli->pipes_struct, r);
8041                         return NT_STATUS_OK;
8042                 }
8043
8044                 case NDR_SPOOLSS_DELETEPRINTERIC: {
8045                         struct spoolss_DeletePrinterIC *r = (struct spoolss_DeletePrinterIC *)_r;
8046                         r->out.result = _spoolss_DeletePrinterIC(cli->pipes_struct, r);
8047                         return NT_STATUS_OK;
8048                 }
8049
8050                 case NDR_SPOOLSS_ADDPRINTERCONNECTION: {
8051                         struct spoolss_AddPrinterConnection *r = (struct spoolss_AddPrinterConnection *)_r;
8052                         r->out.result = _spoolss_AddPrinterConnection(cli->pipes_struct, r);
8053                         return NT_STATUS_OK;
8054                 }
8055
8056                 case NDR_SPOOLSS_DELETEPRINTERCONNECTION: {
8057                         struct spoolss_DeletePrinterConnection *r = (struct spoolss_DeletePrinterConnection *)_r;
8058                         r->out.result = _spoolss_DeletePrinterConnection(cli->pipes_struct, r);
8059                         return NT_STATUS_OK;
8060                 }
8061
8062                 case NDR_SPOOLSS_PRINTERMESSAGEBOX: {
8063                         struct spoolss_PrinterMessageBox *r = (struct spoolss_PrinterMessageBox *)_r;
8064                         r->out.result = _spoolss_PrinterMessageBox(cli->pipes_struct, r);
8065                         return NT_STATUS_OK;
8066                 }
8067
8068                 case NDR_SPOOLSS_ADDMONITOR: {
8069                         struct spoolss_AddMonitor *r = (struct spoolss_AddMonitor *)_r;
8070                         r->out.result = _spoolss_AddMonitor(cli->pipes_struct, r);
8071                         return NT_STATUS_OK;
8072                 }
8073
8074                 case NDR_SPOOLSS_DELETEMONITOR: {
8075                         struct spoolss_DeleteMonitor *r = (struct spoolss_DeleteMonitor *)_r;
8076                         r->out.result = _spoolss_DeleteMonitor(cli->pipes_struct, r);
8077                         return NT_STATUS_OK;
8078                 }
8079
8080                 case NDR_SPOOLSS_DELETEPRINTPROCESSOR: {
8081                         struct spoolss_DeletePrintProcessor *r = (struct spoolss_DeletePrintProcessor *)_r;
8082                         r->out.result = _spoolss_DeletePrintProcessor(cli->pipes_struct, r);
8083                         return NT_STATUS_OK;
8084                 }
8085
8086                 case NDR_SPOOLSS_ADDPRINTPROVIDOR: {
8087                         struct spoolss_AddPrintProvidor *r = (struct spoolss_AddPrintProvidor *)_r;
8088                         r->out.result = _spoolss_AddPrintProvidor(cli->pipes_struct, r);
8089                         return NT_STATUS_OK;
8090                 }
8091
8092                 case NDR_SPOOLSS_DELETEPRINTPROVIDOR: {
8093                         struct spoolss_DeletePrintProvidor *r = (struct spoolss_DeletePrintProvidor *)_r;
8094                         r->out.result = _spoolss_DeletePrintProvidor(cli->pipes_struct, r);
8095                         return NT_STATUS_OK;
8096                 }
8097
8098                 case NDR_SPOOLSS_ENUMPRINTPROCDATATYPES: {
8099                         struct spoolss_EnumPrintProcDataTypes *r = (struct spoolss_EnumPrintProcDataTypes *)_r;
8100                         ZERO_STRUCT(r->out);
8101                         r->out.count = talloc_zero(mem_ctx, uint32_t);
8102                         if (r->out.count == NULL) {
8103                         return NT_STATUS_NO_MEMORY;
8104                         }
8105
8106                         r->out.info = talloc_zero(mem_ctx, union spoolss_PrintProcDataTypesInfo *);
8107                         if (r->out.info == NULL) {
8108                         return NT_STATUS_NO_MEMORY;
8109                         }
8110
8111                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
8112                         if (r->out.needed == NULL) {
8113                         return NT_STATUS_NO_MEMORY;
8114                         }
8115
8116                         r->out.result = _spoolss_EnumPrintProcDataTypes(cli->pipes_struct, r);
8117                         return NT_STATUS_OK;
8118                 }
8119
8120                 case NDR_SPOOLSS_RESETPRINTER: {
8121                         struct spoolss_ResetPrinter *r = (struct spoolss_ResetPrinter *)_r;
8122                         r->out.result = _spoolss_ResetPrinter(cli->pipes_struct, r);
8123                         return NT_STATUS_OK;
8124                 }
8125
8126                 case NDR_SPOOLSS_GETPRINTERDRIVER2: {
8127                         struct spoolss_GetPrinterDriver2 *r = (struct spoolss_GetPrinterDriver2 *)_r;
8128                         ZERO_STRUCT(r->out);
8129                         r->out.info = talloc_zero(mem_ctx, union spoolss_DriverInfo);
8130                         if (r->out.info == NULL) {
8131                         return NT_STATUS_NO_MEMORY;
8132                         }
8133
8134                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
8135                         if (r->out.needed == NULL) {
8136                         return NT_STATUS_NO_MEMORY;
8137                         }
8138
8139                         r->out.server_major_version = talloc_zero(mem_ctx, uint32_t);
8140                         if (r->out.server_major_version == NULL) {
8141                         return NT_STATUS_NO_MEMORY;
8142                         }
8143
8144                         r->out.server_minor_version = talloc_zero(mem_ctx, uint32_t);
8145                         if (r->out.server_minor_version == NULL) {
8146                         return NT_STATUS_NO_MEMORY;
8147                         }
8148
8149                         r->out.result = _spoolss_GetPrinterDriver2(cli->pipes_struct, r);
8150                         return NT_STATUS_OK;
8151                 }
8152
8153                 case NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION: {
8154                         struct spoolss_FindFirstPrinterChangeNotification *r = (struct spoolss_FindFirstPrinterChangeNotification *)_r;
8155                         r->out.result = _spoolss_FindFirstPrinterChangeNotification(cli->pipes_struct, r);
8156                         return NT_STATUS_OK;
8157                 }
8158
8159                 case NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION: {
8160                         struct spoolss_FindNextPrinterChangeNotification *r = (struct spoolss_FindNextPrinterChangeNotification *)_r;
8161                         r->out.result = _spoolss_FindNextPrinterChangeNotification(cli->pipes_struct, r);
8162                         return NT_STATUS_OK;
8163                 }
8164
8165                 case NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY: {
8166                         struct spoolss_FindClosePrinterNotify *r = (struct spoolss_FindClosePrinterNotify *)_r;
8167                         r->out.result = _spoolss_FindClosePrinterNotify(cli->pipes_struct, r);
8168                         return NT_STATUS_OK;
8169                 }
8170
8171                 case NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD: {
8172                         struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r = (struct spoolss_RouterFindFirstPrinterChangeNotificationOld *)_r;
8173                         r->out.result = _spoolss_RouterFindFirstPrinterChangeNotificationOld(cli->pipes_struct, r);
8174                         return NT_STATUS_OK;
8175                 }
8176
8177                 case NDR_SPOOLSS_REPLYOPENPRINTER: {
8178                         struct spoolss_ReplyOpenPrinter *r = (struct spoolss_ReplyOpenPrinter *)_r;
8179                         ZERO_STRUCT(r->out);
8180                         r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
8181                         if (r->out.handle == NULL) {
8182                         return NT_STATUS_NO_MEMORY;
8183                         }
8184
8185                         r->out.result = _spoolss_ReplyOpenPrinter(cli->pipes_struct, r);
8186                         return NT_STATUS_OK;
8187                 }
8188
8189                 case NDR_SPOOLSS_ROUTERREPLYPRINTER: {
8190                         struct spoolss_RouterReplyPrinter *r = (struct spoolss_RouterReplyPrinter *)_r;
8191                         r->out.result = _spoolss_RouterReplyPrinter(cli->pipes_struct, r);
8192                         return NT_STATUS_OK;
8193                 }
8194
8195                 case NDR_SPOOLSS_REPLYCLOSEPRINTER: {
8196                         struct spoolss_ReplyClosePrinter *r = (struct spoolss_ReplyClosePrinter *)_r;
8197                         ZERO_STRUCT(r->out);
8198                         r->out.handle = r->in.handle;
8199                         r->out.result = _spoolss_ReplyClosePrinter(cli->pipes_struct, r);
8200                         return NT_STATUS_OK;
8201                 }
8202
8203                 case NDR_SPOOLSS_ADDPORTEX: {
8204                         struct spoolss_AddPortEx *r = (struct spoolss_AddPortEx *)_r;
8205                         r->out.result = _spoolss_AddPortEx(cli->pipes_struct, r);
8206                         return NT_STATUS_OK;
8207                 }
8208
8209                 case NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION: {
8210                         struct spoolss_RouterFindFirstPrinterChangeNotification *r = (struct spoolss_RouterFindFirstPrinterChangeNotification *)_r;
8211                         r->out.result = _spoolss_RouterFindFirstPrinterChangeNotification(cli->pipes_struct, r);
8212                         return NT_STATUS_OK;
8213                 }
8214
8215                 case NDR_SPOOLSS_SPOOLERINIT: {
8216                         struct spoolss_SpoolerInit *r = (struct spoolss_SpoolerInit *)_r;
8217                         r->out.result = _spoolss_SpoolerInit(cli->pipes_struct, r);
8218                         return NT_STATUS_OK;
8219                 }
8220
8221                 case NDR_SPOOLSS_RESETPRINTEREX: {
8222                         struct spoolss_ResetPrinterEx *r = (struct spoolss_ResetPrinterEx *)_r;
8223                         r->out.result = _spoolss_ResetPrinterEx(cli->pipes_struct, r);
8224                         return NT_STATUS_OK;
8225                 }
8226
8227                 case NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX: {
8228                         struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r = (struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *)_r;
8229                         r->out.result = _spoolss_RemoteFindFirstPrinterChangeNotifyEx(cli->pipes_struct, r);
8230                         return NT_STATUS_OK;
8231                 }
8232
8233                 case NDR_SPOOLSS_ROUTERREPLYPRINTEREX: {
8234                         struct spoolss_RouterReplyPrinterEx *r = (struct spoolss_RouterReplyPrinterEx *)_r;
8235                         ZERO_STRUCT(r->out);
8236                         r->out.reply_result = talloc_zero(mem_ctx, uint32_t);
8237                         if (r->out.reply_result == NULL) {
8238                         return NT_STATUS_NO_MEMORY;
8239                         }
8240
8241                         r->out.result = _spoolss_RouterReplyPrinterEx(cli->pipes_struct, r);
8242                         return NT_STATUS_OK;
8243                 }
8244
8245                 case NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY: {
8246                         struct spoolss_RouterRefreshPrinterChangeNotify *r = (struct spoolss_RouterRefreshPrinterChangeNotify *)_r;
8247                         ZERO_STRUCT(r->out);
8248                         r->out.info = talloc_zero(mem_ctx, struct spoolss_NotifyInfo *);
8249                         if (r->out.info == NULL) {
8250                         return NT_STATUS_NO_MEMORY;
8251                         }
8252
8253                         r->out.result = _spoolss_RouterRefreshPrinterChangeNotify(cli->pipes_struct, r);
8254                         return NT_STATUS_OK;
8255                 }
8256
8257                 case NDR_SPOOLSS_44: {
8258                         struct spoolss_44 *r = (struct spoolss_44 *)_r;
8259                         r->out.result = _spoolss_44(cli->pipes_struct, r);
8260                         return NT_STATUS_OK;
8261                 }
8262
8263                 case NDR_SPOOLSS_OPENPRINTEREX: {
8264                         struct spoolss_OpenPrinterEx *r = (struct spoolss_OpenPrinterEx *)_r;
8265                         ZERO_STRUCT(r->out);
8266                         r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
8267                         if (r->out.handle == NULL) {
8268                         return NT_STATUS_NO_MEMORY;
8269                         }
8270
8271                         r->out.result = _spoolss_OpenPrinterEx(cli->pipes_struct, r);
8272                         return NT_STATUS_OK;
8273                 }
8274
8275                 case NDR_SPOOLSS_ADDPRINTEREX: {
8276                         struct spoolss_AddPrinterEx *r = (struct spoolss_AddPrinterEx *)_r;
8277                         ZERO_STRUCT(r->out);
8278                         r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
8279                         if (r->out.handle == NULL) {
8280                         return NT_STATUS_NO_MEMORY;
8281                         }
8282
8283                         r->out.result = _spoolss_AddPrinterEx(cli->pipes_struct, r);
8284                         return NT_STATUS_OK;
8285                 }
8286
8287                 case NDR_SPOOLSS_47: {
8288                         struct spoolss_47 *r = (struct spoolss_47 *)_r;
8289                         r->out.result = _spoolss_47(cli->pipes_struct, r);
8290                         return NT_STATUS_OK;
8291                 }
8292
8293                 case NDR_SPOOLSS_ENUMPRINTERDATA: {
8294                         struct spoolss_EnumPrinterData *r = (struct spoolss_EnumPrinterData *)_r;
8295                         ZERO_STRUCT(r->out);
8296                         r->out.value_name = talloc_zero_array(mem_ctx, const char, r->in.value_offered / 2);
8297                         if (r->out.value_name == NULL) {
8298                         return NT_STATUS_NO_MEMORY;
8299                         }
8300
8301                         r->out.value_needed = talloc_zero(mem_ctx, uint32_t);
8302                         if (r->out.value_needed == NULL) {
8303                         return NT_STATUS_NO_MEMORY;
8304                         }
8305
8306                         r->out.type = talloc_zero(mem_ctx, enum winreg_Type);
8307                         if (r->out.type == NULL) {
8308                         return NT_STATUS_NO_MEMORY;
8309                         }
8310
8311                         r->out.data = talloc_zero_array(mem_ctx, uint8_t, r->in.data_offered);
8312                         if (r->out.data == NULL) {
8313                         return NT_STATUS_NO_MEMORY;
8314                         }
8315
8316                         r->out.data_needed = talloc_zero(mem_ctx, uint32_t);
8317                         if (r->out.data_needed == NULL) {
8318                         return NT_STATUS_NO_MEMORY;
8319                         }
8320
8321                         r->out.result = _spoolss_EnumPrinterData(cli->pipes_struct, r);
8322                         return NT_STATUS_OK;
8323                 }
8324
8325                 case NDR_SPOOLSS_DELETEPRINTERDATA: {
8326                         struct spoolss_DeletePrinterData *r = (struct spoolss_DeletePrinterData *)_r;
8327                         r->out.result = _spoolss_DeletePrinterData(cli->pipes_struct, r);
8328                         return NT_STATUS_OK;
8329                 }
8330
8331                 case NDR_SPOOLSS_4A: {
8332                         struct spoolss_4a *r = (struct spoolss_4a *)_r;
8333                         r->out.result = _spoolss_4a(cli->pipes_struct, r);
8334                         return NT_STATUS_OK;
8335                 }
8336
8337                 case NDR_SPOOLSS_4B: {
8338                         struct spoolss_4b *r = (struct spoolss_4b *)_r;
8339                         r->out.result = _spoolss_4b(cli->pipes_struct, r);
8340                         return NT_STATUS_OK;
8341                 }
8342
8343                 case NDR_SPOOLSS_4C: {
8344                         struct spoolss_4c *r = (struct spoolss_4c *)_r;
8345                         r->out.result = _spoolss_4c(cli->pipes_struct, r);
8346                         return NT_STATUS_OK;
8347                 }
8348
8349                 case NDR_SPOOLSS_SETPRINTERDATAEX: {
8350                         struct spoolss_SetPrinterDataEx *r = (struct spoolss_SetPrinterDataEx *)_r;
8351                         r->out.result = _spoolss_SetPrinterDataEx(cli->pipes_struct, r);
8352                         return NT_STATUS_OK;
8353                 }
8354
8355                 case NDR_SPOOLSS_GETPRINTERDATAEX: {
8356                         struct spoolss_GetPrinterDataEx *r = (struct spoolss_GetPrinterDataEx *)_r;
8357                         ZERO_STRUCT(r->out);
8358                         r->out.type = talloc_zero(mem_ctx, enum winreg_Type);
8359                         if (r->out.type == NULL) {
8360                         return NT_STATUS_NO_MEMORY;
8361                         }
8362
8363                         r->out.buffer = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
8364                         if (r->out.buffer == NULL) {
8365                         return NT_STATUS_NO_MEMORY;
8366                         }
8367
8368                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
8369                         if (r->out.needed == NULL) {
8370                         return NT_STATUS_NO_MEMORY;
8371                         }
8372
8373                         r->out.result = _spoolss_GetPrinterDataEx(cli->pipes_struct, r);
8374                         return NT_STATUS_OK;
8375                 }
8376
8377                 case NDR_SPOOLSS_ENUMPRINTERDATAEX: {
8378                         struct spoolss_EnumPrinterDataEx *r = (struct spoolss_EnumPrinterDataEx *)_r;
8379                         ZERO_STRUCT(r->out);
8380                         r->out.buffer = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
8381                         if (r->out.buffer == NULL) {
8382                         return NT_STATUS_NO_MEMORY;
8383                         }
8384
8385                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
8386                         if (r->out.needed == NULL) {
8387                         return NT_STATUS_NO_MEMORY;
8388                         }
8389
8390                         r->out.count = talloc_zero(mem_ctx, uint32_t);
8391                         if (r->out.count == NULL) {
8392                         return NT_STATUS_NO_MEMORY;
8393                         }
8394
8395                         r->out.result = _spoolss_EnumPrinterDataEx(cli->pipes_struct, r);
8396                         return NT_STATUS_OK;
8397                 }
8398
8399                 case NDR_SPOOLSS_ENUMPRINTERKEY: {
8400                         struct spoolss_EnumPrinterKey *r = (struct spoolss_EnumPrinterKey *)_r;
8401                         ZERO_STRUCT(r->out);
8402                         r->out.key_buffer = talloc_zero_array(mem_ctx, uint16_t, r->in.key_buffer_size / 2);
8403                         if (r->out.key_buffer == NULL) {
8404                         return NT_STATUS_NO_MEMORY;
8405                         }
8406
8407                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
8408                         if (r->out.needed == NULL) {
8409                         return NT_STATUS_NO_MEMORY;
8410                         }
8411
8412                         r->out.result = _spoolss_EnumPrinterKey(cli->pipes_struct, r);
8413                         return NT_STATUS_OK;
8414                 }
8415
8416                 case NDR_SPOOLSS_DELETEPRINTERDATAEX: {
8417                         struct spoolss_DeletePrinterDataEx *r = (struct spoolss_DeletePrinterDataEx *)_r;
8418                         r->out.result = _spoolss_DeletePrinterDataEx(cli->pipes_struct, r);
8419                         return NT_STATUS_OK;
8420                 }
8421
8422                 case NDR_SPOOLSS_DELETEPRINTERKEY: {
8423                         struct spoolss_DeletePrinterKey *r = (struct spoolss_DeletePrinterKey *)_r;
8424                         r->out.result = _spoolss_DeletePrinterKey(cli->pipes_struct, r);
8425                         return NT_STATUS_OK;
8426                 }
8427
8428                 case NDR_SPOOLSS_53: {
8429                         struct spoolss_53 *r = (struct spoolss_53 *)_r;
8430                         r->out.result = _spoolss_53(cli->pipes_struct, r);
8431                         return NT_STATUS_OK;
8432                 }
8433
8434                 case NDR_SPOOLSS_DELETEPRINTERDRIVEREX: {
8435                         struct spoolss_DeletePrinterDriverEx *r = (struct spoolss_DeletePrinterDriverEx *)_r;
8436                         r->out.result = _spoolss_DeletePrinterDriverEx(cli->pipes_struct, r);
8437                         return NT_STATUS_OK;
8438                 }
8439
8440                 case NDR_SPOOLSS_55: {
8441                         struct spoolss_55 *r = (struct spoolss_55 *)_r;
8442                         r->out.result = _spoolss_55(cli->pipes_struct, r);
8443                         return NT_STATUS_OK;
8444                 }
8445
8446                 case NDR_SPOOLSS_56: {
8447                         struct spoolss_56 *r = (struct spoolss_56 *)_r;
8448                         r->out.result = _spoolss_56(cli->pipes_struct, r);
8449                         return NT_STATUS_OK;
8450                 }
8451
8452                 case NDR_SPOOLSS_57: {
8453                         struct spoolss_57 *r = (struct spoolss_57 *)_r;
8454                         r->out.result = _spoolss_57(cli->pipes_struct, r);
8455                         return NT_STATUS_OK;
8456                 }
8457
8458                 case NDR_SPOOLSS_XCVDATA: {
8459                         struct spoolss_XcvData *r = (struct spoolss_XcvData *)_r;
8460                         ZERO_STRUCT(r->out);
8461                         r->out.status_code = r->in.status_code;
8462                         r->out.out_data = talloc_zero_array(mem_ctx, uint8_t, r->in.out_data_size);
8463                         if (r->out.out_data == NULL) {
8464                         return NT_STATUS_NO_MEMORY;
8465                         }
8466
8467                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
8468                         if (r->out.needed == NULL) {
8469                         return NT_STATUS_NO_MEMORY;
8470                         }
8471
8472                         r->out.result = _spoolss_XcvData(cli->pipes_struct, r);
8473                         return NT_STATUS_OK;
8474                 }
8475
8476                 case NDR_SPOOLSS_ADDPRINTERDRIVEREX: {
8477                         struct spoolss_AddPrinterDriverEx *r = (struct spoolss_AddPrinterDriverEx *)_r;
8478                         r->out.result = _spoolss_AddPrinterDriverEx(cli->pipes_struct, r);
8479                         return NT_STATUS_OK;
8480                 }
8481
8482                 case NDR_SPOOLSS_5A: {
8483                         struct spoolss_5a *r = (struct spoolss_5a *)_r;
8484                         r->out.result = _spoolss_5a(cli->pipes_struct, r);
8485                         return NT_STATUS_OK;
8486                 }
8487
8488                 case NDR_SPOOLSS_5B: {
8489                         struct spoolss_5b *r = (struct spoolss_5b *)_r;
8490                         r->out.result = _spoolss_5b(cli->pipes_struct, r);
8491                         return NT_STATUS_OK;
8492                 }
8493
8494                 case NDR_SPOOLSS_5C: {
8495                         struct spoolss_5c *r = (struct spoolss_5c *)_r;
8496                         r->out.result = _spoolss_5c(cli->pipes_struct, r);
8497                         return NT_STATUS_OK;
8498                 }
8499
8500                 case NDR_SPOOLSS_5D: {
8501                         struct spoolss_5d *r = (struct spoolss_5d *)_r;
8502                         r->out.result = _spoolss_5d(cli->pipes_struct, r);
8503                         return NT_STATUS_OK;
8504                 }
8505
8506                 case NDR_SPOOLSS_5E: {
8507                         struct spoolss_5e *r = (struct spoolss_5e *)_r;
8508                         r->out.result = _spoolss_5e(cli->pipes_struct, r);
8509                         return NT_STATUS_OK;
8510                 }
8511
8512                 case NDR_SPOOLSS_5F: {
8513                         struct spoolss_5f *r = (struct spoolss_5f *)_r;
8514                         r->out.result = _spoolss_5f(cli->pipes_struct, r);
8515                         return NT_STATUS_OK;
8516                 }
8517
8518                 default:
8519                         return NT_STATUS_NOT_IMPLEMENTED;
8520         }
8521 }
8522
8523 NTSTATUS rpc_spoolss_init(void)
8524 {
8525         return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "spoolss", "spoolss", &ndr_table_spoolss, api_spoolss_cmds, sizeof(api_spoolss_cmds) / sizeof(struct api_struct));
8526 }