source: branches/samba-3.5.x/librpc/gen_ndr/srv_spoolss.c

Last change on this file was 429, checked in by Silvan Scherrer, 15 years ago

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