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_array(r, uint8_t, r->in.offered);
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.data = talloc_zero_array(r, uint8_t, r->in.offered);
6151 if (r->out.data == 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._ndr_size = talloc_zero(r, uint32_t);
6329 if (r->out._ndr_size == NULL) {
6334 r->out.key_buffer = talloc_zero(r, union spoolss_KeyNames);
6335 if (r->out.key_buffer == NULL) {
6340 r->out.needed = talloc_zero(r, uint32_t);
6341 if (r->out.needed == NULL) {
6346 r->out.result = _spoolss_EnumPrinterKey(p, r);
6348 if (p->rng_fault_state) {
6350 /* Return true here, srv_pipe_hnd.c will take care */
6354 if (DEBUGLEVEL >= 10) {
6355 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterKey, r);
6358 push = ndr_push_init_ctx(r, NULL);
6364 ndr_err = call->ndr_push(push, NDR_OUT, r);
6365 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6370 blob = ndr_push_blob(push);
6371 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6381 static bool api_spoolss_DeletePrinterDataEx(pipes_struct *p)
6383 const struct ndr_interface_call *call;
6384 struct ndr_pull *pull;
6385 struct ndr_push *push;
6386 enum ndr_err_code ndr_err;
6388 struct spoolss_DeletePrinterDataEx *r;
6390 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERDATAEX];
6392 r = talloc(talloc_tos(), struct spoolss_DeletePrinterDataEx);
6397 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6402 pull = ndr_pull_init_blob(&blob, r, NULL);
6408 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6409 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6410 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6415 if (DEBUGLEVEL >= 10) {
6416 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDataEx, r);
6419 r->out.result = _spoolss_DeletePrinterDataEx(p, r);
6421 if (p->rng_fault_state) {
6423 /* Return true here, srv_pipe_hnd.c will take care */
6427 if (DEBUGLEVEL >= 10) {
6428 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDataEx, r);
6431 push = ndr_push_init_ctx(r, NULL);
6437 ndr_err = call->ndr_push(push, NDR_OUT, r);
6438 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6443 blob = ndr_push_blob(push);
6444 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6454 static bool api_spoolss_DeletePrinterKey(pipes_struct *p)
6456 const struct ndr_interface_call *call;
6457 struct ndr_pull *pull;
6458 struct ndr_push *push;
6459 enum ndr_err_code ndr_err;
6461 struct spoolss_DeletePrinterKey *r;
6463 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERKEY];
6465 r = talloc(talloc_tos(), struct spoolss_DeletePrinterKey);
6470 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6475 pull = ndr_pull_init_blob(&blob, r, NULL);
6481 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6482 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6483 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6488 if (DEBUGLEVEL >= 10) {
6489 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterKey, r);
6492 r->out.result = _spoolss_DeletePrinterKey(p, r);
6494 if (p->rng_fault_state) {
6496 /* Return true here, srv_pipe_hnd.c will take care */
6500 if (DEBUGLEVEL >= 10) {
6501 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterKey, r);
6504 push = ndr_push_init_ctx(r, NULL);
6510 ndr_err = call->ndr_push(push, NDR_OUT, r);
6511 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6516 blob = ndr_push_blob(push);
6517 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6527 static bool api_spoolss_53(pipes_struct *p)
6529 const struct ndr_interface_call *call;
6530 struct ndr_pull *pull;
6531 struct ndr_push *push;
6532 enum ndr_err_code ndr_err;
6534 struct spoolss_53 *r;
6536 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_53];
6538 r = talloc(talloc_tos(), struct spoolss_53);
6543 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6548 pull = ndr_pull_init_blob(&blob, r, NULL);
6554 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6555 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6556 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6561 if (DEBUGLEVEL >= 10) {
6562 NDR_PRINT_IN_DEBUG(spoolss_53, r);
6565 r->out.result = _spoolss_53(p, r);
6567 if (p->rng_fault_state) {
6569 /* Return true here, srv_pipe_hnd.c will take care */
6573 if (DEBUGLEVEL >= 10) {
6574 NDR_PRINT_OUT_DEBUG(spoolss_53, r);
6577 push = ndr_push_init_ctx(r, NULL);
6583 ndr_err = call->ndr_push(push, NDR_OUT, r);
6584 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6589 blob = ndr_push_blob(push);
6590 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6600 static bool api_spoolss_DeletePrinterDriverEx(pipes_struct *p)
6602 const struct ndr_interface_call *call;
6603 struct ndr_pull *pull;
6604 struct ndr_push *push;
6605 enum ndr_err_code ndr_err;
6607 struct spoolss_DeletePrinterDriverEx *r;
6609 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERDRIVEREX];
6611 r = talloc(talloc_tos(), struct spoolss_DeletePrinterDriverEx);
6616 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6621 pull = ndr_pull_init_blob(&blob, r, NULL);
6627 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6628 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6629 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6634 if (DEBUGLEVEL >= 10) {
6635 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDriverEx, r);
6638 r->out.result = _spoolss_DeletePrinterDriverEx(p, r);
6640 if (p->rng_fault_state) {
6642 /* Return true here, srv_pipe_hnd.c will take care */
6646 if (DEBUGLEVEL >= 10) {
6647 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDriverEx, r);
6650 push = ndr_push_init_ctx(r, NULL);
6656 ndr_err = call->ndr_push(push, NDR_OUT, r);
6657 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6662 blob = ndr_push_blob(push);
6663 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6673 static bool api_spoolss_55(pipes_struct *p)
6675 const struct ndr_interface_call *call;
6676 struct ndr_pull *pull;
6677 struct ndr_push *push;
6678 enum ndr_err_code ndr_err;
6680 struct spoolss_55 *r;
6682 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_55];
6684 r = talloc(talloc_tos(), struct spoolss_55);
6689 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6694 pull = ndr_pull_init_blob(&blob, r, NULL);
6700 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6701 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6702 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6707 if (DEBUGLEVEL >= 10) {
6708 NDR_PRINT_IN_DEBUG(spoolss_55, r);
6711 r->out.result = _spoolss_55(p, r);
6713 if (p->rng_fault_state) {
6715 /* Return true here, srv_pipe_hnd.c will take care */
6719 if (DEBUGLEVEL >= 10) {
6720 NDR_PRINT_OUT_DEBUG(spoolss_55, r);
6723 push = ndr_push_init_ctx(r, NULL);
6729 ndr_err = call->ndr_push(push, NDR_OUT, r);
6730 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6735 blob = ndr_push_blob(push);
6736 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6746 static bool api_spoolss_56(pipes_struct *p)
6748 const struct ndr_interface_call *call;
6749 struct ndr_pull *pull;
6750 struct ndr_push *push;
6751 enum ndr_err_code ndr_err;
6753 struct spoolss_56 *r;
6755 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_56];
6757 r = talloc(talloc_tos(), struct spoolss_56);
6762 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6767 pull = ndr_pull_init_blob(&blob, r, NULL);
6773 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6774 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6775 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6780 if (DEBUGLEVEL >= 10) {
6781 NDR_PRINT_IN_DEBUG(spoolss_56, r);
6784 r->out.result = _spoolss_56(p, r);
6786 if (p->rng_fault_state) {
6788 /* Return true here, srv_pipe_hnd.c will take care */
6792 if (DEBUGLEVEL >= 10) {
6793 NDR_PRINT_OUT_DEBUG(spoolss_56, r);
6796 push = ndr_push_init_ctx(r, NULL);
6802 ndr_err = call->ndr_push(push, NDR_OUT, r);
6803 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6808 blob = ndr_push_blob(push);
6809 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6819 static bool api_spoolss_57(pipes_struct *p)
6821 const struct ndr_interface_call *call;
6822 struct ndr_pull *pull;
6823 struct ndr_push *push;
6824 enum ndr_err_code ndr_err;
6826 struct spoolss_57 *r;
6828 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_57];
6830 r = talloc(talloc_tos(), struct spoolss_57);
6835 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6840 pull = ndr_pull_init_blob(&blob, r, NULL);
6846 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6847 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6848 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6853 if (DEBUGLEVEL >= 10) {
6854 NDR_PRINT_IN_DEBUG(spoolss_57, r);
6857 r->out.result = _spoolss_57(p, r);
6859 if (p->rng_fault_state) {
6861 /* Return true here, srv_pipe_hnd.c will take care */
6865 if (DEBUGLEVEL >= 10) {
6866 NDR_PRINT_OUT_DEBUG(spoolss_57, r);
6869 push = ndr_push_init_ctx(r, NULL);
6875 ndr_err = call->ndr_push(push, NDR_OUT, r);
6876 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6881 blob = ndr_push_blob(push);
6882 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6892 static bool api_spoolss_XcvData(pipes_struct *p)
6894 const struct ndr_interface_call *call;
6895 struct ndr_pull *pull;
6896 struct ndr_push *push;
6897 enum ndr_err_code ndr_err;
6899 struct spoolss_XcvData *r;
6901 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_XCVDATA];
6903 r = talloc(talloc_tos(), struct spoolss_XcvData);
6908 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6913 pull = ndr_pull_init_blob(&blob, r, NULL);
6919 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6920 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6921 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6926 if (DEBUGLEVEL >= 10) {
6927 NDR_PRINT_IN_DEBUG(spoolss_XcvData, r);
6930 ZERO_STRUCT(r->out);
6931 r->out.status_code = r->in.status_code;
6932 r->out.out_data = talloc_zero_array(r, uint8_t, r->in.out_data_size);
6933 if (r->out.out_data == NULL) {
6938 r->out.needed = talloc_zero(r, uint32_t);
6939 if (r->out.needed == NULL) {
6944 r->out.result = _spoolss_XcvData(p, r);
6946 if (p->rng_fault_state) {
6948 /* Return true here, srv_pipe_hnd.c will take care */
6952 if (DEBUGLEVEL >= 10) {
6953 NDR_PRINT_OUT_DEBUG(spoolss_XcvData, r);
6956 push = ndr_push_init_ctx(r, NULL);
6962 ndr_err = call->ndr_push(push, NDR_OUT, r);
6963 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6968 blob = ndr_push_blob(push);
6969 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6979 static bool api_spoolss_AddPrinterDriverEx(pipes_struct *p)
6981 const struct ndr_interface_call *call;
6982 struct ndr_pull *pull;
6983 struct ndr_push *push;
6984 enum ndr_err_code ndr_err;
6986 struct spoolss_AddPrinterDriverEx *r;
6988 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTERDRIVEREX];
6990 r = talloc(talloc_tos(), struct spoolss_AddPrinterDriverEx);
6995 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7000 pull = ndr_pull_init_blob(&blob, r, NULL);
7006 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7007 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7008 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7013 if (DEBUGLEVEL >= 10) {
7014 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterDriverEx, r);
7017 r->out.result = _spoolss_AddPrinterDriverEx(p, r);
7019 if (p->rng_fault_state) {
7021 /* Return true here, srv_pipe_hnd.c will take care */
7025 if (DEBUGLEVEL >= 10) {
7026 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterDriverEx, r);
7029 push = ndr_push_init_ctx(r, NULL);
7035 ndr_err = call->ndr_push(push, NDR_OUT, r);
7036 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7041 blob = ndr_push_blob(push);
7042 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7052 static bool api_spoolss_5a(pipes_struct *p)
7054 const struct ndr_interface_call *call;
7055 struct ndr_pull *pull;
7056 struct ndr_push *push;
7057 enum ndr_err_code ndr_err;
7059 struct spoolss_5a *r;
7061 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5A];
7063 r = talloc(talloc_tos(), struct spoolss_5a);
7068 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7073 pull = ndr_pull_init_blob(&blob, r, NULL);
7079 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7080 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7081 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7086 if (DEBUGLEVEL >= 10) {
7087 NDR_PRINT_IN_DEBUG(spoolss_5a, r);
7090 r->out.result = _spoolss_5a(p, r);
7092 if (p->rng_fault_state) {
7094 /* Return true here, srv_pipe_hnd.c will take care */
7098 if (DEBUGLEVEL >= 10) {
7099 NDR_PRINT_OUT_DEBUG(spoolss_5a, r);
7102 push = ndr_push_init_ctx(r, NULL);
7108 ndr_err = call->ndr_push(push, NDR_OUT, r);
7109 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7114 blob = ndr_push_blob(push);
7115 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7125 static bool api_spoolss_5b(pipes_struct *p)
7127 const struct ndr_interface_call *call;
7128 struct ndr_pull *pull;
7129 struct ndr_push *push;
7130 enum ndr_err_code ndr_err;
7132 struct spoolss_5b *r;
7134 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5B];
7136 r = talloc(talloc_tos(), struct spoolss_5b);
7141 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7146 pull = ndr_pull_init_blob(&blob, r, NULL);
7152 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7153 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7154 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7159 if (DEBUGLEVEL >= 10) {
7160 NDR_PRINT_IN_DEBUG(spoolss_5b, r);
7163 r->out.result = _spoolss_5b(p, r);
7165 if (p->rng_fault_state) {
7167 /* Return true here, srv_pipe_hnd.c will take care */
7171 if (DEBUGLEVEL >= 10) {
7172 NDR_PRINT_OUT_DEBUG(spoolss_5b, r);
7175 push = ndr_push_init_ctx(r, NULL);
7181 ndr_err = call->ndr_push(push, NDR_OUT, r);
7182 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7187 blob = ndr_push_blob(push);
7188 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7198 static bool api_spoolss_5c(pipes_struct *p)
7200 const struct ndr_interface_call *call;
7201 struct ndr_pull *pull;
7202 struct ndr_push *push;
7203 enum ndr_err_code ndr_err;
7205 struct spoolss_5c *r;
7207 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5C];
7209 r = talloc(talloc_tos(), struct spoolss_5c);
7214 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7219 pull = ndr_pull_init_blob(&blob, r, NULL);
7225 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7226 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7227 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7232 if (DEBUGLEVEL >= 10) {
7233 NDR_PRINT_IN_DEBUG(spoolss_5c, r);
7236 r->out.result = _spoolss_5c(p, r);
7238 if (p->rng_fault_state) {
7240 /* Return true here, srv_pipe_hnd.c will take care */
7244 if (DEBUGLEVEL >= 10) {
7245 NDR_PRINT_OUT_DEBUG(spoolss_5c, r);
7248 push = ndr_push_init_ctx(r, NULL);
7254 ndr_err = call->ndr_push(push, NDR_OUT, r);
7255 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7260 blob = ndr_push_blob(push);
7261 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7271 static bool api_spoolss_5d(pipes_struct *p)
7273 const struct ndr_interface_call *call;
7274 struct ndr_pull *pull;
7275 struct ndr_push *push;
7276 enum ndr_err_code ndr_err;
7278 struct spoolss_5d *r;
7280 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5D];
7282 r = talloc(talloc_tos(), struct spoolss_5d);
7287 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7292 pull = ndr_pull_init_blob(&blob, r, NULL);
7298 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7299 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7300 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7305 if (DEBUGLEVEL >= 10) {
7306 NDR_PRINT_IN_DEBUG(spoolss_5d, r);
7309 r->out.result = _spoolss_5d(p, r);
7311 if (p->rng_fault_state) {
7313 /* Return true here, srv_pipe_hnd.c will take care */
7317 if (DEBUGLEVEL >= 10) {
7318 NDR_PRINT_OUT_DEBUG(spoolss_5d, r);
7321 push = ndr_push_init_ctx(r, NULL);
7327 ndr_err = call->ndr_push(push, NDR_OUT, r);
7328 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7333 blob = ndr_push_blob(push);
7334 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7344 static bool api_spoolss_5e(pipes_struct *p)
7346 const struct ndr_interface_call *call;
7347 struct ndr_pull *pull;
7348 struct ndr_push *push;
7349 enum ndr_err_code ndr_err;
7351 struct spoolss_5e *r;
7353 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5E];
7355 r = talloc(talloc_tos(), struct spoolss_5e);
7360 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7365 pull = ndr_pull_init_blob(&blob, r, NULL);
7371 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7372 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7373 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7378 if (DEBUGLEVEL >= 10) {
7379 NDR_PRINT_IN_DEBUG(spoolss_5e, r);
7382 r->out.result = _spoolss_5e(p, r);
7384 if (p->rng_fault_state) {
7386 /* Return true here, srv_pipe_hnd.c will take care */
7390 if (DEBUGLEVEL >= 10) {
7391 NDR_PRINT_OUT_DEBUG(spoolss_5e, r);
7394 push = ndr_push_init_ctx(r, NULL);
7400 ndr_err = call->ndr_push(push, NDR_OUT, r);
7401 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7406 blob = ndr_push_blob(push);
7407 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7417 static bool api_spoolss_5f(pipes_struct *p)
7419 const struct ndr_interface_call *call;
7420 struct ndr_pull *pull;
7421 struct ndr_push *push;
7422 enum ndr_err_code ndr_err;
7424 struct spoolss_5f *r;
7426 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5F];
7428 r = talloc(talloc_tos(), struct spoolss_5f);
7433 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7438 pull = ndr_pull_init_blob(&blob, r, NULL);
7444 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7445 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7446 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7451 if (DEBUGLEVEL >= 10) {
7452 NDR_PRINT_IN_DEBUG(spoolss_5f, r);
7455 r->out.result = _spoolss_5f(p, r);
7457 if (p->rng_fault_state) {
7459 /* Return true here, srv_pipe_hnd.c will take care */
7463 if (DEBUGLEVEL >= 10) {
7464 NDR_PRINT_OUT_DEBUG(spoolss_5f, r);
7467 push = ndr_push_init_ctx(r, NULL);
7473 ndr_err = call->ndr_push(push, NDR_OUT, r);
7474 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7479 blob = ndr_push_blob(push);
7480 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7490 static bool api_spoolss_60(pipes_struct *p)
7492 const struct ndr_interface_call *call;
7493 struct ndr_pull *pull;
7494 struct ndr_push *push;
7495 enum ndr_err_code ndr_err;
7497 struct spoolss_60 *r;
7499 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_60];
7501 r = talloc(talloc_tos(), struct spoolss_60);
7506 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7511 pull = ndr_pull_init_blob(&blob, r, NULL);
7517 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7518 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7519 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7524 if (DEBUGLEVEL >= 10) {
7525 NDR_PRINT_IN_DEBUG(spoolss_60, r);
7528 r->out.result = _spoolss_60(p, r);
7530 if (p->rng_fault_state) {
7532 /* Return true here, srv_pipe_hnd.c will take care */
7536 if (DEBUGLEVEL >= 10) {
7537 NDR_PRINT_OUT_DEBUG(spoolss_60, r);
7540 push = ndr_push_init_ctx(r, NULL);
7546 ndr_err = call->ndr_push(push, NDR_OUT, r);
7547 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7552 blob = ndr_push_blob(push);
7553 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7563 static bool api_spoolss_61(pipes_struct *p)
7565 const struct ndr_interface_call *call;
7566 struct ndr_pull *pull;
7567 struct ndr_push *push;
7568 enum ndr_err_code ndr_err;
7570 struct spoolss_61 *r;
7572 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_61];
7574 r = talloc(talloc_tos(), struct spoolss_61);
7579 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7584 pull = ndr_pull_init_blob(&blob, r, NULL);
7590 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7591 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7592 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7597 if (DEBUGLEVEL >= 10) {
7598 NDR_PRINT_IN_DEBUG(spoolss_61, r);
7601 r->out.result = _spoolss_61(p, r);
7603 if (p->rng_fault_state) {
7605 /* Return true here, srv_pipe_hnd.c will take care */
7609 if (DEBUGLEVEL >= 10) {
7610 NDR_PRINT_OUT_DEBUG(spoolss_61, r);
7613 push = ndr_push_init_ctx(r, NULL);
7619 ndr_err = call->ndr_push(push, NDR_OUT, r);
7620 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7625 blob = ndr_push_blob(push);
7626 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7636 static bool api_spoolss_62(pipes_struct *p)
7638 const struct ndr_interface_call *call;
7639 struct ndr_pull *pull;
7640 struct ndr_push *push;
7641 enum ndr_err_code ndr_err;
7643 struct spoolss_62 *r;
7645 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_62];
7647 r = talloc(talloc_tos(), struct spoolss_62);
7652 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7657 pull = ndr_pull_init_blob(&blob, r, NULL);
7663 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7664 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7665 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7670 if (DEBUGLEVEL >= 10) {
7671 NDR_PRINT_IN_DEBUG(spoolss_62, r);
7674 r->out.result = _spoolss_62(p, r);
7676 if (p->rng_fault_state) {
7678 /* Return true here, srv_pipe_hnd.c will take care */
7682 if (DEBUGLEVEL >= 10) {
7683 NDR_PRINT_OUT_DEBUG(spoolss_62, r);
7686 push = ndr_push_init_ctx(r, NULL);
7692 ndr_err = call->ndr_push(push, NDR_OUT, r);
7693 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7698 blob = ndr_push_blob(push);
7699 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7709 static bool api_spoolss_63(pipes_struct *p)
7711 const struct ndr_interface_call *call;
7712 struct ndr_pull *pull;
7713 struct ndr_push *push;
7714 enum ndr_err_code ndr_err;
7716 struct spoolss_63 *r;
7718 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_63];
7720 r = talloc(talloc_tos(), struct spoolss_63);
7725 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7730 pull = ndr_pull_init_blob(&blob, r, NULL);
7736 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7737 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7738 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7743 if (DEBUGLEVEL >= 10) {
7744 NDR_PRINT_IN_DEBUG(spoolss_63, r);
7747 r->out.result = _spoolss_63(p, r);
7749 if (p->rng_fault_state) {
7751 /* Return true here, srv_pipe_hnd.c will take care */
7755 if (DEBUGLEVEL >= 10) {
7756 NDR_PRINT_OUT_DEBUG(spoolss_63, r);
7759 push = ndr_push_init_ctx(r, NULL);
7765 ndr_err = call->ndr_push(push, NDR_OUT, r);
7766 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7771 blob = ndr_push_blob(push);
7772 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7782 static bool api_spoolss_64(pipes_struct *p)
7784 const struct ndr_interface_call *call;
7785 struct ndr_pull *pull;
7786 struct ndr_push *push;
7787 enum ndr_err_code ndr_err;
7789 struct spoolss_64 *r;
7791 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_64];
7793 r = talloc(talloc_tos(), struct spoolss_64);
7798 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7803 pull = ndr_pull_init_blob(&blob, r, NULL);
7809 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7810 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7811 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7816 if (DEBUGLEVEL >= 10) {
7817 NDR_PRINT_IN_DEBUG(spoolss_64, r);
7820 r->out.result = _spoolss_64(p, r);
7822 if (p->rng_fault_state) {
7824 /* Return true here, srv_pipe_hnd.c will take care */
7828 if (DEBUGLEVEL >= 10) {
7829 NDR_PRINT_OUT_DEBUG(spoolss_64, r);
7832 push = ndr_push_init_ctx(r, NULL);
7838 ndr_err = call->ndr_push(push, NDR_OUT, r);
7839 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7844 blob = ndr_push_blob(push);
7845 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7855 static bool api_spoolss_65(pipes_struct *p)
7857 const struct ndr_interface_call *call;
7858 struct ndr_pull *pull;
7859 struct ndr_push *push;
7860 enum ndr_err_code ndr_err;
7862 struct spoolss_65 *r;
7864 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_65];
7866 r = talloc(talloc_tos(), struct spoolss_65);
7871 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7876 pull = ndr_pull_init_blob(&blob, r, NULL);
7882 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7883 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7884 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7889 if (DEBUGLEVEL >= 10) {
7890 NDR_PRINT_IN_DEBUG(spoolss_65, r);
7893 r->out.result = _spoolss_65(p, r);
7895 if (p->rng_fault_state) {
7897 /* Return true here, srv_pipe_hnd.c will take care */
7901 if (DEBUGLEVEL >= 10) {
7902 NDR_PRINT_OUT_DEBUG(spoolss_65, r);
7905 push = ndr_push_init_ctx(r, NULL);
7911 ndr_err = call->ndr_push(push, NDR_OUT, r);
7912 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7917 blob = ndr_push_blob(push);
7918 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7928 static bool api_spoolss_GetCorePrinterDrivers(pipes_struct *p)
7930 const struct ndr_interface_call *call;
7931 struct ndr_pull *pull;
7932 struct ndr_push *push;
7933 enum ndr_err_code ndr_err;
7935 struct spoolss_GetCorePrinterDrivers *r;
7937 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETCOREPRINTERDRIVERS];
7939 r = talloc(talloc_tos(), struct spoolss_GetCorePrinterDrivers);
7944 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7949 pull = ndr_pull_init_blob(&blob, r, NULL);
7955 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7956 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7957 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7962 if (DEBUGLEVEL >= 10) {
7963 NDR_PRINT_IN_DEBUG(spoolss_GetCorePrinterDrivers, r);
7966 ZERO_STRUCT(r->out);
7967 r->out.core_printer_drivers = talloc_zero_array(r, struct spoolss_CorePrinterDriver, r->in.core_printer_driver_count);
7968 if (r->out.core_printer_drivers == NULL) {
7973 r->out.result = _spoolss_GetCorePrinterDrivers(p, r);
7975 if (p->rng_fault_state) {
7977 /* Return true here, srv_pipe_hnd.c will take care */
7981 if (DEBUGLEVEL >= 10) {
7982 NDR_PRINT_OUT_DEBUG(spoolss_GetCorePrinterDrivers, r);
7985 push = ndr_push_init_ctx(r, NULL);
7991 ndr_err = call->ndr_push(push, NDR_OUT, r);
7992 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7997 blob = ndr_push_blob(push);
7998 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8008 static bool api_spoolss_67(pipes_struct *p)
8010 const struct ndr_interface_call *call;
8011 struct ndr_pull *pull;
8012 struct ndr_push *push;
8013 enum ndr_err_code ndr_err;
8015 struct spoolss_67 *r;
8017 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_67];
8019 r = talloc(talloc_tos(), struct spoolss_67);
8024 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8029 pull = ndr_pull_init_blob(&blob, r, NULL);
8035 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8036 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8037 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8042 if (DEBUGLEVEL >= 10) {
8043 NDR_PRINT_IN_DEBUG(spoolss_67, r);
8046 r->out.result = _spoolss_67(p, r);
8048 if (p->rng_fault_state) {
8050 /* Return true here, srv_pipe_hnd.c will take care */
8054 if (DEBUGLEVEL >= 10) {
8055 NDR_PRINT_OUT_DEBUG(spoolss_67, r);
8058 push = ndr_push_init_ctx(r, NULL);
8064 ndr_err = call->ndr_push(push, NDR_OUT, r);
8065 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8070 blob = ndr_push_blob(push);
8071 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8081 static bool api_spoolss_GetPrinterDriverPackagePath(pipes_struct *p)
8083 const struct ndr_interface_call *call;
8084 struct ndr_pull *pull;
8085 struct ndr_push *push;
8086 enum ndr_err_code ndr_err;
8088 struct spoolss_GetPrinterDriverPackagePath *r;
8090 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH];
8092 r = talloc(talloc_tos(), struct spoolss_GetPrinterDriverPackagePath);
8097 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8102 pull = ndr_pull_init_blob(&blob, r, NULL);
8108 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8109 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8110 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8115 if (DEBUGLEVEL >= 10) {
8116 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriverPackagePath, r);
8119 ZERO_STRUCT(r->out);
8120 r->out.driver_package_cab = r->in.driver_package_cab;
8121 r->out.required = talloc_zero(r, uint32_t);
8122 if (r->out.required == NULL) {
8127 r->out.result = _spoolss_GetPrinterDriverPackagePath(p, r);
8129 if (p->rng_fault_state) {
8131 /* Return true here, srv_pipe_hnd.c will take care */
8135 if (DEBUGLEVEL >= 10) {
8136 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriverPackagePath, r);
8139 push = ndr_push_init_ctx(r, NULL);
8145 ndr_err = call->ndr_push(push, NDR_OUT, r);
8146 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8151 blob = ndr_push_blob(push);
8152 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8162 static bool api_spoolss_69(pipes_struct *p)
8164 const struct ndr_interface_call *call;
8165 struct ndr_pull *pull;
8166 struct ndr_push *push;
8167 enum ndr_err_code ndr_err;
8169 struct spoolss_69 *r;
8171 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_69];
8173 r = talloc(talloc_tos(), struct spoolss_69);
8178 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8183 pull = ndr_pull_init_blob(&blob, r, NULL);
8189 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8190 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8191 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8196 if (DEBUGLEVEL >= 10) {
8197 NDR_PRINT_IN_DEBUG(spoolss_69, r);
8200 r->out.result = _spoolss_69(p, r);
8202 if (p->rng_fault_state) {
8204 /* Return true here, srv_pipe_hnd.c will take care */
8208 if (DEBUGLEVEL >= 10) {
8209 NDR_PRINT_OUT_DEBUG(spoolss_69, r);
8212 push = ndr_push_init_ctx(r, NULL);
8218 ndr_err = call->ndr_push(push, NDR_OUT, r);
8219 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8224 blob = ndr_push_blob(push);
8225 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8235 static bool api_spoolss_6a(pipes_struct *p)
8237 const struct ndr_interface_call *call;
8238 struct ndr_pull *pull;
8239 struct ndr_push *push;
8240 enum ndr_err_code ndr_err;
8242 struct spoolss_6a *r;
8244 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6A];
8246 r = talloc(talloc_tos(), struct spoolss_6a);
8251 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8256 pull = ndr_pull_init_blob(&blob, r, NULL);
8262 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8263 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8264 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8269 if (DEBUGLEVEL >= 10) {
8270 NDR_PRINT_IN_DEBUG(spoolss_6a, r);
8273 r->out.result = _spoolss_6a(p, r);
8275 if (p->rng_fault_state) {
8277 /* Return true here, srv_pipe_hnd.c will take care */
8281 if (DEBUGLEVEL >= 10) {
8282 NDR_PRINT_OUT_DEBUG(spoolss_6a, r);
8285 push = ndr_push_init_ctx(r, NULL);
8291 ndr_err = call->ndr_push(push, NDR_OUT, r);
8292 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8297 blob = ndr_push_blob(push);
8298 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8308 static bool api_spoolss_6b(pipes_struct *p)
8310 const struct ndr_interface_call *call;
8311 struct ndr_pull *pull;
8312 struct ndr_push *push;
8313 enum ndr_err_code ndr_err;
8315 struct spoolss_6b *r;
8317 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6B];
8319 r = talloc(talloc_tos(), struct spoolss_6b);
8324 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8329 pull = ndr_pull_init_blob(&blob, r, NULL);
8335 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8336 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8337 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8342 if (DEBUGLEVEL >= 10) {
8343 NDR_PRINT_IN_DEBUG(spoolss_6b, r);
8346 r->out.result = _spoolss_6b(p, r);
8348 if (p->rng_fault_state) {
8350 /* Return true here, srv_pipe_hnd.c will take care */
8354 if (DEBUGLEVEL >= 10) {
8355 NDR_PRINT_OUT_DEBUG(spoolss_6b, r);
8358 push = ndr_push_init_ctx(r, NULL);
8364 ndr_err = call->ndr_push(push, NDR_OUT, r);
8365 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8370 blob = ndr_push_blob(push);
8371 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8381 static bool api_spoolss_6c(pipes_struct *p)
8383 const struct ndr_interface_call *call;
8384 struct ndr_pull *pull;
8385 struct ndr_push *push;
8386 enum ndr_err_code ndr_err;
8388 struct spoolss_6c *r;
8390 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6C];
8392 r = talloc(talloc_tos(), struct spoolss_6c);
8397 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8402 pull = ndr_pull_init_blob(&blob, r, NULL);
8408 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8409 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8410 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8415 if (DEBUGLEVEL >= 10) {
8416 NDR_PRINT_IN_DEBUG(spoolss_6c, r);
8419 r->out.result = _spoolss_6c(p, r);
8421 if (p->rng_fault_state) {
8423 /* Return true here, srv_pipe_hnd.c will take care */
8427 if (DEBUGLEVEL >= 10) {
8428 NDR_PRINT_OUT_DEBUG(spoolss_6c, r);
8431 push = ndr_push_init_ctx(r, NULL);
8437 ndr_err = call->ndr_push(push, NDR_OUT, r);
8438 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8443 blob = ndr_push_blob(push);
8444 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8454 static bool api_spoolss_6d(pipes_struct *p)
8456 const struct ndr_interface_call *call;
8457 struct ndr_pull *pull;
8458 struct ndr_push *push;
8459 enum ndr_err_code ndr_err;
8461 struct spoolss_6d *r;
8463 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6D];
8465 r = talloc(talloc_tos(), struct spoolss_6d);
8470 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8475 pull = ndr_pull_init_blob(&blob, r, NULL);
8481 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8482 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8483 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8488 if (DEBUGLEVEL >= 10) {
8489 NDR_PRINT_IN_DEBUG(spoolss_6d, r);
8492 r->out.result = _spoolss_6d(p, r);
8494 if (p->rng_fault_state) {
8496 /* Return true here, srv_pipe_hnd.c will take care */
8500 if (DEBUGLEVEL >= 10) {
8501 NDR_PRINT_OUT_DEBUG(spoolss_6d, r);
8504 push = ndr_push_init_ctx(r, NULL);
8510 ndr_err = call->ndr_push(push, NDR_OUT, r);
8511 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8516 blob = ndr_push_blob(push);
8517 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8529 static struct api_struct api_spoolss_cmds[] =
8531 {"SPOOLSS_ENUMPRINTERS", NDR_SPOOLSS_ENUMPRINTERS, api_spoolss_EnumPrinters},
8532 {"SPOOLSS_OPENPRINTER", NDR_SPOOLSS_OPENPRINTER, api_spoolss_OpenPrinter},
8533 {"SPOOLSS_SETJOB", NDR_SPOOLSS_SETJOB, api_spoolss_SetJob},
8534 {"SPOOLSS_GETJOB", NDR_SPOOLSS_GETJOB, api_spoolss_GetJob},
8535 {"SPOOLSS_ENUMJOBS", NDR_SPOOLSS_ENUMJOBS, api_spoolss_EnumJobs},
8536 {"SPOOLSS_ADDPRINTER", NDR_SPOOLSS_ADDPRINTER, api_spoolss_AddPrinter},
8537 {"SPOOLSS_DELETEPRINTER", NDR_SPOOLSS_DELETEPRINTER, api_spoolss_DeletePrinter},
8538 {"SPOOLSS_SETPRINTER", NDR_SPOOLSS_SETPRINTER, api_spoolss_SetPrinter},
8539 {"SPOOLSS_GETPRINTER", NDR_SPOOLSS_GETPRINTER, api_spoolss_GetPrinter},
8540 {"SPOOLSS_ADDPRINTERDRIVER", NDR_SPOOLSS_ADDPRINTERDRIVER, api_spoolss_AddPrinterDriver},
8541 {"SPOOLSS_ENUMPRINTERDRIVERS", NDR_SPOOLSS_ENUMPRINTERDRIVERS, api_spoolss_EnumPrinterDrivers},
8542 {"SPOOLSS_GETPRINTERDRIVER", NDR_SPOOLSS_GETPRINTERDRIVER, api_spoolss_GetPrinterDriver},
8543 {"SPOOLSS_GETPRINTERDRIVERDIRECTORY", NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY, api_spoolss_GetPrinterDriverDirectory},
8544 {"SPOOLSS_DELETEPRINTERDRIVER", NDR_SPOOLSS_DELETEPRINTERDRIVER, api_spoolss_DeletePrinterDriver},
8545 {"SPOOLSS_ADDPRINTPROCESSOR", NDR_SPOOLSS_ADDPRINTPROCESSOR, api_spoolss_AddPrintProcessor},
8546 {"SPOOLSS_ENUMPRINTPROCESSORS", NDR_SPOOLSS_ENUMPRINTPROCESSORS, api_spoolss_EnumPrintProcessors},
8547 {"SPOOLSS_GETPRINTPROCESSORDIRECTORY", NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY, api_spoolss_GetPrintProcessorDirectory},
8548 {"SPOOLSS_STARTDOCPRINTER", NDR_SPOOLSS_STARTDOCPRINTER, api_spoolss_StartDocPrinter},
8549 {"SPOOLSS_STARTPAGEPRINTER", NDR_SPOOLSS_STARTPAGEPRINTER, api_spoolss_StartPagePrinter},
8550 {"SPOOLSS_WRITEPRINTER", NDR_SPOOLSS_WRITEPRINTER, api_spoolss_WritePrinter},
8551 {"SPOOLSS_ENDPAGEPRINTER", NDR_SPOOLSS_ENDPAGEPRINTER, api_spoolss_EndPagePrinter},
8552 {"SPOOLSS_ABORTPRINTER", NDR_SPOOLSS_ABORTPRINTER, api_spoolss_AbortPrinter},
8553 {"SPOOLSS_READPRINTER", NDR_SPOOLSS_READPRINTER, api_spoolss_ReadPrinter},
8554 {"SPOOLSS_ENDDOCPRINTER", NDR_SPOOLSS_ENDDOCPRINTER, api_spoolss_EndDocPrinter},
8555 {"SPOOLSS_ADDJOB", NDR_SPOOLSS_ADDJOB, api_spoolss_AddJob},
8556 {"SPOOLSS_SCHEDULEJOB", NDR_SPOOLSS_SCHEDULEJOB, api_spoolss_ScheduleJob},
8557 {"SPOOLSS_GETPRINTERDATA", NDR_SPOOLSS_GETPRINTERDATA, api_spoolss_GetPrinterData},
8558 {"SPOOLSS_SETPRINTERDATA", NDR_SPOOLSS_SETPRINTERDATA, api_spoolss_SetPrinterData},
8559 {"SPOOLSS_WAITFORPRINTERCHANGE", NDR_SPOOLSS_WAITFORPRINTERCHANGE, api_spoolss_WaitForPrinterChange},
8560 {"SPOOLSS_CLOSEPRINTER", NDR_SPOOLSS_CLOSEPRINTER, api_spoolss_ClosePrinter},
8561 {"SPOOLSS_ADDFORM", NDR_SPOOLSS_ADDFORM, api_spoolss_AddForm},
8562 {"SPOOLSS_DELETEFORM", NDR_SPOOLSS_DELETEFORM, api_spoolss_DeleteForm},
8563 {"SPOOLSS_GETFORM", NDR_SPOOLSS_GETFORM, api_spoolss_GetForm},
8564 {"SPOOLSS_SETFORM", NDR_SPOOLSS_SETFORM, api_spoolss_SetForm},
8565 {"SPOOLSS_ENUMFORMS", NDR_SPOOLSS_ENUMFORMS, api_spoolss_EnumForms},
8566 {"SPOOLSS_ENUMPORTS", NDR_SPOOLSS_ENUMPORTS, api_spoolss_EnumPorts},
8567 {"SPOOLSS_ENUMMONITORS", NDR_SPOOLSS_ENUMMONITORS, api_spoolss_EnumMonitors},
8568 {"SPOOLSS_ADDPORT", NDR_SPOOLSS_ADDPORT, api_spoolss_AddPort},
8569 {"SPOOLSS_CONFIGUREPORT", NDR_SPOOLSS_CONFIGUREPORT, api_spoolss_ConfigurePort},
8570 {"SPOOLSS_DELETEPORT", NDR_SPOOLSS_DELETEPORT, api_spoolss_DeletePort},
8571 {"SPOOLSS_CREATEPRINTERIC", NDR_SPOOLSS_CREATEPRINTERIC, api_spoolss_CreatePrinterIC},
8572 {"SPOOLSS_PLAYGDISCRIPTONPRINTERIC", NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC, api_spoolss_PlayGDIScriptOnPrinterIC},
8573 {"SPOOLSS_DELETEPRINTERIC", NDR_SPOOLSS_DELETEPRINTERIC, api_spoolss_DeletePrinterIC},
8574 {"SPOOLSS_ADDPRINTERCONNECTION", NDR_SPOOLSS_ADDPRINTERCONNECTION, api_spoolss_AddPrinterConnection},
8575 {"SPOOLSS_DELETEPRINTERCONNECTION", NDR_SPOOLSS_DELETEPRINTERCONNECTION, api_spoolss_DeletePrinterConnection},
8576 {"SPOOLSS_PRINTERMESSAGEBOX", NDR_SPOOLSS_PRINTERMESSAGEBOX, api_spoolss_PrinterMessageBox},
8577 {"SPOOLSS_ADDMONITOR", NDR_SPOOLSS_ADDMONITOR, api_spoolss_AddMonitor},
8578 {"SPOOLSS_DELETEMONITOR", NDR_SPOOLSS_DELETEMONITOR, api_spoolss_DeleteMonitor},
8579 {"SPOOLSS_DELETEPRINTPROCESSOR", NDR_SPOOLSS_DELETEPRINTPROCESSOR, api_spoolss_DeletePrintProcessor},
8580 {"SPOOLSS_ADDPRINTPROVIDOR", NDR_SPOOLSS_ADDPRINTPROVIDOR, api_spoolss_AddPrintProvidor},
8581 {"SPOOLSS_DELETEPRINTPROVIDOR", NDR_SPOOLSS_DELETEPRINTPROVIDOR, api_spoolss_DeletePrintProvidor},
8582 {"SPOOLSS_ENUMPRINTPROCDATATYPES", NDR_SPOOLSS_ENUMPRINTPROCDATATYPES, api_spoolss_EnumPrintProcDataTypes},
8583 {"SPOOLSS_RESETPRINTER", NDR_SPOOLSS_RESETPRINTER, api_spoolss_ResetPrinter},
8584 {"SPOOLSS_GETPRINTERDRIVER2", NDR_SPOOLSS_GETPRINTERDRIVER2, api_spoolss_GetPrinterDriver2},
8585 {"SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION", NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION, api_spoolss_FindFirstPrinterChangeNotification},
8586 {"SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION", NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION, api_spoolss_FindNextPrinterChangeNotification},
8587 {"SPOOLSS_FINDCLOSEPRINTERNOTIFY", NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY, api_spoolss_FindClosePrinterNotify},
8588 {"SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD", NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD, api_spoolss_RouterFindFirstPrinterChangeNotificationOld},
8589 {"SPOOLSS_REPLYOPENPRINTER", NDR_SPOOLSS_REPLYOPENPRINTER, api_spoolss_ReplyOpenPrinter},
8590 {"SPOOLSS_ROUTERREPLYPRINTER", NDR_SPOOLSS_ROUTERREPLYPRINTER, api_spoolss_RouterReplyPrinter},
8591 {"SPOOLSS_REPLYCLOSEPRINTER", NDR_SPOOLSS_REPLYCLOSEPRINTER, api_spoolss_ReplyClosePrinter},
8592 {"SPOOLSS_ADDPORTEX", NDR_SPOOLSS_ADDPORTEX, api_spoolss_AddPortEx},
8593 {"SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION", NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION, api_spoolss_RouterFindFirstPrinterChangeNotification},
8594 {"SPOOLSS_SPOOLERINIT", NDR_SPOOLSS_SPOOLERINIT, api_spoolss_SpoolerInit},
8595 {"SPOOLSS_RESETPRINTEREX", NDR_SPOOLSS_RESETPRINTEREX, api_spoolss_ResetPrinterEx},
8596 {"SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX", NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX, api_spoolss_RemoteFindFirstPrinterChangeNotifyEx},
8597 {"SPOOLSS_ROUTERREPLYPRINTEREX", NDR_SPOOLSS_ROUTERREPLYPRINTEREX, api_spoolss_RouterReplyPrinterEx},
8598 {"SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY", NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY, api_spoolss_RouterRefreshPrinterChangeNotify},
8599 {"SPOOLSS_44", NDR_SPOOLSS_44, api_spoolss_44},
8600 {"SPOOLSS_OPENPRINTEREX", NDR_SPOOLSS_OPENPRINTEREX, api_spoolss_OpenPrinterEx},
8601 {"SPOOLSS_ADDPRINTEREX", NDR_SPOOLSS_ADDPRINTEREX, api_spoolss_AddPrinterEx},
8602 {"SPOOLSS_47", NDR_SPOOLSS_47, api_spoolss_47},
8603 {"SPOOLSS_ENUMPRINTERDATA", NDR_SPOOLSS_ENUMPRINTERDATA, api_spoolss_EnumPrinterData},
8604 {"SPOOLSS_DELETEPRINTERDATA", NDR_SPOOLSS_DELETEPRINTERDATA, api_spoolss_DeletePrinterData},
8605 {"SPOOLSS_4A", NDR_SPOOLSS_4A, api_spoolss_4a},
8606 {"SPOOLSS_4B", NDR_SPOOLSS_4B, api_spoolss_4b},
8607 {"SPOOLSS_4C", NDR_SPOOLSS_4C, api_spoolss_4c},
8608 {"SPOOLSS_SETPRINTERDATAEX", NDR_SPOOLSS_SETPRINTERDATAEX, api_spoolss_SetPrinterDataEx},
8609 {"SPOOLSS_GETPRINTERDATAEX", NDR_SPOOLSS_GETPRINTERDATAEX, api_spoolss_GetPrinterDataEx},
8610 {"SPOOLSS_ENUMPRINTERDATAEX", NDR_SPOOLSS_ENUMPRINTERDATAEX, api_spoolss_EnumPrinterDataEx},
8611 {"SPOOLSS_ENUMPRINTERKEY", NDR_SPOOLSS_ENUMPRINTERKEY, api_spoolss_EnumPrinterKey},
8612 {"SPOOLSS_DELETEPRINTERDATAEX", NDR_SPOOLSS_DELETEPRINTERDATAEX, api_spoolss_DeletePrinterDataEx},
8613 {"SPOOLSS_DELETEPRINTERKEY", NDR_SPOOLSS_DELETEPRINTERKEY, api_spoolss_DeletePrinterKey},
8614 {"SPOOLSS_53", NDR_SPOOLSS_53, api_spoolss_53},
8615 {"SPOOLSS_DELETEPRINTERDRIVEREX", NDR_SPOOLSS_DELETEPRINTERDRIVEREX, api_spoolss_DeletePrinterDriverEx},
8616 {"SPOOLSS_55", NDR_SPOOLSS_55, api_spoolss_55},
8617 {"SPOOLSS_56", NDR_SPOOLSS_56, api_spoolss_56},
8618 {"SPOOLSS_57", NDR_SPOOLSS_57, api_spoolss_57},
8619 {"SPOOLSS_XCVDATA", NDR_SPOOLSS_XCVDATA, api_spoolss_XcvData},
8620 {"SPOOLSS_ADDPRINTERDRIVEREX", NDR_SPOOLSS_ADDPRINTERDRIVEREX, api_spoolss_AddPrinterDriverEx},
8621 {"SPOOLSS_5A", NDR_SPOOLSS_5A, api_spoolss_5a},
8622 {"SPOOLSS_5B", NDR_SPOOLSS_5B, api_spoolss_5b},
8623 {"SPOOLSS_5C", NDR_SPOOLSS_5C, api_spoolss_5c},
8624 {"SPOOLSS_5D", NDR_SPOOLSS_5D, api_spoolss_5d},
8625 {"SPOOLSS_5E", NDR_SPOOLSS_5E, api_spoolss_5e},
8626 {"SPOOLSS_5F", NDR_SPOOLSS_5F, api_spoolss_5f},
8627 {"SPOOLSS_60", NDR_SPOOLSS_60, api_spoolss_60},
8628 {"SPOOLSS_61", NDR_SPOOLSS_61, api_spoolss_61},
8629 {"SPOOLSS_62", NDR_SPOOLSS_62, api_spoolss_62},
8630 {"SPOOLSS_63", NDR_SPOOLSS_63, api_spoolss_63},
8631 {"SPOOLSS_64", NDR_SPOOLSS_64, api_spoolss_64},
8632 {"SPOOLSS_65", NDR_SPOOLSS_65, api_spoolss_65},
8633 {"SPOOLSS_GETCOREPRINTERDRIVERS", NDR_SPOOLSS_GETCOREPRINTERDRIVERS, api_spoolss_GetCorePrinterDrivers},
8634 {"SPOOLSS_67", NDR_SPOOLSS_67, api_spoolss_67},
8635 {"SPOOLSS_GETPRINTERDRIVERPACKAGEPATH", NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH, api_spoolss_GetPrinterDriverPackagePath},
8636 {"SPOOLSS_69", NDR_SPOOLSS_69, api_spoolss_69},
8637 {"SPOOLSS_6A", NDR_SPOOLSS_6A, api_spoolss_6a},
8638 {"SPOOLSS_6B", NDR_SPOOLSS_6B, api_spoolss_6b},
8639 {"SPOOLSS_6C", NDR_SPOOLSS_6C, api_spoolss_6c},
8640 {"SPOOLSS_6D", NDR_SPOOLSS_6D, api_spoolss_6d},
8643 void spoolss_get_pipe_fns(struct api_struct **fns, int *n_fns)
8645 *fns = api_spoolss_cmds;
8646 *n_fns = sizeof(api_spoolss_cmds) / sizeof(struct api_struct);
8649 NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r)
8651 if (cli->pipes_struct == NULL) {
8652 return NT_STATUS_INVALID_PARAMETER;
8657 case NDR_SPOOLSS_ENUMPRINTERS: {
8658 struct spoolss_EnumPrinters *r = (struct spoolss_EnumPrinters *)_r;
8659 ZERO_STRUCT(r->out);
8660 r->out.count = talloc_zero(mem_ctx, uint32_t);
8661 if (r->out.count == NULL) {
8662 return NT_STATUS_NO_MEMORY;
8665 r->out.info = talloc_zero(mem_ctx, union spoolss_PrinterInfo *);
8666 if (r->out.info == NULL) {
8667 return NT_STATUS_NO_MEMORY;
8670 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8671 if (r->out.needed == NULL) {
8672 return NT_STATUS_NO_MEMORY;
8675 r->out.result = _spoolss_EnumPrinters(cli->pipes_struct, r);
8676 return NT_STATUS_OK;
8679 case NDR_SPOOLSS_OPENPRINTER: {
8680 struct spoolss_OpenPrinter *r = (struct spoolss_OpenPrinter *)_r;
8681 ZERO_STRUCT(r->out);
8682 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
8683 if (r->out.handle == NULL) {
8684 return NT_STATUS_NO_MEMORY;
8687 r->out.result = _spoolss_OpenPrinter(cli->pipes_struct, r);
8688 return NT_STATUS_OK;
8691 case NDR_SPOOLSS_SETJOB: {
8692 struct spoolss_SetJob *r = (struct spoolss_SetJob *)_r;
8693 r->out.result = _spoolss_SetJob(cli->pipes_struct, r);
8694 return NT_STATUS_OK;
8697 case NDR_SPOOLSS_GETJOB: {
8698 struct spoolss_GetJob *r = (struct spoolss_GetJob *)_r;
8699 ZERO_STRUCT(r->out);
8700 r->out.info = talloc_zero(mem_ctx, union spoolss_JobInfo);
8701 if (r->out.info == NULL) {
8702 return NT_STATUS_NO_MEMORY;
8705 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8706 if (r->out.needed == NULL) {
8707 return NT_STATUS_NO_MEMORY;
8710 r->out.result = _spoolss_GetJob(cli->pipes_struct, r);
8711 return NT_STATUS_OK;
8714 case NDR_SPOOLSS_ENUMJOBS: {
8715 struct spoolss_EnumJobs *r = (struct spoolss_EnumJobs *)_r;
8716 ZERO_STRUCT(r->out);
8717 r->out.count = talloc_zero(mem_ctx, uint32_t);
8718 if (r->out.count == NULL) {
8719 return NT_STATUS_NO_MEMORY;
8722 r->out.info = talloc_zero(mem_ctx, union spoolss_JobInfo *);
8723 if (r->out.info == NULL) {
8724 return NT_STATUS_NO_MEMORY;
8727 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8728 if (r->out.needed == NULL) {
8729 return NT_STATUS_NO_MEMORY;
8732 r->out.result = _spoolss_EnumJobs(cli->pipes_struct, r);
8733 return NT_STATUS_OK;
8736 case NDR_SPOOLSS_ADDPRINTER: {
8737 struct spoolss_AddPrinter *r = (struct spoolss_AddPrinter *)_r;
8738 ZERO_STRUCT(r->out);
8739 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
8740 if (r->out.handle == NULL) {
8741 return NT_STATUS_NO_MEMORY;
8744 r->out.result = _spoolss_AddPrinter(cli->pipes_struct, r);
8745 return NT_STATUS_OK;
8748 case NDR_SPOOLSS_DELETEPRINTER: {
8749 struct spoolss_DeletePrinter *r = (struct spoolss_DeletePrinter *)_r;
8750 r->out.result = _spoolss_DeletePrinter(cli->pipes_struct, r);
8751 return NT_STATUS_OK;
8754 case NDR_SPOOLSS_SETPRINTER: {
8755 struct spoolss_SetPrinter *r = (struct spoolss_SetPrinter *)_r;
8756 r->out.result = _spoolss_SetPrinter(cli->pipes_struct, r);
8757 return NT_STATUS_OK;
8760 case NDR_SPOOLSS_GETPRINTER: {
8761 struct spoolss_GetPrinter *r = (struct spoolss_GetPrinter *)_r;
8762 ZERO_STRUCT(r->out);
8763 r->out.info = talloc_zero(mem_ctx, union spoolss_PrinterInfo);
8764 if (r->out.info == NULL) {
8765 return NT_STATUS_NO_MEMORY;
8768 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8769 if (r->out.needed == NULL) {
8770 return NT_STATUS_NO_MEMORY;
8773 r->out.result = _spoolss_GetPrinter(cli->pipes_struct, r);
8774 return NT_STATUS_OK;
8777 case NDR_SPOOLSS_ADDPRINTERDRIVER: {
8778 struct spoolss_AddPrinterDriver *r = (struct spoolss_AddPrinterDriver *)_r;
8779 r->out.result = _spoolss_AddPrinterDriver(cli->pipes_struct, r);
8780 return NT_STATUS_OK;
8783 case NDR_SPOOLSS_ENUMPRINTERDRIVERS: {
8784 struct spoolss_EnumPrinterDrivers *r = (struct spoolss_EnumPrinterDrivers *)_r;
8785 ZERO_STRUCT(r->out);
8786 r->out.count = talloc_zero(mem_ctx, uint32_t);
8787 if (r->out.count == NULL) {
8788 return NT_STATUS_NO_MEMORY;
8791 r->out.info = talloc_zero(mem_ctx, union spoolss_DriverInfo *);
8792 if (r->out.info == NULL) {
8793 return NT_STATUS_NO_MEMORY;
8796 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8797 if (r->out.needed == NULL) {
8798 return NT_STATUS_NO_MEMORY;
8801 r->out.result = _spoolss_EnumPrinterDrivers(cli->pipes_struct, r);
8802 return NT_STATUS_OK;
8805 case NDR_SPOOLSS_GETPRINTERDRIVER: {
8806 struct spoolss_GetPrinterDriver *r = (struct spoolss_GetPrinterDriver *)_r;
8807 ZERO_STRUCT(r->out);
8808 r->out.info = talloc_zero(mem_ctx, union spoolss_DriverInfo);
8809 if (r->out.info == NULL) {
8810 return NT_STATUS_NO_MEMORY;
8813 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8814 if (r->out.needed == NULL) {
8815 return NT_STATUS_NO_MEMORY;
8818 r->out.result = _spoolss_GetPrinterDriver(cli->pipes_struct, r);
8819 return NT_STATUS_OK;
8822 case NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY: {
8823 struct spoolss_GetPrinterDriverDirectory *r = (struct spoolss_GetPrinterDriverDirectory *)_r;
8824 ZERO_STRUCT(r->out);
8825 r->out.info = talloc_zero(mem_ctx, union spoolss_DriverDirectoryInfo);
8826 if (r->out.info == NULL) {
8827 return NT_STATUS_NO_MEMORY;
8830 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8831 if (r->out.needed == NULL) {
8832 return NT_STATUS_NO_MEMORY;
8835 r->out.result = _spoolss_GetPrinterDriverDirectory(cli->pipes_struct, r);
8836 return NT_STATUS_OK;
8839 case NDR_SPOOLSS_DELETEPRINTERDRIVER: {
8840 struct spoolss_DeletePrinterDriver *r = (struct spoolss_DeletePrinterDriver *)_r;
8841 r->out.result = _spoolss_DeletePrinterDriver(cli->pipes_struct, r);
8842 return NT_STATUS_OK;
8845 case NDR_SPOOLSS_ADDPRINTPROCESSOR: {
8846 struct spoolss_AddPrintProcessor *r = (struct spoolss_AddPrintProcessor *)_r;
8847 r->out.result = _spoolss_AddPrintProcessor(cli->pipes_struct, r);
8848 return NT_STATUS_OK;
8851 case NDR_SPOOLSS_ENUMPRINTPROCESSORS: {
8852 struct spoolss_EnumPrintProcessors *r = (struct spoolss_EnumPrintProcessors *)_r;
8853 ZERO_STRUCT(r->out);
8854 r->out.count = talloc_zero(mem_ctx, uint32_t);
8855 if (r->out.count == NULL) {
8856 return NT_STATUS_NO_MEMORY;
8859 r->out.info = talloc_zero(mem_ctx, union spoolss_PrintProcessorInfo *);
8860 if (r->out.info == NULL) {
8861 return NT_STATUS_NO_MEMORY;
8864 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8865 if (r->out.needed == NULL) {
8866 return NT_STATUS_NO_MEMORY;
8869 r->out.result = _spoolss_EnumPrintProcessors(cli->pipes_struct, r);
8870 return NT_STATUS_OK;
8873 case NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY: {
8874 struct spoolss_GetPrintProcessorDirectory *r = (struct spoolss_GetPrintProcessorDirectory *)_r;
8875 ZERO_STRUCT(r->out);
8876 r->out.info = talloc_zero(mem_ctx, union spoolss_PrintProcessorDirectoryInfo);
8877 if (r->out.info == NULL) {
8878 return NT_STATUS_NO_MEMORY;
8881 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8882 if (r->out.needed == NULL) {
8883 return NT_STATUS_NO_MEMORY;
8886 r->out.result = _spoolss_GetPrintProcessorDirectory(cli->pipes_struct, r);
8887 return NT_STATUS_OK;
8890 case NDR_SPOOLSS_STARTDOCPRINTER: {
8891 struct spoolss_StartDocPrinter *r = (struct spoolss_StartDocPrinter *)_r;
8892 ZERO_STRUCT(r->out);
8893 r->out.job_id = talloc_zero(mem_ctx, uint32_t);
8894 if (r->out.job_id == NULL) {
8895 return NT_STATUS_NO_MEMORY;
8898 r->out.result = _spoolss_StartDocPrinter(cli->pipes_struct, r);
8899 return NT_STATUS_OK;
8902 case NDR_SPOOLSS_STARTPAGEPRINTER: {
8903 struct spoolss_StartPagePrinter *r = (struct spoolss_StartPagePrinter *)_r;
8904 r->out.result = _spoolss_StartPagePrinter(cli->pipes_struct, r);
8905 return NT_STATUS_OK;
8908 case NDR_SPOOLSS_WRITEPRINTER: {
8909 struct spoolss_WritePrinter *r = (struct spoolss_WritePrinter *)_r;
8910 ZERO_STRUCT(r->out);
8911 r->out.num_written = talloc_zero(mem_ctx, uint32_t);
8912 if (r->out.num_written == NULL) {
8913 return NT_STATUS_NO_MEMORY;
8916 r->out.result = _spoolss_WritePrinter(cli->pipes_struct, r);
8917 return NT_STATUS_OK;
8920 case NDR_SPOOLSS_ENDPAGEPRINTER: {
8921 struct spoolss_EndPagePrinter *r = (struct spoolss_EndPagePrinter *)_r;
8922 r->out.result = _spoolss_EndPagePrinter(cli->pipes_struct, r);
8923 return NT_STATUS_OK;
8926 case NDR_SPOOLSS_ABORTPRINTER: {
8927 struct spoolss_AbortPrinter *r = (struct spoolss_AbortPrinter *)_r;
8928 r->out.result = _spoolss_AbortPrinter(cli->pipes_struct, r);
8929 return NT_STATUS_OK;
8932 case NDR_SPOOLSS_READPRINTER: {
8933 struct spoolss_ReadPrinter *r = (struct spoolss_ReadPrinter *)_r;
8934 ZERO_STRUCT(r->out);
8935 r->out.data = talloc_zero_array(mem_ctx, uint8_t, r->in.data_size);
8936 if (r->out.data == NULL) {
8937 return NT_STATUS_NO_MEMORY;
8940 r->out._data_size = talloc_zero(mem_ctx, uint32_t);
8941 if (r->out._data_size == NULL) {
8942 return NT_STATUS_NO_MEMORY;
8945 r->out.result = _spoolss_ReadPrinter(cli->pipes_struct, r);
8946 return NT_STATUS_OK;
8949 case NDR_SPOOLSS_ENDDOCPRINTER: {
8950 struct spoolss_EndDocPrinter *r = (struct spoolss_EndDocPrinter *)_r;
8951 r->out.result = _spoolss_EndDocPrinter(cli->pipes_struct, r);
8952 return NT_STATUS_OK;
8955 case NDR_SPOOLSS_ADDJOB: {
8956 struct spoolss_AddJob *r = (struct spoolss_AddJob *)_r;
8957 ZERO_STRUCT(r->out);
8958 r->out.buffer = r->in.buffer;
8959 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8960 if (r->out.needed == NULL) {
8961 return NT_STATUS_NO_MEMORY;
8964 r->out.result = _spoolss_AddJob(cli->pipes_struct, r);
8965 return NT_STATUS_OK;
8968 case NDR_SPOOLSS_SCHEDULEJOB: {
8969 struct spoolss_ScheduleJob *r = (struct spoolss_ScheduleJob *)_r;
8970 r->out.result = _spoolss_ScheduleJob(cli->pipes_struct, r);
8971 return NT_STATUS_OK;
8974 case NDR_SPOOLSS_GETPRINTERDATA: {
8975 struct spoolss_GetPrinterData *r = (struct spoolss_GetPrinterData *)_r;
8976 ZERO_STRUCT(r->out);
8977 r->out.type = talloc_zero(mem_ctx, enum winreg_Type);
8978 if (r->out.type == NULL) {
8979 return NT_STATUS_NO_MEMORY;
8982 r->out.data = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
8983 if (r->out.data == NULL) {
8984 return NT_STATUS_NO_MEMORY;
8987 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8988 if (r->out.needed == NULL) {
8989 return NT_STATUS_NO_MEMORY;
8992 r->out.result = _spoolss_GetPrinterData(cli->pipes_struct, r);
8993 return NT_STATUS_OK;
8996 case NDR_SPOOLSS_SETPRINTERDATA: {
8997 struct spoolss_SetPrinterData *r = (struct spoolss_SetPrinterData *)_r;
8998 r->out.result = _spoolss_SetPrinterData(cli->pipes_struct, r);
8999 return NT_STATUS_OK;
9002 case NDR_SPOOLSS_WAITFORPRINTERCHANGE: {
9003 struct spoolss_WaitForPrinterChange *r = (struct spoolss_WaitForPrinterChange *)_r;
9004 r->out.result = _spoolss_WaitForPrinterChange(cli->pipes_struct, r);
9005 return NT_STATUS_OK;
9008 case NDR_SPOOLSS_CLOSEPRINTER: {
9009 struct spoolss_ClosePrinter *r = (struct spoolss_ClosePrinter *)_r;
9010 ZERO_STRUCT(r->out);
9011 r->out.handle = r->in.handle;
9012 r->out.result = _spoolss_ClosePrinter(cli->pipes_struct, r);
9013 return NT_STATUS_OK;
9016 case NDR_SPOOLSS_ADDFORM: {
9017 struct spoolss_AddForm *r = (struct spoolss_AddForm *)_r;
9018 r->out.result = _spoolss_AddForm(cli->pipes_struct, r);
9019 return NT_STATUS_OK;
9022 case NDR_SPOOLSS_DELETEFORM: {
9023 struct spoolss_DeleteForm *r = (struct spoolss_DeleteForm *)_r;
9024 r->out.result = _spoolss_DeleteForm(cli->pipes_struct, r);
9025 return NT_STATUS_OK;
9028 case NDR_SPOOLSS_GETFORM: {
9029 struct spoolss_GetForm *r = (struct spoolss_GetForm *)_r;
9030 ZERO_STRUCT(r->out);
9031 r->out.info = talloc_zero(mem_ctx, union spoolss_FormInfo);
9032 if (r->out.info == NULL) {
9033 return NT_STATUS_NO_MEMORY;
9036 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9037 if (r->out.needed == NULL) {
9038 return NT_STATUS_NO_MEMORY;
9041 r->out.result = _spoolss_GetForm(cli->pipes_struct, r);
9042 return NT_STATUS_OK;
9045 case NDR_SPOOLSS_SETFORM: {
9046 struct spoolss_SetForm *r = (struct spoolss_SetForm *)_r;
9047 r->out.result = _spoolss_SetForm(cli->pipes_struct, r);
9048 return NT_STATUS_OK;
9051 case NDR_SPOOLSS_ENUMFORMS: {
9052 struct spoolss_EnumForms *r = (struct spoolss_EnumForms *)_r;
9053 ZERO_STRUCT(r->out);
9054 r->out.count = talloc_zero(mem_ctx, uint32_t);
9055 if (r->out.count == NULL) {
9056 return NT_STATUS_NO_MEMORY;
9059 r->out.info = talloc_zero(mem_ctx, union spoolss_FormInfo *);
9060 if (r->out.info == NULL) {
9061 return NT_STATUS_NO_MEMORY;
9064 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9065 if (r->out.needed == NULL) {
9066 return NT_STATUS_NO_MEMORY;
9069 r->out.result = _spoolss_EnumForms(cli->pipes_struct, r);
9070 return NT_STATUS_OK;
9073 case NDR_SPOOLSS_ENUMPORTS: {
9074 struct spoolss_EnumPorts *r = (struct spoolss_EnumPorts *)_r;
9075 ZERO_STRUCT(r->out);
9076 r->out.count = talloc_zero(mem_ctx, uint32_t);
9077 if (r->out.count == NULL) {
9078 return NT_STATUS_NO_MEMORY;
9081 r->out.info = talloc_zero(mem_ctx, union spoolss_PortInfo *);
9082 if (r->out.info == NULL) {
9083 return NT_STATUS_NO_MEMORY;
9086 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9087 if (r->out.needed == NULL) {
9088 return NT_STATUS_NO_MEMORY;
9091 r->out.result = _spoolss_EnumPorts(cli->pipes_struct, r);
9092 return NT_STATUS_OK;
9095 case NDR_SPOOLSS_ENUMMONITORS: {
9096 struct spoolss_EnumMonitors *r = (struct spoolss_EnumMonitors *)_r;
9097 ZERO_STRUCT(r->out);
9098 r->out.count = talloc_zero(mem_ctx, uint32_t);
9099 if (r->out.count == NULL) {
9100 return NT_STATUS_NO_MEMORY;
9103 r->out.info = talloc_zero(mem_ctx, union spoolss_MonitorInfo *);
9104 if (r->out.info == NULL) {
9105 return NT_STATUS_NO_MEMORY;
9108 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9109 if (r->out.needed == NULL) {
9110 return NT_STATUS_NO_MEMORY;
9113 r->out.result = _spoolss_EnumMonitors(cli->pipes_struct, r);
9114 return NT_STATUS_OK;
9117 case NDR_SPOOLSS_ADDPORT: {
9118 struct spoolss_AddPort *r = (struct spoolss_AddPort *)_r;
9119 r->out.result = _spoolss_AddPort(cli->pipes_struct, r);
9120 return NT_STATUS_OK;
9123 case NDR_SPOOLSS_CONFIGUREPORT: {
9124 struct spoolss_ConfigurePort *r = (struct spoolss_ConfigurePort *)_r;
9125 r->out.result = _spoolss_ConfigurePort(cli->pipes_struct, r);
9126 return NT_STATUS_OK;
9129 case NDR_SPOOLSS_DELETEPORT: {
9130 struct spoolss_DeletePort *r = (struct spoolss_DeletePort *)_r;
9131 r->out.result = _spoolss_DeletePort(cli->pipes_struct, r);
9132 return NT_STATUS_OK;
9135 case NDR_SPOOLSS_CREATEPRINTERIC: {
9136 struct spoolss_CreatePrinterIC *r = (struct spoolss_CreatePrinterIC *)_r;
9137 ZERO_STRUCT(r->out);
9138 r->out.gdi_handle = talloc_zero(mem_ctx, struct policy_handle);
9139 if (r->out.gdi_handle == NULL) {
9140 return NT_STATUS_NO_MEMORY;
9143 r->out.result = _spoolss_CreatePrinterIC(cli->pipes_struct, r);
9144 return NT_STATUS_OK;
9147 case NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC: {
9148 struct spoolss_PlayGDIScriptOnPrinterIC *r = (struct spoolss_PlayGDIScriptOnPrinterIC *)_r;
9149 r->out.result = _spoolss_PlayGDIScriptOnPrinterIC(cli->pipes_struct, r);
9150 return NT_STATUS_OK;
9153 case NDR_SPOOLSS_DELETEPRINTERIC: {
9154 struct spoolss_DeletePrinterIC *r = (struct spoolss_DeletePrinterIC *)_r;
9155 ZERO_STRUCT(r->out);
9156 r->out.gdi_handle = r->in.gdi_handle;
9157 r->out.result = _spoolss_DeletePrinterIC(cli->pipes_struct, r);
9158 return NT_STATUS_OK;
9161 case NDR_SPOOLSS_ADDPRINTERCONNECTION: {
9162 struct spoolss_AddPrinterConnection *r = (struct spoolss_AddPrinterConnection *)_r;
9163 r->out.result = _spoolss_AddPrinterConnection(cli->pipes_struct, r);
9164 return NT_STATUS_OK;
9167 case NDR_SPOOLSS_DELETEPRINTERCONNECTION: {
9168 struct spoolss_DeletePrinterConnection *r = (struct spoolss_DeletePrinterConnection *)_r;
9169 r->out.result = _spoolss_DeletePrinterConnection(cli->pipes_struct, r);
9170 return NT_STATUS_OK;
9173 case NDR_SPOOLSS_PRINTERMESSAGEBOX: {
9174 struct spoolss_PrinterMessageBox *r = (struct spoolss_PrinterMessageBox *)_r;
9175 r->out.result = _spoolss_PrinterMessageBox(cli->pipes_struct, r);
9176 return NT_STATUS_OK;
9179 case NDR_SPOOLSS_ADDMONITOR: {
9180 struct spoolss_AddMonitor *r = (struct spoolss_AddMonitor *)_r;
9181 r->out.result = _spoolss_AddMonitor(cli->pipes_struct, r);
9182 return NT_STATUS_OK;
9185 case NDR_SPOOLSS_DELETEMONITOR: {
9186 struct spoolss_DeleteMonitor *r = (struct spoolss_DeleteMonitor *)_r;
9187 r->out.result = _spoolss_DeleteMonitor(cli->pipes_struct, r);
9188 return NT_STATUS_OK;
9191 case NDR_SPOOLSS_DELETEPRINTPROCESSOR: {
9192 struct spoolss_DeletePrintProcessor *r = (struct spoolss_DeletePrintProcessor *)_r;
9193 r->out.result = _spoolss_DeletePrintProcessor(cli->pipes_struct, r);
9194 return NT_STATUS_OK;
9197 case NDR_SPOOLSS_ADDPRINTPROVIDOR: {
9198 struct spoolss_AddPrintProvidor *r = (struct spoolss_AddPrintProvidor *)_r;
9199 r->out.result = _spoolss_AddPrintProvidor(cli->pipes_struct, r);
9200 return NT_STATUS_OK;
9203 case NDR_SPOOLSS_DELETEPRINTPROVIDOR: {
9204 struct spoolss_DeletePrintProvidor *r = (struct spoolss_DeletePrintProvidor *)_r;
9205 r->out.result = _spoolss_DeletePrintProvidor(cli->pipes_struct, r);
9206 return NT_STATUS_OK;
9209 case NDR_SPOOLSS_ENUMPRINTPROCDATATYPES: {
9210 struct spoolss_EnumPrintProcDataTypes *r = (struct spoolss_EnumPrintProcDataTypes *)_r;
9211 ZERO_STRUCT(r->out);
9212 r->out.count = talloc_zero(mem_ctx, uint32_t);
9213 if (r->out.count == NULL) {
9214 return NT_STATUS_NO_MEMORY;
9217 r->out.info = talloc_zero(mem_ctx, union spoolss_PrintProcDataTypesInfo *);
9218 if (r->out.info == NULL) {
9219 return NT_STATUS_NO_MEMORY;
9222 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9223 if (r->out.needed == NULL) {
9224 return NT_STATUS_NO_MEMORY;
9227 r->out.result = _spoolss_EnumPrintProcDataTypes(cli->pipes_struct, r);
9228 return NT_STATUS_OK;
9231 case NDR_SPOOLSS_RESETPRINTER: {
9232 struct spoolss_ResetPrinter *r = (struct spoolss_ResetPrinter *)_r;
9233 r->out.result = _spoolss_ResetPrinter(cli->pipes_struct, r);
9234 return NT_STATUS_OK;
9237 case NDR_SPOOLSS_GETPRINTERDRIVER2: {
9238 struct spoolss_GetPrinterDriver2 *r = (struct spoolss_GetPrinterDriver2 *)_r;
9239 ZERO_STRUCT(r->out);
9240 r->out.info = talloc_zero(mem_ctx, union spoolss_DriverInfo);
9241 if (r->out.info == NULL) {
9242 return NT_STATUS_NO_MEMORY;
9245 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9246 if (r->out.needed == NULL) {
9247 return NT_STATUS_NO_MEMORY;
9250 r->out.server_major_version = talloc_zero(mem_ctx, uint32_t);
9251 if (r->out.server_major_version == NULL) {
9252 return NT_STATUS_NO_MEMORY;
9255 r->out.server_minor_version = talloc_zero(mem_ctx, uint32_t);
9256 if (r->out.server_minor_version == NULL) {
9257 return NT_STATUS_NO_MEMORY;
9260 r->out.result = _spoolss_GetPrinterDriver2(cli->pipes_struct, r);
9261 return NT_STATUS_OK;
9264 case NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION: {
9265 struct spoolss_FindFirstPrinterChangeNotification *r = (struct spoolss_FindFirstPrinterChangeNotification *)_r;
9266 r->out.result = _spoolss_FindFirstPrinterChangeNotification(cli->pipes_struct, r);
9267 return NT_STATUS_OK;
9270 case NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION: {
9271 struct spoolss_FindNextPrinterChangeNotification *r = (struct spoolss_FindNextPrinterChangeNotification *)_r;
9272 r->out.result = _spoolss_FindNextPrinterChangeNotification(cli->pipes_struct, r);
9273 return NT_STATUS_OK;
9276 case NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY: {
9277 struct spoolss_FindClosePrinterNotify *r = (struct spoolss_FindClosePrinterNotify *)_r;
9278 r->out.result = _spoolss_FindClosePrinterNotify(cli->pipes_struct, r);
9279 return NT_STATUS_OK;
9282 case NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD: {
9283 struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r = (struct spoolss_RouterFindFirstPrinterChangeNotificationOld *)_r;
9284 r->out.result = _spoolss_RouterFindFirstPrinterChangeNotificationOld(cli->pipes_struct, r);
9285 return NT_STATUS_OK;
9288 case NDR_SPOOLSS_REPLYOPENPRINTER: {
9289 struct spoolss_ReplyOpenPrinter *r = (struct spoolss_ReplyOpenPrinter *)_r;
9290 ZERO_STRUCT(r->out);
9291 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
9292 if (r->out.handle == NULL) {
9293 return NT_STATUS_NO_MEMORY;
9296 r->out.result = _spoolss_ReplyOpenPrinter(cli->pipes_struct, r);
9297 return NT_STATUS_OK;
9300 case NDR_SPOOLSS_ROUTERREPLYPRINTER: {
9301 struct spoolss_RouterReplyPrinter *r = (struct spoolss_RouterReplyPrinter *)_r;
9302 r->out.result = _spoolss_RouterReplyPrinter(cli->pipes_struct, r);
9303 return NT_STATUS_OK;
9306 case NDR_SPOOLSS_REPLYCLOSEPRINTER: {
9307 struct spoolss_ReplyClosePrinter *r = (struct spoolss_ReplyClosePrinter *)_r;
9308 ZERO_STRUCT(r->out);
9309 r->out.handle = r->in.handle;
9310 r->out.result = _spoolss_ReplyClosePrinter(cli->pipes_struct, r);
9311 return NT_STATUS_OK;
9314 case NDR_SPOOLSS_ADDPORTEX: {
9315 struct spoolss_AddPortEx *r = (struct spoolss_AddPortEx *)_r;
9316 r->out.result = _spoolss_AddPortEx(cli->pipes_struct, r);
9317 return NT_STATUS_OK;
9320 case NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION: {
9321 struct spoolss_RouterFindFirstPrinterChangeNotification *r = (struct spoolss_RouterFindFirstPrinterChangeNotification *)_r;
9322 r->out.result = _spoolss_RouterFindFirstPrinterChangeNotification(cli->pipes_struct, r);
9323 return NT_STATUS_OK;
9326 case NDR_SPOOLSS_SPOOLERINIT: {
9327 struct spoolss_SpoolerInit *r = (struct spoolss_SpoolerInit *)_r;
9328 r->out.result = _spoolss_SpoolerInit(cli->pipes_struct, r);
9329 return NT_STATUS_OK;
9332 case NDR_SPOOLSS_RESETPRINTEREX: {
9333 struct spoolss_ResetPrinterEx *r = (struct spoolss_ResetPrinterEx *)_r;
9334 r->out.result = _spoolss_ResetPrinterEx(cli->pipes_struct, r);
9335 return NT_STATUS_OK;
9338 case NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX: {
9339 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r = (struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *)_r;
9340 r->out.result = _spoolss_RemoteFindFirstPrinterChangeNotifyEx(cli->pipes_struct, r);
9341 return NT_STATUS_OK;
9344 case NDR_SPOOLSS_ROUTERREPLYPRINTEREX: {
9345 struct spoolss_RouterReplyPrinterEx *r = (struct spoolss_RouterReplyPrinterEx *)_r;
9346 ZERO_STRUCT(r->out);
9347 r->out.reply_result = talloc_zero(mem_ctx, uint32_t);
9348 if (r->out.reply_result == NULL) {
9349 return NT_STATUS_NO_MEMORY;
9352 r->out.result = _spoolss_RouterReplyPrinterEx(cli->pipes_struct, r);
9353 return NT_STATUS_OK;
9356 case NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY: {
9357 struct spoolss_RouterRefreshPrinterChangeNotify *r = (struct spoolss_RouterRefreshPrinterChangeNotify *)_r;
9358 ZERO_STRUCT(r->out);
9359 r->out.info = talloc_zero(mem_ctx, struct spoolss_NotifyInfo *);
9360 if (r->out.info == NULL) {
9361 return NT_STATUS_NO_MEMORY;
9364 r->out.result = _spoolss_RouterRefreshPrinterChangeNotify(cli->pipes_struct, r);
9365 return NT_STATUS_OK;
9368 case NDR_SPOOLSS_44: {
9369 struct spoolss_44 *r = (struct spoolss_44 *)_r;
9370 r->out.result = _spoolss_44(cli->pipes_struct, r);
9371 return NT_STATUS_OK;
9374 case NDR_SPOOLSS_OPENPRINTEREX: {
9375 struct spoolss_OpenPrinterEx *r = (struct spoolss_OpenPrinterEx *)_r;
9376 ZERO_STRUCT(r->out);
9377 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
9378 if (r->out.handle == NULL) {
9379 return NT_STATUS_NO_MEMORY;
9382 r->out.result = _spoolss_OpenPrinterEx(cli->pipes_struct, r);
9383 return NT_STATUS_OK;
9386 case NDR_SPOOLSS_ADDPRINTEREX: {
9387 struct spoolss_AddPrinterEx *r = (struct spoolss_AddPrinterEx *)_r;
9388 ZERO_STRUCT(r->out);
9389 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
9390 if (r->out.handle == NULL) {
9391 return NT_STATUS_NO_MEMORY;
9394 r->out.result = _spoolss_AddPrinterEx(cli->pipes_struct, r);
9395 return NT_STATUS_OK;
9398 case NDR_SPOOLSS_47: {
9399 struct spoolss_47 *r = (struct spoolss_47 *)_r;
9400 r->out.result = _spoolss_47(cli->pipes_struct, r);
9401 return NT_STATUS_OK;
9404 case NDR_SPOOLSS_ENUMPRINTERDATA: {
9405 struct spoolss_EnumPrinterData *r = (struct spoolss_EnumPrinterData *)_r;
9406 ZERO_STRUCT(r->out);
9407 r->out.value_name = talloc_zero_array(mem_ctx, const char, r->in.value_offered / 2);
9408 if (r->out.value_name == NULL) {
9409 return NT_STATUS_NO_MEMORY;
9412 r->out.value_needed = talloc_zero(mem_ctx, uint32_t);
9413 if (r->out.value_needed == NULL) {
9414 return NT_STATUS_NO_MEMORY;
9417 r->out.type = talloc_zero(mem_ctx, enum winreg_Type);
9418 if (r->out.type == NULL) {
9419 return NT_STATUS_NO_MEMORY;
9422 r->out.data = talloc_zero_array(mem_ctx, uint8_t, r->in.data_offered);
9423 if (r->out.data == NULL) {
9424 return NT_STATUS_NO_MEMORY;
9427 r->out.data_needed = talloc_zero(mem_ctx, uint32_t);
9428 if (r->out.data_needed == NULL) {
9429 return NT_STATUS_NO_MEMORY;
9432 r->out.result = _spoolss_EnumPrinterData(cli->pipes_struct, r);
9433 return NT_STATUS_OK;
9436 case NDR_SPOOLSS_DELETEPRINTERDATA: {
9437 struct spoolss_DeletePrinterData *r = (struct spoolss_DeletePrinterData *)_r;
9438 r->out.result = _spoolss_DeletePrinterData(cli->pipes_struct, r);
9439 return NT_STATUS_OK;
9442 case NDR_SPOOLSS_4A: {
9443 struct spoolss_4a *r = (struct spoolss_4a *)_r;
9444 r->out.result = _spoolss_4a(cli->pipes_struct, r);
9445 return NT_STATUS_OK;
9448 case NDR_SPOOLSS_4B: {
9449 struct spoolss_4b *r = (struct spoolss_4b *)_r;
9450 r->out.result = _spoolss_4b(cli->pipes_struct, r);
9451 return NT_STATUS_OK;
9454 case NDR_SPOOLSS_4C: {
9455 struct spoolss_4c *r = (struct spoolss_4c *)_r;
9456 r->out.result = _spoolss_4c(cli->pipes_struct, r);
9457 return NT_STATUS_OK;
9460 case NDR_SPOOLSS_SETPRINTERDATAEX: {
9461 struct spoolss_SetPrinterDataEx *r = (struct spoolss_SetPrinterDataEx *)_r;
9462 r->out.result = _spoolss_SetPrinterDataEx(cli->pipes_struct, r);
9463 return NT_STATUS_OK;
9466 case NDR_SPOOLSS_GETPRINTERDATAEX: {
9467 struct spoolss_GetPrinterDataEx *r = (struct spoolss_GetPrinterDataEx *)_r;
9468 ZERO_STRUCT(r->out);
9469 r->out.type = talloc_zero(mem_ctx, enum winreg_Type);
9470 if (r->out.type == NULL) {
9471 return NT_STATUS_NO_MEMORY;
9474 r->out.data = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
9475 if (r->out.data == NULL) {
9476 return NT_STATUS_NO_MEMORY;
9479 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9480 if (r->out.needed == NULL) {
9481 return NT_STATUS_NO_MEMORY;
9484 r->out.result = _spoolss_GetPrinterDataEx(cli->pipes_struct, r);
9485 return NT_STATUS_OK;
9488 case NDR_SPOOLSS_ENUMPRINTERDATAEX: {
9489 struct spoolss_EnumPrinterDataEx *r = (struct spoolss_EnumPrinterDataEx *)_r;
9490 ZERO_STRUCT(r->out);
9491 r->out.count = talloc_zero(mem_ctx, uint32_t);
9492 if (r->out.count == NULL) {
9493 return NT_STATUS_NO_MEMORY;
9496 r->out.info = talloc_zero(mem_ctx, struct spoolss_PrinterEnumValues *);
9497 if (r->out.info == NULL) {
9498 return NT_STATUS_NO_MEMORY;
9501 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9502 if (r->out.needed == NULL) {
9503 return NT_STATUS_NO_MEMORY;
9506 r->out.result = _spoolss_EnumPrinterDataEx(cli->pipes_struct, r);
9507 return NT_STATUS_OK;
9510 case NDR_SPOOLSS_ENUMPRINTERKEY: {
9511 struct spoolss_EnumPrinterKey *r = (struct spoolss_EnumPrinterKey *)_r;
9512 ZERO_STRUCT(r->out);
9513 r->out._ndr_size = talloc_zero(mem_ctx, uint32_t);
9514 if (r->out._ndr_size == NULL) {
9515 return NT_STATUS_NO_MEMORY;
9518 r->out.key_buffer = talloc_zero(mem_ctx, union spoolss_KeyNames);
9519 if (r->out.key_buffer == NULL) {
9520 return NT_STATUS_NO_MEMORY;
9523 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9524 if (r->out.needed == NULL) {
9525 return NT_STATUS_NO_MEMORY;
9528 r->out.result = _spoolss_EnumPrinterKey(cli->pipes_struct, r);
9529 return NT_STATUS_OK;
9532 case NDR_SPOOLSS_DELETEPRINTERDATAEX: {
9533 struct spoolss_DeletePrinterDataEx *r = (struct spoolss_DeletePrinterDataEx *)_r;
9534 r->out.result = _spoolss_DeletePrinterDataEx(cli->pipes_struct, r);
9535 return NT_STATUS_OK;
9538 case NDR_SPOOLSS_DELETEPRINTERKEY: {
9539 struct spoolss_DeletePrinterKey *r = (struct spoolss_DeletePrinterKey *)_r;
9540 r->out.result = _spoolss_DeletePrinterKey(cli->pipes_struct, r);
9541 return NT_STATUS_OK;
9544 case NDR_SPOOLSS_53: {
9545 struct spoolss_53 *r = (struct spoolss_53 *)_r;
9546 r->out.result = _spoolss_53(cli->pipes_struct, r);
9547 return NT_STATUS_OK;
9550 case NDR_SPOOLSS_DELETEPRINTERDRIVEREX: {
9551 struct spoolss_DeletePrinterDriverEx *r = (struct spoolss_DeletePrinterDriverEx *)_r;
9552 r->out.result = _spoolss_DeletePrinterDriverEx(cli->pipes_struct, r);
9553 return NT_STATUS_OK;
9556 case NDR_SPOOLSS_55: {
9557 struct spoolss_55 *r = (struct spoolss_55 *)_r;
9558 r->out.result = _spoolss_55(cli->pipes_struct, r);
9559 return NT_STATUS_OK;
9562 case NDR_SPOOLSS_56: {
9563 struct spoolss_56 *r = (struct spoolss_56 *)_r;
9564 r->out.result = _spoolss_56(cli->pipes_struct, r);
9565 return NT_STATUS_OK;
9568 case NDR_SPOOLSS_57: {
9569 struct spoolss_57 *r = (struct spoolss_57 *)_r;
9570 r->out.result = _spoolss_57(cli->pipes_struct, r);
9571 return NT_STATUS_OK;
9574 case NDR_SPOOLSS_XCVDATA: {
9575 struct spoolss_XcvData *r = (struct spoolss_XcvData *)_r;
9576 ZERO_STRUCT(r->out);
9577 r->out.status_code = r->in.status_code;
9578 r->out.out_data = talloc_zero_array(mem_ctx, uint8_t, r->in.out_data_size);
9579 if (r->out.out_data == NULL) {
9580 return NT_STATUS_NO_MEMORY;
9583 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9584 if (r->out.needed == NULL) {
9585 return NT_STATUS_NO_MEMORY;
9588 r->out.result = _spoolss_XcvData(cli->pipes_struct, r);
9589 return NT_STATUS_OK;
9592 case NDR_SPOOLSS_ADDPRINTERDRIVEREX: {
9593 struct spoolss_AddPrinterDriverEx *r = (struct spoolss_AddPrinterDriverEx *)_r;
9594 r->out.result = _spoolss_AddPrinterDriverEx(cli->pipes_struct, r);
9595 return NT_STATUS_OK;
9598 case NDR_SPOOLSS_5A: {
9599 struct spoolss_5a *r = (struct spoolss_5a *)_r;
9600 r->out.result = _spoolss_5a(cli->pipes_struct, r);
9601 return NT_STATUS_OK;
9604 case NDR_SPOOLSS_5B: {
9605 struct spoolss_5b *r = (struct spoolss_5b *)_r;
9606 r->out.result = _spoolss_5b(cli->pipes_struct, r);
9607 return NT_STATUS_OK;
9610 case NDR_SPOOLSS_5C: {
9611 struct spoolss_5c *r = (struct spoolss_5c *)_r;
9612 r->out.result = _spoolss_5c(cli->pipes_struct, r);
9613 return NT_STATUS_OK;
9616 case NDR_SPOOLSS_5D: {
9617 struct spoolss_5d *r = (struct spoolss_5d *)_r;
9618 r->out.result = _spoolss_5d(cli->pipes_struct, r);
9619 return NT_STATUS_OK;
9622 case NDR_SPOOLSS_5E: {
9623 struct spoolss_5e *r = (struct spoolss_5e *)_r;
9624 r->out.result = _spoolss_5e(cli->pipes_struct, r);
9625 return NT_STATUS_OK;
9628 case NDR_SPOOLSS_5F: {
9629 struct spoolss_5f *r = (struct spoolss_5f *)_r;
9630 r->out.result = _spoolss_5f(cli->pipes_struct, r);
9631 return NT_STATUS_OK;
9634 case NDR_SPOOLSS_60: {
9635 struct spoolss_60 *r = (struct spoolss_60 *)_r;
9636 r->out.result = _spoolss_60(cli->pipes_struct, r);
9637 return NT_STATUS_OK;
9640 case NDR_SPOOLSS_61: {
9641 struct spoolss_61 *r = (struct spoolss_61 *)_r;
9642 r->out.result = _spoolss_61(cli->pipes_struct, r);
9643 return NT_STATUS_OK;
9646 case NDR_SPOOLSS_62: {
9647 struct spoolss_62 *r = (struct spoolss_62 *)_r;
9648 r->out.result = _spoolss_62(cli->pipes_struct, r);
9649 return NT_STATUS_OK;
9652 case NDR_SPOOLSS_63: {
9653 struct spoolss_63 *r = (struct spoolss_63 *)_r;
9654 r->out.result = _spoolss_63(cli->pipes_struct, r);
9655 return NT_STATUS_OK;
9658 case NDR_SPOOLSS_64: {
9659 struct spoolss_64 *r = (struct spoolss_64 *)_r;
9660 r->out.result = _spoolss_64(cli->pipes_struct, r);
9661 return NT_STATUS_OK;
9664 case NDR_SPOOLSS_65: {
9665 struct spoolss_65 *r = (struct spoolss_65 *)_r;
9666 r->out.result = _spoolss_65(cli->pipes_struct, r);
9667 return NT_STATUS_OK;
9670 case NDR_SPOOLSS_GETCOREPRINTERDRIVERS: {
9671 struct spoolss_GetCorePrinterDrivers *r = (struct spoolss_GetCorePrinterDrivers *)_r;
9672 ZERO_STRUCT(r->out);
9673 r->out.core_printer_drivers = talloc_zero_array(mem_ctx, struct spoolss_CorePrinterDriver, r->in.core_printer_driver_count);
9674 if (r->out.core_printer_drivers == NULL) {
9675 return NT_STATUS_NO_MEMORY;
9678 r->out.result = _spoolss_GetCorePrinterDrivers(cli->pipes_struct, r);
9679 return NT_STATUS_OK;
9682 case NDR_SPOOLSS_67: {
9683 struct spoolss_67 *r = (struct spoolss_67 *)_r;
9684 r->out.result = _spoolss_67(cli->pipes_struct, r);
9685 return NT_STATUS_OK;
9688 case NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH: {
9689 struct spoolss_GetPrinterDriverPackagePath *r = (struct spoolss_GetPrinterDriverPackagePath *)_r;
9690 ZERO_STRUCT(r->out);
9691 r->out.driver_package_cab = r->in.driver_package_cab;
9692 r->out.required = talloc_zero(mem_ctx, uint32_t);
9693 if (r->out.required == NULL) {
9694 return NT_STATUS_NO_MEMORY;
9697 r->out.result = _spoolss_GetPrinterDriverPackagePath(cli->pipes_struct, r);
9698 return NT_STATUS_OK;
9701 case NDR_SPOOLSS_69: {
9702 struct spoolss_69 *r = (struct spoolss_69 *)_r;
9703 r->out.result = _spoolss_69(cli->pipes_struct, r);
9704 return NT_STATUS_OK;
9707 case NDR_SPOOLSS_6A: {
9708 struct spoolss_6a *r = (struct spoolss_6a *)_r;
9709 r->out.result = _spoolss_6a(cli->pipes_struct, r);
9710 return NT_STATUS_OK;
9713 case NDR_SPOOLSS_6B: {
9714 struct spoolss_6b *r = (struct spoolss_6b *)_r;
9715 r->out.result = _spoolss_6b(cli->pipes_struct, r);
9716 return NT_STATUS_OK;
9719 case NDR_SPOOLSS_6C: {
9720 struct spoolss_6c *r = (struct spoolss_6c *)_r;
9721 r->out.result = _spoolss_6c(cli->pipes_struct, r);
9722 return NT_STATUS_OK;
9725 case NDR_SPOOLSS_6D: {
9726 struct spoolss_6d *r = (struct spoolss_6d *)_r;
9727 r->out.result = _spoolss_6d(cli->pipes_struct, r);
9728 return NT_STATUS_OK;
9732 return NT_STATUS_NOT_IMPLEMENTED;
9736 NTSTATUS rpc_spoolss_init(void)
9738 return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "spoolss", "spoolss", &ndr_table_spoolss, api_spoolss_cmds, sizeof(api_spoolss_cmds) / sizeof(struct api_struct));