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