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