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 spoolss_PrinterDataType);
2117         if (r->out.type == NULL) {
2118                 talloc_free(r);
2119                 return false;
2120         }
2121
2122         r->out.needed = talloc_zero(r, uint32_t);
2123         if (r->out.needed == NULL) {
2124                 talloc_free(r);
2125                 return false;
2126         }
2127
2128         r->out.result = _spoolss_GetPrinterData(p, r);
2129
2130         if (p->rng_fault_state) {
2131                 talloc_free(r);
2132                 /* Return true here, srv_pipe_hnd.c will take care */
2133                 return true;
2134         }
2135
2136         if (DEBUGLEVEL >= 10) {
2137                 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterData, r);
2138         }
2139
2140         push = ndr_push_init_ctx(r, NULL);
2141         if (push == NULL) {
2142                 talloc_free(r);
2143                 return false;
2144         }
2145
2146         ndr_err = call->ndr_push(push, NDR_OUT, r);
2147         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2148                 talloc_free(r);
2149                 return false;
2150         }
2151
2152         blob = ndr_push_blob(push);
2153         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2154                 talloc_free(r);
2155                 return false;
2156         }
2157
2158         talloc_free(r);
2159
2160         return true;
2161 }
2162
2163 static bool api_spoolss_SetPrinterData(pipes_struct *p)
2164 {
2165         const struct ndr_interface_call *call;
2166         struct ndr_pull *pull;
2167         struct ndr_push *push;
2168         enum ndr_err_code ndr_err;
2169         DATA_BLOB blob;
2170         struct spoolss_SetPrinterData *r;
2171
2172         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_SETPRINTERDATA];
2173
2174         r = talloc(talloc_tos(), struct spoolss_SetPrinterData);
2175         if (r == NULL) {
2176                 return false;
2177         }
2178
2179         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2180                 talloc_free(r);
2181                 return false;
2182         }
2183
2184         pull = ndr_pull_init_blob(&blob, r, NULL);
2185         if (pull == NULL) {
2186                 talloc_free(r);
2187                 return false;
2188         }
2189
2190         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2191         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2192         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2193                 talloc_free(r);
2194                 return false;
2195         }
2196
2197         if (DEBUGLEVEL >= 10) {
2198                 NDR_PRINT_IN_DEBUG(spoolss_SetPrinterData, r);
2199         }
2200
2201         r->out.result = _spoolss_SetPrinterData(p, r);
2202
2203         if (p->rng_fault_state) {
2204                 talloc_free(r);
2205                 /* Return true here, srv_pipe_hnd.c will take care */
2206                 return true;
2207         }
2208
2209         if (DEBUGLEVEL >= 10) {
2210                 NDR_PRINT_OUT_DEBUG(spoolss_SetPrinterData, r);
2211         }
2212
2213         push = ndr_push_init_ctx(r, NULL);
2214         if (push == NULL) {
2215                 talloc_free(r);
2216                 return false;
2217         }
2218
2219         ndr_err = call->ndr_push(push, NDR_OUT, r);
2220         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2221                 talloc_free(r);
2222                 return false;
2223         }
2224
2225         blob = ndr_push_blob(push);
2226         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2227                 talloc_free(r);
2228                 return false;
2229         }
2230
2231         talloc_free(r);
2232
2233         return true;
2234 }
2235
2236 static bool api_spoolss_WaitForPrinterChange(pipes_struct *p)
2237 {
2238         const struct ndr_interface_call *call;
2239         struct ndr_pull *pull;
2240         struct ndr_push *push;
2241         enum ndr_err_code ndr_err;
2242         DATA_BLOB blob;
2243         struct spoolss_WaitForPrinterChange *r;
2244
2245         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_WAITFORPRINTERCHANGE];
2246
2247         r = talloc(talloc_tos(), struct spoolss_WaitForPrinterChange);
2248         if (r == NULL) {
2249                 return false;
2250         }
2251
2252         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2253                 talloc_free(r);
2254                 return false;
2255         }
2256
2257         pull = ndr_pull_init_blob(&blob, r, NULL);
2258         if (pull == NULL) {
2259                 talloc_free(r);
2260                 return false;
2261         }
2262
2263         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2264         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2265         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2266                 talloc_free(r);
2267                 return false;
2268         }
2269
2270         if (DEBUGLEVEL >= 10) {
2271                 NDR_PRINT_IN_DEBUG(spoolss_WaitForPrinterChange, r);
2272         }
2273
2274         r->out.result = _spoolss_WaitForPrinterChange(p, r);
2275
2276         if (p->rng_fault_state) {
2277                 talloc_free(r);
2278                 /* Return true here, srv_pipe_hnd.c will take care */
2279                 return true;
2280         }
2281
2282         if (DEBUGLEVEL >= 10) {
2283                 NDR_PRINT_OUT_DEBUG(spoolss_WaitForPrinterChange, r);
2284         }
2285
2286         push = ndr_push_init_ctx(r, NULL);
2287         if (push == NULL) {
2288                 talloc_free(r);
2289                 return false;
2290         }
2291
2292         ndr_err = call->ndr_push(push, NDR_OUT, r);
2293         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2294                 talloc_free(r);
2295                 return false;
2296         }
2297
2298         blob = ndr_push_blob(push);
2299         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2300                 talloc_free(r);
2301                 return false;
2302         }
2303
2304         talloc_free(r);
2305
2306         return true;
2307 }
2308
2309 static bool api_spoolss_ClosePrinter(pipes_struct *p)
2310 {
2311         const struct ndr_interface_call *call;
2312         struct ndr_pull *pull;
2313         struct ndr_push *push;
2314         enum ndr_err_code ndr_err;
2315         DATA_BLOB blob;
2316         struct spoolss_ClosePrinter *r;
2317
2318         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_CLOSEPRINTER];
2319
2320         r = talloc(talloc_tos(), struct spoolss_ClosePrinter);
2321         if (r == NULL) {
2322                 return false;
2323         }
2324
2325         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2326                 talloc_free(r);
2327                 return false;
2328         }
2329
2330         pull = ndr_pull_init_blob(&blob, r, NULL);
2331         if (pull == NULL) {
2332                 talloc_free(r);
2333                 return false;
2334         }
2335
2336         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2337         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2338         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2339                 talloc_free(r);
2340                 return false;
2341         }
2342
2343         if (DEBUGLEVEL >= 10) {
2344                 NDR_PRINT_IN_DEBUG(spoolss_ClosePrinter, r);
2345         }
2346
2347         ZERO_STRUCT(r->out);
2348         r->out.handle = r->in.handle;
2349         r->out.result = _spoolss_ClosePrinter(p, r);
2350
2351         if (p->rng_fault_state) {
2352                 talloc_free(r);
2353                 /* Return true here, srv_pipe_hnd.c will take care */
2354                 return true;
2355         }
2356
2357         if (DEBUGLEVEL >= 10) {
2358                 NDR_PRINT_OUT_DEBUG(spoolss_ClosePrinter, r);
2359         }
2360
2361         push = ndr_push_init_ctx(r, NULL);
2362         if (push == NULL) {
2363                 talloc_free(r);
2364                 return false;
2365         }
2366
2367         ndr_err = call->ndr_push(push, NDR_OUT, r);
2368         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2369                 talloc_free(r);
2370                 return false;
2371         }
2372
2373         blob = ndr_push_blob(push);
2374         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2375                 talloc_free(r);
2376                 return false;
2377         }
2378
2379         talloc_free(r);
2380
2381         return true;
2382 }
2383
2384 static bool api_spoolss_AddForm(pipes_struct *p)
2385 {
2386         const struct ndr_interface_call *call;
2387         struct ndr_pull *pull;
2388         struct ndr_push *push;
2389         enum ndr_err_code ndr_err;
2390         DATA_BLOB blob;
2391         struct spoolss_AddForm *r;
2392
2393         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDFORM];
2394
2395         r = talloc(talloc_tos(), struct spoolss_AddForm);
2396         if (r == NULL) {
2397                 return false;
2398         }
2399
2400         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2401                 talloc_free(r);
2402                 return false;
2403         }
2404
2405         pull = ndr_pull_init_blob(&blob, r, NULL);
2406         if (pull == NULL) {
2407                 talloc_free(r);
2408                 return false;
2409         }
2410
2411         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2412         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2413         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2414                 talloc_free(r);
2415                 return false;
2416         }
2417
2418         if (DEBUGLEVEL >= 10) {
2419                 NDR_PRINT_IN_DEBUG(spoolss_AddForm, r);
2420         }
2421
2422         r->out.result = _spoolss_AddForm(p, r);
2423
2424         if (p->rng_fault_state) {
2425                 talloc_free(r);
2426                 /* Return true here, srv_pipe_hnd.c will take care */
2427                 return true;
2428         }
2429
2430         if (DEBUGLEVEL >= 10) {
2431                 NDR_PRINT_OUT_DEBUG(spoolss_AddForm, r);
2432         }
2433
2434         push = ndr_push_init_ctx(r, NULL);
2435         if (push == NULL) {
2436                 talloc_free(r);
2437                 return false;
2438         }
2439
2440         ndr_err = call->ndr_push(push, NDR_OUT, r);
2441         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2442                 talloc_free(r);
2443                 return false;
2444         }
2445
2446         blob = ndr_push_blob(push);
2447         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2448                 talloc_free(r);
2449                 return false;
2450         }
2451
2452         talloc_free(r);
2453
2454         return true;
2455 }
2456
2457 static bool api_spoolss_DeleteForm(pipes_struct *p)
2458 {
2459         const struct ndr_interface_call *call;
2460         struct ndr_pull *pull;
2461         struct ndr_push *push;
2462         enum ndr_err_code ndr_err;
2463         DATA_BLOB blob;
2464         struct spoolss_DeleteForm *r;
2465
2466         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEFORM];
2467
2468         r = talloc(talloc_tos(), struct spoolss_DeleteForm);
2469         if (r == NULL) {
2470                 return false;
2471         }
2472
2473         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2474                 talloc_free(r);
2475                 return false;
2476         }
2477
2478         pull = ndr_pull_init_blob(&blob, r, NULL);
2479         if (pull == NULL) {
2480                 talloc_free(r);
2481                 return false;
2482         }
2483
2484         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2485         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2486         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2487                 talloc_free(r);
2488                 return false;
2489         }
2490
2491         if (DEBUGLEVEL >= 10) {
2492                 NDR_PRINT_IN_DEBUG(spoolss_DeleteForm, r);
2493         }
2494
2495         r->out.result = _spoolss_DeleteForm(p, r);
2496
2497         if (p->rng_fault_state) {
2498                 talloc_free(r);
2499                 /* Return true here, srv_pipe_hnd.c will take care */
2500                 return true;
2501         }
2502
2503         if (DEBUGLEVEL >= 10) {
2504                 NDR_PRINT_OUT_DEBUG(spoolss_DeleteForm, r);
2505         }
2506
2507         push = ndr_push_init_ctx(r, NULL);
2508         if (push == NULL) {
2509                 talloc_free(r);
2510                 return false;
2511         }
2512
2513         ndr_err = call->ndr_push(push, NDR_OUT, r);
2514         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2515                 talloc_free(r);
2516                 return false;
2517         }
2518
2519         blob = ndr_push_blob(push);
2520         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2521                 talloc_free(r);
2522                 return false;
2523         }
2524
2525         talloc_free(r);
2526
2527         return true;
2528 }
2529
2530 static bool api_spoolss_GetForm(pipes_struct *p)
2531 {
2532         const struct ndr_interface_call *call;
2533         struct ndr_pull *pull;
2534         struct ndr_push *push;
2535         enum ndr_err_code ndr_err;
2536         DATA_BLOB blob;
2537         struct spoolss_GetForm *r;
2538
2539         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETFORM];
2540
2541         r = talloc(talloc_tos(), struct spoolss_GetForm);
2542         if (r == NULL) {
2543                 return false;
2544         }
2545
2546         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2547                 talloc_free(r);
2548                 return false;
2549         }
2550
2551         pull = ndr_pull_init_blob(&blob, r, NULL);
2552         if (pull == NULL) {
2553                 talloc_free(r);
2554                 return false;
2555         }
2556
2557         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2558         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2559         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2560                 talloc_free(r);
2561                 return false;
2562         }
2563
2564         if (DEBUGLEVEL >= 10) {
2565                 NDR_PRINT_IN_DEBUG(spoolss_GetForm, r);
2566         }
2567
2568         ZERO_STRUCT(r->out);
2569         r->out.info = talloc_zero(r, union spoolss_FormInfo);
2570         if (r->out.info == NULL) {
2571                 talloc_free(r);
2572                 return false;
2573         }
2574
2575         r->out.needed = talloc_zero(r, uint32_t);
2576         if (r->out.needed == NULL) {
2577                 talloc_free(r);
2578                 return false;
2579         }
2580
2581         r->out.result = _spoolss_GetForm(p, r);
2582
2583         if (p->rng_fault_state) {
2584                 talloc_free(r);
2585                 /* Return true here, srv_pipe_hnd.c will take care */
2586                 return true;
2587         }
2588
2589         if (DEBUGLEVEL >= 10) {
2590                 NDR_PRINT_OUT_DEBUG(spoolss_GetForm, r);
2591         }
2592
2593         push = ndr_push_init_ctx(r, NULL);
2594         if (push == NULL) {
2595                 talloc_free(r);
2596                 return false;
2597         }
2598
2599         ndr_err = call->ndr_push(push, NDR_OUT, r);
2600         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2601                 talloc_free(r);
2602                 return false;
2603         }
2604
2605         blob = ndr_push_blob(push);
2606         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2607                 talloc_free(r);
2608                 return false;
2609         }
2610
2611         talloc_free(r);
2612
2613         return true;
2614 }
2615
2616 static bool api_spoolss_SetForm(pipes_struct *p)
2617 {
2618         const struct ndr_interface_call *call;
2619         struct ndr_pull *pull;
2620         struct ndr_push *push;
2621         enum ndr_err_code ndr_err;
2622         DATA_BLOB blob;
2623         struct spoolss_SetForm *r;
2624
2625         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_SETFORM];
2626
2627         r = talloc(talloc_tos(), struct spoolss_SetForm);
2628         if (r == NULL) {
2629                 return false;
2630         }
2631
2632         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2633                 talloc_free(r);
2634                 return false;
2635         }
2636
2637         pull = ndr_pull_init_blob(&blob, r, NULL);
2638         if (pull == NULL) {
2639                 talloc_free(r);
2640                 return false;
2641         }
2642
2643         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2644         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2645         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2646                 talloc_free(r);
2647                 return false;
2648         }
2649
2650         if (DEBUGLEVEL >= 10) {
2651                 NDR_PRINT_IN_DEBUG(spoolss_SetForm, r);
2652         }
2653
2654         r->out.result = _spoolss_SetForm(p, r);
2655
2656         if (p->rng_fault_state) {
2657                 talloc_free(r);
2658                 /* Return true here, srv_pipe_hnd.c will take care */
2659                 return true;
2660         }
2661
2662         if (DEBUGLEVEL >= 10) {
2663                 NDR_PRINT_OUT_DEBUG(spoolss_SetForm, r);
2664         }
2665
2666         push = ndr_push_init_ctx(r, NULL);
2667         if (push == NULL) {
2668                 talloc_free(r);
2669                 return false;
2670         }
2671
2672         ndr_err = call->ndr_push(push, NDR_OUT, r);
2673         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2674                 talloc_free(r);
2675                 return false;
2676         }
2677
2678         blob = ndr_push_blob(push);
2679         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2680                 talloc_free(r);
2681                 return false;
2682         }
2683
2684         talloc_free(r);
2685
2686         return true;
2687 }
2688
2689 static bool api_spoolss_EnumForms(pipes_struct *p)
2690 {
2691         const struct ndr_interface_call *call;
2692         struct ndr_pull *pull;
2693         struct ndr_push *push;
2694         enum ndr_err_code ndr_err;
2695         DATA_BLOB blob;
2696         struct spoolss_EnumForms *r;
2697
2698         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMFORMS];
2699
2700         r = talloc(talloc_tos(), struct spoolss_EnumForms);
2701         if (r == NULL) {
2702                 return false;
2703         }
2704
2705         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2706                 talloc_free(r);
2707                 return false;
2708         }
2709
2710         pull = ndr_pull_init_blob(&blob, r, NULL);
2711         if (pull == NULL) {
2712                 talloc_free(r);
2713                 return false;
2714         }
2715
2716         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2717         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2718         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2719                 talloc_free(r);
2720                 return false;
2721         }
2722
2723         if (DEBUGLEVEL >= 10) {
2724                 NDR_PRINT_IN_DEBUG(spoolss_EnumForms, r);
2725         }
2726
2727         ZERO_STRUCT(r->out);
2728         r->out.count = talloc_zero(r, uint32_t);
2729         if (r->out.count == NULL) {
2730                 talloc_free(r);
2731                 return false;
2732         }
2733
2734         r->out.info = talloc_zero(r, union spoolss_FormInfo *);
2735         if (r->out.info == NULL) {
2736                 talloc_free(r);
2737                 return false;
2738         }
2739
2740         r->out.needed = talloc_zero(r, uint32_t);
2741         if (r->out.needed == NULL) {
2742                 talloc_free(r);
2743                 return false;
2744         }
2745
2746         r->out.result = _spoolss_EnumForms(p, r);
2747
2748         if (p->rng_fault_state) {
2749                 talloc_free(r);
2750                 /* Return true here, srv_pipe_hnd.c will take care */
2751                 return true;
2752         }
2753
2754         if (DEBUGLEVEL >= 10) {
2755                 NDR_PRINT_OUT_DEBUG(spoolss_EnumForms, r);
2756         }
2757
2758         push = ndr_push_init_ctx(r, NULL);
2759         if (push == NULL) {
2760                 talloc_free(r);
2761                 return false;
2762         }
2763
2764         ndr_err = call->ndr_push(push, NDR_OUT, r);
2765         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2766                 talloc_free(r);
2767                 return false;
2768         }
2769
2770         blob = ndr_push_blob(push);
2771         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2772                 talloc_free(r);
2773                 return false;
2774         }
2775
2776         talloc_free(r);
2777
2778         return true;
2779 }
2780
2781 static bool api_spoolss_EnumPorts(pipes_struct *p)
2782 {
2783         const struct ndr_interface_call *call;
2784         struct ndr_pull *pull;
2785         struct ndr_push *push;
2786         enum ndr_err_code ndr_err;
2787         DATA_BLOB blob;
2788         struct spoolss_EnumPorts *r;
2789
2790         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPORTS];
2791
2792         r = talloc(talloc_tos(), struct spoolss_EnumPorts);
2793         if (r == NULL) {
2794                 return false;
2795         }
2796
2797         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2798                 talloc_free(r);
2799                 return false;
2800         }
2801
2802         pull = ndr_pull_init_blob(&blob, r, NULL);
2803         if (pull == NULL) {
2804                 talloc_free(r);
2805                 return false;
2806         }
2807
2808         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2809         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2810         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2811                 talloc_free(r);
2812                 return false;
2813         }
2814
2815         if (DEBUGLEVEL >= 10) {
2816                 NDR_PRINT_IN_DEBUG(spoolss_EnumPorts, r);
2817         }
2818
2819         ZERO_STRUCT(r->out);
2820         r->out.count = talloc_zero(r, uint32_t);
2821         if (r->out.count == NULL) {
2822                 talloc_free(r);
2823                 return false;
2824         }
2825
2826         r->out.info = talloc_zero(r, union spoolss_PortInfo *);
2827         if (r->out.info == NULL) {
2828                 talloc_free(r);
2829                 return false;
2830         }
2831
2832         r->out.needed = talloc_zero(r, uint32_t);
2833         if (r->out.needed == NULL) {
2834                 talloc_free(r);
2835                 return false;
2836         }
2837
2838         r->out.result = _spoolss_EnumPorts(p, r);
2839
2840         if (p->rng_fault_state) {
2841                 talloc_free(r);
2842                 /* Return true here, srv_pipe_hnd.c will take care */
2843                 return true;
2844         }
2845
2846         if (DEBUGLEVEL >= 10) {
2847                 NDR_PRINT_OUT_DEBUG(spoolss_EnumPorts, r);
2848         }
2849
2850         push = ndr_push_init_ctx(r, NULL);
2851         if (push == NULL) {
2852                 talloc_free(r);
2853                 return false;
2854         }
2855
2856         ndr_err = call->ndr_push(push, NDR_OUT, r);
2857         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2858                 talloc_free(r);
2859                 return false;
2860         }
2861
2862         blob = ndr_push_blob(push);
2863         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2864                 talloc_free(r);
2865                 return false;
2866         }
2867
2868         talloc_free(r);
2869
2870         return true;
2871 }
2872
2873 static bool api_spoolss_EnumMonitors(pipes_struct *p)
2874 {
2875         const struct ndr_interface_call *call;
2876         struct ndr_pull *pull;
2877         struct ndr_push *push;
2878         enum ndr_err_code ndr_err;
2879         DATA_BLOB blob;
2880         struct spoolss_EnumMonitors *r;
2881
2882         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMMONITORS];
2883
2884         r = talloc(talloc_tos(), struct spoolss_EnumMonitors);
2885         if (r == NULL) {
2886                 return false;
2887         }
2888
2889         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2890                 talloc_free(r);
2891                 return false;
2892         }
2893
2894         pull = ndr_pull_init_blob(&blob, r, NULL);
2895         if (pull == NULL) {
2896                 talloc_free(r);
2897                 return false;
2898         }
2899
2900         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2901         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2902         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2903                 talloc_free(r);
2904                 return false;
2905         }
2906
2907         if (DEBUGLEVEL >= 10) {
2908                 NDR_PRINT_IN_DEBUG(spoolss_EnumMonitors, r);
2909         }
2910
2911         ZERO_STRUCT(r->out);
2912         r->out.count = talloc_zero(r, uint32_t);
2913         if (r->out.count == NULL) {
2914                 talloc_free(r);
2915                 return false;
2916         }
2917
2918         r->out.info = talloc_zero(r, union spoolss_MonitorInfo *);
2919         if (r->out.info == NULL) {
2920                 talloc_free(r);
2921                 return false;
2922         }
2923
2924         r->out.needed = talloc_zero(r, uint32_t);
2925         if (r->out.needed == NULL) {
2926                 talloc_free(r);
2927                 return false;
2928         }
2929
2930         r->out.result = _spoolss_EnumMonitors(p, r);
2931
2932         if (p->rng_fault_state) {
2933                 talloc_free(r);
2934                 /* Return true here, srv_pipe_hnd.c will take care */
2935                 return true;
2936         }
2937
2938         if (DEBUGLEVEL >= 10) {
2939                 NDR_PRINT_OUT_DEBUG(spoolss_EnumMonitors, r);
2940         }
2941
2942         push = ndr_push_init_ctx(r, NULL);
2943         if (push == NULL) {
2944                 talloc_free(r);
2945                 return false;
2946         }
2947
2948         ndr_err = call->ndr_push(push, NDR_OUT, r);
2949         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2950                 talloc_free(r);
2951                 return false;
2952         }
2953
2954         blob = ndr_push_blob(push);
2955         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2956                 talloc_free(r);
2957                 return false;
2958         }
2959
2960         talloc_free(r);
2961
2962         return true;
2963 }
2964
2965 static bool api_spoolss_AddPort(pipes_struct *p)
2966 {
2967         const struct ndr_interface_call *call;
2968         struct ndr_pull *pull;
2969         struct ndr_push *push;
2970         enum ndr_err_code ndr_err;
2971         DATA_BLOB blob;
2972         struct spoolss_AddPort *r;
2973
2974         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPORT];
2975
2976         r = talloc(talloc_tos(), struct spoolss_AddPort);
2977         if (r == NULL) {
2978                 return false;
2979         }
2980
2981         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2982                 talloc_free(r);
2983                 return false;
2984         }
2985
2986         pull = ndr_pull_init_blob(&blob, r, NULL);
2987         if (pull == NULL) {
2988                 talloc_free(r);
2989                 return false;
2990         }
2991
2992         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2993         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2994         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2995                 talloc_free(r);
2996                 return false;
2997         }
2998
2999         if (DEBUGLEVEL >= 10) {
3000                 NDR_PRINT_IN_DEBUG(spoolss_AddPort, r);
3001         }
3002
3003         r->out.result = _spoolss_AddPort(p, r);
3004
3005         if (p->rng_fault_state) {
3006                 talloc_free(r);
3007                 /* Return true here, srv_pipe_hnd.c will take care */
3008                 return true;
3009         }
3010
3011         if (DEBUGLEVEL >= 10) {
3012                 NDR_PRINT_OUT_DEBUG(spoolss_AddPort, r);
3013         }
3014
3015         push = ndr_push_init_ctx(r, NULL);
3016         if (push == NULL) {
3017                 talloc_free(r);
3018                 return false;
3019         }
3020
3021         ndr_err = call->ndr_push(push, NDR_OUT, r);
3022         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3023                 talloc_free(r);
3024                 return false;
3025         }
3026
3027         blob = ndr_push_blob(push);
3028         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3029                 talloc_free(r);
3030                 return false;
3031         }
3032
3033         talloc_free(r);
3034
3035         return true;
3036 }
3037
3038 static bool api_spoolss_ConfigurePort(pipes_struct *p)
3039 {
3040         const struct ndr_interface_call *call;
3041         struct ndr_pull *pull;
3042         struct ndr_push *push;
3043         enum ndr_err_code ndr_err;
3044         DATA_BLOB blob;
3045         struct spoolss_ConfigurePort *r;
3046
3047         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_CONFIGUREPORT];
3048
3049         r = talloc(talloc_tos(), struct spoolss_ConfigurePort);
3050         if (r == NULL) {
3051                 return false;
3052         }
3053
3054         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3055                 talloc_free(r);
3056                 return false;
3057         }
3058
3059         pull = ndr_pull_init_blob(&blob, r, NULL);
3060         if (pull == NULL) {
3061                 talloc_free(r);
3062                 return false;
3063         }
3064
3065         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3066         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3067         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3068                 talloc_free(r);
3069                 return false;
3070         }
3071
3072         if (DEBUGLEVEL >= 10) {
3073                 NDR_PRINT_IN_DEBUG(spoolss_ConfigurePort, r);
3074         }
3075
3076         r->out.result = _spoolss_ConfigurePort(p, r);
3077
3078         if (p->rng_fault_state) {
3079                 talloc_free(r);
3080                 /* Return true here, srv_pipe_hnd.c will take care */
3081                 return true;
3082         }
3083
3084         if (DEBUGLEVEL >= 10) {
3085                 NDR_PRINT_OUT_DEBUG(spoolss_ConfigurePort, r);
3086         }
3087
3088         push = ndr_push_init_ctx(r, NULL);
3089         if (push == NULL) {
3090                 talloc_free(r);
3091                 return false;
3092         }
3093
3094         ndr_err = call->ndr_push(push, NDR_OUT, r);
3095         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3096                 talloc_free(r);
3097                 return false;
3098         }
3099
3100         blob = ndr_push_blob(push);
3101         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3102                 talloc_free(r);
3103                 return false;
3104         }
3105
3106         talloc_free(r);
3107
3108         return true;
3109 }
3110
3111 static bool api_spoolss_DeletePort(pipes_struct *p)
3112 {
3113         const struct ndr_interface_call *call;
3114         struct ndr_pull *pull;
3115         struct ndr_push *push;
3116         enum ndr_err_code ndr_err;
3117         DATA_BLOB blob;
3118         struct spoolss_DeletePort *r;
3119
3120         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPORT];
3121
3122         r = talloc(talloc_tos(), struct spoolss_DeletePort);
3123         if (r == NULL) {
3124                 return false;
3125         }
3126
3127         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3128                 talloc_free(r);
3129                 return false;
3130         }
3131
3132         pull = ndr_pull_init_blob(&blob, r, NULL);
3133         if (pull == NULL) {
3134                 talloc_free(r);
3135                 return false;
3136         }
3137
3138         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3139         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3140         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3141                 talloc_free(r);
3142                 return false;
3143         }
3144
3145         if (DEBUGLEVEL >= 10) {
3146                 NDR_PRINT_IN_DEBUG(spoolss_DeletePort, r);
3147         }
3148
3149         r->out.result = _spoolss_DeletePort(p, r);
3150
3151         if (p->rng_fault_state) {
3152                 talloc_free(r);
3153                 /* Return true here, srv_pipe_hnd.c will take care */
3154                 return true;
3155         }
3156
3157         if (DEBUGLEVEL >= 10) {
3158                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePort, r);
3159         }
3160
3161         push = ndr_push_init_ctx(r, NULL);
3162         if (push == NULL) {
3163                 talloc_free(r);
3164                 return false;
3165         }
3166
3167         ndr_err = call->ndr_push(push, NDR_OUT, r);
3168         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3169                 talloc_free(r);
3170                 return false;
3171         }
3172
3173         blob = ndr_push_blob(push);
3174         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3175                 talloc_free(r);
3176                 return false;
3177         }
3178
3179         talloc_free(r);
3180
3181         return true;
3182 }
3183
3184 static bool api_spoolss_CreatePrinterIC(pipes_struct *p)
3185 {
3186         const struct ndr_interface_call *call;
3187         struct ndr_pull *pull;
3188         struct ndr_push *push;
3189         enum ndr_err_code ndr_err;
3190         DATA_BLOB blob;
3191         struct spoolss_CreatePrinterIC *r;
3192
3193         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_CREATEPRINTERIC];
3194
3195         r = talloc(talloc_tos(), struct spoolss_CreatePrinterIC);
3196         if (r == NULL) {
3197                 return false;
3198         }
3199
3200         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3201                 talloc_free(r);
3202                 return false;
3203         }
3204
3205         pull = ndr_pull_init_blob(&blob, r, NULL);
3206         if (pull == NULL) {
3207                 talloc_free(r);
3208                 return false;
3209         }
3210
3211         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3212         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3213         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3214                 talloc_free(r);
3215                 return false;
3216         }
3217
3218         if (DEBUGLEVEL >= 10) {
3219                 NDR_PRINT_IN_DEBUG(spoolss_CreatePrinterIC, r);
3220         }
3221
3222         r->out.result = _spoolss_CreatePrinterIC(p, r);
3223
3224         if (p->rng_fault_state) {
3225                 talloc_free(r);
3226                 /* Return true here, srv_pipe_hnd.c will take care */
3227                 return true;
3228         }
3229
3230         if (DEBUGLEVEL >= 10) {
3231                 NDR_PRINT_OUT_DEBUG(spoolss_CreatePrinterIC, r);
3232         }
3233
3234         push = ndr_push_init_ctx(r, NULL);
3235         if (push == NULL) {
3236                 talloc_free(r);
3237                 return false;
3238         }
3239
3240         ndr_err = call->ndr_push(push, NDR_OUT, r);
3241         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3242                 talloc_free(r);
3243                 return false;
3244         }
3245
3246         blob = ndr_push_blob(push);
3247         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3248                 talloc_free(r);
3249                 return false;
3250         }
3251
3252         talloc_free(r);
3253
3254         return true;
3255 }
3256
3257 static bool api_spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p)
3258 {
3259         const struct ndr_interface_call *call;
3260         struct ndr_pull *pull;
3261         struct ndr_push *push;
3262         enum ndr_err_code ndr_err;
3263         DATA_BLOB blob;
3264         struct spoolss_PlayGDIScriptOnPrinterIC *r;
3265
3266         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC];
3267
3268         r = talloc(talloc_tos(), struct spoolss_PlayGDIScriptOnPrinterIC);
3269         if (r == NULL) {
3270                 return false;
3271         }
3272
3273         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3274                 talloc_free(r);
3275                 return false;
3276         }
3277
3278         pull = ndr_pull_init_blob(&blob, r, NULL);
3279         if (pull == NULL) {
3280                 talloc_free(r);
3281                 return false;
3282         }
3283
3284         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3285         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3286         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3287                 talloc_free(r);
3288                 return false;
3289         }
3290
3291         if (DEBUGLEVEL >= 10) {
3292                 NDR_PRINT_IN_DEBUG(spoolss_PlayGDIScriptOnPrinterIC, r);
3293         }
3294
3295         r->out.result = _spoolss_PlayGDIScriptOnPrinterIC(p, r);
3296
3297         if (p->rng_fault_state) {
3298                 talloc_free(r);
3299                 /* Return true here, srv_pipe_hnd.c will take care */
3300                 return true;
3301         }
3302
3303         if (DEBUGLEVEL >= 10) {
3304                 NDR_PRINT_OUT_DEBUG(spoolss_PlayGDIScriptOnPrinterIC, r);
3305         }
3306
3307         push = ndr_push_init_ctx(r, NULL);
3308         if (push == NULL) {
3309                 talloc_free(r);
3310                 return false;
3311         }
3312
3313         ndr_err = call->ndr_push(push, NDR_OUT, r);
3314         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3315                 talloc_free(r);
3316                 return false;
3317         }
3318
3319         blob = ndr_push_blob(push);
3320         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3321                 talloc_free(r);
3322                 return false;
3323         }
3324
3325         talloc_free(r);
3326
3327         return true;
3328 }
3329
3330 static bool api_spoolss_DeletePrinterIC(pipes_struct *p)
3331 {
3332         const struct ndr_interface_call *call;
3333         struct ndr_pull *pull;
3334         struct ndr_push *push;
3335         enum ndr_err_code ndr_err;
3336         DATA_BLOB blob;
3337         struct spoolss_DeletePrinterIC *r;
3338
3339         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERIC];
3340
3341         r = talloc(talloc_tos(), struct spoolss_DeletePrinterIC);
3342         if (r == NULL) {
3343                 return false;
3344         }
3345
3346         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3347                 talloc_free(r);
3348                 return false;
3349         }
3350
3351         pull = ndr_pull_init_blob(&blob, r, NULL);
3352         if (pull == NULL) {
3353                 talloc_free(r);
3354                 return false;
3355         }
3356
3357         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3358         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3359         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3360                 talloc_free(r);
3361                 return false;
3362         }
3363
3364         if (DEBUGLEVEL >= 10) {
3365                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterIC, r);
3366         }
3367
3368         r->out.result = _spoolss_DeletePrinterIC(p, r);
3369
3370         if (p->rng_fault_state) {
3371                 talloc_free(r);
3372                 /* Return true here, srv_pipe_hnd.c will take care */
3373                 return true;
3374         }
3375
3376         if (DEBUGLEVEL >= 10) {
3377                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterIC, r);
3378         }
3379
3380         push = ndr_push_init_ctx(r, NULL);
3381         if (push == NULL) {
3382                 talloc_free(r);
3383                 return false;
3384         }
3385
3386         ndr_err = call->ndr_push(push, NDR_OUT, r);
3387         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3388                 talloc_free(r);
3389                 return false;
3390         }
3391
3392         blob = ndr_push_blob(push);
3393         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3394                 talloc_free(r);
3395                 return false;
3396         }
3397
3398         talloc_free(r);
3399
3400         return true;
3401 }
3402
3403 static bool api_spoolss_AddPrinterConnection(pipes_struct *p)
3404 {
3405         const struct ndr_interface_call *call;
3406         struct ndr_pull *pull;
3407         struct ndr_push *push;
3408         enum ndr_err_code ndr_err;
3409         DATA_BLOB blob;
3410         struct spoolss_AddPrinterConnection *r;
3411
3412         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTERCONNECTION];
3413
3414         r = talloc(talloc_tos(), struct spoolss_AddPrinterConnection);
3415         if (r == NULL) {
3416                 return false;
3417         }
3418
3419         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3420                 talloc_free(r);
3421                 return false;
3422         }
3423
3424         pull = ndr_pull_init_blob(&blob, r, NULL);
3425         if (pull == NULL) {
3426                 talloc_free(r);
3427                 return false;
3428         }
3429
3430         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3431         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3432         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3433                 talloc_free(r);
3434                 return false;
3435         }
3436
3437         if (DEBUGLEVEL >= 10) {
3438                 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterConnection, r);
3439         }
3440
3441         r->out.result = _spoolss_AddPrinterConnection(p, r);
3442
3443         if (p->rng_fault_state) {
3444                 talloc_free(r);
3445                 /* Return true here, srv_pipe_hnd.c will take care */
3446                 return true;
3447         }
3448
3449         if (DEBUGLEVEL >= 10) {
3450                 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterConnection, r);
3451         }
3452
3453         push = ndr_push_init_ctx(r, NULL);
3454         if (push == NULL) {
3455                 talloc_free(r);
3456                 return false;
3457         }
3458
3459         ndr_err = call->ndr_push(push, NDR_OUT, r);
3460         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3461                 talloc_free(r);
3462                 return false;
3463         }
3464
3465         blob = ndr_push_blob(push);
3466         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3467                 talloc_free(r);
3468                 return false;
3469         }
3470
3471         talloc_free(r);
3472
3473         return true;
3474 }
3475
3476 static bool api_spoolss_DeletePrinterConnection(pipes_struct *p)
3477 {
3478         const struct ndr_interface_call *call;
3479         struct ndr_pull *pull;
3480         struct ndr_push *push;
3481         enum ndr_err_code ndr_err;
3482         DATA_BLOB blob;
3483         struct spoolss_DeletePrinterConnection *r;
3484
3485         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERCONNECTION];
3486
3487         r = talloc(talloc_tos(), struct spoolss_DeletePrinterConnection);
3488         if (r == NULL) {
3489                 return false;
3490         }
3491
3492         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3493                 talloc_free(r);
3494                 return false;
3495         }
3496
3497         pull = ndr_pull_init_blob(&blob, r, NULL);
3498         if (pull == NULL) {
3499                 talloc_free(r);
3500                 return false;
3501         }
3502
3503         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3504         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3505         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3506                 talloc_free(r);
3507                 return false;
3508         }
3509
3510         if (DEBUGLEVEL >= 10) {
3511                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterConnection, r);
3512         }
3513
3514         r->out.result = _spoolss_DeletePrinterConnection(p, r);
3515
3516         if (p->rng_fault_state) {
3517                 talloc_free(r);
3518                 /* Return true here, srv_pipe_hnd.c will take care */
3519                 return true;
3520         }
3521
3522         if (DEBUGLEVEL >= 10) {
3523                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterConnection, r);
3524         }
3525
3526         push = ndr_push_init_ctx(r, NULL);
3527         if (push == NULL) {
3528                 talloc_free(r);
3529                 return false;
3530         }
3531
3532         ndr_err = call->ndr_push(push, NDR_OUT, r);
3533         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3534                 talloc_free(r);
3535                 return false;
3536         }
3537
3538         blob = ndr_push_blob(push);
3539         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3540                 talloc_free(r);
3541                 return false;
3542         }
3543
3544         talloc_free(r);
3545
3546         return true;
3547 }
3548
3549 static bool api_spoolss_PrinterMessageBox(pipes_struct *p)
3550 {
3551         const struct ndr_interface_call *call;
3552         struct ndr_pull *pull;
3553         struct ndr_push *push;
3554         enum ndr_err_code ndr_err;
3555         DATA_BLOB blob;
3556         struct spoolss_PrinterMessageBox *r;
3557
3558         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_PRINTERMESSAGEBOX];
3559
3560         r = talloc(talloc_tos(), struct spoolss_PrinterMessageBox);
3561         if (r == NULL) {
3562                 return false;
3563         }
3564
3565         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3566                 talloc_free(r);
3567                 return false;
3568         }
3569
3570         pull = ndr_pull_init_blob(&blob, r, NULL);
3571         if (pull == NULL) {
3572                 talloc_free(r);
3573                 return false;
3574         }
3575
3576         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3577         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3578         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3579                 talloc_free(r);
3580                 return false;
3581         }
3582
3583         if (DEBUGLEVEL >= 10) {
3584                 NDR_PRINT_IN_DEBUG(spoolss_PrinterMessageBox, r);
3585         }
3586
3587         r->out.result = _spoolss_PrinterMessageBox(p, r);
3588
3589         if (p->rng_fault_state) {
3590                 talloc_free(r);
3591                 /* Return true here, srv_pipe_hnd.c will take care */
3592                 return true;
3593         }
3594
3595         if (DEBUGLEVEL >= 10) {
3596                 NDR_PRINT_OUT_DEBUG(spoolss_PrinterMessageBox, r);
3597         }
3598
3599         push = ndr_push_init_ctx(r, NULL);
3600         if (push == NULL) {
3601                 talloc_free(r);
3602                 return false;
3603         }
3604
3605         ndr_err = call->ndr_push(push, NDR_OUT, r);
3606         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3607                 talloc_free(r);
3608                 return false;
3609         }
3610
3611         blob = ndr_push_blob(push);
3612         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3613                 talloc_free(r);
3614                 return false;
3615         }
3616
3617         talloc_free(r);
3618
3619         return true;
3620 }
3621
3622 static bool api_spoolss_AddMonitor(pipes_struct *p)
3623 {
3624         const struct ndr_interface_call *call;
3625         struct ndr_pull *pull;
3626         struct ndr_push *push;
3627         enum ndr_err_code ndr_err;
3628         DATA_BLOB blob;
3629         struct spoolss_AddMonitor *r;
3630
3631         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDMONITOR];
3632
3633         r = talloc(talloc_tos(), struct spoolss_AddMonitor);
3634         if (r == NULL) {
3635                 return false;
3636         }
3637
3638         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3639                 talloc_free(r);
3640                 return false;
3641         }
3642
3643         pull = ndr_pull_init_blob(&blob, r, NULL);
3644         if (pull == NULL) {
3645                 talloc_free(r);
3646                 return false;
3647         }
3648
3649         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3650         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3651         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3652                 talloc_free(r);
3653                 return false;
3654         }
3655
3656         if (DEBUGLEVEL >= 10) {
3657                 NDR_PRINT_IN_DEBUG(spoolss_AddMonitor, r);
3658         }
3659
3660         r->out.result = _spoolss_AddMonitor(p, r);
3661
3662         if (p->rng_fault_state) {
3663                 talloc_free(r);
3664                 /* Return true here, srv_pipe_hnd.c will take care */
3665                 return true;
3666         }
3667
3668         if (DEBUGLEVEL >= 10) {
3669                 NDR_PRINT_OUT_DEBUG(spoolss_AddMonitor, r);
3670         }
3671
3672         push = ndr_push_init_ctx(r, NULL);
3673         if (push == NULL) {
3674                 talloc_free(r);
3675                 return false;
3676         }
3677
3678         ndr_err = call->ndr_push(push, NDR_OUT, r);
3679         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3680                 talloc_free(r);
3681                 return false;
3682         }
3683
3684         blob = ndr_push_blob(push);
3685         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3686                 talloc_free(r);
3687                 return false;
3688         }
3689
3690         talloc_free(r);
3691
3692         return true;
3693 }
3694
3695 static bool api_spoolss_DeleteMonitor(pipes_struct *p)
3696 {
3697         const struct ndr_interface_call *call;
3698         struct ndr_pull *pull;
3699         struct ndr_push *push;
3700         enum ndr_err_code ndr_err;
3701         DATA_BLOB blob;
3702         struct spoolss_DeleteMonitor *r;
3703
3704         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEMONITOR];
3705
3706         r = talloc(talloc_tos(), struct spoolss_DeleteMonitor);
3707         if (r == NULL) {
3708                 return false;
3709         }
3710
3711         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3712                 talloc_free(r);
3713                 return false;
3714         }
3715
3716         pull = ndr_pull_init_blob(&blob, r, NULL);
3717         if (pull == NULL) {
3718                 talloc_free(r);
3719                 return false;
3720         }
3721
3722         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3723         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3724         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3725                 talloc_free(r);
3726                 return false;
3727         }
3728
3729         if (DEBUGLEVEL >= 10) {
3730                 NDR_PRINT_IN_DEBUG(spoolss_DeleteMonitor, r);
3731         }
3732
3733         r->out.result = _spoolss_DeleteMonitor(p, r);
3734
3735         if (p->rng_fault_state) {
3736                 talloc_free(r);
3737                 /* Return true here, srv_pipe_hnd.c will take care */
3738                 return true;
3739         }
3740
3741         if (DEBUGLEVEL >= 10) {
3742                 NDR_PRINT_OUT_DEBUG(spoolss_DeleteMonitor, r);
3743         }
3744
3745         push = ndr_push_init_ctx(r, NULL);
3746         if (push == NULL) {
3747                 talloc_free(r);
3748                 return false;
3749         }
3750
3751         ndr_err = call->ndr_push(push, NDR_OUT, r);
3752         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3753                 talloc_free(r);
3754                 return false;
3755         }
3756
3757         blob = ndr_push_blob(push);
3758         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3759                 talloc_free(r);
3760                 return false;
3761         }
3762
3763         talloc_free(r);
3764
3765         return true;
3766 }
3767
3768 static bool api_spoolss_DeletePrintProcessor(pipes_struct *p)
3769 {
3770         const struct ndr_interface_call *call;
3771         struct ndr_pull *pull;
3772         struct ndr_push *push;
3773         enum ndr_err_code ndr_err;
3774         DATA_BLOB blob;
3775         struct spoolss_DeletePrintProcessor *r;
3776
3777         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTPROCESSOR];
3778
3779         r = talloc(talloc_tos(), struct spoolss_DeletePrintProcessor);
3780         if (r == NULL) {
3781                 return false;
3782         }
3783
3784         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3785                 talloc_free(r);
3786                 return false;
3787         }
3788
3789         pull = ndr_pull_init_blob(&blob, r, NULL);
3790         if (pull == NULL) {
3791                 talloc_free(r);
3792                 return false;
3793         }
3794
3795         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3796         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3797         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3798                 talloc_free(r);
3799                 return false;
3800         }
3801
3802         if (DEBUGLEVEL >= 10) {
3803                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrintProcessor, r);
3804         }
3805
3806         r->out.result = _spoolss_DeletePrintProcessor(p, r);
3807
3808         if (p->rng_fault_state) {
3809                 talloc_free(r);
3810                 /* Return true here, srv_pipe_hnd.c will take care */
3811                 return true;
3812         }
3813
3814         if (DEBUGLEVEL >= 10) {
3815                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrintProcessor, r);
3816         }
3817
3818         push = ndr_push_init_ctx(r, NULL);
3819         if (push == NULL) {
3820                 talloc_free(r);
3821                 return false;
3822         }
3823
3824         ndr_err = call->ndr_push(push, NDR_OUT, r);
3825         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3826                 talloc_free(r);
3827                 return false;
3828         }
3829
3830         blob = ndr_push_blob(push);
3831         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3832                 talloc_free(r);
3833                 return false;
3834         }
3835
3836         talloc_free(r);
3837
3838         return true;
3839 }
3840
3841 static bool api_spoolss_AddPrintProvidor(pipes_struct *p)
3842 {
3843         const struct ndr_interface_call *call;
3844         struct ndr_pull *pull;
3845         struct ndr_push *push;
3846         enum ndr_err_code ndr_err;
3847         DATA_BLOB blob;
3848         struct spoolss_AddPrintProvidor *r;
3849
3850         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTPROVIDOR];
3851
3852         r = talloc(talloc_tos(), struct spoolss_AddPrintProvidor);
3853         if (r == NULL) {
3854                 return false;
3855         }
3856
3857         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3858                 talloc_free(r);
3859                 return false;
3860         }
3861
3862         pull = ndr_pull_init_blob(&blob, r, NULL);
3863         if (pull == NULL) {
3864                 talloc_free(r);
3865                 return false;
3866         }
3867
3868         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3869         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3870         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3871                 talloc_free(r);
3872                 return false;
3873         }
3874
3875         if (DEBUGLEVEL >= 10) {
3876                 NDR_PRINT_IN_DEBUG(spoolss_AddPrintProvidor, r);
3877         }
3878
3879         r->out.result = _spoolss_AddPrintProvidor(p, r);
3880
3881         if (p->rng_fault_state) {
3882                 talloc_free(r);
3883                 /* Return true here, srv_pipe_hnd.c will take care */
3884                 return true;
3885         }
3886
3887         if (DEBUGLEVEL >= 10) {
3888                 NDR_PRINT_OUT_DEBUG(spoolss_AddPrintProvidor, r);
3889         }
3890
3891         push = ndr_push_init_ctx(r, NULL);
3892         if (push == NULL) {
3893                 talloc_free(r);
3894                 return false;
3895         }
3896
3897         ndr_err = call->ndr_push(push, NDR_OUT, r);
3898         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3899                 talloc_free(r);
3900                 return false;
3901         }
3902
3903         blob = ndr_push_blob(push);
3904         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3905                 talloc_free(r);
3906                 return false;
3907         }
3908
3909         talloc_free(r);
3910
3911         return true;
3912 }
3913
3914 static bool api_spoolss_DeletePrintProvidor(pipes_struct *p)
3915 {
3916         const struct ndr_interface_call *call;
3917         struct ndr_pull *pull;
3918         struct ndr_push *push;
3919         enum ndr_err_code ndr_err;
3920         DATA_BLOB blob;
3921         struct spoolss_DeletePrintProvidor *r;
3922
3923         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTPROVIDOR];
3924
3925         r = talloc(talloc_tos(), struct spoolss_DeletePrintProvidor);
3926         if (r == NULL) {
3927                 return false;
3928         }
3929
3930         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3931                 talloc_free(r);
3932                 return false;
3933         }
3934
3935         pull = ndr_pull_init_blob(&blob, r, NULL);
3936         if (pull == NULL) {
3937                 talloc_free(r);
3938                 return false;
3939         }
3940
3941         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3942         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3943         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3944                 talloc_free(r);
3945                 return false;
3946         }
3947
3948         if (DEBUGLEVEL >= 10) {
3949                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrintProvidor, r);
3950         }
3951
3952         r->out.result = _spoolss_DeletePrintProvidor(p, r);
3953
3954         if (p->rng_fault_state) {
3955                 talloc_free(r);
3956                 /* Return true here, srv_pipe_hnd.c will take care */
3957                 return true;
3958         }
3959
3960         if (DEBUGLEVEL >= 10) {
3961                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrintProvidor, r);
3962         }
3963
3964         push = ndr_push_init_ctx(r, NULL);
3965         if (push == NULL) {
3966                 talloc_free(r);
3967                 return false;
3968         }
3969
3970         ndr_err = call->ndr_push(push, NDR_OUT, r);
3971         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3972                 talloc_free(r);
3973                 return false;
3974         }
3975
3976         blob = ndr_push_blob(push);
3977         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3978                 talloc_free(r);
3979                 return false;
3980         }
3981
3982         talloc_free(r);
3983
3984         return true;
3985 }
3986
3987 static bool api_spoolss_EnumPrintProcDataTypes(pipes_struct *p)
3988 {
3989         const struct ndr_interface_call *call;
3990         struct ndr_pull *pull;
3991         struct ndr_push *push;
3992         enum ndr_err_code ndr_err;
3993         DATA_BLOB blob;
3994         struct spoolss_EnumPrintProcDataTypes *r;
3995
3996         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPRINTPROCDATATYPES];
3997
3998         r = talloc(talloc_tos(), struct spoolss_EnumPrintProcDataTypes);
3999         if (r == NULL) {
4000                 return false;
4001         }
4002
4003         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4004                 talloc_free(r);
4005                 return false;
4006         }
4007
4008         pull = ndr_pull_init_blob(&blob, r, NULL);
4009         if (pull == NULL) {
4010                 talloc_free(r);
4011                 return false;
4012         }
4013
4014         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4015         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4016         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4017                 talloc_free(r);
4018                 return false;
4019         }
4020
4021         if (DEBUGLEVEL >= 10) {
4022                 NDR_PRINT_IN_DEBUG(spoolss_EnumPrintProcDataTypes, r);
4023         }
4024
4025         ZERO_STRUCT(r->out);
4026         r->out.count = talloc_zero(r, uint32_t);
4027         if (r->out.count == NULL) {
4028                 talloc_free(r);
4029                 return false;
4030         }
4031
4032         r->out.info = talloc_zero(r, union spoolss_PrintProcDataTypesInfo *);
4033         if (r->out.info == NULL) {
4034                 talloc_free(r);
4035                 return false;
4036         }
4037
4038         r->out.needed = talloc_zero(r, uint32_t);
4039         if (r->out.needed == NULL) {
4040                 talloc_free(r);
4041                 return false;
4042         }
4043
4044         r->out.result = _spoolss_EnumPrintProcDataTypes(p, r);
4045
4046         if (p->rng_fault_state) {
4047                 talloc_free(r);
4048                 /* Return true here, srv_pipe_hnd.c will take care */
4049                 return true;
4050         }
4051
4052         if (DEBUGLEVEL >= 10) {
4053                 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrintProcDataTypes, r);
4054         }
4055
4056         push = ndr_push_init_ctx(r, NULL);
4057         if (push == NULL) {
4058                 talloc_free(r);
4059                 return false;
4060         }
4061
4062         ndr_err = call->ndr_push(push, NDR_OUT, r);
4063         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4064                 talloc_free(r);
4065                 return false;
4066         }
4067
4068         blob = ndr_push_blob(push);
4069         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4070                 talloc_free(r);
4071                 return false;
4072         }
4073
4074         talloc_free(r);
4075
4076         return true;
4077 }
4078
4079 static bool api_spoolss_ResetPrinter(pipes_struct *p)
4080 {
4081         const struct ndr_interface_call *call;
4082         struct ndr_pull *pull;
4083         struct ndr_push *push;
4084         enum ndr_err_code ndr_err;
4085         DATA_BLOB blob;
4086         struct spoolss_ResetPrinter *r;
4087
4088         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_RESETPRINTER];
4089
4090         r = talloc(talloc_tos(), struct spoolss_ResetPrinter);
4091         if (r == NULL) {
4092                 return false;
4093         }
4094
4095         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4096                 talloc_free(r);
4097                 return false;
4098         }
4099
4100         pull = ndr_pull_init_blob(&blob, r, NULL);
4101         if (pull == NULL) {
4102                 talloc_free(r);
4103                 return false;
4104         }
4105
4106         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4107         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4108         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4109                 talloc_free(r);
4110                 return false;
4111         }
4112
4113         if (DEBUGLEVEL >= 10) {
4114                 NDR_PRINT_IN_DEBUG(spoolss_ResetPrinter, r);
4115         }
4116
4117         r->out.result = _spoolss_ResetPrinter(p, r);
4118
4119         if (p->rng_fault_state) {
4120                 talloc_free(r);
4121                 /* Return true here, srv_pipe_hnd.c will take care */
4122                 return true;
4123         }
4124
4125         if (DEBUGLEVEL >= 10) {
4126                 NDR_PRINT_OUT_DEBUG(spoolss_ResetPrinter, r);
4127         }
4128
4129         push = ndr_push_init_ctx(r, NULL);
4130         if (push == NULL) {
4131                 talloc_free(r);
4132                 return false;
4133         }
4134
4135         ndr_err = call->ndr_push(push, NDR_OUT, r);
4136         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4137                 talloc_free(r);
4138                 return false;
4139         }
4140
4141         blob = ndr_push_blob(push);
4142         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4143                 talloc_free(r);
4144                 return false;
4145         }
4146
4147         talloc_free(r);
4148
4149         return true;
4150 }
4151
4152 static bool api_spoolss_GetPrinterDriver2(pipes_struct *p)
4153 {
4154         const struct ndr_interface_call *call;
4155         struct ndr_pull *pull;
4156         struct ndr_push *push;
4157         enum ndr_err_code ndr_err;
4158         DATA_BLOB blob;
4159         struct spoolss_GetPrinterDriver2 *r;
4160
4161         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTERDRIVER2];
4162
4163         r = talloc(talloc_tos(), struct spoolss_GetPrinterDriver2);
4164         if (r == NULL) {
4165                 return false;
4166         }
4167
4168         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4169                 talloc_free(r);
4170                 return false;
4171         }
4172
4173         pull = ndr_pull_init_blob(&blob, r, NULL);
4174         if (pull == NULL) {
4175                 talloc_free(r);
4176                 return false;
4177         }
4178
4179         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4180         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4181         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4182                 talloc_free(r);
4183                 return false;
4184         }
4185
4186         if (DEBUGLEVEL >= 10) {
4187                 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriver2, r);
4188         }
4189
4190         ZERO_STRUCT(r->out);
4191         r->out.info = talloc_zero(r, union spoolss_DriverInfo);
4192         if (r->out.info == NULL) {
4193                 talloc_free(r);
4194                 return false;
4195         }
4196
4197         r->out.needed = talloc_zero(r, uint32_t);
4198         if (r->out.needed == NULL) {
4199                 talloc_free(r);
4200                 return false;
4201         }
4202
4203         r->out.server_major_version = talloc_zero(r, uint32_t);
4204         if (r->out.server_major_version == NULL) {
4205                 talloc_free(r);
4206                 return false;
4207         }
4208
4209         r->out.server_minor_version = talloc_zero(r, uint32_t);
4210         if (r->out.server_minor_version == NULL) {
4211                 talloc_free(r);
4212                 return false;
4213         }
4214
4215         r->out.result = _spoolss_GetPrinterDriver2(p, r);
4216
4217         if (p->rng_fault_state) {
4218                 talloc_free(r);
4219                 /* Return true here, srv_pipe_hnd.c will take care */
4220                 return true;
4221         }
4222
4223         if (DEBUGLEVEL >= 10) {
4224                 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriver2, r);
4225         }
4226
4227         push = ndr_push_init_ctx(r, NULL);
4228         if (push == NULL) {
4229                 talloc_free(r);
4230                 return false;
4231         }
4232
4233         ndr_err = call->ndr_push(push, NDR_OUT, r);
4234         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4235                 talloc_free(r);
4236                 return false;
4237         }
4238
4239         blob = ndr_push_blob(push);
4240         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4241                 talloc_free(r);
4242                 return false;
4243         }
4244
4245         talloc_free(r);
4246
4247         return true;
4248 }
4249
4250 static bool api_spoolss_FindFirstPrinterChangeNotification(pipes_struct *p)
4251 {
4252         const struct ndr_interface_call *call;
4253         struct ndr_pull *pull;
4254         struct ndr_push *push;
4255         enum ndr_err_code ndr_err;
4256         DATA_BLOB blob;
4257         struct spoolss_FindFirstPrinterChangeNotification *r;
4258
4259         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION];
4260
4261         r = talloc(talloc_tos(), struct spoolss_FindFirstPrinterChangeNotification);
4262         if (r == NULL) {
4263                 return false;
4264         }
4265
4266         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4267                 talloc_free(r);
4268                 return false;
4269         }
4270
4271         pull = ndr_pull_init_blob(&blob, r, NULL);
4272         if (pull == NULL) {
4273                 talloc_free(r);
4274                 return false;
4275         }
4276
4277         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4278         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4279         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4280                 talloc_free(r);
4281                 return false;
4282         }
4283
4284         if (DEBUGLEVEL >= 10) {
4285                 NDR_PRINT_IN_DEBUG(spoolss_FindFirstPrinterChangeNotification, r);
4286         }
4287
4288         r->out.result = _spoolss_FindFirstPrinterChangeNotification(p, r);
4289
4290         if (p->rng_fault_state) {
4291                 talloc_free(r);
4292                 /* Return true here, srv_pipe_hnd.c will take care */
4293                 return true;
4294         }
4295
4296         if (DEBUGLEVEL >= 10) {
4297                 NDR_PRINT_OUT_DEBUG(spoolss_FindFirstPrinterChangeNotification, r);
4298         }
4299
4300         push = ndr_push_init_ctx(r, NULL);
4301         if (push == NULL) {
4302                 talloc_free(r);
4303                 return false;
4304         }
4305
4306         ndr_err = call->ndr_push(push, NDR_OUT, r);
4307         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4308                 talloc_free(r);
4309                 return false;
4310         }
4311
4312         blob = ndr_push_blob(push);
4313         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4314                 talloc_free(r);
4315                 return false;
4316         }
4317
4318         talloc_free(r);
4319
4320         return true;
4321 }
4322
4323 static bool api_spoolss_FindNextPrinterChangeNotification(pipes_struct *p)
4324 {
4325         const struct ndr_interface_call *call;
4326         struct ndr_pull *pull;
4327         struct ndr_push *push;
4328         enum ndr_err_code ndr_err;
4329         DATA_BLOB blob;
4330         struct spoolss_FindNextPrinterChangeNotification *r;
4331
4332         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION];
4333
4334         r = talloc(talloc_tos(), struct spoolss_FindNextPrinterChangeNotification);
4335         if (r == NULL) {
4336                 return false;
4337         }
4338
4339         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4340                 talloc_free(r);
4341                 return false;
4342         }
4343
4344         pull = ndr_pull_init_blob(&blob, r, NULL);
4345         if (pull == NULL) {
4346                 talloc_free(r);
4347                 return false;
4348         }
4349
4350         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4351         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4352         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4353                 talloc_free(r);
4354                 return false;
4355         }
4356
4357         if (DEBUGLEVEL >= 10) {
4358                 NDR_PRINT_IN_DEBUG(spoolss_FindNextPrinterChangeNotification, r);
4359         }
4360
4361         r->out.result = _spoolss_FindNextPrinterChangeNotification(p, r);
4362
4363         if (p->rng_fault_state) {
4364                 talloc_free(r);
4365                 /* Return true here, srv_pipe_hnd.c will take care */
4366                 return true;
4367         }
4368
4369         if (DEBUGLEVEL >= 10) {
4370                 NDR_PRINT_OUT_DEBUG(spoolss_FindNextPrinterChangeNotification, r);
4371         }
4372
4373         push = ndr_push_init_ctx(r, NULL);
4374         if (push == NULL) {
4375                 talloc_free(r);
4376                 return false;
4377         }
4378
4379         ndr_err = call->ndr_push(push, NDR_OUT, r);
4380         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4381                 talloc_free(r);
4382                 return false;
4383         }
4384
4385         blob = ndr_push_blob(push);
4386         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4387                 talloc_free(r);
4388                 return false;
4389         }
4390
4391         talloc_free(r);
4392
4393         return true;
4394 }
4395
4396 static bool api_spoolss_FindClosePrinterNotify(pipes_struct *p)
4397 {
4398         const struct ndr_interface_call *call;
4399         struct ndr_pull *pull;
4400         struct ndr_push *push;
4401         enum ndr_err_code ndr_err;
4402         DATA_BLOB blob;
4403         struct spoolss_FindClosePrinterNotify *r;
4404
4405         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY];
4406
4407         r = talloc(talloc_tos(), struct spoolss_FindClosePrinterNotify);
4408         if (r == NULL) {
4409                 return false;
4410         }
4411
4412         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4413                 talloc_free(r);
4414                 return false;
4415         }
4416
4417         pull = ndr_pull_init_blob(&blob, r, NULL);
4418         if (pull == NULL) {
4419                 talloc_free(r);
4420                 return false;
4421         }
4422
4423         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4424         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4425         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4426                 talloc_free(r);
4427                 return false;
4428         }
4429
4430         if (DEBUGLEVEL >= 10) {
4431                 NDR_PRINT_IN_DEBUG(spoolss_FindClosePrinterNotify, r);
4432         }
4433
4434         r->out.result = _spoolss_FindClosePrinterNotify(p, r);
4435
4436         if (p->rng_fault_state) {
4437                 talloc_free(r);
4438                 /* Return true here, srv_pipe_hnd.c will take care */
4439                 return true;
4440         }
4441
4442         if (DEBUGLEVEL >= 10) {
4443                 NDR_PRINT_OUT_DEBUG(spoolss_FindClosePrinterNotify, r);
4444         }
4445
4446         push = ndr_push_init_ctx(r, NULL);
4447         if (push == NULL) {
4448                 talloc_free(r);
4449                 return false;
4450         }
4451
4452         ndr_err = call->ndr_push(push, NDR_OUT, r);
4453         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4454                 talloc_free(r);
4455                 return false;
4456         }
4457
4458         blob = ndr_push_blob(push);
4459         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4460                 talloc_free(r);
4461                 return false;
4462         }
4463
4464         talloc_free(r);
4465
4466         return true;
4467 }
4468
4469 static bool api_spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p)
4470 {
4471         const struct ndr_interface_call *call;
4472         struct ndr_pull *pull;
4473         struct ndr_push *push;
4474         enum ndr_err_code ndr_err;
4475         DATA_BLOB blob;
4476         struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r;
4477
4478         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD];
4479
4480         r = talloc(talloc_tos(), struct spoolss_RouterFindFirstPrinterChangeNotificationOld);
4481         if (r == NULL) {
4482                 return false;
4483         }
4484
4485         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4486                 talloc_free(r);
4487                 return false;
4488         }
4489
4490         pull = ndr_pull_init_blob(&blob, r, NULL);
4491         if (pull == NULL) {
4492                 talloc_free(r);
4493                 return false;
4494         }
4495
4496         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4497         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4498         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4499                 talloc_free(r);
4500                 return false;
4501         }
4502
4503         if (DEBUGLEVEL >= 10) {
4504                 NDR_PRINT_IN_DEBUG(spoolss_RouterFindFirstPrinterChangeNotificationOld, r);
4505         }
4506
4507         r->out.result = _spoolss_RouterFindFirstPrinterChangeNotificationOld(p, r);
4508
4509         if (p->rng_fault_state) {
4510                 talloc_free(r);
4511                 /* Return true here, srv_pipe_hnd.c will take care */
4512                 return true;
4513         }
4514
4515         if (DEBUGLEVEL >= 10) {
4516                 NDR_PRINT_OUT_DEBUG(spoolss_RouterFindFirstPrinterChangeNotificationOld, r);
4517         }
4518
4519         push = ndr_push_init_ctx(r, NULL);
4520         if (push == NULL) {
4521                 talloc_free(r);
4522                 return false;
4523         }
4524
4525         ndr_err = call->ndr_push(push, NDR_OUT, r);
4526         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4527                 talloc_free(r);
4528                 return false;
4529         }
4530
4531         blob = ndr_push_blob(push);
4532         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4533                 talloc_free(r);
4534                 return false;
4535         }
4536
4537         talloc_free(r);
4538
4539         return true;
4540 }
4541
4542 static bool api_spoolss_ReplyOpenPrinter(pipes_struct *p)
4543 {
4544         const struct ndr_interface_call *call;
4545         struct ndr_pull *pull;
4546         struct ndr_push *push;
4547         enum ndr_err_code ndr_err;
4548         DATA_BLOB blob;
4549         struct spoolss_ReplyOpenPrinter *r;
4550
4551         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_REPLYOPENPRINTER];
4552
4553         r = talloc(talloc_tos(), struct spoolss_ReplyOpenPrinter);
4554         if (r == NULL) {
4555                 return false;
4556         }
4557
4558         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4559                 talloc_free(r);
4560                 return false;
4561         }
4562
4563         pull = ndr_pull_init_blob(&blob, r, NULL);
4564         if (pull == NULL) {
4565                 talloc_free(r);
4566                 return false;
4567         }
4568
4569         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4570         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4571         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4572                 talloc_free(r);
4573                 return false;
4574         }
4575
4576         if (DEBUGLEVEL >= 10) {
4577                 NDR_PRINT_IN_DEBUG(spoolss_ReplyOpenPrinter, r);
4578         }
4579
4580         ZERO_STRUCT(r->out);
4581         r->out.handle = talloc_zero(r, struct policy_handle);
4582         if (r->out.handle == NULL) {
4583                 talloc_free(r);
4584                 return false;
4585         }
4586
4587         r->out.result = _spoolss_ReplyOpenPrinter(p, r);
4588
4589         if (p->rng_fault_state) {
4590                 talloc_free(r);
4591                 /* Return true here, srv_pipe_hnd.c will take care */
4592                 return true;
4593         }
4594
4595         if (DEBUGLEVEL >= 10) {
4596                 NDR_PRINT_OUT_DEBUG(spoolss_ReplyOpenPrinter, r);
4597         }
4598
4599         push = ndr_push_init_ctx(r, NULL);
4600         if (push == NULL) {
4601                 talloc_free(r);
4602                 return false;
4603         }
4604
4605         ndr_err = call->ndr_push(push, NDR_OUT, r);
4606         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4607                 talloc_free(r);
4608                 return false;
4609         }
4610
4611         blob = ndr_push_blob(push);
4612         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4613                 talloc_free(r);
4614                 return false;
4615         }
4616
4617         talloc_free(r);
4618
4619         return true;
4620 }
4621
4622 static bool api_spoolss_RouterReplyPrinter(pipes_struct *p)
4623 {
4624         const struct ndr_interface_call *call;
4625         struct ndr_pull *pull;
4626         struct ndr_push *push;
4627         enum ndr_err_code ndr_err;
4628         DATA_BLOB blob;
4629         struct spoolss_RouterReplyPrinter *r;
4630
4631         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ROUTERREPLYPRINTER];
4632
4633         r = talloc(talloc_tos(), struct spoolss_RouterReplyPrinter);
4634         if (r == NULL) {
4635                 return false;
4636         }
4637
4638         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4639                 talloc_free(r);
4640                 return false;
4641         }
4642
4643         pull = ndr_pull_init_blob(&blob, r, NULL);
4644         if (pull == NULL) {
4645                 talloc_free(r);
4646                 return false;
4647         }
4648
4649         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4650         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4651         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4652                 talloc_free(r);
4653                 return false;
4654         }
4655
4656         if (DEBUGLEVEL >= 10) {
4657                 NDR_PRINT_IN_DEBUG(spoolss_RouterReplyPrinter, r);
4658         }
4659
4660         r->out.result = _spoolss_RouterReplyPrinter(p, r);
4661
4662         if (p->rng_fault_state) {
4663                 talloc_free(r);
4664                 /* Return true here, srv_pipe_hnd.c will take care */
4665                 return true;
4666         }
4667
4668         if (DEBUGLEVEL >= 10) {
4669                 NDR_PRINT_OUT_DEBUG(spoolss_RouterReplyPrinter, r);
4670         }
4671
4672         push = ndr_push_init_ctx(r, NULL);
4673         if (push == NULL) {
4674                 talloc_free(r);
4675                 return false;
4676         }
4677
4678         ndr_err = call->ndr_push(push, NDR_OUT, r);
4679         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4680                 talloc_free(r);
4681                 return false;
4682         }
4683
4684         blob = ndr_push_blob(push);
4685         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4686                 talloc_free(r);
4687                 return false;
4688         }
4689
4690         talloc_free(r);
4691
4692         return true;
4693 }
4694
4695 static bool api_spoolss_ReplyClosePrinter(pipes_struct *p)
4696 {
4697         const struct ndr_interface_call *call;
4698         struct ndr_pull *pull;
4699         struct ndr_push *push;
4700         enum ndr_err_code ndr_err;
4701         DATA_BLOB blob;
4702         struct spoolss_ReplyClosePrinter *r;
4703
4704         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_REPLYCLOSEPRINTER];
4705
4706         r = talloc(talloc_tos(), struct spoolss_ReplyClosePrinter);
4707         if (r == NULL) {
4708                 return false;
4709         }
4710
4711         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4712                 talloc_free(r);
4713                 return false;
4714         }
4715
4716         pull = ndr_pull_init_blob(&blob, r, NULL);
4717         if (pull == NULL) {
4718                 talloc_free(r);
4719                 return false;
4720         }
4721
4722         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4723         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4724         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4725                 talloc_free(r);
4726                 return false;
4727         }
4728
4729         if (DEBUGLEVEL >= 10) {
4730                 NDR_PRINT_IN_DEBUG(spoolss_ReplyClosePrinter, r);
4731         }
4732
4733         ZERO_STRUCT(r->out);
4734         r->out.handle = r->in.handle;
4735         r->out.result = _spoolss_ReplyClosePrinter(p, r);
4736
4737         if (p->rng_fault_state) {
4738                 talloc_free(r);
4739                 /* Return true here, srv_pipe_hnd.c will take care */
4740                 return true;
4741         }
4742
4743         if (DEBUGLEVEL >= 10) {
4744                 NDR_PRINT_OUT_DEBUG(spoolss_ReplyClosePrinter, r);
4745         }
4746
4747         push = ndr_push_init_ctx(r, NULL);
4748         if (push == NULL) {
4749                 talloc_free(r);
4750                 return false;
4751         }
4752
4753         ndr_err = call->ndr_push(push, NDR_OUT, r);
4754         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4755                 talloc_free(r);
4756                 return false;
4757         }
4758
4759         blob = ndr_push_blob(push);
4760         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4761                 talloc_free(r);
4762                 return false;
4763         }
4764
4765         talloc_free(r);
4766
4767         return true;
4768 }
4769
4770 static bool api_spoolss_AddPortEx(pipes_struct *p)
4771 {
4772         const struct ndr_interface_call *call;
4773         struct ndr_pull *pull;
4774         struct ndr_push *push;
4775         enum ndr_err_code ndr_err;
4776         DATA_BLOB blob;
4777         struct spoolss_AddPortEx *r;
4778
4779         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPORTEX];
4780
4781         r = talloc(talloc_tos(), struct spoolss_AddPortEx);
4782         if (r == NULL) {
4783                 return false;
4784         }
4785
4786         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4787                 talloc_free(r);
4788                 return false;
4789         }
4790
4791         pull = ndr_pull_init_blob(&blob, r, NULL);
4792         if (pull == NULL) {
4793                 talloc_free(r);
4794                 return false;
4795         }
4796
4797         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4798         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4799         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4800                 talloc_free(r);
4801                 return false;
4802         }
4803
4804         if (DEBUGLEVEL >= 10) {
4805                 NDR_PRINT_IN_DEBUG(spoolss_AddPortEx, r);
4806         }
4807
4808         r->out.result = _spoolss_AddPortEx(p, r);
4809
4810         if (p->rng_fault_state) {
4811                 talloc_free(r);
4812                 /* Return true here, srv_pipe_hnd.c will take care */
4813                 return true;
4814         }
4815
4816         if (DEBUGLEVEL >= 10) {
4817                 NDR_PRINT_OUT_DEBUG(spoolss_AddPortEx, r);
4818         }
4819
4820         push = ndr_push_init_ctx(r, NULL);
4821         if (push == NULL) {
4822                 talloc_free(r);
4823                 return false;
4824         }
4825
4826         ndr_err = call->ndr_push(push, NDR_OUT, r);
4827         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4828                 talloc_free(r);
4829                 return false;
4830         }
4831
4832         blob = ndr_push_blob(push);
4833         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4834                 talloc_free(r);
4835                 return false;
4836         }
4837
4838         talloc_free(r);
4839
4840         return true;
4841 }
4842
4843 static bool api_spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p)
4844 {
4845         const struct ndr_interface_call *call;
4846         struct ndr_pull *pull;
4847         struct ndr_push *push;
4848         enum ndr_err_code ndr_err;
4849         DATA_BLOB blob;
4850         struct spoolss_RouterFindFirstPrinterChangeNotification *r;
4851
4852         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION];
4853
4854         r = talloc(talloc_tos(), struct spoolss_RouterFindFirstPrinterChangeNotification);
4855         if (r == NULL) {
4856                 return false;
4857         }
4858
4859         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4860                 talloc_free(r);
4861                 return false;
4862         }
4863
4864         pull = ndr_pull_init_blob(&blob, r, NULL);
4865         if (pull == NULL) {
4866                 talloc_free(r);
4867                 return false;
4868         }
4869
4870         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4871         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4872         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4873                 talloc_free(r);
4874                 return false;
4875         }
4876
4877         if (DEBUGLEVEL >= 10) {
4878                 NDR_PRINT_IN_DEBUG(spoolss_RouterFindFirstPrinterChangeNotification, r);
4879         }
4880
4881         r->out.result = _spoolss_RouterFindFirstPrinterChangeNotification(p, r);
4882
4883         if (p->rng_fault_state) {
4884                 talloc_free(r);
4885                 /* Return true here, srv_pipe_hnd.c will take care */
4886                 return true;
4887         }
4888
4889         if (DEBUGLEVEL >= 10) {
4890                 NDR_PRINT_OUT_DEBUG(spoolss_RouterFindFirstPrinterChangeNotification, r);
4891         }
4892
4893         push = ndr_push_init_ctx(r, NULL);
4894         if (push == NULL) {
4895                 talloc_free(r);
4896                 return false;
4897         }
4898
4899         ndr_err = call->ndr_push(push, NDR_OUT, r);
4900         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4901                 talloc_free(r);
4902                 return false;
4903         }
4904
4905         blob = ndr_push_blob(push);
4906         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4907                 talloc_free(r);
4908                 return false;
4909         }
4910
4911         talloc_free(r);
4912
4913         return true;
4914 }
4915
4916 static bool api_spoolss_SpoolerInit(pipes_struct *p)
4917 {
4918         const struct ndr_interface_call *call;
4919         struct ndr_pull *pull;
4920         struct ndr_push *push;
4921         enum ndr_err_code ndr_err;
4922         DATA_BLOB blob;
4923         struct spoolss_SpoolerInit *r;
4924
4925         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_SPOOLERINIT];
4926
4927         r = talloc(talloc_tos(), struct spoolss_SpoolerInit);
4928         if (r == NULL) {
4929                 return false;
4930         }
4931
4932         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4933                 talloc_free(r);
4934                 return false;
4935         }
4936
4937         pull = ndr_pull_init_blob(&blob, r, NULL);
4938         if (pull == NULL) {
4939                 talloc_free(r);
4940                 return false;
4941         }
4942
4943         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4944         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4945         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4946                 talloc_free(r);
4947                 return false;
4948         }
4949
4950         if (DEBUGLEVEL >= 10) {
4951                 NDR_PRINT_IN_DEBUG(spoolss_SpoolerInit, r);
4952         }
4953
4954         r->out.result = _spoolss_SpoolerInit(p, r);
4955
4956         if (p->rng_fault_state) {
4957                 talloc_free(r);
4958                 /* Return true here, srv_pipe_hnd.c will take care */
4959                 return true;
4960         }
4961
4962         if (DEBUGLEVEL >= 10) {
4963                 NDR_PRINT_OUT_DEBUG(spoolss_SpoolerInit, r);
4964         }
4965
4966         push = ndr_push_init_ctx(r, NULL);
4967         if (push == NULL) {
4968                 talloc_free(r);
4969                 return false;
4970         }
4971
4972         ndr_err = call->ndr_push(push, NDR_OUT, r);
4973         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4974                 talloc_free(r);
4975                 return false;
4976         }
4977
4978         blob = ndr_push_blob(push);
4979         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4980                 talloc_free(r);
4981                 return false;
4982         }
4983
4984         talloc_free(r);
4985
4986         return true;
4987 }
4988
4989 static bool api_spoolss_ResetPrinterEx(pipes_struct *p)
4990 {
4991         const struct ndr_interface_call *call;
4992         struct ndr_pull *pull;
4993         struct ndr_push *push;
4994         enum ndr_err_code ndr_err;
4995         DATA_BLOB blob;
4996         struct spoolss_ResetPrinterEx *r;
4997
4998         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_RESETPRINTEREX];
4999
5000         r = talloc(talloc_tos(), struct spoolss_ResetPrinterEx);
5001         if (r == NULL) {
5002                 return false;
5003         }
5004
5005         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5006                 talloc_free(r);
5007                 return false;
5008         }
5009
5010         pull = ndr_pull_init_blob(&blob, r, NULL);
5011         if (pull == NULL) {
5012                 talloc_free(r);
5013                 return false;
5014         }
5015
5016         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5017         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5018         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5019                 talloc_free(r);
5020                 return false;
5021         }
5022
5023         if (DEBUGLEVEL >= 10) {
5024                 NDR_PRINT_IN_DEBUG(spoolss_ResetPrinterEx, r);
5025         }
5026
5027         r->out.result = _spoolss_ResetPrinterEx(p, r);
5028
5029         if (p->rng_fault_state) {
5030                 talloc_free(r);
5031                 /* Return true here, srv_pipe_hnd.c will take care */
5032                 return true;
5033         }
5034
5035         if (DEBUGLEVEL >= 10) {
5036                 NDR_PRINT_OUT_DEBUG(spoolss_ResetPrinterEx, r);
5037         }
5038
5039         push = ndr_push_init_ctx(r, NULL);
5040         if (push == NULL) {
5041                 talloc_free(r);
5042                 return false;
5043         }
5044
5045         ndr_err = call->ndr_push(push, NDR_OUT, r);
5046         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5047                 talloc_free(r);
5048                 return false;
5049         }
5050
5051         blob = ndr_push_blob(push);
5052         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5053                 talloc_free(r);
5054                 return false;
5055         }
5056
5057         talloc_free(r);
5058
5059         return true;
5060 }
5061
5062 static bool api_spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct *p)
5063 {
5064         const struct ndr_interface_call *call;
5065         struct ndr_pull *pull;
5066         struct ndr_push *push;
5067         enum ndr_err_code ndr_err;
5068         DATA_BLOB blob;
5069         struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r;
5070
5071         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX];
5072
5073         r = talloc(talloc_tos(), struct spoolss_RemoteFindFirstPrinterChangeNotifyEx);
5074         if (r == NULL) {
5075                 return false;
5076         }
5077
5078         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5079                 talloc_free(r);
5080                 return false;
5081         }
5082
5083         pull = ndr_pull_init_blob(&blob, r, NULL);
5084         if (pull == NULL) {
5085                 talloc_free(r);
5086                 return false;
5087         }
5088
5089         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5090         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5091         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5092                 talloc_free(r);
5093                 return false;
5094         }
5095
5096         if (DEBUGLEVEL >= 10) {
5097                 NDR_PRINT_IN_DEBUG(spoolss_RemoteFindFirstPrinterChangeNotifyEx, r);
5098         }
5099
5100         r->out.result = _spoolss_RemoteFindFirstPrinterChangeNotifyEx(p, r);
5101
5102         if (p->rng_fault_state) {
5103                 talloc_free(r);
5104                 /* Return true here, srv_pipe_hnd.c will take care */
5105                 return true;
5106         }
5107
5108         if (DEBUGLEVEL >= 10) {
5109                 NDR_PRINT_OUT_DEBUG(spoolss_RemoteFindFirstPrinterChangeNotifyEx, r);
5110         }
5111
5112         push = ndr_push_init_ctx(r, NULL);
5113         if (push == NULL) {
5114                 talloc_free(r);
5115                 return false;
5116         }
5117
5118         ndr_err = call->ndr_push(push, NDR_OUT, r);
5119         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5120                 talloc_free(r);
5121                 return false;
5122         }
5123
5124         blob = ndr_push_blob(push);
5125         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5126                 talloc_free(r);
5127                 return false;
5128         }
5129
5130         talloc_free(r);
5131
5132         return true;
5133 }
5134
5135 static bool api_spoolss_RouterReplyPrinterEx(pipes_struct *p)
5136 {
5137         const struct ndr_interface_call *call;
5138         struct ndr_pull *pull;
5139         struct ndr_push *push;
5140         enum ndr_err_code ndr_err;
5141         DATA_BLOB blob;
5142         struct spoolss_RouterReplyPrinterEx *r;
5143
5144         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ROUTERREPLYPRINTEREX];
5145
5146         r = talloc(talloc_tos(), struct spoolss_RouterReplyPrinterEx);
5147         if (r == NULL) {
5148                 return false;
5149         }
5150
5151         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5152                 talloc_free(r);
5153                 return false;
5154         }
5155
5156         pull = ndr_pull_init_blob(&blob, r, NULL);
5157         if (pull == NULL) {
5158                 talloc_free(r);
5159                 return false;
5160         }
5161
5162         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5163         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5164         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5165                 talloc_free(r);
5166                 return false;
5167         }
5168
5169         if (DEBUGLEVEL >= 10) {
5170                 NDR_PRINT_IN_DEBUG(spoolss_RouterReplyPrinterEx, r);
5171         }
5172
5173         ZERO_STRUCT(r->out);
5174         r->out.reply_result = talloc_zero(r, uint32_t);
5175         if (r->out.reply_result == NULL) {
5176                 talloc_free(r);
5177                 return false;
5178         }
5179
5180         r->out.result = _spoolss_RouterReplyPrinterEx(p, r);
5181
5182         if (p->rng_fault_state) {
5183                 talloc_free(r);
5184                 /* Return true here, srv_pipe_hnd.c will take care */
5185                 return true;
5186         }
5187
5188         if (DEBUGLEVEL >= 10) {
5189                 NDR_PRINT_OUT_DEBUG(spoolss_RouterReplyPrinterEx, r);
5190         }
5191
5192         push = ndr_push_init_ctx(r, NULL);
5193         if (push == NULL) {
5194                 talloc_free(r);
5195                 return false;
5196         }
5197
5198         ndr_err = call->ndr_push(push, NDR_OUT, r);
5199         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5200                 talloc_free(r);
5201                 return false;
5202         }
5203
5204         blob = ndr_push_blob(push);
5205         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5206                 talloc_free(r);
5207                 return false;
5208         }
5209
5210         talloc_free(r);
5211
5212         return true;
5213 }
5214
5215 static bool api_spoolss_RouterRefreshPrinterChangeNotify(pipes_struct *p)
5216 {
5217         const struct ndr_interface_call *call;
5218         struct ndr_pull *pull;
5219         struct ndr_push *push;
5220         enum ndr_err_code ndr_err;
5221         DATA_BLOB blob;
5222         struct spoolss_RouterRefreshPrinterChangeNotify *r;
5223
5224         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY];
5225
5226         r = talloc(talloc_tos(), struct spoolss_RouterRefreshPrinterChangeNotify);
5227         if (r == NULL) {
5228                 return false;
5229         }
5230
5231         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5232                 talloc_free(r);
5233                 return false;
5234         }
5235
5236         pull = ndr_pull_init_blob(&blob, r, NULL);
5237         if (pull == NULL) {
5238                 talloc_free(r);
5239                 return false;
5240         }
5241
5242         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5243         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5244         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5245                 talloc_free(r);
5246                 return false;
5247         }
5248
5249         if (DEBUGLEVEL >= 10) {
5250                 NDR_PRINT_IN_DEBUG(spoolss_RouterRefreshPrinterChangeNotify, r);
5251         }
5252
5253         ZERO_STRUCT(r->out);
5254         r->out.info = talloc_zero(r, struct spoolss_NotifyInfo *);
5255         if (r->out.info == NULL) {
5256                 talloc_free(r);
5257                 return false;
5258         }
5259
5260         r->out.result = _spoolss_RouterRefreshPrinterChangeNotify(p, r);
5261
5262         if (p->rng_fault_state) {
5263                 talloc_free(r);
5264                 /* Return true here, srv_pipe_hnd.c will take care */
5265                 return true;
5266         }
5267
5268         if (DEBUGLEVEL >= 10) {
5269                 NDR_PRINT_OUT_DEBUG(spoolss_RouterRefreshPrinterChangeNotify, r);
5270         }
5271
5272         push = ndr_push_init_ctx(r, NULL);
5273         if (push == NULL) {
5274                 talloc_free(r);
5275                 return false;
5276         }
5277
5278         ndr_err = call->ndr_push(push, NDR_OUT, r);
5279         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5280                 talloc_free(r);
5281                 return false;
5282         }
5283
5284         blob = ndr_push_blob(push);
5285         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5286                 talloc_free(r);
5287                 return false;
5288         }
5289
5290         talloc_free(r);
5291
5292         return true;
5293 }
5294
5295 static bool api_spoolss_44(pipes_struct *p)
5296 {
5297         const struct ndr_interface_call *call;
5298         struct ndr_pull *pull;
5299         struct ndr_push *push;
5300         enum ndr_err_code ndr_err;
5301         DATA_BLOB blob;
5302         struct spoolss_44 *r;
5303
5304         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_44];
5305
5306         r = talloc(talloc_tos(), struct spoolss_44);
5307         if (r == NULL) {
5308                 return false;
5309         }
5310
5311         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5312                 talloc_free(r);
5313                 return false;
5314         }
5315
5316         pull = ndr_pull_init_blob(&blob, r, NULL);
5317         if (pull == NULL) {
5318                 talloc_free(r);
5319                 return false;
5320         }
5321
5322         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5323         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5324         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5325                 talloc_free(r);
5326                 return false;
5327         }
5328
5329         if (DEBUGLEVEL >= 10) {
5330                 NDR_PRINT_IN_DEBUG(spoolss_44, r);
5331         }
5332
5333         r->out.result = _spoolss_44(p, r);
5334
5335         if (p->rng_fault_state) {
5336                 talloc_free(r);
5337                 /* Return true here, srv_pipe_hnd.c will take care */
5338                 return true;
5339         }
5340
5341         if (DEBUGLEVEL >= 10) {
5342                 NDR_PRINT_OUT_DEBUG(spoolss_44, r);
5343         }
5344
5345         push = ndr_push_init_ctx(r, NULL);
5346         if (push == NULL) {
5347                 talloc_free(r);
5348                 return false;
5349         }
5350
5351         ndr_err = call->ndr_push(push, NDR_OUT, r);
5352         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5353                 talloc_free(r);
5354                 return false;
5355         }
5356
5357         blob = ndr_push_blob(push);
5358         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5359                 talloc_free(r);
5360                 return false;
5361         }
5362
5363         talloc_free(r);
5364
5365         return true;
5366 }
5367
5368 static bool api_spoolss_OpenPrinterEx(pipes_struct *p)
5369 {
5370         const struct ndr_interface_call *call;
5371         struct ndr_pull *pull;
5372         struct ndr_push *push;
5373         enum ndr_err_code ndr_err;
5374         DATA_BLOB blob;
5375         struct spoolss_OpenPrinterEx *r;
5376
5377         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_OPENPRINTEREX];
5378
5379         r = talloc(talloc_tos(), struct spoolss_OpenPrinterEx);
5380         if (r == NULL) {
5381                 return false;
5382         }
5383
5384         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5385                 talloc_free(r);
5386                 return false;
5387         }
5388
5389         pull = ndr_pull_init_blob(&blob, r, NULL);
5390         if (pull == NULL) {
5391                 talloc_free(r);
5392                 return false;
5393         }
5394
5395         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5396         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5397         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5398                 talloc_free(r);
5399                 return false;
5400         }
5401
5402         if (DEBUGLEVEL >= 10) {
5403                 NDR_PRINT_IN_DEBUG(spoolss_OpenPrinterEx, r);
5404         }
5405
5406         ZERO_STRUCT(r->out);
5407         r->out.handle = talloc_zero(r, struct policy_handle);
5408         if (r->out.handle == NULL) {
5409                 talloc_free(r);
5410                 return false;
5411         }
5412
5413         r->out.result = _spoolss_OpenPrinterEx(p, r);
5414
5415         if (p->rng_fault_state) {
5416                 talloc_free(r);
5417                 /* Return true here, srv_pipe_hnd.c will take care */
5418                 return true;
5419         }
5420
5421         if (DEBUGLEVEL >= 10) {
5422                 NDR_PRINT_OUT_DEBUG(spoolss_OpenPrinterEx, r);
5423         }
5424
5425         push = ndr_push_init_ctx(r, NULL);
5426         if (push == NULL) {
5427                 talloc_free(r);
5428                 return false;
5429         }
5430
5431         ndr_err = call->ndr_push(push, NDR_OUT, r);
5432         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5433                 talloc_free(r);
5434                 return false;
5435         }
5436
5437         blob = ndr_push_blob(push);
5438         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5439                 talloc_free(r);
5440                 return false;
5441         }
5442
5443         talloc_free(r);
5444
5445         return true;
5446 }
5447
5448 static bool api_spoolss_AddPrinterEx(pipes_struct *p)
5449 {
5450         const struct ndr_interface_call *call;
5451         struct ndr_pull *pull;
5452         struct ndr_push *push;
5453         enum ndr_err_code ndr_err;
5454         DATA_BLOB blob;
5455         struct spoolss_AddPrinterEx *r;
5456
5457         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTEREX];
5458
5459         r = talloc(talloc_tos(), struct spoolss_AddPrinterEx);
5460         if (r == NULL) {
5461                 return false;
5462         }
5463
5464         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5465                 talloc_free(r);
5466                 return false;
5467         }
5468
5469         pull = ndr_pull_init_blob(&blob, r, NULL);
5470         if (pull == NULL) {
5471                 talloc_free(r);
5472                 return false;
5473         }
5474
5475         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5476         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5477         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5478                 talloc_free(r);
5479                 return false;
5480         }
5481
5482         if (DEBUGLEVEL >= 10) {
5483                 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterEx, r);
5484         }
5485
5486         ZERO_STRUCT(r->out);
5487         r->out.handle = talloc_zero(r, struct policy_handle);
5488         if (r->out.handle == NULL) {
5489                 talloc_free(r);
5490                 return false;
5491         }
5492
5493         r->out.result = _spoolss_AddPrinterEx(p, r);
5494
5495         if (p->rng_fault_state) {
5496                 talloc_free(r);
5497                 /* Return true here, srv_pipe_hnd.c will take care */
5498                 return true;
5499         }
5500
5501         if (DEBUGLEVEL >= 10) {
5502                 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterEx, r);
5503         }
5504
5505         push = ndr_push_init_ctx(r, NULL);
5506         if (push == NULL) {
5507                 talloc_free(r);
5508                 return false;
5509         }
5510
5511         ndr_err = call->ndr_push(push, NDR_OUT, r);
5512         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5513                 talloc_free(r);
5514                 return false;
5515         }
5516
5517         blob = ndr_push_blob(push);
5518         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5519                 talloc_free(r);
5520                 return false;
5521         }
5522
5523         talloc_free(r);
5524
5525         return true;
5526 }
5527
5528 static bool api_spoolss_47(pipes_struct *p)
5529 {
5530         const struct ndr_interface_call *call;
5531         struct ndr_pull *pull;
5532         struct ndr_push *push;
5533         enum ndr_err_code ndr_err;
5534         DATA_BLOB blob;
5535         struct spoolss_47 *r;
5536
5537         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_47];
5538
5539         r = talloc(talloc_tos(), struct spoolss_47);
5540         if (r == NULL) {
5541                 return false;
5542         }
5543
5544         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5545                 talloc_free(r);
5546                 return false;
5547         }
5548
5549         pull = ndr_pull_init_blob(&blob, r, NULL);
5550         if (pull == NULL) {
5551                 talloc_free(r);
5552                 return false;
5553         }
5554
5555         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5556         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5557         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5558                 talloc_free(r);
5559                 return false;
5560         }
5561
5562         if (DEBUGLEVEL >= 10) {
5563                 NDR_PRINT_IN_DEBUG(spoolss_47, r);
5564         }
5565
5566         r->out.result = _spoolss_47(p, r);
5567
5568         if (p->rng_fault_state) {
5569                 talloc_free(r);
5570                 /* Return true here, srv_pipe_hnd.c will take care */
5571                 return true;
5572         }
5573
5574         if (DEBUGLEVEL >= 10) {
5575                 NDR_PRINT_OUT_DEBUG(spoolss_47, r);
5576         }
5577
5578         push = ndr_push_init_ctx(r, NULL);
5579         if (push == NULL) {
5580                 talloc_free(r);
5581                 return false;
5582         }
5583
5584         ndr_err = call->ndr_push(push, NDR_OUT, r);
5585         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5586                 talloc_free(r);
5587                 return false;
5588         }
5589
5590         blob = ndr_push_blob(push);
5591         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5592                 talloc_free(r);
5593                 return false;
5594         }
5595
5596         talloc_free(r);
5597
5598         return true;
5599 }
5600
5601 static bool api_spoolss_EnumPrinterData(pipes_struct *p)
5602 {
5603         const struct ndr_interface_call *call;
5604         struct ndr_pull *pull;
5605         struct ndr_push *push;
5606         enum ndr_err_code ndr_err;
5607         DATA_BLOB blob;
5608         struct spoolss_EnumPrinterData *r;
5609
5610         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPRINTERDATA];
5611
5612         r = talloc(talloc_tos(), struct spoolss_EnumPrinterData);
5613         if (r == NULL) {
5614                 return false;
5615         }
5616
5617         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5618                 talloc_free(r);
5619                 return false;
5620         }
5621
5622         pull = ndr_pull_init_blob(&blob, r, NULL);
5623         if (pull == NULL) {
5624                 talloc_free(r);
5625                 return false;
5626         }
5627
5628         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5629         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5630         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5631                 talloc_free(r);
5632                 return false;
5633         }
5634
5635         if (DEBUGLEVEL >= 10) {
5636                 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterData, r);
5637         }
5638
5639         ZERO_STRUCT(r->out);
5640         r->out.value_name = talloc_zero_array(r, const char, r->in.value_offered / 2);
5641         if (r->out.value_name == NULL) {
5642                 talloc_free(r);
5643                 return false;
5644         }
5645
5646         r->out.value_needed = talloc_zero(r, uint32_t);
5647         if (r->out.value_needed == NULL) {
5648                 talloc_free(r);
5649                 return false;
5650         }
5651
5652         r->out.printerdata_type = talloc_zero(r, uint32_t);
5653         if (r->out.printerdata_type == NULL) {
5654                 talloc_free(r);
5655                 return false;
5656         }
5657
5658         r->out.buffer = talloc_zero(r, DATA_BLOB);
5659         if (r->out.buffer == NULL) {
5660                 talloc_free(r);
5661                 return false;
5662         }
5663
5664         r->out.data_needed = talloc_zero(r, uint32_t);
5665         if (r->out.data_needed == NULL) {
5666                 talloc_free(r);
5667                 return false;
5668         }
5669
5670         r->out.result = _spoolss_EnumPrinterData(p, r);
5671
5672         if (p->rng_fault_state) {
5673                 talloc_free(r);
5674                 /* Return true here, srv_pipe_hnd.c will take care */
5675                 return true;
5676         }
5677
5678         if (DEBUGLEVEL >= 10) {
5679                 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterData, r);
5680         }
5681
5682         push = ndr_push_init_ctx(r, NULL);
5683         if (push == NULL) {
5684                 talloc_free(r);
5685                 return false;
5686         }
5687
5688         ndr_err = call->ndr_push(push, NDR_OUT, r);
5689         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5690                 talloc_free(r);
5691                 return false;
5692         }
5693
5694         blob = ndr_push_blob(push);
5695         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5696                 talloc_free(r);
5697                 return false;
5698         }
5699
5700         talloc_free(r);
5701
5702         return true;
5703 }
5704
5705 static bool api_spoolss_DeletePrinterData(pipes_struct *p)
5706 {
5707         const struct ndr_interface_call *call;
5708         struct ndr_pull *pull;
5709         struct ndr_push *push;
5710         enum ndr_err_code ndr_err;
5711         DATA_BLOB blob;
5712         struct spoolss_DeletePrinterData *r;
5713
5714         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERDATA];
5715
5716         r = talloc(talloc_tos(), struct spoolss_DeletePrinterData);
5717         if (r == NULL) {
5718                 return false;
5719         }
5720
5721         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5722                 talloc_free(r);
5723                 return false;
5724         }
5725
5726         pull = ndr_pull_init_blob(&blob, r, NULL);
5727         if (pull == NULL) {
5728                 talloc_free(r);
5729                 return false;
5730         }
5731
5732         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5733         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5734         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5735                 talloc_free(r);
5736                 return false;
5737         }
5738
5739         if (DEBUGLEVEL >= 10) {
5740                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterData, r);
5741         }
5742
5743         r->out.result = _spoolss_DeletePrinterData(p, r);
5744
5745         if (p->rng_fault_state) {
5746                 talloc_free(r);
5747                 /* Return true here, srv_pipe_hnd.c will take care */
5748                 return true;
5749         }
5750
5751         if (DEBUGLEVEL >= 10) {
5752                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterData, r);
5753         }
5754
5755         push = ndr_push_init_ctx(r, NULL);
5756         if (push == NULL) {
5757                 talloc_free(r);
5758                 return false;
5759         }
5760
5761         ndr_err = call->ndr_push(push, NDR_OUT, r);
5762         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5763                 talloc_free(r);
5764                 return false;
5765         }
5766
5767         blob = ndr_push_blob(push);
5768         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5769                 talloc_free(r);
5770                 return false;
5771         }
5772
5773         talloc_free(r);
5774
5775         return true;
5776 }
5777
5778 static bool api_spoolss_4a(pipes_struct *p)
5779 {
5780         const struct ndr_interface_call *call;
5781         struct ndr_pull *pull;
5782         struct ndr_push *push;
5783         enum ndr_err_code ndr_err;
5784         DATA_BLOB blob;
5785         struct spoolss_4a *r;
5786
5787         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_4A];
5788
5789         r = talloc(talloc_tos(), struct spoolss_4a);
5790         if (r == NULL) {
5791                 return false;
5792         }
5793
5794         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5795                 talloc_free(r);
5796                 return false;
5797         }
5798
5799         pull = ndr_pull_init_blob(&blob, r, NULL);
5800         if (pull == NULL) {
5801                 talloc_free(r);
5802                 return false;
5803         }
5804
5805         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5806         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5807         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5808                 talloc_free(r);
5809                 return false;
5810         }
5811
5812         if (DEBUGLEVEL >= 10) {
5813                 NDR_PRINT_IN_DEBUG(spoolss_4a, r);
5814         }
5815
5816         r->out.result = _spoolss_4a(p, r);
5817
5818         if (p->rng_fault_state) {
5819                 talloc_free(r);
5820                 /* Return true here, srv_pipe_hnd.c will take care */
5821                 return true;
5822         }
5823
5824         if (DEBUGLEVEL >= 10) {
5825                 NDR_PRINT_OUT_DEBUG(spoolss_4a, r);
5826         }
5827
5828         push = ndr_push_init_ctx(r, NULL);
5829         if (push == NULL) {
5830                 talloc_free(r);
5831                 return false;
5832         }
5833
5834         ndr_err = call->ndr_push(push, NDR_OUT, r);
5835         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5836                 talloc_free(r);
5837                 return false;
5838         }
5839
5840         blob = ndr_push_blob(push);
5841         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5842                 talloc_free(r);
5843                 return false;
5844         }
5845
5846         talloc_free(r);
5847
5848         return true;
5849 }
5850
5851 static bool api_spoolss_4b(pipes_struct *p)
5852 {
5853         const struct ndr_interface_call *call;
5854         struct ndr_pull *pull;
5855         struct ndr_push *push;
5856         enum ndr_err_code ndr_err;
5857         DATA_BLOB blob;
5858         struct spoolss_4b *r;
5859
5860         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_4B];
5861
5862         r = talloc(talloc_tos(), struct spoolss_4b);
5863         if (r == NULL) {
5864                 return false;
5865         }
5866
5867         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5868                 talloc_free(r);
5869                 return false;
5870         }
5871
5872         pull = ndr_pull_init_blob(&blob, r, NULL);
5873         if (pull == NULL) {
5874                 talloc_free(r);
5875                 return false;
5876         }
5877
5878         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5879         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5880         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5881                 talloc_free(r);
5882                 return false;
5883         }
5884
5885         if (DEBUGLEVEL >= 10) {
5886                 NDR_PRINT_IN_DEBUG(spoolss_4b, r);
5887         }
5888
5889         r->out.result = _spoolss_4b(p, r);
5890
5891         if (p->rng_fault_state) {
5892                 talloc_free(r);
5893                 /* Return true here, srv_pipe_hnd.c will take care */
5894                 return true;
5895         }
5896
5897         if (DEBUGLEVEL >= 10) {
5898                 NDR_PRINT_OUT_DEBUG(spoolss_4b, r);
5899         }
5900
5901         push = ndr_push_init_ctx(r, NULL);
5902         if (push == NULL) {
5903                 talloc_free(r);
5904                 return false;
5905         }
5906
5907         ndr_err = call->ndr_push(push, NDR_OUT, r);
5908         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5909                 talloc_free(r);
5910                 return false;
5911         }
5912
5913         blob = ndr_push_blob(push);
5914         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5915                 talloc_free(r);
5916                 return false;
5917         }
5918
5919         talloc_free(r);
5920
5921         return true;
5922 }
5923
5924 static bool api_spoolss_4c(pipes_struct *p)
5925 {
5926         const struct ndr_interface_call *call;
5927         struct ndr_pull *pull;
5928         struct ndr_push *push;
5929         enum ndr_err_code ndr_err;
5930         DATA_BLOB blob;
5931         struct spoolss_4c *r;
5932
5933         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_4C];
5934
5935         r = talloc(talloc_tos(), struct spoolss_4c);
5936         if (r == NULL) {
5937                 return false;
5938         }
5939
5940         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5941                 talloc_free(r);
5942                 return false;
5943         }
5944
5945         pull = ndr_pull_init_blob(&blob, r, NULL);
5946         if (pull == NULL) {
5947                 talloc_free(r);
5948                 return false;
5949         }
5950
5951         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5952         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5953         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5954                 talloc_free(r);
5955                 return false;
5956         }
5957
5958         if (DEBUGLEVEL >= 10) {
5959                 NDR_PRINT_IN_DEBUG(spoolss_4c, r);
5960         }
5961
5962         r->out.result = _spoolss_4c(p, r);
5963
5964         if (p->rng_fault_state) {
5965                 talloc_free(r);
5966                 /* Return true here, srv_pipe_hnd.c will take care */
5967                 return true;
5968         }
5969
5970         if (DEBUGLEVEL >= 10) {
5971                 NDR_PRINT_OUT_DEBUG(spoolss_4c, r);
5972         }
5973
5974         push = ndr_push_init_ctx(r, NULL);
5975         if (push == NULL) {
5976                 talloc_free(r);
5977                 return false;
5978         }
5979
5980         ndr_err = call->ndr_push(push, NDR_OUT, r);
5981         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5982                 talloc_free(r);
5983                 return false;
5984         }
5985
5986         blob = ndr_push_blob(push);
5987         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5988                 talloc_free(r);
5989                 return false;
5990         }
5991
5992         talloc_free(r);
5993
5994         return true;
5995 }
5996
5997 static bool api_spoolss_SetPrinterDataEx(pipes_struct *p)
5998 {
5999         const struct ndr_interface_call *call;
6000         struct ndr_pull *pull;
6001         struct ndr_push *push;
6002         enum ndr_err_code ndr_err;
6003         DATA_BLOB blob;
6004         struct spoolss_SetPrinterDataEx *r;
6005
6006         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_SETPRINTERDATAEX];
6007
6008         r = talloc(talloc_tos(), struct spoolss_SetPrinterDataEx);
6009         if (r == NULL) {
6010                 return false;
6011         }
6012
6013         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6014                 talloc_free(r);
6015                 return false;
6016         }
6017
6018         pull = ndr_pull_init_blob(&blob, r, NULL);
6019         if (pull == NULL) {
6020                 talloc_free(r);
6021                 return false;
6022         }
6023
6024         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6025         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6026         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6027                 talloc_free(r);
6028                 return false;
6029         }
6030
6031         if (DEBUGLEVEL >= 10) {
6032                 NDR_PRINT_IN_DEBUG(spoolss_SetPrinterDataEx, r);
6033         }
6034
6035         r->out.result = _spoolss_SetPrinterDataEx(p, r);
6036
6037         if (p->rng_fault_state) {
6038                 talloc_free(r);
6039                 /* Return true here, srv_pipe_hnd.c will take care */
6040                 return true;
6041         }
6042
6043         if (DEBUGLEVEL >= 10) {
6044                 NDR_PRINT_OUT_DEBUG(spoolss_SetPrinterDataEx, r);
6045         }
6046
6047         push = ndr_push_init_ctx(r, NULL);
6048         if (push == NULL) {
6049                 talloc_free(r);
6050                 return false;
6051         }
6052
6053         ndr_err = call->ndr_push(push, NDR_OUT, r);
6054         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6055                 talloc_free(r);
6056                 return false;
6057         }
6058
6059         blob = ndr_push_blob(push);
6060         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6061                 talloc_free(r);
6062                 return false;
6063         }
6064
6065         talloc_free(r);
6066
6067         return true;
6068 }
6069
6070 static bool api_spoolss_GetPrinterDataEx(pipes_struct *p)
6071 {
6072         const struct ndr_interface_call *call;
6073         struct ndr_pull *pull;
6074         struct ndr_push *push;
6075         enum ndr_err_code ndr_err;
6076         DATA_BLOB blob;
6077         struct spoolss_GetPrinterDataEx *r;
6078
6079         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTERDATAEX];
6080
6081         r = talloc(talloc_tos(), struct spoolss_GetPrinterDataEx);
6082         if (r == NULL) {
6083                 return false;
6084         }
6085
6086         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6087                 talloc_free(r);
6088                 return false;
6089         }
6090
6091         pull = ndr_pull_init_blob(&blob, r, NULL);
6092         if (pull == NULL) {
6093                 talloc_free(r);
6094                 return false;
6095         }
6096
6097         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6098         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6099         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6100                 talloc_free(r);
6101                 return false;
6102         }
6103
6104         if (DEBUGLEVEL >= 10) {
6105                 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDataEx, r);
6106         }
6107
6108         ZERO_STRUCT(r->out);
6109         r->out.type = talloc_zero(r, uint32_t);
6110         if (r->out.type == NULL) {
6111                 talloc_free(r);
6112                 return false;
6113         }
6114
6115         r->out.buffer = talloc_zero_array(r, uint8_t, r->in.offered);
6116         if (r->out.buffer == NULL) {
6117                 talloc_free(r);
6118                 return false;
6119         }
6120
6121         r->out.needed = talloc_zero(r, uint32_t);
6122         if (r->out.needed == NULL) {
6123                 talloc_free(r);
6124                 return false;
6125         }
6126
6127         r->out.result = _spoolss_GetPrinterDataEx(p, r);
6128
6129         if (p->rng_fault_state) {
6130                 talloc_free(r);
6131                 /* Return true here, srv_pipe_hnd.c will take care */
6132                 return true;
6133         }
6134
6135         if (DEBUGLEVEL >= 10) {
6136                 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDataEx, r);
6137         }
6138
6139         push = ndr_push_init_ctx(r, NULL);
6140         if (push == NULL) {
6141                 talloc_free(r);
6142                 return false;
6143         }
6144
6145         ndr_err = call->ndr_push(push, NDR_OUT, r);
6146         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6147                 talloc_free(r);
6148                 return false;
6149         }
6150
6151         blob = ndr_push_blob(push);
6152         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6153                 talloc_free(r);
6154                 return false;
6155         }
6156
6157         talloc_free(r);
6158
6159         return true;
6160 }
6161
6162 static bool api_spoolss_EnumPrinterDataEx(pipes_struct *p)
6163 {
6164         const struct ndr_interface_call *call;
6165         struct ndr_pull *pull;
6166         struct ndr_push *push;
6167         enum ndr_err_code ndr_err;
6168         DATA_BLOB blob;
6169         struct spoolss_EnumPrinterDataEx *r;
6170
6171         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPRINTERDATAEX];
6172
6173         r = talloc(talloc_tos(), struct spoolss_EnumPrinterDataEx);
6174         if (r == NULL) {
6175                 return false;
6176         }
6177
6178         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6179                 talloc_free(r);
6180                 return false;
6181         }
6182
6183         pull = ndr_pull_init_blob(&blob, r, NULL);
6184         if (pull == NULL) {
6185                 talloc_free(r);
6186                 return false;
6187         }
6188
6189         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6190         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6191         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6192                 talloc_free(r);
6193                 return false;
6194         }
6195
6196         if (DEBUGLEVEL >= 10) {
6197                 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterDataEx, r);
6198         }
6199
6200         ZERO_STRUCT(r->out);
6201         r->out.buffer = talloc_zero_array(r, uint8_t, r->in.offered);
6202         if (r->out.buffer == NULL) {
6203                 talloc_free(r);
6204                 return false;
6205         }
6206
6207         r->out.needed = talloc_zero(r, uint32_t);
6208         if (r->out.needed == NULL) {
6209                 talloc_free(r);
6210                 return false;
6211         }
6212
6213         r->out.count = talloc_zero(r, uint32_t);
6214         if (r->out.count == NULL) {
6215                 talloc_free(r);
6216                 return false;
6217         }
6218
6219         r->out.result = _spoolss_EnumPrinterDataEx(p, r);
6220
6221         if (p->rng_fault_state) {
6222                 talloc_free(r);
6223                 /* Return true here, srv_pipe_hnd.c will take care */
6224                 return true;
6225         }
6226
6227         if (DEBUGLEVEL >= 10) {
6228                 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterDataEx, r);
6229         }
6230
6231         push = ndr_push_init_ctx(r, NULL);
6232         if (push == NULL) {
6233                 talloc_free(r);
6234                 return false;
6235         }
6236
6237         ndr_err = call->ndr_push(push, NDR_OUT, r);
6238         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6239                 talloc_free(r);
6240                 return false;
6241         }
6242
6243         blob = ndr_push_blob(push);
6244         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6245                 talloc_free(r);
6246                 return false;
6247         }
6248
6249         talloc_free(r);
6250
6251         return true;
6252 }
6253
6254 static bool api_spoolss_EnumPrinterKey(pipes_struct *p)
6255 {
6256         const struct ndr_interface_call *call;
6257         struct ndr_pull *pull;
6258         struct ndr_push *push;
6259         enum ndr_err_code ndr_err;
6260         DATA_BLOB blob;
6261         struct spoolss_EnumPrinterKey *r;
6262
6263         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPRINTERKEY];
6264
6265         r = talloc(talloc_tos(), struct spoolss_EnumPrinterKey);
6266         if (r == NULL) {
6267                 return false;
6268         }
6269
6270         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6271                 talloc_free(r);
6272                 return false;
6273         }
6274
6275         pull = ndr_pull_init_blob(&blob, r, NULL);
6276         if (pull == NULL) {
6277                 talloc_free(r);
6278                 return false;
6279         }
6280
6281         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6282         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6283         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6284                 talloc_free(r);
6285                 return false;
6286         }
6287
6288         if (DEBUGLEVEL >= 10) {
6289                 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterKey, r);
6290         }
6291
6292         ZERO_STRUCT(r->out);
6293         r->out.key_buffer = talloc_zero_array(r, uint16_t, r->in.key_buffer_size / 2);
6294         if (r->out.key_buffer == NULL) {
6295                 talloc_free(r);
6296                 return false;
6297         }
6298
6299         r->out.needed = talloc_zero(r, uint32_t);
6300         if (r->out.needed == NULL) {
6301                 talloc_free(r);
6302                 return false;
6303         }
6304
6305         r->out.result = _spoolss_EnumPrinterKey(p, r);
6306
6307         if (p->rng_fault_state) {
6308                 talloc_free(r);
6309                 /* Return true here, srv_pipe_hnd.c will take care */
6310                 return true;
6311         }
6312
6313         if (DEBUGLEVEL >= 10) {
6314                 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterKey, r);
6315         }
6316
6317         push = ndr_push_init_ctx(r, NULL);
6318         if (push == NULL) {
6319                 talloc_free(r);
6320                 return false;
6321         }
6322
6323         ndr_err = call->ndr_push(push, NDR_OUT, r);
6324         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6325                 talloc_free(r);
6326                 return false;
6327         }
6328
6329         blob = ndr_push_blob(push);
6330         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6331                 talloc_free(r);
6332                 return false;
6333         }
6334
6335         talloc_free(r);
6336
6337         return true;
6338 }
6339
6340 static bool api_spoolss_DeletePrinterDataEx(pipes_struct *p)
6341 {
6342         const struct ndr_interface_call *call;
6343         struct ndr_pull *pull;
6344         struct ndr_push *push;
6345         enum ndr_err_code ndr_err;
6346         DATA_BLOB blob;
6347         struct spoolss_DeletePrinterDataEx *r;
6348
6349         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERDATAEX];
6350
6351         r = talloc(talloc_tos(), struct spoolss_DeletePrinterDataEx);
6352         if (r == NULL) {
6353                 return false;
6354         }
6355
6356         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6357                 talloc_free(r);
6358                 return false;
6359         }
6360
6361         pull = ndr_pull_init_blob(&blob, r, NULL);
6362         if (pull == NULL) {
6363                 talloc_free(r);
6364                 return false;
6365         }
6366
6367         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6368         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6369         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6370                 talloc_free(r);
6371                 return false;
6372         }
6373
6374         if (DEBUGLEVEL >= 10) {
6375                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDataEx, r);
6376         }
6377
6378         r->out.result = _spoolss_DeletePrinterDataEx(p, r);
6379
6380         if (p->rng_fault_state) {
6381                 talloc_free(r);
6382                 /* Return true here, srv_pipe_hnd.c will take care */
6383                 return true;
6384         }
6385
6386         if (DEBUGLEVEL >= 10) {
6387                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDataEx, r);
6388         }
6389
6390         push = ndr_push_init_ctx(r, NULL);
6391         if (push == NULL) {
6392                 talloc_free(r);
6393                 return false;
6394         }
6395
6396         ndr_err = call->ndr_push(push, NDR_OUT, r);
6397         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6398                 talloc_free(r);
6399                 return false;
6400         }
6401
6402         blob = ndr_push_blob(push);
6403         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6404                 talloc_free(r);
6405                 return false;
6406         }
6407
6408         talloc_free(r);
6409
6410         return true;
6411 }
6412
6413 static bool api_spoolss_DeletePrinterKey(pipes_struct *p)
6414 {
6415         const struct ndr_interface_call *call;
6416         struct ndr_pull *pull;
6417         struct ndr_push *push;
6418         enum ndr_err_code ndr_err;
6419         DATA_BLOB blob;
6420         struct spoolss_DeletePrinterKey *r;
6421
6422         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERKEY];
6423
6424         r = talloc(talloc_tos(), struct spoolss_DeletePrinterKey);
6425         if (r == NULL) {
6426                 return false;
6427         }
6428
6429         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6430                 talloc_free(r);
6431                 return false;
6432         }
6433
6434         pull = ndr_pull_init_blob(&blob, r, NULL);
6435         if (pull == NULL) {
6436                 talloc_free(r);
6437                 return false;
6438         }
6439
6440         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6441         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6442         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6443                 talloc_free(r);
6444                 return false;
6445         }
6446
6447         if (DEBUGLEVEL >= 10) {
6448                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterKey, r);
6449         }
6450
6451         r->out.result = _spoolss_DeletePrinterKey(p, r);
6452
6453         if (p->rng_fault_state) {
6454                 talloc_free(r);
6455                 /* Return true here, srv_pipe_hnd.c will take care */
6456                 return true;
6457         }
6458
6459         if (DEBUGLEVEL >= 10) {
6460                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterKey, r);
6461         }
6462
6463         push = ndr_push_init_ctx(r, NULL);
6464         if (push == NULL) {
6465                 talloc_free(r);
6466                 return false;
6467         }
6468
6469         ndr_err = call->ndr_push(push, NDR_OUT, r);
6470         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6471                 talloc_free(r);
6472                 return false;
6473         }
6474
6475         blob = ndr_push_blob(push);
6476         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6477                 talloc_free(r);
6478                 return false;
6479         }
6480
6481         talloc_free(r);
6482
6483         return true;
6484 }
6485
6486 static bool api_spoolss_53(pipes_struct *p)
6487 {
6488         const struct ndr_interface_call *call;
6489         struct ndr_pull *pull;
6490         struct ndr_push *push;
6491         enum ndr_err_code ndr_err;
6492         DATA_BLOB blob;
6493         struct spoolss_53 *r;
6494
6495         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_53];
6496
6497         r = talloc(talloc_tos(), struct spoolss_53);
6498         if (r == NULL) {
6499                 return false;
6500         }
6501
6502         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6503                 talloc_free(r);
6504                 return false;
6505         }
6506
6507         pull = ndr_pull_init_blob(&blob, r, NULL);
6508         if (pull == NULL) {
6509                 talloc_free(r);
6510                 return false;
6511         }
6512
6513         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6514         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6515         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6516                 talloc_free(r);
6517                 return false;
6518         }
6519
6520         if (DEBUGLEVEL >= 10) {
6521                 NDR_PRINT_IN_DEBUG(spoolss_53, r);
6522         }
6523
6524         r->out.result = _spoolss_53(p, r);
6525
6526         if (p->rng_fault_state) {
6527                 talloc_free(r);
6528                 /* Return true here, srv_pipe_hnd.c will take care */
6529                 return true;
6530         }
6531
6532         if (DEBUGLEVEL >= 10) {
6533                 NDR_PRINT_OUT_DEBUG(spoolss_53, r);
6534         }
6535
6536         push = ndr_push_init_ctx(r, NULL);
6537         if (push == NULL) {
6538                 talloc_free(r);
6539                 return false;
6540         }
6541
6542         ndr_err = call->ndr_push(push, NDR_OUT, r);
6543         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6544                 talloc_free(r);
6545                 return false;
6546         }
6547
6548         blob = ndr_push_blob(push);
6549         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6550                 talloc_free(r);
6551                 return false;
6552         }
6553
6554         talloc_free(r);
6555
6556         return true;
6557 }
6558
6559 static bool api_spoolss_DeletePrinterDriverEx(pipes_struct *p)
6560 {
6561         const struct ndr_interface_call *call;
6562         struct ndr_pull *pull;
6563         struct ndr_push *push;
6564         enum ndr_err_code ndr_err;
6565         DATA_BLOB blob;
6566         struct spoolss_DeletePrinterDriverEx *r;
6567
6568         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERDRIVEREX];
6569
6570         r = talloc(talloc_tos(), struct spoolss_DeletePrinterDriverEx);
6571         if (r == NULL) {
6572                 return false;
6573         }
6574
6575         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6576                 talloc_free(r);
6577                 return false;
6578         }
6579
6580         pull = ndr_pull_init_blob(&blob, r, NULL);
6581         if (pull == NULL) {
6582                 talloc_free(r);
6583                 return false;
6584         }
6585
6586         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6587         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6588         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6589                 talloc_free(r);
6590                 return false;
6591         }
6592
6593         if (DEBUGLEVEL >= 10) {
6594                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDriverEx, r);
6595         }
6596
6597         r->out.result = _spoolss_DeletePrinterDriverEx(p, r);
6598
6599         if (p->rng_fault_state) {
6600                 talloc_free(r);
6601                 /* Return true here, srv_pipe_hnd.c will take care */
6602                 return true;
6603         }
6604
6605         if (DEBUGLEVEL >= 10) {
6606                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDriverEx, r);
6607         }
6608
6609         push = ndr_push_init_ctx(r, NULL);
6610         if (push == NULL) {
6611                 talloc_free(r);
6612                 return false;
6613         }
6614
6615         ndr_err = call->ndr_push(push, NDR_OUT, r);
6616         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6617                 talloc_free(r);
6618                 return false;
6619         }
6620
6621         blob = ndr_push_blob(push);
6622         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6623                 talloc_free(r);
6624                 return false;
6625         }
6626
6627         talloc_free(r);
6628
6629         return true;
6630 }
6631
6632 static bool api_spoolss_55(pipes_struct *p)
6633 {
6634         const struct ndr_interface_call *call;
6635         struct ndr_pull *pull;
6636         struct ndr_push *push;
6637         enum ndr_err_code ndr_err;
6638         DATA_BLOB blob;
6639         struct spoolss_55 *r;
6640
6641         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_55];
6642
6643         r = talloc(talloc_tos(), struct spoolss_55);
6644         if (r == NULL) {
6645                 return false;
6646         }
6647
6648         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6649                 talloc_free(r);
6650                 return false;
6651         }
6652
6653         pull = ndr_pull_init_blob(&blob, r, NULL);
6654         if (pull == NULL) {
6655                 talloc_free(r);
6656                 return false;
6657         }
6658
6659         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6660         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6661         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6662                 talloc_free(r);
6663                 return false;
6664         }
6665
6666         if (DEBUGLEVEL >= 10) {
6667                 NDR_PRINT_IN_DEBUG(spoolss_55, r);
6668         }
6669
6670         r->out.result = _spoolss_55(p, r);
6671
6672         if (p->rng_fault_state) {
6673                 talloc_free(r);
6674                 /* Return true here, srv_pipe_hnd.c will take care */
6675                 return true;
6676         }
6677
6678         if (DEBUGLEVEL >= 10) {
6679                 NDR_PRINT_OUT_DEBUG(spoolss_55, r);
6680         }
6681
6682         push = ndr_push_init_ctx(r, NULL);
6683         if (push == NULL) {
6684                 talloc_free(r);
6685                 return false;
6686         }
6687
6688         ndr_err = call->ndr_push(push, NDR_OUT, r);
6689         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6690                 talloc_free(r);
6691                 return false;
6692         }
6693
6694         blob = ndr_push_blob(push);
6695         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6696                 talloc_free(r);
6697                 return false;
6698         }
6699
6700         talloc_free(r);
6701
6702         return true;
6703 }
6704
6705 static bool api_spoolss_56(pipes_struct *p)
6706 {
6707         const struct ndr_interface_call *call;
6708         struct ndr_pull *pull;
6709         struct ndr_push *push;
6710         enum ndr_err_code ndr_err;
6711         DATA_BLOB blob;
6712         struct spoolss_56 *r;
6713
6714         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_56];
6715
6716         r = talloc(talloc_tos(), struct spoolss_56);
6717         if (r == NULL) {
6718                 return false;
6719         }
6720
6721         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6722                 talloc_free(r);
6723                 return false;
6724         }
6725
6726         pull = ndr_pull_init_blob(&blob, r, NULL);
6727         if (pull == NULL) {
6728                 talloc_free(r);
6729                 return false;
6730         }
6731
6732         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6733         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6734         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6735                 talloc_free(r);
6736                 return false;
6737         }
6738
6739         if (DEBUGLEVEL >= 10) {
6740                 NDR_PRINT_IN_DEBUG(spoolss_56, r);
6741         }
6742
6743         r->out.result = _spoolss_56(p, r);
6744
6745         if (p->rng_fault_state) {
6746                 talloc_free(r);
6747                 /* Return true here, srv_pipe_hnd.c will take care */
6748                 return true;
6749         }
6750
6751         if (DEBUGLEVEL >= 10) {
6752                 NDR_PRINT_OUT_DEBUG(spoolss_56, r);
6753         }
6754
6755         push = ndr_push_init_ctx(r, NULL);
6756         if (push == NULL) {
6757                 talloc_free(r);
6758                 return false;
6759         }
6760
6761         ndr_err = call->ndr_push(push, NDR_OUT, r);
6762         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6763                 talloc_free(r);
6764                 return false;
6765         }
6766
6767         blob = ndr_push_blob(push);
6768         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6769                 talloc_free(r);
6770                 return false;
6771         }
6772
6773         talloc_free(r);
6774
6775         return true;
6776 }
6777
6778 static bool api_spoolss_57(pipes_struct *p)
6779 {
6780         const struct ndr_interface_call *call;
6781         struct ndr_pull *pull;
6782         struct ndr_push *push;
6783         enum ndr_err_code ndr_err;
6784         DATA_BLOB blob;
6785         struct spoolss_57 *r;
6786
6787         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_57];
6788
6789         r = talloc(talloc_tos(), struct spoolss_57);
6790         if (r == NULL) {
6791                 return false;
6792         }
6793
6794         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6795                 talloc_free(r);
6796                 return false;
6797         }
6798
6799         pull = ndr_pull_init_blob(&blob, r, NULL);
6800         if (pull == NULL) {
6801                 talloc_free(r);
6802                 return false;
6803         }
6804
6805         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6806         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6807         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6808                 talloc_free(r);
6809                 return false;
6810         }
6811
6812         if (DEBUGLEVEL >= 10) {
6813                 NDR_PRINT_IN_DEBUG(spoolss_57, r);
6814         }
6815
6816         r->out.result = _spoolss_57(p, r);
6817
6818         if (p->rng_fault_state) {
6819                 talloc_free(r);
6820                 /* Return true here, srv_pipe_hnd.c will take care */
6821                 return true;
6822         }
6823
6824         if (DEBUGLEVEL >= 10) {
6825                 NDR_PRINT_OUT_DEBUG(spoolss_57, r);
6826         }
6827
6828         push = ndr_push_init_ctx(r, NULL);
6829         if (push == NULL) {
6830                 talloc_free(r);
6831                 return false;
6832         }
6833
6834         ndr_err = call->ndr_push(push, NDR_OUT, r);
6835         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6836                 talloc_free(r);
6837                 return false;
6838         }
6839
6840         blob = ndr_push_blob(push);
6841         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6842                 talloc_free(r);
6843                 return false;
6844         }
6845
6846         talloc_free(r);
6847
6848         return true;
6849 }
6850
6851 static bool api_spoolss_XcvData(pipes_struct *p)
6852 {
6853         const struct ndr_interface_call *call;
6854         struct ndr_pull *pull;
6855         struct ndr_push *push;
6856         enum ndr_err_code ndr_err;
6857         DATA_BLOB blob;
6858         struct spoolss_XcvData *r;
6859
6860         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_XCVDATA];
6861
6862         r = talloc(talloc_tos(), struct spoolss_XcvData);
6863         if (r == NULL) {
6864                 return false;
6865         }
6866
6867         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6868                 talloc_free(r);
6869                 return false;
6870         }
6871
6872         pull = ndr_pull_init_blob(&blob, r, NULL);
6873         if (pull == NULL) {
6874                 talloc_free(r);
6875                 return false;
6876         }
6877
6878         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6879         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6880         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6881                 talloc_free(r);
6882                 return false;
6883         }
6884
6885         if (DEBUGLEVEL >= 10) {
6886                 NDR_PRINT_IN_DEBUG(spoolss_XcvData, r);
6887         }
6888
6889         ZERO_STRUCT(r->out);
6890         r->out.status_code = r->in.status_code;
6891         r->out.out_data = talloc_zero_array(r, uint8_t, r->in.out_data_size);
6892         if (r->out.out_data == NULL) {
6893                 talloc_free(r);
6894                 return false;
6895         }
6896
6897         r->out.needed = talloc_zero(r, uint32_t);
6898         if (r->out.needed == NULL) {
6899                 talloc_free(r);
6900                 return false;
6901         }
6902
6903         r->out.result = _spoolss_XcvData(p, r);
6904
6905         if (p->rng_fault_state) {
6906                 talloc_free(r);
6907                 /* Return true here, srv_pipe_hnd.c will take care */
6908                 return true;
6909         }
6910
6911         if (DEBUGLEVEL >= 10) {
6912                 NDR_PRINT_OUT_DEBUG(spoolss_XcvData, r);
6913         }
6914
6915         push = ndr_push_init_ctx(r, NULL);
6916         if (push == NULL) {
6917                 talloc_free(r);
6918                 return false;
6919         }
6920
6921         ndr_err = call->ndr_push(push, NDR_OUT, r);
6922         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6923                 talloc_free(r);
6924                 return false;
6925         }
6926
6927         blob = ndr_push_blob(push);
6928         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6929                 talloc_free(r);
6930                 return false;
6931         }
6932
6933         talloc_free(r);
6934
6935         return true;
6936 }
6937
6938 static bool api_spoolss_AddPrinterDriverEx(pipes_struct *p)
6939 {
6940         const struct ndr_interface_call *call;
6941         struct ndr_pull *pull;
6942         struct ndr_push *push;
6943         enum ndr_err_code ndr_err;
6944         DATA_BLOB blob;
6945         struct spoolss_AddPrinterDriverEx *r;
6946
6947         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTERDRIVEREX];
6948
6949         r = talloc(talloc_tos(), struct spoolss_AddPrinterDriverEx);
6950         if (r == NULL) {
6951                 return false;
6952         }
6953
6954         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6955                 talloc_free(r);
6956                 return false;
6957         }
6958
6959         pull = ndr_pull_init_blob(&blob, r, NULL);
6960         if (pull == NULL) {
6961                 talloc_free(r);
6962                 return false;
6963         }
6964
6965         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6966         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6967         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6968                 talloc_free(r);
6969                 return false;
6970         }
6971
6972         if (DEBUGLEVEL >= 10) {
6973                 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterDriverEx, r);
6974         }
6975
6976         r->out.result = _spoolss_AddPrinterDriverEx(p, r);
6977
6978         if (p->rng_fault_state) {
6979                 talloc_free(r);
6980                 /* Return true here, srv_pipe_hnd.c will take care */
6981                 return true;
6982         }
6983
6984         if (DEBUGLEVEL >= 10) {
6985                 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterDriverEx, r);
6986         }
6987
6988         push = ndr_push_init_ctx(r, NULL);
6989         if (push == NULL) {
6990                 talloc_free(r);
6991                 return false;
6992         }
6993
6994         ndr_err = call->ndr_push(push, NDR_OUT, r);
6995         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6996                 talloc_free(r);
6997                 return false;
6998         }
6999
7000         blob = ndr_push_blob(push);
7001         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7002                 talloc_free(r);
7003                 return false;
7004         }
7005
7006         talloc_free(r);
7007
7008         return true;
7009 }
7010
7011 static bool api_spoolss_5a(pipes_struct *p)
7012 {
7013         const struct ndr_interface_call *call;
7014         struct ndr_pull *pull;
7015         struct ndr_push *push;
7016         enum ndr_err_code ndr_err;
7017         DATA_BLOB blob;
7018         struct spoolss_5a *r;
7019
7020         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5A];
7021
7022         r = talloc(talloc_tos(), struct spoolss_5a);
7023         if (r == NULL) {
7024                 return false;
7025         }
7026
7027         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7028                 talloc_free(r);
7029                 return false;
7030         }
7031
7032         pull = ndr_pull_init_blob(&blob, r, NULL);
7033         if (pull == NULL) {
7034                 talloc_free(r);
7035                 return false;
7036         }
7037
7038         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7039         ndr_err = call->ndr_pull(pull, NDR_IN, r);
7040         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7041                 talloc_free(r);
7042                 return false;
7043         }
7044
7045         if (DEBUGLEVEL >= 10) {
7046                 NDR_PRINT_IN_DEBUG(spoolss_5a, r);
7047         }
7048
7049         r->out.result = _spoolss_5a(p, r);
7050
7051         if (p->rng_fault_state) {
7052                 talloc_free(r);
7053                 /* Return true here, srv_pipe_hnd.c will take care */
7054                 return true;
7055         }
7056
7057         if (DEBUGLEVEL >= 10) {
7058                 NDR_PRINT_OUT_DEBUG(spoolss_5a, r);
7059         }
7060
7061         push = ndr_push_init_ctx(r, NULL);
7062         if (push == NULL) {
7063                 talloc_free(r);
7064                 return false;
7065         }
7066
7067         ndr_err = call->ndr_push(push, NDR_OUT, r);
7068         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7069                 talloc_free(r);
7070                 return false;
7071         }
7072
7073         blob = ndr_push_blob(push);
7074         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7075                 talloc_free(r);
7076                 return false;
7077         }
7078
7079         talloc_free(r);
7080
7081         return true;
7082 }
7083
7084 static bool api_spoolss_5b(pipes_struct *p)
7085 {
7086         const struct ndr_interface_call *call;
7087         struct ndr_pull *pull;
7088         struct ndr_push *push;
7089         enum ndr_err_code ndr_err;
7090         DATA_BLOB blob;
7091         struct spoolss_5b *r;
7092
7093         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5B];
7094
7095         r = talloc(talloc_tos(), struct spoolss_5b);
7096         if (r == NULL) {
7097                 return false;
7098         }
7099
7100         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7101                 talloc_free(r);
7102                 return false;
7103         }
7104
7105         pull = ndr_pull_init_blob(&blob, r, NULL);
7106         if (pull == NULL) {
7107                 talloc_free(r);
7108                 return false;
7109         }
7110
7111         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7112         ndr_err = call->ndr_pull(pull, NDR_IN, r);
7113         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7114                 talloc_free(r);
7115                 return false;
7116         }
7117
7118         if (DEBUGLEVEL >= 10) {
7119                 NDR_PRINT_IN_DEBUG(spoolss_5b, r);
7120         }
7121
7122         r->out.result = _spoolss_5b(p, r);
7123
7124         if (p->rng_fault_state) {
7125                 talloc_free(r);
7126                 /* Return true here, srv_pipe_hnd.c will take care */
7127                 return true;
7128         }
7129
7130         if (DEBUGLEVEL >= 10) {
7131                 NDR_PRINT_OUT_DEBUG(spoolss_5b, r);
7132         }
7133
7134         push = ndr_push_init_ctx(r, NULL);
7135         if (push == NULL) {
7136                 talloc_free(r);
7137                 return false;
7138         }
7139
7140         ndr_err = call->ndr_push(push, NDR_OUT, r);
7141         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7142                 talloc_free(r);
7143                 return false;
7144         }
7145
7146         blob = ndr_push_blob(push);
7147         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7148                 talloc_free(r);
7149                 return false;
7150         }
7151
7152         talloc_free(r);
7153
7154         return true;
7155 }
7156
7157 static bool api_spoolss_5c(pipes_struct *p)
7158 {
7159         const struct ndr_interface_call *call;
7160         struct ndr_pull *pull;
7161         struct ndr_push *push;
7162         enum ndr_err_code ndr_err;
7163         DATA_BLOB blob;
7164         struct spoolss_5c *r;
7165
7166         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5C];
7167
7168         r = talloc(talloc_tos(), struct spoolss_5c);
7169         if (r == NULL) {
7170                 return false;
7171         }
7172
7173         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7174                 talloc_free(r);
7175                 return false;
7176         }
7177
7178         pull = ndr_pull_init_blob(&blob, r, NULL);
7179         if (pull == NULL) {
7180                 talloc_free(r);
7181                 return false;
7182         }
7183
7184         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7185         ndr_err = call->ndr_pull(pull, NDR_IN, r);
7186         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7187                 talloc_free(r);
7188                 return false;
7189         }
7190
7191         if (DEBUGLEVEL >= 10) {
7192                 NDR_PRINT_IN_DEBUG(spoolss_5c, r);
7193         }
7194
7195         r->out.result = _spoolss_5c(p, r);
7196
7197         if (p->rng_fault_state) {
7198                 talloc_free(r);
7199                 /* Return true here, srv_pipe_hnd.c will take care */
7200                 return true;
7201         }
7202
7203         if (DEBUGLEVEL >= 10) {
7204                 NDR_PRINT_OUT_DEBUG(spoolss_5c, r);
7205         }
7206
7207         push = ndr_push_init_ctx(r, NULL);
7208         if (push == NULL) {
7209                 talloc_free(r);
7210                 return false;
7211         }
7212
7213         ndr_err = call->ndr_push(push, NDR_OUT, r);
7214         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7215                 talloc_free(r);
7216                 return false;
7217         }
7218
7219         blob = ndr_push_blob(push);
7220         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7221                 talloc_free(r);
7222                 return false;
7223         }
7224
7225         talloc_free(r);
7226
7227         return true;
7228 }
7229
7230 static bool api_spoolss_5d(pipes_struct *p)
7231 {
7232         const struct ndr_interface_call *call;
7233         struct ndr_pull *pull;
7234         struct ndr_push *push;
7235         enum ndr_err_code ndr_err;
7236         DATA_BLOB blob;
7237         struct spoolss_5d *r;
7238
7239         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5D];
7240
7241         r = talloc(talloc_tos(), struct spoolss_5d);
7242         if (r == NULL) {
7243                 return false;
7244         }
7245
7246         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7247                 talloc_free(r);
7248                 return false;
7249         }
7250
7251         pull = ndr_pull_init_blob(&blob, r, NULL);
7252         if (pull == NULL) {
7253                 talloc_free(r);
7254                 return false;
7255         }
7256
7257         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7258         ndr_err = call->ndr_pull(pull, NDR_IN, r);
7259         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7260                 talloc_free(r);
7261                 return false;
7262         }
7263
7264         if (DEBUGLEVEL >= 10) {
7265                 NDR_PRINT_IN_DEBUG(spoolss_5d, r);
7266         }
7267
7268         r->out.result = _spoolss_5d(p, r);
7269
7270         if (p->rng_fault_state) {
7271                 talloc_free(r);
7272                 /* Return true here, srv_pipe_hnd.c will take care */
7273                 return true;
7274         }
7275
7276         if (DEBUGLEVEL >= 10) {
7277                 NDR_PRINT_OUT_DEBUG(spoolss_5d, r);
7278         }
7279
7280         push = ndr_push_init_ctx(r, NULL);
7281         if (push == NULL) {
7282                 talloc_free(r);
7283                 return false;
7284         }
7285
7286         ndr_err = call->ndr_push(push, NDR_OUT, r);
7287         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7288                 talloc_free(r);
7289                 return false;
7290         }
7291
7292         blob = ndr_push_blob(push);
7293         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7294                 talloc_free(r);
7295                 return false;
7296         }
7297
7298         talloc_free(r);
7299
7300         return true;
7301 }
7302
7303 static bool api_spoolss_5e(pipes_struct *p)
7304 {
7305         const struct ndr_interface_call *call;
7306         struct ndr_pull *pull;
7307         struct ndr_push *push;
7308         enum ndr_err_code ndr_err;
7309         DATA_BLOB blob;
7310         struct spoolss_5e *r;
7311
7312         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5E];
7313
7314         r = talloc(talloc_tos(), struct spoolss_5e);
7315         if (r == NULL) {
7316                 return false;
7317         }
7318
7319         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7320                 talloc_free(r);
7321                 return false;
7322         }
7323
7324         pull = ndr_pull_init_blob(&blob, r, NULL);
7325         if (pull == NULL) {
7326                 talloc_free(r);
7327                 return false;
7328         }
7329
7330         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7331         ndr_err = call->ndr_pull(pull, NDR_IN, r);
7332         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7333                 talloc_free(r);
7334                 return false;
7335         }
7336
7337         if (DEBUGLEVEL >= 10) {
7338                 NDR_PRINT_IN_DEBUG(spoolss_5e, r);
7339         }
7340
7341         r->out.result = _spoolss_5e(p, r);
7342
7343         if (p->rng_fault_state) {
7344                 talloc_free(r);
7345                 /* Return true here, srv_pipe_hnd.c will take care */
7346                 return true;
7347         }
7348
7349         if (DEBUGLEVEL >= 10) {
7350                 NDR_PRINT_OUT_DEBUG(spoolss_5e, r);
7351         }
7352
7353         push = ndr_push_init_ctx(r, NULL);
7354         if (push == NULL) {
7355                 talloc_free(r);
7356                 return false;
7357         }
7358
7359         ndr_err = call->ndr_push(push, NDR_OUT, r);
7360         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7361                 talloc_free(r);
7362                 return false;
7363         }
7364
7365         blob = ndr_push_blob(push);
7366         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7367                 talloc_free(r);
7368                 return false;
7369         }
7370
7371         talloc_free(r);
7372
7373         return true;
7374 }
7375
7376 static bool api_spoolss_5f(pipes_struct *p)
7377 {
7378         const struct ndr_interface_call *call;
7379         struct ndr_pull *pull;
7380         struct ndr_push *push;
7381         enum ndr_err_code ndr_err;
7382         DATA_BLOB blob;
7383         struct spoolss_5f *r;
7384
7385         call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5F];
7386
7387         r = talloc(talloc_tos(), struct spoolss_5f);
7388         if (r == NULL) {
7389                 return false;
7390         }
7391
7392         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7393                 talloc_free(r);
7394                 return false;
7395         }
7396
7397         pull = ndr_pull_init_blob(&blob, r, NULL);
7398         if (pull == NULL) {
7399                 talloc_free(r);
7400                 return false;
7401         }
7402
7403         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7404         ndr_err = call->ndr_pull(pull, NDR_IN, r);
7405         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7406                 talloc_free(r);
7407                 return false;
7408         }
7409
7410         if (DEBUGLEVEL >= 10) {
7411                 NDR_PRINT_IN_DEBUG(spoolss_5f, r);
7412         }
7413
7414         r->out.result = _spoolss_5f(p, r);
7415
7416         if (p->rng_fault_state) {
7417                 talloc_free(r);
7418                 /* Return true here, srv_pipe_hnd.c will take care */
7419                 return true;
7420         }
7421
7422         if (DEBUGLEVEL >= 10) {
7423                 NDR_PRINT_OUT_DEBUG(spoolss_5f, r);
7424         }
7425
7426         push = ndr_push_init_ctx(r, NULL);
7427         if (push == NULL) {
7428                 talloc_free(r);
7429                 return false;
7430         }
7431
7432         ndr_err = call->ndr_push(push, NDR_OUT, r);
7433         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7434                 talloc_free(r);
7435                 return false;
7436         }
7437
7438         blob = ndr_push_blob(push);
7439         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7440                 talloc_free(r);
7441                 return false;
7442         }
7443
7444         talloc_free(r);
7445
7446         return true;
7447 }
7448
7449
7450 /* Tables */
7451 static struct api_struct api_spoolss_cmds[] =
7452 {
7453         {"SPOOLSS_ENUMPRINTERS", NDR_SPOOLSS_ENUMPRINTERS, api_spoolss_EnumPrinters},
7454         {"SPOOLSS_OPENPRINTER", NDR_SPOOLSS_OPENPRINTER, api_spoolss_OpenPrinter},
7455         {"SPOOLSS_SETJOB", NDR_SPOOLSS_SETJOB, api_spoolss_SetJob},
7456         {"SPOOLSS_GETJOB", NDR_SPOOLSS_GETJOB, api_spoolss_GetJob},
7457         {"SPOOLSS_ENUMJOBS", NDR_SPOOLSS_ENUMJOBS, api_spoolss_EnumJobs},
7458         {"SPOOLSS_ADDPRINTER", NDR_SPOOLSS_ADDPRINTER, api_spoolss_AddPrinter},
7459         {"SPOOLSS_DELETEPRINTER", NDR_SPOOLSS_DELETEPRINTER, api_spoolss_DeletePrinter},
7460         {"SPOOLSS_SETPRINTER", NDR_SPOOLSS_SETPRINTER, api_spoolss_SetPrinter},
7461         {"SPOOLSS_GETPRINTER", NDR_SPOOLSS_GETPRINTER, api_spoolss_GetPrinter},
7462         {"SPOOLSS_ADDPRINTERDRIVER", NDR_SPOOLSS_ADDPRINTERDRIVER, api_spoolss_AddPrinterDriver},
7463         {"SPOOLSS_ENUMPRINTERDRIVERS", NDR_SPOOLSS_ENUMPRINTERDRIVERS, api_spoolss_EnumPrinterDrivers},
7464         {"SPOOLSS_GETPRINTERDRIVER", NDR_SPOOLSS_GETPRINTERDRIVER, api_spoolss_GetPrinterDriver},
7465         {"SPOOLSS_GETPRINTERDRIVERDIRECTORY", NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY, api_spoolss_GetPrinterDriverDirectory},
7466         {"SPOOLSS_DELETEPRINTERDRIVER", NDR_SPOOLSS_DELETEPRINTERDRIVER, api_spoolss_DeletePrinterDriver},
7467         {"SPOOLSS_ADDPRINTPROCESSOR", NDR_SPOOLSS_ADDPRINTPROCESSOR, api_spoolss_AddPrintProcessor},
7468         {"SPOOLSS_ENUMPRINTPROCESSORS", NDR_SPOOLSS_ENUMPRINTPROCESSORS, api_spoolss_EnumPrintProcessors},
7469         {"SPOOLSS_GETPRINTPROCESSORDIRECTORY", NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY, api_spoolss_GetPrintProcessorDirectory},
7470         {"SPOOLSS_STARTDOCPRINTER", NDR_SPOOLSS_STARTDOCPRINTER, api_spoolss_StartDocPrinter},
7471         {"SPOOLSS_STARTPAGEPRINTER", NDR_SPOOLSS_STARTPAGEPRINTER, api_spoolss_StartPagePrinter},
7472         {"SPOOLSS_WRITEPRINTER", NDR_SPOOLSS_WRITEPRINTER, api_spoolss_WritePrinter},
7473         {"SPOOLSS_ENDPAGEPRINTER", NDR_SPOOLSS_ENDPAGEPRINTER, api_spoolss_EndPagePrinter},
7474         {"SPOOLSS_ABORTPRINTER", NDR_SPOOLSS_ABORTPRINTER, api_spoolss_AbortPrinter},
7475         {"SPOOLSS_READPRINTER", NDR_SPOOLSS_READPRINTER, api_spoolss_ReadPrinter},
7476         {"SPOOLSS_ENDDOCPRINTER", NDR_SPOOLSS_ENDDOCPRINTER, api_spoolss_EndDocPrinter},
7477         {"SPOOLSS_ADDJOB", NDR_SPOOLSS_ADDJOB, api_spoolss_AddJob},
7478         {"SPOOLSS_SCHEDULEJOB", NDR_SPOOLSS_SCHEDULEJOB, api_spoolss_ScheduleJob},
7479         {"SPOOLSS_GETPRINTERDATA", NDR_SPOOLSS_GETPRINTERDATA, api_spoolss_GetPrinterData},
7480         {"SPOOLSS_SETPRINTERDATA", NDR_SPOOLSS_SETPRINTERDATA, api_spoolss_SetPrinterData},
7481         {"SPOOLSS_WAITFORPRINTERCHANGE", NDR_SPOOLSS_WAITFORPRINTERCHANGE, api_spoolss_WaitForPrinterChange},
7482         {"SPOOLSS_CLOSEPRINTER", NDR_SPOOLSS_CLOSEPRINTER, api_spoolss_ClosePrinter},
7483         {"SPOOLSS_ADDFORM", NDR_SPOOLSS_ADDFORM, api_spoolss_AddForm},
7484         {"SPOOLSS_DELETEFORM", NDR_SPOOLSS_DELETEFORM, api_spoolss_DeleteForm},
7485         {"SPOOLSS_GETFORM", NDR_SPOOLSS_GETFORM, api_spoolss_GetForm},
7486         {"SPOOLSS_SETFORM", NDR_SPOOLSS_SETFORM, api_spoolss_SetForm},
7487         {"SPOOLSS_ENUMFORMS", NDR_SPOOLSS_ENUMFORMS, api_spoolss_EnumForms},
7488         {"SPOOLSS_ENUMPORTS", NDR_SPOOLSS_ENUMPORTS, api_spoolss_EnumPorts},
7489         {"SPOOLSS_ENUMMONITORS", NDR_SPOOLSS_ENUMMONITORS, api_spoolss_EnumMonitors},
7490         {"SPOOLSS_ADDPORT", NDR_SPOOLSS_ADDPORT, api_spoolss_AddPort},
7491         {"SPOOLSS_CONFIGUREPORT", NDR_SPOOLSS_CONFIGUREPORT, api_spoolss_ConfigurePort},
7492         {"SPOOLSS_DELETEPORT", NDR_SPOOLSS_DELETEPORT, api_spoolss_DeletePort},
7493         {"SPOOLSS_CREATEPRINTERIC", NDR_SPOOLSS_CREATEPRINTERIC, api_spoolss_CreatePrinterIC},
7494         {"SPOOLSS_PLAYGDISCRIPTONPRINTERIC", NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC, api_spoolss_PlayGDIScriptOnPrinterIC},
7495         {"SPOOLSS_DELETEPRINTERIC", NDR_SPOOLSS_DELETEPRINTERIC, api_spoolss_DeletePrinterIC},
7496         {"SPOOLSS_ADDPRINTERCONNECTION", NDR_SPOOLSS_ADDPRINTERCONNECTION, api_spoolss_AddPrinterConnection},
7497         {"SPOOLSS_DELETEPRINTERCONNECTION", NDR_SPOOLSS_DELETEPRINTERCONNECTION, api_spoolss_DeletePrinterConnection},
7498         {"SPOOLSS_PRINTERMESSAGEBOX", NDR_SPOOLSS_PRINTERMESSAGEBOX, api_spoolss_PrinterMessageBox},
7499         {"SPOOLSS_ADDMONITOR", NDR_SPOOLSS_ADDMONITOR, api_spoolss_AddMonitor},
7500         {"SPOOLSS_DELETEMONITOR", NDR_SPOOLSS_DELETEMONITOR, api_spoolss_DeleteMonitor},
7501         {"SPOOLSS_DELETEPRINTPROCESSOR", NDR_SPOOLSS_DELETEPRINTPROCESSOR, api_spoolss_DeletePrintProcessor},
7502         {"SPOOLSS_ADDPRINTPROVIDOR", NDR_SPOOLSS_ADDPRINTPROVIDOR, api_spoolss_AddPrintProvidor},
7503         {"SPOOLSS_DELETEPRINTPROVIDOR", NDR_SPOOLSS_DELETEPRINTPROVIDOR, api_spoolss_DeletePrintProvidor},
7504         {"SPOOLSS_ENUMPRINTPROCDATATYPES", NDR_SPOOLSS_ENUMPRINTPROCDATATYPES, api_spoolss_EnumPrintProcDataTypes},
7505         {"SPOOLSS_RESETPRINTER", NDR_SPOOLSS_RESETPRINTER, api_spoolss_ResetPrinter},
7506         {"SPOOLSS_GETPRINTERDRIVER2", NDR_SPOOLSS_GETPRINTERDRIVER2, api_spoolss_GetPrinterDriver2},
7507         {"SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION", NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION, api_spoolss_FindFirstPrinterChangeNotification},
7508         {"SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION", NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION, api_spoolss_FindNextPrinterChangeNotification},
7509         {"SPOOLSS_FINDCLOSEPRINTERNOTIFY", NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY, api_spoolss_FindClosePrinterNotify},
7510         {"SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD", NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD, api_spoolss_RouterFindFirstPrinterChangeNotificationOld},
7511         {"SPOOLSS_REPLYOPENPRINTER", NDR_SPOOLSS_REPLYOPENPRINTER, api_spoolss_ReplyOpenPrinter},
7512         {"SPOOLSS_ROUTERREPLYPRINTER", NDR_SPOOLSS_ROUTERREPLYPRINTER, api_spoolss_RouterReplyPrinter},
7513         {"SPOOLSS_REPLYCLOSEPRINTER", NDR_SPOOLSS_REPLYCLOSEPRINTER, api_spoolss_ReplyClosePrinter},
7514         {"SPOOLSS_ADDPORTEX", NDR_SPOOLSS_ADDPORTEX, api_spoolss_AddPortEx},
7515         {"SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION", NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION, api_spoolss_RouterFindFirstPrinterChangeNotification},
7516         {"SPOOLSS_SPOOLERINIT", NDR_SPOOLSS_SPOOLERINIT, api_spoolss_SpoolerInit},
7517         {"SPOOLSS_RESETPRINTEREX", NDR_SPOOLSS_RESETPRINTEREX, api_spoolss_ResetPrinterEx},
7518         {"SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX", NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX, api_spoolss_RemoteFindFirstPrinterChangeNotifyEx},
7519         {"SPOOLSS_ROUTERREPLYPRINTEREX", NDR_SPOOLSS_ROUTERREPLYPRINTEREX, api_spoolss_RouterReplyPrinterEx},
7520         {"SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY", NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY, api_spoolss_RouterRefreshPrinterChangeNotify},
7521         {"SPOOLSS_44", NDR_SPOOLSS_44, api_spoolss_44},
7522         {"SPOOLSS_OPENPRINTEREX", NDR_SPOOLSS_OPENPRINTEREX, api_spoolss_OpenPrinterEx},
7523         {"SPOOLSS_ADDPRINTEREX", NDR_SPOOLSS_ADDPRINTEREX, api_spoolss_AddPrinterEx},
7524         {"SPOOLSS_47", NDR_SPOOLSS_47, api_spoolss_47},
7525         {"SPOOLSS_ENUMPRINTERDATA", NDR_SPOOLSS_ENUMPRINTERDATA, api_spoolss_EnumPrinterData},
7526         {"SPOOLSS_DELETEPRINTERDATA", NDR_SPOOLSS_DELETEPRINTERDATA, api_spoolss_DeletePrinterData},
7527         {"SPOOLSS_4A", NDR_SPOOLSS_4A, api_spoolss_4a},
7528         {"SPOOLSS_4B", NDR_SPOOLSS_4B, api_spoolss_4b},
7529         {"SPOOLSS_4C", NDR_SPOOLSS_4C, api_spoolss_4c},
7530         {"SPOOLSS_SETPRINTERDATAEX", NDR_SPOOLSS_SETPRINTERDATAEX, api_spoolss_SetPrinterDataEx},
7531         {"SPOOLSS_GETPRINTERDATAEX", NDR_SPOOLSS_GETPRINTERDATAEX, api_spoolss_GetPrinterDataEx},
7532         {"SPOOLSS_ENUMPRINTERDATAEX", NDR_SPOOLSS_ENUMPRINTERDATAEX, api_spoolss_EnumPrinterDataEx},
7533         {"SPOOLSS_ENUMPRINTERKEY", NDR_SPOOLSS_ENUMPRINTERKEY, api_spoolss_EnumPrinterKey},
7534         {"SPOOLSS_DELETEPRINTERDATAEX", NDR_SPOOLSS_DELETEPRINTERDATAEX, api_spoolss_DeletePrinterDataEx},
7535         {"SPOOLSS_DELETEPRINTERKEY", NDR_SPOOLSS_DELETEPRINTERKEY, api_spoolss_DeletePrinterKey},
7536         {"SPOOLSS_53", NDR_SPOOLSS_53, api_spoolss_53},
7537         {"SPOOLSS_DELETEPRINTERDRIVEREX", NDR_SPOOLSS_DELETEPRINTERDRIVEREX, api_spoolss_DeletePrinterDriverEx},
7538         {"SPOOLSS_55", NDR_SPOOLSS_55, api_spoolss_55},
7539         {"SPOOLSS_56", NDR_SPOOLSS_56, api_spoolss_56},
7540         {"SPOOLSS_57", NDR_SPOOLSS_57, api_spoolss_57},
7541         {"SPOOLSS_XCVDATA", NDR_SPOOLSS_XCVDATA, api_spoolss_XcvData},
7542         {"SPOOLSS_ADDPRINTERDRIVEREX", NDR_SPOOLSS_ADDPRINTERDRIVEREX, api_spoolss_AddPrinterDriverEx},
7543         {"SPOOLSS_5A", NDR_SPOOLSS_5A, api_spoolss_5a},
7544         {"SPOOLSS_5B", NDR_SPOOLSS_5B, api_spoolss_5b},
7545         {"SPOOLSS_5C", NDR_SPOOLSS_5C, api_spoolss_5c},
7546         {"SPOOLSS_5D", NDR_SPOOLSS_5D, api_spoolss_5d},
7547         {"SPOOLSS_5E", NDR_SPOOLSS_5E, api_spoolss_5e},
7548         {"SPOOLSS_5F", NDR_SPOOLSS_5F, api_spoolss_5f},
7549 };
7550
7551 void spoolss_get_pipe_fns(struct api_struct **fns, int *n_fns)
7552 {
7553         *fns = api_spoolss_cmds;
7554         *n_fns = sizeof(api_spoolss_cmds) / sizeof(struct api_struct);
7555 }
7556
7557 NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r)
7558 {
7559         if (cli->pipes_struct == NULL) {
7560                 return NT_STATUS_INVALID_PARAMETER;
7561         }
7562
7563         switch (opnum)
7564         {
7565                 case NDR_SPOOLSS_ENUMPRINTERS: {
7566                         struct spoolss_EnumPrinters *r = (struct spoolss_EnumPrinters *)_r;
7567                         ZERO_STRUCT(r->out);
7568                         r->out.count = talloc_zero(mem_ctx, uint32_t);
7569                         if (r->out.count == NULL) {
7570                         return NT_STATUS_NO_MEMORY;
7571                         }
7572
7573                         r->out.info = talloc_zero(mem_ctx, union spoolss_PrinterInfo *);
7574                         if (r->out.info == NULL) {
7575                         return NT_STATUS_NO_MEMORY;
7576                         }
7577
7578                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7579                         if (r->out.needed == NULL) {
7580                         return NT_STATUS_NO_MEMORY;
7581                         }
7582
7583                         r->out.result = _spoolss_EnumPrinters(cli->pipes_struct, r);
7584                         return NT_STATUS_OK;
7585                 }
7586
7587                 case NDR_SPOOLSS_OPENPRINTER: {
7588                         struct spoolss_OpenPrinter *r = (struct spoolss_OpenPrinter *)_r;
7589                         ZERO_STRUCT(r->out);
7590                         r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
7591                         if (r->out.handle == NULL) {
7592                         return NT_STATUS_NO_MEMORY;
7593                         }
7594
7595                         r->out.result = _spoolss_OpenPrinter(cli->pipes_struct, r);
7596                         return NT_STATUS_OK;
7597                 }
7598
7599                 case NDR_SPOOLSS_SETJOB: {
7600                         struct spoolss_SetJob *r = (struct spoolss_SetJob *)_r;
7601                         r->out.result = _spoolss_SetJob(cli->pipes_struct, r);
7602                         return NT_STATUS_OK;
7603                 }
7604
7605                 case NDR_SPOOLSS_GETJOB: {
7606                         struct spoolss_GetJob *r = (struct spoolss_GetJob *)_r;
7607                         ZERO_STRUCT(r->out);
7608                         r->out.info = talloc_zero(mem_ctx, union spoolss_JobInfo);
7609                         if (r->out.info == NULL) {
7610                         return NT_STATUS_NO_MEMORY;
7611                         }
7612
7613                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7614                         if (r->out.needed == NULL) {
7615                         return NT_STATUS_NO_MEMORY;
7616                         }
7617
7618                         r->out.result = _spoolss_GetJob(cli->pipes_struct, r);
7619                         return NT_STATUS_OK;
7620                 }
7621
7622                 case NDR_SPOOLSS_ENUMJOBS: {
7623                         struct spoolss_EnumJobs *r = (struct spoolss_EnumJobs *)_r;
7624                         ZERO_STRUCT(r->out);
7625                         r->out.count = talloc_zero(mem_ctx, uint32_t);
7626                         if (r->out.count == NULL) {
7627                         return NT_STATUS_NO_MEMORY;
7628                         }
7629
7630                         r->out.info = talloc_zero(mem_ctx, union spoolss_JobInfo *);
7631                         if (r->out.info == NULL) {
7632                         return NT_STATUS_NO_MEMORY;
7633                         }
7634
7635                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7636                         if (r->out.needed == NULL) {
7637                         return NT_STATUS_NO_MEMORY;
7638                         }
7639
7640                         r->out.result = _spoolss_EnumJobs(cli->pipes_struct, r);
7641                         return NT_STATUS_OK;
7642                 }
7643
7644                 case NDR_SPOOLSS_ADDPRINTER: {
7645                         struct spoolss_AddPrinter *r = (struct spoolss_AddPrinter *)_r;
7646                         r->out.result = _spoolss_AddPrinter(cli->pipes_struct, r);
7647                         return NT_STATUS_OK;
7648                 }
7649
7650                 case NDR_SPOOLSS_DELETEPRINTER: {
7651                         struct spoolss_DeletePrinter *r = (struct spoolss_DeletePrinter *)_r;
7652                         r->out.result = _spoolss_DeletePrinter(cli->pipes_struct, r);
7653                         return NT_STATUS_OK;
7654                 }
7655
7656                 case NDR_SPOOLSS_SETPRINTER: {
7657                         struct spoolss_SetPrinter *r = (struct spoolss_SetPrinter *)_r;
7658                         r->out.result = _spoolss_SetPrinter(cli->pipes_struct, r);
7659                         return NT_STATUS_OK;
7660                 }
7661
7662                 case NDR_SPOOLSS_GETPRINTER: {
7663                         struct spoolss_GetPrinter *r = (struct spoolss_GetPrinter *)_r;
7664                         ZERO_STRUCT(r->out);
7665                         r->out.info = talloc_zero(mem_ctx, union spoolss_PrinterInfo);
7666                         if (r->out.info == NULL) {
7667                         return NT_STATUS_NO_MEMORY;
7668                         }
7669
7670                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7671                         if (r->out.needed == NULL) {
7672                         return NT_STATUS_NO_MEMORY;
7673                         }
7674
7675                         r->out.result = _spoolss_GetPrinter(cli->pipes_struct, r);
7676                         return NT_STATUS_OK;
7677                 }
7678
7679                 case NDR_SPOOLSS_ADDPRINTERDRIVER: {
7680                         struct spoolss_AddPrinterDriver *r = (struct spoolss_AddPrinterDriver *)_r;
7681                         r->out.result = _spoolss_AddPrinterDriver(cli->pipes_struct, r);
7682                         return NT_STATUS_OK;
7683                 }
7684
7685                 case NDR_SPOOLSS_ENUMPRINTERDRIVERS: {
7686                         struct spoolss_EnumPrinterDrivers *r = (struct spoolss_EnumPrinterDrivers *)_r;
7687                         ZERO_STRUCT(r->out);
7688                         r->out.count = talloc_zero(mem_ctx, uint32_t);
7689                         if (r->out.count == NULL) {
7690                         return NT_STATUS_NO_MEMORY;
7691                         }
7692
7693                         r->out.info = talloc_zero(mem_ctx, union spoolss_DriverInfo *);
7694                         if (r->out.info == NULL) {
7695                         return NT_STATUS_NO_MEMORY;
7696                         }
7697
7698                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7699                         if (r->out.needed == NULL) {
7700                         return NT_STATUS_NO_MEMORY;
7701                         }
7702
7703                         r->out.result = _spoolss_EnumPrinterDrivers(cli->pipes_struct, r);
7704                         return NT_STATUS_OK;
7705                 }
7706
7707                 case NDR_SPOOLSS_GETPRINTERDRIVER: {
7708                         struct spoolss_GetPrinterDriver *r = (struct spoolss_GetPrinterDriver *)_r;
7709                         r->out.result = _spoolss_GetPrinterDriver(cli->pipes_struct, r);
7710                         return NT_STATUS_OK;
7711                 }
7712
7713                 case NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY: {
7714                         struct spoolss_GetPrinterDriverDirectory *r = (struct spoolss_GetPrinterDriverDirectory *)_r;
7715                         ZERO_STRUCT(r->out);
7716                         r->out.info = talloc_zero(mem_ctx, union spoolss_DriverDirectoryInfo);
7717                         if (r->out.info == NULL) {
7718                         return NT_STATUS_NO_MEMORY;
7719                         }
7720
7721                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7722                         if (r->out.needed == NULL) {
7723                         return NT_STATUS_NO_MEMORY;
7724                         }
7725
7726                         r->out.result = _spoolss_GetPrinterDriverDirectory(cli->pipes_struct, r);
7727                         return NT_STATUS_OK;
7728                 }
7729
7730                 case NDR_SPOOLSS_DELETEPRINTERDRIVER: {
7731                         struct spoolss_DeletePrinterDriver *r = (struct spoolss_DeletePrinterDriver *)_r;
7732                         r->out.result = _spoolss_DeletePrinterDriver(cli->pipes_struct, r);
7733                         return NT_STATUS_OK;
7734                 }
7735
7736                 case NDR_SPOOLSS_ADDPRINTPROCESSOR: {
7737                         struct spoolss_AddPrintProcessor *r = (struct spoolss_AddPrintProcessor *)_r;
7738                         r->out.result = _spoolss_AddPrintProcessor(cli->pipes_struct, r);
7739                         return NT_STATUS_OK;
7740                 }
7741
7742                 case NDR_SPOOLSS_ENUMPRINTPROCESSORS: {
7743                         struct spoolss_EnumPrintProcessors *r = (struct spoolss_EnumPrintProcessors *)_r;
7744                         ZERO_STRUCT(r->out);
7745                         r->out.count = talloc_zero(mem_ctx, uint32_t);
7746                         if (r->out.count == NULL) {
7747                         return NT_STATUS_NO_MEMORY;
7748                         }
7749
7750                         r->out.info = talloc_zero(mem_ctx, union spoolss_PrintProcessorInfo *);
7751                         if (r->out.info == NULL) {
7752                         return NT_STATUS_NO_MEMORY;
7753                         }
7754
7755                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7756                         if (r->out.needed == NULL) {
7757                         return NT_STATUS_NO_MEMORY;
7758                         }
7759
7760                         r->out.result = _spoolss_EnumPrintProcessors(cli->pipes_struct, r);
7761                         return NT_STATUS_OK;
7762                 }
7763
7764                 case NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY: {
7765                         struct spoolss_GetPrintProcessorDirectory *r = (struct spoolss_GetPrintProcessorDirectory *)_r;
7766                         ZERO_STRUCT(r->out);
7767                         r->out.info = talloc_zero(mem_ctx, union spoolss_PrintProcessorDirectoryInfo);
7768                         if (r->out.info == NULL) {
7769                         return NT_STATUS_NO_MEMORY;
7770                         }
7771
7772                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7773                         if (r->out.needed == NULL) {
7774                         return NT_STATUS_NO_MEMORY;
7775                         }
7776
7777                         r->out.result = _spoolss_GetPrintProcessorDirectory(cli->pipes_struct, r);
7778                         return NT_STATUS_OK;
7779                 }
7780
7781                 case NDR_SPOOLSS_STARTDOCPRINTER: {
7782                         struct spoolss_StartDocPrinter *r = (struct spoolss_StartDocPrinter *)_r;
7783                         ZERO_STRUCT(r->out);
7784                         r->out.job_id = talloc_zero(mem_ctx, uint32_t);
7785                         if (r->out.job_id == NULL) {
7786                         return NT_STATUS_NO_MEMORY;
7787                         }
7788
7789                         r->out.result = _spoolss_StartDocPrinter(cli->pipes_struct, r);
7790                         return NT_STATUS_OK;
7791                 }
7792
7793                 case NDR_SPOOLSS_STARTPAGEPRINTER: {
7794                         struct spoolss_StartPagePrinter *r = (struct spoolss_StartPagePrinter *)_r;
7795                         r->out.result = _spoolss_StartPagePrinter(cli->pipes_struct, r);
7796                         return NT_STATUS_OK;
7797                 }
7798
7799                 case NDR_SPOOLSS_WRITEPRINTER: {
7800                         struct spoolss_WritePrinter *r = (struct spoolss_WritePrinter *)_r;
7801                         ZERO_STRUCT(r->out);
7802                         r->out.num_written = talloc_zero(mem_ctx, uint32_t);
7803                         if (r->out.num_written == NULL) {
7804                         return NT_STATUS_NO_MEMORY;
7805                         }
7806
7807                         r->out.result = _spoolss_WritePrinter(cli->pipes_struct, r);
7808                         return NT_STATUS_OK;
7809                 }
7810
7811                 case NDR_SPOOLSS_ENDPAGEPRINTER: {
7812                         struct spoolss_EndPagePrinter *r = (struct spoolss_EndPagePrinter *)_r;
7813                         r->out.result = _spoolss_EndPagePrinter(cli->pipes_struct, r);
7814                         return NT_STATUS_OK;
7815                 }
7816
7817                 case NDR_SPOOLSS_ABORTPRINTER: {
7818                         struct spoolss_AbortPrinter *r = (struct spoolss_AbortPrinter *)_r;
7819                         r->out.result = _spoolss_AbortPrinter(cli->pipes_struct, r);
7820                         return NT_STATUS_OK;
7821                 }
7822
7823                 case NDR_SPOOLSS_READPRINTER: {
7824                         struct spoolss_ReadPrinter *r = (struct spoolss_ReadPrinter *)_r;
7825                         ZERO_STRUCT(r->out);
7826                         r->out.data = talloc_zero_array(mem_ctx, uint8_t, r->in.data_size);
7827                         if (r->out.data == NULL) {
7828                         return NT_STATUS_NO_MEMORY;
7829                         }
7830
7831                         r->out._data_size = talloc_zero(mem_ctx, uint32_t);
7832                         if (r->out._data_size == NULL) {
7833                         return NT_STATUS_NO_MEMORY;
7834                         }
7835
7836                         r->out.result = _spoolss_ReadPrinter(cli->pipes_struct, r);
7837                         return NT_STATUS_OK;
7838                 }
7839
7840                 case NDR_SPOOLSS_ENDDOCPRINTER: {
7841                         struct spoolss_EndDocPrinter *r = (struct spoolss_EndDocPrinter *)_r;
7842                         r->out.result = _spoolss_EndDocPrinter(cli->pipes_struct, r);
7843                         return NT_STATUS_OK;
7844                 }
7845
7846                 case NDR_SPOOLSS_ADDJOB: {
7847                         struct spoolss_AddJob *r = (struct spoolss_AddJob *)_r;
7848                         ZERO_STRUCT(r->out);
7849                         r->out.buffer = r->in.buffer;
7850                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7851                         if (r->out.needed == NULL) {
7852                         return NT_STATUS_NO_MEMORY;
7853                         }
7854
7855                         r->out.result = _spoolss_AddJob(cli->pipes_struct, r);
7856                         return NT_STATUS_OK;
7857                 }
7858
7859                 case NDR_SPOOLSS_SCHEDULEJOB: {
7860                         struct spoolss_ScheduleJob *r = (struct spoolss_ScheduleJob *)_r;
7861                         r->out.result = _spoolss_ScheduleJob(cli->pipes_struct, r);
7862                         return NT_STATUS_OK;
7863                 }
7864
7865                 case NDR_SPOOLSS_GETPRINTERDATA: {
7866                         struct spoolss_GetPrinterData *r = (struct spoolss_GetPrinterData *)_r;
7867                         ZERO_STRUCT(r->out);
7868                         r->out.type = talloc_zero(mem_ctx, enum spoolss_PrinterDataType);
7869                         if (r->out.type == NULL) {
7870                         return NT_STATUS_NO_MEMORY;
7871                         }
7872
7873                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7874                         if (r->out.needed == NULL) {
7875                         return NT_STATUS_NO_MEMORY;
7876                         }
7877
7878                         r->out.result = _spoolss_GetPrinterData(cli->pipes_struct, r);
7879                         return NT_STATUS_OK;
7880                 }
7881
7882                 case NDR_SPOOLSS_SETPRINTERDATA: {
7883                         struct spoolss_SetPrinterData *r = (struct spoolss_SetPrinterData *)_r;
7884                         r->out.result = _spoolss_SetPrinterData(cli->pipes_struct, r);
7885                         return NT_STATUS_OK;
7886                 }
7887
7888                 case NDR_SPOOLSS_WAITFORPRINTERCHANGE: {
7889                         struct spoolss_WaitForPrinterChange *r = (struct spoolss_WaitForPrinterChange *)_r;
7890                         r->out.result = _spoolss_WaitForPrinterChange(cli->pipes_struct, r);
7891                         return NT_STATUS_OK;
7892                 }
7893
7894                 case NDR_SPOOLSS_CLOSEPRINTER: {
7895                         struct spoolss_ClosePrinter *r = (struct spoolss_ClosePrinter *)_r;
7896                         ZERO_STRUCT(r->out);
7897                         r->out.handle = r->in.handle;
7898                         r->out.result = _spoolss_ClosePrinter(cli->pipes_struct, r);
7899                         return NT_STATUS_OK;
7900                 }
7901
7902                 case NDR_SPOOLSS_ADDFORM: {
7903                         struct spoolss_AddForm *r = (struct spoolss_AddForm *)_r;
7904                         r->out.result = _spoolss_AddForm(cli->pipes_struct, r);
7905                         return NT_STATUS_OK;
7906                 }
7907
7908                 case NDR_SPOOLSS_DELETEFORM: {
7909                         struct spoolss_DeleteForm *r = (struct spoolss_DeleteForm *)_r;
7910                         r->out.result = _spoolss_DeleteForm(cli->pipes_struct, r);
7911                         return NT_STATUS_OK;
7912                 }
7913
7914                 case NDR_SPOOLSS_GETFORM: {
7915                         struct spoolss_GetForm *r = (struct spoolss_GetForm *)_r;
7916                         ZERO_STRUCT(r->out);
7917                         r->out.info = talloc_zero(mem_ctx, union spoolss_FormInfo);
7918                         if (r->out.info == NULL) {
7919                         return NT_STATUS_NO_MEMORY;
7920                         }
7921
7922                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7923                         if (r->out.needed == NULL) {
7924                         return NT_STATUS_NO_MEMORY;
7925                         }
7926
7927                         r->out.result = _spoolss_GetForm(cli->pipes_struct, r);
7928                         return NT_STATUS_OK;
7929                 }
7930
7931                 case NDR_SPOOLSS_SETFORM: {
7932                         struct spoolss_SetForm *r = (struct spoolss_SetForm *)_r;
7933                         r->out.result = _spoolss_SetForm(cli->pipes_struct, r);
7934                         return NT_STATUS_OK;
7935                 }
7936
7937                 case NDR_SPOOLSS_ENUMFORMS: {
7938                         struct spoolss_EnumForms *r = (struct spoolss_EnumForms *)_r;
7939                         ZERO_STRUCT(r->out);
7940                         r->out.count = talloc_zero(mem_ctx, uint32_t);
7941                         if (r->out.count == NULL) {
7942                         return NT_STATUS_NO_MEMORY;
7943                         }
7944
7945                         r->out.info = talloc_zero(mem_ctx, union spoolss_FormInfo *);
7946                         if (r->out.info == NULL) {
7947                         return NT_STATUS_NO_MEMORY;
7948                         }
7949
7950                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7951                         if (r->out.needed == NULL) {
7952                         return NT_STATUS_NO_MEMORY;
7953                         }
7954
7955                         r->out.result = _spoolss_EnumForms(cli->pipes_struct, r);
7956                         return NT_STATUS_OK;
7957                 }
7958
7959                 case NDR_SPOOLSS_ENUMPORTS: {
7960                         struct spoolss_EnumPorts *r = (struct spoolss_EnumPorts *)_r;
7961                         ZERO_STRUCT(r->out);
7962                         r->out.count = talloc_zero(mem_ctx, uint32_t);
7963                         if (r->out.count == NULL) {
7964                         return NT_STATUS_NO_MEMORY;
7965                         }
7966
7967                         r->out.info = talloc_zero(mem_ctx, union spoolss_PortInfo *);
7968                         if (r->out.info == NULL) {
7969                         return NT_STATUS_NO_MEMORY;
7970                         }
7971
7972                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7973                         if (r->out.needed == NULL) {
7974                         return NT_STATUS_NO_MEMORY;
7975                         }
7976
7977                         r->out.result = _spoolss_EnumPorts(cli->pipes_struct, r);
7978                         return NT_STATUS_OK;
7979                 }
7980
7981                 case NDR_SPOOLSS_ENUMMONITORS: {
7982                         struct spoolss_EnumMonitors *r = (struct spoolss_EnumMonitors *)_r;
7983                         ZERO_STRUCT(r->out);
7984                         r->out.count = talloc_zero(mem_ctx, uint32_t);
7985                         if (r->out.count == NULL) {
7986                         return NT_STATUS_NO_MEMORY;
7987                         }
7988
7989                         r->out.info = talloc_zero(mem_ctx, union spoolss_MonitorInfo *);
7990                         if (r->out.info == NULL) {
7991                         return NT_STATUS_NO_MEMORY;
7992                         }
7993
7994                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
7995                         if (r->out.needed == NULL) {
7996                         return NT_STATUS_NO_MEMORY;
7997                         }
7998
7999                         r->out.result = _spoolss_EnumMonitors(cli->pipes_struct, r);
8000                         return NT_STATUS_OK;
8001                 }
8002
8003                 case NDR_SPOOLSS_ADDPORT: {
8004                         struct spoolss_AddPort *r = (struct spoolss_AddPort *)_r;
8005                         r->out.result = _spoolss_AddPort(cli->pipes_struct, r);
8006                         return NT_STATUS_OK;
8007                 }
8008
8009                 case NDR_SPOOLSS_CONFIGUREPORT: {
8010                         struct spoolss_ConfigurePort *r = (struct spoolss_ConfigurePort *)_r;
8011                         r->out.result = _spoolss_ConfigurePort(cli->pipes_struct, r);
8012                         return NT_STATUS_OK;
8013                 }
8014
8015                 case NDR_SPOOLSS_DELETEPORT: {
8016                         struct spoolss_DeletePort *r = (struct spoolss_DeletePort *)_r;
8017                         r->out.result = _spoolss_DeletePort(cli->pipes_struct, r);
8018                         return NT_STATUS_OK;
8019                 }
8020
8021                 case NDR_SPOOLSS_CREATEPRINTERIC: {
8022                         struct spoolss_CreatePrinterIC *r = (struct spoolss_CreatePrinterIC *)_r;
8023                         r->out.result = _spoolss_CreatePrinterIC(cli->pipes_struct, r);
8024                         return NT_STATUS_OK;
8025                 }
8026
8027                 case NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC: {
8028                         struct spoolss_PlayGDIScriptOnPrinterIC *r = (struct spoolss_PlayGDIScriptOnPrinterIC *)_r;
8029                         r->out.result = _spoolss_PlayGDIScriptOnPrinterIC(cli->pipes_struct, r);
8030                         return NT_STATUS_OK;
8031                 }
8032
8033                 case NDR_SPOOLSS_DELETEPRINTERIC: {
8034                         struct spoolss_DeletePrinterIC *r = (struct spoolss_DeletePrinterIC *)_r;
8035                         r->out.result = _spoolss_DeletePrinterIC(cli->pipes_struct, r);
8036                         return NT_STATUS_OK;
8037                 }
8038
8039                 case NDR_SPOOLSS_ADDPRINTERCONNECTION: {
8040                         struct spoolss_AddPrinterConnection *r = (struct spoolss_AddPrinterConnection *)_r;
8041                         r->out.result = _spoolss_AddPrinterConnection(cli->pipes_struct, r);
8042                         return NT_STATUS_OK;
8043                 }
8044
8045                 case NDR_SPOOLSS_DELETEPRINTERCONNECTION: {
8046                         struct spoolss_DeletePrinterConnection *r = (struct spoolss_DeletePrinterConnection *)_r;
8047                         r->out.result = _spoolss_DeletePrinterConnection(cli->pipes_struct, r);
8048                         return NT_STATUS_OK;
8049                 }
8050
8051                 case NDR_SPOOLSS_PRINTERMESSAGEBOX: {
8052                         struct spoolss_PrinterMessageBox *r = (struct spoolss_PrinterMessageBox *)_r;
8053                         r->out.result = _spoolss_PrinterMessageBox(cli->pipes_struct, r);
8054                         return NT_STATUS_OK;
8055                 }
8056
8057                 case NDR_SPOOLSS_ADDMONITOR: {
8058                         struct spoolss_AddMonitor *r = (struct spoolss_AddMonitor *)_r;
8059                         r->out.result = _spoolss_AddMonitor(cli->pipes_struct, r);
8060                         return NT_STATUS_OK;
8061                 }
8062
8063                 case NDR_SPOOLSS_DELETEMONITOR: {
8064                         struct spoolss_DeleteMonitor *r = (struct spoolss_DeleteMonitor *)_r;
8065                         r->out.result = _spoolss_DeleteMonitor(cli->pipes_struct, r);
8066                         return NT_STATUS_OK;
8067                 }
8068
8069                 case NDR_SPOOLSS_DELETEPRINTPROCESSOR: {
8070                         struct spoolss_DeletePrintProcessor *r = (struct spoolss_DeletePrintProcessor *)_r;
8071                         r->out.result = _spoolss_DeletePrintProcessor(cli->pipes_struct, r);
8072                         return NT_STATUS_OK;
8073                 }
8074
8075                 case NDR_SPOOLSS_ADDPRINTPROVIDOR: {
8076                         struct spoolss_AddPrintProvidor *r = (struct spoolss_AddPrintProvidor *)_r;
8077                         r->out.result = _spoolss_AddPrintProvidor(cli->pipes_struct, r);
8078                         return NT_STATUS_OK;
8079                 }
8080
8081                 case NDR_SPOOLSS_DELETEPRINTPROVIDOR: {
8082                         struct spoolss_DeletePrintProvidor *r = (struct spoolss_DeletePrintProvidor *)_r;
8083                         r->out.result = _spoolss_DeletePrintProvidor(cli->pipes_struct, r);
8084                         return NT_STATUS_OK;
8085                 }
8086
8087                 case NDR_SPOOLSS_ENUMPRINTPROCDATATYPES: {
8088                         struct spoolss_EnumPrintProcDataTypes *r = (struct spoolss_EnumPrintProcDataTypes *)_r;
8089                         ZERO_STRUCT(r->out);
8090                         r->out.count = talloc_zero(mem_ctx, uint32_t);
8091                         if (r->out.count == NULL) {
8092                         return NT_STATUS_NO_MEMORY;
8093                         }
8094
8095                         r->out.info = talloc_zero(mem_ctx, union spoolss_PrintProcDataTypesInfo *);
8096                         if (r->out.info == NULL) {
8097                         return NT_STATUS_NO_MEMORY;
8098                         }
8099
8100                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
8101                         if (r->out.needed == NULL) {
8102                         return NT_STATUS_NO_MEMORY;
8103                         }
8104
8105                         r->out.result = _spoolss_EnumPrintProcDataTypes(cli->pipes_struct, r);
8106                         return NT_STATUS_OK;
8107                 }
8108
8109                 case NDR_SPOOLSS_RESETPRINTER: {
8110                         struct spoolss_ResetPrinter *r = (struct spoolss_ResetPrinter *)_r;
8111                         r->out.result = _spoolss_ResetPrinter(cli->pipes_struct, r);
8112                         return NT_STATUS_OK;
8113                 }
8114
8115                 case NDR_SPOOLSS_GETPRINTERDRIVER2: {
8116                         struct spoolss_GetPrinterDriver2 *r = (struct spoolss_GetPrinterDriver2 *)_r;
8117                         ZERO_STRUCT(r->out);
8118                         r->out.info = talloc_zero(mem_ctx, union spoolss_DriverInfo);
8119                         if (r->out.info == NULL) {
8120                         return NT_STATUS_NO_MEMORY;
8121                         }
8122
8123                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
8124                         if (r->out.needed == NULL) {
8125                         return NT_STATUS_NO_MEMORY;
8126                         }
8127
8128                         r->out.server_major_version = talloc_zero(mem_ctx, uint32_t);
8129                         if (r->out.server_major_version == NULL) {
8130                         return NT_STATUS_NO_MEMORY;
8131                         }
8132
8133                         r->out.server_minor_version = talloc_zero(mem_ctx, uint32_t);
8134                         if (r->out.server_minor_version == NULL) {
8135                         return NT_STATUS_NO_MEMORY;
8136                         }
8137
8138                         r->out.result = _spoolss_GetPrinterDriver2(cli->pipes_struct, r);
8139                         return NT_STATUS_OK;
8140                 }
8141
8142                 case NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION: {
8143                         struct spoolss_FindFirstPrinterChangeNotification *r = (struct spoolss_FindFirstPrinterChangeNotification *)_r;
8144                         r->out.result = _spoolss_FindFirstPrinterChangeNotification(cli->pipes_struct, r);
8145                         return NT_STATUS_OK;
8146                 }
8147
8148                 case NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION: {
8149                         struct spoolss_FindNextPrinterChangeNotification *r = (struct spoolss_FindNextPrinterChangeNotification *)_r;
8150                         r->out.result = _spoolss_FindNextPrinterChangeNotification(cli->pipes_struct, r);
8151                         return NT_STATUS_OK;
8152                 }
8153
8154                 case NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY: {
8155                         struct spoolss_FindClosePrinterNotify *r = (struct spoolss_FindClosePrinterNotify *)_r;
8156                         r->out.result = _spoolss_FindClosePrinterNotify(cli->pipes_struct, r);
8157                         return NT_STATUS_OK;
8158                 }
8159
8160                 case NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD: {
8161                         struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r = (struct spoolss_RouterFindFirstPrinterChangeNotificationOld *)_r;
8162                         r->out.result = _spoolss_RouterFindFirstPrinterChangeNotificationOld(cli->pipes_struct, r);
8163                         return NT_STATUS_OK;
8164                 }
8165
8166                 case NDR_SPOOLSS_REPLYOPENPRINTER: {
8167                         struct spoolss_ReplyOpenPrinter *r = (struct spoolss_ReplyOpenPrinter *)_r;
8168                         ZERO_STRUCT(r->out);
8169                         r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
8170                         if (r->out.handle == NULL) {
8171                         return NT_STATUS_NO_MEMORY;
8172                         }
8173
8174                         r->out.result = _spoolss_ReplyOpenPrinter(cli->pipes_struct, r);
8175                         return NT_STATUS_OK;
8176                 }
8177
8178                 case NDR_SPOOLSS_ROUTERREPLYPRINTER: {
8179                         struct spoolss_RouterReplyPrinter *r = (struct spoolss_RouterReplyPrinter *)_r;
8180                         r->out.result = _spoolss_RouterReplyPrinter(cli->pipes_struct, r);
8181                         return NT_STATUS_OK;
8182                 }
8183
8184                 case NDR_SPOOLSS_REPLYCLOSEPRINTER: {
8185                         struct spoolss_ReplyClosePrinter *r = (struct spoolss_ReplyClosePrinter *)_r;
8186                         ZERO_STRUCT(r->out);
8187                         r->out.handle = r->in.handle;
8188                         r->out.result = _spoolss_ReplyClosePrinter(cli->pipes_struct, r);
8189                         return NT_STATUS_OK;
8190                 }
8191
8192                 case NDR_SPOOLSS_ADDPORTEX: {
8193                         struct spoolss_AddPortEx *r = (struct spoolss_AddPortEx *)_r;
8194                         r->out.result = _spoolss_AddPortEx(cli->pipes_struct, r);
8195                         return NT_STATUS_OK;
8196                 }
8197
8198                 case NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION: {
8199                         struct spoolss_RouterFindFirstPrinterChangeNotification *r = (struct spoolss_RouterFindFirstPrinterChangeNotification *)_r;
8200                         r->out.result = _spoolss_RouterFindFirstPrinterChangeNotification(cli->pipes_struct, r);
8201                         return NT_STATUS_OK;
8202                 }
8203
8204                 case NDR_SPOOLSS_SPOOLERINIT: {
8205                         struct spoolss_SpoolerInit *r = (struct spoolss_SpoolerInit *)_r;
8206                         r->out.result = _spoolss_SpoolerInit(cli->pipes_struct, r);
8207                         return NT_STATUS_OK;
8208                 }
8209
8210                 case NDR_SPOOLSS_RESETPRINTEREX: {
8211                         struct spoolss_ResetPrinterEx *r = (struct spoolss_ResetPrinterEx *)_r;
8212                         r->out.result = _spoolss_ResetPrinterEx(cli->pipes_struct, r);
8213                         return NT_STATUS_OK;
8214                 }
8215
8216                 case NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX: {
8217                         struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r = (struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *)_r;
8218                         r->out.result = _spoolss_RemoteFindFirstPrinterChangeNotifyEx(cli->pipes_struct, r);
8219                         return NT_STATUS_OK;
8220                 }
8221
8222                 case NDR_SPOOLSS_ROUTERREPLYPRINTEREX: {
8223                         struct spoolss_RouterReplyPrinterEx *r = (struct spoolss_RouterReplyPrinterEx *)_r;
8224                         ZERO_STRUCT(r->out);
8225                         r->out.reply_result = talloc_zero(mem_ctx, uint32_t);
8226                         if (r->out.reply_result == NULL) {
8227                         return NT_STATUS_NO_MEMORY;
8228                         }
8229
8230                         r->out.result = _spoolss_RouterReplyPrinterEx(cli->pipes_struct, r);
8231                         return NT_STATUS_OK;
8232                 }
8233
8234                 case NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY: {
8235                         struct spoolss_RouterRefreshPrinterChangeNotify *r = (struct spoolss_RouterRefreshPrinterChangeNotify *)_r;
8236                         ZERO_STRUCT(r->out);
8237                         r->out.info = talloc_zero(mem_ctx, struct spoolss_NotifyInfo *);
8238                         if (r->out.info == NULL) {
8239                         return NT_STATUS_NO_MEMORY;
8240                         }
8241
8242                         r->out.result = _spoolss_RouterRefreshPrinterChangeNotify(cli->pipes_struct, r);
8243                         return NT_STATUS_OK;
8244                 }
8245
8246                 case NDR_SPOOLSS_44: {
8247                         struct spoolss_44 *r = (struct spoolss_44 *)_r;
8248                         r->out.result = _spoolss_44(cli->pipes_struct, r);
8249                         return NT_STATUS_OK;
8250                 }
8251
8252                 case NDR_SPOOLSS_OPENPRINTEREX: {
8253                         struct spoolss_OpenPrinterEx *r = (struct spoolss_OpenPrinterEx *)_r;
8254                         ZERO_STRUCT(r->out);
8255                         r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
8256                         if (r->out.handle == NULL) {
8257                         return NT_STATUS_NO_MEMORY;
8258                         }
8259
8260                         r->out.result = _spoolss_OpenPrinterEx(cli->pipes_struct, r);
8261                         return NT_STATUS_OK;
8262                 }
8263
8264                 case NDR_SPOOLSS_ADDPRINTEREX: {
8265                         struct spoolss_AddPrinterEx *r = (struct spoolss_AddPrinterEx *)_r;
8266                         ZERO_STRUCT(r->out);
8267                         r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
8268                         if (r->out.handle == NULL) {
8269                         return NT_STATUS_NO_MEMORY;
8270                         }
8271
8272                         r->out.result = _spoolss_AddPrinterEx(cli->pipes_struct, r);
8273                         return NT_STATUS_OK;
8274                 }
8275
8276                 case NDR_SPOOLSS_47: {
8277                         struct spoolss_47 *r = (struct spoolss_47 *)_r;
8278                         r->out.result = _spoolss_47(cli->pipes_struct, r);
8279                         return NT_STATUS_OK;
8280                 }
8281
8282                 case NDR_SPOOLSS_ENUMPRINTERDATA: {
8283                         struct spoolss_EnumPrinterData *r = (struct spoolss_EnumPrinterData *)_r;
8284                         ZERO_STRUCT(r->out);
8285                         r->out.value_name = talloc_zero_array(mem_ctx, const char, r->in.value_offered / 2);
8286                         if (r->out.value_name == NULL) {
8287                         return NT_STATUS_NO_MEMORY;
8288                         }
8289
8290                         r->out.value_needed = talloc_zero(mem_ctx, uint32_t);
8291                         if (r->out.value_needed == NULL) {
8292                         return NT_STATUS_NO_MEMORY;
8293                         }
8294
8295                         r->out.printerdata_type = talloc_zero(mem_ctx, uint32_t);
8296                         if (r->out.printerdata_type == NULL) {
8297                         return NT_STATUS_NO_MEMORY;
8298                         }
8299
8300                         r->out.buffer = talloc_zero(mem_ctx, DATA_BLOB);
8301                         if (r->out.buffer == NULL) {
8302                         return NT_STATUS_NO_MEMORY;
8303                         }
8304
8305                         r->out.data_needed = talloc_zero(mem_ctx, uint32_t);
8306                         if (r->out.data_needed == NULL) {
8307                         return NT_STATUS_NO_MEMORY;
8308                         }
8309
8310                         r->out.result = _spoolss_EnumPrinterData(cli->pipes_struct, r);
8311                         return NT_STATUS_OK;
8312                 }
8313
8314                 case NDR_SPOOLSS_DELETEPRINTERDATA: {
8315                         struct spoolss_DeletePrinterData *r = (struct spoolss_DeletePrinterData *)_r;
8316                         r->out.result = _spoolss_DeletePrinterData(cli->pipes_struct, r);
8317                         return NT_STATUS_OK;
8318                 }
8319
8320                 case NDR_SPOOLSS_4A: {
8321                         struct spoolss_4a *r = (struct spoolss_4a *)_r;
8322                         r->out.result = _spoolss_4a(cli->pipes_struct, r);
8323                         return NT_STATUS_OK;
8324                 }
8325
8326                 case NDR_SPOOLSS_4B: {
8327                         struct spoolss_4b *r = (struct spoolss_4b *)_r;
8328                         r->out.result = _spoolss_4b(cli->pipes_struct, r);
8329                         return NT_STATUS_OK;
8330                 }
8331
8332                 case NDR_SPOOLSS_4C: {
8333                         struct spoolss_4c *r = (struct spoolss_4c *)_r;
8334                         r->out.result = _spoolss_4c(cli->pipes_struct, r);
8335                         return NT_STATUS_OK;
8336                 }
8337
8338                 case NDR_SPOOLSS_SETPRINTERDATAEX: {
8339                         struct spoolss_SetPrinterDataEx *r = (struct spoolss_SetPrinterDataEx *)_r;
8340                         r->out.result = _spoolss_SetPrinterDataEx(cli->pipes_struct, r);
8341                         return NT_STATUS_OK;
8342                 }
8343
8344                 case NDR_SPOOLSS_GETPRINTERDATAEX: {
8345                         struct spoolss_GetPrinterDataEx *r = (struct spoolss_GetPrinterDataEx *)_r;
8346                         ZERO_STRUCT(r->out);
8347                         r->out.type = talloc_zero(mem_ctx, uint32_t);
8348                         if (r->out.type == NULL) {
8349                         return NT_STATUS_NO_MEMORY;
8350                         }
8351
8352                         r->out.buffer = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
8353                         if (r->out.buffer == NULL) {
8354                         return NT_STATUS_NO_MEMORY;
8355                         }
8356
8357                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
8358                         if (r->out.needed == NULL) {
8359                         return NT_STATUS_NO_MEMORY;
8360                         }
8361
8362                         r->out.result = _spoolss_GetPrinterDataEx(cli->pipes_struct, r);
8363                         return NT_STATUS_OK;
8364                 }
8365
8366                 case NDR_SPOOLSS_ENUMPRINTERDATAEX: {
8367                         struct spoolss_EnumPrinterDataEx *r = (struct spoolss_EnumPrinterDataEx *)_r;
8368                         ZERO_STRUCT(r->out);
8369                         r->out.buffer = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
8370                         if (r->out.buffer == NULL) {
8371                         return NT_STATUS_NO_MEMORY;
8372                         }
8373
8374                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
8375                         if (r->out.needed == NULL) {
8376                         return NT_STATUS_NO_MEMORY;
8377                         }
8378
8379                         r->out.count = talloc_zero(mem_ctx, uint32_t);
8380                         if (r->out.count == NULL) {
8381                         return NT_STATUS_NO_MEMORY;
8382                         }
8383
8384                         r->out.result = _spoolss_EnumPrinterDataEx(cli->pipes_struct, r);
8385                         return NT_STATUS_OK;
8386                 }
8387
8388                 case NDR_SPOOLSS_ENUMPRINTERKEY: {
8389                         struct spoolss_EnumPrinterKey *r = (struct spoolss_EnumPrinterKey *)_r;
8390                         ZERO_STRUCT(r->out);
8391                         r->out.key_buffer = talloc_zero_array(mem_ctx, uint16_t, r->in.key_buffer_size / 2);
8392                         if (r->out.key_buffer == NULL) {
8393                         return NT_STATUS_NO_MEMORY;
8394                         }
8395
8396                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
8397                         if (r->out.needed == NULL) {
8398                         return NT_STATUS_NO_MEMORY;
8399                         }
8400
8401                         r->out.result = _spoolss_EnumPrinterKey(cli->pipes_struct, r);
8402                         return NT_STATUS_OK;
8403                 }
8404
8405                 case NDR_SPOOLSS_DELETEPRINTERDATAEX: {
8406                         struct spoolss_DeletePrinterDataEx *r = (struct spoolss_DeletePrinterDataEx *)_r;
8407                         r->out.result = _spoolss_DeletePrinterDataEx(cli->pipes_struct, r);
8408                         return NT_STATUS_OK;
8409                 }
8410
8411                 case NDR_SPOOLSS_DELETEPRINTERKEY: {
8412                         struct spoolss_DeletePrinterKey *r = (struct spoolss_DeletePrinterKey *)_r;
8413                         r->out.result = _spoolss_DeletePrinterKey(cli->pipes_struct, r);
8414                         return NT_STATUS_OK;
8415                 }
8416
8417                 case NDR_SPOOLSS_53: {
8418                         struct spoolss_53 *r = (struct spoolss_53 *)_r;
8419                         r->out.result = _spoolss_53(cli->pipes_struct, r);
8420                         return NT_STATUS_OK;
8421                 }
8422
8423                 case NDR_SPOOLSS_DELETEPRINTERDRIVEREX: {
8424                         struct spoolss_DeletePrinterDriverEx *r = (struct spoolss_DeletePrinterDriverEx *)_r;
8425                         r->out.result = _spoolss_DeletePrinterDriverEx(cli->pipes_struct, r);
8426                         return NT_STATUS_OK;
8427                 }
8428
8429                 case NDR_SPOOLSS_55: {
8430                         struct spoolss_55 *r = (struct spoolss_55 *)_r;
8431                         r->out.result = _spoolss_55(cli->pipes_struct, r);
8432                         return NT_STATUS_OK;
8433                 }
8434
8435                 case NDR_SPOOLSS_56: {
8436                         struct spoolss_56 *r = (struct spoolss_56 *)_r;
8437                         r->out.result = _spoolss_56(cli->pipes_struct, r);
8438                         return NT_STATUS_OK;
8439                 }
8440
8441                 case NDR_SPOOLSS_57: {
8442                         struct spoolss_57 *r = (struct spoolss_57 *)_r;
8443                         r->out.result = _spoolss_57(cli->pipes_struct, r);
8444                         return NT_STATUS_OK;
8445                 }
8446
8447                 case NDR_SPOOLSS_XCVDATA: {
8448                         struct spoolss_XcvData *r = (struct spoolss_XcvData *)_r;
8449                         ZERO_STRUCT(r->out);
8450                         r->out.status_code = r->in.status_code;
8451                         r->out.out_data = talloc_zero_array(mem_ctx, uint8_t, r->in.out_data_size);
8452                         if (r->out.out_data == NULL) {
8453                         return NT_STATUS_NO_MEMORY;
8454                         }
8455
8456                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
8457                         if (r->out.needed == NULL) {
8458                         return NT_STATUS_NO_MEMORY;
8459                         }
8460
8461                         r->out.result = _spoolss_XcvData(cli->pipes_struct, r);
8462                         return NT_STATUS_OK;
8463                 }
8464
8465                 case NDR_SPOOLSS_ADDPRINTERDRIVEREX: {
8466                         struct spoolss_AddPrinterDriverEx *r = (struct spoolss_AddPrinterDriverEx *)_r;
8467                         r->out.result = _spoolss_AddPrinterDriverEx(cli->pipes_struct, r);
8468                         return NT_STATUS_OK;
8469                 }
8470
8471                 case NDR_SPOOLSS_5A: {
8472                         struct spoolss_5a *r = (struct spoolss_5a *)_r;
8473                         r->out.result = _spoolss_5a(cli->pipes_struct, r);
8474                         return NT_STATUS_OK;
8475                 }
8476
8477                 case NDR_SPOOLSS_5B: {
8478                         struct spoolss_5b *r = (struct spoolss_5b *)_r;
8479                         r->out.result = _spoolss_5b(cli->pipes_struct, r);
8480                         return NT_STATUS_OK;
8481                 }
8482
8483                 case NDR_SPOOLSS_5C: {
8484                         struct spoolss_5c *r = (struct spoolss_5c *)_r;
8485                         r->out.result = _spoolss_5c(cli->pipes_struct, r);
8486                         return NT_STATUS_OK;
8487                 }
8488
8489                 case NDR_SPOOLSS_5D: {
8490                         struct spoolss_5d *r = (struct spoolss_5d *)_r;
8491                         r->out.result = _spoolss_5d(cli->pipes_struct, r);
8492                         return NT_STATUS_OK;
8493                 }
8494
8495                 case NDR_SPOOLSS_5E: {
8496                         struct spoolss_5e *r = (struct spoolss_5e *)_r;
8497                         r->out.result = _spoolss_5e(cli->pipes_struct, r);
8498                         return NT_STATUS_OK;
8499                 }
8500
8501                 case NDR_SPOOLSS_5F: {
8502                         struct spoolss_5f *r = (struct spoolss_5f *)_r;
8503                         r->out.result = _spoolss_5f(cli->pipes_struct, r);
8504                         return NT_STATUS_OK;
8505                 }
8506
8507                 default:
8508                         return NT_STATUS_NOT_IMPLEMENTED;
8509         }
8510 }
8511
8512 NTSTATUS rpc_spoolss_init(void)
8513 {
8514         return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "spoolss", "spoolss", &ndr_table_spoolss, api_spoolss_cmds, sizeof(api_spoolss_cmds) / sizeof(struct api_struct));
8515 }