2 * Unix SMB/CIFS implementation.
3 * server auto-generated by pidl. DO NOT MODIFY!
7 #include "../librpc/gen_ndr/srv_spoolss.h"
9 static bool api_spoolss_EnumPrinters(pipes_struct *p)
11 const struct ndr_interface_call *call;
12 struct ndr_pull *pull;
13 struct ndr_push *push;
14 enum ndr_err_code ndr_err;
16 struct spoolss_EnumPrinters *r;
18 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPRINTERS];
20 r = talloc(talloc_tos(), struct spoolss_EnumPrinters);
25 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
30 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
43 if (DEBUGLEVEL >= 10) {
44 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinters, r);
48 r->out.count = talloc_zero(r, uint32_t);
49 if (r->out.count == NULL) {
54 r->out.info = talloc_zero(r, union spoolss_PrinterInfo *);
55 if (r->out.info == NULL) {
60 r->out.needed = talloc_zero(r, uint32_t);
61 if (r->out.needed == NULL) {
66 r->out.result = _spoolss_EnumPrinters(p, r);
68 if (p->rng_fault_state) {
70 /* Return true here, srv_pipe_hnd.c will take care */
74 if (DEBUGLEVEL >= 10) {
75 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinters, r);
78 push = ndr_push_init_ctx(r, NULL);
84 ndr_err = call->ndr_push(push, NDR_OUT, r);
85 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
90 blob = ndr_push_blob(push);
91 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
101 static bool api_spoolss_OpenPrinter(pipes_struct *p)
103 const struct ndr_interface_call *call;
104 struct ndr_pull *pull;
105 struct ndr_push *push;
106 enum ndr_err_code ndr_err;
108 struct spoolss_OpenPrinter *r;
110 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_OPENPRINTER];
112 r = talloc(talloc_tos(), struct spoolss_OpenPrinter);
117 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
122 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
135 if (DEBUGLEVEL >= 10) {
136 NDR_PRINT_IN_DEBUG(spoolss_OpenPrinter, r);
140 r->out.handle = talloc_zero(r, struct policy_handle);
141 if (r->out.handle == NULL) {
146 r->out.result = _spoolss_OpenPrinter(p, r);
148 if (p->rng_fault_state) {
150 /* Return true here, srv_pipe_hnd.c will take care */
154 if (DEBUGLEVEL >= 10) {
155 NDR_PRINT_OUT_DEBUG(spoolss_OpenPrinter, r);
158 push = ndr_push_init_ctx(r, NULL);
164 ndr_err = call->ndr_push(push, NDR_OUT, r);
165 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
170 blob = ndr_push_blob(push);
171 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
181 static bool api_spoolss_SetJob(pipes_struct *p)
183 const struct ndr_interface_call *call;
184 struct ndr_pull *pull;
185 struct ndr_push *push;
186 enum ndr_err_code ndr_err;
188 struct spoolss_SetJob *r;
190 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_SETJOB];
192 r = talloc(talloc_tos(), struct spoolss_SetJob);
197 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
202 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
215 if (DEBUGLEVEL >= 10) {
216 NDR_PRINT_IN_DEBUG(spoolss_SetJob, r);
219 r->out.result = _spoolss_SetJob(p, r);
221 if (p->rng_fault_state) {
223 /* Return true here, srv_pipe_hnd.c will take care */
227 if (DEBUGLEVEL >= 10) {
228 NDR_PRINT_OUT_DEBUG(spoolss_SetJob, r);
231 push = ndr_push_init_ctx(r, NULL);
237 ndr_err = call->ndr_push(push, NDR_OUT, r);
238 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
243 blob = ndr_push_blob(push);
244 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
254 static bool api_spoolss_GetJob(pipes_struct *p)
256 const struct ndr_interface_call *call;
257 struct ndr_pull *pull;
258 struct ndr_push *push;
259 enum ndr_err_code ndr_err;
261 struct spoolss_GetJob *r;
263 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETJOB];
265 r = talloc(talloc_tos(), struct spoolss_GetJob);
270 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
275 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
288 if (DEBUGLEVEL >= 10) {
289 NDR_PRINT_IN_DEBUG(spoolss_GetJob, r);
293 r->out.info = talloc_zero(r, union spoolss_JobInfo);
294 if (r->out.info == NULL) {
299 r->out.needed = talloc_zero(r, uint32_t);
300 if (r->out.needed == NULL) {
305 r->out.result = _spoolss_GetJob(p, r);
307 if (p->rng_fault_state) {
309 /* Return true here, srv_pipe_hnd.c will take care */
313 if (DEBUGLEVEL >= 10) {
314 NDR_PRINT_OUT_DEBUG(spoolss_GetJob, r);
317 push = ndr_push_init_ctx(r, NULL);
323 ndr_err = call->ndr_push(push, NDR_OUT, r);
324 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
329 blob = ndr_push_blob(push);
330 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
340 static bool api_spoolss_EnumJobs(pipes_struct *p)
342 const struct ndr_interface_call *call;
343 struct ndr_pull *pull;
344 struct ndr_push *push;
345 enum ndr_err_code ndr_err;
347 struct spoolss_EnumJobs *r;
349 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMJOBS];
351 r = talloc(talloc_tos(), struct spoolss_EnumJobs);
356 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
361 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
374 if (DEBUGLEVEL >= 10) {
375 NDR_PRINT_IN_DEBUG(spoolss_EnumJobs, r);
379 r->out.count = talloc_zero(r, uint32_t);
380 if (r->out.count == NULL) {
385 r->out.info = talloc_zero(r, union spoolss_JobInfo *);
386 if (r->out.info == NULL) {
391 r->out.needed = talloc_zero(r, uint32_t);
392 if (r->out.needed == NULL) {
397 r->out.result = _spoolss_EnumJobs(p, r);
399 if (p->rng_fault_state) {
401 /* Return true here, srv_pipe_hnd.c will take care */
405 if (DEBUGLEVEL >= 10) {
406 NDR_PRINT_OUT_DEBUG(spoolss_EnumJobs, r);
409 push = ndr_push_init_ctx(r, NULL);
415 ndr_err = call->ndr_push(push, NDR_OUT, r);
416 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
421 blob = ndr_push_blob(push);
422 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
432 static bool api_spoolss_AddPrinter(pipes_struct *p)
434 const struct ndr_interface_call *call;
435 struct ndr_pull *pull;
436 struct ndr_push *push;
437 enum ndr_err_code ndr_err;
439 struct spoolss_AddPrinter *r;
441 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTER];
443 r = talloc(talloc_tos(), struct spoolss_AddPrinter);
448 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
453 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
466 if (DEBUGLEVEL >= 10) {
467 NDR_PRINT_IN_DEBUG(spoolss_AddPrinter, r);
471 r->out.handle = talloc_zero(r, struct policy_handle);
472 if (r->out.handle == NULL) {
477 r->out.result = _spoolss_AddPrinter(p, r);
479 if (p->rng_fault_state) {
481 /* Return true here, srv_pipe_hnd.c will take care */
485 if (DEBUGLEVEL >= 10) {
486 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinter, r);
489 push = ndr_push_init_ctx(r, NULL);
495 ndr_err = call->ndr_push(push, NDR_OUT, r);
496 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
501 blob = ndr_push_blob(push);
502 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
512 static bool api_spoolss_DeletePrinter(pipes_struct *p)
514 const struct ndr_interface_call *call;
515 struct ndr_pull *pull;
516 struct ndr_push *push;
517 enum ndr_err_code ndr_err;
519 struct spoolss_DeletePrinter *r;
521 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTER];
523 r = talloc(talloc_tos(), struct spoolss_DeletePrinter);
528 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
533 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
546 if (DEBUGLEVEL >= 10) {
547 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinter, r);
550 r->out.result = _spoolss_DeletePrinter(p, r);
552 if (p->rng_fault_state) {
554 /* Return true here, srv_pipe_hnd.c will take care */
558 if (DEBUGLEVEL >= 10) {
559 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinter, r);
562 push = ndr_push_init_ctx(r, NULL);
568 ndr_err = call->ndr_push(push, NDR_OUT, r);
569 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
574 blob = ndr_push_blob(push);
575 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
585 static bool api_spoolss_SetPrinter(pipes_struct *p)
587 const struct ndr_interface_call *call;
588 struct ndr_pull *pull;
589 struct ndr_push *push;
590 enum ndr_err_code ndr_err;
592 struct spoolss_SetPrinter *r;
594 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_SETPRINTER];
596 r = talloc(talloc_tos(), struct spoolss_SetPrinter);
601 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
606 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
619 if (DEBUGLEVEL >= 10) {
620 NDR_PRINT_IN_DEBUG(spoolss_SetPrinter, r);
623 r->out.result = _spoolss_SetPrinter(p, r);
625 if (p->rng_fault_state) {
627 /* Return true here, srv_pipe_hnd.c will take care */
631 if (DEBUGLEVEL >= 10) {
632 NDR_PRINT_OUT_DEBUG(spoolss_SetPrinter, r);
635 push = ndr_push_init_ctx(r, NULL);
641 ndr_err = call->ndr_push(push, NDR_OUT, r);
642 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
647 blob = ndr_push_blob(push);
648 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
658 static bool api_spoolss_GetPrinter(pipes_struct *p)
660 const struct ndr_interface_call *call;
661 struct ndr_pull *pull;
662 struct ndr_push *push;
663 enum ndr_err_code ndr_err;
665 struct spoolss_GetPrinter *r;
667 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTER];
669 r = talloc(talloc_tos(), struct spoolss_GetPrinter);
674 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
679 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
692 if (DEBUGLEVEL >= 10) {
693 NDR_PRINT_IN_DEBUG(spoolss_GetPrinter, r);
697 r->out.info = talloc_zero(r, union spoolss_PrinterInfo);
698 if (r->out.info == NULL) {
703 r->out.needed = talloc_zero(r, uint32_t);
704 if (r->out.needed == NULL) {
709 r->out.result = _spoolss_GetPrinter(p, r);
711 if (p->rng_fault_state) {
713 /* Return true here, srv_pipe_hnd.c will take care */
717 if (DEBUGLEVEL >= 10) {
718 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinter, r);
721 push = ndr_push_init_ctx(r, NULL);
727 ndr_err = call->ndr_push(push, NDR_OUT, r);
728 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
733 blob = ndr_push_blob(push);
734 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
744 static bool api_spoolss_AddPrinterDriver(pipes_struct *p)
746 const struct ndr_interface_call *call;
747 struct ndr_pull *pull;
748 struct ndr_push *push;
749 enum ndr_err_code ndr_err;
751 struct spoolss_AddPrinterDriver *r;
753 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTERDRIVER];
755 r = talloc(talloc_tos(), struct spoolss_AddPrinterDriver);
760 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
765 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
778 if (DEBUGLEVEL >= 10) {
779 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterDriver, r);
782 r->out.result = _spoolss_AddPrinterDriver(p, r);
784 if (p->rng_fault_state) {
786 /* Return true here, srv_pipe_hnd.c will take care */
790 if (DEBUGLEVEL >= 10) {
791 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterDriver, r);
794 push = ndr_push_init_ctx(r, NULL);
800 ndr_err = call->ndr_push(push, NDR_OUT, r);
801 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
806 blob = ndr_push_blob(push);
807 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
817 static bool api_spoolss_EnumPrinterDrivers(pipes_struct *p)
819 const struct ndr_interface_call *call;
820 struct ndr_pull *pull;
821 struct ndr_push *push;
822 enum ndr_err_code ndr_err;
824 struct spoolss_EnumPrinterDrivers *r;
826 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPRINTERDRIVERS];
828 r = talloc(talloc_tos(), struct spoolss_EnumPrinterDrivers);
833 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
838 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
851 if (DEBUGLEVEL >= 10) {
852 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterDrivers, r);
856 r->out.count = talloc_zero(r, uint32_t);
857 if (r->out.count == NULL) {
862 r->out.info = talloc_zero(r, union spoolss_DriverInfo *);
863 if (r->out.info == NULL) {
868 r->out.needed = talloc_zero(r, uint32_t);
869 if (r->out.needed == NULL) {
874 r->out.result = _spoolss_EnumPrinterDrivers(p, r);
876 if (p->rng_fault_state) {
878 /* Return true here, srv_pipe_hnd.c will take care */
882 if (DEBUGLEVEL >= 10) {
883 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterDrivers, r);
886 push = ndr_push_init_ctx(r, NULL);
892 ndr_err = call->ndr_push(push, NDR_OUT, r);
893 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
898 blob = ndr_push_blob(push);
899 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
909 static bool api_spoolss_GetPrinterDriver(pipes_struct *p)
911 const struct ndr_interface_call *call;
912 struct ndr_pull *pull;
913 struct ndr_push *push;
914 enum ndr_err_code ndr_err;
916 struct spoolss_GetPrinterDriver *r;
918 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTERDRIVER];
920 r = talloc(talloc_tos(), struct spoolss_GetPrinterDriver);
925 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
930 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
943 if (DEBUGLEVEL >= 10) {
944 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriver, r);
948 r->out.info = talloc_zero(r, union spoolss_DriverInfo);
949 if (r->out.info == NULL) {
954 r->out.needed = talloc_zero(r, uint32_t);
955 if (r->out.needed == NULL) {
960 r->out.result = _spoolss_GetPrinterDriver(p, r);
962 if (p->rng_fault_state) {
964 /* Return true here, srv_pipe_hnd.c will take care */
968 if (DEBUGLEVEL >= 10) {
969 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriver, r);
972 push = ndr_push_init_ctx(r, NULL);
978 ndr_err = call->ndr_push(push, NDR_OUT, r);
979 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
984 blob = ndr_push_blob(push);
985 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
995 static bool api_spoolss_GetPrinterDriverDirectory(pipes_struct *p)
997 const struct ndr_interface_call *call;
998 struct ndr_pull *pull;
999 struct ndr_push *push;
1000 enum ndr_err_code ndr_err;
1002 struct spoolss_GetPrinterDriverDirectory *r;
1004 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY];
1006 r = talloc(talloc_tos(), struct spoolss_GetPrinterDriverDirectory);
1011 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1016 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1029 if (DEBUGLEVEL >= 10) {
1030 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriverDirectory, r);
1033 ZERO_STRUCT(r->out);
1034 r->out.info = talloc_zero(r, union spoolss_DriverDirectoryInfo);
1035 if (r->out.info == NULL) {
1040 r->out.needed = talloc_zero(r, uint32_t);
1041 if (r->out.needed == NULL) {
1046 r->out.result = _spoolss_GetPrinterDriverDirectory(p, r);
1048 if (p->rng_fault_state) {
1050 /* Return true here, srv_pipe_hnd.c will take care */
1054 if (DEBUGLEVEL >= 10) {
1055 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriverDirectory, r);
1058 push = ndr_push_init_ctx(r, NULL);
1064 ndr_err = call->ndr_push(push, NDR_OUT, r);
1065 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1070 blob = ndr_push_blob(push);
1071 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1081 static bool api_spoolss_DeletePrinterDriver(pipes_struct *p)
1083 const struct ndr_interface_call *call;
1084 struct ndr_pull *pull;
1085 struct ndr_push *push;
1086 enum ndr_err_code ndr_err;
1088 struct spoolss_DeletePrinterDriver *r;
1090 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERDRIVER];
1092 r = talloc(talloc_tos(), struct spoolss_DeletePrinterDriver);
1097 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1102 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1115 if (DEBUGLEVEL >= 10) {
1116 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDriver, r);
1119 r->out.result = _spoolss_DeletePrinterDriver(p, r);
1121 if (p->rng_fault_state) {
1123 /* Return true here, srv_pipe_hnd.c will take care */
1127 if (DEBUGLEVEL >= 10) {
1128 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDriver, r);
1131 push = ndr_push_init_ctx(r, NULL);
1137 ndr_err = call->ndr_push(push, NDR_OUT, r);
1138 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1143 blob = ndr_push_blob(push);
1144 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1154 static bool api_spoolss_AddPrintProcessor(pipes_struct *p)
1156 const struct ndr_interface_call *call;
1157 struct ndr_pull *pull;
1158 struct ndr_push *push;
1159 enum ndr_err_code ndr_err;
1161 struct spoolss_AddPrintProcessor *r;
1163 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTPROCESSOR];
1165 r = talloc(talloc_tos(), struct spoolss_AddPrintProcessor);
1170 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1175 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1188 if (DEBUGLEVEL >= 10) {
1189 NDR_PRINT_IN_DEBUG(spoolss_AddPrintProcessor, r);
1192 r->out.result = _spoolss_AddPrintProcessor(p, r);
1194 if (p->rng_fault_state) {
1196 /* Return true here, srv_pipe_hnd.c will take care */
1200 if (DEBUGLEVEL >= 10) {
1201 NDR_PRINT_OUT_DEBUG(spoolss_AddPrintProcessor, r);
1204 push = ndr_push_init_ctx(r, NULL);
1210 ndr_err = call->ndr_push(push, NDR_OUT, r);
1211 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1216 blob = ndr_push_blob(push);
1217 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1227 static bool api_spoolss_EnumPrintProcessors(pipes_struct *p)
1229 const struct ndr_interface_call *call;
1230 struct ndr_pull *pull;
1231 struct ndr_push *push;
1232 enum ndr_err_code ndr_err;
1234 struct spoolss_EnumPrintProcessors *r;
1236 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPRINTPROCESSORS];
1238 r = talloc(talloc_tos(), struct spoolss_EnumPrintProcessors);
1243 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1248 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1261 if (DEBUGLEVEL >= 10) {
1262 NDR_PRINT_IN_DEBUG(spoolss_EnumPrintProcessors, r);
1265 ZERO_STRUCT(r->out);
1266 r->out.count = talloc_zero(r, uint32_t);
1267 if (r->out.count == NULL) {
1272 r->out.info = talloc_zero(r, union spoolss_PrintProcessorInfo *);
1273 if (r->out.info == NULL) {
1278 r->out.needed = talloc_zero(r, uint32_t);
1279 if (r->out.needed == NULL) {
1284 r->out.result = _spoolss_EnumPrintProcessors(p, r);
1286 if (p->rng_fault_state) {
1288 /* Return true here, srv_pipe_hnd.c will take care */
1292 if (DEBUGLEVEL >= 10) {
1293 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrintProcessors, r);
1296 push = ndr_push_init_ctx(r, NULL);
1302 ndr_err = call->ndr_push(push, NDR_OUT, r);
1303 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1308 blob = ndr_push_blob(push);
1309 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1319 static bool api_spoolss_GetPrintProcessorDirectory(pipes_struct *p)
1321 const struct ndr_interface_call *call;
1322 struct ndr_pull *pull;
1323 struct ndr_push *push;
1324 enum ndr_err_code ndr_err;
1326 struct spoolss_GetPrintProcessorDirectory *r;
1328 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY];
1330 r = talloc(talloc_tos(), struct spoolss_GetPrintProcessorDirectory);
1335 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1340 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1353 if (DEBUGLEVEL >= 10) {
1354 NDR_PRINT_IN_DEBUG(spoolss_GetPrintProcessorDirectory, r);
1357 ZERO_STRUCT(r->out);
1358 r->out.info = talloc_zero(r, union spoolss_PrintProcessorDirectoryInfo);
1359 if (r->out.info == NULL) {
1364 r->out.needed = talloc_zero(r, uint32_t);
1365 if (r->out.needed == NULL) {
1370 r->out.result = _spoolss_GetPrintProcessorDirectory(p, r);
1372 if (p->rng_fault_state) {
1374 /* Return true here, srv_pipe_hnd.c will take care */
1378 if (DEBUGLEVEL >= 10) {
1379 NDR_PRINT_OUT_DEBUG(spoolss_GetPrintProcessorDirectory, r);
1382 push = ndr_push_init_ctx(r, NULL);
1388 ndr_err = call->ndr_push(push, NDR_OUT, r);
1389 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1394 blob = ndr_push_blob(push);
1395 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1405 static bool api_spoolss_StartDocPrinter(pipes_struct *p)
1407 const struct ndr_interface_call *call;
1408 struct ndr_pull *pull;
1409 struct ndr_push *push;
1410 enum ndr_err_code ndr_err;
1412 struct spoolss_StartDocPrinter *r;
1414 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_STARTDOCPRINTER];
1416 r = talloc(talloc_tos(), struct spoolss_StartDocPrinter);
1421 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1426 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1439 if (DEBUGLEVEL >= 10) {
1440 NDR_PRINT_IN_DEBUG(spoolss_StartDocPrinter, r);
1443 ZERO_STRUCT(r->out);
1444 r->out.job_id = talloc_zero(r, uint32_t);
1445 if (r->out.job_id == NULL) {
1450 r->out.result = _spoolss_StartDocPrinter(p, r);
1452 if (p->rng_fault_state) {
1454 /* Return true here, srv_pipe_hnd.c will take care */
1458 if (DEBUGLEVEL >= 10) {
1459 NDR_PRINT_OUT_DEBUG(spoolss_StartDocPrinter, r);
1462 push = ndr_push_init_ctx(r, NULL);
1468 ndr_err = call->ndr_push(push, NDR_OUT, r);
1469 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1474 blob = ndr_push_blob(push);
1475 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1485 static bool api_spoolss_StartPagePrinter(pipes_struct *p)
1487 const struct ndr_interface_call *call;
1488 struct ndr_pull *pull;
1489 struct ndr_push *push;
1490 enum ndr_err_code ndr_err;
1492 struct spoolss_StartPagePrinter *r;
1494 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_STARTPAGEPRINTER];
1496 r = talloc(talloc_tos(), struct spoolss_StartPagePrinter);
1501 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1506 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1519 if (DEBUGLEVEL >= 10) {
1520 NDR_PRINT_IN_DEBUG(spoolss_StartPagePrinter, r);
1523 r->out.result = _spoolss_StartPagePrinter(p, r);
1525 if (p->rng_fault_state) {
1527 /* Return true here, srv_pipe_hnd.c will take care */
1531 if (DEBUGLEVEL >= 10) {
1532 NDR_PRINT_OUT_DEBUG(spoolss_StartPagePrinter, r);
1535 push = ndr_push_init_ctx(r, NULL);
1541 ndr_err = call->ndr_push(push, NDR_OUT, r);
1542 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1547 blob = ndr_push_blob(push);
1548 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1558 static bool api_spoolss_WritePrinter(pipes_struct *p)
1560 const struct ndr_interface_call *call;
1561 struct ndr_pull *pull;
1562 struct ndr_push *push;
1563 enum ndr_err_code ndr_err;
1565 struct spoolss_WritePrinter *r;
1567 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_WRITEPRINTER];
1569 r = talloc(talloc_tos(), struct spoolss_WritePrinter);
1574 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1579 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1592 if (DEBUGLEVEL >= 10) {
1593 NDR_PRINT_IN_DEBUG(spoolss_WritePrinter, r);
1596 ZERO_STRUCT(r->out);
1597 r->out.num_written = talloc_zero(r, uint32_t);
1598 if (r->out.num_written == NULL) {
1603 r->out.result = _spoolss_WritePrinter(p, r);
1605 if (p->rng_fault_state) {
1607 /* Return true here, srv_pipe_hnd.c will take care */
1611 if (DEBUGLEVEL >= 10) {
1612 NDR_PRINT_OUT_DEBUG(spoolss_WritePrinter, r);
1615 push = ndr_push_init_ctx(r, NULL);
1621 ndr_err = call->ndr_push(push, NDR_OUT, r);
1622 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1627 blob = ndr_push_blob(push);
1628 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1638 static bool api_spoolss_EndPagePrinter(pipes_struct *p)
1640 const struct ndr_interface_call *call;
1641 struct ndr_pull *pull;
1642 struct ndr_push *push;
1643 enum ndr_err_code ndr_err;
1645 struct spoolss_EndPagePrinter *r;
1647 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENDPAGEPRINTER];
1649 r = talloc(talloc_tos(), struct spoolss_EndPagePrinter);
1654 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1659 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1672 if (DEBUGLEVEL >= 10) {
1673 NDR_PRINT_IN_DEBUG(spoolss_EndPagePrinter, r);
1676 r->out.result = _spoolss_EndPagePrinter(p, r);
1678 if (p->rng_fault_state) {
1680 /* Return true here, srv_pipe_hnd.c will take care */
1684 if (DEBUGLEVEL >= 10) {
1685 NDR_PRINT_OUT_DEBUG(spoolss_EndPagePrinter, r);
1688 push = ndr_push_init_ctx(r, NULL);
1694 ndr_err = call->ndr_push(push, NDR_OUT, r);
1695 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1700 blob = ndr_push_blob(push);
1701 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1711 static bool api_spoolss_AbortPrinter(pipes_struct *p)
1713 const struct ndr_interface_call *call;
1714 struct ndr_pull *pull;
1715 struct ndr_push *push;
1716 enum ndr_err_code ndr_err;
1718 struct spoolss_AbortPrinter *r;
1720 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ABORTPRINTER];
1722 r = talloc(talloc_tos(), struct spoolss_AbortPrinter);
1727 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1732 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1745 if (DEBUGLEVEL >= 10) {
1746 NDR_PRINT_IN_DEBUG(spoolss_AbortPrinter, r);
1749 r->out.result = _spoolss_AbortPrinter(p, r);
1751 if (p->rng_fault_state) {
1753 /* Return true here, srv_pipe_hnd.c will take care */
1757 if (DEBUGLEVEL >= 10) {
1758 NDR_PRINT_OUT_DEBUG(spoolss_AbortPrinter, r);
1761 push = ndr_push_init_ctx(r, NULL);
1767 ndr_err = call->ndr_push(push, NDR_OUT, r);
1768 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1773 blob = ndr_push_blob(push);
1774 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1784 static bool api_spoolss_ReadPrinter(pipes_struct *p)
1786 const struct ndr_interface_call *call;
1787 struct ndr_pull *pull;
1788 struct ndr_push *push;
1789 enum ndr_err_code ndr_err;
1791 struct spoolss_ReadPrinter *r;
1793 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_READPRINTER];
1795 r = talloc(talloc_tos(), struct spoolss_ReadPrinter);
1800 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1805 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1818 if (DEBUGLEVEL >= 10) {
1819 NDR_PRINT_IN_DEBUG(spoolss_ReadPrinter, r);
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) {
1829 r->out._data_size = talloc_zero(r, uint32_t);
1830 if (r->out._data_size == NULL) {
1835 r->out.result = _spoolss_ReadPrinter(p, r);
1837 if (p->rng_fault_state) {
1839 /* Return true here, srv_pipe_hnd.c will take care */
1843 if (DEBUGLEVEL >= 10) {
1844 NDR_PRINT_OUT_DEBUG(spoolss_ReadPrinter, r);
1847 push = ndr_push_init_ctx(r, NULL);
1853 ndr_err = call->ndr_push(push, NDR_OUT, r);
1854 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1859 blob = ndr_push_blob(push);
1860 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1870 static bool api_spoolss_EndDocPrinter(pipes_struct *p)
1872 const struct ndr_interface_call *call;
1873 struct ndr_pull *pull;
1874 struct ndr_push *push;
1875 enum ndr_err_code ndr_err;
1877 struct spoolss_EndDocPrinter *r;
1879 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENDDOCPRINTER];
1881 r = talloc(talloc_tos(), struct spoolss_EndDocPrinter);
1886 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1891 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1904 if (DEBUGLEVEL >= 10) {
1905 NDR_PRINT_IN_DEBUG(spoolss_EndDocPrinter, r);
1908 r->out.result = _spoolss_EndDocPrinter(p, r);
1910 if (p->rng_fault_state) {
1912 /* Return true here, srv_pipe_hnd.c will take care */
1916 if (DEBUGLEVEL >= 10) {
1917 NDR_PRINT_OUT_DEBUG(spoolss_EndDocPrinter, r);
1920 push = ndr_push_init_ctx(r, NULL);
1926 ndr_err = call->ndr_push(push, NDR_OUT, r);
1927 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1932 blob = ndr_push_blob(push);
1933 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1943 static bool api_spoolss_AddJob(pipes_struct *p)
1945 const struct ndr_interface_call *call;
1946 struct ndr_pull *pull;
1947 struct ndr_push *push;
1948 enum ndr_err_code ndr_err;
1950 struct spoolss_AddJob *r;
1952 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDJOB];
1954 r = talloc(talloc_tos(), struct spoolss_AddJob);
1959 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1964 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1977 if (DEBUGLEVEL >= 10) {
1978 NDR_PRINT_IN_DEBUG(spoolss_AddJob, r);
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) {
1989 r->out.result = _spoolss_AddJob(p, r);
1991 if (p->rng_fault_state) {
1993 /* Return true here, srv_pipe_hnd.c will take care */
1997 if (DEBUGLEVEL >= 10) {
1998 NDR_PRINT_OUT_DEBUG(spoolss_AddJob, r);
2001 push = ndr_push_init_ctx(r, NULL);
2007 ndr_err = call->ndr_push(push, NDR_OUT, r);
2008 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2013 blob = ndr_push_blob(push);
2014 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2024 static bool api_spoolss_ScheduleJob(pipes_struct *p)
2026 const struct ndr_interface_call *call;
2027 struct ndr_pull *pull;
2028 struct ndr_push *push;
2029 enum ndr_err_code ndr_err;
2031 struct spoolss_ScheduleJob *r;
2033 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_SCHEDULEJOB];
2035 r = talloc(talloc_tos(), struct spoolss_ScheduleJob);
2040 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2045 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2058 if (DEBUGLEVEL >= 10) {
2059 NDR_PRINT_IN_DEBUG(spoolss_ScheduleJob, r);
2062 r->out.result = _spoolss_ScheduleJob(p, r);
2064 if (p->rng_fault_state) {
2066 /* Return true here, srv_pipe_hnd.c will take care */
2070 if (DEBUGLEVEL >= 10) {
2071 NDR_PRINT_OUT_DEBUG(spoolss_ScheduleJob, r);
2074 push = ndr_push_init_ctx(r, NULL);
2080 ndr_err = call->ndr_push(push, NDR_OUT, r);
2081 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2086 blob = ndr_push_blob(push);
2087 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2097 static bool api_spoolss_GetPrinterData(pipes_struct *p)
2099 const struct ndr_interface_call *call;
2100 struct ndr_pull *pull;
2101 struct ndr_push *push;
2102 enum ndr_err_code ndr_err;
2104 struct spoolss_GetPrinterData *r;
2106 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTERDATA];
2108 r = talloc(talloc_tos(), struct spoolss_GetPrinterData);
2113 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2118 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2131 if (DEBUGLEVEL >= 10) {
2132 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterData, r);
2135 ZERO_STRUCT(r->out);
2136 r->out.type = talloc_zero(r, enum winreg_Type);
2137 if (r->out.type == NULL) {
2142 r->out.data = talloc_zero(r, union spoolss_PrinterData);
2143 if (r->out.data == NULL) {
2148 r->out.needed = talloc_zero(r, uint32_t);
2149 if (r->out.needed == NULL) {
2154 r->out.result = _spoolss_GetPrinterData(p, r);
2156 if (p->rng_fault_state) {
2158 /* Return true here, srv_pipe_hnd.c will take care */
2162 if (DEBUGLEVEL >= 10) {
2163 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterData, r);
2166 push = ndr_push_init_ctx(r, NULL);
2172 ndr_err = call->ndr_push(push, NDR_OUT, r);
2173 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2178 blob = ndr_push_blob(push);
2179 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2189 static bool api_spoolss_SetPrinterData(pipes_struct *p)
2191 const struct ndr_interface_call *call;
2192 struct ndr_pull *pull;
2193 struct ndr_push *push;
2194 enum ndr_err_code ndr_err;
2196 struct spoolss_SetPrinterData *r;
2198 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_SETPRINTERDATA];
2200 r = talloc(talloc_tos(), struct spoolss_SetPrinterData);
2205 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2210 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2223 if (DEBUGLEVEL >= 10) {
2224 NDR_PRINT_IN_DEBUG(spoolss_SetPrinterData, r);
2227 r->out.result = _spoolss_SetPrinterData(p, r);
2229 if (p->rng_fault_state) {
2231 /* Return true here, srv_pipe_hnd.c will take care */
2235 if (DEBUGLEVEL >= 10) {
2236 NDR_PRINT_OUT_DEBUG(spoolss_SetPrinterData, r);
2239 push = ndr_push_init_ctx(r, NULL);
2245 ndr_err = call->ndr_push(push, NDR_OUT, r);
2246 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2251 blob = ndr_push_blob(push);
2252 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2262 static bool api_spoolss_WaitForPrinterChange(pipes_struct *p)
2264 const struct ndr_interface_call *call;
2265 struct ndr_pull *pull;
2266 struct ndr_push *push;
2267 enum ndr_err_code ndr_err;
2269 struct spoolss_WaitForPrinterChange *r;
2271 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_WAITFORPRINTERCHANGE];
2273 r = talloc(talloc_tos(), struct spoolss_WaitForPrinterChange);
2278 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2283 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2296 if (DEBUGLEVEL >= 10) {
2297 NDR_PRINT_IN_DEBUG(spoolss_WaitForPrinterChange, r);
2300 r->out.result = _spoolss_WaitForPrinterChange(p, r);
2302 if (p->rng_fault_state) {
2304 /* Return true here, srv_pipe_hnd.c will take care */
2308 if (DEBUGLEVEL >= 10) {
2309 NDR_PRINT_OUT_DEBUG(spoolss_WaitForPrinterChange, r);
2312 push = ndr_push_init_ctx(r, NULL);
2318 ndr_err = call->ndr_push(push, NDR_OUT, r);
2319 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2324 blob = ndr_push_blob(push);
2325 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2335 static bool api_spoolss_ClosePrinter(pipes_struct *p)
2337 const struct ndr_interface_call *call;
2338 struct ndr_pull *pull;
2339 struct ndr_push *push;
2340 enum ndr_err_code ndr_err;
2342 struct spoolss_ClosePrinter *r;
2344 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_CLOSEPRINTER];
2346 r = talloc(talloc_tos(), struct spoolss_ClosePrinter);
2351 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2356 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2369 if (DEBUGLEVEL >= 10) {
2370 NDR_PRINT_IN_DEBUG(spoolss_ClosePrinter, r);
2373 ZERO_STRUCT(r->out);
2374 r->out.handle = r->in.handle;
2375 r->out.result = _spoolss_ClosePrinter(p, r);
2377 if (p->rng_fault_state) {
2379 /* Return true here, srv_pipe_hnd.c will take care */
2383 if (DEBUGLEVEL >= 10) {
2384 NDR_PRINT_OUT_DEBUG(spoolss_ClosePrinter, r);
2387 push = ndr_push_init_ctx(r, NULL);
2393 ndr_err = call->ndr_push(push, NDR_OUT, r);
2394 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2399 blob = ndr_push_blob(push);
2400 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2410 static bool api_spoolss_AddForm(pipes_struct *p)
2412 const struct ndr_interface_call *call;
2413 struct ndr_pull *pull;
2414 struct ndr_push *push;
2415 enum ndr_err_code ndr_err;
2417 struct spoolss_AddForm *r;
2419 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDFORM];
2421 r = talloc(talloc_tos(), struct spoolss_AddForm);
2426 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2431 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2444 if (DEBUGLEVEL >= 10) {
2445 NDR_PRINT_IN_DEBUG(spoolss_AddForm, r);
2448 r->out.result = _spoolss_AddForm(p, r);
2450 if (p->rng_fault_state) {
2452 /* Return true here, srv_pipe_hnd.c will take care */
2456 if (DEBUGLEVEL >= 10) {
2457 NDR_PRINT_OUT_DEBUG(spoolss_AddForm, r);
2460 push = ndr_push_init_ctx(r, NULL);
2466 ndr_err = call->ndr_push(push, NDR_OUT, r);
2467 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2472 blob = ndr_push_blob(push);
2473 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2483 static bool api_spoolss_DeleteForm(pipes_struct *p)
2485 const struct ndr_interface_call *call;
2486 struct ndr_pull *pull;
2487 struct ndr_push *push;
2488 enum ndr_err_code ndr_err;
2490 struct spoolss_DeleteForm *r;
2492 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEFORM];
2494 r = talloc(talloc_tos(), struct spoolss_DeleteForm);
2499 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2504 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2517 if (DEBUGLEVEL >= 10) {
2518 NDR_PRINT_IN_DEBUG(spoolss_DeleteForm, r);
2521 r->out.result = _spoolss_DeleteForm(p, r);
2523 if (p->rng_fault_state) {
2525 /* Return true here, srv_pipe_hnd.c will take care */
2529 if (DEBUGLEVEL >= 10) {
2530 NDR_PRINT_OUT_DEBUG(spoolss_DeleteForm, r);
2533 push = ndr_push_init_ctx(r, NULL);
2539 ndr_err = call->ndr_push(push, NDR_OUT, r);
2540 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2545 blob = ndr_push_blob(push);
2546 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2556 static bool api_spoolss_GetForm(pipes_struct *p)
2558 const struct ndr_interface_call *call;
2559 struct ndr_pull *pull;
2560 struct ndr_push *push;
2561 enum ndr_err_code ndr_err;
2563 struct spoolss_GetForm *r;
2565 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETFORM];
2567 r = talloc(talloc_tos(), struct spoolss_GetForm);
2572 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2577 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2590 if (DEBUGLEVEL >= 10) {
2591 NDR_PRINT_IN_DEBUG(spoolss_GetForm, r);
2594 ZERO_STRUCT(r->out);
2595 r->out.info = talloc_zero(r, union spoolss_FormInfo);
2596 if (r->out.info == NULL) {
2601 r->out.needed = talloc_zero(r, uint32_t);
2602 if (r->out.needed == NULL) {
2607 r->out.result = _spoolss_GetForm(p, r);
2609 if (p->rng_fault_state) {
2611 /* Return true here, srv_pipe_hnd.c will take care */
2615 if (DEBUGLEVEL >= 10) {
2616 NDR_PRINT_OUT_DEBUG(spoolss_GetForm, r);
2619 push = ndr_push_init_ctx(r, NULL);
2625 ndr_err = call->ndr_push(push, NDR_OUT, r);
2626 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2631 blob = ndr_push_blob(push);
2632 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2642 static bool api_spoolss_SetForm(pipes_struct *p)
2644 const struct ndr_interface_call *call;
2645 struct ndr_pull *pull;
2646 struct ndr_push *push;
2647 enum ndr_err_code ndr_err;
2649 struct spoolss_SetForm *r;
2651 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_SETFORM];
2653 r = talloc(talloc_tos(), struct spoolss_SetForm);
2658 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2663 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2676 if (DEBUGLEVEL >= 10) {
2677 NDR_PRINT_IN_DEBUG(spoolss_SetForm, r);
2680 r->out.result = _spoolss_SetForm(p, r);
2682 if (p->rng_fault_state) {
2684 /* Return true here, srv_pipe_hnd.c will take care */
2688 if (DEBUGLEVEL >= 10) {
2689 NDR_PRINT_OUT_DEBUG(spoolss_SetForm, r);
2692 push = ndr_push_init_ctx(r, NULL);
2698 ndr_err = call->ndr_push(push, NDR_OUT, r);
2699 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2704 blob = ndr_push_blob(push);
2705 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2715 static bool api_spoolss_EnumForms(pipes_struct *p)
2717 const struct ndr_interface_call *call;
2718 struct ndr_pull *pull;
2719 struct ndr_push *push;
2720 enum ndr_err_code ndr_err;
2722 struct spoolss_EnumForms *r;
2724 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMFORMS];
2726 r = talloc(talloc_tos(), struct spoolss_EnumForms);
2731 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2736 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2749 if (DEBUGLEVEL >= 10) {
2750 NDR_PRINT_IN_DEBUG(spoolss_EnumForms, r);
2753 ZERO_STRUCT(r->out);
2754 r->out.count = talloc_zero(r, uint32_t);
2755 if (r->out.count == NULL) {
2760 r->out.info = talloc_zero(r, union spoolss_FormInfo *);
2761 if (r->out.info == NULL) {
2766 r->out.needed = talloc_zero(r, uint32_t);
2767 if (r->out.needed == NULL) {
2772 r->out.result = _spoolss_EnumForms(p, r);
2774 if (p->rng_fault_state) {
2776 /* Return true here, srv_pipe_hnd.c will take care */
2780 if (DEBUGLEVEL >= 10) {
2781 NDR_PRINT_OUT_DEBUG(spoolss_EnumForms, r);
2784 push = ndr_push_init_ctx(r, NULL);
2790 ndr_err = call->ndr_push(push, NDR_OUT, r);
2791 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2796 blob = ndr_push_blob(push);
2797 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2807 static bool api_spoolss_EnumPorts(pipes_struct *p)
2809 const struct ndr_interface_call *call;
2810 struct ndr_pull *pull;
2811 struct ndr_push *push;
2812 enum ndr_err_code ndr_err;
2814 struct spoolss_EnumPorts *r;
2816 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPORTS];
2818 r = talloc(talloc_tos(), struct spoolss_EnumPorts);
2823 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2828 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2841 if (DEBUGLEVEL >= 10) {
2842 NDR_PRINT_IN_DEBUG(spoolss_EnumPorts, r);
2845 ZERO_STRUCT(r->out);
2846 r->out.count = talloc_zero(r, uint32_t);
2847 if (r->out.count == NULL) {
2852 r->out.info = talloc_zero(r, union spoolss_PortInfo *);
2853 if (r->out.info == NULL) {
2858 r->out.needed = talloc_zero(r, uint32_t);
2859 if (r->out.needed == NULL) {
2864 r->out.result = _spoolss_EnumPorts(p, r);
2866 if (p->rng_fault_state) {
2868 /* Return true here, srv_pipe_hnd.c will take care */
2872 if (DEBUGLEVEL >= 10) {
2873 NDR_PRINT_OUT_DEBUG(spoolss_EnumPorts, r);
2876 push = ndr_push_init_ctx(r, NULL);
2882 ndr_err = call->ndr_push(push, NDR_OUT, r);
2883 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2888 blob = ndr_push_blob(push);
2889 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2899 static bool api_spoolss_EnumMonitors(pipes_struct *p)
2901 const struct ndr_interface_call *call;
2902 struct ndr_pull *pull;
2903 struct ndr_push *push;
2904 enum ndr_err_code ndr_err;
2906 struct spoolss_EnumMonitors *r;
2908 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMMONITORS];
2910 r = talloc(talloc_tos(), struct spoolss_EnumMonitors);
2915 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2920 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2933 if (DEBUGLEVEL >= 10) {
2934 NDR_PRINT_IN_DEBUG(spoolss_EnumMonitors, r);
2937 ZERO_STRUCT(r->out);
2938 r->out.count = talloc_zero(r, uint32_t);
2939 if (r->out.count == NULL) {
2944 r->out.info = talloc_zero(r, union spoolss_MonitorInfo *);
2945 if (r->out.info == NULL) {
2950 r->out.needed = talloc_zero(r, uint32_t);
2951 if (r->out.needed == NULL) {
2956 r->out.result = _spoolss_EnumMonitors(p, r);
2958 if (p->rng_fault_state) {
2960 /* Return true here, srv_pipe_hnd.c will take care */
2964 if (DEBUGLEVEL >= 10) {
2965 NDR_PRINT_OUT_DEBUG(spoolss_EnumMonitors, r);
2968 push = ndr_push_init_ctx(r, NULL);
2974 ndr_err = call->ndr_push(push, NDR_OUT, r);
2975 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2980 blob = ndr_push_blob(push);
2981 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2991 static bool api_spoolss_AddPort(pipes_struct *p)
2993 const struct ndr_interface_call *call;
2994 struct ndr_pull *pull;
2995 struct ndr_push *push;
2996 enum ndr_err_code ndr_err;
2998 struct spoolss_AddPort *r;
3000 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPORT];
3002 r = talloc(talloc_tos(), struct spoolss_AddPort);
3007 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3012 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
3025 if (DEBUGLEVEL >= 10) {
3026 NDR_PRINT_IN_DEBUG(spoolss_AddPort, r);
3029 r->out.result = _spoolss_AddPort(p, r);
3031 if (p->rng_fault_state) {
3033 /* Return true here, srv_pipe_hnd.c will take care */
3037 if (DEBUGLEVEL >= 10) {
3038 NDR_PRINT_OUT_DEBUG(spoolss_AddPort, r);
3041 push = ndr_push_init_ctx(r, NULL);
3047 ndr_err = call->ndr_push(push, NDR_OUT, r);
3048 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3053 blob = ndr_push_blob(push);
3054 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3064 static bool api_spoolss_ConfigurePort(pipes_struct *p)
3066 const struct ndr_interface_call *call;
3067 struct ndr_pull *pull;
3068 struct ndr_push *push;
3069 enum ndr_err_code ndr_err;
3071 struct spoolss_ConfigurePort *r;
3073 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_CONFIGUREPORT];
3075 r = talloc(talloc_tos(), struct spoolss_ConfigurePort);
3080 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3085 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
3098 if (DEBUGLEVEL >= 10) {
3099 NDR_PRINT_IN_DEBUG(spoolss_ConfigurePort, r);
3102 r->out.result = _spoolss_ConfigurePort(p, r);
3104 if (p->rng_fault_state) {
3106 /* Return true here, srv_pipe_hnd.c will take care */
3110 if (DEBUGLEVEL >= 10) {
3111 NDR_PRINT_OUT_DEBUG(spoolss_ConfigurePort, r);
3114 push = ndr_push_init_ctx(r, NULL);
3120 ndr_err = call->ndr_push(push, NDR_OUT, r);
3121 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3126 blob = ndr_push_blob(push);
3127 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3137 static bool api_spoolss_DeletePort(pipes_struct *p)
3139 const struct ndr_interface_call *call;
3140 struct ndr_pull *pull;
3141 struct ndr_push *push;
3142 enum ndr_err_code ndr_err;
3144 struct spoolss_DeletePort *r;
3146 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPORT];
3148 r = talloc(talloc_tos(), struct spoolss_DeletePort);
3153 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3158 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
3171 if (DEBUGLEVEL >= 10) {
3172 NDR_PRINT_IN_DEBUG(spoolss_DeletePort, r);
3175 r->out.result = _spoolss_DeletePort(p, r);
3177 if (p->rng_fault_state) {
3179 /* Return true here, srv_pipe_hnd.c will take care */
3183 if (DEBUGLEVEL >= 10) {
3184 NDR_PRINT_OUT_DEBUG(spoolss_DeletePort, r);
3187 push = ndr_push_init_ctx(r, NULL);
3193 ndr_err = call->ndr_push(push, NDR_OUT, r);
3194 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3199 blob = ndr_push_blob(push);
3200 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3210 static bool api_spoolss_CreatePrinterIC(pipes_struct *p)
3212 const struct ndr_interface_call *call;
3213 struct ndr_pull *pull;
3214 struct ndr_push *push;
3215 enum ndr_err_code ndr_err;
3217 struct spoolss_CreatePrinterIC *r;
3219 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_CREATEPRINTERIC];
3221 r = talloc(talloc_tos(), struct spoolss_CreatePrinterIC);
3226 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3231 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
3244 if (DEBUGLEVEL >= 10) {
3245 NDR_PRINT_IN_DEBUG(spoolss_CreatePrinterIC, r);
3248 ZERO_STRUCT(r->out);
3249 r->out.gdi_handle = talloc_zero(r, struct policy_handle);
3250 if (r->out.gdi_handle == NULL) {
3255 r->out.result = _spoolss_CreatePrinterIC(p, r);
3257 if (p->rng_fault_state) {
3259 /* Return true here, srv_pipe_hnd.c will take care */
3263 if (DEBUGLEVEL >= 10) {
3264 NDR_PRINT_OUT_DEBUG(spoolss_CreatePrinterIC, r);
3267 push = ndr_push_init_ctx(r, NULL);
3273 ndr_err = call->ndr_push(push, NDR_OUT, r);
3274 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3279 blob = ndr_push_blob(push);
3280 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3290 static bool api_spoolss_PlayGDIScriptOnPrinterIC(pipes_struct *p)
3292 const struct ndr_interface_call *call;
3293 struct ndr_pull *pull;
3294 struct ndr_push *push;
3295 enum ndr_err_code ndr_err;
3297 struct spoolss_PlayGDIScriptOnPrinterIC *r;
3299 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC];
3301 r = talloc(talloc_tos(), struct spoolss_PlayGDIScriptOnPrinterIC);
3306 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3311 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
3324 if (DEBUGLEVEL >= 10) {
3325 NDR_PRINT_IN_DEBUG(spoolss_PlayGDIScriptOnPrinterIC, r);
3328 r->out.result = _spoolss_PlayGDIScriptOnPrinterIC(p, r);
3330 if (p->rng_fault_state) {
3332 /* Return true here, srv_pipe_hnd.c will take care */
3336 if (DEBUGLEVEL >= 10) {
3337 NDR_PRINT_OUT_DEBUG(spoolss_PlayGDIScriptOnPrinterIC, r);
3340 push = ndr_push_init_ctx(r, NULL);
3346 ndr_err = call->ndr_push(push, NDR_OUT, r);
3347 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3352 blob = ndr_push_blob(push);
3353 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3363 static bool api_spoolss_DeletePrinterIC(pipes_struct *p)
3365 const struct ndr_interface_call *call;
3366 struct ndr_pull *pull;
3367 struct ndr_push *push;
3368 enum ndr_err_code ndr_err;
3370 struct spoolss_DeletePrinterIC *r;
3372 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERIC];
3374 r = talloc(talloc_tos(), struct spoolss_DeletePrinterIC);
3379 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3384 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
3397 if (DEBUGLEVEL >= 10) {
3398 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterIC, r);
3401 ZERO_STRUCT(r->out);
3402 r->out.gdi_handle = r->in.gdi_handle;
3403 r->out.result = _spoolss_DeletePrinterIC(p, r);
3405 if (p->rng_fault_state) {
3407 /* Return true here, srv_pipe_hnd.c will take care */
3411 if (DEBUGLEVEL >= 10) {
3412 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterIC, r);
3415 push = ndr_push_init_ctx(r, NULL);
3421 ndr_err = call->ndr_push(push, NDR_OUT, r);
3422 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3427 blob = ndr_push_blob(push);
3428 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3438 static bool api_spoolss_AddPrinterConnection(pipes_struct *p)
3440 const struct ndr_interface_call *call;
3441 struct ndr_pull *pull;
3442 struct ndr_push *push;
3443 enum ndr_err_code ndr_err;
3445 struct spoolss_AddPrinterConnection *r;
3447 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTERCONNECTION];
3449 r = talloc(talloc_tos(), struct spoolss_AddPrinterConnection);
3454 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3459 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
3472 if (DEBUGLEVEL >= 10) {
3473 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterConnection, r);
3476 r->out.result = _spoolss_AddPrinterConnection(p, r);
3478 if (p->rng_fault_state) {
3480 /* Return true here, srv_pipe_hnd.c will take care */
3484 if (DEBUGLEVEL >= 10) {
3485 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterConnection, r);
3488 push = ndr_push_init_ctx(r, NULL);
3494 ndr_err = call->ndr_push(push, NDR_OUT, r);
3495 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3500 blob = ndr_push_blob(push);
3501 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3511 static bool api_spoolss_DeletePrinterConnection(pipes_struct *p)
3513 const struct ndr_interface_call *call;
3514 struct ndr_pull *pull;
3515 struct ndr_push *push;
3516 enum ndr_err_code ndr_err;
3518 struct spoolss_DeletePrinterConnection *r;
3520 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERCONNECTION];
3522 r = talloc(talloc_tos(), struct spoolss_DeletePrinterConnection);
3527 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3532 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
3545 if (DEBUGLEVEL >= 10) {
3546 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterConnection, r);
3549 r->out.result = _spoolss_DeletePrinterConnection(p, r);
3551 if (p->rng_fault_state) {
3553 /* Return true here, srv_pipe_hnd.c will take care */
3557 if (DEBUGLEVEL >= 10) {
3558 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterConnection, r);
3561 push = ndr_push_init_ctx(r, NULL);
3567 ndr_err = call->ndr_push(push, NDR_OUT, r);
3568 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3573 blob = ndr_push_blob(push);
3574 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3584 static bool api_spoolss_PrinterMessageBox(pipes_struct *p)
3586 const struct ndr_interface_call *call;
3587 struct ndr_pull *pull;
3588 struct ndr_push *push;
3589 enum ndr_err_code ndr_err;
3591 struct spoolss_PrinterMessageBox *r;
3593 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_PRINTERMESSAGEBOX];
3595 r = talloc(talloc_tos(), struct spoolss_PrinterMessageBox);
3600 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3605 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
3618 if (DEBUGLEVEL >= 10) {
3619 NDR_PRINT_IN_DEBUG(spoolss_PrinterMessageBox, r);
3622 r->out.result = _spoolss_PrinterMessageBox(p, r);
3624 if (p->rng_fault_state) {
3626 /* Return true here, srv_pipe_hnd.c will take care */
3630 if (DEBUGLEVEL >= 10) {
3631 NDR_PRINT_OUT_DEBUG(spoolss_PrinterMessageBox, r);
3634 push = ndr_push_init_ctx(r, NULL);
3640 ndr_err = call->ndr_push(push, NDR_OUT, r);
3641 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3646 blob = ndr_push_blob(push);
3647 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3657 static bool api_spoolss_AddMonitor(pipes_struct *p)
3659 const struct ndr_interface_call *call;
3660 struct ndr_pull *pull;
3661 struct ndr_push *push;
3662 enum ndr_err_code ndr_err;
3664 struct spoolss_AddMonitor *r;
3666 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDMONITOR];
3668 r = talloc(talloc_tos(), struct spoolss_AddMonitor);
3673 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3678 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
3691 if (DEBUGLEVEL >= 10) {
3692 NDR_PRINT_IN_DEBUG(spoolss_AddMonitor, r);
3695 r->out.result = _spoolss_AddMonitor(p, r);
3697 if (p->rng_fault_state) {
3699 /* Return true here, srv_pipe_hnd.c will take care */
3703 if (DEBUGLEVEL >= 10) {
3704 NDR_PRINT_OUT_DEBUG(spoolss_AddMonitor, r);
3707 push = ndr_push_init_ctx(r, NULL);
3713 ndr_err = call->ndr_push(push, NDR_OUT, r);
3714 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3719 blob = ndr_push_blob(push);
3720 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3730 static bool api_spoolss_DeleteMonitor(pipes_struct *p)
3732 const struct ndr_interface_call *call;
3733 struct ndr_pull *pull;
3734 struct ndr_push *push;
3735 enum ndr_err_code ndr_err;
3737 struct spoolss_DeleteMonitor *r;
3739 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEMONITOR];
3741 r = talloc(talloc_tos(), struct spoolss_DeleteMonitor);
3746 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3751 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
3764 if (DEBUGLEVEL >= 10) {
3765 NDR_PRINT_IN_DEBUG(spoolss_DeleteMonitor, r);
3768 r->out.result = _spoolss_DeleteMonitor(p, r);
3770 if (p->rng_fault_state) {
3772 /* Return true here, srv_pipe_hnd.c will take care */
3776 if (DEBUGLEVEL >= 10) {
3777 NDR_PRINT_OUT_DEBUG(spoolss_DeleteMonitor, r);
3780 push = ndr_push_init_ctx(r, NULL);
3786 ndr_err = call->ndr_push(push, NDR_OUT, r);
3787 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3792 blob = ndr_push_blob(push);
3793 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3803 static bool api_spoolss_DeletePrintProcessor(pipes_struct *p)
3805 const struct ndr_interface_call *call;
3806 struct ndr_pull *pull;
3807 struct ndr_push *push;
3808 enum ndr_err_code ndr_err;
3810 struct spoolss_DeletePrintProcessor *r;
3812 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTPROCESSOR];
3814 r = talloc(talloc_tos(), struct spoolss_DeletePrintProcessor);
3819 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3824 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
3837 if (DEBUGLEVEL >= 10) {
3838 NDR_PRINT_IN_DEBUG(spoolss_DeletePrintProcessor, r);
3841 r->out.result = _spoolss_DeletePrintProcessor(p, r);
3843 if (p->rng_fault_state) {
3845 /* Return true here, srv_pipe_hnd.c will take care */
3849 if (DEBUGLEVEL >= 10) {
3850 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrintProcessor, r);
3853 push = ndr_push_init_ctx(r, NULL);
3859 ndr_err = call->ndr_push(push, NDR_OUT, r);
3860 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3865 blob = ndr_push_blob(push);
3866 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3876 static bool api_spoolss_AddPrintProvidor(pipes_struct *p)
3878 const struct ndr_interface_call *call;
3879 struct ndr_pull *pull;
3880 struct ndr_push *push;
3881 enum ndr_err_code ndr_err;
3883 struct spoolss_AddPrintProvidor *r;
3885 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTPROVIDOR];
3887 r = talloc(talloc_tos(), struct spoolss_AddPrintProvidor);
3892 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3897 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
3910 if (DEBUGLEVEL >= 10) {
3911 NDR_PRINT_IN_DEBUG(spoolss_AddPrintProvidor, r);
3914 r->out.result = _spoolss_AddPrintProvidor(p, r);
3916 if (p->rng_fault_state) {
3918 /* Return true here, srv_pipe_hnd.c will take care */
3922 if (DEBUGLEVEL >= 10) {
3923 NDR_PRINT_OUT_DEBUG(spoolss_AddPrintProvidor, r);
3926 push = ndr_push_init_ctx(r, NULL);
3932 ndr_err = call->ndr_push(push, NDR_OUT, r);
3933 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3938 blob = ndr_push_blob(push);
3939 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3949 static bool api_spoolss_DeletePrintProvidor(pipes_struct *p)
3951 const struct ndr_interface_call *call;
3952 struct ndr_pull *pull;
3953 struct ndr_push *push;
3954 enum ndr_err_code ndr_err;
3956 struct spoolss_DeletePrintProvidor *r;
3958 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTPROVIDOR];
3960 r = talloc(talloc_tos(), struct spoolss_DeletePrintProvidor);
3965 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3970 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
3983 if (DEBUGLEVEL >= 10) {
3984 NDR_PRINT_IN_DEBUG(spoolss_DeletePrintProvidor, r);
3987 r->out.result = _spoolss_DeletePrintProvidor(p, r);
3989 if (p->rng_fault_state) {
3991 /* Return true here, srv_pipe_hnd.c will take care */
3995 if (DEBUGLEVEL >= 10) {
3996 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrintProvidor, r);
3999 push = ndr_push_init_ctx(r, NULL);
4005 ndr_err = call->ndr_push(push, NDR_OUT, r);
4006 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4011 blob = ndr_push_blob(push);
4012 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4022 static bool api_spoolss_EnumPrintProcDataTypes(pipes_struct *p)
4024 const struct ndr_interface_call *call;
4025 struct ndr_pull *pull;
4026 struct ndr_push *push;
4027 enum ndr_err_code ndr_err;
4029 struct spoolss_EnumPrintProcDataTypes *r;
4031 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPRINTPROCDATATYPES];
4033 r = talloc(talloc_tos(), struct spoolss_EnumPrintProcDataTypes);
4038 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4043 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
4056 if (DEBUGLEVEL >= 10) {
4057 NDR_PRINT_IN_DEBUG(spoolss_EnumPrintProcDataTypes, r);
4060 ZERO_STRUCT(r->out);
4061 r->out.count = talloc_zero(r, uint32_t);
4062 if (r->out.count == NULL) {
4067 r->out.info = talloc_zero(r, union spoolss_PrintProcDataTypesInfo *);
4068 if (r->out.info == NULL) {
4073 r->out.needed = talloc_zero(r, uint32_t);
4074 if (r->out.needed == NULL) {
4079 r->out.result = _spoolss_EnumPrintProcDataTypes(p, r);
4081 if (p->rng_fault_state) {
4083 /* Return true here, srv_pipe_hnd.c will take care */
4087 if (DEBUGLEVEL >= 10) {
4088 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrintProcDataTypes, r);
4091 push = ndr_push_init_ctx(r, NULL);
4097 ndr_err = call->ndr_push(push, NDR_OUT, r);
4098 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4103 blob = ndr_push_blob(push);
4104 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4114 static bool api_spoolss_ResetPrinter(pipes_struct *p)
4116 const struct ndr_interface_call *call;
4117 struct ndr_pull *pull;
4118 struct ndr_push *push;
4119 enum ndr_err_code ndr_err;
4121 struct spoolss_ResetPrinter *r;
4123 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_RESETPRINTER];
4125 r = talloc(talloc_tos(), struct spoolss_ResetPrinter);
4130 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4135 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
4148 if (DEBUGLEVEL >= 10) {
4149 NDR_PRINT_IN_DEBUG(spoolss_ResetPrinter, r);
4152 r->out.result = _spoolss_ResetPrinter(p, r);
4154 if (p->rng_fault_state) {
4156 /* Return true here, srv_pipe_hnd.c will take care */
4160 if (DEBUGLEVEL >= 10) {
4161 NDR_PRINT_OUT_DEBUG(spoolss_ResetPrinter, r);
4164 push = ndr_push_init_ctx(r, NULL);
4170 ndr_err = call->ndr_push(push, NDR_OUT, r);
4171 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4176 blob = ndr_push_blob(push);
4177 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4187 static bool api_spoolss_GetPrinterDriver2(pipes_struct *p)
4189 const struct ndr_interface_call *call;
4190 struct ndr_pull *pull;
4191 struct ndr_push *push;
4192 enum ndr_err_code ndr_err;
4194 struct spoolss_GetPrinterDriver2 *r;
4196 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTERDRIVER2];
4198 r = talloc(talloc_tos(), struct spoolss_GetPrinterDriver2);
4203 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4208 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
4221 if (DEBUGLEVEL >= 10) {
4222 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriver2, r);
4225 ZERO_STRUCT(r->out);
4226 r->out.info = talloc_zero(r, union spoolss_DriverInfo);
4227 if (r->out.info == NULL) {
4232 r->out.needed = talloc_zero(r, uint32_t);
4233 if (r->out.needed == NULL) {
4238 r->out.server_major_version = talloc_zero(r, uint32_t);
4239 if (r->out.server_major_version == NULL) {
4244 r->out.server_minor_version = talloc_zero(r, uint32_t);
4245 if (r->out.server_minor_version == NULL) {
4250 r->out.result = _spoolss_GetPrinterDriver2(p, r);
4252 if (p->rng_fault_state) {
4254 /* Return true here, srv_pipe_hnd.c will take care */
4258 if (DEBUGLEVEL >= 10) {
4259 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriver2, r);
4262 push = ndr_push_init_ctx(r, NULL);
4268 ndr_err = call->ndr_push(push, NDR_OUT, r);
4269 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4274 blob = ndr_push_blob(push);
4275 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4285 static bool api_spoolss_FindFirstPrinterChangeNotification(pipes_struct *p)
4287 const struct ndr_interface_call *call;
4288 struct ndr_pull *pull;
4289 struct ndr_push *push;
4290 enum ndr_err_code ndr_err;
4292 struct spoolss_FindFirstPrinterChangeNotification *r;
4294 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION];
4296 r = talloc(talloc_tos(), struct spoolss_FindFirstPrinterChangeNotification);
4301 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4306 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
4319 if (DEBUGLEVEL >= 10) {
4320 NDR_PRINT_IN_DEBUG(spoolss_FindFirstPrinterChangeNotification, r);
4323 r->out.result = _spoolss_FindFirstPrinterChangeNotification(p, r);
4325 if (p->rng_fault_state) {
4327 /* Return true here, srv_pipe_hnd.c will take care */
4331 if (DEBUGLEVEL >= 10) {
4332 NDR_PRINT_OUT_DEBUG(spoolss_FindFirstPrinterChangeNotification, r);
4335 push = ndr_push_init_ctx(r, NULL);
4341 ndr_err = call->ndr_push(push, NDR_OUT, r);
4342 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4347 blob = ndr_push_blob(push);
4348 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4358 static bool api_spoolss_FindNextPrinterChangeNotification(pipes_struct *p)
4360 const struct ndr_interface_call *call;
4361 struct ndr_pull *pull;
4362 struct ndr_push *push;
4363 enum ndr_err_code ndr_err;
4365 struct spoolss_FindNextPrinterChangeNotification *r;
4367 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION];
4369 r = talloc(talloc_tos(), struct spoolss_FindNextPrinterChangeNotification);
4374 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4379 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
4392 if (DEBUGLEVEL >= 10) {
4393 NDR_PRINT_IN_DEBUG(spoolss_FindNextPrinterChangeNotification, r);
4396 r->out.result = _spoolss_FindNextPrinterChangeNotification(p, r);
4398 if (p->rng_fault_state) {
4400 /* Return true here, srv_pipe_hnd.c will take care */
4404 if (DEBUGLEVEL >= 10) {
4405 NDR_PRINT_OUT_DEBUG(spoolss_FindNextPrinterChangeNotification, r);
4408 push = ndr_push_init_ctx(r, NULL);
4414 ndr_err = call->ndr_push(push, NDR_OUT, r);
4415 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4420 blob = ndr_push_blob(push);
4421 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4431 static bool api_spoolss_FindClosePrinterNotify(pipes_struct *p)
4433 const struct ndr_interface_call *call;
4434 struct ndr_pull *pull;
4435 struct ndr_push *push;
4436 enum ndr_err_code ndr_err;
4438 struct spoolss_FindClosePrinterNotify *r;
4440 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY];
4442 r = talloc(talloc_tos(), struct spoolss_FindClosePrinterNotify);
4447 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4452 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
4465 if (DEBUGLEVEL >= 10) {
4466 NDR_PRINT_IN_DEBUG(spoolss_FindClosePrinterNotify, r);
4469 r->out.result = _spoolss_FindClosePrinterNotify(p, r);
4471 if (p->rng_fault_state) {
4473 /* Return true here, srv_pipe_hnd.c will take care */
4477 if (DEBUGLEVEL >= 10) {
4478 NDR_PRINT_OUT_DEBUG(spoolss_FindClosePrinterNotify, r);
4481 push = ndr_push_init_ctx(r, NULL);
4487 ndr_err = call->ndr_push(push, NDR_OUT, r);
4488 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4493 blob = ndr_push_blob(push);
4494 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4504 static bool api_spoolss_RouterFindFirstPrinterChangeNotificationOld(pipes_struct *p)
4506 const struct ndr_interface_call *call;
4507 struct ndr_pull *pull;
4508 struct ndr_push *push;
4509 enum ndr_err_code ndr_err;
4511 struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r;
4513 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD];
4515 r = talloc(talloc_tos(), struct spoolss_RouterFindFirstPrinterChangeNotificationOld);
4520 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4525 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
4538 if (DEBUGLEVEL >= 10) {
4539 NDR_PRINT_IN_DEBUG(spoolss_RouterFindFirstPrinterChangeNotificationOld, r);
4542 r->out.result = _spoolss_RouterFindFirstPrinterChangeNotificationOld(p, r);
4544 if (p->rng_fault_state) {
4546 /* Return true here, srv_pipe_hnd.c will take care */
4550 if (DEBUGLEVEL >= 10) {
4551 NDR_PRINT_OUT_DEBUG(spoolss_RouterFindFirstPrinterChangeNotificationOld, r);
4554 push = ndr_push_init_ctx(r, NULL);
4560 ndr_err = call->ndr_push(push, NDR_OUT, r);
4561 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4566 blob = ndr_push_blob(push);
4567 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4577 static bool api_spoolss_ReplyOpenPrinter(pipes_struct *p)
4579 const struct ndr_interface_call *call;
4580 struct ndr_pull *pull;
4581 struct ndr_push *push;
4582 enum ndr_err_code ndr_err;
4584 struct spoolss_ReplyOpenPrinter *r;
4586 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_REPLYOPENPRINTER];
4588 r = talloc(talloc_tos(), struct spoolss_ReplyOpenPrinter);
4593 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4598 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
4611 if (DEBUGLEVEL >= 10) {
4612 NDR_PRINT_IN_DEBUG(spoolss_ReplyOpenPrinter, r);
4615 ZERO_STRUCT(r->out);
4616 r->out.handle = talloc_zero(r, struct policy_handle);
4617 if (r->out.handle == NULL) {
4622 r->out.result = _spoolss_ReplyOpenPrinter(p, r);
4624 if (p->rng_fault_state) {
4626 /* Return true here, srv_pipe_hnd.c will take care */
4630 if (DEBUGLEVEL >= 10) {
4631 NDR_PRINT_OUT_DEBUG(spoolss_ReplyOpenPrinter, r);
4634 push = ndr_push_init_ctx(r, NULL);
4640 ndr_err = call->ndr_push(push, NDR_OUT, r);
4641 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4646 blob = ndr_push_blob(push);
4647 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4657 static bool api_spoolss_RouterReplyPrinter(pipes_struct *p)
4659 const struct ndr_interface_call *call;
4660 struct ndr_pull *pull;
4661 struct ndr_push *push;
4662 enum ndr_err_code ndr_err;
4664 struct spoolss_RouterReplyPrinter *r;
4666 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ROUTERREPLYPRINTER];
4668 r = talloc(talloc_tos(), struct spoolss_RouterReplyPrinter);
4673 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4678 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
4691 if (DEBUGLEVEL >= 10) {
4692 NDR_PRINT_IN_DEBUG(spoolss_RouterReplyPrinter, r);
4695 r->out.result = _spoolss_RouterReplyPrinter(p, r);
4697 if (p->rng_fault_state) {
4699 /* Return true here, srv_pipe_hnd.c will take care */
4703 if (DEBUGLEVEL >= 10) {
4704 NDR_PRINT_OUT_DEBUG(spoolss_RouterReplyPrinter, r);
4707 push = ndr_push_init_ctx(r, NULL);
4713 ndr_err = call->ndr_push(push, NDR_OUT, r);
4714 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4719 blob = ndr_push_blob(push);
4720 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4730 static bool api_spoolss_ReplyClosePrinter(pipes_struct *p)
4732 const struct ndr_interface_call *call;
4733 struct ndr_pull *pull;
4734 struct ndr_push *push;
4735 enum ndr_err_code ndr_err;
4737 struct spoolss_ReplyClosePrinter *r;
4739 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_REPLYCLOSEPRINTER];
4741 r = talloc(talloc_tos(), struct spoolss_ReplyClosePrinter);
4746 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4751 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
4764 if (DEBUGLEVEL >= 10) {
4765 NDR_PRINT_IN_DEBUG(spoolss_ReplyClosePrinter, r);
4768 ZERO_STRUCT(r->out);
4769 r->out.handle = r->in.handle;
4770 r->out.result = _spoolss_ReplyClosePrinter(p, r);
4772 if (p->rng_fault_state) {
4774 /* Return true here, srv_pipe_hnd.c will take care */
4778 if (DEBUGLEVEL >= 10) {
4779 NDR_PRINT_OUT_DEBUG(spoolss_ReplyClosePrinter, r);
4782 push = ndr_push_init_ctx(r, NULL);
4788 ndr_err = call->ndr_push(push, NDR_OUT, r);
4789 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4794 blob = ndr_push_blob(push);
4795 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4805 static bool api_spoolss_AddPortEx(pipes_struct *p)
4807 const struct ndr_interface_call *call;
4808 struct ndr_pull *pull;
4809 struct ndr_push *push;
4810 enum ndr_err_code ndr_err;
4812 struct spoolss_AddPortEx *r;
4814 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPORTEX];
4816 r = talloc(talloc_tos(), struct spoolss_AddPortEx);
4821 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4826 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
4839 if (DEBUGLEVEL >= 10) {
4840 NDR_PRINT_IN_DEBUG(spoolss_AddPortEx, r);
4843 r->out.result = _spoolss_AddPortEx(p, r);
4845 if (p->rng_fault_state) {
4847 /* Return true here, srv_pipe_hnd.c will take care */
4851 if (DEBUGLEVEL >= 10) {
4852 NDR_PRINT_OUT_DEBUG(spoolss_AddPortEx, r);
4855 push = ndr_push_init_ctx(r, NULL);
4861 ndr_err = call->ndr_push(push, NDR_OUT, r);
4862 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4867 blob = ndr_push_blob(push);
4868 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4878 static bool api_spoolss_RouterFindFirstPrinterChangeNotification(pipes_struct *p)
4880 const struct ndr_interface_call *call;
4881 struct ndr_pull *pull;
4882 struct ndr_push *push;
4883 enum ndr_err_code ndr_err;
4885 struct spoolss_RouterFindFirstPrinterChangeNotification *r;
4887 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION];
4889 r = talloc(talloc_tos(), struct spoolss_RouterFindFirstPrinterChangeNotification);
4894 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4899 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
4912 if (DEBUGLEVEL >= 10) {
4913 NDR_PRINT_IN_DEBUG(spoolss_RouterFindFirstPrinterChangeNotification, r);
4916 r->out.result = _spoolss_RouterFindFirstPrinterChangeNotification(p, r);
4918 if (p->rng_fault_state) {
4920 /* Return true here, srv_pipe_hnd.c will take care */
4924 if (DEBUGLEVEL >= 10) {
4925 NDR_PRINT_OUT_DEBUG(spoolss_RouterFindFirstPrinterChangeNotification, r);
4928 push = ndr_push_init_ctx(r, NULL);
4934 ndr_err = call->ndr_push(push, NDR_OUT, r);
4935 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4940 blob = ndr_push_blob(push);
4941 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4951 static bool api_spoolss_SpoolerInit(pipes_struct *p)
4953 const struct ndr_interface_call *call;
4954 struct ndr_pull *pull;
4955 struct ndr_push *push;
4956 enum ndr_err_code ndr_err;
4958 struct spoolss_SpoolerInit *r;
4960 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_SPOOLERINIT];
4962 r = talloc(talloc_tos(), struct spoolss_SpoolerInit);
4967 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4972 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
4985 if (DEBUGLEVEL >= 10) {
4986 NDR_PRINT_IN_DEBUG(spoolss_SpoolerInit, r);
4989 r->out.result = _spoolss_SpoolerInit(p, r);
4991 if (p->rng_fault_state) {
4993 /* Return true here, srv_pipe_hnd.c will take care */
4997 if (DEBUGLEVEL >= 10) {
4998 NDR_PRINT_OUT_DEBUG(spoolss_SpoolerInit, r);
5001 push = ndr_push_init_ctx(r, NULL);
5007 ndr_err = call->ndr_push(push, NDR_OUT, r);
5008 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5013 blob = ndr_push_blob(push);
5014 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5024 static bool api_spoolss_ResetPrinterEx(pipes_struct *p)
5026 const struct ndr_interface_call *call;
5027 struct ndr_pull *pull;
5028 struct ndr_push *push;
5029 enum ndr_err_code ndr_err;
5031 struct spoolss_ResetPrinterEx *r;
5033 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_RESETPRINTEREX];
5035 r = talloc(talloc_tos(), struct spoolss_ResetPrinterEx);
5040 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5045 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
5058 if (DEBUGLEVEL >= 10) {
5059 NDR_PRINT_IN_DEBUG(spoolss_ResetPrinterEx, r);
5062 r->out.result = _spoolss_ResetPrinterEx(p, r);
5064 if (p->rng_fault_state) {
5066 /* Return true here, srv_pipe_hnd.c will take care */
5070 if (DEBUGLEVEL >= 10) {
5071 NDR_PRINT_OUT_DEBUG(spoolss_ResetPrinterEx, r);
5074 push = ndr_push_init_ctx(r, NULL);
5080 ndr_err = call->ndr_push(push, NDR_OUT, r);
5081 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5086 blob = ndr_push_blob(push);
5087 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5097 static bool api_spoolss_RemoteFindFirstPrinterChangeNotifyEx(pipes_struct *p)
5099 const struct ndr_interface_call *call;
5100 struct ndr_pull *pull;
5101 struct ndr_push *push;
5102 enum ndr_err_code ndr_err;
5104 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r;
5106 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX];
5108 r = talloc(talloc_tos(), struct spoolss_RemoteFindFirstPrinterChangeNotifyEx);
5113 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5118 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
5131 if (DEBUGLEVEL >= 10) {
5132 NDR_PRINT_IN_DEBUG(spoolss_RemoteFindFirstPrinterChangeNotifyEx, r);
5135 r->out.result = _spoolss_RemoteFindFirstPrinterChangeNotifyEx(p, r);
5137 if (p->rng_fault_state) {
5139 /* Return true here, srv_pipe_hnd.c will take care */
5143 if (DEBUGLEVEL >= 10) {
5144 NDR_PRINT_OUT_DEBUG(spoolss_RemoteFindFirstPrinterChangeNotifyEx, r);
5147 push = ndr_push_init_ctx(r, NULL);
5153 ndr_err = call->ndr_push(push, NDR_OUT, r);
5154 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5159 blob = ndr_push_blob(push);
5160 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5170 static bool api_spoolss_RouterReplyPrinterEx(pipes_struct *p)
5172 const struct ndr_interface_call *call;
5173 struct ndr_pull *pull;
5174 struct ndr_push *push;
5175 enum ndr_err_code ndr_err;
5177 struct spoolss_RouterReplyPrinterEx *r;
5179 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ROUTERREPLYPRINTEREX];
5181 r = talloc(talloc_tos(), struct spoolss_RouterReplyPrinterEx);
5186 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5191 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
5204 if (DEBUGLEVEL >= 10) {
5205 NDR_PRINT_IN_DEBUG(spoolss_RouterReplyPrinterEx, r);
5208 ZERO_STRUCT(r->out);
5209 r->out.reply_result = talloc_zero(r, uint32_t);
5210 if (r->out.reply_result == NULL) {
5215 r->out.result = _spoolss_RouterReplyPrinterEx(p, r);
5217 if (p->rng_fault_state) {
5219 /* Return true here, srv_pipe_hnd.c will take care */
5223 if (DEBUGLEVEL >= 10) {
5224 NDR_PRINT_OUT_DEBUG(spoolss_RouterReplyPrinterEx, r);
5227 push = ndr_push_init_ctx(r, NULL);
5233 ndr_err = call->ndr_push(push, NDR_OUT, r);
5234 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5239 blob = ndr_push_blob(push);
5240 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5250 static bool api_spoolss_RouterRefreshPrinterChangeNotify(pipes_struct *p)
5252 const struct ndr_interface_call *call;
5253 struct ndr_pull *pull;
5254 struct ndr_push *push;
5255 enum ndr_err_code ndr_err;
5257 struct spoolss_RouterRefreshPrinterChangeNotify *r;
5259 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY];
5261 r = talloc(talloc_tos(), struct spoolss_RouterRefreshPrinterChangeNotify);
5266 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5271 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
5284 if (DEBUGLEVEL >= 10) {
5285 NDR_PRINT_IN_DEBUG(spoolss_RouterRefreshPrinterChangeNotify, r);
5288 ZERO_STRUCT(r->out);
5289 r->out.info = talloc_zero(r, struct spoolss_NotifyInfo *);
5290 if (r->out.info == NULL) {
5295 r->out.result = _spoolss_RouterRefreshPrinterChangeNotify(p, r);
5297 if (p->rng_fault_state) {
5299 /* Return true here, srv_pipe_hnd.c will take care */
5303 if (DEBUGLEVEL >= 10) {
5304 NDR_PRINT_OUT_DEBUG(spoolss_RouterRefreshPrinterChangeNotify, r);
5307 push = ndr_push_init_ctx(r, NULL);
5313 ndr_err = call->ndr_push(push, NDR_OUT, r);
5314 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5319 blob = ndr_push_blob(push);
5320 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5330 static bool api_spoolss_44(pipes_struct *p)
5332 const struct ndr_interface_call *call;
5333 struct ndr_pull *pull;
5334 struct ndr_push *push;
5335 enum ndr_err_code ndr_err;
5337 struct spoolss_44 *r;
5339 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_44];
5341 r = talloc(talloc_tos(), struct spoolss_44);
5346 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5351 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
5364 if (DEBUGLEVEL >= 10) {
5365 NDR_PRINT_IN_DEBUG(spoolss_44, r);
5368 r->out.result = _spoolss_44(p, r);
5370 if (p->rng_fault_state) {
5372 /* Return true here, srv_pipe_hnd.c will take care */
5376 if (DEBUGLEVEL >= 10) {
5377 NDR_PRINT_OUT_DEBUG(spoolss_44, r);
5380 push = ndr_push_init_ctx(r, NULL);
5386 ndr_err = call->ndr_push(push, NDR_OUT, r);
5387 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5392 blob = ndr_push_blob(push);
5393 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5403 static bool api_spoolss_OpenPrinterEx(pipes_struct *p)
5405 const struct ndr_interface_call *call;
5406 struct ndr_pull *pull;
5407 struct ndr_push *push;
5408 enum ndr_err_code ndr_err;
5410 struct spoolss_OpenPrinterEx *r;
5412 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_OPENPRINTEREX];
5414 r = talloc(talloc_tos(), struct spoolss_OpenPrinterEx);
5419 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5424 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
5437 if (DEBUGLEVEL >= 10) {
5438 NDR_PRINT_IN_DEBUG(spoolss_OpenPrinterEx, r);
5441 ZERO_STRUCT(r->out);
5442 r->out.handle = talloc_zero(r, struct policy_handle);
5443 if (r->out.handle == NULL) {
5448 r->out.result = _spoolss_OpenPrinterEx(p, r);
5450 if (p->rng_fault_state) {
5452 /* Return true here, srv_pipe_hnd.c will take care */
5456 if (DEBUGLEVEL >= 10) {
5457 NDR_PRINT_OUT_DEBUG(spoolss_OpenPrinterEx, r);
5460 push = ndr_push_init_ctx(r, NULL);
5466 ndr_err = call->ndr_push(push, NDR_OUT, r);
5467 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5472 blob = ndr_push_blob(push);
5473 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5483 static bool api_spoolss_AddPrinterEx(pipes_struct *p)
5485 const struct ndr_interface_call *call;
5486 struct ndr_pull *pull;
5487 struct ndr_push *push;
5488 enum ndr_err_code ndr_err;
5490 struct spoolss_AddPrinterEx *r;
5492 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTEREX];
5494 r = talloc(talloc_tos(), struct spoolss_AddPrinterEx);
5499 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5504 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
5517 if (DEBUGLEVEL >= 10) {
5518 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterEx, r);
5521 ZERO_STRUCT(r->out);
5522 r->out.handle = talloc_zero(r, struct policy_handle);
5523 if (r->out.handle == NULL) {
5528 r->out.result = _spoolss_AddPrinterEx(p, r);
5530 if (p->rng_fault_state) {
5532 /* Return true here, srv_pipe_hnd.c will take care */
5536 if (DEBUGLEVEL >= 10) {
5537 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterEx, r);
5540 push = ndr_push_init_ctx(r, NULL);
5546 ndr_err = call->ndr_push(push, NDR_OUT, r);
5547 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5552 blob = ndr_push_blob(push);
5553 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5563 static bool api_spoolss_47(pipes_struct *p)
5565 const struct ndr_interface_call *call;
5566 struct ndr_pull *pull;
5567 struct ndr_push *push;
5568 enum ndr_err_code ndr_err;
5570 struct spoolss_47 *r;
5572 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_47];
5574 r = talloc(talloc_tos(), struct spoolss_47);
5579 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5584 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
5597 if (DEBUGLEVEL >= 10) {
5598 NDR_PRINT_IN_DEBUG(spoolss_47, r);
5601 r->out.result = _spoolss_47(p, r);
5603 if (p->rng_fault_state) {
5605 /* Return true here, srv_pipe_hnd.c will take care */
5609 if (DEBUGLEVEL >= 10) {
5610 NDR_PRINT_OUT_DEBUG(spoolss_47, r);
5613 push = ndr_push_init_ctx(r, NULL);
5619 ndr_err = call->ndr_push(push, NDR_OUT, r);
5620 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5625 blob = ndr_push_blob(push);
5626 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5636 static bool api_spoolss_EnumPrinterData(pipes_struct *p)
5638 const struct ndr_interface_call *call;
5639 struct ndr_pull *pull;
5640 struct ndr_push *push;
5641 enum ndr_err_code ndr_err;
5643 struct spoolss_EnumPrinterData *r;
5645 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPRINTERDATA];
5647 r = talloc(talloc_tos(), struct spoolss_EnumPrinterData);
5652 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5657 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
5670 if (DEBUGLEVEL >= 10) {
5671 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterData, r);
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) {
5681 r->out.value_needed = talloc_zero(r, uint32_t);
5682 if (r->out.value_needed == NULL) {
5687 r->out.type = talloc_zero(r, enum winreg_Type);
5688 if (r->out.type == NULL) {
5693 r->out.data = talloc_zero_array(r, uint8_t, r->in.data_offered);
5694 if (r->out.data == NULL) {
5699 r->out.data_needed = talloc_zero(r, uint32_t);
5700 if (r->out.data_needed == NULL) {
5705 r->out.result = _spoolss_EnumPrinterData(p, r);
5707 if (p->rng_fault_state) {
5709 /* Return true here, srv_pipe_hnd.c will take care */
5713 if (DEBUGLEVEL >= 10) {
5714 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterData, r);
5717 push = ndr_push_init_ctx(r, NULL);
5723 ndr_err = call->ndr_push(push, NDR_OUT, r);
5724 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5729 blob = ndr_push_blob(push);
5730 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5740 static bool api_spoolss_DeletePrinterData(pipes_struct *p)
5742 const struct ndr_interface_call *call;
5743 struct ndr_pull *pull;
5744 struct ndr_push *push;
5745 enum ndr_err_code ndr_err;
5747 struct spoolss_DeletePrinterData *r;
5749 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERDATA];
5751 r = talloc(talloc_tos(), struct spoolss_DeletePrinterData);
5756 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5761 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
5774 if (DEBUGLEVEL >= 10) {
5775 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterData, r);
5778 r->out.result = _spoolss_DeletePrinterData(p, r);
5780 if (p->rng_fault_state) {
5782 /* Return true here, srv_pipe_hnd.c will take care */
5786 if (DEBUGLEVEL >= 10) {
5787 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterData, r);
5790 push = ndr_push_init_ctx(r, NULL);
5796 ndr_err = call->ndr_push(push, NDR_OUT, r);
5797 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5802 blob = ndr_push_blob(push);
5803 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5813 static bool api_spoolss_4a(pipes_struct *p)
5815 const struct ndr_interface_call *call;
5816 struct ndr_pull *pull;
5817 struct ndr_push *push;
5818 enum ndr_err_code ndr_err;
5820 struct spoolss_4a *r;
5822 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_4A];
5824 r = talloc(talloc_tos(), struct spoolss_4a);
5829 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5834 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
5847 if (DEBUGLEVEL >= 10) {
5848 NDR_PRINT_IN_DEBUG(spoolss_4a, r);
5851 r->out.result = _spoolss_4a(p, r);
5853 if (p->rng_fault_state) {
5855 /* Return true here, srv_pipe_hnd.c will take care */
5859 if (DEBUGLEVEL >= 10) {
5860 NDR_PRINT_OUT_DEBUG(spoolss_4a, r);
5863 push = ndr_push_init_ctx(r, NULL);
5869 ndr_err = call->ndr_push(push, NDR_OUT, r);
5870 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5875 blob = ndr_push_blob(push);
5876 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5886 static bool api_spoolss_4b(pipes_struct *p)
5888 const struct ndr_interface_call *call;
5889 struct ndr_pull *pull;
5890 struct ndr_push *push;
5891 enum ndr_err_code ndr_err;
5893 struct spoolss_4b *r;
5895 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_4B];
5897 r = talloc(talloc_tos(), struct spoolss_4b);
5902 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5907 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
5920 if (DEBUGLEVEL >= 10) {
5921 NDR_PRINT_IN_DEBUG(spoolss_4b, r);
5924 r->out.result = _spoolss_4b(p, r);
5926 if (p->rng_fault_state) {
5928 /* Return true here, srv_pipe_hnd.c will take care */
5932 if (DEBUGLEVEL >= 10) {
5933 NDR_PRINT_OUT_DEBUG(spoolss_4b, r);
5936 push = ndr_push_init_ctx(r, NULL);
5942 ndr_err = call->ndr_push(push, NDR_OUT, r);
5943 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5948 blob = ndr_push_blob(push);
5949 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5959 static bool api_spoolss_4c(pipes_struct *p)
5961 const struct ndr_interface_call *call;
5962 struct ndr_pull *pull;
5963 struct ndr_push *push;
5964 enum ndr_err_code ndr_err;
5966 struct spoolss_4c *r;
5968 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_4C];
5970 r = talloc(talloc_tos(), struct spoolss_4c);
5975 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5980 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
5993 if (DEBUGLEVEL >= 10) {
5994 NDR_PRINT_IN_DEBUG(spoolss_4c, r);
5997 r->out.result = _spoolss_4c(p, r);
5999 if (p->rng_fault_state) {
6001 /* Return true here, srv_pipe_hnd.c will take care */
6005 if (DEBUGLEVEL >= 10) {
6006 NDR_PRINT_OUT_DEBUG(spoolss_4c, r);
6009 push = ndr_push_init_ctx(r, NULL);
6015 ndr_err = call->ndr_push(push, NDR_OUT, r);
6016 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6021 blob = ndr_push_blob(push);
6022 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6032 static bool api_spoolss_SetPrinterDataEx(pipes_struct *p)
6034 const struct ndr_interface_call *call;
6035 struct ndr_pull *pull;
6036 struct ndr_push *push;
6037 enum ndr_err_code ndr_err;
6039 struct spoolss_SetPrinterDataEx *r;
6041 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_SETPRINTERDATAEX];
6043 r = talloc(talloc_tos(), struct spoolss_SetPrinterDataEx);
6048 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6053 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
6066 if (DEBUGLEVEL >= 10) {
6067 NDR_PRINT_IN_DEBUG(spoolss_SetPrinterDataEx, r);
6070 r->out.result = _spoolss_SetPrinterDataEx(p, r);
6072 if (p->rng_fault_state) {
6074 /* Return true here, srv_pipe_hnd.c will take care */
6078 if (DEBUGLEVEL >= 10) {
6079 NDR_PRINT_OUT_DEBUG(spoolss_SetPrinterDataEx, r);
6082 push = ndr_push_init_ctx(r, NULL);
6088 ndr_err = call->ndr_push(push, NDR_OUT, r);
6089 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6094 blob = ndr_push_blob(push);
6095 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6105 static bool api_spoolss_GetPrinterDataEx(pipes_struct *p)
6107 const struct ndr_interface_call *call;
6108 struct ndr_pull *pull;
6109 struct ndr_push *push;
6110 enum ndr_err_code ndr_err;
6112 struct spoolss_GetPrinterDataEx *r;
6114 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTERDATAEX];
6116 r = talloc(talloc_tos(), struct spoolss_GetPrinterDataEx);
6121 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6126 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
6139 if (DEBUGLEVEL >= 10) {
6140 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDataEx, r);
6143 ZERO_STRUCT(r->out);
6144 r->out.type = talloc_zero(r, enum winreg_Type);
6145 if (r->out.type == NULL) {
6150 r->out.buffer = talloc_zero_array(r, uint8_t, r->in.offered);
6151 if (r->out.buffer == NULL) {
6156 r->out.needed = talloc_zero(r, uint32_t);
6157 if (r->out.needed == NULL) {
6162 r->out.result = _spoolss_GetPrinterDataEx(p, r);
6164 if (p->rng_fault_state) {
6166 /* Return true here, srv_pipe_hnd.c will take care */
6170 if (DEBUGLEVEL >= 10) {
6171 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDataEx, r);
6174 push = ndr_push_init_ctx(r, NULL);
6180 ndr_err = call->ndr_push(push, NDR_OUT, r);
6181 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6186 blob = ndr_push_blob(push);
6187 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6197 static bool api_spoolss_EnumPrinterDataEx(pipes_struct *p)
6199 const struct ndr_interface_call *call;
6200 struct ndr_pull *pull;
6201 struct ndr_push *push;
6202 enum ndr_err_code ndr_err;
6204 struct spoolss_EnumPrinterDataEx *r;
6206 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPRINTERDATAEX];
6208 r = talloc(talloc_tos(), struct spoolss_EnumPrinterDataEx);
6213 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6218 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
6231 if (DEBUGLEVEL >= 10) {
6232 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterDataEx, r);
6235 ZERO_STRUCT(r->out);
6236 r->out.count = talloc_zero(r, uint32_t);
6237 if (r->out.count == NULL) {
6242 r->out.info = talloc_zero(r, struct spoolss_PrinterEnumValues *);
6243 if (r->out.info == NULL) {
6248 r->out.needed = talloc_zero(r, uint32_t);
6249 if (r->out.needed == NULL) {
6254 r->out.result = _spoolss_EnumPrinterDataEx(p, r);
6256 if (p->rng_fault_state) {
6258 /* Return true here, srv_pipe_hnd.c will take care */
6262 if (DEBUGLEVEL >= 10) {
6263 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterDataEx, r);
6266 push = ndr_push_init_ctx(r, NULL);
6272 ndr_err = call->ndr_push(push, NDR_OUT, r);
6273 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6278 blob = ndr_push_blob(push);
6279 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6289 static bool api_spoolss_EnumPrinterKey(pipes_struct *p)
6291 const struct ndr_interface_call *call;
6292 struct ndr_pull *pull;
6293 struct ndr_push *push;
6294 enum ndr_err_code ndr_err;
6296 struct spoolss_EnumPrinterKey *r;
6298 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPRINTERKEY];
6300 r = talloc(talloc_tos(), struct spoolss_EnumPrinterKey);
6305 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6310 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
6323 if (DEBUGLEVEL >= 10) {
6324 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterKey, r);
6327 ZERO_STRUCT(r->out);
6328 r->out.key_buffer = talloc_zero(r, const char **);
6329 if (r->out.key_buffer == NULL) {
6334 r->out.needed = talloc_zero(r, uint32_t);
6335 if (r->out.needed == NULL) {
6340 r->out.result = _spoolss_EnumPrinterKey(p, r);
6342 if (p->rng_fault_state) {
6344 /* Return true here, srv_pipe_hnd.c will take care */
6348 if (DEBUGLEVEL >= 10) {
6349 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterKey, r);
6352 push = ndr_push_init_ctx(r, NULL);
6358 ndr_err = call->ndr_push(push, NDR_OUT, r);
6359 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6364 blob = ndr_push_blob(push);
6365 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6375 static bool api_spoolss_DeletePrinterDataEx(pipes_struct *p)
6377 const struct ndr_interface_call *call;
6378 struct ndr_pull *pull;
6379 struct ndr_push *push;
6380 enum ndr_err_code ndr_err;
6382 struct spoolss_DeletePrinterDataEx *r;
6384 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERDATAEX];
6386 r = talloc(talloc_tos(), struct spoolss_DeletePrinterDataEx);
6391 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6396 pull = ndr_pull_init_blob(&blob, r, NULL);
6402 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6403 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6404 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6409 if (DEBUGLEVEL >= 10) {
6410 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDataEx, r);
6413 r->out.result = _spoolss_DeletePrinterDataEx(p, r);
6415 if (p->rng_fault_state) {
6417 /* Return true here, srv_pipe_hnd.c will take care */
6421 if (DEBUGLEVEL >= 10) {
6422 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDataEx, r);
6425 push = ndr_push_init_ctx(r, NULL);
6431 ndr_err = call->ndr_push(push, NDR_OUT, r);
6432 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6437 blob = ndr_push_blob(push);
6438 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6448 static bool api_spoolss_DeletePrinterKey(pipes_struct *p)
6450 const struct ndr_interface_call *call;
6451 struct ndr_pull *pull;
6452 struct ndr_push *push;
6453 enum ndr_err_code ndr_err;
6455 struct spoolss_DeletePrinterKey *r;
6457 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERKEY];
6459 r = talloc(talloc_tos(), struct spoolss_DeletePrinterKey);
6464 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6469 pull = ndr_pull_init_blob(&blob, r, NULL);
6475 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6476 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6477 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6482 if (DEBUGLEVEL >= 10) {
6483 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterKey, r);
6486 r->out.result = _spoolss_DeletePrinterKey(p, r);
6488 if (p->rng_fault_state) {
6490 /* Return true here, srv_pipe_hnd.c will take care */
6494 if (DEBUGLEVEL >= 10) {
6495 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterKey, r);
6498 push = ndr_push_init_ctx(r, NULL);
6504 ndr_err = call->ndr_push(push, NDR_OUT, r);
6505 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6510 blob = ndr_push_blob(push);
6511 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6521 static bool api_spoolss_53(pipes_struct *p)
6523 const struct ndr_interface_call *call;
6524 struct ndr_pull *pull;
6525 struct ndr_push *push;
6526 enum ndr_err_code ndr_err;
6528 struct spoolss_53 *r;
6530 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_53];
6532 r = talloc(talloc_tos(), struct spoolss_53);
6537 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6542 pull = ndr_pull_init_blob(&blob, r, NULL);
6548 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6549 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6550 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6555 if (DEBUGLEVEL >= 10) {
6556 NDR_PRINT_IN_DEBUG(spoolss_53, r);
6559 r->out.result = _spoolss_53(p, r);
6561 if (p->rng_fault_state) {
6563 /* Return true here, srv_pipe_hnd.c will take care */
6567 if (DEBUGLEVEL >= 10) {
6568 NDR_PRINT_OUT_DEBUG(spoolss_53, r);
6571 push = ndr_push_init_ctx(r, NULL);
6577 ndr_err = call->ndr_push(push, NDR_OUT, r);
6578 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6583 blob = ndr_push_blob(push);
6584 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6594 static bool api_spoolss_DeletePrinterDriverEx(pipes_struct *p)
6596 const struct ndr_interface_call *call;
6597 struct ndr_pull *pull;
6598 struct ndr_push *push;
6599 enum ndr_err_code ndr_err;
6601 struct spoolss_DeletePrinterDriverEx *r;
6603 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERDRIVEREX];
6605 r = talloc(talloc_tos(), struct spoolss_DeletePrinterDriverEx);
6610 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6615 pull = ndr_pull_init_blob(&blob, r, NULL);
6621 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6622 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6623 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6628 if (DEBUGLEVEL >= 10) {
6629 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDriverEx, r);
6632 r->out.result = _spoolss_DeletePrinterDriverEx(p, r);
6634 if (p->rng_fault_state) {
6636 /* Return true here, srv_pipe_hnd.c will take care */
6640 if (DEBUGLEVEL >= 10) {
6641 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDriverEx, r);
6644 push = ndr_push_init_ctx(r, NULL);
6650 ndr_err = call->ndr_push(push, NDR_OUT, r);
6651 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6656 blob = ndr_push_blob(push);
6657 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6667 static bool api_spoolss_55(pipes_struct *p)
6669 const struct ndr_interface_call *call;
6670 struct ndr_pull *pull;
6671 struct ndr_push *push;
6672 enum ndr_err_code ndr_err;
6674 struct spoolss_55 *r;
6676 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_55];
6678 r = talloc(talloc_tos(), struct spoolss_55);
6683 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6688 pull = ndr_pull_init_blob(&blob, r, NULL);
6694 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6695 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6696 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6701 if (DEBUGLEVEL >= 10) {
6702 NDR_PRINT_IN_DEBUG(spoolss_55, r);
6705 r->out.result = _spoolss_55(p, r);
6707 if (p->rng_fault_state) {
6709 /* Return true here, srv_pipe_hnd.c will take care */
6713 if (DEBUGLEVEL >= 10) {
6714 NDR_PRINT_OUT_DEBUG(spoolss_55, r);
6717 push = ndr_push_init_ctx(r, NULL);
6723 ndr_err = call->ndr_push(push, NDR_OUT, r);
6724 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6729 blob = ndr_push_blob(push);
6730 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6740 static bool api_spoolss_56(pipes_struct *p)
6742 const struct ndr_interface_call *call;
6743 struct ndr_pull *pull;
6744 struct ndr_push *push;
6745 enum ndr_err_code ndr_err;
6747 struct spoolss_56 *r;
6749 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_56];
6751 r = talloc(talloc_tos(), struct spoolss_56);
6756 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6761 pull = ndr_pull_init_blob(&blob, r, NULL);
6767 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6768 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6769 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6774 if (DEBUGLEVEL >= 10) {
6775 NDR_PRINT_IN_DEBUG(spoolss_56, r);
6778 r->out.result = _spoolss_56(p, r);
6780 if (p->rng_fault_state) {
6782 /* Return true here, srv_pipe_hnd.c will take care */
6786 if (DEBUGLEVEL >= 10) {
6787 NDR_PRINT_OUT_DEBUG(spoolss_56, r);
6790 push = ndr_push_init_ctx(r, NULL);
6796 ndr_err = call->ndr_push(push, NDR_OUT, r);
6797 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6802 blob = ndr_push_blob(push);
6803 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6813 static bool api_spoolss_57(pipes_struct *p)
6815 const struct ndr_interface_call *call;
6816 struct ndr_pull *pull;
6817 struct ndr_push *push;
6818 enum ndr_err_code ndr_err;
6820 struct spoolss_57 *r;
6822 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_57];
6824 r = talloc(talloc_tos(), struct spoolss_57);
6829 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6834 pull = ndr_pull_init_blob(&blob, r, NULL);
6840 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6841 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6842 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6847 if (DEBUGLEVEL >= 10) {
6848 NDR_PRINT_IN_DEBUG(spoolss_57, r);
6851 r->out.result = _spoolss_57(p, r);
6853 if (p->rng_fault_state) {
6855 /* Return true here, srv_pipe_hnd.c will take care */
6859 if (DEBUGLEVEL >= 10) {
6860 NDR_PRINT_OUT_DEBUG(spoolss_57, r);
6863 push = ndr_push_init_ctx(r, NULL);
6869 ndr_err = call->ndr_push(push, NDR_OUT, r);
6870 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6875 blob = ndr_push_blob(push);
6876 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6886 static bool api_spoolss_XcvData(pipes_struct *p)
6888 const struct ndr_interface_call *call;
6889 struct ndr_pull *pull;
6890 struct ndr_push *push;
6891 enum ndr_err_code ndr_err;
6893 struct spoolss_XcvData *r;
6895 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_XCVDATA];
6897 r = talloc(talloc_tos(), struct spoolss_XcvData);
6902 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6907 pull = ndr_pull_init_blob(&blob, r, NULL);
6913 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6914 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6915 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6920 if (DEBUGLEVEL >= 10) {
6921 NDR_PRINT_IN_DEBUG(spoolss_XcvData, r);
6924 ZERO_STRUCT(r->out);
6925 r->out.status_code = r->in.status_code;
6926 r->out.out_data = talloc_zero_array(r, uint8_t, r->in.out_data_size);
6927 if (r->out.out_data == NULL) {
6932 r->out.needed = talloc_zero(r, uint32_t);
6933 if (r->out.needed == NULL) {
6938 r->out.result = _spoolss_XcvData(p, r);
6940 if (p->rng_fault_state) {
6942 /* Return true here, srv_pipe_hnd.c will take care */
6946 if (DEBUGLEVEL >= 10) {
6947 NDR_PRINT_OUT_DEBUG(spoolss_XcvData, r);
6950 push = ndr_push_init_ctx(r, NULL);
6956 ndr_err = call->ndr_push(push, NDR_OUT, r);
6957 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6962 blob = ndr_push_blob(push);
6963 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6973 static bool api_spoolss_AddPrinterDriverEx(pipes_struct *p)
6975 const struct ndr_interface_call *call;
6976 struct ndr_pull *pull;
6977 struct ndr_push *push;
6978 enum ndr_err_code ndr_err;
6980 struct spoolss_AddPrinterDriverEx *r;
6982 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTERDRIVEREX];
6984 r = talloc(talloc_tos(), struct spoolss_AddPrinterDriverEx);
6989 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6994 pull = ndr_pull_init_blob(&blob, r, NULL);
7000 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7001 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7002 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7007 if (DEBUGLEVEL >= 10) {
7008 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterDriverEx, r);
7011 r->out.result = _spoolss_AddPrinterDriverEx(p, r);
7013 if (p->rng_fault_state) {
7015 /* Return true here, srv_pipe_hnd.c will take care */
7019 if (DEBUGLEVEL >= 10) {
7020 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterDriverEx, r);
7023 push = ndr_push_init_ctx(r, NULL);
7029 ndr_err = call->ndr_push(push, NDR_OUT, r);
7030 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7035 blob = ndr_push_blob(push);
7036 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7046 static bool api_spoolss_5a(pipes_struct *p)
7048 const struct ndr_interface_call *call;
7049 struct ndr_pull *pull;
7050 struct ndr_push *push;
7051 enum ndr_err_code ndr_err;
7053 struct spoolss_5a *r;
7055 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5A];
7057 r = talloc(talloc_tos(), struct spoolss_5a);
7062 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7067 pull = ndr_pull_init_blob(&blob, r, NULL);
7073 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7074 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7075 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7080 if (DEBUGLEVEL >= 10) {
7081 NDR_PRINT_IN_DEBUG(spoolss_5a, r);
7084 r->out.result = _spoolss_5a(p, r);
7086 if (p->rng_fault_state) {
7088 /* Return true here, srv_pipe_hnd.c will take care */
7092 if (DEBUGLEVEL >= 10) {
7093 NDR_PRINT_OUT_DEBUG(spoolss_5a, r);
7096 push = ndr_push_init_ctx(r, NULL);
7102 ndr_err = call->ndr_push(push, NDR_OUT, r);
7103 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7108 blob = ndr_push_blob(push);
7109 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7119 static bool api_spoolss_5b(pipes_struct *p)
7121 const struct ndr_interface_call *call;
7122 struct ndr_pull *pull;
7123 struct ndr_push *push;
7124 enum ndr_err_code ndr_err;
7126 struct spoolss_5b *r;
7128 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5B];
7130 r = talloc(talloc_tos(), struct spoolss_5b);
7135 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7140 pull = ndr_pull_init_blob(&blob, r, NULL);
7146 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7147 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7148 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7153 if (DEBUGLEVEL >= 10) {
7154 NDR_PRINT_IN_DEBUG(spoolss_5b, r);
7157 r->out.result = _spoolss_5b(p, r);
7159 if (p->rng_fault_state) {
7161 /* Return true here, srv_pipe_hnd.c will take care */
7165 if (DEBUGLEVEL >= 10) {
7166 NDR_PRINT_OUT_DEBUG(spoolss_5b, r);
7169 push = ndr_push_init_ctx(r, NULL);
7175 ndr_err = call->ndr_push(push, NDR_OUT, r);
7176 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7181 blob = ndr_push_blob(push);
7182 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7192 static bool api_spoolss_5c(pipes_struct *p)
7194 const struct ndr_interface_call *call;
7195 struct ndr_pull *pull;
7196 struct ndr_push *push;
7197 enum ndr_err_code ndr_err;
7199 struct spoolss_5c *r;
7201 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5C];
7203 r = talloc(talloc_tos(), struct spoolss_5c);
7208 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7213 pull = ndr_pull_init_blob(&blob, r, NULL);
7219 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7220 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7221 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7226 if (DEBUGLEVEL >= 10) {
7227 NDR_PRINT_IN_DEBUG(spoolss_5c, r);
7230 r->out.result = _spoolss_5c(p, r);
7232 if (p->rng_fault_state) {
7234 /* Return true here, srv_pipe_hnd.c will take care */
7238 if (DEBUGLEVEL >= 10) {
7239 NDR_PRINT_OUT_DEBUG(spoolss_5c, r);
7242 push = ndr_push_init_ctx(r, NULL);
7248 ndr_err = call->ndr_push(push, NDR_OUT, r);
7249 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7254 blob = ndr_push_blob(push);
7255 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7265 static bool api_spoolss_5d(pipes_struct *p)
7267 const struct ndr_interface_call *call;
7268 struct ndr_pull *pull;
7269 struct ndr_push *push;
7270 enum ndr_err_code ndr_err;
7272 struct spoolss_5d *r;
7274 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5D];
7276 r = talloc(talloc_tos(), struct spoolss_5d);
7281 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7286 pull = ndr_pull_init_blob(&blob, r, NULL);
7292 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7293 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7294 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7299 if (DEBUGLEVEL >= 10) {
7300 NDR_PRINT_IN_DEBUG(spoolss_5d, r);
7303 r->out.result = _spoolss_5d(p, r);
7305 if (p->rng_fault_state) {
7307 /* Return true here, srv_pipe_hnd.c will take care */
7311 if (DEBUGLEVEL >= 10) {
7312 NDR_PRINT_OUT_DEBUG(spoolss_5d, r);
7315 push = ndr_push_init_ctx(r, NULL);
7321 ndr_err = call->ndr_push(push, NDR_OUT, r);
7322 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7327 blob = ndr_push_blob(push);
7328 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7338 static bool api_spoolss_5e(pipes_struct *p)
7340 const struct ndr_interface_call *call;
7341 struct ndr_pull *pull;
7342 struct ndr_push *push;
7343 enum ndr_err_code ndr_err;
7345 struct spoolss_5e *r;
7347 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5E];
7349 r = talloc(talloc_tos(), struct spoolss_5e);
7354 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7359 pull = ndr_pull_init_blob(&blob, r, NULL);
7365 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7366 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7367 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7372 if (DEBUGLEVEL >= 10) {
7373 NDR_PRINT_IN_DEBUG(spoolss_5e, r);
7376 r->out.result = _spoolss_5e(p, r);
7378 if (p->rng_fault_state) {
7380 /* Return true here, srv_pipe_hnd.c will take care */
7384 if (DEBUGLEVEL >= 10) {
7385 NDR_PRINT_OUT_DEBUG(spoolss_5e, r);
7388 push = ndr_push_init_ctx(r, NULL);
7394 ndr_err = call->ndr_push(push, NDR_OUT, r);
7395 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7400 blob = ndr_push_blob(push);
7401 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7411 static bool api_spoolss_5f(pipes_struct *p)
7413 const struct ndr_interface_call *call;
7414 struct ndr_pull *pull;
7415 struct ndr_push *push;
7416 enum ndr_err_code ndr_err;
7418 struct spoolss_5f *r;
7420 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5F];
7422 r = talloc(talloc_tos(), struct spoolss_5f);
7427 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7432 pull = ndr_pull_init_blob(&blob, r, NULL);
7438 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7439 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7440 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7445 if (DEBUGLEVEL >= 10) {
7446 NDR_PRINT_IN_DEBUG(spoolss_5f, r);
7449 r->out.result = _spoolss_5f(p, r);
7451 if (p->rng_fault_state) {
7453 /* Return true here, srv_pipe_hnd.c will take care */
7457 if (DEBUGLEVEL >= 10) {
7458 NDR_PRINT_OUT_DEBUG(spoolss_5f, r);
7461 push = ndr_push_init_ctx(r, NULL);
7467 ndr_err = call->ndr_push(push, NDR_OUT, r);
7468 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7473 blob = ndr_push_blob(push);
7474 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7484 static bool api_spoolss_60(pipes_struct *p)
7486 const struct ndr_interface_call *call;
7487 struct ndr_pull *pull;
7488 struct ndr_push *push;
7489 enum ndr_err_code ndr_err;
7491 struct spoolss_60 *r;
7493 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_60];
7495 r = talloc(talloc_tos(), struct spoolss_60);
7500 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7505 pull = ndr_pull_init_blob(&blob, r, NULL);
7511 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7512 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7513 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7518 if (DEBUGLEVEL >= 10) {
7519 NDR_PRINT_IN_DEBUG(spoolss_60, r);
7522 r->out.result = _spoolss_60(p, r);
7524 if (p->rng_fault_state) {
7526 /* Return true here, srv_pipe_hnd.c will take care */
7530 if (DEBUGLEVEL >= 10) {
7531 NDR_PRINT_OUT_DEBUG(spoolss_60, r);
7534 push = ndr_push_init_ctx(r, NULL);
7540 ndr_err = call->ndr_push(push, NDR_OUT, r);
7541 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7546 blob = ndr_push_blob(push);
7547 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7557 static bool api_spoolss_61(pipes_struct *p)
7559 const struct ndr_interface_call *call;
7560 struct ndr_pull *pull;
7561 struct ndr_push *push;
7562 enum ndr_err_code ndr_err;
7564 struct spoolss_61 *r;
7566 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_61];
7568 r = talloc(talloc_tos(), struct spoolss_61);
7573 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7578 pull = ndr_pull_init_blob(&blob, r, NULL);
7584 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7585 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7586 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7591 if (DEBUGLEVEL >= 10) {
7592 NDR_PRINT_IN_DEBUG(spoolss_61, r);
7595 r->out.result = _spoolss_61(p, r);
7597 if (p->rng_fault_state) {
7599 /* Return true here, srv_pipe_hnd.c will take care */
7603 if (DEBUGLEVEL >= 10) {
7604 NDR_PRINT_OUT_DEBUG(spoolss_61, r);
7607 push = ndr_push_init_ctx(r, NULL);
7613 ndr_err = call->ndr_push(push, NDR_OUT, r);
7614 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7619 blob = ndr_push_blob(push);
7620 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7630 static bool api_spoolss_62(pipes_struct *p)
7632 const struct ndr_interface_call *call;
7633 struct ndr_pull *pull;
7634 struct ndr_push *push;
7635 enum ndr_err_code ndr_err;
7637 struct spoolss_62 *r;
7639 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_62];
7641 r = talloc(talloc_tos(), struct spoolss_62);
7646 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7651 pull = ndr_pull_init_blob(&blob, r, NULL);
7657 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7658 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7659 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7664 if (DEBUGLEVEL >= 10) {
7665 NDR_PRINT_IN_DEBUG(spoolss_62, r);
7668 r->out.result = _spoolss_62(p, r);
7670 if (p->rng_fault_state) {
7672 /* Return true here, srv_pipe_hnd.c will take care */
7676 if (DEBUGLEVEL >= 10) {
7677 NDR_PRINT_OUT_DEBUG(spoolss_62, r);
7680 push = ndr_push_init_ctx(r, NULL);
7686 ndr_err = call->ndr_push(push, NDR_OUT, r);
7687 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7692 blob = ndr_push_blob(push);
7693 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7703 static bool api_spoolss_63(pipes_struct *p)
7705 const struct ndr_interface_call *call;
7706 struct ndr_pull *pull;
7707 struct ndr_push *push;
7708 enum ndr_err_code ndr_err;
7710 struct spoolss_63 *r;
7712 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_63];
7714 r = talloc(talloc_tos(), struct spoolss_63);
7719 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7724 pull = ndr_pull_init_blob(&blob, r, NULL);
7730 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7731 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7732 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7737 if (DEBUGLEVEL >= 10) {
7738 NDR_PRINT_IN_DEBUG(spoolss_63, r);
7741 r->out.result = _spoolss_63(p, r);
7743 if (p->rng_fault_state) {
7745 /* Return true here, srv_pipe_hnd.c will take care */
7749 if (DEBUGLEVEL >= 10) {
7750 NDR_PRINT_OUT_DEBUG(spoolss_63, r);
7753 push = ndr_push_init_ctx(r, NULL);
7759 ndr_err = call->ndr_push(push, NDR_OUT, r);
7760 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7765 blob = ndr_push_blob(push);
7766 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7776 static bool api_spoolss_64(pipes_struct *p)
7778 const struct ndr_interface_call *call;
7779 struct ndr_pull *pull;
7780 struct ndr_push *push;
7781 enum ndr_err_code ndr_err;
7783 struct spoolss_64 *r;
7785 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_64];
7787 r = talloc(talloc_tos(), struct spoolss_64);
7792 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7797 pull = ndr_pull_init_blob(&blob, r, NULL);
7803 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7804 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7805 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7810 if (DEBUGLEVEL >= 10) {
7811 NDR_PRINT_IN_DEBUG(spoolss_64, r);
7814 r->out.result = _spoolss_64(p, r);
7816 if (p->rng_fault_state) {
7818 /* Return true here, srv_pipe_hnd.c will take care */
7822 if (DEBUGLEVEL >= 10) {
7823 NDR_PRINT_OUT_DEBUG(spoolss_64, r);
7826 push = ndr_push_init_ctx(r, NULL);
7832 ndr_err = call->ndr_push(push, NDR_OUT, r);
7833 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7838 blob = ndr_push_blob(push);
7839 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7849 static bool api_spoolss_65(pipes_struct *p)
7851 const struct ndr_interface_call *call;
7852 struct ndr_pull *pull;
7853 struct ndr_push *push;
7854 enum ndr_err_code ndr_err;
7856 struct spoolss_65 *r;
7858 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_65];
7860 r = talloc(talloc_tos(), struct spoolss_65);
7865 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7870 pull = ndr_pull_init_blob(&blob, r, NULL);
7876 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7877 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7878 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7883 if (DEBUGLEVEL >= 10) {
7884 NDR_PRINT_IN_DEBUG(spoolss_65, r);
7887 r->out.result = _spoolss_65(p, r);
7889 if (p->rng_fault_state) {
7891 /* Return true here, srv_pipe_hnd.c will take care */
7895 if (DEBUGLEVEL >= 10) {
7896 NDR_PRINT_OUT_DEBUG(spoolss_65, r);
7899 push = ndr_push_init_ctx(r, NULL);
7905 ndr_err = call->ndr_push(push, NDR_OUT, r);
7906 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7911 blob = ndr_push_blob(push);
7912 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7922 static bool api_spoolss_GetCorePrinterDrivers(pipes_struct *p)
7924 const struct ndr_interface_call *call;
7925 struct ndr_pull *pull;
7926 struct ndr_push *push;
7927 enum ndr_err_code ndr_err;
7929 struct spoolss_GetCorePrinterDrivers *r;
7931 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETCOREPRINTERDRIVERS];
7933 r = talloc(talloc_tos(), struct spoolss_GetCorePrinterDrivers);
7938 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7943 pull = ndr_pull_init_blob(&blob, r, NULL);
7949 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7950 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7951 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7956 if (DEBUGLEVEL >= 10) {
7957 NDR_PRINT_IN_DEBUG(spoolss_GetCorePrinterDrivers, r);
7960 ZERO_STRUCT(r->out);
7961 r->out.core_printer_drivers = talloc_zero_array(r, struct spoolss_CorePrinterDriver, r->in.core_printer_driver_count);
7962 if (r->out.core_printer_drivers == NULL) {
7967 r->out.result = _spoolss_GetCorePrinterDrivers(p, r);
7969 if (p->rng_fault_state) {
7971 /* Return true here, srv_pipe_hnd.c will take care */
7975 if (DEBUGLEVEL >= 10) {
7976 NDR_PRINT_OUT_DEBUG(spoolss_GetCorePrinterDrivers, r);
7979 push = ndr_push_init_ctx(r, NULL);
7985 ndr_err = call->ndr_push(push, NDR_OUT, r);
7986 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7991 blob = ndr_push_blob(push);
7992 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8002 static bool api_spoolss_67(pipes_struct *p)
8004 const struct ndr_interface_call *call;
8005 struct ndr_pull *pull;
8006 struct ndr_push *push;
8007 enum ndr_err_code ndr_err;
8009 struct spoolss_67 *r;
8011 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_67];
8013 r = talloc(talloc_tos(), struct spoolss_67);
8018 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8023 pull = ndr_pull_init_blob(&blob, r, NULL);
8029 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8030 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8031 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8036 if (DEBUGLEVEL >= 10) {
8037 NDR_PRINT_IN_DEBUG(spoolss_67, r);
8040 r->out.result = _spoolss_67(p, r);
8042 if (p->rng_fault_state) {
8044 /* Return true here, srv_pipe_hnd.c will take care */
8048 if (DEBUGLEVEL >= 10) {
8049 NDR_PRINT_OUT_DEBUG(spoolss_67, r);
8052 push = ndr_push_init_ctx(r, NULL);
8058 ndr_err = call->ndr_push(push, NDR_OUT, r);
8059 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8064 blob = ndr_push_blob(push);
8065 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8075 static bool api_spoolss_GetPrinterDriverPackagePath(pipes_struct *p)
8077 const struct ndr_interface_call *call;
8078 struct ndr_pull *pull;
8079 struct ndr_push *push;
8080 enum ndr_err_code ndr_err;
8082 struct spoolss_GetPrinterDriverPackagePath *r;
8084 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH];
8086 r = talloc(talloc_tos(), struct spoolss_GetPrinterDriverPackagePath);
8091 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8096 pull = ndr_pull_init_blob(&blob, r, NULL);
8102 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8103 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8104 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8109 if (DEBUGLEVEL >= 10) {
8110 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriverPackagePath, r);
8113 ZERO_STRUCT(r->out);
8114 r->out.driver_package_cab = r->in.driver_package_cab;
8115 r->out.required = talloc_zero(r, uint32_t);
8116 if (r->out.required == NULL) {
8121 r->out.result = _spoolss_GetPrinterDriverPackagePath(p, r);
8123 if (p->rng_fault_state) {
8125 /* Return true here, srv_pipe_hnd.c will take care */
8129 if (DEBUGLEVEL >= 10) {
8130 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriverPackagePath, r);
8133 push = ndr_push_init_ctx(r, NULL);
8139 ndr_err = call->ndr_push(push, NDR_OUT, r);
8140 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8145 blob = ndr_push_blob(push);
8146 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8156 static bool api_spoolss_69(pipes_struct *p)
8158 const struct ndr_interface_call *call;
8159 struct ndr_pull *pull;
8160 struct ndr_push *push;
8161 enum ndr_err_code ndr_err;
8163 struct spoolss_69 *r;
8165 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_69];
8167 r = talloc(talloc_tos(), struct spoolss_69);
8172 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8177 pull = ndr_pull_init_blob(&blob, r, NULL);
8183 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8184 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8185 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8190 if (DEBUGLEVEL >= 10) {
8191 NDR_PRINT_IN_DEBUG(spoolss_69, r);
8194 r->out.result = _spoolss_69(p, r);
8196 if (p->rng_fault_state) {
8198 /* Return true here, srv_pipe_hnd.c will take care */
8202 if (DEBUGLEVEL >= 10) {
8203 NDR_PRINT_OUT_DEBUG(spoolss_69, r);
8206 push = ndr_push_init_ctx(r, NULL);
8212 ndr_err = call->ndr_push(push, NDR_OUT, r);
8213 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8218 blob = ndr_push_blob(push);
8219 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8229 static bool api_spoolss_6a(pipes_struct *p)
8231 const struct ndr_interface_call *call;
8232 struct ndr_pull *pull;
8233 struct ndr_push *push;
8234 enum ndr_err_code ndr_err;
8236 struct spoolss_6a *r;
8238 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6A];
8240 r = talloc(talloc_tos(), struct spoolss_6a);
8245 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8250 pull = ndr_pull_init_blob(&blob, r, NULL);
8256 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8257 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8258 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8263 if (DEBUGLEVEL >= 10) {
8264 NDR_PRINT_IN_DEBUG(spoolss_6a, r);
8267 r->out.result = _spoolss_6a(p, r);
8269 if (p->rng_fault_state) {
8271 /* Return true here, srv_pipe_hnd.c will take care */
8275 if (DEBUGLEVEL >= 10) {
8276 NDR_PRINT_OUT_DEBUG(spoolss_6a, r);
8279 push = ndr_push_init_ctx(r, NULL);
8285 ndr_err = call->ndr_push(push, NDR_OUT, r);
8286 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8291 blob = ndr_push_blob(push);
8292 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8302 static bool api_spoolss_6b(pipes_struct *p)
8304 const struct ndr_interface_call *call;
8305 struct ndr_pull *pull;
8306 struct ndr_push *push;
8307 enum ndr_err_code ndr_err;
8309 struct spoolss_6b *r;
8311 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6B];
8313 r = talloc(talloc_tos(), struct spoolss_6b);
8318 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8323 pull = ndr_pull_init_blob(&blob, r, NULL);
8329 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8330 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8331 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8336 if (DEBUGLEVEL >= 10) {
8337 NDR_PRINT_IN_DEBUG(spoolss_6b, r);
8340 r->out.result = _spoolss_6b(p, r);
8342 if (p->rng_fault_state) {
8344 /* Return true here, srv_pipe_hnd.c will take care */
8348 if (DEBUGLEVEL >= 10) {
8349 NDR_PRINT_OUT_DEBUG(spoolss_6b, r);
8352 push = ndr_push_init_ctx(r, NULL);
8358 ndr_err = call->ndr_push(push, NDR_OUT, r);
8359 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8364 blob = ndr_push_blob(push);
8365 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8375 static bool api_spoolss_6c(pipes_struct *p)
8377 const struct ndr_interface_call *call;
8378 struct ndr_pull *pull;
8379 struct ndr_push *push;
8380 enum ndr_err_code ndr_err;
8382 struct spoolss_6c *r;
8384 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6C];
8386 r = talloc(talloc_tos(), struct spoolss_6c);
8391 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8396 pull = ndr_pull_init_blob(&blob, r, NULL);
8402 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8403 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8404 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8409 if (DEBUGLEVEL >= 10) {
8410 NDR_PRINT_IN_DEBUG(spoolss_6c, r);
8413 r->out.result = _spoolss_6c(p, r);
8415 if (p->rng_fault_state) {
8417 /* Return true here, srv_pipe_hnd.c will take care */
8421 if (DEBUGLEVEL >= 10) {
8422 NDR_PRINT_OUT_DEBUG(spoolss_6c, r);
8425 push = ndr_push_init_ctx(r, NULL);
8431 ndr_err = call->ndr_push(push, NDR_OUT, r);
8432 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8437 blob = ndr_push_blob(push);
8438 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8448 static bool api_spoolss_6d(pipes_struct *p)
8450 const struct ndr_interface_call *call;
8451 struct ndr_pull *pull;
8452 struct ndr_push *push;
8453 enum ndr_err_code ndr_err;
8455 struct spoolss_6d *r;
8457 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6D];
8459 r = talloc(talloc_tos(), struct spoolss_6d);
8464 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8469 pull = ndr_pull_init_blob(&blob, r, NULL);
8475 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8476 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8477 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8482 if (DEBUGLEVEL >= 10) {
8483 NDR_PRINT_IN_DEBUG(spoolss_6d, r);
8486 r->out.result = _spoolss_6d(p, r);
8488 if (p->rng_fault_state) {
8490 /* Return true here, srv_pipe_hnd.c will take care */
8494 if (DEBUGLEVEL >= 10) {
8495 NDR_PRINT_OUT_DEBUG(spoolss_6d, r);
8498 push = ndr_push_init_ctx(r, NULL);
8504 ndr_err = call->ndr_push(push, NDR_OUT, r);
8505 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8510 blob = ndr_push_blob(push);
8511 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8523 static struct api_struct api_spoolss_cmds[] =
8525 {"SPOOLSS_ENUMPRINTERS", NDR_SPOOLSS_ENUMPRINTERS, api_spoolss_EnumPrinters},
8526 {"SPOOLSS_OPENPRINTER", NDR_SPOOLSS_OPENPRINTER, api_spoolss_OpenPrinter},
8527 {"SPOOLSS_SETJOB", NDR_SPOOLSS_SETJOB, api_spoolss_SetJob},
8528 {"SPOOLSS_GETJOB", NDR_SPOOLSS_GETJOB, api_spoolss_GetJob},
8529 {"SPOOLSS_ENUMJOBS", NDR_SPOOLSS_ENUMJOBS, api_spoolss_EnumJobs},
8530 {"SPOOLSS_ADDPRINTER", NDR_SPOOLSS_ADDPRINTER, api_spoolss_AddPrinter},
8531 {"SPOOLSS_DELETEPRINTER", NDR_SPOOLSS_DELETEPRINTER, api_spoolss_DeletePrinter},
8532 {"SPOOLSS_SETPRINTER", NDR_SPOOLSS_SETPRINTER, api_spoolss_SetPrinter},
8533 {"SPOOLSS_GETPRINTER", NDR_SPOOLSS_GETPRINTER, api_spoolss_GetPrinter},
8534 {"SPOOLSS_ADDPRINTERDRIVER", NDR_SPOOLSS_ADDPRINTERDRIVER, api_spoolss_AddPrinterDriver},
8535 {"SPOOLSS_ENUMPRINTERDRIVERS", NDR_SPOOLSS_ENUMPRINTERDRIVERS, api_spoolss_EnumPrinterDrivers},
8536 {"SPOOLSS_GETPRINTERDRIVER", NDR_SPOOLSS_GETPRINTERDRIVER, api_spoolss_GetPrinterDriver},
8537 {"SPOOLSS_GETPRINTERDRIVERDIRECTORY", NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY, api_spoolss_GetPrinterDriverDirectory},
8538 {"SPOOLSS_DELETEPRINTERDRIVER", NDR_SPOOLSS_DELETEPRINTERDRIVER, api_spoolss_DeletePrinterDriver},
8539 {"SPOOLSS_ADDPRINTPROCESSOR", NDR_SPOOLSS_ADDPRINTPROCESSOR, api_spoolss_AddPrintProcessor},
8540 {"SPOOLSS_ENUMPRINTPROCESSORS", NDR_SPOOLSS_ENUMPRINTPROCESSORS, api_spoolss_EnumPrintProcessors},
8541 {"SPOOLSS_GETPRINTPROCESSORDIRECTORY", NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY, api_spoolss_GetPrintProcessorDirectory},
8542 {"SPOOLSS_STARTDOCPRINTER", NDR_SPOOLSS_STARTDOCPRINTER, api_spoolss_StartDocPrinter},
8543 {"SPOOLSS_STARTPAGEPRINTER", NDR_SPOOLSS_STARTPAGEPRINTER, api_spoolss_StartPagePrinter},
8544 {"SPOOLSS_WRITEPRINTER", NDR_SPOOLSS_WRITEPRINTER, api_spoolss_WritePrinter},
8545 {"SPOOLSS_ENDPAGEPRINTER", NDR_SPOOLSS_ENDPAGEPRINTER, api_spoolss_EndPagePrinter},
8546 {"SPOOLSS_ABORTPRINTER", NDR_SPOOLSS_ABORTPRINTER, api_spoolss_AbortPrinter},
8547 {"SPOOLSS_READPRINTER", NDR_SPOOLSS_READPRINTER, api_spoolss_ReadPrinter},
8548 {"SPOOLSS_ENDDOCPRINTER", NDR_SPOOLSS_ENDDOCPRINTER, api_spoolss_EndDocPrinter},
8549 {"SPOOLSS_ADDJOB", NDR_SPOOLSS_ADDJOB, api_spoolss_AddJob},
8550 {"SPOOLSS_SCHEDULEJOB", NDR_SPOOLSS_SCHEDULEJOB, api_spoolss_ScheduleJob},
8551 {"SPOOLSS_GETPRINTERDATA", NDR_SPOOLSS_GETPRINTERDATA, api_spoolss_GetPrinterData},
8552 {"SPOOLSS_SETPRINTERDATA", NDR_SPOOLSS_SETPRINTERDATA, api_spoolss_SetPrinterData},
8553 {"SPOOLSS_WAITFORPRINTERCHANGE", NDR_SPOOLSS_WAITFORPRINTERCHANGE, api_spoolss_WaitForPrinterChange},
8554 {"SPOOLSS_CLOSEPRINTER", NDR_SPOOLSS_CLOSEPRINTER, api_spoolss_ClosePrinter},
8555 {"SPOOLSS_ADDFORM", NDR_SPOOLSS_ADDFORM, api_spoolss_AddForm},
8556 {"SPOOLSS_DELETEFORM", NDR_SPOOLSS_DELETEFORM, api_spoolss_DeleteForm},
8557 {"SPOOLSS_GETFORM", NDR_SPOOLSS_GETFORM, api_spoolss_GetForm},
8558 {"SPOOLSS_SETFORM", NDR_SPOOLSS_SETFORM, api_spoolss_SetForm},
8559 {"SPOOLSS_ENUMFORMS", NDR_SPOOLSS_ENUMFORMS, api_spoolss_EnumForms},
8560 {"SPOOLSS_ENUMPORTS", NDR_SPOOLSS_ENUMPORTS, api_spoolss_EnumPorts},
8561 {"SPOOLSS_ENUMMONITORS", NDR_SPOOLSS_ENUMMONITORS, api_spoolss_EnumMonitors},
8562 {"SPOOLSS_ADDPORT", NDR_SPOOLSS_ADDPORT, api_spoolss_AddPort},
8563 {"SPOOLSS_CONFIGUREPORT", NDR_SPOOLSS_CONFIGUREPORT, api_spoolss_ConfigurePort},
8564 {"SPOOLSS_DELETEPORT", NDR_SPOOLSS_DELETEPORT, api_spoolss_DeletePort},
8565 {"SPOOLSS_CREATEPRINTERIC", NDR_SPOOLSS_CREATEPRINTERIC, api_spoolss_CreatePrinterIC},
8566 {"SPOOLSS_PLAYGDISCRIPTONPRINTERIC", NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC, api_spoolss_PlayGDIScriptOnPrinterIC},
8567 {"SPOOLSS_DELETEPRINTERIC", NDR_SPOOLSS_DELETEPRINTERIC, api_spoolss_DeletePrinterIC},
8568 {"SPOOLSS_ADDPRINTERCONNECTION", NDR_SPOOLSS_ADDPRINTERCONNECTION, api_spoolss_AddPrinterConnection},
8569 {"SPOOLSS_DELETEPRINTERCONNECTION", NDR_SPOOLSS_DELETEPRINTERCONNECTION, api_spoolss_DeletePrinterConnection},
8570 {"SPOOLSS_PRINTERMESSAGEBOX", NDR_SPOOLSS_PRINTERMESSAGEBOX, api_spoolss_PrinterMessageBox},
8571 {"SPOOLSS_ADDMONITOR", NDR_SPOOLSS_ADDMONITOR, api_spoolss_AddMonitor},
8572 {"SPOOLSS_DELETEMONITOR", NDR_SPOOLSS_DELETEMONITOR, api_spoolss_DeleteMonitor},
8573 {"SPOOLSS_DELETEPRINTPROCESSOR", NDR_SPOOLSS_DELETEPRINTPROCESSOR, api_spoolss_DeletePrintProcessor},
8574 {"SPOOLSS_ADDPRINTPROVIDOR", NDR_SPOOLSS_ADDPRINTPROVIDOR, api_spoolss_AddPrintProvidor},
8575 {"SPOOLSS_DELETEPRINTPROVIDOR", NDR_SPOOLSS_DELETEPRINTPROVIDOR, api_spoolss_DeletePrintProvidor},
8576 {"SPOOLSS_ENUMPRINTPROCDATATYPES", NDR_SPOOLSS_ENUMPRINTPROCDATATYPES, api_spoolss_EnumPrintProcDataTypes},
8577 {"SPOOLSS_RESETPRINTER", NDR_SPOOLSS_RESETPRINTER, api_spoolss_ResetPrinter},
8578 {"SPOOLSS_GETPRINTERDRIVER2", NDR_SPOOLSS_GETPRINTERDRIVER2, api_spoolss_GetPrinterDriver2},
8579 {"SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION", NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION, api_spoolss_FindFirstPrinterChangeNotification},
8580 {"SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION", NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION, api_spoolss_FindNextPrinterChangeNotification},
8581 {"SPOOLSS_FINDCLOSEPRINTERNOTIFY", NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY, api_spoolss_FindClosePrinterNotify},
8582 {"SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD", NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD, api_spoolss_RouterFindFirstPrinterChangeNotificationOld},
8583 {"SPOOLSS_REPLYOPENPRINTER", NDR_SPOOLSS_REPLYOPENPRINTER, api_spoolss_ReplyOpenPrinter},
8584 {"SPOOLSS_ROUTERREPLYPRINTER", NDR_SPOOLSS_ROUTERREPLYPRINTER, api_spoolss_RouterReplyPrinter},
8585 {"SPOOLSS_REPLYCLOSEPRINTER", NDR_SPOOLSS_REPLYCLOSEPRINTER, api_spoolss_ReplyClosePrinter},
8586 {"SPOOLSS_ADDPORTEX", NDR_SPOOLSS_ADDPORTEX, api_spoolss_AddPortEx},
8587 {"SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION", NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION, api_spoolss_RouterFindFirstPrinterChangeNotification},
8588 {"SPOOLSS_SPOOLERINIT", NDR_SPOOLSS_SPOOLERINIT, api_spoolss_SpoolerInit},
8589 {"SPOOLSS_RESETPRINTEREX", NDR_SPOOLSS_RESETPRINTEREX, api_spoolss_ResetPrinterEx},
8590 {"SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX", NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX, api_spoolss_RemoteFindFirstPrinterChangeNotifyEx},
8591 {"SPOOLSS_ROUTERREPLYPRINTEREX", NDR_SPOOLSS_ROUTERREPLYPRINTEREX, api_spoolss_RouterReplyPrinterEx},
8592 {"SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY", NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY, api_spoolss_RouterRefreshPrinterChangeNotify},
8593 {"SPOOLSS_44", NDR_SPOOLSS_44, api_spoolss_44},
8594 {"SPOOLSS_OPENPRINTEREX", NDR_SPOOLSS_OPENPRINTEREX, api_spoolss_OpenPrinterEx},
8595 {"SPOOLSS_ADDPRINTEREX", NDR_SPOOLSS_ADDPRINTEREX, api_spoolss_AddPrinterEx},
8596 {"SPOOLSS_47", NDR_SPOOLSS_47, api_spoolss_47},
8597 {"SPOOLSS_ENUMPRINTERDATA", NDR_SPOOLSS_ENUMPRINTERDATA, api_spoolss_EnumPrinterData},
8598 {"SPOOLSS_DELETEPRINTERDATA", NDR_SPOOLSS_DELETEPRINTERDATA, api_spoolss_DeletePrinterData},
8599 {"SPOOLSS_4A", NDR_SPOOLSS_4A, api_spoolss_4a},
8600 {"SPOOLSS_4B", NDR_SPOOLSS_4B, api_spoolss_4b},
8601 {"SPOOLSS_4C", NDR_SPOOLSS_4C, api_spoolss_4c},
8602 {"SPOOLSS_SETPRINTERDATAEX", NDR_SPOOLSS_SETPRINTERDATAEX, api_spoolss_SetPrinterDataEx},
8603 {"SPOOLSS_GETPRINTERDATAEX", NDR_SPOOLSS_GETPRINTERDATAEX, api_spoolss_GetPrinterDataEx},
8604 {"SPOOLSS_ENUMPRINTERDATAEX", NDR_SPOOLSS_ENUMPRINTERDATAEX, api_spoolss_EnumPrinterDataEx},
8605 {"SPOOLSS_ENUMPRINTERKEY", NDR_SPOOLSS_ENUMPRINTERKEY, api_spoolss_EnumPrinterKey},
8606 {"SPOOLSS_DELETEPRINTERDATAEX", NDR_SPOOLSS_DELETEPRINTERDATAEX, api_spoolss_DeletePrinterDataEx},
8607 {"SPOOLSS_DELETEPRINTERKEY", NDR_SPOOLSS_DELETEPRINTERKEY, api_spoolss_DeletePrinterKey},
8608 {"SPOOLSS_53", NDR_SPOOLSS_53, api_spoolss_53},
8609 {"SPOOLSS_DELETEPRINTERDRIVEREX", NDR_SPOOLSS_DELETEPRINTERDRIVEREX, api_spoolss_DeletePrinterDriverEx},
8610 {"SPOOLSS_55", NDR_SPOOLSS_55, api_spoolss_55},
8611 {"SPOOLSS_56", NDR_SPOOLSS_56, api_spoolss_56},
8612 {"SPOOLSS_57", NDR_SPOOLSS_57, api_spoolss_57},
8613 {"SPOOLSS_XCVDATA", NDR_SPOOLSS_XCVDATA, api_spoolss_XcvData},
8614 {"SPOOLSS_ADDPRINTERDRIVEREX", NDR_SPOOLSS_ADDPRINTERDRIVEREX, api_spoolss_AddPrinterDriverEx},
8615 {"SPOOLSS_5A", NDR_SPOOLSS_5A, api_spoolss_5a},
8616 {"SPOOLSS_5B", NDR_SPOOLSS_5B, api_spoolss_5b},
8617 {"SPOOLSS_5C", NDR_SPOOLSS_5C, api_spoolss_5c},
8618 {"SPOOLSS_5D", NDR_SPOOLSS_5D, api_spoolss_5d},
8619 {"SPOOLSS_5E", NDR_SPOOLSS_5E, api_spoolss_5e},
8620 {"SPOOLSS_5F", NDR_SPOOLSS_5F, api_spoolss_5f},
8621 {"SPOOLSS_60", NDR_SPOOLSS_60, api_spoolss_60},
8622 {"SPOOLSS_61", NDR_SPOOLSS_61, api_spoolss_61},
8623 {"SPOOLSS_62", NDR_SPOOLSS_62, api_spoolss_62},
8624 {"SPOOLSS_63", NDR_SPOOLSS_63, api_spoolss_63},
8625 {"SPOOLSS_64", NDR_SPOOLSS_64, api_spoolss_64},
8626 {"SPOOLSS_65", NDR_SPOOLSS_65, api_spoolss_65},
8627 {"SPOOLSS_GETCOREPRINTERDRIVERS", NDR_SPOOLSS_GETCOREPRINTERDRIVERS, api_spoolss_GetCorePrinterDrivers},
8628 {"SPOOLSS_67", NDR_SPOOLSS_67, api_spoolss_67},
8629 {"SPOOLSS_GETPRINTERDRIVERPACKAGEPATH", NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH, api_spoolss_GetPrinterDriverPackagePath},
8630 {"SPOOLSS_69", NDR_SPOOLSS_69, api_spoolss_69},
8631 {"SPOOLSS_6A", NDR_SPOOLSS_6A, api_spoolss_6a},
8632 {"SPOOLSS_6B", NDR_SPOOLSS_6B, api_spoolss_6b},
8633 {"SPOOLSS_6C", NDR_SPOOLSS_6C, api_spoolss_6c},
8634 {"SPOOLSS_6D", NDR_SPOOLSS_6D, api_spoolss_6d},
8637 void spoolss_get_pipe_fns(struct api_struct **fns, int *n_fns)
8639 *fns = api_spoolss_cmds;
8640 *n_fns = sizeof(api_spoolss_cmds) / sizeof(struct api_struct);
8643 NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *interface, uint32_t interface_version, uint32_t opnum, void *_r)
8645 if (cli->pipes_struct == NULL) {
8646 return NT_STATUS_INVALID_PARAMETER;
8651 case NDR_SPOOLSS_ENUMPRINTERS: {
8652 struct spoolss_EnumPrinters *r = (struct spoolss_EnumPrinters *)_r;
8653 ZERO_STRUCT(r->out);
8654 r->out.count = talloc_zero(mem_ctx, uint32_t);
8655 if (r->out.count == NULL) {
8656 return NT_STATUS_NO_MEMORY;
8659 r->out.info = talloc_zero(mem_ctx, union spoolss_PrinterInfo *);
8660 if (r->out.info == NULL) {
8661 return NT_STATUS_NO_MEMORY;
8664 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8665 if (r->out.needed == NULL) {
8666 return NT_STATUS_NO_MEMORY;
8669 r->out.result = _spoolss_EnumPrinters(cli->pipes_struct, r);
8670 return NT_STATUS_OK;
8673 case NDR_SPOOLSS_OPENPRINTER: {
8674 struct spoolss_OpenPrinter *r = (struct spoolss_OpenPrinter *)_r;
8675 ZERO_STRUCT(r->out);
8676 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
8677 if (r->out.handle == NULL) {
8678 return NT_STATUS_NO_MEMORY;
8681 r->out.result = _spoolss_OpenPrinter(cli->pipes_struct, r);
8682 return NT_STATUS_OK;
8685 case NDR_SPOOLSS_SETJOB: {
8686 struct spoolss_SetJob *r = (struct spoolss_SetJob *)_r;
8687 r->out.result = _spoolss_SetJob(cli->pipes_struct, r);
8688 return NT_STATUS_OK;
8691 case NDR_SPOOLSS_GETJOB: {
8692 struct spoolss_GetJob *r = (struct spoolss_GetJob *)_r;
8693 ZERO_STRUCT(r->out);
8694 r->out.info = talloc_zero(mem_ctx, union spoolss_JobInfo);
8695 if (r->out.info == NULL) {
8696 return NT_STATUS_NO_MEMORY;
8699 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8700 if (r->out.needed == NULL) {
8701 return NT_STATUS_NO_MEMORY;
8704 r->out.result = _spoolss_GetJob(cli->pipes_struct, r);
8705 return NT_STATUS_OK;
8708 case NDR_SPOOLSS_ENUMJOBS: {
8709 struct spoolss_EnumJobs *r = (struct spoolss_EnumJobs *)_r;
8710 ZERO_STRUCT(r->out);
8711 r->out.count = talloc_zero(mem_ctx, uint32_t);
8712 if (r->out.count == NULL) {
8713 return NT_STATUS_NO_MEMORY;
8716 r->out.info = talloc_zero(mem_ctx, union spoolss_JobInfo *);
8717 if (r->out.info == NULL) {
8718 return NT_STATUS_NO_MEMORY;
8721 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8722 if (r->out.needed == NULL) {
8723 return NT_STATUS_NO_MEMORY;
8726 r->out.result = _spoolss_EnumJobs(cli->pipes_struct, r);
8727 return NT_STATUS_OK;
8730 case NDR_SPOOLSS_ADDPRINTER: {
8731 struct spoolss_AddPrinter *r = (struct spoolss_AddPrinter *)_r;
8732 ZERO_STRUCT(r->out);
8733 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
8734 if (r->out.handle == NULL) {
8735 return NT_STATUS_NO_MEMORY;
8738 r->out.result = _spoolss_AddPrinter(cli->pipes_struct, r);
8739 return NT_STATUS_OK;
8742 case NDR_SPOOLSS_DELETEPRINTER: {
8743 struct spoolss_DeletePrinter *r = (struct spoolss_DeletePrinter *)_r;
8744 r->out.result = _spoolss_DeletePrinter(cli->pipes_struct, r);
8745 return NT_STATUS_OK;
8748 case NDR_SPOOLSS_SETPRINTER: {
8749 struct spoolss_SetPrinter *r = (struct spoolss_SetPrinter *)_r;
8750 r->out.result = _spoolss_SetPrinter(cli->pipes_struct, r);
8751 return NT_STATUS_OK;
8754 case NDR_SPOOLSS_GETPRINTER: {
8755 struct spoolss_GetPrinter *r = (struct spoolss_GetPrinter *)_r;
8756 ZERO_STRUCT(r->out);
8757 r->out.info = talloc_zero(mem_ctx, union spoolss_PrinterInfo);
8758 if (r->out.info == NULL) {
8759 return NT_STATUS_NO_MEMORY;
8762 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8763 if (r->out.needed == NULL) {
8764 return NT_STATUS_NO_MEMORY;
8767 r->out.result = _spoolss_GetPrinter(cli->pipes_struct, r);
8768 return NT_STATUS_OK;
8771 case NDR_SPOOLSS_ADDPRINTERDRIVER: {
8772 struct spoolss_AddPrinterDriver *r = (struct spoolss_AddPrinterDriver *)_r;
8773 r->out.result = _spoolss_AddPrinterDriver(cli->pipes_struct, r);
8774 return NT_STATUS_OK;
8777 case NDR_SPOOLSS_ENUMPRINTERDRIVERS: {
8778 struct spoolss_EnumPrinterDrivers *r = (struct spoolss_EnumPrinterDrivers *)_r;
8779 ZERO_STRUCT(r->out);
8780 r->out.count = talloc_zero(mem_ctx, uint32_t);
8781 if (r->out.count == NULL) {
8782 return NT_STATUS_NO_MEMORY;
8785 r->out.info = talloc_zero(mem_ctx, union spoolss_DriverInfo *);
8786 if (r->out.info == NULL) {
8787 return NT_STATUS_NO_MEMORY;
8790 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8791 if (r->out.needed == NULL) {
8792 return NT_STATUS_NO_MEMORY;
8795 r->out.result = _spoolss_EnumPrinterDrivers(cli->pipes_struct, r);
8796 return NT_STATUS_OK;
8799 case NDR_SPOOLSS_GETPRINTERDRIVER: {
8800 struct spoolss_GetPrinterDriver *r = (struct spoolss_GetPrinterDriver *)_r;
8801 ZERO_STRUCT(r->out);
8802 r->out.info = talloc_zero(mem_ctx, union spoolss_DriverInfo);
8803 if (r->out.info == NULL) {
8804 return NT_STATUS_NO_MEMORY;
8807 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8808 if (r->out.needed == NULL) {
8809 return NT_STATUS_NO_MEMORY;
8812 r->out.result = _spoolss_GetPrinterDriver(cli->pipes_struct, r);
8813 return NT_STATUS_OK;
8816 case NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY: {
8817 struct spoolss_GetPrinterDriverDirectory *r = (struct spoolss_GetPrinterDriverDirectory *)_r;
8818 ZERO_STRUCT(r->out);
8819 r->out.info = talloc_zero(mem_ctx, union spoolss_DriverDirectoryInfo);
8820 if (r->out.info == NULL) {
8821 return NT_STATUS_NO_MEMORY;
8824 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8825 if (r->out.needed == NULL) {
8826 return NT_STATUS_NO_MEMORY;
8829 r->out.result = _spoolss_GetPrinterDriverDirectory(cli->pipes_struct, r);
8830 return NT_STATUS_OK;
8833 case NDR_SPOOLSS_DELETEPRINTERDRIVER: {
8834 struct spoolss_DeletePrinterDriver *r = (struct spoolss_DeletePrinterDriver *)_r;
8835 r->out.result = _spoolss_DeletePrinterDriver(cli->pipes_struct, r);
8836 return NT_STATUS_OK;
8839 case NDR_SPOOLSS_ADDPRINTPROCESSOR: {
8840 struct spoolss_AddPrintProcessor *r = (struct spoolss_AddPrintProcessor *)_r;
8841 r->out.result = _spoolss_AddPrintProcessor(cli->pipes_struct, r);
8842 return NT_STATUS_OK;
8845 case NDR_SPOOLSS_ENUMPRINTPROCESSORS: {
8846 struct spoolss_EnumPrintProcessors *r = (struct spoolss_EnumPrintProcessors *)_r;
8847 ZERO_STRUCT(r->out);
8848 r->out.count = talloc_zero(mem_ctx, uint32_t);
8849 if (r->out.count == NULL) {
8850 return NT_STATUS_NO_MEMORY;
8853 r->out.info = talloc_zero(mem_ctx, union spoolss_PrintProcessorInfo *);
8854 if (r->out.info == NULL) {
8855 return NT_STATUS_NO_MEMORY;
8858 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8859 if (r->out.needed == NULL) {
8860 return NT_STATUS_NO_MEMORY;
8863 r->out.result = _spoolss_EnumPrintProcessors(cli->pipes_struct, r);
8864 return NT_STATUS_OK;
8867 case NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY: {
8868 struct spoolss_GetPrintProcessorDirectory *r = (struct spoolss_GetPrintProcessorDirectory *)_r;
8869 ZERO_STRUCT(r->out);
8870 r->out.info = talloc_zero(mem_ctx, union spoolss_PrintProcessorDirectoryInfo);
8871 if (r->out.info == NULL) {
8872 return NT_STATUS_NO_MEMORY;
8875 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8876 if (r->out.needed == NULL) {
8877 return NT_STATUS_NO_MEMORY;
8880 r->out.result = _spoolss_GetPrintProcessorDirectory(cli->pipes_struct, r);
8881 return NT_STATUS_OK;
8884 case NDR_SPOOLSS_STARTDOCPRINTER: {
8885 struct spoolss_StartDocPrinter *r = (struct spoolss_StartDocPrinter *)_r;
8886 ZERO_STRUCT(r->out);
8887 r->out.job_id = talloc_zero(mem_ctx, uint32_t);
8888 if (r->out.job_id == NULL) {
8889 return NT_STATUS_NO_MEMORY;
8892 r->out.result = _spoolss_StartDocPrinter(cli->pipes_struct, r);
8893 return NT_STATUS_OK;
8896 case NDR_SPOOLSS_STARTPAGEPRINTER: {
8897 struct spoolss_StartPagePrinter *r = (struct spoolss_StartPagePrinter *)_r;
8898 r->out.result = _spoolss_StartPagePrinter(cli->pipes_struct, r);
8899 return NT_STATUS_OK;
8902 case NDR_SPOOLSS_WRITEPRINTER: {
8903 struct spoolss_WritePrinter *r = (struct spoolss_WritePrinter *)_r;
8904 ZERO_STRUCT(r->out);
8905 r->out.num_written = talloc_zero(mem_ctx, uint32_t);
8906 if (r->out.num_written == NULL) {
8907 return NT_STATUS_NO_MEMORY;
8910 r->out.result = _spoolss_WritePrinter(cli->pipes_struct, r);
8911 return NT_STATUS_OK;
8914 case NDR_SPOOLSS_ENDPAGEPRINTER: {
8915 struct spoolss_EndPagePrinter *r = (struct spoolss_EndPagePrinter *)_r;
8916 r->out.result = _spoolss_EndPagePrinter(cli->pipes_struct, r);
8917 return NT_STATUS_OK;
8920 case NDR_SPOOLSS_ABORTPRINTER: {
8921 struct spoolss_AbortPrinter *r = (struct spoolss_AbortPrinter *)_r;
8922 r->out.result = _spoolss_AbortPrinter(cli->pipes_struct, r);
8923 return NT_STATUS_OK;
8926 case NDR_SPOOLSS_READPRINTER: {
8927 struct spoolss_ReadPrinter *r = (struct spoolss_ReadPrinter *)_r;
8928 ZERO_STRUCT(r->out);
8929 r->out.data = talloc_zero_array(mem_ctx, uint8_t, r->in.data_size);
8930 if (r->out.data == NULL) {
8931 return NT_STATUS_NO_MEMORY;
8934 r->out._data_size = talloc_zero(mem_ctx, uint32_t);
8935 if (r->out._data_size == NULL) {
8936 return NT_STATUS_NO_MEMORY;
8939 r->out.result = _spoolss_ReadPrinter(cli->pipes_struct, r);
8940 return NT_STATUS_OK;
8943 case NDR_SPOOLSS_ENDDOCPRINTER: {
8944 struct spoolss_EndDocPrinter *r = (struct spoolss_EndDocPrinter *)_r;
8945 r->out.result = _spoolss_EndDocPrinter(cli->pipes_struct, r);
8946 return NT_STATUS_OK;
8949 case NDR_SPOOLSS_ADDJOB: {
8950 struct spoolss_AddJob *r = (struct spoolss_AddJob *)_r;
8951 ZERO_STRUCT(r->out);
8952 r->out.buffer = r->in.buffer;
8953 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8954 if (r->out.needed == NULL) {
8955 return NT_STATUS_NO_MEMORY;
8958 r->out.result = _spoolss_AddJob(cli->pipes_struct, r);
8959 return NT_STATUS_OK;
8962 case NDR_SPOOLSS_SCHEDULEJOB: {
8963 struct spoolss_ScheduleJob *r = (struct spoolss_ScheduleJob *)_r;
8964 r->out.result = _spoolss_ScheduleJob(cli->pipes_struct, r);
8965 return NT_STATUS_OK;
8968 case NDR_SPOOLSS_GETPRINTERDATA: {
8969 struct spoolss_GetPrinterData *r = (struct spoolss_GetPrinterData *)_r;
8970 ZERO_STRUCT(r->out);
8971 r->out.type = talloc_zero(mem_ctx, enum winreg_Type);
8972 if (r->out.type == NULL) {
8973 return NT_STATUS_NO_MEMORY;
8976 r->out.data = talloc_zero(mem_ctx, union spoolss_PrinterData);
8977 if (r->out.data == NULL) {
8978 return NT_STATUS_NO_MEMORY;
8981 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8982 if (r->out.needed == NULL) {
8983 return NT_STATUS_NO_MEMORY;
8986 r->out.result = _spoolss_GetPrinterData(cli->pipes_struct, r);
8987 return NT_STATUS_OK;
8990 case NDR_SPOOLSS_SETPRINTERDATA: {
8991 struct spoolss_SetPrinterData *r = (struct spoolss_SetPrinterData *)_r;
8992 r->out.result = _spoolss_SetPrinterData(cli->pipes_struct, r);
8993 return NT_STATUS_OK;
8996 case NDR_SPOOLSS_WAITFORPRINTERCHANGE: {
8997 struct spoolss_WaitForPrinterChange *r = (struct spoolss_WaitForPrinterChange *)_r;
8998 r->out.result = _spoolss_WaitForPrinterChange(cli->pipes_struct, r);
8999 return NT_STATUS_OK;
9002 case NDR_SPOOLSS_CLOSEPRINTER: {
9003 struct spoolss_ClosePrinter *r = (struct spoolss_ClosePrinter *)_r;
9004 ZERO_STRUCT(r->out);
9005 r->out.handle = r->in.handle;
9006 r->out.result = _spoolss_ClosePrinter(cli->pipes_struct, r);
9007 return NT_STATUS_OK;
9010 case NDR_SPOOLSS_ADDFORM: {
9011 struct spoolss_AddForm *r = (struct spoolss_AddForm *)_r;
9012 r->out.result = _spoolss_AddForm(cli->pipes_struct, r);
9013 return NT_STATUS_OK;
9016 case NDR_SPOOLSS_DELETEFORM: {
9017 struct spoolss_DeleteForm *r = (struct spoolss_DeleteForm *)_r;
9018 r->out.result = _spoolss_DeleteForm(cli->pipes_struct, r);
9019 return NT_STATUS_OK;
9022 case NDR_SPOOLSS_GETFORM: {
9023 struct spoolss_GetForm *r = (struct spoolss_GetForm *)_r;
9024 ZERO_STRUCT(r->out);
9025 r->out.info = talloc_zero(mem_ctx, union spoolss_FormInfo);
9026 if (r->out.info == NULL) {
9027 return NT_STATUS_NO_MEMORY;
9030 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9031 if (r->out.needed == NULL) {
9032 return NT_STATUS_NO_MEMORY;
9035 r->out.result = _spoolss_GetForm(cli->pipes_struct, r);
9036 return NT_STATUS_OK;
9039 case NDR_SPOOLSS_SETFORM: {
9040 struct spoolss_SetForm *r = (struct spoolss_SetForm *)_r;
9041 r->out.result = _spoolss_SetForm(cli->pipes_struct, r);
9042 return NT_STATUS_OK;
9045 case NDR_SPOOLSS_ENUMFORMS: {
9046 struct spoolss_EnumForms *r = (struct spoolss_EnumForms *)_r;
9047 ZERO_STRUCT(r->out);
9048 r->out.count = talloc_zero(mem_ctx, uint32_t);
9049 if (r->out.count == NULL) {
9050 return NT_STATUS_NO_MEMORY;
9053 r->out.info = talloc_zero(mem_ctx, union spoolss_FormInfo *);
9054 if (r->out.info == NULL) {
9055 return NT_STATUS_NO_MEMORY;
9058 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9059 if (r->out.needed == NULL) {
9060 return NT_STATUS_NO_MEMORY;
9063 r->out.result = _spoolss_EnumForms(cli->pipes_struct, r);
9064 return NT_STATUS_OK;
9067 case NDR_SPOOLSS_ENUMPORTS: {
9068 struct spoolss_EnumPorts *r = (struct spoolss_EnumPorts *)_r;
9069 ZERO_STRUCT(r->out);
9070 r->out.count = talloc_zero(mem_ctx, uint32_t);
9071 if (r->out.count == NULL) {
9072 return NT_STATUS_NO_MEMORY;
9075 r->out.info = talloc_zero(mem_ctx, union spoolss_PortInfo *);
9076 if (r->out.info == NULL) {
9077 return NT_STATUS_NO_MEMORY;
9080 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9081 if (r->out.needed == NULL) {
9082 return NT_STATUS_NO_MEMORY;
9085 r->out.result = _spoolss_EnumPorts(cli->pipes_struct, r);
9086 return NT_STATUS_OK;
9089 case NDR_SPOOLSS_ENUMMONITORS: {
9090 struct spoolss_EnumMonitors *r = (struct spoolss_EnumMonitors *)_r;
9091 ZERO_STRUCT(r->out);
9092 r->out.count = talloc_zero(mem_ctx, uint32_t);
9093 if (r->out.count == NULL) {
9094 return NT_STATUS_NO_MEMORY;
9097 r->out.info = talloc_zero(mem_ctx, union spoolss_MonitorInfo *);
9098 if (r->out.info == NULL) {
9099 return NT_STATUS_NO_MEMORY;
9102 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9103 if (r->out.needed == NULL) {
9104 return NT_STATUS_NO_MEMORY;
9107 r->out.result = _spoolss_EnumMonitors(cli->pipes_struct, r);
9108 return NT_STATUS_OK;
9111 case NDR_SPOOLSS_ADDPORT: {
9112 struct spoolss_AddPort *r = (struct spoolss_AddPort *)_r;
9113 r->out.result = _spoolss_AddPort(cli->pipes_struct, r);
9114 return NT_STATUS_OK;
9117 case NDR_SPOOLSS_CONFIGUREPORT: {
9118 struct spoolss_ConfigurePort *r = (struct spoolss_ConfigurePort *)_r;
9119 r->out.result = _spoolss_ConfigurePort(cli->pipes_struct, r);
9120 return NT_STATUS_OK;
9123 case NDR_SPOOLSS_DELETEPORT: {
9124 struct spoolss_DeletePort *r = (struct spoolss_DeletePort *)_r;
9125 r->out.result = _spoolss_DeletePort(cli->pipes_struct, r);
9126 return NT_STATUS_OK;
9129 case NDR_SPOOLSS_CREATEPRINTERIC: {
9130 struct spoolss_CreatePrinterIC *r = (struct spoolss_CreatePrinterIC *)_r;
9131 ZERO_STRUCT(r->out);
9132 r->out.gdi_handle = talloc_zero(mem_ctx, struct policy_handle);
9133 if (r->out.gdi_handle == NULL) {
9134 return NT_STATUS_NO_MEMORY;
9137 r->out.result = _spoolss_CreatePrinterIC(cli->pipes_struct, r);
9138 return NT_STATUS_OK;
9141 case NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC: {
9142 struct spoolss_PlayGDIScriptOnPrinterIC *r = (struct spoolss_PlayGDIScriptOnPrinterIC *)_r;
9143 r->out.result = _spoolss_PlayGDIScriptOnPrinterIC(cli->pipes_struct, r);
9144 return NT_STATUS_OK;
9147 case NDR_SPOOLSS_DELETEPRINTERIC: {
9148 struct spoolss_DeletePrinterIC *r = (struct spoolss_DeletePrinterIC *)_r;
9149 ZERO_STRUCT(r->out);
9150 r->out.gdi_handle = r->in.gdi_handle;
9151 r->out.result = _spoolss_DeletePrinterIC(cli->pipes_struct, r);
9152 return NT_STATUS_OK;
9155 case NDR_SPOOLSS_ADDPRINTERCONNECTION: {
9156 struct spoolss_AddPrinterConnection *r = (struct spoolss_AddPrinterConnection *)_r;
9157 r->out.result = _spoolss_AddPrinterConnection(cli->pipes_struct, r);
9158 return NT_STATUS_OK;
9161 case NDR_SPOOLSS_DELETEPRINTERCONNECTION: {
9162 struct spoolss_DeletePrinterConnection *r = (struct spoolss_DeletePrinterConnection *)_r;
9163 r->out.result = _spoolss_DeletePrinterConnection(cli->pipes_struct, r);
9164 return NT_STATUS_OK;
9167 case NDR_SPOOLSS_PRINTERMESSAGEBOX: {
9168 struct spoolss_PrinterMessageBox *r = (struct spoolss_PrinterMessageBox *)_r;
9169 r->out.result = _spoolss_PrinterMessageBox(cli->pipes_struct, r);
9170 return NT_STATUS_OK;
9173 case NDR_SPOOLSS_ADDMONITOR: {
9174 struct spoolss_AddMonitor *r = (struct spoolss_AddMonitor *)_r;
9175 r->out.result = _spoolss_AddMonitor(cli->pipes_struct, r);
9176 return NT_STATUS_OK;
9179 case NDR_SPOOLSS_DELETEMONITOR: {
9180 struct spoolss_DeleteMonitor *r = (struct spoolss_DeleteMonitor *)_r;
9181 r->out.result = _spoolss_DeleteMonitor(cli->pipes_struct, r);
9182 return NT_STATUS_OK;
9185 case NDR_SPOOLSS_DELETEPRINTPROCESSOR: {
9186 struct spoolss_DeletePrintProcessor *r = (struct spoolss_DeletePrintProcessor *)_r;
9187 r->out.result = _spoolss_DeletePrintProcessor(cli->pipes_struct, r);
9188 return NT_STATUS_OK;
9191 case NDR_SPOOLSS_ADDPRINTPROVIDOR: {
9192 struct spoolss_AddPrintProvidor *r = (struct spoolss_AddPrintProvidor *)_r;
9193 r->out.result = _spoolss_AddPrintProvidor(cli->pipes_struct, r);
9194 return NT_STATUS_OK;
9197 case NDR_SPOOLSS_DELETEPRINTPROVIDOR: {
9198 struct spoolss_DeletePrintProvidor *r = (struct spoolss_DeletePrintProvidor *)_r;
9199 r->out.result = _spoolss_DeletePrintProvidor(cli->pipes_struct, r);
9200 return NT_STATUS_OK;
9203 case NDR_SPOOLSS_ENUMPRINTPROCDATATYPES: {
9204 struct spoolss_EnumPrintProcDataTypes *r = (struct spoolss_EnumPrintProcDataTypes *)_r;
9205 ZERO_STRUCT(r->out);
9206 r->out.count = talloc_zero(mem_ctx, uint32_t);
9207 if (r->out.count == NULL) {
9208 return NT_STATUS_NO_MEMORY;
9211 r->out.info = talloc_zero(mem_ctx, union spoolss_PrintProcDataTypesInfo *);
9212 if (r->out.info == NULL) {
9213 return NT_STATUS_NO_MEMORY;
9216 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9217 if (r->out.needed == NULL) {
9218 return NT_STATUS_NO_MEMORY;
9221 r->out.result = _spoolss_EnumPrintProcDataTypes(cli->pipes_struct, r);
9222 return NT_STATUS_OK;
9225 case NDR_SPOOLSS_RESETPRINTER: {
9226 struct spoolss_ResetPrinter *r = (struct spoolss_ResetPrinter *)_r;
9227 r->out.result = _spoolss_ResetPrinter(cli->pipes_struct, r);
9228 return NT_STATUS_OK;
9231 case NDR_SPOOLSS_GETPRINTERDRIVER2: {
9232 struct spoolss_GetPrinterDriver2 *r = (struct spoolss_GetPrinterDriver2 *)_r;
9233 ZERO_STRUCT(r->out);
9234 r->out.info = talloc_zero(mem_ctx, union spoolss_DriverInfo);
9235 if (r->out.info == NULL) {
9236 return NT_STATUS_NO_MEMORY;
9239 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9240 if (r->out.needed == NULL) {
9241 return NT_STATUS_NO_MEMORY;
9244 r->out.server_major_version = talloc_zero(mem_ctx, uint32_t);
9245 if (r->out.server_major_version == NULL) {
9246 return NT_STATUS_NO_MEMORY;
9249 r->out.server_minor_version = talloc_zero(mem_ctx, uint32_t);
9250 if (r->out.server_minor_version == NULL) {
9251 return NT_STATUS_NO_MEMORY;
9254 r->out.result = _spoolss_GetPrinterDriver2(cli->pipes_struct, r);
9255 return NT_STATUS_OK;
9258 case NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION: {
9259 struct spoolss_FindFirstPrinterChangeNotification *r = (struct spoolss_FindFirstPrinterChangeNotification *)_r;
9260 r->out.result = _spoolss_FindFirstPrinterChangeNotification(cli->pipes_struct, r);
9261 return NT_STATUS_OK;
9264 case NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION: {
9265 struct spoolss_FindNextPrinterChangeNotification *r = (struct spoolss_FindNextPrinterChangeNotification *)_r;
9266 r->out.result = _spoolss_FindNextPrinterChangeNotification(cli->pipes_struct, r);
9267 return NT_STATUS_OK;
9270 case NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY: {
9271 struct spoolss_FindClosePrinterNotify *r = (struct spoolss_FindClosePrinterNotify *)_r;
9272 r->out.result = _spoolss_FindClosePrinterNotify(cli->pipes_struct, r);
9273 return NT_STATUS_OK;
9276 case NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD: {
9277 struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r = (struct spoolss_RouterFindFirstPrinterChangeNotificationOld *)_r;
9278 r->out.result = _spoolss_RouterFindFirstPrinterChangeNotificationOld(cli->pipes_struct, r);
9279 return NT_STATUS_OK;
9282 case NDR_SPOOLSS_REPLYOPENPRINTER: {
9283 struct spoolss_ReplyOpenPrinter *r = (struct spoolss_ReplyOpenPrinter *)_r;
9284 ZERO_STRUCT(r->out);
9285 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
9286 if (r->out.handle == NULL) {
9287 return NT_STATUS_NO_MEMORY;
9290 r->out.result = _spoolss_ReplyOpenPrinter(cli->pipes_struct, r);
9291 return NT_STATUS_OK;
9294 case NDR_SPOOLSS_ROUTERREPLYPRINTER: {
9295 struct spoolss_RouterReplyPrinter *r = (struct spoolss_RouterReplyPrinter *)_r;
9296 r->out.result = _spoolss_RouterReplyPrinter(cli->pipes_struct, r);
9297 return NT_STATUS_OK;
9300 case NDR_SPOOLSS_REPLYCLOSEPRINTER: {
9301 struct spoolss_ReplyClosePrinter *r = (struct spoolss_ReplyClosePrinter *)_r;
9302 ZERO_STRUCT(r->out);
9303 r->out.handle = r->in.handle;
9304 r->out.result = _spoolss_ReplyClosePrinter(cli->pipes_struct, r);
9305 return NT_STATUS_OK;
9308 case NDR_SPOOLSS_ADDPORTEX: {
9309 struct spoolss_AddPortEx *r = (struct spoolss_AddPortEx *)_r;
9310 r->out.result = _spoolss_AddPortEx(cli->pipes_struct, r);
9311 return NT_STATUS_OK;
9314 case NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION: {
9315 struct spoolss_RouterFindFirstPrinterChangeNotification *r = (struct spoolss_RouterFindFirstPrinterChangeNotification *)_r;
9316 r->out.result = _spoolss_RouterFindFirstPrinterChangeNotification(cli->pipes_struct, r);
9317 return NT_STATUS_OK;
9320 case NDR_SPOOLSS_SPOOLERINIT: {
9321 struct spoolss_SpoolerInit *r = (struct spoolss_SpoolerInit *)_r;
9322 r->out.result = _spoolss_SpoolerInit(cli->pipes_struct, r);
9323 return NT_STATUS_OK;
9326 case NDR_SPOOLSS_RESETPRINTEREX: {
9327 struct spoolss_ResetPrinterEx *r = (struct spoolss_ResetPrinterEx *)_r;
9328 r->out.result = _spoolss_ResetPrinterEx(cli->pipes_struct, r);
9329 return NT_STATUS_OK;
9332 case NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX: {
9333 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r = (struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *)_r;
9334 r->out.result = _spoolss_RemoteFindFirstPrinterChangeNotifyEx(cli->pipes_struct, r);
9335 return NT_STATUS_OK;
9338 case NDR_SPOOLSS_ROUTERREPLYPRINTEREX: {
9339 struct spoolss_RouterReplyPrinterEx *r = (struct spoolss_RouterReplyPrinterEx *)_r;
9340 ZERO_STRUCT(r->out);
9341 r->out.reply_result = talloc_zero(mem_ctx, uint32_t);
9342 if (r->out.reply_result == NULL) {
9343 return NT_STATUS_NO_MEMORY;
9346 r->out.result = _spoolss_RouterReplyPrinterEx(cli->pipes_struct, r);
9347 return NT_STATUS_OK;
9350 case NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY: {
9351 struct spoolss_RouterRefreshPrinterChangeNotify *r = (struct spoolss_RouterRefreshPrinterChangeNotify *)_r;
9352 ZERO_STRUCT(r->out);
9353 r->out.info = talloc_zero(mem_ctx, struct spoolss_NotifyInfo *);
9354 if (r->out.info == NULL) {
9355 return NT_STATUS_NO_MEMORY;
9358 r->out.result = _spoolss_RouterRefreshPrinterChangeNotify(cli->pipes_struct, r);
9359 return NT_STATUS_OK;
9362 case NDR_SPOOLSS_44: {
9363 struct spoolss_44 *r = (struct spoolss_44 *)_r;
9364 r->out.result = _spoolss_44(cli->pipes_struct, r);
9365 return NT_STATUS_OK;
9368 case NDR_SPOOLSS_OPENPRINTEREX: {
9369 struct spoolss_OpenPrinterEx *r = (struct spoolss_OpenPrinterEx *)_r;
9370 ZERO_STRUCT(r->out);
9371 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
9372 if (r->out.handle == NULL) {
9373 return NT_STATUS_NO_MEMORY;
9376 r->out.result = _spoolss_OpenPrinterEx(cli->pipes_struct, r);
9377 return NT_STATUS_OK;
9380 case NDR_SPOOLSS_ADDPRINTEREX: {
9381 struct spoolss_AddPrinterEx *r = (struct spoolss_AddPrinterEx *)_r;
9382 ZERO_STRUCT(r->out);
9383 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
9384 if (r->out.handle == NULL) {
9385 return NT_STATUS_NO_MEMORY;
9388 r->out.result = _spoolss_AddPrinterEx(cli->pipes_struct, r);
9389 return NT_STATUS_OK;
9392 case NDR_SPOOLSS_47: {
9393 struct spoolss_47 *r = (struct spoolss_47 *)_r;
9394 r->out.result = _spoolss_47(cli->pipes_struct, r);
9395 return NT_STATUS_OK;
9398 case NDR_SPOOLSS_ENUMPRINTERDATA: {
9399 struct spoolss_EnumPrinterData *r = (struct spoolss_EnumPrinterData *)_r;
9400 ZERO_STRUCT(r->out);
9401 r->out.value_name = talloc_zero_array(mem_ctx, const char, r->in.value_offered / 2);
9402 if (r->out.value_name == NULL) {
9403 return NT_STATUS_NO_MEMORY;
9406 r->out.value_needed = talloc_zero(mem_ctx, uint32_t);
9407 if (r->out.value_needed == NULL) {
9408 return NT_STATUS_NO_MEMORY;
9411 r->out.type = talloc_zero(mem_ctx, enum winreg_Type);
9412 if (r->out.type == NULL) {
9413 return NT_STATUS_NO_MEMORY;
9416 r->out.data = talloc_zero_array(mem_ctx, uint8_t, r->in.data_offered);
9417 if (r->out.data == NULL) {
9418 return NT_STATUS_NO_MEMORY;
9421 r->out.data_needed = talloc_zero(mem_ctx, uint32_t);
9422 if (r->out.data_needed == NULL) {
9423 return NT_STATUS_NO_MEMORY;
9426 r->out.result = _spoolss_EnumPrinterData(cli->pipes_struct, r);
9427 return NT_STATUS_OK;
9430 case NDR_SPOOLSS_DELETEPRINTERDATA: {
9431 struct spoolss_DeletePrinterData *r = (struct spoolss_DeletePrinterData *)_r;
9432 r->out.result = _spoolss_DeletePrinterData(cli->pipes_struct, r);
9433 return NT_STATUS_OK;
9436 case NDR_SPOOLSS_4A: {
9437 struct spoolss_4a *r = (struct spoolss_4a *)_r;
9438 r->out.result = _spoolss_4a(cli->pipes_struct, r);
9439 return NT_STATUS_OK;
9442 case NDR_SPOOLSS_4B: {
9443 struct spoolss_4b *r = (struct spoolss_4b *)_r;
9444 r->out.result = _spoolss_4b(cli->pipes_struct, r);
9445 return NT_STATUS_OK;
9448 case NDR_SPOOLSS_4C: {
9449 struct spoolss_4c *r = (struct spoolss_4c *)_r;
9450 r->out.result = _spoolss_4c(cli->pipes_struct, r);
9451 return NT_STATUS_OK;
9454 case NDR_SPOOLSS_SETPRINTERDATAEX: {
9455 struct spoolss_SetPrinterDataEx *r = (struct spoolss_SetPrinterDataEx *)_r;
9456 r->out.result = _spoolss_SetPrinterDataEx(cli->pipes_struct, r);
9457 return NT_STATUS_OK;
9460 case NDR_SPOOLSS_GETPRINTERDATAEX: {
9461 struct spoolss_GetPrinterDataEx *r = (struct spoolss_GetPrinterDataEx *)_r;
9462 ZERO_STRUCT(r->out);
9463 r->out.type = talloc_zero(mem_ctx, enum winreg_Type);
9464 if (r->out.type == NULL) {
9465 return NT_STATUS_NO_MEMORY;
9468 r->out.buffer = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
9469 if (r->out.buffer == NULL) {
9470 return NT_STATUS_NO_MEMORY;
9473 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9474 if (r->out.needed == NULL) {
9475 return NT_STATUS_NO_MEMORY;
9478 r->out.result = _spoolss_GetPrinterDataEx(cli->pipes_struct, r);
9479 return NT_STATUS_OK;
9482 case NDR_SPOOLSS_ENUMPRINTERDATAEX: {
9483 struct spoolss_EnumPrinterDataEx *r = (struct spoolss_EnumPrinterDataEx *)_r;
9484 ZERO_STRUCT(r->out);
9485 r->out.count = talloc_zero(mem_ctx, uint32_t);
9486 if (r->out.count == NULL) {
9487 return NT_STATUS_NO_MEMORY;
9490 r->out.info = talloc_zero(mem_ctx, struct spoolss_PrinterEnumValues *);
9491 if (r->out.info == NULL) {
9492 return NT_STATUS_NO_MEMORY;
9495 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9496 if (r->out.needed == NULL) {
9497 return NT_STATUS_NO_MEMORY;
9500 r->out.result = _spoolss_EnumPrinterDataEx(cli->pipes_struct, r);
9501 return NT_STATUS_OK;
9504 case NDR_SPOOLSS_ENUMPRINTERKEY: {
9505 struct spoolss_EnumPrinterKey *r = (struct spoolss_EnumPrinterKey *)_r;
9506 ZERO_STRUCT(r->out);
9507 r->out.key_buffer = talloc_zero(mem_ctx, const char **);
9508 if (r->out.key_buffer == NULL) {
9509 return NT_STATUS_NO_MEMORY;
9512 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9513 if (r->out.needed == NULL) {
9514 return NT_STATUS_NO_MEMORY;
9517 r->out.result = _spoolss_EnumPrinterKey(cli->pipes_struct, r);
9518 return NT_STATUS_OK;
9521 case NDR_SPOOLSS_DELETEPRINTERDATAEX: {
9522 struct spoolss_DeletePrinterDataEx *r = (struct spoolss_DeletePrinterDataEx *)_r;
9523 r->out.result = _spoolss_DeletePrinterDataEx(cli->pipes_struct, r);
9524 return NT_STATUS_OK;
9527 case NDR_SPOOLSS_DELETEPRINTERKEY: {
9528 struct spoolss_DeletePrinterKey *r = (struct spoolss_DeletePrinterKey *)_r;
9529 r->out.result = _spoolss_DeletePrinterKey(cli->pipes_struct, r);
9530 return NT_STATUS_OK;
9533 case NDR_SPOOLSS_53: {
9534 struct spoolss_53 *r = (struct spoolss_53 *)_r;
9535 r->out.result = _spoolss_53(cli->pipes_struct, r);
9536 return NT_STATUS_OK;
9539 case NDR_SPOOLSS_DELETEPRINTERDRIVEREX: {
9540 struct spoolss_DeletePrinterDriverEx *r = (struct spoolss_DeletePrinterDriverEx *)_r;
9541 r->out.result = _spoolss_DeletePrinterDriverEx(cli->pipes_struct, r);
9542 return NT_STATUS_OK;
9545 case NDR_SPOOLSS_55: {
9546 struct spoolss_55 *r = (struct spoolss_55 *)_r;
9547 r->out.result = _spoolss_55(cli->pipes_struct, r);
9548 return NT_STATUS_OK;
9551 case NDR_SPOOLSS_56: {
9552 struct spoolss_56 *r = (struct spoolss_56 *)_r;
9553 r->out.result = _spoolss_56(cli->pipes_struct, r);
9554 return NT_STATUS_OK;
9557 case NDR_SPOOLSS_57: {
9558 struct spoolss_57 *r = (struct spoolss_57 *)_r;
9559 r->out.result = _spoolss_57(cli->pipes_struct, r);
9560 return NT_STATUS_OK;
9563 case NDR_SPOOLSS_XCVDATA: {
9564 struct spoolss_XcvData *r = (struct spoolss_XcvData *)_r;
9565 ZERO_STRUCT(r->out);
9566 r->out.status_code = r->in.status_code;
9567 r->out.out_data = talloc_zero_array(mem_ctx, uint8_t, r->in.out_data_size);
9568 if (r->out.out_data == NULL) {
9569 return NT_STATUS_NO_MEMORY;
9572 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9573 if (r->out.needed == NULL) {
9574 return NT_STATUS_NO_MEMORY;
9577 r->out.result = _spoolss_XcvData(cli->pipes_struct, r);
9578 return NT_STATUS_OK;
9581 case NDR_SPOOLSS_ADDPRINTERDRIVEREX: {
9582 struct spoolss_AddPrinterDriverEx *r = (struct spoolss_AddPrinterDriverEx *)_r;
9583 r->out.result = _spoolss_AddPrinterDriverEx(cli->pipes_struct, r);
9584 return NT_STATUS_OK;
9587 case NDR_SPOOLSS_5A: {
9588 struct spoolss_5a *r = (struct spoolss_5a *)_r;
9589 r->out.result = _spoolss_5a(cli->pipes_struct, r);
9590 return NT_STATUS_OK;
9593 case NDR_SPOOLSS_5B: {
9594 struct spoolss_5b *r = (struct spoolss_5b *)_r;
9595 r->out.result = _spoolss_5b(cli->pipes_struct, r);
9596 return NT_STATUS_OK;
9599 case NDR_SPOOLSS_5C: {
9600 struct spoolss_5c *r = (struct spoolss_5c *)_r;
9601 r->out.result = _spoolss_5c(cli->pipes_struct, r);
9602 return NT_STATUS_OK;
9605 case NDR_SPOOLSS_5D: {
9606 struct spoolss_5d *r = (struct spoolss_5d *)_r;
9607 r->out.result = _spoolss_5d(cli->pipes_struct, r);
9608 return NT_STATUS_OK;
9611 case NDR_SPOOLSS_5E: {
9612 struct spoolss_5e *r = (struct spoolss_5e *)_r;
9613 r->out.result = _spoolss_5e(cli->pipes_struct, r);
9614 return NT_STATUS_OK;
9617 case NDR_SPOOLSS_5F: {
9618 struct spoolss_5f *r = (struct spoolss_5f *)_r;
9619 r->out.result = _spoolss_5f(cli->pipes_struct, r);
9620 return NT_STATUS_OK;
9623 case NDR_SPOOLSS_60: {
9624 struct spoolss_60 *r = (struct spoolss_60 *)_r;
9625 r->out.result = _spoolss_60(cli->pipes_struct, r);
9626 return NT_STATUS_OK;
9629 case NDR_SPOOLSS_61: {
9630 struct spoolss_61 *r = (struct spoolss_61 *)_r;
9631 r->out.result = _spoolss_61(cli->pipes_struct, r);
9632 return NT_STATUS_OK;
9635 case NDR_SPOOLSS_62: {
9636 struct spoolss_62 *r = (struct spoolss_62 *)_r;
9637 r->out.result = _spoolss_62(cli->pipes_struct, r);
9638 return NT_STATUS_OK;
9641 case NDR_SPOOLSS_63: {
9642 struct spoolss_63 *r = (struct spoolss_63 *)_r;
9643 r->out.result = _spoolss_63(cli->pipes_struct, r);
9644 return NT_STATUS_OK;
9647 case NDR_SPOOLSS_64: {
9648 struct spoolss_64 *r = (struct spoolss_64 *)_r;
9649 r->out.result = _spoolss_64(cli->pipes_struct, r);
9650 return NT_STATUS_OK;
9653 case NDR_SPOOLSS_65: {
9654 struct spoolss_65 *r = (struct spoolss_65 *)_r;
9655 r->out.result = _spoolss_65(cli->pipes_struct, r);
9656 return NT_STATUS_OK;
9659 case NDR_SPOOLSS_GETCOREPRINTERDRIVERS: {
9660 struct spoolss_GetCorePrinterDrivers *r = (struct spoolss_GetCorePrinterDrivers *)_r;
9661 ZERO_STRUCT(r->out);
9662 r->out.core_printer_drivers = talloc_zero_array(mem_ctx, struct spoolss_CorePrinterDriver, r->in.core_printer_driver_count);
9663 if (r->out.core_printer_drivers == NULL) {
9664 return NT_STATUS_NO_MEMORY;
9667 r->out.result = _spoolss_GetCorePrinterDrivers(cli->pipes_struct, r);
9668 return NT_STATUS_OK;
9671 case NDR_SPOOLSS_67: {
9672 struct spoolss_67 *r = (struct spoolss_67 *)_r;
9673 r->out.result = _spoolss_67(cli->pipes_struct, r);
9674 return NT_STATUS_OK;
9677 case NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH: {
9678 struct spoolss_GetPrinterDriverPackagePath *r = (struct spoolss_GetPrinterDriverPackagePath *)_r;
9679 ZERO_STRUCT(r->out);
9680 r->out.driver_package_cab = r->in.driver_package_cab;
9681 r->out.required = talloc_zero(mem_ctx, uint32_t);
9682 if (r->out.required == NULL) {
9683 return NT_STATUS_NO_MEMORY;
9686 r->out.result = _spoolss_GetPrinterDriverPackagePath(cli->pipes_struct, r);
9687 return NT_STATUS_OK;
9690 case NDR_SPOOLSS_69: {
9691 struct spoolss_69 *r = (struct spoolss_69 *)_r;
9692 r->out.result = _spoolss_69(cli->pipes_struct, r);
9693 return NT_STATUS_OK;
9696 case NDR_SPOOLSS_6A: {
9697 struct spoolss_6a *r = (struct spoolss_6a *)_r;
9698 r->out.result = _spoolss_6a(cli->pipes_struct, r);
9699 return NT_STATUS_OK;
9702 case NDR_SPOOLSS_6B: {
9703 struct spoolss_6b *r = (struct spoolss_6b *)_r;
9704 r->out.result = _spoolss_6b(cli->pipes_struct, r);
9705 return NT_STATUS_OK;
9708 case NDR_SPOOLSS_6C: {
9709 struct spoolss_6c *r = (struct spoolss_6c *)_r;
9710 r->out.result = _spoolss_6c(cli->pipes_struct, r);
9711 return NT_STATUS_OK;
9714 case NDR_SPOOLSS_6D: {
9715 struct spoolss_6d *r = (struct spoolss_6d *)_r;
9716 r->out.result = _spoolss_6d(cli->pipes_struct, r);
9717 return NT_STATUS_OK;
9721 return NT_STATUS_NOT_IMPLEMENTED;
9725 NTSTATUS rpc_spoolss_init(void)
9727 return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "spoolss", "spoolss", &ndr_table_spoolss, api_spoolss_cmds, sizeof(api_spoolss_cmds) / sizeof(struct api_struct));