?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libds: fixed spelling error
[Samba/cd1.git] / librpc / gen_ndr / srv_spoolss.c
blobc3266dc5af3ae89b5521743dde42d11229e5c924
1 /*
2 * Unix SMB/CIFS implementation.
3 * server auto-generated by pidl. DO NOT MODIFY!
4 */
5
6 #include "includes.h"
7 #include "../librpc/gen_ndr/srv_spoolss.h"
8
9 static bool api_spoolss_EnumPrinters(pipes_struct *p)
10 {
11 const struct ndr_interface_call *call;
12 struct ndr_pull *pull;
13 struct ndr_push *push;
14 enum ndr_err_code ndr_err;
15 DATA_BLOB blob;
16 struct spoolss_EnumPrinters *r;
17
18 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMPRINTERS];
19
20 r = talloc(talloc_tos(), struct spoolss_EnumPrinters);
21 if (r == NULL) {
22 return false;
23 }
24
25 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
26 talloc_free(r);
27 return false;
28 }
29
30 pull = ndr_pull_init_blob(&blob, r, NULL);
31 if (pull == NULL) {
32 talloc_free(r);
33 return false;
34 }
35
36 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
37 ndr_err = call->ndr_pull(pull, NDR_IN, r);
38 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
39 talloc_free(r);
40 return false;
41 }
42
43 if (DEBUGLEVEL >= 10) {
44 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinters, r);
45 }
46
47 ZERO_STRUCT(r->out);
48 r->out.count = talloc_zero(r, uint32_t);
49 if (r->out.count == NULL) {
50 talloc_free(r);
51 return false;
52 }
53
54 r->out.info = talloc_zero(r, union spoolss_PrinterInfo *);
55 if (r->out.info == NULL) {
56 talloc_free(r);
57 return false;
58 }
59
60 r->out.needed = talloc_zero(r, uint32_t);
61 if (r->out.needed == NULL) {
62 talloc_free(r);
63 return false;
64 }
65
66 r->out.result = _spoolss_EnumPrinters(p, r);
67
68 if (p->rng_fault_state) {
69 talloc_free(r);
70 /* Return true here, srv_pipe_hnd.c will take care */
71 return true;
72 }
73
74 if (DEBUGLEVEL >= 10) {
75 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinters, r);
76 }
77
78 push = ndr_push_init_ctx(r, NULL);
79 if (push == NULL) {
80 talloc_free(r);
81 return false;
82 }
83
84 ndr_err = call->ndr_push(push, NDR_OUT, r);
85 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
86 talloc_free(r);
87 return false;
88 }
89
90 blob = ndr_push_blob(push);
91 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
92 talloc_free(r);
93 return false;
94 }
95
96 talloc_free(r);
97
98 return true;
99 }
100
101 static bool api_spoolss_OpenPrinter(pipes_struct *p)
102 {
103 const struct ndr_interface_call *call;
104 struct ndr_pull *pull;
105 struct ndr_push *push;
106 enum ndr_err_code ndr_err;
107 DATA_BLOB blob;
108 struct spoolss_OpenPrinter *r;
109
110 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_OPENPRINTER];
111
112 r = talloc(talloc_tos(), struct spoolss_OpenPrinter);
113 if (r == NULL) {
114 return false;
115 }
116
117 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
118 talloc_free(r);
119 return false;
120 }
121
122 pull = ndr_pull_init_blob(&blob, r, NULL);
123 if (pull == NULL) {
124 talloc_free(r);
125 return false;
126 }
127
128 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
129 ndr_err = call->ndr_pull(pull, NDR_IN, r);
130 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
131 talloc_free(r);
132 return false;
133 }
134
135 if (DEBUGLEVEL >= 10) {
136 NDR_PRINT_IN_DEBUG(spoolss_OpenPrinter, r);
137 }
138
139 ZERO_STRUCT(r->out);
140 r->out.handle = talloc_zero(r, struct policy_handle);
141 if (r->out.handle == NULL) {
142 talloc_free(r);
143 return false;
144 }
145
146 r->out.result = _spoolss_OpenPrinter(p, r);
147
148 if (p->rng_fault_state) {
149 talloc_free(r);
150 /* Return true here, srv_pipe_hnd.c will take care */
151 return true;
152 }
153
154 if (DEBUGLEVEL >= 10) {
155 NDR_PRINT_OUT_DEBUG(spoolss_OpenPrinter, r);
156 }
157
158 push = ndr_push_init_ctx(r, NULL);
159 if (push == NULL) {
160 talloc_free(r);
161 return false;
162 }
163
164 ndr_err = call->ndr_push(push, NDR_OUT, r);
165 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
166 talloc_free(r);
167 return false;
168 }
169
170 blob = ndr_push_blob(push);
171 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
172 talloc_free(r);
173 return false;
174 }
175
176 talloc_free(r);
177
178 return true;
179 }
180
181 static bool api_spoolss_SetJob(pipes_struct *p)
182 {
183 const struct ndr_interface_call *call;
184 struct ndr_pull *pull;
185 struct ndr_push *push;
186 enum ndr_err_code ndr_err;
187 DATA_BLOB blob;
188 struct spoolss_SetJob *r;
189
190 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_SETJOB];
191
192 r = talloc(talloc_tos(), struct spoolss_SetJob);
193 if (r == NULL) {
194 return false;
195 }
196
197 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
198 talloc_free(r);
199 return false;
200 }
201
202 pull = ndr_pull_init_blob(&blob, r, NULL);
203 if (pull == NULL) {
204 talloc_free(r);
205 return false;
206 }
207
208 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
209 ndr_err = call->ndr_pull(pull, NDR_IN, r);
210 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
211 talloc_free(r);
212 return false;
213 }
214
215 if (DEBUGLEVEL >= 10) {
216 NDR_PRINT_IN_DEBUG(spoolss_SetJob, r);
217 }
218
219 r->out.result = _spoolss_SetJob(p, r);
220
221 if (p->rng_fault_state) {
222 talloc_free(r);
223 /* Return true here, srv_pipe_hnd.c will take care */
224 return true;
225 }
226
227 if (DEBUGLEVEL >= 10) {
228 NDR_PRINT_OUT_DEBUG(spoolss_SetJob, r);
229 }
230
231 push = ndr_push_init_ctx(r, NULL);
232 if (push == NULL) {
233 talloc_free(r);
234 return false;
235 }
236
237 ndr_err = call->ndr_push(push, NDR_OUT, r);
238 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
239 talloc_free(r);
240 return false;
241 }
242
243 blob = ndr_push_blob(push);
244 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
245 talloc_free(r);
246 return false;
247 }
248
249 talloc_free(r);
250
251 return true;
252 }
253
254 static bool api_spoolss_GetJob(pipes_struct *p)
255 {
256 const struct ndr_interface_call *call;
257 struct ndr_pull *pull;
258 struct ndr_push *push;
259 enum ndr_err_code ndr_err;
260 DATA_BLOB blob;
261 struct spoolss_GetJob *r;
262
263 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETJOB];
264
265 r = talloc(talloc_tos(), struct spoolss_GetJob);
266 if (r == NULL) {
267 return false;
268 }
269
270 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
271 talloc_free(r);
272 return false;
273 }
274
275 pull = ndr_pull_init_blob(&blob, r, NULL);
276 if (pull == NULL) {
277 talloc_free(r);
278 return false;
279 }
280
281 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
282 ndr_err = call->ndr_pull(pull, NDR_IN, r);
283 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
284 talloc_free(r);
285 return false;
286 }
287
288 if (DEBUGLEVEL >= 10) {
289 NDR_PRINT_IN_DEBUG(spoolss_GetJob, r);
290 }
291
292 ZERO_STRUCT(r->out);
293 r->out.info = talloc_zero(r, union spoolss_JobInfo);
294 if (r->out.info == NULL) {
295 talloc_free(r);
296 return false;
297 }
298
299 r->out.needed = talloc_zero(r, uint32_t);
300 if (r->out.needed == NULL) {
301 talloc_free(r);
302 return false;
303 }
304
305 r->out.result = _spoolss_GetJob(p, r);
306
307 if (p->rng_fault_state) {
308 talloc_free(r);
309 /* Return true here, srv_pipe_hnd.c will take care */
310 return true;
311 }
312
313 if (DEBUGLEVEL >= 10) {
314 NDR_PRINT_OUT_DEBUG(spoolss_GetJob, r);
315 }
316
317 push = ndr_push_init_ctx(r, NULL);
318 if (push == NULL) {
319 talloc_free(r);
320 return false;
321 }
322
323 ndr_err = call->ndr_push(push, NDR_OUT, r);
324 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
325 talloc_free(r);
326 return false;
327 }
328
329 blob = ndr_push_blob(push);
330 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
331 talloc_free(r);
332 return false;
333 }
334
335 talloc_free(r);
336
337 return true;
338 }
339
340 static bool api_spoolss_EnumJobs(pipes_struct *p)
341 {
342 const struct ndr_interface_call *call;
343 struct ndr_pull *pull;
344 struct ndr_push *push;
345 enum ndr_err_code ndr_err;
346 DATA_BLOB blob;
347 struct spoolss_EnumJobs *r;
348
349 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ENUMJOBS];
350
351 r = talloc(talloc_tos(), struct spoolss_EnumJobs);
352 if (r == NULL) {
353 return false;
354 }
355
356 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
357 talloc_free(r);
358 return false;
359 }
360
361 pull = ndr_pull_init_blob(&blob, r, NULL);
362 if (pull == NULL) {
363 talloc_free(r);
364 return false;
365 }
366
367 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
368 ndr_err = call->ndr_pull(pull, NDR_IN, r);
369 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
370 talloc_free(r);
371 return false;
372 }
373
374 if (DEBUGLEVEL >= 10) {
375 NDR_PRINT_IN_DEBUG(spoolss_EnumJobs, r);
376 }
377
378 ZERO_STRUCT(r->out);
379 r->out.count = talloc_zero(r, uint32_t);
380 if (r->out.count == NULL) {
381 talloc_free(r);
382 return false;
383 }
384
385 r->out.info = talloc_zero(r, union spoolss_JobInfo *);
386 if (r->out.info == NULL) {
387 talloc_free(r);
388 return false;
389 }
390
391 r->out.needed = talloc_zero(r, uint32_t);
392 if (r->out.needed == NULL) {
393 talloc_free(r);
394 return false;
395 }
396
397 r->out.result = _spoolss_EnumJobs(p, r);
398
399 if (p->rng_fault_state) {
400 talloc_free(r);
401 /* Return true here, srv_pipe_hnd.c will take care */
402 return true;
403 }
404
405 if (DEBUGLEVEL >= 10) {
406 NDR_PRINT_OUT_DEBUG(spoolss_EnumJobs, r);
407 }
408
409 push = ndr_push_init_ctx(r, NULL);
410 if (push == NULL) {
411 talloc_free(r);
412 return false;
413 }
414
415 ndr_err = call->ndr_push(push, NDR_OUT, r);
416 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
417 talloc_free(r);
418 return false;
419 }
420
421 blob = ndr_push_blob(push);
422 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
423 talloc_free(r);
424 return false;
425 }
426
427 talloc_free(r);
428
429 return true;
430 }
431
432 static bool api_spoolss_AddPrinter(pipes_struct *p)
433 {
434 const struct ndr_interface_call *call;
435 struct ndr_pull *pull;
436 struct ndr_push *push;
437 enum ndr_err_code ndr_err;
438 DATA_BLOB blob;
439 struct spoolss_AddPrinter *r;
440
441 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTER];
442
443 r = talloc(talloc_tos(), struct spoolss_AddPrinter);
444 if (r == NULL) {
445 return false;
446 }
447
448 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
449 talloc_free(r);
450 return false;
451 }
452
453 pull = ndr_pull_init_blob(&blob, r, NULL);
454 if (pull == NULL) {
455 talloc_free(r);
456 return false;
457 }
458
459 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
460 ndr_err = call->ndr_pull(pull, NDR_IN, r);
461 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
462 talloc_free(r);
463 return false;
464 }
465
466 if (DEBUGLEVEL >= 10) {
467 NDR_PRINT_IN_DEBUG(spoolss_AddPrinter, r);
468 }
469
470 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
512 static 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
585 static 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
658 static 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
744 static 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
817 static 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
909 static 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
995 static 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
1081 static 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
1154 static 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
1227 static 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
1319 static 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
1405 static 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
1485 static 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
1558 static 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
1638 static 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
1711 static 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
1784 static 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
1870 static 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
1943 static 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
2024 static 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
2097 static 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(r, union spoolss_PrinterData);
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
2189 static 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
2262 static 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
2335 static 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
2410 static 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
2483 static 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
2556 static 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
2642 static 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
2715 static 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
2807 static 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
2899 static 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
2991 static 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
3064 static 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
3137 static 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
3210 static 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
3290 static 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
3363 static 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
3438 static 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
3511 static 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
3584 static 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
3657 static 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
3730 static 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
3803 static 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
3876 static 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
3949 static 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
4022 static 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
4114 static 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
4187 static 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
4285 static 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
4358 static 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
4431 static 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
4504 static 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
4577 static 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
4657 static 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
4730 static 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
4805 static 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
4878 static 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
4951 static 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
5024 static 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
5097 static 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
5170 static 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
5250 static 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
5330 static 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
5403 static 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
5483 static 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
5563 static 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
5636 static 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
5740 static 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
5813 static 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
5886 static 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
5959 static 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
6032 static 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
6105 static 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.buffer = talloc_zero_array(r, uint8_t, r->in.offered);
6151 if (r->out.buffer == 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
6197 static 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
6289 static 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.key_buffer = talloc_zero(r, const char **);
6329 if (r->out.key_buffer == NULL) {
6330 talloc_free(r);
6331 return false;
6332 }
6333
6334 r->out.needed = talloc_zero(r, uint32_t);
6335 if (r->out.needed == NULL) {
6336 talloc_free(r);
6337 return false;
6338 }
6339
6340 r->out.result = _spoolss_EnumPrinterKey(p, r);
6341
6342 if (p->rng_fault_state) {
6343 talloc_free(r);
6344 /* Return true here, srv_pipe_hnd.c will take care */
6345 return true;
6346 }
6347
6348 if (DEBUGLEVEL >= 10) {
6349 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterKey, r);
6350 }
6351
6352 push = ndr_push_init_ctx(r, NULL);
6353 if (push == NULL) {
6354 talloc_free(r);
6355 return false;
6356 }
6357
6358 ndr_err = call->ndr_push(push, NDR_OUT, r);
6359 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6360 talloc_free(r);
6361 return false;
6362 }
6363
6364 blob = ndr_push_blob(push);
6365 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6366 talloc_free(r);
6367 return false;
6368 }
6369
6370 talloc_free(r);
6371
6372 return true;
6373 }
6374
6375 static bool api_spoolss_DeletePrinterDataEx(pipes_struct *p)
6376 {
6377 const struct ndr_interface_call *call;
6378 struct ndr_pull *pull;
6379 struct ndr_push *push;
6380 enum ndr_err_code ndr_err;
6381 DATA_BLOB blob;
6382 struct spoolss_DeletePrinterDataEx *r;
6383
6384 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERDATAEX];
6385
6386 r = talloc(talloc_tos(), struct spoolss_DeletePrinterDataEx);
6387 if (r == NULL) {
6388 return false;
6389 }
6390
6391 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6392 talloc_free(r);
6393 return false;
6394 }
6395
6396 pull = ndr_pull_init_blob(&blob, r, NULL);
6397 if (pull == NULL) {
6398 talloc_free(r);
6399 return false;
6400 }
6401
6402 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6403 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6404 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6405 talloc_free(r);
6406 return false;
6407 }
6408
6409 if (DEBUGLEVEL >= 10) {
6410 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDataEx, r);
6411 }
6412
6413 r->out.result = _spoolss_DeletePrinterDataEx(p, r);
6414
6415 if (p->rng_fault_state) {
6416 talloc_free(r);
6417 /* Return true here, srv_pipe_hnd.c will take care */
6418 return true;
6419 }
6420
6421 if (DEBUGLEVEL >= 10) {
6422 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDataEx, r);
6423 }
6424
6425 push = ndr_push_init_ctx(r, NULL);
6426 if (push == NULL) {
6427 talloc_free(r);
6428 return false;
6429 }
6430
6431 ndr_err = call->ndr_push(push, NDR_OUT, r);
6432 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6433 talloc_free(r);
6434 return false;
6435 }
6436
6437 blob = ndr_push_blob(push);
6438 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6439 talloc_free(r);
6440 return false;
6441 }
6442
6443 talloc_free(r);
6444
6445 return true;
6446 }
6447
6448 static bool api_spoolss_DeletePrinterKey(pipes_struct *p)
6449 {
6450 const struct ndr_interface_call *call;
6451 struct ndr_pull *pull;
6452 struct ndr_push *push;
6453 enum ndr_err_code ndr_err;
6454 DATA_BLOB blob;
6455 struct spoolss_DeletePrinterKey *r;
6456
6457 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERKEY];
6458
6459 r = talloc(talloc_tos(), struct spoolss_DeletePrinterKey);
6460 if (r == NULL) {
6461 return false;
6462 }
6463
6464 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6465 talloc_free(r);
6466 return false;
6467 }
6468
6469 pull = ndr_pull_init_blob(&blob, r, NULL);
6470 if (pull == NULL) {
6471 talloc_free(r);
6472 return false;
6473 }
6474
6475 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6476 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6477 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6478 talloc_free(r);
6479 return false;
6480 }
6481
6482 if (DEBUGLEVEL >= 10) {
6483 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterKey, r);
6484 }
6485
6486 r->out.result = _spoolss_DeletePrinterKey(p, r);
6487
6488 if (p->rng_fault_state) {
6489 talloc_free(r);
6490 /* Return true here, srv_pipe_hnd.c will take care */
6491 return true;
6492 }
6493
6494 if (DEBUGLEVEL >= 10) {
6495 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterKey, r);
6496 }
6497
6498 push = ndr_push_init_ctx(r, NULL);
6499 if (push == NULL) {
6500 talloc_free(r);
6501 return false;
6502 }
6503
6504 ndr_err = call->ndr_push(push, NDR_OUT, r);
6505 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6506 talloc_free(r);
6507 return false;
6508 }
6509
6510 blob = ndr_push_blob(push);
6511 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6512 talloc_free(r);
6513 return false;
6514 }
6515
6516 talloc_free(r);
6517
6518 return true;
6519 }
6520
6521 static bool api_spoolss_53(pipes_struct *p)
6522 {
6523 const struct ndr_interface_call *call;
6524 struct ndr_pull *pull;
6525 struct ndr_push *push;
6526 enum ndr_err_code ndr_err;
6527 DATA_BLOB blob;
6528 struct spoolss_53 *r;
6529
6530 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_53];
6531
6532 r = talloc(talloc_tos(), struct spoolss_53);
6533 if (r == NULL) {
6534 return false;
6535 }
6536
6537 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6538 talloc_free(r);
6539 return false;
6540 }
6541
6542 pull = ndr_pull_init_blob(&blob, r, NULL);
6543 if (pull == NULL) {
6544 talloc_free(r);
6545 return false;
6546 }
6547
6548 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6549 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6550 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6551 talloc_free(r);
6552 return false;
6553 }
6554
6555 if (DEBUGLEVEL >= 10) {
6556 NDR_PRINT_IN_DEBUG(spoolss_53, r);
6557 }
6558
6559 r->out.result = _spoolss_53(p, r);
6560
6561 if (p->rng_fault_state) {
6562 talloc_free(r);
6563 /* Return true here, srv_pipe_hnd.c will take care */
6564 return true;
6565 }
6566
6567 if (DEBUGLEVEL >= 10) {
6568 NDR_PRINT_OUT_DEBUG(spoolss_53, r);
6569 }
6570
6571 push = ndr_push_init_ctx(r, NULL);
6572 if (push == NULL) {
6573 talloc_free(r);
6574 return false;
6575 }
6576
6577 ndr_err = call->ndr_push(push, NDR_OUT, r);
6578 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6579 talloc_free(r);
6580 return false;
6581 }
6582
6583 blob = ndr_push_blob(push);
6584 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6585 talloc_free(r);
6586 return false;
6587 }
6588
6589 talloc_free(r);
6590
6591 return true;
6592 }
6593
6594 static bool api_spoolss_DeletePrinterDriverEx(pipes_struct *p)
6595 {
6596 const struct ndr_interface_call *call;
6597 struct ndr_pull *pull;
6598 struct ndr_push *push;
6599 enum ndr_err_code ndr_err;
6600 DATA_BLOB blob;
6601 struct spoolss_DeletePrinterDriverEx *r;
6602
6603 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_DELETEPRINTERDRIVEREX];
6604
6605 r = talloc(talloc_tos(), struct spoolss_DeletePrinterDriverEx);
6606 if (r == NULL) {
6607 return false;
6608 }
6609
6610 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6611 talloc_free(r);
6612 return false;
6613 }
6614
6615 pull = ndr_pull_init_blob(&blob, r, NULL);
6616 if (pull == NULL) {
6617 talloc_free(r);
6618 return false;
6619 }
6620
6621 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6622 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6623 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6624 talloc_free(r);
6625 return false;
6626 }
6627
6628 if (DEBUGLEVEL >= 10) {
6629 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDriverEx, r);
6630 }
6631
6632 r->out.result = _spoolss_DeletePrinterDriverEx(p, r);
6633
6634 if (p->rng_fault_state) {
6635 talloc_free(r);
6636 /* Return true here, srv_pipe_hnd.c will take care */
6637 return true;
6638 }
6639
6640 if (DEBUGLEVEL >= 10) {
6641 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDriverEx, r);
6642 }
6643
6644 push = ndr_push_init_ctx(r, NULL);
6645 if (push == NULL) {
6646 talloc_free(r);
6647 return false;
6648 }
6649
6650 ndr_err = call->ndr_push(push, NDR_OUT, r);
6651 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6652 talloc_free(r);
6653 return false;
6654 }
6655
6656 blob = ndr_push_blob(push);
6657 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6658 talloc_free(r);
6659 return false;
6660 }
6661
6662 talloc_free(r);
6663
6664 return true;
6665 }
6666
6667 static bool api_spoolss_55(pipes_struct *p)
6668 {
6669 const struct ndr_interface_call *call;
6670 struct ndr_pull *pull;
6671 struct ndr_push *push;
6672 enum ndr_err_code ndr_err;
6673 DATA_BLOB blob;
6674 struct spoolss_55 *r;
6675
6676 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_55];
6677
6678 r = talloc(talloc_tos(), struct spoolss_55);
6679 if (r == NULL) {
6680 return false;
6681 }
6682
6683 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6684 talloc_free(r);
6685 return false;
6686 }
6687
6688 pull = ndr_pull_init_blob(&blob, r, NULL);
6689 if (pull == NULL) {
6690 talloc_free(r);
6691 return false;
6692 }
6693
6694 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6695 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6696 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6697 talloc_free(r);
6698 return false;
6699 }
6700
6701 if (DEBUGLEVEL >= 10) {
6702 NDR_PRINT_IN_DEBUG(spoolss_55, r);
6703 }
6704
6705 r->out.result = _spoolss_55(p, r);
6706
6707 if (p->rng_fault_state) {
6708 talloc_free(r);
6709 /* Return true here, srv_pipe_hnd.c will take care */
6710 return true;
6711 }
6712
6713 if (DEBUGLEVEL >= 10) {
6714 NDR_PRINT_OUT_DEBUG(spoolss_55, r);
6715 }
6716
6717 push = ndr_push_init_ctx(r, NULL);
6718 if (push == NULL) {
6719 talloc_free(r);
6720 return false;
6721 }
6722
6723 ndr_err = call->ndr_push(push, NDR_OUT, r);
6724 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6725 talloc_free(r);
6726 return false;
6727 }
6728
6729 blob = ndr_push_blob(push);
6730 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6731 talloc_free(r);
6732 return false;
6733 }
6734
6735 talloc_free(r);
6736
6737 return true;
6738 }
6739
6740 static bool api_spoolss_56(pipes_struct *p)
6741 {
6742 const struct ndr_interface_call *call;
6743 struct ndr_pull *pull;
6744 struct ndr_push *push;
6745 enum ndr_err_code ndr_err;
6746 DATA_BLOB blob;
6747 struct spoolss_56 *r;
6748
6749 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_56];
6750
6751 r = talloc(talloc_tos(), struct spoolss_56);
6752 if (r == NULL) {
6753 return false;
6754 }
6755
6756 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6757 talloc_free(r);
6758 return false;
6759 }
6760
6761 pull = ndr_pull_init_blob(&blob, r, NULL);
6762 if (pull == NULL) {
6763 talloc_free(r);
6764 return false;
6765 }
6766
6767 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6768 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6769 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6770 talloc_free(r);
6771 return false;
6772 }
6773
6774 if (DEBUGLEVEL >= 10) {
6775 NDR_PRINT_IN_DEBUG(spoolss_56, r);
6776 }
6777
6778 r->out.result = _spoolss_56(p, r);
6779
6780 if (p->rng_fault_state) {
6781 talloc_free(r);
6782 /* Return true here, srv_pipe_hnd.c will take care */
6783 return true;
6784 }
6785
6786 if (DEBUGLEVEL >= 10) {
6787 NDR_PRINT_OUT_DEBUG(spoolss_56, r);
6788 }
6789
6790 push = ndr_push_init_ctx(r, NULL);
6791 if (push == NULL) {
6792 talloc_free(r);
6793 return false;
6794 }
6795
6796 ndr_err = call->ndr_push(push, NDR_OUT, r);
6797 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6798 talloc_free(r);
6799 return false;
6800 }
6801
6802 blob = ndr_push_blob(push);
6803 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6804 talloc_free(r);
6805 return false;
6806 }
6807
6808 talloc_free(r);
6809
6810 return true;
6811 }
6812
6813 static bool api_spoolss_57(pipes_struct *p)
6814 {
6815 const struct ndr_interface_call *call;
6816 struct ndr_pull *pull;
6817 struct ndr_push *push;
6818 enum ndr_err_code ndr_err;
6819 DATA_BLOB blob;
6820 struct spoolss_57 *r;
6821
6822 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_57];
6823
6824 r = talloc(talloc_tos(), struct spoolss_57);
6825 if (r == NULL) {
6826 return false;
6827 }
6828
6829 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6830 talloc_free(r);
6831 return false;
6832 }
6833
6834 pull = ndr_pull_init_blob(&blob, r, NULL);
6835 if (pull == NULL) {
6836 talloc_free(r);
6837 return false;
6838 }
6839
6840 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6841 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6842 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6843 talloc_free(r);
6844 return false;
6845 }
6846
6847 if (DEBUGLEVEL >= 10) {
6848 NDR_PRINT_IN_DEBUG(spoolss_57, r);
6849 }
6850
6851 r->out.result = _spoolss_57(p, r);
6852
6853 if (p->rng_fault_state) {
6854 talloc_free(r);
6855 /* Return true here, srv_pipe_hnd.c will take care */
6856 return true;
6857 }
6858
6859 if (DEBUGLEVEL >= 10) {
6860 NDR_PRINT_OUT_DEBUG(spoolss_57, r);
6861 }
6862
6863 push = ndr_push_init_ctx(r, NULL);
6864 if (push == NULL) {
6865 talloc_free(r);
6866 return false;
6867 }
6868
6869 ndr_err = call->ndr_push(push, NDR_OUT, r);
6870 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6871 talloc_free(r);
6872 return false;
6873 }
6874
6875 blob = ndr_push_blob(push);
6876 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6877 talloc_free(r);
6878 return false;
6879 }
6880
6881 talloc_free(r);
6882
6883 return true;
6884 }
6885
6886 static bool api_spoolss_XcvData(pipes_struct *p)
6887 {
6888 const struct ndr_interface_call *call;
6889 struct ndr_pull *pull;
6890 struct ndr_push *push;
6891 enum ndr_err_code ndr_err;
6892 DATA_BLOB blob;
6893 struct spoolss_XcvData *r;
6894
6895 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_XCVDATA];
6896
6897 r = talloc(talloc_tos(), struct spoolss_XcvData);
6898 if (r == NULL) {
6899 return false;
6900 }
6901
6902 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6903 talloc_free(r);
6904 return false;
6905 }
6906
6907 pull = ndr_pull_init_blob(&blob, r, NULL);
6908 if (pull == NULL) {
6909 talloc_free(r);
6910 return false;
6911 }
6912
6913 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6914 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6915 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6916 talloc_free(r);
6917 return false;
6918 }
6919
6920 if (DEBUGLEVEL >= 10) {
6921 NDR_PRINT_IN_DEBUG(spoolss_XcvData, r);
6922 }
6923
6924 ZERO_STRUCT(r->out);
6925 r->out.status_code = r->in.status_code;
6926 r->out.out_data = talloc_zero_array(r, uint8_t, r->in.out_data_size);
6927 if (r->out.out_data == NULL) {
6928 talloc_free(r);
6929 return false;
6930 }
6931
6932 r->out.needed = talloc_zero(r, uint32_t);
6933 if (r->out.needed == NULL) {
6934 talloc_free(r);
6935 return false;
6936 }
6937
6938 r->out.result = _spoolss_XcvData(p, r);
6939
6940 if (p->rng_fault_state) {
6941 talloc_free(r);
6942 /* Return true here, srv_pipe_hnd.c will take care */
6943 return true;
6944 }
6945
6946 if (DEBUGLEVEL >= 10) {
6947 NDR_PRINT_OUT_DEBUG(spoolss_XcvData, r);
6948 }
6949
6950 push = ndr_push_init_ctx(r, NULL);
6951 if (push == NULL) {
6952 talloc_free(r);
6953 return false;
6954 }
6955
6956 ndr_err = call->ndr_push(push, NDR_OUT, r);
6957 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6958 talloc_free(r);
6959 return false;
6960 }
6961
6962 blob = ndr_push_blob(push);
6963 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6964 talloc_free(r);
6965 return false;
6966 }
6967
6968 talloc_free(r);
6969
6970 return true;
6971 }
6972
6973 static bool api_spoolss_AddPrinterDriverEx(pipes_struct *p)
6974 {
6975 const struct ndr_interface_call *call;
6976 struct ndr_pull *pull;
6977 struct ndr_push *push;
6978 enum ndr_err_code ndr_err;
6979 DATA_BLOB blob;
6980 struct spoolss_AddPrinterDriverEx *r;
6981
6982 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_ADDPRINTERDRIVEREX];
6983
6984 r = talloc(talloc_tos(), struct spoolss_AddPrinterDriverEx);
6985 if (r == NULL) {
6986 return false;
6987 }
6988
6989 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6990 talloc_free(r);
6991 return false;
6992 }
6993
6994 pull = ndr_pull_init_blob(&blob, r, NULL);
6995 if (pull == NULL) {
6996 talloc_free(r);
6997 return false;
6998 }
6999
7000 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7001 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7002 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7003 talloc_free(r);
7004 return false;
7005 }
7006
7007 if (DEBUGLEVEL >= 10) {
7008 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterDriverEx, r);
7009 }
7010
7011 r->out.result = _spoolss_AddPrinterDriverEx(p, r);
7012
7013 if (p->rng_fault_state) {
7014 talloc_free(r);
7015 /* Return true here, srv_pipe_hnd.c will take care */
7016 return true;
7017 }
7018
7019 if (DEBUGLEVEL >= 10) {
7020 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterDriverEx, r);
7021 }
7022
7023 push = ndr_push_init_ctx(r, NULL);
7024 if (push == NULL) {
7025 talloc_free(r);
7026 return false;
7027 }
7028
7029 ndr_err = call->ndr_push(push, NDR_OUT, r);
7030 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7031 talloc_free(r);
7032 return false;
7033 }
7034
7035 blob = ndr_push_blob(push);
7036 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7037 talloc_free(r);
7038 return false;
7039 }
7040
7041 talloc_free(r);
7042
7043 return true;
7044 }
7045
7046 static bool api_spoolss_5a(pipes_struct *p)
7047 {
7048 const struct ndr_interface_call *call;
7049 struct ndr_pull *pull;
7050 struct ndr_push *push;
7051 enum ndr_err_code ndr_err;
7052 DATA_BLOB blob;
7053 struct spoolss_5a *r;
7054
7055 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5A];
7056
7057 r = talloc(talloc_tos(), struct spoolss_5a);
7058 if (r == NULL) {
7059 return false;
7060 }
7061
7062 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7063 talloc_free(r);
7064 return false;
7065 }
7066
7067 pull = ndr_pull_init_blob(&blob, r, NULL);
7068 if (pull == NULL) {
7069 talloc_free(r);
7070 return false;
7071 }
7072
7073 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7074 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7075 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7076 talloc_free(r);
7077 return false;
7078 }
7079
7080 if (DEBUGLEVEL >= 10) {
7081 NDR_PRINT_IN_DEBUG(spoolss_5a, r);
7082 }
7083
7084 r->out.result = _spoolss_5a(p, r);
7085
7086 if (p->rng_fault_state) {
7087 talloc_free(r);
7088 /* Return true here, srv_pipe_hnd.c will take care */
7089 return true;
7090 }
7091
7092 if (DEBUGLEVEL >= 10) {
7093 NDR_PRINT_OUT_DEBUG(spoolss_5a, r);
7094 }
7095
7096 push = ndr_push_init_ctx(r, NULL);
7097 if (push == NULL) {
7098 talloc_free(r);
7099 return false;
7100 }
7101
7102 ndr_err = call->ndr_push(push, NDR_OUT, r);
7103 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7104 talloc_free(r);
7105 return false;
7106 }
7107
7108 blob = ndr_push_blob(push);
7109 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7110 talloc_free(r);
7111 return false;
7112 }
7113
7114 talloc_free(r);
7115
7116 return true;
7117 }
7118
7119 static bool api_spoolss_5b(pipes_struct *p)
7120 {
7121 const struct ndr_interface_call *call;
7122 struct ndr_pull *pull;
7123 struct ndr_push *push;
7124 enum ndr_err_code ndr_err;
7125 DATA_BLOB blob;
7126 struct spoolss_5b *r;
7127
7128 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5B];
7129
7130 r = talloc(talloc_tos(), struct spoolss_5b);
7131 if (r == NULL) {
7132 return false;
7133 }
7134
7135 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7136 talloc_free(r);
7137 return false;
7138 }
7139
7140 pull = ndr_pull_init_blob(&blob, r, NULL);
7141 if (pull == NULL) {
7142 talloc_free(r);
7143 return false;
7144 }
7145
7146 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7147 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7148 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7149 talloc_free(r);
7150 return false;
7151 }
7152
7153 if (DEBUGLEVEL >= 10) {
7154 NDR_PRINT_IN_DEBUG(spoolss_5b, r);
7155 }
7156
7157 r->out.result = _spoolss_5b(p, r);
7158
7159 if (p->rng_fault_state) {
7160 talloc_free(r);
7161 /* Return true here, srv_pipe_hnd.c will take care */
7162 return true;
7163 }
7164
7165 if (DEBUGLEVEL >= 10) {
7166 NDR_PRINT_OUT_DEBUG(spoolss_5b, r);
7167 }
7168
7169 push = ndr_push_init_ctx(r, NULL);
7170 if (push == NULL) {
7171 talloc_free(r);
7172 return false;
7173 }
7174
7175 ndr_err = call->ndr_push(push, NDR_OUT, r);
7176 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7177 talloc_free(r);
7178 return false;
7179 }
7180
7181 blob = ndr_push_blob(push);
7182 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7183 talloc_free(r);
7184 return false;
7185 }
7186
7187 talloc_free(r);
7188
7189 return true;
7190 }
7191
7192 static bool api_spoolss_5c(pipes_struct *p)
7193 {
7194 const struct ndr_interface_call *call;
7195 struct ndr_pull *pull;
7196 struct ndr_push *push;
7197 enum ndr_err_code ndr_err;
7198 DATA_BLOB blob;
7199 struct spoolss_5c *r;
7200
7201 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5C];
7202
7203 r = talloc(talloc_tos(), struct spoolss_5c);
7204 if (r == NULL) {
7205 return false;
7206 }
7207
7208 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7209 talloc_free(r);
7210 return false;
7211 }
7212
7213 pull = ndr_pull_init_blob(&blob, r, NULL);
7214 if (pull == NULL) {
7215 talloc_free(r);
7216 return false;
7217 }
7218
7219 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7220 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7221 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7222 talloc_free(r);
7223 return false;
7224 }
7225
7226 if (DEBUGLEVEL >= 10) {
7227 NDR_PRINT_IN_DEBUG(spoolss_5c, r);
7228 }
7229
7230 r->out.result = _spoolss_5c(p, r);
7231
7232 if (p->rng_fault_state) {
7233 talloc_free(r);
7234 /* Return true here, srv_pipe_hnd.c will take care */
7235 return true;
7236 }
7237
7238 if (DEBUGLEVEL >= 10) {
7239 NDR_PRINT_OUT_DEBUG(spoolss_5c, r);
7240 }
7241
7242 push = ndr_push_init_ctx(r, NULL);
7243 if (push == NULL) {
7244 talloc_free(r);
7245 return false;
7246 }
7247
7248 ndr_err = call->ndr_push(push, NDR_OUT, r);
7249 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7250 talloc_free(r);
7251 return false;
7252 }
7253
7254 blob = ndr_push_blob(push);
7255 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7256 talloc_free(r);
7257 return false;
7258 }
7259
7260 talloc_free(r);
7261
7262 return true;
7263 }
7264
7265 static bool api_spoolss_5d(pipes_struct *p)
7266 {
7267 const struct ndr_interface_call *call;
7268 struct ndr_pull *pull;
7269 struct ndr_push *push;
7270 enum ndr_err_code ndr_err;
7271 DATA_BLOB blob;
7272 struct spoolss_5d *r;
7273
7274 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5D];
7275
7276 r = talloc(talloc_tos(), struct spoolss_5d);
7277 if (r == NULL) {
7278 return false;
7279 }
7280
7281 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7282 talloc_free(r);
7283 return false;
7284 }
7285
7286 pull = ndr_pull_init_blob(&blob, r, NULL);
7287 if (pull == NULL) {
7288 talloc_free(r);
7289 return false;
7290 }
7291
7292 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7293 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7294 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7295 talloc_free(r);
7296 return false;
7297 }
7298
7299 if (DEBUGLEVEL >= 10) {
7300 NDR_PRINT_IN_DEBUG(spoolss_5d, r);
7301 }
7302
7303 r->out.result = _spoolss_5d(p, r);
7304
7305 if (p->rng_fault_state) {
7306 talloc_free(r);
7307 /* Return true here, srv_pipe_hnd.c will take care */
7308 return true;
7309 }
7310
7311 if (DEBUGLEVEL >= 10) {
7312 NDR_PRINT_OUT_DEBUG(spoolss_5d, r);
7313 }
7314
7315 push = ndr_push_init_ctx(r, NULL);
7316 if (push == NULL) {
7317 talloc_free(r);
7318 return false;
7319 }
7320
7321 ndr_err = call->ndr_push(push, NDR_OUT, r);
7322 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7323 talloc_free(r);
7324 return false;
7325 }
7326
7327 blob = ndr_push_blob(push);
7328 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7329 talloc_free(r);
7330 return false;
7331 }
7332
7333 talloc_free(r);
7334
7335 return true;
7336 }
7337
7338 static bool api_spoolss_5e(pipes_struct *p)
7339 {
7340 const struct ndr_interface_call *call;
7341 struct ndr_pull *pull;
7342 struct ndr_push *push;
7343 enum ndr_err_code ndr_err;
7344 DATA_BLOB blob;
7345 struct spoolss_5e *r;
7346
7347 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5E];
7348
7349 r = talloc(talloc_tos(), struct spoolss_5e);
7350 if (r == NULL) {
7351 return false;
7352 }
7353
7354 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7355 talloc_free(r);
7356 return false;
7357 }
7358
7359 pull = ndr_pull_init_blob(&blob, r, NULL);
7360 if (pull == NULL) {
7361 talloc_free(r);
7362 return false;
7363 }
7364
7365 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7366 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7367 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7368 talloc_free(r);
7369 return false;
7370 }
7371
7372 if (DEBUGLEVEL >= 10) {
7373 NDR_PRINT_IN_DEBUG(spoolss_5e, r);
7374 }
7375
7376 r->out.result = _spoolss_5e(p, r);
7377
7378 if (p->rng_fault_state) {
7379 talloc_free(r);
7380 /* Return true here, srv_pipe_hnd.c will take care */
7381 return true;
7382 }
7383
7384 if (DEBUGLEVEL >= 10) {
7385 NDR_PRINT_OUT_DEBUG(spoolss_5e, r);
7386 }
7387
7388 push = ndr_push_init_ctx(r, NULL);
7389 if (push == NULL) {
7390 talloc_free(r);
7391 return false;
7392 }
7393
7394 ndr_err = call->ndr_push(push, NDR_OUT, r);
7395 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7396 talloc_free(r);
7397 return false;
7398 }
7399
7400 blob = ndr_push_blob(push);
7401 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7402 talloc_free(r);
7403 return false;
7404 }
7405
7406 talloc_free(r);
7407
7408 return true;
7409 }
7410
7411 static bool api_spoolss_5f(pipes_struct *p)
7412 {
7413 const struct ndr_interface_call *call;
7414 struct ndr_pull *pull;
7415 struct ndr_push *push;
7416 enum ndr_err_code ndr_err;
7417 DATA_BLOB blob;
7418 struct spoolss_5f *r;
7419
7420 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_5F];
7421
7422 r = talloc(talloc_tos(), struct spoolss_5f);
7423 if (r == NULL) {
7424 return false;
7425 }
7426
7427 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7428 talloc_free(r);
7429 return false;
7430 }
7431
7432 pull = ndr_pull_init_blob(&blob, r, NULL);
7433 if (pull == NULL) {
7434 talloc_free(r);
7435 return false;
7436 }
7437
7438 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7439 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7440 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7441 talloc_free(r);
7442 return false;
7443 }
7444
7445 if (DEBUGLEVEL >= 10) {
7446 NDR_PRINT_IN_DEBUG(spoolss_5f, r);
7447 }
7448
7449 r->out.result = _spoolss_5f(p, r);
7450
7451 if (p->rng_fault_state) {
7452 talloc_free(r);
7453 /* Return true here, srv_pipe_hnd.c will take care */
7454 return true;
7455 }
7456
7457 if (DEBUGLEVEL >= 10) {
7458 NDR_PRINT_OUT_DEBUG(spoolss_5f, r);
7459 }
7460
7461 push = ndr_push_init_ctx(r, NULL);
7462 if (push == NULL) {
7463 talloc_free(r);
7464 return false;
7465 }
7466
7467 ndr_err = call->ndr_push(push, NDR_OUT, r);
7468 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7469 talloc_free(r);
7470 return false;
7471 }
7472
7473 blob = ndr_push_blob(push);
7474 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7475 talloc_free(r);
7476 return false;
7477 }
7478
7479 talloc_free(r);
7480
7481 return true;
7482 }
7483
7484 static bool api_spoolss_60(pipes_struct *p)
7485 {
7486 const struct ndr_interface_call *call;
7487 struct ndr_pull *pull;
7488 struct ndr_push *push;
7489 enum ndr_err_code ndr_err;
7490 DATA_BLOB blob;
7491 struct spoolss_60 *r;
7492
7493 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_60];
7494
7495 r = talloc(talloc_tos(), struct spoolss_60);
7496 if (r == NULL) {
7497 return false;
7498 }
7499
7500 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7501 talloc_free(r);
7502 return false;
7503 }
7504
7505 pull = ndr_pull_init_blob(&blob, r, NULL);
7506 if (pull == NULL) {
7507 talloc_free(r);
7508 return false;
7509 }
7510
7511 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7512 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7513 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7514 talloc_free(r);
7515 return false;
7516 }
7517
7518 if (DEBUGLEVEL >= 10) {
7519 NDR_PRINT_IN_DEBUG(spoolss_60, r);
7520 }
7521
7522 r->out.result = _spoolss_60(p, r);
7523
7524 if (p->rng_fault_state) {
7525 talloc_free(r);
7526 /* Return true here, srv_pipe_hnd.c will take care */
7527 return true;
7528 }
7529
7530 if (DEBUGLEVEL >= 10) {
7531 NDR_PRINT_OUT_DEBUG(spoolss_60, r);
7532 }
7533
7534 push = ndr_push_init_ctx(r, NULL);
7535 if (push == NULL) {
7536 talloc_free(r);
7537 return false;
7538 }
7539
7540 ndr_err = call->ndr_push(push, NDR_OUT, r);
7541 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7542 talloc_free(r);
7543 return false;
7544 }
7545
7546 blob = ndr_push_blob(push);
7547 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7548 talloc_free(r);
7549 return false;
7550 }
7551
7552 talloc_free(r);
7553
7554 return true;
7555 }
7556
7557 static bool api_spoolss_61(pipes_struct *p)
7558 {
7559 const struct ndr_interface_call *call;
7560 struct ndr_pull *pull;
7561 struct ndr_push *push;
7562 enum ndr_err_code ndr_err;
7563 DATA_BLOB blob;
7564 struct spoolss_61 *r;
7565
7566 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_61];
7567
7568 r = talloc(talloc_tos(), struct spoolss_61);
7569 if (r == NULL) {
7570 return false;
7571 }
7572
7573 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7574 talloc_free(r);
7575 return false;
7576 }
7577
7578 pull = ndr_pull_init_blob(&blob, r, NULL);
7579 if (pull == NULL) {
7580 talloc_free(r);
7581 return false;
7582 }
7583
7584 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7585 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7586 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7587 talloc_free(r);
7588 return false;
7589 }
7590
7591 if (DEBUGLEVEL >= 10) {
7592 NDR_PRINT_IN_DEBUG(spoolss_61, r);
7593 }
7594
7595 r->out.result = _spoolss_61(p, r);
7596
7597 if (p->rng_fault_state) {
7598 talloc_free(r);
7599 /* Return true here, srv_pipe_hnd.c will take care */
7600 return true;
7601 }
7602
7603 if (DEBUGLEVEL >= 10) {
7604 NDR_PRINT_OUT_DEBUG(spoolss_61, r);
7605 }
7606
7607 push = ndr_push_init_ctx(r, NULL);
7608 if (push == NULL) {
7609 talloc_free(r);
7610 return false;
7611 }
7612
7613 ndr_err = call->ndr_push(push, NDR_OUT, r);
7614 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7615 talloc_free(r);
7616 return false;
7617 }
7618
7619 blob = ndr_push_blob(push);
7620 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7621 talloc_free(r);
7622 return false;
7623 }
7624
7625 talloc_free(r);
7626
7627 return true;
7628 }
7629
7630 static bool api_spoolss_62(pipes_struct *p)
7631 {
7632 const struct ndr_interface_call *call;
7633 struct ndr_pull *pull;
7634 struct ndr_push *push;
7635 enum ndr_err_code ndr_err;
7636 DATA_BLOB blob;
7637 struct spoolss_62 *r;
7638
7639 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_62];
7640
7641 r = talloc(talloc_tos(), struct spoolss_62);
7642 if (r == NULL) {
7643 return false;
7644 }
7645
7646 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7647 talloc_free(r);
7648 return false;
7649 }
7650
7651 pull = ndr_pull_init_blob(&blob, r, NULL);
7652 if (pull == NULL) {
7653 talloc_free(r);
7654 return false;
7655 }
7656
7657 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7658 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7659 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7660 talloc_free(r);
7661 return false;
7662 }
7663
7664 if (DEBUGLEVEL >= 10) {
7665 NDR_PRINT_IN_DEBUG(spoolss_62, r);
7666 }
7667
7668 r->out.result = _spoolss_62(p, r);
7669
7670 if (p->rng_fault_state) {
7671 talloc_free(r);
7672 /* Return true here, srv_pipe_hnd.c will take care */
7673 return true;
7674 }
7675
7676 if (DEBUGLEVEL >= 10) {
7677 NDR_PRINT_OUT_DEBUG(spoolss_62, r);
7678 }
7679
7680 push = ndr_push_init_ctx(r, NULL);
7681 if (push == NULL) {
7682 talloc_free(r);
7683 return false;
7684 }
7685
7686 ndr_err = call->ndr_push(push, NDR_OUT, r);
7687 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7688 talloc_free(r);
7689 return false;
7690 }
7691
7692 blob = ndr_push_blob(push);
7693 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7694 talloc_free(r);
7695 return false;
7696 }
7697
7698 talloc_free(r);
7699
7700 return true;
7701 }
7702
7703 static bool api_spoolss_63(pipes_struct *p)
7704 {
7705 const struct ndr_interface_call *call;
7706 struct ndr_pull *pull;
7707 struct ndr_push *push;
7708 enum ndr_err_code ndr_err;
7709 DATA_BLOB blob;
7710 struct spoolss_63 *r;
7711
7712 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_63];
7713
7714 r = talloc(talloc_tos(), struct spoolss_63);
7715 if (r == NULL) {
7716 return false;
7717 }
7718
7719 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7720 talloc_free(r);
7721 return false;
7722 }
7723
7724 pull = ndr_pull_init_blob(&blob, r, NULL);
7725 if (pull == NULL) {
7726 talloc_free(r);
7727 return false;
7728 }
7729
7730 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7731 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7732 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7733 talloc_free(r);
7734 return false;
7735 }
7736
7737 if (DEBUGLEVEL >= 10) {
7738 NDR_PRINT_IN_DEBUG(spoolss_63, r);
7739 }
7740
7741 r->out.result = _spoolss_63(p, r);
7742
7743 if (p->rng_fault_state) {
7744 talloc_free(r);
7745 /* Return true here, srv_pipe_hnd.c will take care */
7746 return true;
7747 }
7748
7749 if (DEBUGLEVEL >= 10) {
7750 NDR_PRINT_OUT_DEBUG(spoolss_63, r);
7751 }
7752
7753 push = ndr_push_init_ctx(r, NULL);
7754 if (push == NULL) {
7755 talloc_free(r);
7756 return false;
7757 }
7758
7759 ndr_err = call->ndr_push(push, NDR_OUT, r);
7760 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7761 talloc_free(r);
7762 return false;
7763 }
7764
7765 blob = ndr_push_blob(push);
7766 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7767 talloc_free(r);
7768 return false;
7769 }
7770
7771 talloc_free(r);
7772
7773 return true;
7774 }
7775
7776 static bool api_spoolss_64(pipes_struct *p)
7777 {
7778 const struct ndr_interface_call *call;
7779 struct ndr_pull *pull;
7780 struct ndr_push *push;
7781 enum ndr_err_code ndr_err;
7782 DATA_BLOB blob;
7783 struct spoolss_64 *r;
7784
7785 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_64];
7786
7787 r = talloc(talloc_tos(), struct spoolss_64);
7788 if (r == NULL) {
7789 return false;
7790 }
7791
7792 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7793 talloc_free(r);
7794 return false;
7795 }
7796
7797 pull = ndr_pull_init_blob(&blob, r, NULL);
7798 if (pull == NULL) {
7799 talloc_free(r);
7800 return false;
7801 }
7802
7803 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7804 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7805 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7806 talloc_free(r);
7807 return false;
7808 }
7809
7810 if (DEBUGLEVEL >= 10) {
7811 NDR_PRINT_IN_DEBUG(spoolss_64, r);
7812 }
7813
7814 r->out.result = _spoolss_64(p, r);
7815
7816 if (p->rng_fault_state) {
7817 talloc_free(r);
7818 /* Return true here, srv_pipe_hnd.c will take care */
7819 return true;
7820 }
7821
7822 if (DEBUGLEVEL >= 10) {
7823 NDR_PRINT_OUT_DEBUG(spoolss_64, r);
7824 }
7825
7826 push = ndr_push_init_ctx(r, NULL);
7827 if (push == NULL) {
7828 talloc_free(r);
7829 return false;
7830 }
7831
7832 ndr_err = call->ndr_push(push, NDR_OUT, r);
7833 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7834 talloc_free(r);
7835 return false;
7836 }
7837
7838 blob = ndr_push_blob(push);
7839 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7840 talloc_free(r);
7841 return false;
7842 }
7843
7844 talloc_free(r);
7845
7846 return true;
7847 }
7848
7849 static bool api_spoolss_65(pipes_struct *p)
7850 {
7851 const struct ndr_interface_call *call;
7852 struct ndr_pull *pull;
7853 struct ndr_push *push;
7854 enum ndr_err_code ndr_err;
7855 DATA_BLOB blob;
7856 struct spoolss_65 *r;
7857
7858 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_65];
7859
7860 r = talloc(talloc_tos(), struct spoolss_65);
7861 if (r == NULL) {
7862 return false;
7863 }
7864
7865 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7866 talloc_free(r);
7867 return false;
7868 }
7869
7870 pull = ndr_pull_init_blob(&blob, r, NULL);
7871 if (pull == NULL) {
7872 talloc_free(r);
7873 return false;
7874 }
7875
7876 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7877 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7878 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7879 talloc_free(r);
7880 return false;
7881 }
7882
7883 if (DEBUGLEVEL >= 10) {
7884 NDR_PRINT_IN_DEBUG(spoolss_65, r);
7885 }
7886
7887 r->out.result = _spoolss_65(p, r);
7888
7889 if (p->rng_fault_state) {
7890 talloc_free(r);
7891 /* Return true here, srv_pipe_hnd.c will take care */
7892 return true;
7893 }
7894
7895 if (DEBUGLEVEL >= 10) {
7896 NDR_PRINT_OUT_DEBUG(spoolss_65, r);
7897 }
7898
7899 push = ndr_push_init_ctx(r, NULL);
7900 if (push == NULL) {
7901 talloc_free(r);
7902 return false;
7903 }
7904
7905 ndr_err = call->ndr_push(push, NDR_OUT, r);
7906 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7907 talloc_free(r);
7908 return false;
7909 }
7910
7911 blob = ndr_push_blob(push);
7912 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7913 talloc_free(r);
7914 return false;
7915 }
7916
7917 talloc_free(r);
7918
7919 return true;
7920 }
7921
7922 static bool api_spoolss_GetCorePrinterDrivers(pipes_struct *p)
7923 {
7924 const struct ndr_interface_call *call;
7925 struct ndr_pull *pull;
7926 struct ndr_push *push;
7927 enum ndr_err_code ndr_err;
7928 DATA_BLOB blob;
7929 struct spoolss_GetCorePrinterDrivers *r;
7930
7931 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETCOREPRINTERDRIVERS];
7932
7933 r = talloc(talloc_tos(), struct spoolss_GetCorePrinterDrivers);
7934 if (r == NULL) {
7935 return false;
7936 }
7937
7938 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
7939 talloc_free(r);
7940 return false;
7941 }
7942
7943 pull = ndr_pull_init_blob(&blob, r, NULL);
7944 if (pull == NULL) {
7945 talloc_free(r);
7946 return false;
7947 }
7948
7949 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
7950 ndr_err = call->ndr_pull(pull, NDR_IN, r);
7951 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7952 talloc_free(r);
7953 return false;
7954 }
7955
7956 if (DEBUGLEVEL >= 10) {
7957 NDR_PRINT_IN_DEBUG(spoolss_GetCorePrinterDrivers, r);
7958 }
7959
7960 ZERO_STRUCT(r->out);
7961 r->out.core_printer_drivers = talloc_zero_array(r, struct spoolss_CorePrinterDriver, r->in.core_printer_driver_count);
7962 if (r->out.core_printer_drivers == NULL) {
7963 talloc_free(r);
7964 return false;
7965 }
7966
7967 r->out.result = _spoolss_GetCorePrinterDrivers(p, r);
7968
7969 if (p->rng_fault_state) {
7970 talloc_free(r);
7971 /* Return true here, srv_pipe_hnd.c will take care */
7972 return true;
7973 }
7974
7975 if (DEBUGLEVEL >= 10) {
7976 NDR_PRINT_OUT_DEBUG(spoolss_GetCorePrinterDrivers, r);
7977 }
7978
7979 push = ndr_push_init_ctx(r, NULL);
7980 if (push == NULL) {
7981 talloc_free(r);
7982 return false;
7983 }
7984
7985 ndr_err = call->ndr_push(push, NDR_OUT, r);
7986 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
7987 talloc_free(r);
7988 return false;
7989 }
7990
7991 blob = ndr_push_blob(push);
7992 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
7993 talloc_free(r);
7994 return false;
7995 }
7996
7997 talloc_free(r);
7998
7999 return true;
8000 }
8001
8002 static bool api_spoolss_67(pipes_struct *p)
8003 {
8004 const struct ndr_interface_call *call;
8005 struct ndr_pull *pull;
8006 struct ndr_push *push;
8007 enum ndr_err_code ndr_err;
8008 DATA_BLOB blob;
8009 struct spoolss_67 *r;
8010
8011 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_67];
8012
8013 r = talloc(talloc_tos(), struct spoolss_67);
8014 if (r == NULL) {
8015 return false;
8016 }
8017
8018 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8019 talloc_free(r);
8020 return false;
8021 }
8022
8023 pull = ndr_pull_init_blob(&blob, r, NULL);
8024 if (pull == NULL) {
8025 talloc_free(r);
8026 return false;
8027 }
8028
8029 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8030 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8031 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8032 talloc_free(r);
8033 return false;
8034 }
8035
8036 if (DEBUGLEVEL >= 10) {
8037 NDR_PRINT_IN_DEBUG(spoolss_67, r);
8038 }
8039
8040 r->out.result = _spoolss_67(p, r);
8041
8042 if (p->rng_fault_state) {
8043 talloc_free(r);
8044 /* Return true here, srv_pipe_hnd.c will take care */
8045 return true;
8046 }
8047
8048 if (DEBUGLEVEL >= 10) {
8049 NDR_PRINT_OUT_DEBUG(spoolss_67, r);
8050 }
8051
8052 push = ndr_push_init_ctx(r, NULL);
8053 if (push == NULL) {
8054 talloc_free(r);
8055 return false;
8056 }
8057
8058 ndr_err = call->ndr_push(push, NDR_OUT, r);
8059 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8060 talloc_free(r);
8061 return false;
8062 }
8063
8064 blob = ndr_push_blob(push);
8065 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8066 talloc_free(r);
8067 return false;
8068 }
8069
8070 talloc_free(r);
8071
8072 return true;
8073 }
8074
8075 static bool api_spoolss_GetPrinterDriverPackagePath(pipes_struct *p)
8076 {
8077 const struct ndr_interface_call *call;
8078 struct ndr_pull *pull;
8079 struct ndr_push *push;
8080 enum ndr_err_code ndr_err;
8081 DATA_BLOB blob;
8082 struct spoolss_GetPrinterDriverPackagePath *r;
8083
8084 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH];
8085
8086 r = talloc(talloc_tos(), struct spoolss_GetPrinterDriverPackagePath);
8087 if (r == NULL) {
8088 return false;
8089 }
8090
8091 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8092 talloc_free(r);
8093 return false;
8094 }
8095
8096 pull = ndr_pull_init_blob(&blob, r, NULL);
8097 if (pull == NULL) {
8098 talloc_free(r);
8099 return false;
8100 }
8101
8102 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8103 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8104 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8105 talloc_free(r);
8106 return false;
8107 }
8108
8109 if (DEBUGLEVEL >= 10) {
8110 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriverPackagePath, r);
8111 }
8112
8113 ZERO_STRUCT(r->out);
8114 r->out.driver_package_cab = r->in.driver_package_cab;
8115 r->out.required = talloc_zero(r, uint32_t);
8116 if (r->out.required == NULL) {
8117 talloc_free(r);
8118 return false;
8119 }
8120
8121 r->out.result = _spoolss_GetPrinterDriverPackagePath(p, r);
8122
8123 if (p->rng_fault_state) {
8124 talloc_free(r);
8125 /* Return true here, srv_pipe_hnd.c will take care */
8126 return true;
8127 }
8128
8129 if (DEBUGLEVEL >= 10) {
8130 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriverPackagePath, r);
8131 }
8132
8133 push = ndr_push_init_ctx(r, NULL);
8134 if (push == NULL) {
8135 talloc_free(r);
8136 return false;
8137 }
8138
8139 ndr_err = call->ndr_push(push, NDR_OUT, r);
8140 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8141 talloc_free(r);
8142 return false;
8143 }
8144
8145 blob = ndr_push_blob(push);
8146 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8147 talloc_free(r);
8148 return false;
8149 }
8150
8151 talloc_free(r);
8152
8153 return true;
8154 }
8155
8156 static bool api_spoolss_69(pipes_struct *p)
8157 {
8158 const struct ndr_interface_call *call;
8159 struct ndr_pull *pull;
8160 struct ndr_push *push;
8161 enum ndr_err_code ndr_err;
8162 DATA_BLOB blob;
8163 struct spoolss_69 *r;
8164
8165 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_69];
8166
8167 r = talloc(talloc_tos(), struct spoolss_69);
8168 if (r == NULL) {
8169 return false;
8170 }
8171
8172 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8173 talloc_free(r);
8174 return false;
8175 }
8176
8177 pull = ndr_pull_init_blob(&blob, r, NULL);
8178 if (pull == NULL) {
8179 talloc_free(r);
8180 return false;
8181 }
8182
8183 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8184 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8185 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8186 talloc_free(r);
8187 return false;
8188 }
8189
8190 if (DEBUGLEVEL >= 10) {
8191 NDR_PRINT_IN_DEBUG(spoolss_69, r);
8192 }
8193
8194 r->out.result = _spoolss_69(p, r);
8195
8196 if (p->rng_fault_state) {
8197 talloc_free(r);
8198 /* Return true here, srv_pipe_hnd.c will take care */
8199 return true;
8200 }
8201
8202 if (DEBUGLEVEL >= 10) {
8203 NDR_PRINT_OUT_DEBUG(spoolss_69, r);
8204 }
8205
8206 push = ndr_push_init_ctx(r, NULL);
8207 if (push == NULL) {
8208 talloc_free(r);
8209 return false;
8210 }
8211
8212 ndr_err = call->ndr_push(push, NDR_OUT, r);
8213 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8214 talloc_free(r);
8215 return false;
8216 }
8217
8218 blob = ndr_push_blob(push);
8219 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8220 talloc_free(r);
8221 return false;
8222 }
8223
8224 talloc_free(r);
8225
8226 return true;
8227 }
8228
8229 static bool api_spoolss_6a(pipes_struct *p)
8230 {
8231 const struct ndr_interface_call *call;
8232 struct ndr_pull *pull;
8233 struct ndr_push *push;
8234 enum ndr_err_code ndr_err;
8235 DATA_BLOB blob;
8236 struct spoolss_6a *r;
8237
8238 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6A];
8239
8240 r = talloc(talloc_tos(), struct spoolss_6a);
8241 if (r == NULL) {
8242 return false;
8243 }
8244
8245 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8246 talloc_free(r);
8247 return false;
8248 }
8249
8250 pull = ndr_pull_init_blob(&blob, r, NULL);
8251 if (pull == NULL) {
8252 talloc_free(r);
8253 return false;
8254 }
8255
8256 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8257 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8258 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8259 talloc_free(r);
8260 return false;
8261 }
8262
8263 if (DEBUGLEVEL >= 10) {
8264 NDR_PRINT_IN_DEBUG(spoolss_6a, r);
8265 }
8266
8267 r->out.result = _spoolss_6a(p, r);
8268
8269 if (p->rng_fault_state) {
8270 talloc_free(r);
8271 /* Return true here, srv_pipe_hnd.c will take care */
8272 return true;
8273 }
8274
8275 if (DEBUGLEVEL >= 10) {
8276 NDR_PRINT_OUT_DEBUG(spoolss_6a, r);
8277 }
8278
8279 push = ndr_push_init_ctx(r, NULL);
8280 if (push == NULL) {
8281 talloc_free(r);
8282 return false;
8283 }
8284
8285 ndr_err = call->ndr_push(push, NDR_OUT, r);
8286 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8287 talloc_free(r);
8288 return false;
8289 }
8290
8291 blob = ndr_push_blob(push);
8292 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8293 talloc_free(r);
8294 return false;
8295 }
8296
8297 talloc_free(r);
8298
8299 return true;
8300 }
8301
8302 static bool api_spoolss_6b(pipes_struct *p)
8303 {
8304 const struct ndr_interface_call *call;
8305 struct ndr_pull *pull;
8306 struct ndr_push *push;
8307 enum ndr_err_code ndr_err;
8308 DATA_BLOB blob;
8309 struct spoolss_6b *r;
8310
8311 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6B];
8312
8313 r = talloc(talloc_tos(), struct spoolss_6b);
8314 if (r == NULL) {
8315 return false;
8316 }
8317
8318 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8319 talloc_free(r);
8320 return false;
8321 }
8322
8323 pull = ndr_pull_init_blob(&blob, r, NULL);
8324 if (pull == NULL) {
8325 talloc_free(r);
8326 return false;
8327 }
8328
8329 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8330 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8331 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8332 talloc_free(r);
8333 return false;
8334 }
8335
8336 if (DEBUGLEVEL >= 10) {
8337 NDR_PRINT_IN_DEBUG(spoolss_6b, r);
8338 }
8339
8340 r->out.result = _spoolss_6b(p, r);
8341
8342 if (p->rng_fault_state) {
8343 talloc_free(r);
8344 /* Return true here, srv_pipe_hnd.c will take care */
8345 return true;
8346 }
8347
8348 if (DEBUGLEVEL >= 10) {
8349 NDR_PRINT_OUT_DEBUG(spoolss_6b, r);
8350 }
8351
8352 push = ndr_push_init_ctx(r, NULL);
8353 if (push == NULL) {
8354 talloc_free(r);
8355 return false;
8356 }
8357
8358 ndr_err = call->ndr_push(push, NDR_OUT, r);
8359 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8360 talloc_free(r);
8361 return false;
8362 }
8363
8364 blob = ndr_push_blob(push);
8365 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8366 talloc_free(r);
8367 return false;
8368 }
8369
8370 talloc_free(r);
8371
8372 return true;
8373 }
8374
8375 static bool api_spoolss_6c(pipes_struct *p)
8376 {
8377 const struct ndr_interface_call *call;
8378 struct ndr_pull *pull;
8379 struct ndr_push *push;
8380 enum ndr_err_code ndr_err;
8381 DATA_BLOB blob;
8382 struct spoolss_6c *r;
8383
8384 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6C];
8385
8386 r = talloc(talloc_tos(), struct spoolss_6c);
8387 if (r == NULL) {
8388 return false;
8389 }
8390
8391 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8392 talloc_free(r);
8393 return false;
8394 }
8395
8396 pull = ndr_pull_init_blob(&blob, r, NULL);
8397 if (pull == NULL) {
8398 talloc_free(r);
8399 return false;
8400 }
8401
8402 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8403 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8404 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8405 talloc_free(r);
8406 return false;
8407 }
8408
8409 if (DEBUGLEVEL >= 10) {
8410 NDR_PRINT_IN_DEBUG(spoolss_6c, r);
8411 }
8412
8413 r->out.result = _spoolss_6c(p, r);
8414
8415 if (p->rng_fault_state) {
8416 talloc_free(r);
8417 /* Return true here, srv_pipe_hnd.c will take care */
8418 return true;
8419 }
8420
8421 if (DEBUGLEVEL >= 10) {
8422 NDR_PRINT_OUT_DEBUG(spoolss_6c, r);
8423 }
8424
8425 push = ndr_push_init_ctx(r, NULL);
8426 if (push == NULL) {
8427 talloc_free(r);
8428 return false;
8429 }
8430
8431 ndr_err = call->ndr_push(push, NDR_OUT, r);
8432 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8433 talloc_free(r);
8434 return false;
8435 }
8436
8437 blob = ndr_push_blob(push);
8438 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8439 talloc_free(r);
8440 return false;
8441 }
8442
8443 talloc_free(r);
8444
8445 return true;
8446 }
8447
8448 static bool api_spoolss_6d(pipes_struct *p)
8449 {
8450 const struct ndr_interface_call *call;
8451 struct ndr_pull *pull;
8452 struct ndr_push *push;
8453 enum ndr_err_code ndr_err;
8454 DATA_BLOB blob;
8455 struct spoolss_6d *r;
8456
8457 call = &ndr_table_spoolss.calls[NDR_SPOOLSS_6D];
8458
8459 r = talloc(talloc_tos(), struct spoolss_6d);
8460 if (r == NULL) {
8461 return false;
8462 }
8463
8464 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
8465 talloc_free(r);
8466 return false;
8467 }
8468
8469 pull = ndr_pull_init_blob(&blob, r, NULL);
8470 if (pull == NULL) {
8471 talloc_free(r);
8472 return false;
8473 }
8474
8475 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
8476 ndr_err = call->ndr_pull(pull, NDR_IN, r);
8477 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8478 talloc_free(r);
8479 return false;
8480 }
8481
8482 if (DEBUGLEVEL >= 10) {
8483 NDR_PRINT_IN_DEBUG(spoolss_6d, r);
8484 }
8485
8486 r->out.result = _spoolss_6d(p, r);
8487
8488 if (p->rng_fault_state) {
8489 talloc_free(r);
8490 /* Return true here, srv_pipe_hnd.c will take care */
8491 return true;
8492 }
8493
8494 if (DEBUGLEVEL >= 10) {
8495 NDR_PRINT_OUT_DEBUG(spoolss_6d, r);
8496 }
8497
8498 push = ndr_push_init_ctx(r, NULL);
8499 if (push == NULL) {
8500 talloc_free(r);
8501 return false;
8502 }
8503
8504 ndr_err = call->ndr_push(push, NDR_OUT, r);
8505 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
8506 talloc_free(r);
8507 return false;
8508 }
8509
8510 blob = ndr_push_blob(push);
8511 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
8512 talloc_free(r);
8513 return false;
8514 }
8515
8516 talloc_free(r);
8517
8518 return true;
8519 }
8520
8521
8522 /* Tables */
8523 static struct api_struct api_spoolss_cmds[] =
8524 {
8525 {"SPOOLSS_ENUMPRINTERS", NDR_SPOOLSS_ENUMPRINTERS, api_spoolss_EnumPrinters},
8526 {"SPOOLSS_OPENPRINTER", NDR_SPOOLSS_OPENPRINTER, api_spoolss_OpenPrinter},
8527 {"SPOOLSS_SETJOB", NDR_SPOOLSS_SETJOB, api_spoolss_SetJob},
8528 {"SPOOLSS_GETJOB", NDR_SPOOLSS_GETJOB, api_spoolss_GetJob},
8529 {"SPOOLSS_ENUMJOBS", NDR_SPOOLSS_ENUMJOBS, api_spoolss_EnumJobs},
8530 {"SPOOLSS_ADDPRINTER", NDR_SPOOLSS_ADDPRINTER, api_spoolss_AddPrinter},
8531 {"SPOOLSS_DELETEPRINTER", NDR_SPOOLSS_DELETEPRINTER, api_spoolss_DeletePrinter},
8532 {"SPOOLSS_SETPRINTER", NDR_SPOOLSS_SETPRINTER, api_spoolss_SetPrinter},
8533 {"SPOOLSS_GETPRINTER", NDR_SPOOLSS_GETPRINTER, api_spoolss_GetPrinter},
8534 {"SPOOLSS_ADDPRINTERDRIVER", NDR_SPOOLSS_ADDPRINTERDRIVER, api_spoolss_AddPrinterDriver},
8535 {"SPOOLSS_ENUMPRINTERDRIVERS", NDR_SPOOLSS_ENUMPRINTERDRIVERS, api_spoolss_EnumPrinterDrivers},
8536 {"SPOOLSS_GETPRINTERDRIVER", NDR_SPOOLSS_GETPRINTERDRIVER, api_spoolss_GetPrinterDriver},
8537 {"SPOOLSS_GETPRINTERDRIVERDIRECTORY", NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY, api_spoolss_GetPrinterDriverDirectory},
8538 {"SPOOLSS_DELETEPRINTERDRIVER", NDR_SPOOLSS_DELETEPRINTERDRIVER, api_spoolss_DeletePrinterDriver},
8539 {"SPOOLSS_ADDPRINTPROCESSOR", NDR_SPOOLSS_ADDPRINTPROCESSOR, api_spoolss_AddPrintProcessor},
8540 {"SPOOLSS_ENUMPRINTPROCESSORS", NDR_SPOOLSS_ENUMPRINTPROCESSORS, api_spoolss_EnumPrintProcessors},
8541 {"SPOOLSS_GETPRINTPROCESSORDIRECTORY", NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY, api_spoolss_GetPrintProcessorDirectory},
8542 {"SPOOLSS_STARTDOCPRINTER", NDR_SPOOLSS_STARTDOCPRINTER, api_spoolss_StartDocPrinter},
8543 {"SPOOLSS_STARTPAGEPRINTER", NDR_SPOOLSS_STARTPAGEPRINTER, api_spoolss_StartPagePrinter},
8544 {"SPOOLSS_WRITEPRINTER", NDR_SPOOLSS_WRITEPRINTER, api_spoolss_WritePrinter},
8545 {"SPOOLSS_ENDPAGEPRINTER", NDR_SPOOLSS_ENDPAGEPRINTER, api_spoolss_EndPagePrinter},
8546 {"SPOOLSS_ABORTPRINTER", NDR_SPOOLSS_ABORTPRINTER, api_spoolss_AbortPrinter},
8547 {"SPOOLSS_READPRINTER", NDR_SPOOLSS_READPRINTER, api_spoolss_ReadPrinter},
8548 {"SPOOLSS_ENDDOCPRINTER", NDR_SPOOLSS_ENDDOCPRINTER, api_spoolss_EndDocPrinter},
8549 {"SPOOLSS_ADDJOB", NDR_SPOOLSS_ADDJOB, api_spoolss_AddJob},
8550 {"SPOOLSS_SCHEDULEJOB", NDR_SPOOLSS_SCHEDULEJOB, api_spoolss_ScheduleJob},
8551 {"SPOOLSS_GETPRINTERDATA", NDR_SPOOLSS_GETPRINTERDATA, api_spoolss_GetPrinterData},
8552 {"SPOOLSS_SETPRINTERDATA", NDR_SPOOLSS_SETPRINTERDATA, api_spoolss_SetPrinterData},
8553 {"SPOOLSS_WAITFORPRINTERCHANGE", NDR_SPOOLSS_WAITFORPRINTERCHANGE, api_spoolss_WaitForPrinterChange},
8554 {"SPOOLSS_CLOSEPRINTER", NDR_SPOOLSS_CLOSEPRINTER, api_spoolss_ClosePrinter},
8555 {"SPOOLSS_ADDFORM", NDR_SPOOLSS_ADDFORM, api_spoolss_AddForm},
8556 {"SPOOLSS_DELETEFORM", NDR_SPOOLSS_DELETEFORM, api_spoolss_DeleteForm},
8557 {"SPOOLSS_GETFORM", NDR_SPOOLSS_GETFORM, api_spoolss_GetForm},
8558 {"SPOOLSS_SETFORM", NDR_SPOOLSS_SETFORM, api_spoolss_SetForm},
8559 {"SPOOLSS_ENUMFORMS", NDR_SPOOLSS_ENUMFORMS, api_spoolss_EnumForms},
8560 {"SPOOLSS_ENUMPORTS", NDR_SPOOLSS_ENUMPORTS, api_spoolss_EnumPorts},
8561 {"SPOOLSS_ENUMMONITORS", NDR_SPOOLSS_ENUMMONITORS, api_spoolss_EnumMonitors},
8562 {"SPOOLSS_ADDPORT", NDR_SPOOLSS_ADDPORT, api_spoolss_AddPort},
8563 {"SPOOLSS_CONFIGUREPORT", NDR_SPOOLSS_CONFIGUREPORT, api_spoolss_ConfigurePort},
8564 {"SPOOLSS_DELETEPORT", NDR_SPOOLSS_DELETEPORT, api_spoolss_DeletePort},
8565 {"SPOOLSS_CREATEPRINTERIC", NDR_SPOOLSS_CREATEPRINTERIC, api_spoolss_CreatePrinterIC},
8566 {"SPOOLSS_PLAYGDISCRIPTONPRINTERIC", NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC, api_spoolss_PlayGDIScriptOnPrinterIC},
8567 {"SPOOLSS_DELETEPRINTERIC", NDR_SPOOLSS_DELETEPRINTERIC, api_spoolss_DeletePrinterIC},
8568 {"SPOOLSS_ADDPRINTERCONNECTION", NDR_SPOOLSS_ADDPRINTERCONNECTION, api_spoolss_AddPrinterConnection},
8569 {"SPOOLSS_DELETEPRINTERCONNECTION", NDR_SPOOLSS_DELETEPRINTERCONNECTION, api_spoolss_DeletePrinterConnection},
8570 {"SPOOLSS_PRINTERMESSAGEBOX", NDR_SPOOLSS_PRINTERMESSAGEBOX, api_spoolss_PrinterMessageBox},
8571 {"SPOOLSS_ADDMONITOR", NDR_SPOOLSS_ADDMONITOR, api_spoolss_AddMonitor},
8572 {"SPOOLSS_DELETEMONITOR", NDR_SPOOLSS_DELETEMONITOR, api_spoolss_DeleteMonitor},
8573 {"SPOOLSS_DELETEPRINTPROCESSOR", NDR_SPOOLSS_DELETEPRINTPROCESSOR, api_spoolss_DeletePrintProcessor},
8574 {"SPOOLSS_ADDPRINTPROVIDOR", NDR_SPOOLSS_ADDPRINTPROVIDOR, api_spoolss_AddPrintProvidor},
8575 {"SPOOLSS_DELETEPRINTPROVIDOR", NDR_SPOOLSS_DELETEPRINTPROVIDOR, api_spoolss_DeletePrintProvidor},
8576 {"SPOOLSS_ENUMPRINTPROCDATATYPES", NDR_SPOOLSS_ENUMPRINTPROCDATATYPES, api_spoolss_EnumPrintProcDataTypes},
8577 {"SPOOLSS_RESETPRINTER", NDR_SPOOLSS_RESETPRINTER, api_spoolss_ResetPrinter},
8578 {"SPOOLSS_GETPRINTERDRIVER2", NDR_SPOOLSS_GETPRINTERDRIVER2, api_spoolss_GetPrinterDriver2},
8579 {"SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION", NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION, api_spoolss_FindFirstPrinterChangeNotification},
8580 {"SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION", NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION, api_spoolss_FindNextPrinterChangeNotification},
8581 {"SPOOLSS_FINDCLOSEPRINTERNOTIFY", NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY, api_spoolss_FindClosePrinterNotify},
8582 {"SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD", NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD, api_spoolss_RouterFindFirstPrinterChangeNotificationOld},
8583 {"SPOOLSS_REPLYOPENPRINTER", NDR_SPOOLSS_REPLYOPENPRINTER, api_spoolss_ReplyOpenPrinter},
8584 {"SPOOLSS_ROUTERREPLYPRINTER", NDR_SPOOLSS_ROUTERREPLYPRINTER, api_spoolss_RouterReplyPrinter},
8585 {"SPOOLSS_REPLYCLOSEPRINTER", NDR_SPOOLSS_REPLYCLOSEPRINTER, api_spoolss_ReplyClosePrinter},
8586 {"SPOOLSS_ADDPORTEX", NDR_SPOOLSS_ADDPORTEX, api_spoolss_AddPortEx},
8587 {"SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION", NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION, api_spoolss_RouterFindFirstPrinterChangeNotification},
8588 {"SPOOLSS_SPOOLERINIT", NDR_SPOOLSS_SPOOLERINIT, api_spoolss_SpoolerInit},
8589 {"SPOOLSS_RESETPRINTEREX", NDR_SPOOLSS_RESETPRINTEREX, api_spoolss_ResetPrinterEx},
8590 {"SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX", NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX, api_spoolss_RemoteFindFirstPrinterChangeNotifyEx},
8591 {"SPOOLSS_ROUTERREPLYPRINTEREX", NDR_SPOOLSS_ROUTERREPLYPRINTEREX, api_spoolss_RouterReplyPrinterEx},
8592 {"SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY", NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY, api_spoolss_RouterRefreshPrinterChangeNotify},
8593 {"SPOOLSS_44", NDR_SPOOLSS_44, api_spoolss_44},
8594 {"SPOOLSS_OPENPRINTEREX", NDR_SPOOLSS_OPENPRINTEREX, api_spoolss_OpenPrinterEx},
8595 {"SPOOLSS_ADDPRINTEREX", NDR_SPOOLSS_ADDPRINTEREX, api_spoolss_AddPrinterEx},
8596 {"SPOOLSS_47", NDR_SPOOLSS_47, api_spoolss_47},
8597 {"SPOOLSS_ENUMPRINTERDATA", NDR_SPOOLSS_ENUMPRINTERDATA, api_spoolss_EnumPrinterData},
8598 {"SPOOLSS_DELETEPRINTERDATA", NDR_SPOOLSS_DELETEPRINTERDATA, api_spoolss_DeletePrinterData},
8599 {"SPOOLSS_4A", NDR_SPOOLSS_4A, api_spoolss_4a},
8600 {"SPOOLSS_4B", NDR_SPOOLSS_4B, api_spoolss_4b},
8601 {"SPOOLSS_4C", NDR_SPOOLSS_4C, api_spoolss_4c},
8602 {"SPOOLSS_SETPRINTERDATAEX", NDR_SPOOLSS_SETPRINTERDATAEX, api_spoolss_SetPrinterDataEx},
8603 {"SPOOLSS_GETPRINTERDATAEX", NDR_SPOOLSS_GETPRINTERDATAEX, api_spoolss_GetPrinterDataEx},
8604 {"SPOOLSS_ENUMPRINTERDATAEX", NDR_SPOOLSS_ENUMPRINTERDATAEX, api_spoolss_EnumPrinterDataEx},
8605 {"SPOOLSS_ENUMPRINTERKEY", NDR_SPOOLSS_ENUMPRINTERKEY, api_spoolss_EnumPrinterKey},
8606 {"SPOOLSS_DELETEPRINTERDATAEX", NDR_SPOOLSS_DELETEPRINTERDATAEX, api_spoolss_DeletePrinterDataEx},
8607 {"SPOOLSS_DELETEPRINTERKEY", NDR_SPOOLSS_DELETEPRINTERKEY, api_spoolss_DeletePrinterKey},
8608 {"SPOOLSS_53", NDR_SPOOLSS_53, api_spoolss_53},
8609 {"SPOOLSS_DELETEPRINTERDRIVEREX", NDR_SPOOLSS_DELETEPRINTERDRIVEREX, api_spoolss_DeletePrinterDriverEx},
8610 {"SPOOLSS_55", NDR_SPOOLSS_55, api_spoolss_55},
8611 {"SPOOLSS_56", NDR_SPOOLSS_56, api_spoolss_56},
8612 {"SPOOLSS_57", NDR_SPOOLSS_57, api_spoolss_57},
8613 {"SPOOLSS_XCVDATA", NDR_SPOOLSS_XCVDATA, api_spoolss_XcvData},
8614 {"SPOOLSS_ADDPRINTERDRIVEREX", NDR_SPOOLSS_ADDPRINTERDRIVEREX, api_spoolss_AddPrinterDriverEx},
8615 {"SPOOLSS_5A", NDR_SPOOLSS_5A, api_spoolss_5a},
8616 {"SPOOLSS_5B", NDR_SPOOLSS_5B, api_spoolss_5b},
8617 {"SPOOLSS_5C", NDR_SPOOLSS_5C, api_spoolss_5c},
8618 {"SPOOLSS_5D", NDR_SPOOLSS_5D, api_spoolss_5d},
8619 {"SPOOLSS_5E", NDR_SPOOLSS_5E, api_spoolss_5e},
8620 {"SPOOLSS_5F", NDR_SPOOLSS_5F, api_spoolss_5f},
8621 {"SPOOLSS_60", NDR_SPOOLSS_60, api_spoolss_60},
8622 {"SPOOLSS_61", NDR_SPOOLSS_61, api_spoolss_61},
8623 {"SPOOLSS_62", NDR_SPOOLSS_62, api_spoolss_62},
8624 {"SPOOLSS_63", NDR_SPOOLSS_63, api_spoolss_63},
8625 {"SPOOLSS_64", NDR_SPOOLSS_64, api_spoolss_64},
8626 {"SPOOLSS_65", NDR_SPOOLSS_65, api_spoolss_65},
8627 {"SPOOLSS_GETCOREPRINTERDRIVERS", NDR_SPOOLSS_GETCOREPRINTERDRIVERS, api_spoolss_GetCorePrinterDrivers},
8628 {"SPOOLSS_67", NDR_SPOOLSS_67, api_spoolss_67},
8629 {"SPOOLSS_GETPRINTERDRIVERPACKAGEPATH", NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH, api_spoolss_GetPrinterDriverPackagePath},
8630 {"SPOOLSS_69", NDR_SPOOLSS_69, api_spoolss_69},
8631 {"SPOOLSS_6A", NDR_SPOOLSS_6A, api_spoolss_6a},
8632 {"SPOOLSS_6B", NDR_SPOOLSS_6B, api_spoolss_6b},
8633 {"SPOOLSS_6C", NDR_SPOOLSS_6C, api_spoolss_6c},
8634 {"SPOOLSS_6D", NDR_SPOOLSS_6D, api_spoolss_6d},
8635 };
8636
8637 void spoolss_get_pipe_fns(struct api_struct **fns, int *n_fns)
8638 {
8639 *fns = api_spoolss_cmds;
8640 *n_fns = sizeof(api_spoolss_cmds) / sizeof(struct api_struct);
8641 }
8642
8643 NTSTATUS rpc_spoolss_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r)
8644 {
8645 if (cli->pipes_struct == NULL) {
8646 return NT_STATUS_INVALID_PARAMETER;
8647 }
8648
8649 switch (opnum)
8650 {
8651 case NDR_SPOOLSS_ENUMPRINTERS: {
8652 struct spoolss_EnumPrinters *r = (struct spoolss_EnumPrinters *)_r;
8653 ZERO_STRUCT(r->out);
8654 r->out.count = talloc_zero(mem_ctx, uint32_t);
8655 if (r->out.count == NULL) {
8656 return NT_STATUS_NO_MEMORY;
8657 }
8658
8659 r->out.info = talloc_zero(mem_ctx, union spoolss_PrinterInfo *);
8660 if (r->out.info == NULL) {
8661 return NT_STATUS_NO_MEMORY;
8662 }
8663
8664 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8665 if (r->out.needed == NULL) {
8666 return NT_STATUS_NO_MEMORY;
8667 }
8668
8669 r->out.result = _spoolss_EnumPrinters(cli->pipes_struct, r);
8670 return NT_STATUS_OK;
8671 }
8672
8673 case NDR_SPOOLSS_OPENPRINTER: {
8674 struct spoolss_OpenPrinter *r = (struct spoolss_OpenPrinter *)_r;
8675 ZERO_STRUCT(r->out);
8676 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
8677 if (r->out.handle == NULL) {
8678 return NT_STATUS_NO_MEMORY;
8679 }
8680
8681 r->out.result = _spoolss_OpenPrinter(cli->pipes_struct, r);
8682 return NT_STATUS_OK;
8683 }
8684
8685 case NDR_SPOOLSS_SETJOB: {
8686 struct spoolss_SetJob *r = (struct spoolss_SetJob *)_r;
8687 r->out.result = _spoolss_SetJob(cli->pipes_struct, r);
8688 return NT_STATUS_OK;
8689 }
8690
8691 case NDR_SPOOLSS_GETJOB: {
8692 struct spoolss_GetJob *r = (struct spoolss_GetJob *)_r;
8693 ZERO_STRUCT(r->out);
8694 r->out.info = talloc_zero(mem_ctx, union spoolss_JobInfo);
8695 if (r->out.info == NULL) {
8696 return NT_STATUS_NO_MEMORY;
8697 }
8698
8699 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8700 if (r->out.needed == NULL) {
8701 return NT_STATUS_NO_MEMORY;
8702 }
8703
8704 r->out.result = _spoolss_GetJob(cli->pipes_struct, r);
8705 return NT_STATUS_OK;
8706 }
8707
8708 case NDR_SPOOLSS_ENUMJOBS: {
8709 struct spoolss_EnumJobs *r = (struct spoolss_EnumJobs *)_r;
8710 ZERO_STRUCT(r->out);
8711 r->out.count = talloc_zero(mem_ctx, uint32_t);
8712 if (r->out.count == NULL) {
8713 return NT_STATUS_NO_MEMORY;
8714 }
8715
8716 r->out.info = talloc_zero(mem_ctx, union spoolss_JobInfo *);
8717 if (r->out.info == NULL) {
8718 return NT_STATUS_NO_MEMORY;
8719 }
8720
8721 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8722 if (r->out.needed == NULL) {
8723 return NT_STATUS_NO_MEMORY;
8724 }
8725
8726 r->out.result = _spoolss_EnumJobs(cli->pipes_struct, r);
8727 return NT_STATUS_OK;
8728 }
8729
8730 case NDR_SPOOLSS_ADDPRINTER: {
8731 struct spoolss_AddPrinter *r = (struct spoolss_AddPrinter *)_r;
8732 ZERO_STRUCT(r->out);
8733 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
8734 if (r->out.handle == NULL) {
8735 return NT_STATUS_NO_MEMORY;
8736 }
8737
8738 r->out.result = _spoolss_AddPrinter(cli->pipes_struct, r);
8739 return NT_STATUS_OK;
8740 }
8741
8742 case NDR_SPOOLSS_DELETEPRINTER: {
8743 struct spoolss_DeletePrinter *r = (struct spoolss_DeletePrinter *)_r;
8744 r->out.result = _spoolss_DeletePrinter(cli->pipes_struct, r);
8745 return NT_STATUS_OK;
8746 }
8747
8748 case NDR_SPOOLSS_SETPRINTER: {
8749 struct spoolss_SetPrinter *r = (struct spoolss_SetPrinter *)_r;
8750 r->out.result = _spoolss_SetPrinter(cli->pipes_struct, r);
8751 return NT_STATUS_OK;
8752 }
8753
8754 case NDR_SPOOLSS_GETPRINTER: {
8755 struct spoolss_GetPrinter *r = (struct spoolss_GetPrinter *)_r;
8756 ZERO_STRUCT(r->out);
8757 r->out.info = talloc_zero(mem_ctx, union spoolss_PrinterInfo);
8758 if (r->out.info == NULL) {
8759 return NT_STATUS_NO_MEMORY;
8760 }
8761
8762 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8763 if (r->out.needed == NULL) {
8764 return NT_STATUS_NO_MEMORY;
8765 }
8766
8767 r->out.result = _spoolss_GetPrinter(cli->pipes_struct, r);
8768 return NT_STATUS_OK;
8769 }
8770
8771 case NDR_SPOOLSS_ADDPRINTERDRIVER: {
8772 struct spoolss_AddPrinterDriver *r = (struct spoolss_AddPrinterDriver *)_r;
8773 r->out.result = _spoolss_AddPrinterDriver(cli->pipes_struct, r);
8774 return NT_STATUS_OK;
8775 }
8776
8777 case NDR_SPOOLSS_ENUMPRINTERDRIVERS: {
8778 struct spoolss_EnumPrinterDrivers *r = (struct spoolss_EnumPrinterDrivers *)_r;
8779 ZERO_STRUCT(r->out);
8780 r->out.count = talloc_zero(mem_ctx, uint32_t);
8781 if (r->out.count == NULL) {
8782 return NT_STATUS_NO_MEMORY;
8783 }
8784
8785 r->out.info = talloc_zero(mem_ctx, union spoolss_DriverInfo *);
8786 if (r->out.info == NULL) {
8787 return NT_STATUS_NO_MEMORY;
8788 }
8789
8790 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8791 if (r->out.needed == NULL) {
8792 return NT_STATUS_NO_MEMORY;
8793 }
8794
8795 r->out.result = _spoolss_EnumPrinterDrivers(cli->pipes_struct, r);
8796 return NT_STATUS_OK;
8797 }
8798
8799 case NDR_SPOOLSS_GETPRINTERDRIVER: {
8800 struct spoolss_GetPrinterDriver *r = (struct spoolss_GetPrinterDriver *)_r;
8801 ZERO_STRUCT(r->out);
8802 r->out.info = talloc_zero(mem_ctx, union spoolss_DriverInfo);
8803 if (r->out.info == NULL) {
8804 return NT_STATUS_NO_MEMORY;
8805 }
8806
8807 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8808 if (r->out.needed == NULL) {
8809 return NT_STATUS_NO_MEMORY;
8810 }
8811
8812 r->out.result = _spoolss_GetPrinterDriver(cli->pipes_struct, r);
8813 return NT_STATUS_OK;
8814 }
8815
8816 case NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY: {
8817 struct spoolss_GetPrinterDriverDirectory *r = (struct spoolss_GetPrinterDriverDirectory *)_r;
8818 ZERO_STRUCT(r->out);
8819 r->out.info = talloc_zero(mem_ctx, union spoolss_DriverDirectoryInfo);
8820 if (r->out.info == NULL) {
8821 return NT_STATUS_NO_MEMORY;
8822 }
8823
8824 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8825 if (r->out.needed == NULL) {
8826 return NT_STATUS_NO_MEMORY;
8827 }
8828
8829 r->out.result = _spoolss_GetPrinterDriverDirectory(cli->pipes_struct, r);
8830 return NT_STATUS_OK;
8831 }
8832
8833 case NDR_SPOOLSS_DELETEPRINTERDRIVER: {
8834 struct spoolss_DeletePrinterDriver *r = (struct spoolss_DeletePrinterDriver *)_r;
8835 r->out.result = _spoolss_DeletePrinterDriver(cli->pipes_struct, r);
8836 return NT_STATUS_OK;
8837 }
8838
8839 case NDR_SPOOLSS_ADDPRINTPROCESSOR: {
8840 struct spoolss_AddPrintProcessor *r = (struct spoolss_AddPrintProcessor *)_r;
8841 r->out.result = _spoolss_AddPrintProcessor(cli->pipes_struct, r);
8842 return NT_STATUS_OK;
8843 }
8844
8845 case NDR_SPOOLSS_ENUMPRINTPROCESSORS: {
8846 struct spoolss_EnumPrintProcessors *r = (struct spoolss_EnumPrintProcessors *)_r;
8847 ZERO_STRUCT(r->out);
8848 r->out.count = talloc_zero(mem_ctx, uint32_t);
8849 if (r->out.count == NULL) {
8850 return NT_STATUS_NO_MEMORY;
8851 }
8852
8853 r->out.info = talloc_zero(mem_ctx, union spoolss_PrintProcessorInfo *);
8854 if (r->out.info == NULL) {
8855 return NT_STATUS_NO_MEMORY;
8856 }
8857
8858 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8859 if (r->out.needed == NULL) {
8860 return NT_STATUS_NO_MEMORY;
8861 }
8862
8863 r->out.result = _spoolss_EnumPrintProcessors(cli->pipes_struct, r);
8864 return NT_STATUS_OK;
8865 }
8866
8867 case NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY: {
8868 struct spoolss_GetPrintProcessorDirectory *r = (struct spoolss_GetPrintProcessorDirectory *)_r;
8869 ZERO_STRUCT(r->out);
8870 r->out.info = talloc_zero(mem_ctx, union spoolss_PrintProcessorDirectoryInfo);
8871 if (r->out.info == NULL) {
8872 return NT_STATUS_NO_MEMORY;
8873 }
8874
8875 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8876 if (r->out.needed == NULL) {
8877 return NT_STATUS_NO_MEMORY;
8878 }
8879
8880 r->out.result = _spoolss_GetPrintProcessorDirectory(cli->pipes_struct, r);
8881 return NT_STATUS_OK;
8882 }
8883
8884 case NDR_SPOOLSS_STARTDOCPRINTER: {
8885 struct spoolss_StartDocPrinter *r = (struct spoolss_StartDocPrinter *)_r;
8886 ZERO_STRUCT(r->out);
8887 r->out.job_id = talloc_zero(mem_ctx, uint32_t);
8888 if (r->out.job_id == NULL) {
8889 return NT_STATUS_NO_MEMORY;
8890 }
8891
8892 r->out.result = _spoolss_StartDocPrinter(cli->pipes_struct, r);
8893 return NT_STATUS_OK;
8894 }
8895
8896 case NDR_SPOOLSS_STARTPAGEPRINTER: {
8897 struct spoolss_StartPagePrinter *r = (struct spoolss_StartPagePrinter *)_r;
8898 r->out.result = _spoolss_StartPagePrinter(cli->pipes_struct, r);
8899 return NT_STATUS_OK;
8900 }
8901
8902 case NDR_SPOOLSS_WRITEPRINTER: {
8903 struct spoolss_WritePrinter *r = (struct spoolss_WritePrinter *)_r;
8904 ZERO_STRUCT(r->out);
8905 r->out.num_written = talloc_zero(mem_ctx, uint32_t);
8906 if (r->out.num_written == NULL) {
8907 return NT_STATUS_NO_MEMORY;
8908 }
8909
8910 r->out.result = _spoolss_WritePrinter(cli->pipes_struct, r);
8911 return NT_STATUS_OK;
8912 }
8913
8914 case NDR_SPOOLSS_ENDPAGEPRINTER: {
8915 struct spoolss_EndPagePrinter *r = (struct spoolss_EndPagePrinter *)_r;
8916 r->out.result = _spoolss_EndPagePrinter(cli->pipes_struct, r);
8917 return NT_STATUS_OK;
8918 }
8919
8920 case NDR_SPOOLSS_ABORTPRINTER: {
8921 struct spoolss_AbortPrinter *r = (struct spoolss_AbortPrinter *)_r;
8922 r->out.result = _spoolss_AbortPrinter(cli->pipes_struct, r);
8923 return NT_STATUS_OK;
8924 }
8925
8926 case NDR_SPOOLSS_READPRINTER: {
8927 struct spoolss_ReadPrinter *r = (struct spoolss_ReadPrinter *)_r;
8928 ZERO_STRUCT(r->out);
8929 r->out.data = talloc_zero_array(mem_ctx, uint8_t, r->in.data_size);
8930 if (r->out.data == NULL) {
8931 return NT_STATUS_NO_MEMORY;
8932 }
8933
8934 r->out._data_size = talloc_zero(mem_ctx, uint32_t);
8935 if (r->out._data_size == NULL) {
8936 return NT_STATUS_NO_MEMORY;
8937 }
8938
8939 r->out.result = _spoolss_ReadPrinter(cli->pipes_struct, r);
8940 return NT_STATUS_OK;
8941 }
8942
8943 case NDR_SPOOLSS_ENDDOCPRINTER: {
8944 struct spoolss_EndDocPrinter *r = (struct spoolss_EndDocPrinter *)_r;
8945 r->out.result = _spoolss_EndDocPrinter(cli->pipes_struct, r);
8946 return NT_STATUS_OK;
8947 }
8948
8949 case NDR_SPOOLSS_ADDJOB: {
8950 struct spoolss_AddJob *r = (struct spoolss_AddJob *)_r;
8951 ZERO_STRUCT(r->out);
8952 r->out.buffer = r->in.buffer;
8953 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8954 if (r->out.needed == NULL) {
8955 return NT_STATUS_NO_MEMORY;
8956 }
8957
8958 r->out.result = _spoolss_AddJob(cli->pipes_struct, r);
8959 return NT_STATUS_OK;
8960 }
8961
8962 case NDR_SPOOLSS_SCHEDULEJOB: {
8963 struct spoolss_ScheduleJob *r = (struct spoolss_ScheduleJob *)_r;
8964 r->out.result = _spoolss_ScheduleJob(cli->pipes_struct, r);
8965 return NT_STATUS_OK;
8966 }
8967
8968 case NDR_SPOOLSS_GETPRINTERDATA: {
8969 struct spoolss_GetPrinterData *r = (struct spoolss_GetPrinterData *)_r;
8970 ZERO_STRUCT(r->out);
8971 r->out.type = talloc_zero(mem_ctx, enum winreg_Type);
8972 if (r->out.type == NULL) {
8973 return NT_STATUS_NO_MEMORY;
8974 }
8975
8976 r->out.data = talloc_zero(mem_ctx, union spoolss_PrinterData);
8977 if (r->out.data == NULL) {
8978 return NT_STATUS_NO_MEMORY;
8979 }
8980
8981 r->out.needed = talloc_zero(mem_ctx, uint32_t);
8982 if (r->out.needed == NULL) {
8983 return NT_STATUS_NO_MEMORY;
8984 }
8985
8986 r->out.result = _spoolss_GetPrinterData(cli->pipes_struct, r);
8987 return NT_STATUS_OK;
8988 }
8989
8990 case NDR_SPOOLSS_SETPRINTERDATA: {
8991 struct spoolss_SetPrinterData *r = (struct spoolss_SetPrinterData *)_r;
8992 r->out.result = _spoolss_SetPrinterData(cli->pipes_struct, r);
8993 return NT_STATUS_OK;
8994 }
8995
8996 case NDR_SPOOLSS_WAITFORPRINTERCHANGE: {
8997 struct spoolss_WaitForPrinterChange *r = (struct spoolss_WaitForPrinterChange *)_r;
8998 r->out.result = _spoolss_WaitForPrinterChange(cli->pipes_struct, r);
8999 return NT_STATUS_OK;
9000 }
9001
9002 case NDR_SPOOLSS_CLOSEPRINTER: {
9003 struct spoolss_ClosePrinter *r = (struct spoolss_ClosePrinter *)_r;
9004 ZERO_STRUCT(r->out);
9005 r->out.handle = r->in.handle;
9006 r->out.result = _spoolss_ClosePrinter(cli->pipes_struct, r);
9007 return NT_STATUS_OK;
9008 }
9009
9010 case NDR_SPOOLSS_ADDFORM: {
9011 struct spoolss_AddForm *r = (struct spoolss_AddForm *)_r;
9012 r->out.result = _spoolss_AddForm(cli->pipes_struct, r);
9013 return NT_STATUS_OK;
9014 }
9015
9016 case NDR_SPOOLSS_DELETEFORM: {
9017 struct spoolss_DeleteForm *r = (struct spoolss_DeleteForm *)_r;
9018 r->out.result = _spoolss_DeleteForm(cli->pipes_struct, r);
9019 return NT_STATUS_OK;
9020 }
9021
9022 case NDR_SPOOLSS_GETFORM: {
9023 struct spoolss_GetForm *r = (struct spoolss_GetForm *)_r;
9024 ZERO_STRUCT(r->out);
9025 r->out.info = talloc_zero(mem_ctx, union spoolss_FormInfo);
9026 if (r->out.info == NULL) {
9027 return NT_STATUS_NO_MEMORY;
9028 }
9029
9030 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9031 if (r->out.needed == NULL) {
9032 return NT_STATUS_NO_MEMORY;
9033 }
9034
9035 r->out.result = _spoolss_GetForm(cli->pipes_struct, r);
9036 return NT_STATUS_OK;
9037 }
9038
9039 case NDR_SPOOLSS_SETFORM: {
9040 struct spoolss_SetForm *r = (struct spoolss_SetForm *)_r;
9041 r->out.result = _spoolss_SetForm(cli->pipes_struct, r);
9042 return NT_STATUS_OK;
9043 }
9044
9045 case NDR_SPOOLSS_ENUMFORMS: {
9046 struct spoolss_EnumForms *r = (struct spoolss_EnumForms *)_r;
9047 ZERO_STRUCT(r->out);
9048 r->out.count = talloc_zero(mem_ctx, uint32_t);
9049 if (r->out.count == NULL) {
9050 return NT_STATUS_NO_MEMORY;
9051 }
9052
9053 r->out.info = talloc_zero(mem_ctx, union spoolss_FormInfo *);
9054 if (r->out.info == NULL) {
9055 return NT_STATUS_NO_MEMORY;
9056 }
9057
9058 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9059 if (r->out.needed == NULL) {
9060 return NT_STATUS_NO_MEMORY;
9061 }
9062
9063 r->out.result = _spoolss_EnumForms(cli->pipes_struct, r);
9064 return NT_STATUS_OK;
9065 }
9066
9067 case NDR_SPOOLSS_ENUMPORTS: {
9068 struct spoolss_EnumPorts *r = (struct spoolss_EnumPorts *)_r;
9069 ZERO_STRUCT(r->out);
9070 r->out.count = talloc_zero(mem_ctx, uint32_t);
9071 if (r->out.count == NULL) {
9072 return NT_STATUS_NO_MEMORY;
9073 }
9074
9075 r->out.info = talloc_zero(mem_ctx, union spoolss_PortInfo *);
9076 if (r->out.info == NULL) {
9077 return NT_STATUS_NO_MEMORY;
9078 }
9079
9080 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9081 if (r->out.needed == NULL) {
9082 return NT_STATUS_NO_MEMORY;
9083 }
9084
9085 r->out.result = _spoolss_EnumPorts(cli->pipes_struct, r);
9086 return NT_STATUS_OK;
9087 }
9088
9089 case NDR_SPOOLSS_ENUMMONITORS: {
9090 struct spoolss_EnumMonitors *r = (struct spoolss_EnumMonitors *)_r;
9091 ZERO_STRUCT(r->out);
9092 r->out.count = talloc_zero(mem_ctx, uint32_t);
9093 if (r->out.count == NULL) {
9094 return NT_STATUS_NO_MEMORY;
9095 }
9096
9097 r->out.info = talloc_zero(mem_ctx, union spoolss_MonitorInfo *);
9098 if (r->out.info == NULL) {
9099 return NT_STATUS_NO_MEMORY;
9100 }
9101
9102 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9103 if (r->out.needed == NULL) {
9104 return NT_STATUS_NO_MEMORY;
9105 }
9106
9107 r->out.result = _spoolss_EnumMonitors(cli->pipes_struct, r);
9108 return NT_STATUS_OK;
9109 }
9110
9111 case NDR_SPOOLSS_ADDPORT: {
9112 struct spoolss_AddPort *r = (struct spoolss_AddPort *)_r;
9113 r->out.result = _spoolss_AddPort(cli->pipes_struct, r);
9114 return NT_STATUS_OK;
9115 }
9116
9117 case NDR_SPOOLSS_CONFIGUREPORT: {
9118 struct spoolss_ConfigurePort *r = (struct spoolss_ConfigurePort *)_r;
9119 r->out.result = _spoolss_ConfigurePort(cli->pipes_struct, r);
9120 return NT_STATUS_OK;
9121 }
9122
9123 case NDR_SPOOLSS_DELETEPORT: {
9124 struct spoolss_DeletePort *r = (struct spoolss_DeletePort *)_r;
9125 r->out.result = _spoolss_DeletePort(cli->pipes_struct, r);
9126 return NT_STATUS_OK;
9127 }
9128
9129 case NDR_SPOOLSS_CREATEPRINTERIC: {
9130 struct spoolss_CreatePrinterIC *r = (struct spoolss_CreatePrinterIC *)_r;
9131 ZERO_STRUCT(r->out);
9132 r->out.gdi_handle = talloc_zero(mem_ctx, struct policy_handle);
9133 if (r->out.gdi_handle == NULL) {
9134 return NT_STATUS_NO_MEMORY;
9135 }
9136
9137 r->out.result = _spoolss_CreatePrinterIC(cli->pipes_struct, r);
9138 return NT_STATUS_OK;
9139 }
9140
9141 case NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC: {
9142 struct spoolss_PlayGDIScriptOnPrinterIC *r = (struct spoolss_PlayGDIScriptOnPrinterIC *)_r;
9143 r->out.result = _spoolss_PlayGDIScriptOnPrinterIC(cli->pipes_struct, r);
9144 return NT_STATUS_OK;
9145 }
9146
9147 case NDR_SPOOLSS_DELETEPRINTERIC: {
9148 struct spoolss_DeletePrinterIC *r = (struct spoolss_DeletePrinterIC *)_r;
9149 ZERO_STRUCT(r->out);
9150 r->out.gdi_handle = r->in.gdi_handle;
9151 r->out.result = _spoolss_DeletePrinterIC(cli->pipes_struct, r);
9152 return NT_STATUS_OK;
9153 }
9154
9155 case NDR_SPOOLSS_ADDPRINTERCONNECTION: {
9156 struct spoolss_AddPrinterConnection *r = (struct spoolss_AddPrinterConnection *)_r;
9157 r->out.result = _spoolss_AddPrinterConnection(cli->pipes_struct, r);
9158 return NT_STATUS_OK;
9159 }
9160
9161 case NDR_SPOOLSS_DELETEPRINTERCONNECTION: {
9162 struct spoolss_DeletePrinterConnection *r = (struct spoolss_DeletePrinterConnection *)_r;
9163 r->out.result = _spoolss_DeletePrinterConnection(cli->pipes_struct, r);
9164 return NT_STATUS_OK;
9165 }
9166
9167 case NDR_SPOOLSS_PRINTERMESSAGEBOX: {
9168 struct spoolss_PrinterMessageBox *r = (struct spoolss_PrinterMessageBox *)_r;
9169 r->out.result = _spoolss_PrinterMessageBox(cli->pipes_struct, r);
9170 return NT_STATUS_OK;
9171 }
9172
9173 case NDR_SPOOLSS_ADDMONITOR: {
9174 struct spoolss_AddMonitor *r = (struct spoolss_AddMonitor *)_r;
9175 r->out.result = _spoolss_AddMonitor(cli->pipes_struct, r);
9176 return NT_STATUS_OK;
9177 }
9178
9179 case NDR_SPOOLSS_DELETEMONITOR: {
9180 struct spoolss_DeleteMonitor *r = (struct spoolss_DeleteMonitor *)_r;
9181 r->out.result = _spoolss_DeleteMonitor(cli->pipes_struct, r);
9182 return NT_STATUS_OK;
9183 }
9184
9185 case NDR_SPOOLSS_DELETEPRINTPROCESSOR: {
9186 struct spoolss_DeletePrintProcessor *r = (struct spoolss_DeletePrintProcessor *)_r;
9187 r->out.result = _spoolss_DeletePrintProcessor(cli->pipes_struct, r);
9188 return NT_STATUS_OK;
9189 }
9190
9191 case NDR_SPOOLSS_ADDPRINTPROVIDOR: {
9192 struct spoolss_AddPrintProvidor *r = (struct spoolss_AddPrintProvidor *)_r;
9193 r->out.result = _spoolss_AddPrintProvidor(cli->pipes_struct, r);
9194 return NT_STATUS_OK;
9195 }
9196
9197 case NDR_SPOOLSS_DELETEPRINTPROVIDOR: {
9198 struct spoolss_DeletePrintProvidor *r = (struct spoolss_DeletePrintProvidor *)_r;
9199 r->out.result = _spoolss_DeletePrintProvidor(cli->pipes_struct, r);
9200 return NT_STATUS_OK;
9201 }
9202
9203 case NDR_SPOOLSS_ENUMPRINTPROCDATATYPES: {
9204 struct spoolss_EnumPrintProcDataTypes *r = (struct spoolss_EnumPrintProcDataTypes *)_r;
9205 ZERO_STRUCT(r->out);
9206 r->out.count = talloc_zero(mem_ctx, uint32_t);
9207 if (r->out.count == NULL) {
9208 return NT_STATUS_NO_MEMORY;
9209 }
9210
9211 r->out.info = talloc_zero(mem_ctx, union spoolss_PrintProcDataTypesInfo *);
9212 if (r->out.info == NULL) {
9213 return NT_STATUS_NO_MEMORY;
9214 }
9215
9216 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9217 if (r->out.needed == NULL) {
9218 return NT_STATUS_NO_MEMORY;
9219 }
9220
9221 r->out.result = _spoolss_EnumPrintProcDataTypes(cli->pipes_struct, r);
9222 return NT_STATUS_OK;
9223 }
9224
9225 case NDR_SPOOLSS_RESETPRINTER: {
9226 struct spoolss_ResetPrinter *r = (struct spoolss_ResetPrinter *)_r;
9227 r->out.result = _spoolss_ResetPrinter(cli->pipes_struct, r);
9228 return NT_STATUS_OK;
9229 }
9230
9231 case NDR_SPOOLSS_GETPRINTERDRIVER2: {
9232 struct spoolss_GetPrinterDriver2 *r = (struct spoolss_GetPrinterDriver2 *)_r;
9233 ZERO_STRUCT(r->out);
9234 r->out.info = talloc_zero(mem_ctx, union spoolss_DriverInfo);
9235 if (r->out.info == NULL) {
9236 return NT_STATUS_NO_MEMORY;
9237 }
9238
9239 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9240 if (r->out.needed == NULL) {
9241 return NT_STATUS_NO_MEMORY;
9242 }
9243
9244 r->out.server_major_version = talloc_zero(mem_ctx, uint32_t);
9245 if (r->out.server_major_version == NULL) {
9246 return NT_STATUS_NO_MEMORY;
9247 }
9248
9249 r->out.server_minor_version = talloc_zero(mem_ctx, uint32_t);
9250 if (r->out.server_minor_version == NULL) {
9251 return NT_STATUS_NO_MEMORY;
9252 }
9253
9254 r->out.result = _spoolss_GetPrinterDriver2(cli->pipes_struct, r);
9255 return NT_STATUS_OK;
9256 }
9257
9258 case NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION: {
9259 struct spoolss_FindFirstPrinterChangeNotification *r = (struct spoolss_FindFirstPrinterChangeNotification *)_r;
9260 r->out.result = _spoolss_FindFirstPrinterChangeNotification(cli->pipes_struct, r);
9261 return NT_STATUS_OK;
9262 }
9263
9264 case NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION: {
9265 struct spoolss_FindNextPrinterChangeNotification *r = (struct spoolss_FindNextPrinterChangeNotification *)_r;
9266 r->out.result = _spoolss_FindNextPrinterChangeNotification(cli->pipes_struct, r);
9267 return NT_STATUS_OK;
9268 }
9269
9270 case NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY: {
9271 struct spoolss_FindClosePrinterNotify *r = (struct spoolss_FindClosePrinterNotify *)_r;
9272 r->out.result = _spoolss_FindClosePrinterNotify(cli->pipes_struct, r);
9273 return NT_STATUS_OK;
9274 }
9275
9276 case NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD: {
9277 struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r = (struct spoolss_RouterFindFirstPrinterChangeNotificationOld *)_r;
9278 r->out.result = _spoolss_RouterFindFirstPrinterChangeNotificationOld(cli->pipes_struct, r);
9279 return NT_STATUS_OK;
9280 }
9281
9282 case NDR_SPOOLSS_REPLYOPENPRINTER: {
9283 struct spoolss_ReplyOpenPrinter *r = (struct spoolss_ReplyOpenPrinter *)_r;
9284 ZERO_STRUCT(r->out);
9285 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
9286 if (r->out.handle == NULL) {
9287 return NT_STATUS_NO_MEMORY;
9288 }
9289
9290 r->out.result = _spoolss_ReplyOpenPrinter(cli->pipes_struct, r);
9291 return NT_STATUS_OK;
9292 }
9293
9294 case NDR_SPOOLSS_ROUTERREPLYPRINTER: {
9295 struct spoolss_RouterReplyPrinter *r = (struct spoolss_RouterReplyPrinter *)_r;
9296 r->out.result = _spoolss_RouterReplyPrinter(cli->pipes_struct, r);
9297 return NT_STATUS_OK;
9298 }
9299
9300 case NDR_SPOOLSS_REPLYCLOSEPRINTER: {
9301 struct spoolss_ReplyClosePrinter *r = (struct spoolss_ReplyClosePrinter *)_r;
9302 ZERO_STRUCT(r->out);
9303 r->out.handle = r->in.handle;
9304 r->out.result = _spoolss_ReplyClosePrinter(cli->pipes_struct, r);
9305 return NT_STATUS_OK;
9306 }
9307
9308 case NDR_SPOOLSS_ADDPORTEX: {
9309 struct spoolss_AddPortEx *r = (struct spoolss_AddPortEx *)_r;
9310 r->out.result = _spoolss_AddPortEx(cli->pipes_struct, r);
9311 return NT_STATUS_OK;
9312 }
9313
9314 case NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION: {
9315 struct spoolss_RouterFindFirstPrinterChangeNotification *r = (struct spoolss_RouterFindFirstPrinterChangeNotification *)_r;
9316 r->out.result = _spoolss_RouterFindFirstPrinterChangeNotification(cli->pipes_struct, r);
9317 return NT_STATUS_OK;
9318 }
9319
9320 case NDR_SPOOLSS_SPOOLERINIT: {
9321 struct spoolss_SpoolerInit *r = (struct spoolss_SpoolerInit *)_r;
9322 r->out.result = _spoolss_SpoolerInit(cli->pipes_struct, r);
9323 return NT_STATUS_OK;
9324 }
9325
9326 case NDR_SPOOLSS_RESETPRINTEREX: {
9327 struct spoolss_ResetPrinterEx *r = (struct spoolss_ResetPrinterEx *)_r;
9328 r->out.result = _spoolss_ResetPrinterEx(cli->pipes_struct, r);
9329 return NT_STATUS_OK;
9330 }
9331
9332 case NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX: {
9333 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r = (struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *)_r;
9334 r->out.result = _spoolss_RemoteFindFirstPrinterChangeNotifyEx(cli->pipes_struct, r);
9335 return NT_STATUS_OK;
9336 }
9337
9338 case NDR_SPOOLSS_ROUTERREPLYPRINTEREX: {
9339 struct spoolss_RouterReplyPrinterEx *r = (struct spoolss_RouterReplyPrinterEx *)_r;
9340 ZERO_STRUCT(r->out);
9341 r->out.reply_result = talloc_zero(mem_ctx, uint32_t);
9342 if (r->out.reply_result == NULL) {
9343 return NT_STATUS_NO_MEMORY;
9344 }
9345
9346 r->out.result = _spoolss_RouterReplyPrinterEx(cli->pipes_struct, r);
9347 return NT_STATUS_OK;
9348 }
9349
9350 case NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY: {
9351 struct spoolss_RouterRefreshPrinterChangeNotify *r = (struct spoolss_RouterRefreshPrinterChangeNotify *)_r;
9352 ZERO_STRUCT(r->out);
9353 r->out.info = talloc_zero(mem_ctx, struct spoolss_NotifyInfo *);
9354 if (r->out.info == NULL) {
9355 return NT_STATUS_NO_MEMORY;
9356 }
9357
9358 r->out.result = _spoolss_RouterRefreshPrinterChangeNotify(cli->pipes_struct, r);
9359 return NT_STATUS_OK;
9360 }
9361
9362 case NDR_SPOOLSS_44: {
9363 struct spoolss_44 *r = (struct spoolss_44 *)_r;
9364 r->out.result = _spoolss_44(cli->pipes_struct, r);
9365 return NT_STATUS_OK;
9366 }
9367
9368 case NDR_SPOOLSS_OPENPRINTEREX: {
9369 struct spoolss_OpenPrinterEx *r = (struct spoolss_OpenPrinterEx *)_r;
9370 ZERO_STRUCT(r->out);
9371 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
9372 if (r->out.handle == NULL) {
9373 return NT_STATUS_NO_MEMORY;
9374 }
9375
9376 r->out.result = _spoolss_OpenPrinterEx(cli->pipes_struct, r);
9377 return NT_STATUS_OK;
9378 }
9379
9380 case NDR_SPOOLSS_ADDPRINTEREX: {
9381 struct spoolss_AddPrinterEx *r = (struct spoolss_AddPrinterEx *)_r;
9382 ZERO_STRUCT(r->out);
9383 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
9384 if (r->out.handle == NULL) {
9385 return NT_STATUS_NO_MEMORY;
9386 }
9387
9388 r->out.result = _spoolss_AddPrinterEx(cli->pipes_struct, r);
9389 return NT_STATUS_OK;
9390 }
9391
9392 case NDR_SPOOLSS_47: {
9393 struct spoolss_47 *r = (struct spoolss_47 *)_r;
9394 r->out.result = _spoolss_47(cli->pipes_struct, r);
9395 return NT_STATUS_OK;
9396 }
9397
9398 case NDR_SPOOLSS_ENUMPRINTERDATA: {
9399 struct spoolss_EnumPrinterData *r = (struct spoolss_EnumPrinterData *)_r;
9400 ZERO_STRUCT(r->out);
9401 r->out.value_name = talloc_zero_array(mem_ctx, const char, r->in.value_offered / 2);
9402 if (r->out.value_name == NULL) {
9403 return NT_STATUS_NO_MEMORY;
9404 }
9405
9406 r->out.value_needed = talloc_zero(mem_ctx, uint32_t);
9407 if (r->out.value_needed == NULL) {
9408 return NT_STATUS_NO_MEMORY;
9409 }
9410
9411 r->out.type = talloc_zero(mem_ctx, enum winreg_Type);
9412 if (r->out.type == NULL) {
9413 return NT_STATUS_NO_MEMORY;
9414 }
9415
9416 r->out.data = talloc_zero_array(mem_ctx, uint8_t, r->in.data_offered);
9417 if (r->out.data == NULL) {
9418 return NT_STATUS_NO_MEMORY;
9419 }
9420
9421 r->out.data_needed = talloc_zero(mem_ctx, uint32_t);
9422 if (r->out.data_needed == NULL) {
9423 return NT_STATUS_NO_MEMORY;
9424 }
9425
9426 r->out.result = _spoolss_EnumPrinterData(cli->pipes_struct, r);
9427 return NT_STATUS_OK;
9428 }
9429
9430 case NDR_SPOOLSS_DELETEPRINTERDATA: {
9431 struct spoolss_DeletePrinterData *r = (struct spoolss_DeletePrinterData *)_r;
9432 r->out.result = _spoolss_DeletePrinterData(cli->pipes_struct, r);
9433 return NT_STATUS_OK;
9434 }
9435
9436 case NDR_SPOOLSS_4A: {
9437 struct spoolss_4a *r = (struct spoolss_4a *)_r;
9438 r->out.result = _spoolss_4a(cli->pipes_struct, r);
9439 return NT_STATUS_OK;
9440 }
9441
9442 case NDR_SPOOLSS_4B: {
9443 struct spoolss_4b *r = (struct spoolss_4b *)_r;
9444 r->out.result = _spoolss_4b(cli->pipes_struct, r);
9445 return NT_STATUS_OK;
9446 }
9447
9448 case NDR_SPOOLSS_4C: {
9449 struct spoolss_4c *r = (struct spoolss_4c *)_r;
9450 r->out.result = _spoolss_4c(cli->pipes_struct, r);
9451 return NT_STATUS_OK;
9452 }
9453
9454 case NDR_SPOOLSS_SETPRINTERDATAEX: {
9455 struct spoolss_SetPrinterDataEx *r = (struct spoolss_SetPrinterDataEx *)_r;
9456 r->out.result = _spoolss_SetPrinterDataEx(cli->pipes_struct, r);
9457 return NT_STATUS_OK;
9458 }
9459
9460 case NDR_SPOOLSS_GETPRINTERDATAEX: {
9461 struct spoolss_GetPrinterDataEx *r = (struct spoolss_GetPrinterDataEx *)_r;
9462 ZERO_STRUCT(r->out);
9463 r->out.type = talloc_zero(mem_ctx, enum winreg_Type);
9464 if (r->out.type == NULL) {
9465 return NT_STATUS_NO_MEMORY;
9466 }
9467
9468 r->out.buffer = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
9469 if (r->out.buffer == NULL) {
9470 return NT_STATUS_NO_MEMORY;
9471 }
9472
9473 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9474 if (r->out.needed == NULL) {
9475 return NT_STATUS_NO_MEMORY;
9476 }
9477
9478 r->out.result = _spoolss_GetPrinterDataEx(cli->pipes_struct, r);
9479 return NT_STATUS_OK;
9480 }
9481
9482 case NDR_SPOOLSS_ENUMPRINTERDATAEX: {
9483 struct spoolss_EnumPrinterDataEx *r = (struct spoolss_EnumPrinterDataEx *)_r;
9484 ZERO_STRUCT(r->out);
9485 r->out.count = talloc_zero(mem_ctx, uint32_t);
9486 if (r->out.count == NULL) {
9487 return NT_STATUS_NO_MEMORY;
9488 }
9489
9490 r->out.info = talloc_zero(mem_ctx, struct spoolss_PrinterEnumValues *);
9491 if (r->out.info == NULL) {
9492 return NT_STATUS_NO_MEMORY;
9493 }
9494
9495 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9496 if (r->out.needed == NULL) {
9497 return NT_STATUS_NO_MEMORY;
9498 }
9499
9500 r->out.result = _spoolss_EnumPrinterDataEx(cli->pipes_struct, r);
9501 return NT_STATUS_OK;
9502 }
9503
9504 case NDR_SPOOLSS_ENUMPRINTERKEY: {
9505 struct spoolss_EnumPrinterKey *r = (struct spoolss_EnumPrinterKey *)_r;
9506 ZERO_STRUCT(r->out);
9507 r->out.key_buffer = talloc_zero(mem_ctx, const char **);
9508 if (r->out.key_buffer == NULL) {
9509 return NT_STATUS_NO_MEMORY;
9510 }
9511
9512 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9513 if (r->out.needed == NULL) {
9514 return NT_STATUS_NO_MEMORY;
9515 }
9516
9517 r->out.result = _spoolss_EnumPrinterKey(cli->pipes_struct, r);
9518 return NT_STATUS_OK;
9519 }
9520
9521 case NDR_SPOOLSS_DELETEPRINTERDATAEX: {
9522 struct spoolss_DeletePrinterDataEx *r = (struct spoolss_DeletePrinterDataEx *)_r;
9523 r->out.result = _spoolss_DeletePrinterDataEx(cli->pipes_struct, r);
9524 return NT_STATUS_OK;
9525 }
9526
9527 case NDR_SPOOLSS_DELETEPRINTERKEY: {
9528 struct spoolss_DeletePrinterKey *r = (struct spoolss_DeletePrinterKey *)_r;
9529 r->out.result = _spoolss_DeletePrinterKey(cli->pipes_struct, r);
9530 return NT_STATUS_OK;
9531 }
9532
9533 case NDR_SPOOLSS_53: {
9534 struct spoolss_53 *r = (struct spoolss_53 *)_r;
9535 r->out.result = _spoolss_53(cli->pipes_struct, r);
9536 return NT_STATUS_OK;
9537 }
9538
9539 case NDR_SPOOLSS_DELETEPRINTERDRIVEREX: {
9540 struct spoolss_DeletePrinterDriverEx *r = (struct spoolss_DeletePrinterDriverEx *)_r;
9541 r->out.result = _spoolss_DeletePrinterDriverEx(cli->pipes_struct, r);
9542 return NT_STATUS_OK;
9543 }
9544
9545 case NDR_SPOOLSS_55: {
9546 struct spoolss_55 *r = (struct spoolss_55 *)_r;
9547 r->out.result = _spoolss_55(cli->pipes_struct, r);
9548 return NT_STATUS_OK;
9549 }
9550
9551 case NDR_SPOOLSS_56: {
9552 struct spoolss_56 *r = (struct spoolss_56 *)_r;
9553 r->out.result = _spoolss_56(cli->pipes_struct, r);
9554 return NT_STATUS_OK;
9555 }
9556
9557 case NDR_SPOOLSS_57: {
9558 struct spoolss_57 *r = (struct spoolss_57 *)_r;
9559 r->out.result = _spoolss_57(cli->pipes_struct, r);
9560 return NT_STATUS_OK;
9561 }
9562
9563 case NDR_SPOOLSS_XCVDATA: {
9564 struct spoolss_XcvData *r = (struct spoolss_XcvData *)_r;
9565 ZERO_STRUCT(r->out);
9566 r->out.status_code = r->in.status_code;
9567 r->out.out_data = talloc_zero_array(mem_ctx, uint8_t, r->in.out_data_size);
9568 if (r->out.out_data == NULL) {
9569 return NT_STATUS_NO_MEMORY;
9570 }
9571
9572 r->out.needed = talloc_zero(mem_ctx, uint32_t);
9573 if (r->out.needed == NULL) {
9574 return NT_STATUS_NO_MEMORY;
9575 }
9576
9577 r->out.result = _spoolss_XcvData(cli->pipes_struct, r);
9578 return NT_STATUS_OK;
9579 }
9580
9581 case NDR_SPOOLSS_ADDPRINTERDRIVEREX: {
9582 struct spoolss_AddPrinterDriverEx *r = (struct spoolss_AddPrinterDriverEx *)_r;
9583 r->out.result = _spoolss_AddPrinterDriverEx(cli->pipes_struct, r);
9584 return NT_STATUS_OK;
9585 }
9586
9587 case NDR_SPOOLSS_5A: {
9588 struct spoolss_5a *r = (struct spoolss_5a *)_r;
9589 r->out.result = _spoolss_5a(cli->pipes_struct, r);
9590 return NT_STATUS_OK;
9591 }
9592
9593 case NDR_SPOOLSS_5B: {
9594 struct spoolss_5b *r = (struct spoolss_5b *)_r;
9595 r->out.result = _spoolss_5b(cli->pipes_struct, r);
9596 return NT_STATUS_OK;
9597 }
9598
9599 case NDR_SPOOLSS_5C: {
9600 struct spoolss_5c *r = (struct spoolss_5c *)_r;
9601 r->out.result = _spoolss_5c(cli->pipes_struct, r);
9602 return NT_STATUS_OK;
9603 }
9604
9605 case NDR_SPOOLSS_5D: {
9606 struct spoolss_5d *r = (struct spoolss_5d *)_r;
9607 r->out.result = _spoolss_5d(cli->pipes_struct, r);
9608 return NT_STATUS_OK;
9609 }
9610
9611 case NDR_SPOOLSS_5E: {
9612 struct spoolss_5e *r = (struct spoolss_5e *)_r;
9613 r->out.result = _spoolss_5e(cli->pipes_struct, r);
9614 return NT_STATUS_OK;
9615 }
9616
9617 case NDR_SPOOLSS_5F: {
9618 struct spoolss_5f *r = (struct spoolss_5f *)_r;
9619 r->out.result = _spoolss_5f(cli->pipes_struct, r);
9620 return NT_STATUS_OK;
9621 }
9622
9623 case NDR_SPOOLSS_60: {
9624 struct spoolss_60 *r = (struct spoolss_60 *)_r;
9625 r->out.result = _spoolss_60(cli->pipes_struct, r);
9626 return NT_STATUS_OK;
9627 }
9628
9629 case NDR_SPOOLSS_61: {
9630 struct spoolss_61 *r = (struct spoolss_61 *)_r;
9631 r->out.result = _spoolss_61(cli->pipes_struct, r);
9632 return NT_STATUS_OK;
9633 }
9634
9635 case NDR_SPOOLSS_62: {
9636 struct spoolss_62 *r = (struct spoolss_62 *)_r;
9637 r->out.result = _spoolss_62(cli->pipes_struct, r);
9638 return NT_STATUS_OK;
9639 }
9640
9641 case NDR_SPOOLSS_63: {
9642 struct spoolss_63 *r = (struct spoolss_63 *)_r;
9643 r->out.result = _spoolss_63(cli->pipes_struct, r);
9644 return NT_STATUS_OK;
9645 }
9646
9647 case NDR_SPOOLSS_64: {
9648 struct spoolss_64 *r = (struct spoolss_64 *)_r;
9649 r->out.result = _spoolss_64(cli->pipes_struct, r);
9650 return NT_STATUS_OK;
9651 }
9652
9653 case NDR_SPOOLSS_65: {
9654 struct spoolss_65 *r = (struct spoolss_65 *)_r;
9655 r->out.result = _spoolss_65(cli->pipes_struct, r);
9656 return NT_STATUS_OK;
9657 }
9658
9659 case NDR_SPOOLSS_GETCOREPRINTERDRIVERS: {
9660 struct spoolss_GetCorePrinterDrivers *r = (struct spoolss_GetCorePrinterDrivers *)_r;
9661 ZERO_STRUCT(r->out);
9662 r->out.core_printer_drivers = talloc_zero_array(mem_ctx, struct spoolss_CorePrinterDriver, r->in.core_printer_driver_count);
9663 if (r->out.core_printer_drivers == NULL) {
9664 return NT_STATUS_NO_MEMORY;
9665 }
9666
9667 r->out.result = _spoolss_GetCorePrinterDrivers(cli->pipes_struct, r);
9668 return NT_STATUS_OK;
9669 }
9670
9671 case NDR_SPOOLSS_67: {
9672 struct spoolss_67 *r = (struct spoolss_67 *)_r;
9673 r->out.result = _spoolss_67(cli->pipes_struct, r);
9674 return NT_STATUS_OK;
9675 }
9676
9677 case NDR_SPOOLSS_GETPRINTERDRIVERPACKAGEPATH: {
9678 struct spoolss_GetPrinterDriverPackagePath *r = (struct spoolss_GetPrinterDriverPackagePath *)_r;
9679 ZERO_STRUCT(r->out);
9680 r->out.driver_package_cab = r->in.driver_package_cab;
9681 r->out.required = talloc_zero(mem_ctx, uint32_t);
9682 if (r->out.required == NULL) {
9683 return NT_STATUS_NO_MEMORY;
9684 }
9685
9686 r->out.result = _spoolss_GetPrinterDriverPackagePath(cli->pipes_struct, r);
9687 return NT_STATUS_OK;
9688 }
9689
9690 case NDR_SPOOLSS_69: {
9691 struct spoolss_69 *r = (struct spoolss_69 *)_r;
9692 r->out.result = _spoolss_69(cli->pipes_struct, r);
9693 return NT_STATUS_OK;
9694 }
9695
9696 case NDR_SPOOLSS_6A: {
9697 struct spoolss_6a *r = (struct spoolss_6a *)_r;
9698 r->out.result = _spoolss_6a(cli->pipes_struct, r);
9699 return NT_STATUS_OK;
9700 }
9701
9702 case NDR_SPOOLSS_6B: {
9703 struct spoolss_6b *r = (struct spoolss_6b *)_r;
9704 r->out.result = _spoolss_6b(cli->pipes_struct, r);
9705 return NT_STATUS_OK;
9706 }
9707
9708 case NDR_SPOOLSS_6C: {
9709 struct spoolss_6c *r = (struct spoolss_6c *)_r;
9710 r->out.result = _spoolss_6c(cli->pipes_struct, r);
9711 return NT_STATUS_OK;
9712 }
9713
9714 case NDR_SPOOLSS_6D: {
9715 struct spoolss_6d *r = (struct spoolss_6d *)_r;
9716 r->out.result = _spoolss_6d(cli->pipes_struct, r);
9717 return NT_STATUS_OK;
9718 }
9719
9720 default:
9721 return NT_STATUS_NOT_IMPLEMENTED;
9722 }
9723 }
9724
9725 NTSTATUS rpc_spoolss_init(void)
9726 {
9727 return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "spoolss", "spoolss", &ndr_table_spoolss, api_spoolss_cmds, sizeof(api_spoolss_cmds) / sizeof(struct api_struct));
9728 }
Crístian's Samba branch