?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3:configure: "test" only takes one "="
[Samba/gebeck_regimport.git] / librpc / gen_ndr / cli_spoolss.c
blob1e94a2a63c45cf70ab5fdf8ab58f286a3279a42c
1 /*
2 * Unix SMB/CIFS implementation.
3 * client auto-generated by pidl. DO NOT MODIFY!
4 */
5
6 #include "includes.h"
7 #include "../librpc/gen_ndr/cli_spoolss.h"
8
9 NTSTATUS rpccli_spoolss_EnumPrinters(struct rpc_pipe_client *cli,
10 TALLOC_CTX *mem_ctx,
11 uint32_t flags /* [in] */,
12 const char *server /* [in] [unique,charset(UTF16)] */,
13 uint32_t level /* [in] */,
14 DATA_BLOB *buffer /* [in] [unique] */,
15 uint32_t offered /* [in] */,
16 uint32_t *count /* [out] [ref] */,
17 union spoolss_PrinterInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
18 uint32_t *needed /* [out] [ref] */,
19 WERROR *werror)
20 {
21 struct spoolss_EnumPrinters r;
22 NTSTATUS status;
23
24 /* In parameters */
25 r.in.flags = flags;
26 r.in.server = server;
27 r.in.level = level;
28 r.in.buffer = buffer;
29 r.in.offered = offered;
30
31 if (DEBUGLEVEL >= 10) {
32 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinters, &r);
33 }
34
35 status = cli->dispatch(cli,
36 mem_ctx,
37 &ndr_table_spoolss,
38 NDR_SPOOLSS_ENUMPRINTERS,
39 &r);
40
41 if (!NT_STATUS_IS_OK(status)) {
42 return status;
43 }
44
45 if (DEBUGLEVEL >= 10) {
46 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinters, &r);
47 }
48
49 if (NT_STATUS_IS_ERR(status)) {
50 return status;
51 }
52
53 /* Return variables */
54 *count = *r.out.count;
55 *info = *r.out.info;
56 *needed = *r.out.needed;
57
58 /* Return result */
59 if (werror) {
60 *werror = r.out.result;
61 }
62
63 return werror_to_ntstatus(r.out.result);
64 }
65
66 NTSTATUS rpccli_spoolss_OpenPrinter(struct rpc_pipe_client *cli,
67 TALLOC_CTX *mem_ctx,
68 const char *printername /* [in] [unique,charset(UTF16)] */,
69 const char *datatype /* [in] [unique,charset(UTF16)] */,
70 struct spoolss_DevmodeContainer devmode_ctr /* [in] */,
71 uint32_t access_mask /* [in] */,
72 struct policy_handle *handle /* [out] [ref] */,
73 WERROR *werror)
74 {
75 struct spoolss_OpenPrinter r;
76 NTSTATUS status;
77
78 /* In parameters */
79 r.in.printername = printername;
80 r.in.datatype = datatype;
81 r.in.devmode_ctr = devmode_ctr;
82 r.in.access_mask = access_mask;
83
84 if (DEBUGLEVEL >= 10) {
85 NDR_PRINT_IN_DEBUG(spoolss_OpenPrinter, &r);
86 }
87
88 status = cli->dispatch(cli,
89 mem_ctx,
90 &ndr_table_spoolss,
91 NDR_SPOOLSS_OPENPRINTER,
92 &r);
93
94 if (!NT_STATUS_IS_OK(status)) {
95 return status;
96 }
97
98 if (DEBUGLEVEL >= 10) {
99 NDR_PRINT_OUT_DEBUG(spoolss_OpenPrinter, &r);
100 }
101
102 if (NT_STATUS_IS_ERR(status)) {
103 return status;
104 }
105
106 /* Return variables */
107 *handle = *r.out.handle;
108
109 /* Return result */
110 if (werror) {
111 *werror = r.out.result;
112 }
113
114 return werror_to_ntstatus(r.out.result);
115 }
116
117 NTSTATUS rpccli_spoolss_SetJob(struct rpc_pipe_client *cli,
118 TALLOC_CTX *mem_ctx,
119 struct policy_handle *handle /* [in] [ref] */,
120 uint32_t job_id /* [in] */,
121 struct spoolss_JobInfoContainer *ctr /* [in] [unique] */,
122 enum spoolss_JobControl command /* [in] */,
123 WERROR *werror)
124 {
125 struct spoolss_SetJob r;
126 NTSTATUS status;
127
128 /* In parameters */
129 r.in.handle = handle;
130 r.in.job_id = job_id;
131 r.in.ctr = ctr;
132 r.in.command = command;
133
134 if (DEBUGLEVEL >= 10) {
135 NDR_PRINT_IN_DEBUG(spoolss_SetJob, &r);
136 }
137
138 status = cli->dispatch(cli,
139 mem_ctx,
140 &ndr_table_spoolss,
141 NDR_SPOOLSS_SETJOB,
142 &r);
143
144 if (!NT_STATUS_IS_OK(status)) {
145 return status;
146 }
147
148 if (DEBUGLEVEL >= 10) {
149 NDR_PRINT_OUT_DEBUG(spoolss_SetJob, &r);
150 }
151
152 if (NT_STATUS_IS_ERR(status)) {
153 return status;
154 }
155
156 /* Return variables */
157
158 /* Return result */
159 if (werror) {
160 *werror = r.out.result;
161 }
162
163 return werror_to_ntstatus(r.out.result);
164 }
165
166 NTSTATUS rpccli_spoolss_GetJob(struct rpc_pipe_client *cli,
167 TALLOC_CTX *mem_ctx,
168 struct policy_handle *handle /* [in] [ref] */,
169 uint32_t job_id /* [in] */,
170 uint32_t level /* [in] */,
171 DATA_BLOB *buffer /* [in] [unique] */,
172 uint32_t offered /* [in] */,
173 union spoolss_JobInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
174 uint32_t *needed /* [out] [ref] */,
175 WERROR *werror)
176 {
177 struct spoolss_GetJob r;
178 NTSTATUS status;
179
180 /* In parameters */
181 r.in.handle = handle;
182 r.in.job_id = job_id;
183 r.in.level = level;
184 r.in.buffer = buffer;
185 r.in.offered = offered;
186
187 if (DEBUGLEVEL >= 10) {
188 NDR_PRINT_IN_DEBUG(spoolss_GetJob, &r);
189 }
190
191 status = cli->dispatch(cli,
192 mem_ctx,
193 &ndr_table_spoolss,
194 NDR_SPOOLSS_GETJOB,
195 &r);
196
197 if (!NT_STATUS_IS_OK(status)) {
198 return status;
199 }
200
201 if (DEBUGLEVEL >= 10) {
202 NDR_PRINT_OUT_DEBUG(spoolss_GetJob, &r);
203 }
204
205 if (NT_STATUS_IS_ERR(status)) {
206 return status;
207 }
208
209 /* Return variables */
210 if (info && r.out.info) {
211 *info = *r.out.info;
212 }
213 *needed = *r.out.needed;
214
215 /* Return result */
216 if (werror) {
217 *werror = r.out.result;
218 }
219
220 return werror_to_ntstatus(r.out.result);
221 }
222
223 NTSTATUS rpccli_spoolss_EnumJobs(struct rpc_pipe_client *cli,
224 TALLOC_CTX *mem_ctx,
225 struct policy_handle *handle /* [in] [ref] */,
226 uint32_t firstjob /* [in] */,
227 uint32_t numjobs /* [in] */,
228 uint32_t level /* [in] */,
229 DATA_BLOB *buffer /* [in] [unique] */,
230 uint32_t offered /* [in] */,
231 uint32_t *count /* [out] [ref] */,
232 union spoolss_JobInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
233 uint32_t *needed /* [out] [ref] */,
234 WERROR *werror)
235 {
236 struct spoolss_EnumJobs r;
237 NTSTATUS status;
238
239 /* In parameters */
240 r.in.handle = handle;
241 r.in.firstjob = firstjob;
242 r.in.numjobs = numjobs;
243 r.in.level = level;
244 r.in.buffer = buffer;
245 r.in.offered = offered;
246
247 if (DEBUGLEVEL >= 10) {
248 NDR_PRINT_IN_DEBUG(spoolss_EnumJobs, &r);
249 }
250
251 status = cli->dispatch(cli,
252 mem_ctx,
253 &ndr_table_spoolss,
254 NDR_SPOOLSS_ENUMJOBS,
255 &r);
256
257 if (!NT_STATUS_IS_OK(status)) {
258 return status;
259 }
260
261 if (DEBUGLEVEL >= 10) {
262 NDR_PRINT_OUT_DEBUG(spoolss_EnumJobs, &r);
263 }
264
265 if (NT_STATUS_IS_ERR(status)) {
266 return status;
267 }
268
269 /* Return variables */
270 *count = *r.out.count;
271 *info = *r.out.info;
272 *needed = *r.out.needed;
273
274 /* Return result */
275 if (werror) {
276 *werror = r.out.result;
277 }
278
279 return werror_to_ntstatus(r.out.result);
280 }
281
282 NTSTATUS rpccli_spoolss_AddPrinter(struct rpc_pipe_client *cli,
283 TALLOC_CTX *mem_ctx,
284 WERROR *werror)
285 {
286 struct spoolss_AddPrinter r;
287 NTSTATUS status;
288
289 /* In parameters */
290
291 if (DEBUGLEVEL >= 10) {
292 NDR_PRINT_IN_DEBUG(spoolss_AddPrinter, &r);
293 }
294
295 status = cli->dispatch(cli,
296 mem_ctx,
297 &ndr_table_spoolss,
298 NDR_SPOOLSS_ADDPRINTER,
299 &r);
300
301 if (!NT_STATUS_IS_OK(status)) {
302 return status;
303 }
304
305 if (DEBUGLEVEL >= 10) {
306 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinter, &r);
307 }
308
309 if (NT_STATUS_IS_ERR(status)) {
310 return status;
311 }
312
313 /* Return variables */
314
315 /* Return result */
316 if (werror) {
317 *werror = r.out.result;
318 }
319
320 return werror_to_ntstatus(r.out.result);
321 }
322
323 NTSTATUS rpccli_spoolss_DeletePrinter(struct rpc_pipe_client *cli,
324 TALLOC_CTX *mem_ctx,
325 struct policy_handle *handle /* [in] [ref] */,
326 WERROR *werror)
327 {
328 struct spoolss_DeletePrinter r;
329 NTSTATUS status;
330
331 /* In parameters */
332 r.in.handle = handle;
333
334 if (DEBUGLEVEL >= 10) {
335 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinter, &r);
336 }
337
338 status = cli->dispatch(cli,
339 mem_ctx,
340 &ndr_table_spoolss,
341 NDR_SPOOLSS_DELETEPRINTER,
342 &r);
343
344 if (!NT_STATUS_IS_OK(status)) {
345 return status;
346 }
347
348 if (DEBUGLEVEL >= 10) {
349 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinter, &r);
350 }
351
352 if (NT_STATUS_IS_ERR(status)) {
353 return status;
354 }
355
356 /* Return variables */
357
358 /* Return result */
359 if (werror) {
360 *werror = r.out.result;
361 }
362
363 return werror_to_ntstatus(r.out.result);
364 }
365
366 NTSTATUS rpccli_spoolss_SetPrinter(struct rpc_pipe_client *cli,
367 TALLOC_CTX *mem_ctx,
368 struct policy_handle *handle /* [in] [ref] */,
369 struct spoolss_SetPrinterInfoCtr *info_ctr /* [in] [ref] */,
370 struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
371 struct sec_desc_buf *secdesc_ctr /* [in] [ref] */,
372 enum spoolss_PrinterControl command /* [in] */,
373 WERROR *werror)
374 {
375 struct spoolss_SetPrinter r;
376 NTSTATUS status;
377
378 /* In parameters */
379 r.in.handle = handle;
380 r.in.info_ctr = info_ctr;
381 r.in.devmode_ctr = devmode_ctr;
382 r.in.secdesc_ctr = secdesc_ctr;
383 r.in.command = command;
384
385 if (DEBUGLEVEL >= 10) {
386 NDR_PRINT_IN_DEBUG(spoolss_SetPrinter, &r);
387 }
388
389 status = cli->dispatch(cli,
390 mem_ctx,
391 &ndr_table_spoolss,
392 NDR_SPOOLSS_SETPRINTER,
393 &r);
394
395 if (!NT_STATUS_IS_OK(status)) {
396 return status;
397 }
398
399 if (DEBUGLEVEL >= 10) {
400 NDR_PRINT_OUT_DEBUG(spoolss_SetPrinter, &r);
401 }
402
403 if (NT_STATUS_IS_ERR(status)) {
404 return status;
405 }
406
407 /* Return variables */
408
409 /* Return result */
410 if (werror) {
411 *werror = r.out.result;
412 }
413
414 return werror_to_ntstatus(r.out.result);
415 }
416
417 NTSTATUS rpccli_spoolss_GetPrinter(struct rpc_pipe_client *cli,
418 TALLOC_CTX *mem_ctx,
419 struct policy_handle *handle /* [in] [ref] */,
420 uint32_t level /* [in] */,
421 DATA_BLOB *buffer /* [in] [unique] */,
422 uint32_t offered /* [in] */,
423 union spoolss_PrinterInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
424 uint32_t *needed /* [out] [ref] */,
425 WERROR *werror)
426 {
427 struct spoolss_GetPrinter r;
428 NTSTATUS status;
429
430 /* In parameters */
431 r.in.handle = handle;
432 r.in.level = level;
433 r.in.buffer = buffer;
434 r.in.offered = offered;
435
436 if (DEBUGLEVEL >= 10) {
437 NDR_PRINT_IN_DEBUG(spoolss_GetPrinter, &r);
438 }
439
440 status = cli->dispatch(cli,
441 mem_ctx,
442 &ndr_table_spoolss,
443 NDR_SPOOLSS_GETPRINTER,
444 &r);
445
446 if (!NT_STATUS_IS_OK(status)) {
447 return status;
448 }
449
450 if (DEBUGLEVEL >= 10) {
451 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinter, &r);
452 }
453
454 if (NT_STATUS_IS_ERR(status)) {
455 return status;
456 }
457
458 /* Return variables */
459 if (info && r.out.info) {
460 *info = *r.out.info;
461 }
462 *needed = *r.out.needed;
463
464 /* Return result */
465 if (werror) {
466 *werror = r.out.result;
467 }
468
469 return werror_to_ntstatus(r.out.result);
470 }
471
472 NTSTATUS rpccli_spoolss_AddPrinterDriver(struct rpc_pipe_client *cli,
473 TALLOC_CTX *mem_ctx,
474 const char *servername /* [in] [unique,charset(UTF16)] */,
475 struct spoolss_AddDriverInfoCtr *info_ctr /* [in] [ref] */,
476 WERROR *werror)
477 {
478 struct spoolss_AddPrinterDriver r;
479 NTSTATUS status;
480
481 /* In parameters */
482 r.in.servername = servername;
483 r.in.info_ctr = info_ctr;
484
485 if (DEBUGLEVEL >= 10) {
486 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterDriver, &r);
487 }
488
489 status = cli->dispatch(cli,
490 mem_ctx,
491 &ndr_table_spoolss,
492 NDR_SPOOLSS_ADDPRINTERDRIVER,
493 &r);
494
495 if (!NT_STATUS_IS_OK(status)) {
496 return status;
497 }
498
499 if (DEBUGLEVEL >= 10) {
500 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterDriver, &r);
501 }
502
503 if (NT_STATUS_IS_ERR(status)) {
504 return status;
505 }
506
507 /* Return variables */
508
509 /* Return result */
510 if (werror) {
511 *werror = r.out.result;
512 }
513
514 return werror_to_ntstatus(r.out.result);
515 }
516
517 NTSTATUS rpccli_spoolss_EnumPrinterDrivers(struct rpc_pipe_client *cli,
518 TALLOC_CTX *mem_ctx,
519 const char *server /* [in] [unique,charset(UTF16)] */,
520 const char *environment /* [in] [unique,charset(UTF16)] */,
521 uint32_t level /* [in] */,
522 DATA_BLOB *buffer /* [in] [unique] */,
523 uint32_t offered /* [in] */,
524 uint32_t *count /* [out] [ref] */,
525 union spoolss_DriverInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
526 uint32_t *needed /* [out] [ref] */,
527 WERROR *werror)
528 {
529 struct spoolss_EnumPrinterDrivers r;
530 NTSTATUS status;
531
532 /* In parameters */
533 r.in.server = server;
534 r.in.environment = environment;
535 r.in.level = level;
536 r.in.buffer = buffer;
537 r.in.offered = offered;
538
539 if (DEBUGLEVEL >= 10) {
540 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterDrivers, &r);
541 }
542
543 status = cli->dispatch(cli,
544 mem_ctx,
545 &ndr_table_spoolss,
546 NDR_SPOOLSS_ENUMPRINTERDRIVERS,
547 &r);
548
549 if (!NT_STATUS_IS_OK(status)) {
550 return status;
551 }
552
553 if (DEBUGLEVEL >= 10) {
554 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterDrivers, &r);
555 }
556
557 if (NT_STATUS_IS_ERR(status)) {
558 return status;
559 }
560
561 /* Return variables */
562 *count = *r.out.count;
563 *info = *r.out.info;
564 *needed = *r.out.needed;
565
566 /* Return result */
567 if (werror) {
568 *werror = r.out.result;
569 }
570
571 return werror_to_ntstatus(r.out.result);
572 }
573
574 NTSTATUS rpccli_spoolss_GetPrinterDriver(struct rpc_pipe_client *cli,
575 TALLOC_CTX *mem_ctx,
576 WERROR *werror)
577 {
578 struct spoolss_GetPrinterDriver r;
579 NTSTATUS status;
580
581 /* In parameters */
582
583 if (DEBUGLEVEL >= 10) {
584 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriver, &r);
585 }
586
587 status = cli->dispatch(cli,
588 mem_ctx,
589 &ndr_table_spoolss,
590 NDR_SPOOLSS_GETPRINTERDRIVER,
591 &r);
592
593 if (!NT_STATUS_IS_OK(status)) {
594 return status;
595 }
596
597 if (DEBUGLEVEL >= 10) {
598 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriver, &r);
599 }
600
601 if (NT_STATUS_IS_ERR(status)) {
602 return status;
603 }
604
605 /* Return variables */
606
607 /* Return result */
608 if (werror) {
609 *werror = r.out.result;
610 }
611
612 return werror_to_ntstatus(r.out.result);
613 }
614
615 NTSTATUS rpccli_spoolss_GetPrinterDriverDirectory(struct rpc_pipe_client *cli,
616 TALLOC_CTX *mem_ctx,
617 const char *server /* [in] [unique,charset(UTF16)] */,
618 const char *environment /* [in] [unique,charset(UTF16)] */,
619 uint32_t level /* [in] */,
620 DATA_BLOB *buffer /* [in] [unique] */,
621 uint32_t offered /* [in] */,
622 union spoolss_DriverDirectoryInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
623 uint32_t *needed /* [out] [ref] */,
624 WERROR *werror)
625 {
626 struct spoolss_GetPrinterDriverDirectory r;
627 NTSTATUS status;
628
629 /* In parameters */
630 r.in.server = server;
631 r.in.environment = environment;
632 r.in.level = level;
633 r.in.buffer = buffer;
634 r.in.offered = offered;
635
636 if (DEBUGLEVEL >= 10) {
637 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriverDirectory, &r);
638 }
639
640 status = cli->dispatch(cli,
641 mem_ctx,
642 &ndr_table_spoolss,
643 NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY,
644 &r);
645
646 if (!NT_STATUS_IS_OK(status)) {
647 return status;
648 }
649
650 if (DEBUGLEVEL >= 10) {
651 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriverDirectory, &r);
652 }
653
654 if (NT_STATUS_IS_ERR(status)) {
655 return status;
656 }
657
658 /* Return variables */
659 if (info && r.out.info) {
660 *info = *r.out.info;
661 }
662 *needed = *r.out.needed;
663
664 /* Return result */
665 if (werror) {
666 *werror = r.out.result;
667 }
668
669 return werror_to_ntstatus(r.out.result);
670 }
671
672 NTSTATUS rpccli_spoolss_DeletePrinterDriver(struct rpc_pipe_client *cli,
673 TALLOC_CTX *mem_ctx,
674 const char *server /* [in] [unique,charset(UTF16)] */,
675 const char *architecture /* [in] [charset(UTF16)] */,
676 const char *driver /* [in] [charset(UTF16)] */,
677 WERROR *werror)
678 {
679 struct spoolss_DeletePrinterDriver r;
680 NTSTATUS status;
681
682 /* In parameters */
683 r.in.server = server;
684 r.in.architecture = architecture;
685 r.in.driver = driver;
686
687 if (DEBUGLEVEL >= 10) {
688 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDriver, &r);
689 }
690
691 status = cli->dispatch(cli,
692 mem_ctx,
693 &ndr_table_spoolss,
694 NDR_SPOOLSS_DELETEPRINTERDRIVER,
695 &r);
696
697 if (!NT_STATUS_IS_OK(status)) {
698 return status;
699 }
700
701 if (DEBUGLEVEL >= 10) {
702 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDriver, &r);
703 }
704
705 if (NT_STATUS_IS_ERR(status)) {
706 return status;
707 }
708
709 /* Return variables */
710
711 /* Return result */
712 if (werror) {
713 *werror = r.out.result;
714 }
715
716 return werror_to_ntstatus(r.out.result);
717 }
718
719 NTSTATUS rpccli_spoolss_AddPrintProcessor(struct rpc_pipe_client *cli,
720 TALLOC_CTX *mem_ctx,
721 const char *server /* [in] [unique,charset(UTF16)] */,
722 const char *architecture /* [in] [charset(UTF16)] */,
723 const char *path_name /* [in] [charset(UTF16)] */,
724 const char *print_processor_name /* [in] [charset(UTF16)] */,
725 WERROR *werror)
726 {
727 struct spoolss_AddPrintProcessor r;
728 NTSTATUS status;
729
730 /* In parameters */
731 r.in.server = server;
732 r.in.architecture = architecture;
733 r.in.path_name = path_name;
734 r.in.print_processor_name = print_processor_name;
735
736 if (DEBUGLEVEL >= 10) {
737 NDR_PRINT_IN_DEBUG(spoolss_AddPrintProcessor, &r);
738 }
739
740 status = cli->dispatch(cli,
741 mem_ctx,
742 &ndr_table_spoolss,
743 NDR_SPOOLSS_ADDPRINTPROCESSOR,
744 &r);
745
746 if (!NT_STATUS_IS_OK(status)) {
747 return status;
748 }
749
750 if (DEBUGLEVEL >= 10) {
751 NDR_PRINT_OUT_DEBUG(spoolss_AddPrintProcessor, &r);
752 }
753
754 if (NT_STATUS_IS_ERR(status)) {
755 return status;
756 }
757
758 /* Return variables */
759
760 /* Return result */
761 if (werror) {
762 *werror = r.out.result;
763 }
764
765 return werror_to_ntstatus(r.out.result);
766 }
767
768 NTSTATUS rpccli_spoolss_EnumPrintProcessors(struct rpc_pipe_client *cli,
769 TALLOC_CTX *mem_ctx,
770 const char *servername /* [in] [unique,charset(UTF16)] */,
771 const char *environment /* [in] [unique,charset(UTF16)] */,
772 uint32_t level /* [in] */,
773 DATA_BLOB *buffer /* [in] [unique] */,
774 uint32_t offered /* [in] */,
775 uint32_t *count /* [out] [ref] */,
776 union spoolss_PrintProcessorInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
777 uint32_t *needed /* [out] [ref] */,
778 WERROR *werror)
779 {
780 struct spoolss_EnumPrintProcessors r;
781 NTSTATUS status;
782
783 /* In parameters */
784 r.in.servername = servername;
785 r.in.environment = environment;
786 r.in.level = level;
787 r.in.buffer = buffer;
788 r.in.offered = offered;
789
790 if (DEBUGLEVEL >= 10) {
791 NDR_PRINT_IN_DEBUG(spoolss_EnumPrintProcessors, &r);
792 }
793
794 status = cli->dispatch(cli,
795 mem_ctx,
796 &ndr_table_spoolss,
797 NDR_SPOOLSS_ENUMPRINTPROCESSORS,
798 &r);
799
800 if (!NT_STATUS_IS_OK(status)) {
801 return status;
802 }
803
804 if (DEBUGLEVEL >= 10) {
805 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrintProcessors, &r);
806 }
807
808 if (NT_STATUS_IS_ERR(status)) {
809 return status;
810 }
811
812 /* Return variables */
813 *count = *r.out.count;
814 *info = *r.out.info;
815 *needed = *r.out.needed;
816
817 /* Return result */
818 if (werror) {
819 *werror = r.out.result;
820 }
821
822 return werror_to_ntstatus(r.out.result);
823 }
824
825 NTSTATUS rpccli_spoolss_GetPrintProcessorDirectory(struct rpc_pipe_client *cli,
826 TALLOC_CTX *mem_ctx,
827 const char *server /* [in] [unique,charset(UTF16)] */,
828 const char *environment /* [in] [unique,charset(UTF16)] */,
829 uint32_t level /* [in] */,
830 DATA_BLOB *buffer /* [in] [unique] */,
831 uint32_t offered /* [in] */,
832 union spoolss_PrintProcessorDirectoryInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
833 uint32_t *needed /* [out] [ref] */,
834 WERROR *werror)
835 {
836 struct spoolss_GetPrintProcessorDirectory r;
837 NTSTATUS status;
838
839 /* In parameters */
840 r.in.server = server;
841 r.in.environment = environment;
842 r.in.level = level;
843 r.in.buffer = buffer;
844 r.in.offered = offered;
845
846 if (DEBUGLEVEL >= 10) {
847 NDR_PRINT_IN_DEBUG(spoolss_GetPrintProcessorDirectory, &r);
848 }
849
850 status = cli->dispatch(cli,
851 mem_ctx,
852 &ndr_table_spoolss,
853 NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY,
854 &r);
855
856 if (!NT_STATUS_IS_OK(status)) {
857 return status;
858 }
859
860 if (DEBUGLEVEL >= 10) {
861 NDR_PRINT_OUT_DEBUG(spoolss_GetPrintProcessorDirectory, &r);
862 }
863
864 if (NT_STATUS_IS_ERR(status)) {
865 return status;
866 }
867
868 /* Return variables */
869 if (info && r.out.info) {
870 *info = *r.out.info;
871 }
872 *needed = *r.out.needed;
873
874 /* Return result */
875 if (werror) {
876 *werror = r.out.result;
877 }
878
879 return werror_to_ntstatus(r.out.result);
880 }
881
882 NTSTATUS rpccli_spoolss_StartDocPrinter(struct rpc_pipe_client *cli,
883 TALLOC_CTX *mem_ctx,
884 struct policy_handle *handle /* [in] [ref] */,
885 uint32_t level /* [in] */,
886 union spoolss_DocumentInfo info /* [in] [switch_is(level)] */,
887 uint32_t *job_id /* [out] [ref] */,
888 WERROR *werror)
889 {
890 struct spoolss_StartDocPrinter r;
891 NTSTATUS status;
892
893 /* In parameters */
894 r.in.handle = handle;
895 r.in.level = level;
896 r.in.info = info;
897
898 if (DEBUGLEVEL >= 10) {
899 NDR_PRINT_IN_DEBUG(spoolss_StartDocPrinter, &r);
900 }
901
902 status = cli->dispatch(cli,
903 mem_ctx,
904 &ndr_table_spoolss,
905 NDR_SPOOLSS_STARTDOCPRINTER,
906 &r);
907
908 if (!NT_STATUS_IS_OK(status)) {
909 return status;
910 }
911
912 if (DEBUGLEVEL >= 10) {
913 NDR_PRINT_OUT_DEBUG(spoolss_StartDocPrinter, &r);
914 }
915
916 if (NT_STATUS_IS_ERR(status)) {
917 return status;
918 }
919
920 /* Return variables */
921 *job_id = *r.out.job_id;
922
923 /* Return result */
924 if (werror) {
925 *werror = r.out.result;
926 }
927
928 return werror_to_ntstatus(r.out.result);
929 }
930
931 NTSTATUS rpccli_spoolss_StartPagePrinter(struct rpc_pipe_client *cli,
932 TALLOC_CTX *mem_ctx,
933 struct policy_handle *handle /* [in] [ref] */,
934 WERROR *werror)
935 {
936 struct spoolss_StartPagePrinter r;
937 NTSTATUS status;
938
939 /* In parameters */
940 r.in.handle = handle;
941
942 if (DEBUGLEVEL >= 10) {
943 NDR_PRINT_IN_DEBUG(spoolss_StartPagePrinter, &r);
944 }
945
946 status = cli->dispatch(cli,
947 mem_ctx,
948 &ndr_table_spoolss,
949 NDR_SPOOLSS_STARTPAGEPRINTER,
950 &r);
951
952 if (!NT_STATUS_IS_OK(status)) {
953 return status;
954 }
955
956 if (DEBUGLEVEL >= 10) {
957 NDR_PRINT_OUT_DEBUG(spoolss_StartPagePrinter, &r);
958 }
959
960 if (NT_STATUS_IS_ERR(status)) {
961 return status;
962 }
963
964 /* Return variables */
965
966 /* Return result */
967 if (werror) {
968 *werror = r.out.result;
969 }
970
971 return werror_to_ntstatus(r.out.result);
972 }
973
974 NTSTATUS rpccli_spoolss_WritePrinter(struct rpc_pipe_client *cli,
975 TALLOC_CTX *mem_ctx,
976 struct policy_handle *handle /* [in] [ref] */,
977 DATA_BLOB data /* [in] */,
978 uint32_t _data_size /* [in] [value(r->in.data.length)] */,
979 uint32_t *num_written /* [out] [ref] */,
980 WERROR *werror)
981 {
982 struct spoolss_WritePrinter r;
983 NTSTATUS status;
984
985 /* In parameters */
986 r.in.handle = handle;
987 r.in.data = data;
988 r.in._data_size = _data_size;
989
990 if (DEBUGLEVEL >= 10) {
991 NDR_PRINT_IN_DEBUG(spoolss_WritePrinter, &r);
992 }
993
994 status = cli->dispatch(cli,
995 mem_ctx,
996 &ndr_table_spoolss,
997 NDR_SPOOLSS_WRITEPRINTER,
998 &r);
999
1000 if (!NT_STATUS_IS_OK(status)) {
1001 return status;
1002 }
1003
1004 if (DEBUGLEVEL >= 10) {
1005 NDR_PRINT_OUT_DEBUG(spoolss_WritePrinter, &r);
1006 }
1007
1008 if (NT_STATUS_IS_ERR(status)) {
1009 return status;
1010 }
1011
1012 /* Return variables */
1013 *num_written = *r.out.num_written;
1014
1015 /* Return result */
1016 if (werror) {
1017 *werror = r.out.result;
1018 }
1019
1020 return werror_to_ntstatus(r.out.result);
1021 }
1022
1023 NTSTATUS rpccli_spoolss_EndPagePrinter(struct rpc_pipe_client *cli,
1024 TALLOC_CTX *mem_ctx,
1025 struct policy_handle *handle /* [in] [ref] */,
1026 WERROR *werror)
1027 {
1028 struct spoolss_EndPagePrinter r;
1029 NTSTATUS status;
1030
1031 /* In parameters */
1032 r.in.handle = handle;
1033
1034 if (DEBUGLEVEL >= 10) {
1035 NDR_PRINT_IN_DEBUG(spoolss_EndPagePrinter, &r);
1036 }
1037
1038 status = cli->dispatch(cli,
1039 mem_ctx,
1040 &ndr_table_spoolss,
1041 NDR_SPOOLSS_ENDPAGEPRINTER,
1042 &r);
1043
1044 if (!NT_STATUS_IS_OK(status)) {
1045 return status;
1046 }
1047
1048 if (DEBUGLEVEL >= 10) {
1049 NDR_PRINT_OUT_DEBUG(spoolss_EndPagePrinter, &r);
1050 }
1051
1052 if (NT_STATUS_IS_ERR(status)) {
1053 return status;
1054 }
1055
1056 /* Return variables */
1057
1058 /* Return result */
1059 if (werror) {
1060 *werror = r.out.result;
1061 }
1062
1063 return werror_to_ntstatus(r.out.result);
1064 }
1065
1066 NTSTATUS rpccli_spoolss_AbortPrinter(struct rpc_pipe_client *cli,
1067 TALLOC_CTX *mem_ctx,
1068 struct policy_handle *handle /* [in] [ref] */,
1069 WERROR *werror)
1070 {
1071 struct spoolss_AbortPrinter r;
1072 NTSTATUS status;
1073
1074 /* In parameters */
1075 r.in.handle = handle;
1076
1077 if (DEBUGLEVEL >= 10) {
1078 NDR_PRINT_IN_DEBUG(spoolss_AbortPrinter, &r);
1079 }
1080
1081 status = cli->dispatch(cli,
1082 mem_ctx,
1083 &ndr_table_spoolss,
1084 NDR_SPOOLSS_ABORTPRINTER,
1085 &r);
1086
1087 if (!NT_STATUS_IS_OK(status)) {
1088 return status;
1089 }
1090
1091 if (DEBUGLEVEL >= 10) {
1092 NDR_PRINT_OUT_DEBUG(spoolss_AbortPrinter, &r);
1093 }
1094
1095 if (NT_STATUS_IS_ERR(status)) {
1096 return status;
1097 }
1098
1099 /* Return variables */
1100
1101 /* Return result */
1102 if (werror) {
1103 *werror = r.out.result;
1104 }
1105
1106 return werror_to_ntstatus(r.out.result);
1107 }
1108
1109 NTSTATUS rpccli_spoolss_ReadPrinter(struct rpc_pipe_client *cli,
1110 TALLOC_CTX *mem_ctx,
1111 struct policy_handle *handle /* [in] [ref] */,
1112 uint8_t *data /* [out] [ref,size_is(data_size)] */,
1113 uint32_t data_size /* [in] */,
1114 uint32_t *_data_size /* [out] [ref] */,
1115 WERROR *werror)
1116 {
1117 struct spoolss_ReadPrinter r;
1118 NTSTATUS status;
1119
1120 /* In parameters */
1121 r.in.handle = handle;
1122 r.in.data_size = data_size;
1123
1124 if (DEBUGLEVEL >= 10) {
1125 NDR_PRINT_IN_DEBUG(spoolss_ReadPrinter, &r);
1126 }
1127
1128 status = cli->dispatch(cli,
1129 mem_ctx,
1130 &ndr_table_spoolss,
1131 NDR_SPOOLSS_READPRINTER,
1132 &r);
1133
1134 if (!NT_STATUS_IS_OK(status)) {
1135 return status;
1136 }
1137
1138 if (DEBUGLEVEL >= 10) {
1139 NDR_PRINT_OUT_DEBUG(spoolss_ReadPrinter, &r);
1140 }
1141
1142 if (NT_STATUS_IS_ERR(status)) {
1143 return status;
1144 }
1145
1146 /* Return variables */
1147 memcpy(data, r.out.data, r.in.data_size * sizeof(*data));
1148 *_data_size = *r.out._data_size;
1149
1150 /* Return result */
1151 if (werror) {
1152 *werror = r.out.result;
1153 }
1154
1155 return werror_to_ntstatus(r.out.result);
1156 }
1157
1158 NTSTATUS rpccli_spoolss_EndDocPrinter(struct rpc_pipe_client *cli,
1159 TALLOC_CTX *mem_ctx,
1160 struct policy_handle *handle /* [in] [ref] */,
1161 WERROR *werror)
1162 {
1163 struct spoolss_EndDocPrinter r;
1164 NTSTATUS status;
1165
1166 /* In parameters */
1167 r.in.handle = handle;
1168
1169 if (DEBUGLEVEL >= 10) {
1170 NDR_PRINT_IN_DEBUG(spoolss_EndDocPrinter, &r);
1171 }
1172
1173 status = cli->dispatch(cli,
1174 mem_ctx,
1175 &ndr_table_spoolss,
1176 NDR_SPOOLSS_ENDDOCPRINTER,
1177 &r);
1178
1179 if (!NT_STATUS_IS_OK(status)) {
1180 return status;
1181 }
1182
1183 if (DEBUGLEVEL >= 10) {
1184 NDR_PRINT_OUT_DEBUG(spoolss_EndDocPrinter, &r);
1185 }
1186
1187 if (NT_STATUS_IS_ERR(status)) {
1188 return status;
1189 }
1190
1191 /* Return variables */
1192
1193 /* Return result */
1194 if (werror) {
1195 *werror = r.out.result;
1196 }
1197
1198 return werror_to_ntstatus(r.out.result);
1199 }
1200
1201 NTSTATUS rpccli_spoolss_AddJob(struct rpc_pipe_client *cli,
1202 TALLOC_CTX *mem_ctx,
1203 struct policy_handle *handle /* [in] [ref] */,
1204 uint32_t level /* [in] */,
1205 uint8_t *buffer /* [in,out] [unique,size_is(offered)] */,
1206 uint32_t offered /* [in] */,
1207 uint32_t *needed /* [out] [ref] */,
1208 WERROR *werror)
1209 {
1210 struct spoolss_AddJob r;
1211 NTSTATUS status;
1212
1213 /* In parameters */
1214 r.in.handle = handle;
1215 r.in.level = level;
1216 r.in.buffer = buffer;
1217 r.in.offered = offered;
1218
1219 if (DEBUGLEVEL >= 10) {
1220 NDR_PRINT_IN_DEBUG(spoolss_AddJob, &r);
1221 }
1222
1223 status = cli->dispatch(cli,
1224 mem_ctx,
1225 &ndr_table_spoolss,
1226 NDR_SPOOLSS_ADDJOB,
1227 &r);
1228
1229 if (!NT_STATUS_IS_OK(status)) {
1230 return status;
1231 }
1232
1233 if (DEBUGLEVEL >= 10) {
1234 NDR_PRINT_OUT_DEBUG(spoolss_AddJob, &r);
1235 }
1236
1237 if (NT_STATUS_IS_ERR(status)) {
1238 return status;
1239 }
1240
1241 /* Return variables */
1242 if (buffer && r.out.buffer) {
1243 memcpy(buffer, r.out.buffer, r.in.offered * sizeof(*buffer));
1244 }
1245 *needed = *r.out.needed;
1246
1247 /* Return result */
1248 if (werror) {
1249 *werror = r.out.result;
1250 }
1251
1252 return werror_to_ntstatus(r.out.result);
1253 }
1254
1255 NTSTATUS rpccli_spoolss_ScheduleJob(struct rpc_pipe_client *cli,
1256 TALLOC_CTX *mem_ctx,
1257 struct policy_handle *handle /* [in] [ref] */,
1258 uint32_t jobid /* [in] */,
1259 WERROR *werror)
1260 {
1261 struct spoolss_ScheduleJob r;
1262 NTSTATUS status;
1263
1264 /* In parameters */
1265 r.in.handle = handle;
1266 r.in.jobid = jobid;
1267
1268 if (DEBUGLEVEL >= 10) {
1269 NDR_PRINT_IN_DEBUG(spoolss_ScheduleJob, &r);
1270 }
1271
1272 status = cli->dispatch(cli,
1273 mem_ctx,
1274 &ndr_table_spoolss,
1275 NDR_SPOOLSS_SCHEDULEJOB,
1276 &r);
1277
1278 if (!NT_STATUS_IS_OK(status)) {
1279 return status;
1280 }
1281
1282 if (DEBUGLEVEL >= 10) {
1283 NDR_PRINT_OUT_DEBUG(spoolss_ScheduleJob, &r);
1284 }
1285
1286 if (NT_STATUS_IS_ERR(status)) {
1287 return status;
1288 }
1289
1290 /* Return variables */
1291
1292 /* Return result */
1293 if (werror) {
1294 *werror = r.out.result;
1295 }
1296
1297 return werror_to_ntstatus(r.out.result);
1298 }
1299
1300 NTSTATUS rpccli_spoolss_GetPrinterData(struct rpc_pipe_client *cli,
1301 TALLOC_CTX *mem_ctx,
1302 struct policy_handle *handle /* [in] [ref] */,
1303 const char *value_name /* [in] [charset(UTF16)] */,
1304 uint32_t offered /* [in] */,
1305 enum winreg_Type *type /* [out] [ref] */,
1306 union spoolss_PrinterData *data /* [out] [subcontext_size(offered),ref,subcontext(4),switch_is(*type)] */,
1307 uint32_t *needed /* [out] [ref] */,
1308 WERROR *werror)
1309 {
1310 struct spoolss_GetPrinterData r;
1311 NTSTATUS status;
1312
1313 /* In parameters */
1314 r.in.handle = handle;
1315 r.in.value_name = value_name;
1316 r.in.offered = offered;
1317
1318 if (DEBUGLEVEL >= 10) {
1319 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterData, &r);
1320 }
1321
1322 status = cli->dispatch(cli,
1323 mem_ctx,
1324 &ndr_table_spoolss,
1325 NDR_SPOOLSS_GETPRINTERDATA,
1326 &r);
1327
1328 if (!NT_STATUS_IS_OK(status)) {
1329 return status;
1330 }
1331
1332 if (DEBUGLEVEL >= 10) {
1333 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterData, &r);
1334 }
1335
1336 if (NT_STATUS_IS_ERR(status)) {
1337 return status;
1338 }
1339
1340 /* Return variables */
1341 *type = *r.out.type;
1342 *data = *r.out.data;
1343 *needed = *r.out.needed;
1344
1345 /* Return result */
1346 if (werror) {
1347 *werror = r.out.result;
1348 }
1349
1350 return werror_to_ntstatus(r.out.result);
1351 }
1352
1353 NTSTATUS rpccli_spoolss_SetPrinterData(struct rpc_pipe_client *cli,
1354 TALLOC_CTX *mem_ctx,
1355 struct policy_handle *handle /* [in] [ref] */,
1356 const char *value_name /* [in] [charset(UTF16)] */,
1357 enum winreg_Type type /* [in] */,
1358 union spoolss_PrinterData data /* [in] [subcontext(4),switch_is(type)] */,
1359 uint32_t _offered /* [in] [value(ndr_size_spoolss_PrinterData(&data,type,ndr->iconv_convenience,flags))] */,
1360 WERROR *werror)
1361 {
1362 struct spoolss_SetPrinterData r;
1363 NTSTATUS status;
1364
1365 /* In parameters */
1366 r.in.handle = handle;
1367 r.in.value_name = value_name;
1368 r.in.type = type;
1369 r.in.data = data;
1370 r.in._offered = _offered;
1371
1372 if (DEBUGLEVEL >= 10) {
1373 NDR_PRINT_IN_DEBUG(spoolss_SetPrinterData, &r);
1374 }
1375
1376 status = cli->dispatch(cli,
1377 mem_ctx,
1378 &ndr_table_spoolss,
1379 NDR_SPOOLSS_SETPRINTERDATA,
1380 &r);
1381
1382 if (!NT_STATUS_IS_OK(status)) {
1383 return status;
1384 }
1385
1386 if (DEBUGLEVEL >= 10) {
1387 NDR_PRINT_OUT_DEBUG(spoolss_SetPrinterData, &r);
1388 }
1389
1390 if (NT_STATUS_IS_ERR(status)) {
1391 return status;
1392 }
1393
1394 /* Return variables */
1395
1396 /* Return result */
1397 if (werror) {
1398 *werror = r.out.result;
1399 }
1400
1401 return werror_to_ntstatus(r.out.result);
1402 }
1403
1404 NTSTATUS rpccli_spoolss_WaitForPrinterChange(struct rpc_pipe_client *cli,
1405 TALLOC_CTX *mem_ctx,
1406 WERROR *werror)
1407 {
1408 struct spoolss_WaitForPrinterChange r;
1409 NTSTATUS status;
1410
1411 /* In parameters */
1412
1413 if (DEBUGLEVEL >= 10) {
1414 NDR_PRINT_IN_DEBUG(spoolss_WaitForPrinterChange, &r);
1415 }
1416
1417 status = cli->dispatch(cli,
1418 mem_ctx,
1419 &ndr_table_spoolss,
1420 NDR_SPOOLSS_WAITFORPRINTERCHANGE,
1421 &r);
1422
1423 if (!NT_STATUS_IS_OK(status)) {
1424 return status;
1425 }
1426
1427 if (DEBUGLEVEL >= 10) {
1428 NDR_PRINT_OUT_DEBUG(spoolss_WaitForPrinterChange, &r);
1429 }
1430
1431 if (NT_STATUS_IS_ERR(status)) {
1432 return status;
1433 }
1434
1435 /* Return variables */
1436
1437 /* Return result */
1438 if (werror) {
1439 *werror = r.out.result;
1440 }
1441
1442 return werror_to_ntstatus(r.out.result);
1443 }
1444
1445 NTSTATUS rpccli_spoolss_ClosePrinter(struct rpc_pipe_client *cli,
1446 TALLOC_CTX *mem_ctx,
1447 struct policy_handle *handle /* [in,out] [ref] */,
1448 WERROR *werror)
1449 {
1450 struct spoolss_ClosePrinter r;
1451 NTSTATUS status;
1452
1453 /* In parameters */
1454 r.in.handle = handle;
1455
1456 if (DEBUGLEVEL >= 10) {
1457 NDR_PRINT_IN_DEBUG(spoolss_ClosePrinter, &r);
1458 }
1459
1460 status = cli->dispatch(cli,
1461 mem_ctx,
1462 &ndr_table_spoolss,
1463 NDR_SPOOLSS_CLOSEPRINTER,
1464 &r);
1465
1466 if (!NT_STATUS_IS_OK(status)) {
1467 return status;
1468 }
1469
1470 if (DEBUGLEVEL >= 10) {
1471 NDR_PRINT_OUT_DEBUG(spoolss_ClosePrinter, &r);
1472 }
1473
1474 if (NT_STATUS_IS_ERR(status)) {
1475 return status;
1476 }
1477
1478 /* Return variables */
1479 *handle = *r.out.handle;
1480
1481 /* Return result */
1482 if (werror) {
1483 *werror = r.out.result;
1484 }
1485
1486 return werror_to_ntstatus(r.out.result);
1487 }
1488
1489 NTSTATUS rpccli_spoolss_AddForm(struct rpc_pipe_client *cli,
1490 TALLOC_CTX *mem_ctx,
1491 struct policy_handle *handle /* [in] [ref] */,
1492 uint32_t level /* [in] */,
1493 union spoolss_AddFormInfo info /* [in] [switch_is(level)] */,
1494 WERROR *werror)
1495 {
1496 struct spoolss_AddForm r;
1497 NTSTATUS status;
1498
1499 /* In parameters */
1500 r.in.handle = handle;
1501 r.in.level = level;
1502 r.in.info = info;
1503
1504 if (DEBUGLEVEL >= 10) {
1505 NDR_PRINT_IN_DEBUG(spoolss_AddForm, &r);
1506 }
1507
1508 status = cli->dispatch(cli,
1509 mem_ctx,
1510 &ndr_table_spoolss,
1511 NDR_SPOOLSS_ADDFORM,
1512 &r);
1513
1514 if (!NT_STATUS_IS_OK(status)) {
1515 return status;
1516 }
1517
1518 if (DEBUGLEVEL >= 10) {
1519 NDR_PRINT_OUT_DEBUG(spoolss_AddForm, &r);
1520 }
1521
1522 if (NT_STATUS_IS_ERR(status)) {
1523 return status;
1524 }
1525
1526 /* Return variables */
1527
1528 /* Return result */
1529 if (werror) {
1530 *werror = r.out.result;
1531 }
1532
1533 return werror_to_ntstatus(r.out.result);
1534 }
1535
1536 NTSTATUS rpccli_spoolss_DeleteForm(struct rpc_pipe_client *cli,
1537 TALLOC_CTX *mem_ctx,
1538 struct policy_handle *handle /* [in] [ref] */,
1539 const char *form_name /* [in] [charset(UTF16)] */,
1540 WERROR *werror)
1541 {
1542 struct spoolss_DeleteForm r;
1543 NTSTATUS status;
1544
1545 /* In parameters */
1546 r.in.handle = handle;
1547 r.in.form_name = form_name;
1548
1549 if (DEBUGLEVEL >= 10) {
1550 NDR_PRINT_IN_DEBUG(spoolss_DeleteForm, &r);
1551 }
1552
1553 status = cli->dispatch(cli,
1554 mem_ctx,
1555 &ndr_table_spoolss,
1556 NDR_SPOOLSS_DELETEFORM,
1557 &r);
1558
1559 if (!NT_STATUS_IS_OK(status)) {
1560 return status;
1561 }
1562
1563 if (DEBUGLEVEL >= 10) {
1564 NDR_PRINT_OUT_DEBUG(spoolss_DeleteForm, &r);
1565 }
1566
1567 if (NT_STATUS_IS_ERR(status)) {
1568 return status;
1569 }
1570
1571 /* Return variables */
1572
1573 /* Return result */
1574 if (werror) {
1575 *werror = r.out.result;
1576 }
1577
1578 return werror_to_ntstatus(r.out.result);
1579 }
1580
1581 NTSTATUS rpccli_spoolss_GetForm(struct rpc_pipe_client *cli,
1582 TALLOC_CTX *mem_ctx,
1583 struct policy_handle *handle /* [in] [ref] */,
1584 const char *form_name /* [in] [charset(UTF16)] */,
1585 uint32_t level /* [in] */,
1586 DATA_BLOB *buffer /* [in] [unique] */,
1587 uint32_t offered /* [in] */,
1588 union spoolss_FormInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
1589 uint32_t *needed /* [out] [ref] */,
1590 WERROR *werror)
1591 {
1592 struct spoolss_GetForm r;
1593 NTSTATUS status;
1594
1595 /* In parameters */
1596 r.in.handle = handle;
1597 r.in.form_name = form_name;
1598 r.in.level = level;
1599 r.in.buffer = buffer;
1600 r.in.offered = offered;
1601
1602 if (DEBUGLEVEL >= 10) {
1603 NDR_PRINT_IN_DEBUG(spoolss_GetForm, &r);
1604 }
1605
1606 status = cli->dispatch(cli,
1607 mem_ctx,
1608 &ndr_table_spoolss,
1609 NDR_SPOOLSS_GETFORM,
1610 &r);
1611
1612 if (!NT_STATUS_IS_OK(status)) {
1613 return status;
1614 }
1615
1616 if (DEBUGLEVEL >= 10) {
1617 NDR_PRINT_OUT_DEBUG(spoolss_GetForm, &r);
1618 }
1619
1620 if (NT_STATUS_IS_ERR(status)) {
1621 return status;
1622 }
1623
1624 /* Return variables */
1625 if (info && r.out.info) {
1626 *info = *r.out.info;
1627 }
1628 *needed = *r.out.needed;
1629
1630 /* Return result */
1631 if (werror) {
1632 *werror = r.out.result;
1633 }
1634
1635 return werror_to_ntstatus(r.out.result);
1636 }
1637
1638 NTSTATUS rpccli_spoolss_SetForm(struct rpc_pipe_client *cli,
1639 TALLOC_CTX *mem_ctx,
1640 struct policy_handle *handle /* [in] [ref] */,
1641 const char *form_name /* [in] [charset(UTF16)] */,
1642 uint32_t level /* [in] */,
1643 union spoolss_AddFormInfo info /* [in] [switch_is(level)] */,
1644 WERROR *werror)
1645 {
1646 struct spoolss_SetForm r;
1647 NTSTATUS status;
1648
1649 /* In parameters */
1650 r.in.handle = handle;
1651 r.in.form_name = form_name;
1652 r.in.level = level;
1653 r.in.info = info;
1654
1655 if (DEBUGLEVEL >= 10) {
1656 NDR_PRINT_IN_DEBUG(spoolss_SetForm, &r);
1657 }
1658
1659 status = cli->dispatch(cli,
1660 mem_ctx,
1661 &ndr_table_spoolss,
1662 NDR_SPOOLSS_SETFORM,
1663 &r);
1664
1665 if (!NT_STATUS_IS_OK(status)) {
1666 return status;
1667 }
1668
1669 if (DEBUGLEVEL >= 10) {
1670 NDR_PRINT_OUT_DEBUG(spoolss_SetForm, &r);
1671 }
1672
1673 if (NT_STATUS_IS_ERR(status)) {
1674 return status;
1675 }
1676
1677 /* Return variables */
1678
1679 /* Return result */
1680 if (werror) {
1681 *werror = r.out.result;
1682 }
1683
1684 return werror_to_ntstatus(r.out.result);
1685 }
1686
1687 NTSTATUS rpccli_spoolss_EnumForms(struct rpc_pipe_client *cli,
1688 TALLOC_CTX *mem_ctx,
1689 struct policy_handle *handle /* [in] [ref] */,
1690 uint32_t level /* [in] */,
1691 DATA_BLOB *buffer /* [in] [unique] */,
1692 uint32_t offered /* [in] */,
1693 uint32_t *count /* [out] [ref] */,
1694 union spoolss_FormInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
1695 uint32_t *needed /* [out] [ref] */,
1696 WERROR *werror)
1697 {
1698 struct spoolss_EnumForms r;
1699 NTSTATUS status;
1700
1701 /* In parameters */
1702 r.in.handle = handle;
1703 r.in.level = level;
1704 r.in.buffer = buffer;
1705 r.in.offered = offered;
1706
1707 if (DEBUGLEVEL >= 10) {
1708 NDR_PRINT_IN_DEBUG(spoolss_EnumForms, &r);
1709 }
1710
1711 status = cli->dispatch(cli,
1712 mem_ctx,
1713 &ndr_table_spoolss,
1714 NDR_SPOOLSS_ENUMFORMS,
1715 &r);
1716
1717 if (!NT_STATUS_IS_OK(status)) {
1718 return status;
1719 }
1720
1721 if (DEBUGLEVEL >= 10) {
1722 NDR_PRINT_OUT_DEBUG(spoolss_EnumForms, &r);
1723 }
1724
1725 if (NT_STATUS_IS_ERR(status)) {
1726 return status;
1727 }
1728
1729 /* Return variables */
1730 *count = *r.out.count;
1731 *info = *r.out.info;
1732 *needed = *r.out.needed;
1733
1734 /* Return result */
1735 if (werror) {
1736 *werror = r.out.result;
1737 }
1738
1739 return werror_to_ntstatus(r.out.result);
1740 }
1741
1742 NTSTATUS rpccli_spoolss_EnumPorts(struct rpc_pipe_client *cli,
1743 TALLOC_CTX *mem_ctx,
1744 const char *servername /* [in] [unique,charset(UTF16)] */,
1745 uint32_t level /* [in] */,
1746 DATA_BLOB *buffer /* [in] [unique] */,
1747 uint32_t offered /* [in] */,
1748 uint32_t *count /* [out] [ref] */,
1749 union spoolss_PortInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
1750 uint32_t *needed /* [out] [ref] */,
1751 WERROR *werror)
1752 {
1753 struct spoolss_EnumPorts r;
1754 NTSTATUS status;
1755
1756 /* In parameters */
1757 r.in.servername = servername;
1758 r.in.level = level;
1759 r.in.buffer = buffer;
1760 r.in.offered = offered;
1761
1762 if (DEBUGLEVEL >= 10) {
1763 NDR_PRINT_IN_DEBUG(spoolss_EnumPorts, &r);
1764 }
1765
1766 status = cli->dispatch(cli,
1767 mem_ctx,
1768 &ndr_table_spoolss,
1769 NDR_SPOOLSS_ENUMPORTS,
1770 &r);
1771
1772 if (!NT_STATUS_IS_OK(status)) {
1773 return status;
1774 }
1775
1776 if (DEBUGLEVEL >= 10) {
1777 NDR_PRINT_OUT_DEBUG(spoolss_EnumPorts, &r);
1778 }
1779
1780 if (NT_STATUS_IS_ERR(status)) {
1781 return status;
1782 }
1783
1784 /* Return variables */
1785 *count = *r.out.count;
1786 *info = *r.out.info;
1787 *needed = *r.out.needed;
1788
1789 /* Return result */
1790 if (werror) {
1791 *werror = r.out.result;
1792 }
1793
1794 return werror_to_ntstatus(r.out.result);
1795 }
1796
1797 NTSTATUS rpccli_spoolss_EnumMonitors(struct rpc_pipe_client *cli,
1798 TALLOC_CTX *mem_ctx,
1799 const char *servername /* [in] [unique,charset(UTF16)] */,
1800 uint32_t level /* [in] */,
1801 DATA_BLOB *buffer /* [in] [unique] */,
1802 uint32_t offered /* [in] */,
1803 uint32_t *count /* [out] [ref] */,
1804 union spoolss_MonitorInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
1805 uint32_t *needed /* [out] [ref] */,
1806 WERROR *werror)
1807 {
1808 struct spoolss_EnumMonitors r;
1809 NTSTATUS status;
1810
1811 /* In parameters */
1812 r.in.servername = servername;
1813 r.in.level = level;
1814 r.in.buffer = buffer;
1815 r.in.offered = offered;
1816
1817 if (DEBUGLEVEL >= 10) {
1818 NDR_PRINT_IN_DEBUG(spoolss_EnumMonitors, &r);
1819 }
1820
1821 status = cli->dispatch(cli,
1822 mem_ctx,
1823 &ndr_table_spoolss,
1824 NDR_SPOOLSS_ENUMMONITORS,
1825 &r);
1826
1827 if (!NT_STATUS_IS_OK(status)) {
1828 return status;
1829 }
1830
1831 if (DEBUGLEVEL >= 10) {
1832 NDR_PRINT_OUT_DEBUG(spoolss_EnumMonitors, &r);
1833 }
1834
1835 if (NT_STATUS_IS_ERR(status)) {
1836 return status;
1837 }
1838
1839 /* Return variables */
1840 *count = *r.out.count;
1841 *info = *r.out.info;
1842 *needed = *r.out.needed;
1843
1844 /* Return result */
1845 if (werror) {
1846 *werror = r.out.result;
1847 }
1848
1849 return werror_to_ntstatus(r.out.result);
1850 }
1851
1852 NTSTATUS rpccli_spoolss_AddPort(struct rpc_pipe_client *cli,
1853 TALLOC_CTX *mem_ctx,
1854 const char *server_name /* [in] [unique,charset(UTF16)] */,
1855 uint32_t unknown /* [in] */,
1856 const char *monitor_name /* [in] [charset(UTF16)] */,
1857 WERROR *werror)
1858 {
1859 struct spoolss_AddPort r;
1860 NTSTATUS status;
1861
1862 /* In parameters */
1863 r.in.server_name = server_name;
1864 r.in.unknown = unknown;
1865 r.in.monitor_name = monitor_name;
1866
1867 if (DEBUGLEVEL >= 10) {
1868 NDR_PRINT_IN_DEBUG(spoolss_AddPort, &r);
1869 }
1870
1871 status = cli->dispatch(cli,
1872 mem_ctx,
1873 &ndr_table_spoolss,
1874 NDR_SPOOLSS_ADDPORT,
1875 &r);
1876
1877 if (!NT_STATUS_IS_OK(status)) {
1878 return status;
1879 }
1880
1881 if (DEBUGLEVEL >= 10) {
1882 NDR_PRINT_OUT_DEBUG(spoolss_AddPort, &r);
1883 }
1884
1885 if (NT_STATUS_IS_ERR(status)) {
1886 return status;
1887 }
1888
1889 /* Return variables */
1890
1891 /* Return result */
1892 if (werror) {
1893 *werror = r.out.result;
1894 }
1895
1896 return werror_to_ntstatus(r.out.result);
1897 }
1898
1899 NTSTATUS rpccli_spoolss_ConfigurePort(struct rpc_pipe_client *cli,
1900 TALLOC_CTX *mem_ctx,
1901 WERROR *werror)
1902 {
1903 struct spoolss_ConfigurePort r;
1904 NTSTATUS status;
1905
1906 /* In parameters */
1907
1908 if (DEBUGLEVEL >= 10) {
1909 NDR_PRINT_IN_DEBUG(spoolss_ConfigurePort, &r);
1910 }
1911
1912 status = cli->dispatch(cli,
1913 mem_ctx,
1914 &ndr_table_spoolss,
1915 NDR_SPOOLSS_CONFIGUREPORT,
1916 &r);
1917
1918 if (!NT_STATUS_IS_OK(status)) {
1919 return status;
1920 }
1921
1922 if (DEBUGLEVEL >= 10) {
1923 NDR_PRINT_OUT_DEBUG(spoolss_ConfigurePort, &r);
1924 }
1925
1926 if (NT_STATUS_IS_ERR(status)) {
1927 return status;
1928 }
1929
1930 /* Return variables */
1931
1932 /* Return result */
1933 if (werror) {
1934 *werror = r.out.result;
1935 }
1936
1937 return werror_to_ntstatus(r.out.result);
1938 }
1939
1940 NTSTATUS rpccli_spoolss_DeletePort(struct rpc_pipe_client *cli,
1941 TALLOC_CTX *mem_ctx,
1942 WERROR *werror)
1943 {
1944 struct spoolss_DeletePort r;
1945 NTSTATUS status;
1946
1947 /* In parameters */
1948
1949 if (DEBUGLEVEL >= 10) {
1950 NDR_PRINT_IN_DEBUG(spoolss_DeletePort, &r);
1951 }
1952
1953 status = cli->dispatch(cli,
1954 mem_ctx,
1955 &ndr_table_spoolss,
1956 NDR_SPOOLSS_DELETEPORT,
1957 &r);
1958
1959 if (!NT_STATUS_IS_OK(status)) {
1960 return status;
1961 }
1962
1963 if (DEBUGLEVEL >= 10) {
1964 NDR_PRINT_OUT_DEBUG(spoolss_DeletePort, &r);
1965 }
1966
1967 if (NT_STATUS_IS_ERR(status)) {
1968 return status;
1969 }
1970
1971 /* Return variables */
1972
1973 /* Return result */
1974 if (werror) {
1975 *werror = r.out.result;
1976 }
1977
1978 return werror_to_ntstatus(r.out.result);
1979 }
1980
1981 NTSTATUS rpccli_spoolss_CreatePrinterIC(struct rpc_pipe_client *cli,
1982 TALLOC_CTX *mem_ctx,
1983 WERROR *werror)
1984 {
1985 struct spoolss_CreatePrinterIC r;
1986 NTSTATUS status;
1987
1988 /* In parameters */
1989
1990 if (DEBUGLEVEL >= 10) {
1991 NDR_PRINT_IN_DEBUG(spoolss_CreatePrinterIC, &r);
1992 }
1993
1994 status = cli->dispatch(cli,
1995 mem_ctx,
1996 &ndr_table_spoolss,
1997 NDR_SPOOLSS_CREATEPRINTERIC,
1998 &r);
1999
2000 if (!NT_STATUS_IS_OK(status)) {
2001 return status;
2002 }
2003
2004 if (DEBUGLEVEL >= 10) {
2005 NDR_PRINT_OUT_DEBUG(spoolss_CreatePrinterIC, &r);
2006 }
2007
2008 if (NT_STATUS_IS_ERR(status)) {
2009 return status;
2010 }
2011
2012 /* Return variables */
2013
2014 /* Return result */
2015 if (werror) {
2016 *werror = r.out.result;
2017 }
2018
2019 return werror_to_ntstatus(r.out.result);
2020 }
2021
2022 NTSTATUS rpccli_spoolss_PlayGDIScriptOnPrinterIC(struct rpc_pipe_client *cli,
2023 TALLOC_CTX *mem_ctx,
2024 WERROR *werror)
2025 {
2026 struct spoolss_PlayGDIScriptOnPrinterIC r;
2027 NTSTATUS status;
2028
2029 /* In parameters */
2030
2031 if (DEBUGLEVEL >= 10) {
2032 NDR_PRINT_IN_DEBUG(spoolss_PlayGDIScriptOnPrinterIC, &r);
2033 }
2034
2035 status = cli->dispatch(cli,
2036 mem_ctx,
2037 &ndr_table_spoolss,
2038 NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC,
2039 &r);
2040
2041 if (!NT_STATUS_IS_OK(status)) {
2042 return status;
2043 }
2044
2045 if (DEBUGLEVEL >= 10) {
2046 NDR_PRINT_OUT_DEBUG(spoolss_PlayGDIScriptOnPrinterIC, &r);
2047 }
2048
2049 if (NT_STATUS_IS_ERR(status)) {
2050 return status;
2051 }
2052
2053 /* Return variables */
2054
2055 /* Return result */
2056 if (werror) {
2057 *werror = r.out.result;
2058 }
2059
2060 return werror_to_ntstatus(r.out.result);
2061 }
2062
2063 NTSTATUS rpccli_spoolss_DeletePrinterIC(struct rpc_pipe_client *cli,
2064 TALLOC_CTX *mem_ctx,
2065 WERROR *werror)
2066 {
2067 struct spoolss_DeletePrinterIC r;
2068 NTSTATUS status;
2069
2070 /* In parameters */
2071
2072 if (DEBUGLEVEL >= 10) {
2073 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterIC, &r);
2074 }
2075
2076 status = cli->dispatch(cli,
2077 mem_ctx,
2078 &ndr_table_spoolss,
2079 NDR_SPOOLSS_DELETEPRINTERIC,
2080 &r);
2081
2082 if (!NT_STATUS_IS_OK(status)) {
2083 return status;
2084 }
2085
2086 if (DEBUGLEVEL >= 10) {
2087 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterIC, &r);
2088 }
2089
2090 if (NT_STATUS_IS_ERR(status)) {
2091 return status;
2092 }
2093
2094 /* Return variables */
2095
2096 /* Return result */
2097 if (werror) {
2098 *werror = r.out.result;
2099 }
2100
2101 return werror_to_ntstatus(r.out.result);
2102 }
2103
2104 NTSTATUS rpccli_spoolss_AddPrinterConnection(struct rpc_pipe_client *cli,
2105 TALLOC_CTX *mem_ctx,
2106 WERROR *werror)
2107 {
2108 struct spoolss_AddPrinterConnection r;
2109 NTSTATUS status;
2110
2111 /* In parameters */
2112
2113 if (DEBUGLEVEL >= 10) {
2114 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterConnection, &r);
2115 }
2116
2117 status = cli->dispatch(cli,
2118 mem_ctx,
2119 &ndr_table_spoolss,
2120 NDR_SPOOLSS_ADDPRINTERCONNECTION,
2121 &r);
2122
2123 if (!NT_STATUS_IS_OK(status)) {
2124 return status;
2125 }
2126
2127 if (DEBUGLEVEL >= 10) {
2128 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterConnection, &r);
2129 }
2130
2131 if (NT_STATUS_IS_ERR(status)) {
2132 return status;
2133 }
2134
2135 /* Return variables */
2136
2137 /* Return result */
2138 if (werror) {
2139 *werror = r.out.result;
2140 }
2141
2142 return werror_to_ntstatus(r.out.result);
2143 }
2144
2145 NTSTATUS rpccli_spoolss_DeletePrinterConnection(struct rpc_pipe_client *cli,
2146 TALLOC_CTX *mem_ctx,
2147 WERROR *werror)
2148 {
2149 struct spoolss_DeletePrinterConnection r;
2150 NTSTATUS status;
2151
2152 /* In parameters */
2153
2154 if (DEBUGLEVEL >= 10) {
2155 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterConnection, &r);
2156 }
2157
2158 status = cli->dispatch(cli,
2159 mem_ctx,
2160 &ndr_table_spoolss,
2161 NDR_SPOOLSS_DELETEPRINTERCONNECTION,
2162 &r);
2163
2164 if (!NT_STATUS_IS_OK(status)) {
2165 return status;
2166 }
2167
2168 if (DEBUGLEVEL >= 10) {
2169 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterConnection, &r);
2170 }
2171
2172 if (NT_STATUS_IS_ERR(status)) {
2173 return status;
2174 }
2175
2176 /* Return variables */
2177
2178 /* Return result */
2179 if (werror) {
2180 *werror = r.out.result;
2181 }
2182
2183 return werror_to_ntstatus(r.out.result);
2184 }
2185
2186 NTSTATUS rpccli_spoolss_PrinterMessageBox(struct rpc_pipe_client *cli,
2187 TALLOC_CTX *mem_ctx,
2188 WERROR *werror)
2189 {
2190 struct spoolss_PrinterMessageBox r;
2191 NTSTATUS status;
2192
2193 /* In parameters */
2194
2195 if (DEBUGLEVEL >= 10) {
2196 NDR_PRINT_IN_DEBUG(spoolss_PrinterMessageBox, &r);
2197 }
2198
2199 status = cli->dispatch(cli,
2200 mem_ctx,
2201 &ndr_table_spoolss,
2202 NDR_SPOOLSS_PRINTERMESSAGEBOX,
2203 &r);
2204
2205 if (!NT_STATUS_IS_OK(status)) {
2206 return status;
2207 }
2208
2209 if (DEBUGLEVEL >= 10) {
2210 NDR_PRINT_OUT_DEBUG(spoolss_PrinterMessageBox, &r);
2211 }
2212
2213 if (NT_STATUS_IS_ERR(status)) {
2214 return status;
2215 }
2216
2217 /* Return variables */
2218
2219 /* Return result */
2220 if (werror) {
2221 *werror = r.out.result;
2222 }
2223
2224 return werror_to_ntstatus(r.out.result);
2225 }
2226
2227 NTSTATUS rpccli_spoolss_AddMonitor(struct rpc_pipe_client *cli,
2228 TALLOC_CTX *mem_ctx,
2229 WERROR *werror)
2230 {
2231 struct spoolss_AddMonitor r;
2232 NTSTATUS status;
2233
2234 /* In parameters */
2235
2236 if (DEBUGLEVEL >= 10) {
2237 NDR_PRINT_IN_DEBUG(spoolss_AddMonitor, &r);
2238 }
2239
2240 status = cli->dispatch(cli,
2241 mem_ctx,
2242 &ndr_table_spoolss,
2243 NDR_SPOOLSS_ADDMONITOR,
2244 &r);
2245
2246 if (!NT_STATUS_IS_OK(status)) {
2247 return status;
2248 }
2249
2250 if (DEBUGLEVEL >= 10) {
2251 NDR_PRINT_OUT_DEBUG(spoolss_AddMonitor, &r);
2252 }
2253
2254 if (NT_STATUS_IS_ERR(status)) {
2255 return status;
2256 }
2257
2258 /* Return variables */
2259
2260 /* Return result */
2261 if (werror) {
2262 *werror = r.out.result;
2263 }
2264
2265 return werror_to_ntstatus(r.out.result);
2266 }
2267
2268 NTSTATUS rpccli_spoolss_DeleteMonitor(struct rpc_pipe_client *cli,
2269 TALLOC_CTX *mem_ctx,
2270 WERROR *werror)
2271 {
2272 struct spoolss_DeleteMonitor r;
2273 NTSTATUS status;
2274
2275 /* In parameters */
2276
2277 if (DEBUGLEVEL >= 10) {
2278 NDR_PRINT_IN_DEBUG(spoolss_DeleteMonitor, &r);
2279 }
2280
2281 status = cli->dispatch(cli,
2282 mem_ctx,
2283 &ndr_table_spoolss,
2284 NDR_SPOOLSS_DELETEMONITOR,
2285 &r);
2286
2287 if (!NT_STATUS_IS_OK(status)) {
2288 return status;
2289 }
2290
2291 if (DEBUGLEVEL >= 10) {
2292 NDR_PRINT_OUT_DEBUG(spoolss_DeleteMonitor, &r);
2293 }
2294
2295 if (NT_STATUS_IS_ERR(status)) {
2296 return status;
2297 }
2298
2299 /* Return variables */
2300
2301 /* Return result */
2302 if (werror) {
2303 *werror = r.out.result;
2304 }
2305
2306 return werror_to_ntstatus(r.out.result);
2307 }
2308
2309 NTSTATUS rpccli_spoolss_DeletePrintProcessor(struct rpc_pipe_client *cli,
2310 TALLOC_CTX *mem_ctx,
2311 WERROR *werror)
2312 {
2313 struct spoolss_DeletePrintProcessor r;
2314 NTSTATUS status;
2315
2316 /* In parameters */
2317
2318 if (DEBUGLEVEL >= 10) {
2319 NDR_PRINT_IN_DEBUG(spoolss_DeletePrintProcessor, &r);
2320 }
2321
2322 status = cli->dispatch(cli,
2323 mem_ctx,
2324 &ndr_table_spoolss,
2325 NDR_SPOOLSS_DELETEPRINTPROCESSOR,
2326 &r);
2327
2328 if (!NT_STATUS_IS_OK(status)) {
2329 return status;
2330 }
2331
2332 if (DEBUGLEVEL >= 10) {
2333 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrintProcessor, &r);
2334 }
2335
2336 if (NT_STATUS_IS_ERR(status)) {
2337 return status;
2338 }
2339
2340 /* Return variables */
2341
2342 /* Return result */
2343 if (werror) {
2344 *werror = r.out.result;
2345 }
2346
2347 return werror_to_ntstatus(r.out.result);
2348 }
2349
2350 NTSTATUS rpccli_spoolss_AddPrintProvidor(struct rpc_pipe_client *cli,
2351 TALLOC_CTX *mem_ctx,
2352 WERROR *werror)
2353 {
2354 struct spoolss_AddPrintProvidor r;
2355 NTSTATUS status;
2356
2357 /* In parameters */
2358
2359 if (DEBUGLEVEL >= 10) {
2360 NDR_PRINT_IN_DEBUG(spoolss_AddPrintProvidor, &r);
2361 }
2362
2363 status = cli->dispatch(cli,
2364 mem_ctx,
2365 &ndr_table_spoolss,
2366 NDR_SPOOLSS_ADDPRINTPROVIDOR,
2367 &r);
2368
2369 if (!NT_STATUS_IS_OK(status)) {
2370 return status;
2371 }
2372
2373 if (DEBUGLEVEL >= 10) {
2374 NDR_PRINT_OUT_DEBUG(spoolss_AddPrintProvidor, &r);
2375 }
2376
2377 if (NT_STATUS_IS_ERR(status)) {
2378 return status;
2379 }
2380
2381 /* Return variables */
2382
2383 /* Return result */
2384 if (werror) {
2385 *werror = r.out.result;
2386 }
2387
2388 return werror_to_ntstatus(r.out.result);
2389 }
2390
2391 NTSTATUS rpccli_spoolss_DeletePrintProvidor(struct rpc_pipe_client *cli,
2392 TALLOC_CTX *mem_ctx,
2393 WERROR *werror)
2394 {
2395 struct spoolss_DeletePrintProvidor r;
2396 NTSTATUS status;
2397
2398 /* In parameters */
2399
2400 if (DEBUGLEVEL >= 10) {
2401 NDR_PRINT_IN_DEBUG(spoolss_DeletePrintProvidor, &r);
2402 }
2403
2404 status = cli->dispatch(cli,
2405 mem_ctx,
2406 &ndr_table_spoolss,
2407 NDR_SPOOLSS_DELETEPRINTPROVIDOR,
2408 &r);
2409
2410 if (!NT_STATUS_IS_OK(status)) {
2411 return status;
2412 }
2413
2414 if (DEBUGLEVEL >= 10) {
2415 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrintProvidor, &r);
2416 }
2417
2418 if (NT_STATUS_IS_ERR(status)) {
2419 return status;
2420 }
2421
2422 /* Return variables */
2423
2424 /* Return result */
2425 if (werror) {
2426 *werror = r.out.result;
2427 }
2428
2429 return werror_to_ntstatus(r.out.result);
2430 }
2431
2432 NTSTATUS rpccli_spoolss_EnumPrintProcDataTypes(struct rpc_pipe_client *cli,
2433 TALLOC_CTX *mem_ctx,
2434 const char *servername /* [in] [unique,charset(UTF16)] */,
2435 const char *print_processor_name /* [in] [unique,charset(UTF16)] */,
2436 uint32_t level /* [in] */,
2437 DATA_BLOB *buffer /* [in] [unique] */,
2438 uint32_t offered /* [in] */,
2439 uint32_t *count /* [out] [ref] */,
2440 union spoolss_PrintProcDataTypesInfo **info /* [out] [ref,switch_is(level),size_is(,*count)] */,
2441 uint32_t *needed /* [out] [ref] */,
2442 WERROR *werror)
2443 {
2444 struct spoolss_EnumPrintProcDataTypes r;
2445 NTSTATUS status;
2446
2447 /* In parameters */
2448 r.in.servername = servername;
2449 r.in.print_processor_name = print_processor_name;
2450 r.in.level = level;
2451 r.in.buffer = buffer;
2452 r.in.offered = offered;
2453
2454 if (DEBUGLEVEL >= 10) {
2455 NDR_PRINT_IN_DEBUG(spoolss_EnumPrintProcDataTypes, &r);
2456 }
2457
2458 status = cli->dispatch(cli,
2459 mem_ctx,
2460 &ndr_table_spoolss,
2461 NDR_SPOOLSS_ENUMPRINTPROCDATATYPES,
2462 &r);
2463
2464 if (!NT_STATUS_IS_OK(status)) {
2465 return status;
2466 }
2467
2468 if (DEBUGLEVEL >= 10) {
2469 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrintProcDataTypes, &r);
2470 }
2471
2472 if (NT_STATUS_IS_ERR(status)) {
2473 return status;
2474 }
2475
2476 /* Return variables */
2477 *count = *r.out.count;
2478 *info = *r.out.info;
2479 *needed = *r.out.needed;
2480
2481 /* Return result */
2482 if (werror) {
2483 *werror = r.out.result;
2484 }
2485
2486 return werror_to_ntstatus(r.out.result);
2487 }
2488
2489 NTSTATUS rpccli_spoolss_ResetPrinter(struct rpc_pipe_client *cli,
2490 TALLOC_CTX *mem_ctx,
2491 struct policy_handle *handle /* [in] [ref] */,
2492 const char *data_type /* [in] [unique,charset(UTF16)] */,
2493 struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
2494 WERROR *werror)
2495 {
2496 struct spoolss_ResetPrinter r;
2497 NTSTATUS status;
2498
2499 /* In parameters */
2500 r.in.handle = handle;
2501 r.in.data_type = data_type;
2502 r.in.devmode_ctr = devmode_ctr;
2503
2504 if (DEBUGLEVEL >= 10) {
2505 NDR_PRINT_IN_DEBUG(spoolss_ResetPrinter, &r);
2506 }
2507
2508 status = cli->dispatch(cli,
2509 mem_ctx,
2510 &ndr_table_spoolss,
2511 NDR_SPOOLSS_RESETPRINTER,
2512 &r);
2513
2514 if (!NT_STATUS_IS_OK(status)) {
2515 return status;
2516 }
2517
2518 if (DEBUGLEVEL >= 10) {
2519 NDR_PRINT_OUT_DEBUG(spoolss_ResetPrinter, &r);
2520 }
2521
2522 if (NT_STATUS_IS_ERR(status)) {
2523 return status;
2524 }
2525
2526 /* Return variables */
2527
2528 /* Return result */
2529 if (werror) {
2530 *werror = r.out.result;
2531 }
2532
2533 return werror_to_ntstatus(r.out.result);
2534 }
2535
2536 NTSTATUS rpccli_spoolss_GetPrinterDriver2(struct rpc_pipe_client *cli,
2537 TALLOC_CTX *mem_ctx,
2538 struct policy_handle *handle /* [in] [ref] */,
2539 const char *architecture /* [in] [unique,charset(UTF16)] */,
2540 uint32_t level /* [in] */,
2541 DATA_BLOB *buffer /* [in] [unique] */,
2542 uint32_t offered /* [in] */,
2543 uint32_t client_major_version /* [in] */,
2544 uint32_t client_minor_version /* [in] */,
2545 union spoolss_DriverInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
2546 uint32_t *needed /* [out] [ref] */,
2547 uint32_t *server_major_version /* [out] [ref] */,
2548 uint32_t *server_minor_version /* [out] [ref] */,
2549 WERROR *werror)
2550 {
2551 struct spoolss_GetPrinterDriver2 r;
2552 NTSTATUS status;
2553
2554 /* In parameters */
2555 r.in.handle = handle;
2556 r.in.architecture = architecture;
2557 r.in.level = level;
2558 r.in.buffer = buffer;
2559 r.in.offered = offered;
2560 r.in.client_major_version = client_major_version;
2561 r.in.client_minor_version = client_minor_version;
2562
2563 if (DEBUGLEVEL >= 10) {
2564 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriver2, &r);
2565 }
2566
2567 status = cli->dispatch(cli,
2568 mem_ctx,
2569 &ndr_table_spoolss,
2570 NDR_SPOOLSS_GETPRINTERDRIVER2,
2571 &r);
2572
2573 if (!NT_STATUS_IS_OK(status)) {
2574 return status;
2575 }
2576
2577 if (DEBUGLEVEL >= 10) {
2578 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriver2, &r);
2579 }
2580
2581 if (NT_STATUS_IS_ERR(status)) {
2582 return status;
2583 }
2584
2585 /* Return variables */
2586 if (info && r.out.info) {
2587 *info = *r.out.info;
2588 }
2589 *needed = *r.out.needed;
2590 *server_major_version = *r.out.server_major_version;
2591 *server_minor_version = *r.out.server_minor_version;
2592
2593 /* Return result */
2594 if (werror) {
2595 *werror = r.out.result;
2596 }
2597
2598 return werror_to_ntstatus(r.out.result);
2599 }
2600
2601 NTSTATUS rpccli_spoolss_FindFirstPrinterChangeNotification(struct rpc_pipe_client *cli,
2602 TALLOC_CTX *mem_ctx,
2603 WERROR *werror)
2604 {
2605 struct spoolss_FindFirstPrinterChangeNotification r;
2606 NTSTATUS status;
2607
2608 /* In parameters */
2609
2610 if (DEBUGLEVEL >= 10) {
2611 NDR_PRINT_IN_DEBUG(spoolss_FindFirstPrinterChangeNotification, &r);
2612 }
2613
2614 status = cli->dispatch(cli,
2615 mem_ctx,
2616 &ndr_table_spoolss,
2617 NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION,
2618 &r);
2619
2620 if (!NT_STATUS_IS_OK(status)) {
2621 return status;
2622 }
2623
2624 if (DEBUGLEVEL >= 10) {
2625 NDR_PRINT_OUT_DEBUG(spoolss_FindFirstPrinterChangeNotification, &r);
2626 }
2627
2628 if (NT_STATUS_IS_ERR(status)) {
2629 return status;
2630 }
2631
2632 /* Return variables */
2633
2634 /* Return result */
2635 if (werror) {
2636 *werror = r.out.result;
2637 }
2638
2639 return werror_to_ntstatus(r.out.result);
2640 }
2641
2642 NTSTATUS rpccli_spoolss_FindNextPrinterChangeNotification(struct rpc_pipe_client *cli,
2643 TALLOC_CTX *mem_ctx,
2644 WERROR *werror)
2645 {
2646 struct spoolss_FindNextPrinterChangeNotification r;
2647 NTSTATUS status;
2648
2649 /* In parameters */
2650
2651 if (DEBUGLEVEL >= 10) {
2652 NDR_PRINT_IN_DEBUG(spoolss_FindNextPrinterChangeNotification, &r);
2653 }
2654
2655 status = cli->dispatch(cli,
2656 mem_ctx,
2657 &ndr_table_spoolss,
2658 NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION,
2659 &r);
2660
2661 if (!NT_STATUS_IS_OK(status)) {
2662 return status;
2663 }
2664
2665 if (DEBUGLEVEL >= 10) {
2666 NDR_PRINT_OUT_DEBUG(spoolss_FindNextPrinterChangeNotification, &r);
2667 }
2668
2669 if (NT_STATUS_IS_ERR(status)) {
2670 return status;
2671 }
2672
2673 /* Return variables */
2674
2675 /* Return result */
2676 if (werror) {
2677 *werror = r.out.result;
2678 }
2679
2680 return werror_to_ntstatus(r.out.result);
2681 }
2682
2683 NTSTATUS rpccli_spoolss_FindClosePrinterNotify(struct rpc_pipe_client *cli,
2684 TALLOC_CTX *mem_ctx,
2685 struct policy_handle *handle /* [in] [ref] */,
2686 WERROR *werror)
2687 {
2688 struct spoolss_FindClosePrinterNotify r;
2689 NTSTATUS status;
2690
2691 /* In parameters */
2692 r.in.handle = handle;
2693
2694 if (DEBUGLEVEL >= 10) {
2695 NDR_PRINT_IN_DEBUG(spoolss_FindClosePrinterNotify, &r);
2696 }
2697
2698 status = cli->dispatch(cli,
2699 mem_ctx,
2700 &ndr_table_spoolss,
2701 NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY,
2702 &r);
2703
2704 if (!NT_STATUS_IS_OK(status)) {
2705 return status;
2706 }
2707
2708 if (DEBUGLEVEL >= 10) {
2709 NDR_PRINT_OUT_DEBUG(spoolss_FindClosePrinterNotify, &r);
2710 }
2711
2712 if (NT_STATUS_IS_ERR(status)) {
2713 return status;
2714 }
2715
2716 /* Return variables */
2717
2718 /* Return result */
2719 if (werror) {
2720 *werror = r.out.result;
2721 }
2722
2723 return werror_to_ntstatus(r.out.result);
2724 }
2725
2726 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct rpc_pipe_client *cli,
2727 TALLOC_CTX *mem_ctx,
2728 WERROR *werror)
2729 {
2730 struct spoolss_RouterFindFirstPrinterChangeNotificationOld r;
2731 NTSTATUS status;
2732
2733 /* In parameters */
2734
2735 if (DEBUGLEVEL >= 10) {
2736 NDR_PRINT_IN_DEBUG(spoolss_RouterFindFirstPrinterChangeNotificationOld, &r);
2737 }
2738
2739 status = cli->dispatch(cli,
2740 mem_ctx,
2741 &ndr_table_spoolss,
2742 NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD,
2743 &r);
2744
2745 if (!NT_STATUS_IS_OK(status)) {
2746 return status;
2747 }
2748
2749 if (DEBUGLEVEL >= 10) {
2750 NDR_PRINT_OUT_DEBUG(spoolss_RouterFindFirstPrinterChangeNotificationOld, &r);
2751 }
2752
2753 if (NT_STATUS_IS_ERR(status)) {
2754 return status;
2755 }
2756
2757 /* Return variables */
2758
2759 /* Return result */
2760 if (werror) {
2761 *werror = r.out.result;
2762 }
2763
2764 return werror_to_ntstatus(r.out.result);
2765 }
2766
2767 NTSTATUS rpccli_spoolss_ReplyOpenPrinter(struct rpc_pipe_client *cli,
2768 TALLOC_CTX *mem_ctx,
2769 const char *server_name /* [in] [charset(UTF16)] */,
2770 uint32_t printer_local /* [in] */,
2771 enum winreg_Type type /* [in] */,
2772 uint32_t bufsize /* [in] [range(0,512)] */,
2773 uint8_t *buffer /* [in] [unique,size_is(bufsize)] */,
2774 struct policy_handle *handle /* [out] [ref] */,
2775 WERROR *werror)
2776 {
2777 struct spoolss_ReplyOpenPrinter r;
2778 NTSTATUS status;
2779
2780 /* In parameters */
2781 r.in.server_name = server_name;
2782 r.in.printer_local = printer_local;
2783 r.in.type = type;
2784 r.in.bufsize = bufsize;
2785 r.in.buffer = buffer;
2786
2787 if (DEBUGLEVEL >= 10) {
2788 NDR_PRINT_IN_DEBUG(spoolss_ReplyOpenPrinter, &r);
2789 }
2790
2791 status = cli->dispatch(cli,
2792 mem_ctx,
2793 &ndr_table_spoolss,
2794 NDR_SPOOLSS_REPLYOPENPRINTER,
2795 &r);
2796
2797 if (!NT_STATUS_IS_OK(status)) {
2798 return status;
2799 }
2800
2801 if (DEBUGLEVEL >= 10) {
2802 NDR_PRINT_OUT_DEBUG(spoolss_ReplyOpenPrinter, &r);
2803 }
2804
2805 if (NT_STATUS_IS_ERR(status)) {
2806 return status;
2807 }
2808
2809 /* Return variables */
2810 *handle = *r.out.handle;
2811
2812 /* Return result */
2813 if (werror) {
2814 *werror = r.out.result;
2815 }
2816
2817 return werror_to_ntstatus(r.out.result);
2818 }
2819
2820 NTSTATUS rpccli_spoolss_RouterReplyPrinter(struct rpc_pipe_client *cli,
2821 TALLOC_CTX *mem_ctx,
2822 struct policy_handle *handle /* [in] [ref] */,
2823 uint32_t flags /* [in] */,
2824 uint32_t bufsize /* [in] [range(0,512)] */,
2825 uint8_t *buffer /* [in] [unique,size_is(bufsize)] */,
2826 WERROR *werror)
2827 {
2828 struct spoolss_RouterReplyPrinter r;
2829 NTSTATUS status;
2830
2831 /* In parameters */
2832 r.in.handle = handle;
2833 r.in.flags = flags;
2834 r.in.bufsize = bufsize;
2835 r.in.buffer = buffer;
2836
2837 if (DEBUGLEVEL >= 10) {
2838 NDR_PRINT_IN_DEBUG(spoolss_RouterReplyPrinter, &r);
2839 }
2840
2841 status = cli->dispatch(cli,
2842 mem_ctx,
2843 &ndr_table_spoolss,
2844 NDR_SPOOLSS_ROUTERREPLYPRINTER,
2845 &r);
2846
2847 if (!NT_STATUS_IS_OK(status)) {
2848 return status;
2849 }
2850
2851 if (DEBUGLEVEL >= 10) {
2852 NDR_PRINT_OUT_DEBUG(spoolss_RouterReplyPrinter, &r);
2853 }
2854
2855 if (NT_STATUS_IS_ERR(status)) {
2856 return status;
2857 }
2858
2859 /* Return variables */
2860
2861 /* Return result */
2862 if (werror) {
2863 *werror = r.out.result;
2864 }
2865
2866 return werror_to_ntstatus(r.out.result);
2867 }
2868
2869 NTSTATUS rpccli_spoolss_ReplyClosePrinter(struct rpc_pipe_client *cli,
2870 TALLOC_CTX *mem_ctx,
2871 struct policy_handle *handle /* [in,out] [ref] */,
2872 WERROR *werror)
2873 {
2874 struct spoolss_ReplyClosePrinter r;
2875 NTSTATUS status;
2876
2877 /* In parameters */
2878 r.in.handle = handle;
2879
2880 if (DEBUGLEVEL >= 10) {
2881 NDR_PRINT_IN_DEBUG(spoolss_ReplyClosePrinter, &r);
2882 }
2883
2884 status = cli->dispatch(cli,
2885 mem_ctx,
2886 &ndr_table_spoolss,
2887 NDR_SPOOLSS_REPLYCLOSEPRINTER,
2888 &r);
2889
2890 if (!NT_STATUS_IS_OK(status)) {
2891 return status;
2892 }
2893
2894 if (DEBUGLEVEL >= 10) {
2895 NDR_PRINT_OUT_DEBUG(spoolss_ReplyClosePrinter, &r);
2896 }
2897
2898 if (NT_STATUS_IS_ERR(status)) {
2899 return status;
2900 }
2901
2902 /* Return variables */
2903 *handle = *r.out.handle;
2904
2905 /* Return result */
2906 if (werror) {
2907 *werror = r.out.result;
2908 }
2909
2910 return werror_to_ntstatus(r.out.result);
2911 }
2912
2913 NTSTATUS rpccli_spoolss_AddPortEx(struct rpc_pipe_client *cli,
2914 TALLOC_CTX *mem_ctx,
2915 WERROR *werror)
2916 {
2917 struct spoolss_AddPortEx r;
2918 NTSTATUS status;
2919
2920 /* In parameters */
2921
2922 if (DEBUGLEVEL >= 10) {
2923 NDR_PRINT_IN_DEBUG(spoolss_AddPortEx, &r);
2924 }
2925
2926 status = cli->dispatch(cli,
2927 mem_ctx,
2928 &ndr_table_spoolss,
2929 NDR_SPOOLSS_ADDPORTEX,
2930 &r);
2931
2932 if (!NT_STATUS_IS_OK(status)) {
2933 return status;
2934 }
2935
2936 if (DEBUGLEVEL >= 10) {
2937 NDR_PRINT_OUT_DEBUG(spoolss_AddPortEx, &r);
2938 }
2939
2940 if (NT_STATUS_IS_ERR(status)) {
2941 return status;
2942 }
2943
2944 /* Return variables */
2945
2946 /* Return result */
2947 if (werror) {
2948 *werror = r.out.result;
2949 }
2950
2951 return werror_to_ntstatus(r.out.result);
2952 }
2953
2954 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotification(struct rpc_pipe_client *cli,
2955 TALLOC_CTX *mem_ctx,
2956 WERROR *werror)
2957 {
2958 struct spoolss_RouterFindFirstPrinterChangeNotification r;
2959 NTSTATUS status;
2960
2961 /* In parameters */
2962
2963 if (DEBUGLEVEL >= 10) {
2964 NDR_PRINT_IN_DEBUG(spoolss_RouterFindFirstPrinterChangeNotification, &r);
2965 }
2966
2967 status = cli->dispatch(cli,
2968 mem_ctx,
2969 &ndr_table_spoolss,
2970 NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION,
2971 &r);
2972
2973 if (!NT_STATUS_IS_OK(status)) {
2974 return status;
2975 }
2976
2977 if (DEBUGLEVEL >= 10) {
2978 NDR_PRINT_OUT_DEBUG(spoolss_RouterFindFirstPrinterChangeNotification, &r);
2979 }
2980
2981 if (NT_STATUS_IS_ERR(status)) {
2982 return status;
2983 }
2984
2985 /* Return variables */
2986
2987 /* Return result */
2988 if (werror) {
2989 *werror = r.out.result;
2990 }
2991
2992 return werror_to_ntstatus(r.out.result);
2993 }
2994
2995 NTSTATUS rpccli_spoolss_SpoolerInit(struct rpc_pipe_client *cli,
2996 TALLOC_CTX *mem_ctx,
2997 WERROR *werror)
2998 {
2999 struct spoolss_SpoolerInit r;
3000 NTSTATUS status;
3001
3002 /* In parameters */
3003
3004 if (DEBUGLEVEL >= 10) {
3005 NDR_PRINT_IN_DEBUG(spoolss_SpoolerInit, &r);
3006 }
3007
3008 status = cli->dispatch(cli,
3009 mem_ctx,
3010 &ndr_table_spoolss,
3011 NDR_SPOOLSS_SPOOLERINIT,
3012 &r);
3013
3014 if (!NT_STATUS_IS_OK(status)) {
3015 return status;
3016 }
3017
3018 if (DEBUGLEVEL >= 10) {
3019 NDR_PRINT_OUT_DEBUG(spoolss_SpoolerInit, &r);
3020 }
3021
3022 if (NT_STATUS_IS_ERR(status)) {
3023 return status;
3024 }
3025
3026 /* Return variables */
3027
3028 /* Return result */
3029 if (werror) {
3030 *werror = r.out.result;
3031 }
3032
3033 return werror_to_ntstatus(r.out.result);
3034 }
3035
3036 NTSTATUS rpccli_spoolss_ResetPrinterEx(struct rpc_pipe_client *cli,
3037 TALLOC_CTX *mem_ctx,
3038 WERROR *werror)
3039 {
3040 struct spoolss_ResetPrinterEx r;
3041 NTSTATUS status;
3042
3043 /* In parameters */
3044
3045 if (DEBUGLEVEL >= 10) {
3046 NDR_PRINT_IN_DEBUG(spoolss_ResetPrinterEx, &r);
3047 }
3048
3049 status = cli->dispatch(cli,
3050 mem_ctx,
3051 &ndr_table_spoolss,
3052 NDR_SPOOLSS_RESETPRINTEREX,
3053 &r);
3054
3055 if (!NT_STATUS_IS_OK(status)) {
3056 return status;
3057 }
3058
3059 if (DEBUGLEVEL >= 10) {
3060 NDR_PRINT_OUT_DEBUG(spoolss_ResetPrinterEx, &r);
3061 }
3062
3063 if (NT_STATUS_IS_ERR(status)) {
3064 return status;
3065 }
3066
3067 /* Return variables */
3068
3069 /* Return result */
3070 if (werror) {
3071 *werror = r.out.result;
3072 }
3073
3074 return werror_to_ntstatus(r.out.result);
3075 }
3076
3077 NTSTATUS rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct rpc_pipe_client *cli,
3078 TALLOC_CTX *mem_ctx,
3079 struct policy_handle *handle /* [in] [ref] */,
3080 uint32_t flags /* [in] */,
3081 uint32_t options /* [in] */,
3082 const char *local_machine /* [in] [unique,charset(UTF16)] */,
3083 uint32_t printer_local /* [in] */,
3084 struct spoolss_NotifyOption *notify_options /* [in] [unique] */,
3085 WERROR *werror)
3086 {
3087 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx r;
3088 NTSTATUS status;
3089
3090 /* In parameters */
3091 r.in.handle = handle;
3092 r.in.flags = flags;
3093 r.in.options = options;
3094 r.in.local_machine = local_machine;
3095 r.in.printer_local = printer_local;
3096 r.in.notify_options = notify_options;
3097
3098 if (DEBUGLEVEL >= 10) {
3099 NDR_PRINT_IN_DEBUG(spoolss_RemoteFindFirstPrinterChangeNotifyEx, &r);
3100 }
3101
3102 status = cli->dispatch(cli,
3103 mem_ctx,
3104 &ndr_table_spoolss,
3105 NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX,
3106 &r);
3107
3108 if (!NT_STATUS_IS_OK(status)) {
3109 return status;
3110 }
3111
3112 if (DEBUGLEVEL >= 10) {
3113 NDR_PRINT_OUT_DEBUG(spoolss_RemoteFindFirstPrinterChangeNotifyEx, &r);
3114 }
3115
3116 if (NT_STATUS_IS_ERR(status)) {
3117 return status;
3118 }
3119
3120 /* Return variables */
3121
3122 /* Return result */
3123 if (werror) {
3124 *werror = r.out.result;
3125 }
3126
3127 return werror_to_ntstatus(r.out.result);
3128 }
3129
3130 NTSTATUS rpccli_spoolss_RouterReplyPrinterEx(struct rpc_pipe_client *cli,
3131 TALLOC_CTX *mem_ctx,
3132 struct policy_handle *handle /* [in] [ref] */,
3133 uint32_t color /* [in] */,
3134 uint32_t flags /* [in] */,
3135 uint32_t *reply_result /* [out] [ref] */,
3136 uint32_t reply_type /* [in] */,
3137 union spoolss_ReplyPrinterInfo info /* [in] [switch_is(reply_type)] */,
3138 WERROR *werror)
3139 {
3140 struct spoolss_RouterReplyPrinterEx r;
3141 NTSTATUS status;
3142
3143 /* In parameters */
3144 r.in.handle = handle;
3145 r.in.color = color;
3146 r.in.flags = flags;
3147 r.in.reply_type = reply_type;
3148 r.in.info = info;
3149
3150 if (DEBUGLEVEL >= 10) {
3151 NDR_PRINT_IN_DEBUG(spoolss_RouterReplyPrinterEx, &r);
3152 }
3153
3154 status = cli->dispatch(cli,
3155 mem_ctx,
3156 &ndr_table_spoolss,
3157 NDR_SPOOLSS_ROUTERREPLYPRINTEREX,
3158 &r);
3159
3160 if (!NT_STATUS_IS_OK(status)) {
3161 return status;
3162 }
3163
3164 if (DEBUGLEVEL >= 10) {
3165 NDR_PRINT_OUT_DEBUG(spoolss_RouterReplyPrinterEx, &r);
3166 }
3167
3168 if (NT_STATUS_IS_ERR(status)) {
3169 return status;
3170 }
3171
3172 /* Return variables */
3173 *reply_result = *r.out.reply_result;
3174
3175 /* Return result */
3176 if (werror) {
3177 *werror = r.out.result;
3178 }
3179
3180 return werror_to_ntstatus(r.out.result);
3181 }
3182
3183 NTSTATUS rpccli_spoolss_RouterRefreshPrinterChangeNotify(struct rpc_pipe_client *cli,
3184 TALLOC_CTX *mem_ctx,
3185 struct policy_handle *handle /* [in] [ref] */,
3186 uint32_t change_low /* [in] */,
3187 struct spoolss_NotifyOption *options /* [in] [unique] */,
3188 struct spoolss_NotifyInfo **info /* [out] [ref] */,
3189 WERROR *werror)
3190 {
3191 struct spoolss_RouterRefreshPrinterChangeNotify r;
3192 NTSTATUS status;
3193
3194 /* In parameters */
3195 r.in.handle = handle;
3196 r.in.change_low = change_low;
3197 r.in.options = options;
3198
3199 if (DEBUGLEVEL >= 10) {
3200 NDR_PRINT_IN_DEBUG(spoolss_RouterRefreshPrinterChangeNotify, &r);
3201 }
3202
3203 status = cli->dispatch(cli,
3204 mem_ctx,
3205 &ndr_table_spoolss,
3206 NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFY,
3207 &r);
3208
3209 if (!NT_STATUS_IS_OK(status)) {
3210 return status;
3211 }
3212
3213 if (DEBUGLEVEL >= 10) {
3214 NDR_PRINT_OUT_DEBUG(spoolss_RouterRefreshPrinterChangeNotify, &r);
3215 }
3216
3217 if (NT_STATUS_IS_ERR(status)) {
3218 return status;
3219 }
3220
3221 /* Return variables */
3222 *info = *r.out.info;
3223
3224 /* Return result */
3225 if (werror) {
3226 *werror = r.out.result;
3227 }
3228
3229 return werror_to_ntstatus(r.out.result);
3230 }
3231
3232 NTSTATUS rpccli_spoolss_44(struct rpc_pipe_client *cli,
3233 TALLOC_CTX *mem_ctx,
3234 WERROR *werror)
3235 {
3236 struct spoolss_44 r;
3237 NTSTATUS status;
3238
3239 /* In parameters */
3240
3241 if (DEBUGLEVEL >= 10) {
3242 NDR_PRINT_IN_DEBUG(spoolss_44, &r);
3243 }
3244
3245 status = cli->dispatch(cli,
3246 mem_ctx,
3247 &ndr_table_spoolss,
3248 NDR_SPOOLSS_44,
3249 &r);
3250
3251 if (!NT_STATUS_IS_OK(status)) {
3252 return status;
3253 }
3254
3255 if (DEBUGLEVEL >= 10) {
3256 NDR_PRINT_OUT_DEBUG(spoolss_44, &r);
3257 }
3258
3259 if (NT_STATUS_IS_ERR(status)) {
3260 return status;
3261 }
3262
3263 /* Return variables */
3264
3265 /* Return result */
3266 if (werror) {
3267 *werror = r.out.result;
3268 }
3269
3270 return werror_to_ntstatus(r.out.result);
3271 }
3272
3273 NTSTATUS rpccli_spoolss_OpenPrinterEx(struct rpc_pipe_client *cli,
3274 TALLOC_CTX *mem_ctx,
3275 const char *printername /* [in] [unique,charset(UTF16)] */,
3276 const char *datatype /* [in] [unique,charset(UTF16)] */,
3277 struct spoolss_DevmodeContainer devmode_ctr /* [in] */,
3278 uint32_t access_mask /* [in] */,
3279 uint32_t level /* [in] */,
3280 union spoolss_UserLevel userlevel /* [in] [switch_is(level)] */,
3281 struct policy_handle *handle /* [out] [ref] */,
3282 WERROR *werror)
3283 {
3284 struct spoolss_OpenPrinterEx r;
3285 NTSTATUS status;
3286
3287 /* In parameters */
3288 r.in.printername = printername;
3289 r.in.datatype = datatype;
3290 r.in.devmode_ctr = devmode_ctr;
3291 r.in.access_mask = access_mask;
3292 r.in.level = level;
3293 r.in.userlevel = userlevel;
3294
3295 if (DEBUGLEVEL >= 10) {
3296 NDR_PRINT_IN_DEBUG(spoolss_OpenPrinterEx, &r);
3297 }
3298
3299 status = cli->dispatch(cli,
3300 mem_ctx,
3301 &ndr_table_spoolss,
3302 NDR_SPOOLSS_OPENPRINTEREX,
3303 &r);
3304
3305 if (!NT_STATUS_IS_OK(status)) {
3306 return status;
3307 }
3308
3309 if (DEBUGLEVEL >= 10) {
3310 NDR_PRINT_OUT_DEBUG(spoolss_OpenPrinterEx, &r);
3311 }
3312
3313 if (NT_STATUS_IS_ERR(status)) {
3314 return status;
3315 }
3316
3317 /* Return variables */
3318 *handle = *r.out.handle;
3319
3320 /* Return result */
3321 if (werror) {
3322 *werror = r.out.result;
3323 }
3324
3325 return werror_to_ntstatus(r.out.result);
3326 }
3327
3328 NTSTATUS rpccli_spoolss_AddPrinterEx(struct rpc_pipe_client *cli,
3329 TALLOC_CTX *mem_ctx,
3330 const char *server /* [in] [unique,charset(UTF16)] */,
3331 struct spoolss_SetPrinterInfoCtr *info_ctr /* [in] [ref] */,
3332 struct spoolss_DevmodeContainer *devmode_ctr /* [in] [ref] */,
3333 struct sec_desc_buf *secdesc_ctr /* [in] [ref] */,
3334 struct spoolss_UserLevelCtr *userlevel_ctr /* [in] [ref] */,
3335 struct policy_handle *handle /* [out] [ref] */,
3336 WERROR *werror)
3337 {
3338 struct spoolss_AddPrinterEx r;
3339 NTSTATUS status;
3340
3341 /* In parameters */
3342 r.in.server = server;
3343 r.in.info_ctr = info_ctr;
3344 r.in.devmode_ctr = devmode_ctr;
3345 r.in.secdesc_ctr = secdesc_ctr;
3346 r.in.userlevel_ctr = userlevel_ctr;
3347
3348 if (DEBUGLEVEL >= 10) {
3349 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterEx, &r);
3350 }
3351
3352 status = cli->dispatch(cli,
3353 mem_ctx,
3354 &ndr_table_spoolss,
3355 NDR_SPOOLSS_ADDPRINTEREX,
3356 &r);
3357
3358 if (!NT_STATUS_IS_OK(status)) {
3359 return status;
3360 }
3361
3362 if (DEBUGLEVEL >= 10) {
3363 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterEx, &r);
3364 }
3365
3366 if (NT_STATUS_IS_ERR(status)) {
3367 return status;
3368 }
3369
3370 /* Return variables */
3371 *handle = *r.out.handle;
3372
3373 /* Return result */
3374 if (werror) {
3375 *werror = r.out.result;
3376 }
3377
3378 return werror_to_ntstatus(r.out.result);
3379 }
3380
3381 NTSTATUS rpccli_spoolss_47(struct rpc_pipe_client *cli,
3382 TALLOC_CTX *mem_ctx,
3383 WERROR *werror)
3384 {
3385 struct spoolss_47 r;
3386 NTSTATUS status;
3387
3388 /* In parameters */
3389
3390 if (DEBUGLEVEL >= 10) {
3391 NDR_PRINT_IN_DEBUG(spoolss_47, &r);
3392 }
3393
3394 status = cli->dispatch(cli,
3395 mem_ctx,
3396 &ndr_table_spoolss,
3397 NDR_SPOOLSS_47,
3398 &r);
3399
3400 if (!NT_STATUS_IS_OK(status)) {
3401 return status;
3402 }
3403
3404 if (DEBUGLEVEL >= 10) {
3405 NDR_PRINT_OUT_DEBUG(spoolss_47, &r);
3406 }
3407
3408 if (NT_STATUS_IS_ERR(status)) {
3409 return status;
3410 }
3411
3412 /* Return variables */
3413
3414 /* Return result */
3415 if (werror) {
3416 *werror = r.out.result;
3417 }
3418
3419 return werror_to_ntstatus(r.out.result);
3420 }
3421
3422 NTSTATUS rpccli_spoolss_EnumPrinterData(struct rpc_pipe_client *cli,
3423 TALLOC_CTX *mem_ctx,
3424 struct policy_handle *handle /* [in] [ref] */,
3425 uint32_t enum_index /* [in] */,
3426 const char *value_name /* [out] [charset(UTF16),size_is(value_offered/2)] */,
3427 uint32_t value_offered /* [in] */,
3428 uint32_t *value_needed /* [out] [ref] */,
3429 enum winreg_Type *type /* [out] [ref] */,
3430 uint8_t *data /* [out] [ref,flag(LIBNDR_PRINT_ARRAY_HEX),size_is(data_offered)] */,
3431 uint32_t data_offered /* [in] */,
3432 uint32_t *data_needed /* [out] [ref] */,
3433 WERROR *werror)
3434 {
3435 struct spoolss_EnumPrinterData r;
3436 NTSTATUS status;
3437
3438 /* In parameters */
3439 r.in.handle = handle;
3440 r.in.enum_index = enum_index;
3441 r.in.value_offered = value_offered;
3442 r.in.data_offered = data_offered;
3443
3444 if (DEBUGLEVEL >= 10) {
3445 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterData, &r);
3446 }
3447
3448 status = cli->dispatch(cli,
3449 mem_ctx,
3450 &ndr_table_spoolss,
3451 NDR_SPOOLSS_ENUMPRINTERDATA,
3452 &r);
3453
3454 if (!NT_STATUS_IS_OK(status)) {
3455 return status;
3456 }
3457
3458 if (DEBUGLEVEL >= 10) {
3459 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterData, &r);
3460 }
3461
3462 if (NT_STATUS_IS_ERR(status)) {
3463 return status;
3464 }
3465
3466 /* Return variables */
3467 memcpy(CONST_DISCARD(char *, value_name), r.out.value_name, r.in.value_offered / 2 * sizeof(*value_name));
3468 *value_needed = *r.out.value_needed;
3469 *type = *r.out.type;
3470 memcpy(data, r.out.data, r.in.data_offered * sizeof(*data));
3471 *data_needed = *r.out.data_needed;
3472
3473 /* Return result */
3474 if (werror) {
3475 *werror = r.out.result;
3476 }
3477
3478 return werror_to_ntstatus(r.out.result);
3479 }
3480
3481 NTSTATUS rpccli_spoolss_DeletePrinterData(struct rpc_pipe_client *cli,
3482 TALLOC_CTX *mem_ctx,
3483 struct policy_handle *handle /* [in] [ref] */,
3484 const char *value_name /* [in] [charset(UTF16)] */,
3485 WERROR *werror)
3486 {
3487 struct spoolss_DeletePrinterData r;
3488 NTSTATUS status;
3489
3490 /* In parameters */
3491 r.in.handle = handle;
3492 r.in.value_name = value_name;
3493
3494 if (DEBUGLEVEL >= 10) {
3495 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterData, &r);
3496 }
3497
3498 status = cli->dispatch(cli,
3499 mem_ctx,
3500 &ndr_table_spoolss,
3501 NDR_SPOOLSS_DELETEPRINTERDATA,
3502 &r);
3503
3504 if (!NT_STATUS_IS_OK(status)) {
3505 return status;
3506 }
3507
3508 if (DEBUGLEVEL >= 10) {
3509 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterData, &r);
3510 }
3511
3512 if (NT_STATUS_IS_ERR(status)) {
3513 return status;
3514 }
3515
3516 /* Return variables */
3517
3518 /* Return result */
3519 if (werror) {
3520 *werror = r.out.result;
3521 }
3522
3523 return werror_to_ntstatus(r.out.result);
3524 }
3525
3526 NTSTATUS rpccli_spoolss_4a(struct rpc_pipe_client *cli,
3527 TALLOC_CTX *mem_ctx,
3528 WERROR *werror)
3529 {
3530 struct spoolss_4a r;
3531 NTSTATUS status;
3532
3533 /* In parameters */
3534
3535 if (DEBUGLEVEL >= 10) {
3536 NDR_PRINT_IN_DEBUG(spoolss_4a, &r);
3537 }
3538
3539 status = cli->dispatch(cli,
3540 mem_ctx,
3541 &ndr_table_spoolss,
3542 NDR_SPOOLSS_4A,
3543 &r);
3544
3545 if (!NT_STATUS_IS_OK(status)) {
3546 return status;
3547 }
3548
3549 if (DEBUGLEVEL >= 10) {
3550 NDR_PRINT_OUT_DEBUG(spoolss_4a, &r);
3551 }
3552
3553 if (NT_STATUS_IS_ERR(status)) {
3554 return status;
3555 }
3556
3557 /* Return variables */
3558
3559 /* Return result */
3560 if (werror) {
3561 *werror = r.out.result;
3562 }
3563
3564 return werror_to_ntstatus(r.out.result);
3565 }
3566
3567 NTSTATUS rpccli_spoolss_4b(struct rpc_pipe_client *cli,
3568 TALLOC_CTX *mem_ctx,
3569 WERROR *werror)
3570 {
3571 struct spoolss_4b r;
3572 NTSTATUS status;
3573
3574 /* In parameters */
3575
3576 if (DEBUGLEVEL >= 10) {
3577 NDR_PRINT_IN_DEBUG(spoolss_4b, &r);
3578 }
3579
3580 status = cli->dispatch(cli,
3581 mem_ctx,
3582 &ndr_table_spoolss,
3583 NDR_SPOOLSS_4B,
3584 &r);
3585
3586 if (!NT_STATUS_IS_OK(status)) {
3587 return status;
3588 }
3589
3590 if (DEBUGLEVEL >= 10) {
3591 NDR_PRINT_OUT_DEBUG(spoolss_4b, &r);
3592 }
3593
3594 if (NT_STATUS_IS_ERR(status)) {
3595 return status;
3596 }
3597
3598 /* Return variables */
3599
3600 /* Return result */
3601 if (werror) {
3602 *werror = r.out.result;
3603 }
3604
3605 return werror_to_ntstatus(r.out.result);
3606 }
3607
3608 NTSTATUS rpccli_spoolss_4c(struct rpc_pipe_client *cli,
3609 TALLOC_CTX *mem_ctx,
3610 WERROR *werror)
3611 {
3612 struct spoolss_4c r;
3613 NTSTATUS status;
3614
3615 /* In parameters */
3616
3617 if (DEBUGLEVEL >= 10) {
3618 NDR_PRINT_IN_DEBUG(spoolss_4c, &r);
3619 }
3620
3621 status = cli->dispatch(cli,
3622 mem_ctx,
3623 &ndr_table_spoolss,
3624 NDR_SPOOLSS_4C,
3625 &r);
3626
3627 if (!NT_STATUS_IS_OK(status)) {
3628 return status;
3629 }
3630
3631 if (DEBUGLEVEL >= 10) {
3632 NDR_PRINT_OUT_DEBUG(spoolss_4c, &r);
3633 }
3634
3635 if (NT_STATUS_IS_ERR(status)) {
3636 return status;
3637 }
3638
3639 /* Return variables */
3640
3641 /* Return result */
3642 if (werror) {
3643 *werror = r.out.result;
3644 }
3645
3646 return werror_to_ntstatus(r.out.result);
3647 }
3648
3649 NTSTATUS rpccli_spoolss_SetPrinterDataEx(struct rpc_pipe_client *cli,
3650 TALLOC_CTX *mem_ctx,
3651 struct policy_handle *handle /* [in] [ref] */,
3652 const char *key_name /* [in] [charset(UTF16)] */,
3653 const char *value_name /* [in] [charset(UTF16)] */,
3654 enum winreg_Type type /* [in] */,
3655 uint8_t *buffer /* [in] [ref,size_is(offered)] */,
3656 uint32_t offered /* [in] */,
3657 WERROR *werror)
3658 {
3659 struct spoolss_SetPrinterDataEx r;
3660 NTSTATUS status;
3661
3662 /* In parameters */
3663 r.in.handle = handle;
3664 r.in.key_name = key_name;
3665 r.in.value_name = value_name;
3666 r.in.type = type;
3667 r.in.buffer = buffer;
3668 r.in.offered = offered;
3669
3670 if (DEBUGLEVEL >= 10) {
3671 NDR_PRINT_IN_DEBUG(spoolss_SetPrinterDataEx, &r);
3672 }
3673
3674 status = cli->dispatch(cli,
3675 mem_ctx,
3676 &ndr_table_spoolss,
3677 NDR_SPOOLSS_SETPRINTERDATAEX,
3678 &r);
3679
3680 if (!NT_STATUS_IS_OK(status)) {
3681 return status;
3682 }
3683
3684 if (DEBUGLEVEL >= 10) {
3685 NDR_PRINT_OUT_DEBUG(spoolss_SetPrinterDataEx, &r);
3686 }
3687
3688 if (NT_STATUS_IS_ERR(status)) {
3689 return status;
3690 }
3691
3692 /* Return variables */
3693
3694 /* Return result */
3695 if (werror) {
3696 *werror = r.out.result;
3697 }
3698
3699 return werror_to_ntstatus(r.out.result);
3700 }
3701
3702 NTSTATUS rpccli_spoolss_GetPrinterDataEx(struct rpc_pipe_client *cli,
3703 TALLOC_CTX *mem_ctx,
3704 struct policy_handle *handle /* [in] [ref] */,
3705 const char *key_name /* [in] [charset(UTF16)] */,
3706 const char *value_name /* [in] [charset(UTF16)] */,
3707 enum winreg_Type *type /* [out] [ref] */,
3708 uint8_t *buffer /* [out] [ref,size_is(offered)] */,
3709 uint32_t offered /* [in] */,
3710 uint32_t *needed /* [out] [ref] */,
3711 WERROR *werror)
3712 {
3713 struct spoolss_GetPrinterDataEx r;
3714 NTSTATUS status;
3715
3716 /* In parameters */
3717 r.in.handle = handle;
3718 r.in.key_name = key_name;
3719 r.in.value_name = value_name;
3720 r.in.offered = offered;
3721
3722 if (DEBUGLEVEL >= 10) {
3723 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDataEx, &r);
3724 }
3725
3726 status = cli->dispatch(cli,
3727 mem_ctx,
3728 &ndr_table_spoolss,
3729 NDR_SPOOLSS_GETPRINTERDATAEX,
3730 &r);
3731
3732 if (!NT_STATUS_IS_OK(status)) {
3733 return status;
3734 }
3735
3736 if (DEBUGLEVEL >= 10) {
3737 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDataEx, &r);
3738 }
3739
3740 if (NT_STATUS_IS_ERR(status)) {
3741 return status;
3742 }
3743
3744 /* Return variables */
3745 *type = *r.out.type;
3746 memcpy(buffer, r.out.buffer, r.in.offered * sizeof(*buffer));
3747 *needed = *r.out.needed;
3748
3749 /* Return result */
3750 if (werror) {
3751 *werror = r.out.result;
3752 }
3753
3754 return werror_to_ntstatus(r.out.result);
3755 }
3756
3757 NTSTATUS rpccli_spoolss_EnumPrinterDataEx(struct rpc_pipe_client *cli,
3758 TALLOC_CTX *mem_ctx,
3759 struct policy_handle *handle /* [in] [ref] */,
3760 const char *key_name /* [in] [charset(UTF16)] */,
3761 uint32_t offered /* [in] */,
3762 uint32_t *count /* [out] [ref] */,
3763 struct spoolss_PrinterEnumValues **info /* [out] [ref,size_is(,*count)] */,
3764 uint32_t *needed /* [out] [ref] */,
3765 WERROR *werror)
3766 {
3767 struct spoolss_EnumPrinterDataEx r;
3768 NTSTATUS status;
3769
3770 /* In parameters */
3771 r.in.handle = handle;
3772 r.in.key_name = key_name;
3773 r.in.offered = offered;
3774
3775 if (DEBUGLEVEL >= 10) {
3776 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterDataEx, &r);
3777 }
3778
3779 status = cli->dispatch(cli,
3780 mem_ctx,
3781 &ndr_table_spoolss,
3782 NDR_SPOOLSS_ENUMPRINTERDATAEX,
3783 &r);
3784
3785 if (!NT_STATUS_IS_OK(status)) {
3786 return status;
3787 }
3788
3789 if (DEBUGLEVEL >= 10) {
3790 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterDataEx, &r);
3791 }
3792
3793 if (NT_STATUS_IS_ERR(status)) {
3794 return status;
3795 }
3796
3797 /* Return variables */
3798 *count = *r.out.count;
3799 *info = *r.out.info;
3800 *needed = *r.out.needed;
3801
3802 /* Return result */
3803 if (werror) {
3804 *werror = r.out.result;
3805 }
3806
3807 return werror_to_ntstatus(r.out.result);
3808 }
3809
3810 NTSTATUS rpccli_spoolss_EnumPrinterKey(struct rpc_pipe_client *cli,
3811 TALLOC_CTX *mem_ctx,
3812 struct policy_handle *handle /* [in] [ref] */,
3813 const char *key_name /* [in] [charset(UTF16)] */,
3814 const char ** *key_buffer /* [out] [subcontext_size(offered),ref,subcontext(0),flag(LIBNDR_FLAG_STR_NULLTERM)] */,
3815 uint32_t offered /* [in] */,
3816 uint32_t *needed /* [out] [ref] */,
3817 WERROR *werror)
3818 {
3819 struct spoolss_EnumPrinterKey r;
3820 NTSTATUS status;
3821
3822 /* In parameters */
3823 r.in.handle = handle;
3824 r.in.key_name = key_name;
3825 r.in.offered = offered;
3826
3827 if (DEBUGLEVEL >= 10) {
3828 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterKey, &r);
3829 }
3830
3831 status = cli->dispatch(cli,
3832 mem_ctx,
3833 &ndr_table_spoolss,
3834 NDR_SPOOLSS_ENUMPRINTERKEY,
3835 &r);
3836
3837 if (!NT_STATUS_IS_OK(status)) {
3838 return status;
3839 }
3840
3841 if (DEBUGLEVEL >= 10) {
3842 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterKey, &r);
3843 }
3844
3845 if (NT_STATUS_IS_ERR(status)) {
3846 return status;
3847 }
3848
3849 /* Return variables */
3850 *key_buffer = *r.out.key_buffer;
3851 *needed = *r.out.needed;
3852
3853 /* Return result */
3854 if (werror) {
3855 *werror = r.out.result;
3856 }
3857
3858 return werror_to_ntstatus(r.out.result);
3859 }
3860
3861 NTSTATUS rpccli_spoolss_DeletePrinterDataEx(struct rpc_pipe_client *cli,
3862 TALLOC_CTX *mem_ctx,
3863 struct policy_handle *handle /* [in] [ref] */,
3864 const char *key_name /* [in] [charset(UTF16)] */,
3865 const char *value_name /* [in] [charset(UTF16)] */,
3866 WERROR *werror)
3867 {
3868 struct spoolss_DeletePrinterDataEx r;
3869 NTSTATUS status;
3870
3871 /* In parameters */
3872 r.in.handle = handle;
3873 r.in.key_name = key_name;
3874 r.in.value_name = value_name;
3875
3876 if (DEBUGLEVEL >= 10) {
3877 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDataEx, &r);
3878 }
3879
3880 status = cli->dispatch(cli,
3881 mem_ctx,
3882 &ndr_table_spoolss,
3883 NDR_SPOOLSS_DELETEPRINTERDATAEX,
3884 &r);
3885
3886 if (!NT_STATUS_IS_OK(status)) {
3887 return status;
3888 }
3889
3890 if (DEBUGLEVEL >= 10) {
3891 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDataEx, &r);
3892 }
3893
3894 if (NT_STATUS_IS_ERR(status)) {
3895 return status;
3896 }
3897
3898 /* Return variables */
3899
3900 /* Return result */
3901 if (werror) {
3902 *werror = r.out.result;
3903 }
3904
3905 return werror_to_ntstatus(r.out.result);
3906 }
3907
3908 NTSTATUS rpccli_spoolss_DeletePrinterKey(struct rpc_pipe_client *cli,
3909 TALLOC_CTX *mem_ctx,
3910 struct policy_handle *handle /* [in] [ref] */,
3911 const char *key_name /* [in] [charset(UTF16)] */,
3912 WERROR *werror)
3913 {
3914 struct spoolss_DeletePrinterKey r;
3915 NTSTATUS status;
3916
3917 /* In parameters */
3918 r.in.handle = handle;
3919 r.in.key_name = key_name;
3920
3921 if (DEBUGLEVEL >= 10) {
3922 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterKey, &r);
3923 }
3924
3925 status = cli->dispatch(cli,
3926 mem_ctx,
3927 &ndr_table_spoolss,
3928 NDR_SPOOLSS_DELETEPRINTERKEY,
3929 &r);
3930
3931 if (!NT_STATUS_IS_OK(status)) {
3932 return status;
3933 }
3934
3935 if (DEBUGLEVEL >= 10) {
3936 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterKey, &r);
3937 }
3938
3939 if (NT_STATUS_IS_ERR(status)) {
3940 return status;
3941 }
3942
3943 /* Return variables */
3944
3945 /* Return result */
3946 if (werror) {
3947 *werror = r.out.result;
3948 }
3949
3950 return werror_to_ntstatus(r.out.result);
3951 }
3952
3953 NTSTATUS rpccli_spoolss_53(struct rpc_pipe_client *cli,
3954 TALLOC_CTX *mem_ctx,
3955 WERROR *werror)
3956 {
3957 struct spoolss_53 r;
3958 NTSTATUS status;
3959
3960 /* In parameters */
3961
3962 if (DEBUGLEVEL >= 10) {
3963 NDR_PRINT_IN_DEBUG(spoolss_53, &r);
3964 }
3965
3966 status = cli->dispatch(cli,
3967 mem_ctx,
3968 &ndr_table_spoolss,
3969 NDR_SPOOLSS_53,
3970 &r);
3971
3972 if (!NT_STATUS_IS_OK(status)) {
3973 return status;
3974 }
3975
3976 if (DEBUGLEVEL >= 10) {
3977 NDR_PRINT_OUT_DEBUG(spoolss_53, &r);
3978 }
3979
3980 if (NT_STATUS_IS_ERR(status)) {
3981 return status;
3982 }
3983
3984 /* Return variables */
3985
3986 /* Return result */
3987 if (werror) {
3988 *werror = r.out.result;
3989 }
3990
3991 return werror_to_ntstatus(r.out.result);
3992 }
3993
3994 NTSTATUS rpccli_spoolss_DeletePrinterDriverEx(struct rpc_pipe_client *cli,
3995 TALLOC_CTX *mem_ctx,
3996 const char *server /* [in] [unique,charset(UTF16)] */,
3997 const char *architecture /* [in] [charset(UTF16)] */,
3998 const char *driver /* [in] [charset(UTF16)] */,
3999 uint32_t delete_flags /* [in] */,
4000 uint32_t version /* [in] */,
4001 WERROR *werror)
4002 {
4003 struct spoolss_DeletePrinterDriverEx r;
4004 NTSTATUS status;
4005
4006 /* In parameters */
4007 r.in.server = server;
4008 r.in.architecture = architecture;
4009 r.in.driver = driver;
4010 r.in.delete_flags = delete_flags;
4011 r.in.version = version;
4012
4013 if (DEBUGLEVEL >= 10) {
4014 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDriverEx, &r);
4015 }
4016
4017 status = cli->dispatch(cli,
4018 mem_ctx,
4019 &ndr_table_spoolss,
4020 NDR_SPOOLSS_DELETEPRINTERDRIVEREX,
4021 &r);
4022
4023 if (!NT_STATUS_IS_OK(status)) {
4024 return status;
4025 }
4026
4027 if (DEBUGLEVEL >= 10) {
4028 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDriverEx, &r);
4029 }
4030
4031 if (NT_STATUS_IS_ERR(status)) {
4032 return status;
4033 }
4034
4035 /* Return variables */
4036
4037 /* Return result */
4038 if (werror) {
4039 *werror = r.out.result;
4040 }
4041
4042 return werror_to_ntstatus(r.out.result);
4043 }
4044
4045 NTSTATUS rpccli_spoolss_55(struct rpc_pipe_client *cli,
4046 TALLOC_CTX *mem_ctx,
4047 WERROR *werror)
4048 {
4049 struct spoolss_55 r;
4050 NTSTATUS status;
4051
4052 /* In parameters */
4053
4054 if (DEBUGLEVEL >= 10) {
4055 NDR_PRINT_IN_DEBUG(spoolss_55, &r);
4056 }
4057
4058 status = cli->dispatch(cli,
4059 mem_ctx,
4060 &ndr_table_spoolss,
4061 NDR_SPOOLSS_55,
4062 &r);
4063
4064 if (!NT_STATUS_IS_OK(status)) {
4065 return status;
4066 }
4067
4068 if (DEBUGLEVEL >= 10) {
4069 NDR_PRINT_OUT_DEBUG(spoolss_55, &r);
4070 }
4071
4072 if (NT_STATUS_IS_ERR(status)) {
4073 return status;
4074 }
4075
4076 /* Return variables */
4077
4078 /* Return result */
4079 if (werror) {
4080 *werror = r.out.result;
4081 }
4082
4083 return werror_to_ntstatus(r.out.result);
4084 }
4085
4086 NTSTATUS rpccli_spoolss_56(struct rpc_pipe_client *cli,
4087 TALLOC_CTX *mem_ctx,
4088 WERROR *werror)
4089 {
4090 struct spoolss_56 r;
4091 NTSTATUS status;
4092
4093 /* In parameters */
4094
4095 if (DEBUGLEVEL >= 10) {
4096 NDR_PRINT_IN_DEBUG(spoolss_56, &r);
4097 }
4098
4099 status = cli->dispatch(cli,
4100 mem_ctx,
4101 &ndr_table_spoolss,
4102 NDR_SPOOLSS_56,
4103 &r);
4104
4105 if (!NT_STATUS_IS_OK(status)) {
4106 return status;
4107 }
4108
4109 if (DEBUGLEVEL >= 10) {
4110 NDR_PRINT_OUT_DEBUG(spoolss_56, &r);
4111 }
4112
4113 if (NT_STATUS_IS_ERR(status)) {
4114 return status;
4115 }
4116
4117 /* Return variables */
4118
4119 /* Return result */
4120 if (werror) {
4121 *werror = r.out.result;
4122 }
4123
4124 return werror_to_ntstatus(r.out.result);
4125 }
4126
4127 NTSTATUS rpccli_spoolss_57(struct rpc_pipe_client *cli,
4128 TALLOC_CTX *mem_ctx,
4129 WERROR *werror)
4130 {
4131 struct spoolss_57 r;
4132 NTSTATUS status;
4133
4134 /* In parameters */
4135
4136 if (DEBUGLEVEL >= 10) {
4137 NDR_PRINT_IN_DEBUG(spoolss_57, &r);
4138 }
4139
4140 status = cli->dispatch(cli,
4141 mem_ctx,
4142 &ndr_table_spoolss,
4143 NDR_SPOOLSS_57,
4144 &r);
4145
4146 if (!NT_STATUS_IS_OK(status)) {
4147 return status;
4148 }
4149
4150 if (DEBUGLEVEL >= 10) {
4151 NDR_PRINT_OUT_DEBUG(spoolss_57, &r);
4152 }
4153
4154 if (NT_STATUS_IS_ERR(status)) {
4155 return status;
4156 }
4157
4158 /* Return variables */
4159
4160 /* Return result */
4161 if (werror) {
4162 *werror = r.out.result;
4163 }
4164
4165 return werror_to_ntstatus(r.out.result);
4166 }
4167
4168 NTSTATUS rpccli_spoolss_XcvData(struct rpc_pipe_client *cli,
4169 TALLOC_CTX *mem_ctx,
4170 struct policy_handle *handle /* [in] [ref] */,
4171 const char *function_name /* [in] [charset(UTF16)] */,
4172 DATA_BLOB in_data /* [in] */,
4173 uint32_t _in_data_length /* [in] [value(r->in.in_data.length)] */,
4174 uint8_t *out_data /* [out] [ref,size_is(out_data_size)] */,
4175 uint32_t out_data_size /* [in] */,
4176 uint32_t *needed /* [out] [ref] */,
4177 uint32_t *status_code /* [in,out] [ref] */,
4178 WERROR *werror)
4179 {
4180 struct spoolss_XcvData r;
4181 NTSTATUS status;
4182
4183 /* In parameters */
4184 r.in.handle = handle;
4185 r.in.function_name = function_name;
4186 r.in.in_data = in_data;
4187 r.in._in_data_length = _in_data_length;
4188 r.in.out_data_size = out_data_size;
4189 r.in.status_code = status_code;
4190
4191 if (DEBUGLEVEL >= 10) {
4192 NDR_PRINT_IN_DEBUG(spoolss_XcvData, &r);
4193 }
4194
4195 status = cli->dispatch(cli,
4196 mem_ctx,
4197 &ndr_table_spoolss,
4198 NDR_SPOOLSS_XCVDATA,
4199 &r);
4200
4201 if (!NT_STATUS_IS_OK(status)) {
4202 return status;
4203 }
4204
4205 if (DEBUGLEVEL >= 10) {
4206 NDR_PRINT_OUT_DEBUG(spoolss_XcvData, &r);
4207 }
4208
4209 if (NT_STATUS_IS_ERR(status)) {
4210 return status;
4211 }
4212
4213 /* Return variables */
4214 memcpy(out_data, r.out.out_data, r.in.out_data_size * sizeof(*out_data));
4215 *needed = *r.out.needed;
4216 *status_code = *r.out.status_code;
4217
4218 /* Return result */
4219 if (werror) {
4220 *werror = r.out.result;
4221 }
4222
4223 return werror_to_ntstatus(r.out.result);
4224 }
4225
4226 NTSTATUS rpccli_spoolss_AddPrinterDriverEx(struct rpc_pipe_client *cli,
4227 TALLOC_CTX *mem_ctx,
4228 const char *servername /* [in] [unique,charset(UTF16)] */,
4229 struct spoolss_AddDriverInfoCtr *info_ctr /* [in] [ref] */,
4230 uint32_t flags /* [in] */,
4231 WERROR *werror)
4232 {
4233 struct spoolss_AddPrinterDriverEx r;
4234 NTSTATUS status;
4235
4236 /* In parameters */
4237 r.in.servername = servername;
4238 r.in.info_ctr = info_ctr;
4239 r.in.flags = flags;
4240
4241 if (DEBUGLEVEL >= 10) {
4242 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterDriverEx, &r);
4243 }
4244
4245 status = cli->dispatch(cli,
4246 mem_ctx,
4247 &ndr_table_spoolss,
4248 NDR_SPOOLSS_ADDPRINTERDRIVEREX,
4249 &r);
4250
4251 if (!NT_STATUS_IS_OK(status)) {
4252 return status;
4253 }
4254
4255 if (DEBUGLEVEL >= 10) {
4256 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterDriverEx, &r);
4257 }
4258
4259 if (NT_STATUS_IS_ERR(status)) {
4260 return status;
4261 }
4262
4263 /* Return variables */
4264
4265 /* Return result */
4266 if (werror) {
4267 *werror = r.out.result;
4268 }
4269
4270 return werror_to_ntstatus(r.out.result);
4271 }
4272
4273 NTSTATUS rpccli_spoolss_5a(struct rpc_pipe_client *cli,
4274 TALLOC_CTX *mem_ctx,
4275 WERROR *werror)
4276 {
4277 struct spoolss_5a r;
4278 NTSTATUS status;
4279
4280 /* In parameters */
4281
4282 if (DEBUGLEVEL >= 10) {
4283 NDR_PRINT_IN_DEBUG(spoolss_5a, &r);
4284 }
4285
4286 status = cli->dispatch(cli,
4287 mem_ctx,
4288 &ndr_table_spoolss,
4289 NDR_SPOOLSS_5A,
4290 &r);
4291
4292 if (!NT_STATUS_IS_OK(status)) {
4293 return status;
4294 }
4295
4296 if (DEBUGLEVEL >= 10) {
4297 NDR_PRINT_OUT_DEBUG(spoolss_5a, &r);
4298 }
4299
4300 if (NT_STATUS_IS_ERR(status)) {
4301 return status;
4302 }
4303
4304 /* Return variables */
4305
4306 /* Return result */
4307 if (werror) {
4308 *werror = r.out.result;
4309 }
4310
4311 return werror_to_ntstatus(r.out.result);
4312 }
4313
4314 NTSTATUS rpccli_spoolss_5b(struct rpc_pipe_client *cli,
4315 TALLOC_CTX *mem_ctx,
4316 WERROR *werror)
4317 {
4318 struct spoolss_5b r;
4319 NTSTATUS status;
4320
4321 /* In parameters */
4322
4323 if (DEBUGLEVEL >= 10) {
4324 NDR_PRINT_IN_DEBUG(spoolss_5b, &r);
4325 }
4326
4327 status = cli->dispatch(cli,
4328 mem_ctx,
4329 &ndr_table_spoolss,
4330 NDR_SPOOLSS_5B,
4331 &r);
4332
4333 if (!NT_STATUS_IS_OK(status)) {
4334 return status;
4335 }
4336
4337 if (DEBUGLEVEL >= 10) {
4338 NDR_PRINT_OUT_DEBUG(spoolss_5b, &r);
4339 }
4340
4341 if (NT_STATUS_IS_ERR(status)) {
4342 return status;
4343 }
4344
4345 /* Return variables */
4346
4347 /* Return result */
4348 if (werror) {
4349 *werror = r.out.result;
4350 }
4351
4352 return werror_to_ntstatus(r.out.result);
4353 }
4354
4355 NTSTATUS rpccli_spoolss_5c(struct rpc_pipe_client *cli,
4356 TALLOC_CTX *mem_ctx,
4357 WERROR *werror)
4358 {
4359 struct spoolss_5c r;
4360 NTSTATUS status;
4361
4362 /* In parameters */
4363
4364 if (DEBUGLEVEL >= 10) {
4365 NDR_PRINT_IN_DEBUG(spoolss_5c, &r);
4366 }
4367
4368 status = cli->dispatch(cli,
4369 mem_ctx,
4370 &ndr_table_spoolss,
4371 NDR_SPOOLSS_5C,
4372 &r);
4373
4374 if (!NT_STATUS_IS_OK(status)) {
4375 return status;
4376 }
4377
4378 if (DEBUGLEVEL >= 10) {
4379 NDR_PRINT_OUT_DEBUG(spoolss_5c, &r);
4380 }
4381
4382 if (NT_STATUS_IS_ERR(status)) {
4383 return status;
4384 }
4385
4386 /* Return variables */
4387
4388 /* Return result */
4389 if (werror) {
4390 *werror = r.out.result;
4391 }
4392
4393 return werror_to_ntstatus(r.out.result);
4394 }
4395
4396 NTSTATUS rpccli_spoolss_5d(struct rpc_pipe_client *cli,
4397 TALLOC_CTX *mem_ctx,
4398 WERROR *werror)
4399 {
4400 struct spoolss_5d r;
4401 NTSTATUS status;
4402
4403 /* In parameters */
4404
4405 if (DEBUGLEVEL >= 10) {
4406 NDR_PRINT_IN_DEBUG(spoolss_5d, &r);
4407 }
4408
4409 status = cli->dispatch(cli,
4410 mem_ctx,
4411 &ndr_table_spoolss,
4412 NDR_SPOOLSS_5D,
4413 &r);
4414
4415 if (!NT_STATUS_IS_OK(status)) {
4416 return status;
4417 }
4418
4419 if (DEBUGLEVEL >= 10) {
4420 NDR_PRINT_OUT_DEBUG(spoolss_5d, &r);
4421 }
4422
4423 if (NT_STATUS_IS_ERR(status)) {
4424 return status;
4425 }
4426
4427 /* Return variables */
4428
4429 /* Return result */
4430 if (werror) {
4431 *werror = r.out.result;
4432 }
4433
4434 return werror_to_ntstatus(r.out.result);
4435 }
4436
4437 NTSTATUS rpccli_spoolss_5e(struct rpc_pipe_client *cli,
4438 TALLOC_CTX *mem_ctx,
4439 WERROR *werror)
4440 {
4441 struct spoolss_5e r;
4442 NTSTATUS status;
4443
4444 /* In parameters */
4445
4446 if (DEBUGLEVEL >= 10) {
4447 NDR_PRINT_IN_DEBUG(spoolss_5e, &r);
4448 }
4449
4450 status = cli->dispatch(cli,
4451 mem_ctx,
4452 &ndr_table_spoolss,
4453 NDR_SPOOLSS_5E,
4454 &r);
4455
4456 if (!NT_STATUS_IS_OK(status)) {
4457 return status;
4458 }
4459
4460 if (DEBUGLEVEL >= 10) {
4461 NDR_PRINT_OUT_DEBUG(spoolss_5e, &r);
4462 }
4463
4464 if (NT_STATUS_IS_ERR(status)) {
4465 return status;
4466 }
4467
4468 /* Return variables */
4469
4470 /* Return result */
4471 if (werror) {
4472 *werror = r.out.result;
4473 }
4474
4475 return werror_to_ntstatus(r.out.result);
4476 }
4477
4478 NTSTATUS rpccli_spoolss_5f(struct rpc_pipe_client *cli,
4479 TALLOC_CTX *mem_ctx,
4480 WERROR *werror)
4481 {
4482 struct spoolss_5f r;
4483 NTSTATUS status;
4484
4485 /* In parameters */
4486
4487 if (DEBUGLEVEL >= 10) {
4488 NDR_PRINT_IN_DEBUG(spoolss_5f, &r);
4489 }
4490
4491 status = cli->dispatch(cli,
4492 mem_ctx,
4493 &ndr_table_spoolss,
4494 NDR_SPOOLSS_5F,
4495 &r);
4496
4497 if (!NT_STATUS_IS_OK(status)) {
4498 return status;
4499 }
4500
4501 if (DEBUGLEVEL >= 10) {
4502 NDR_PRINT_OUT_DEBUG(spoolss_5f, &r);
4503 }
4504
4505 if (NT_STATUS_IS_ERR(status)) {
4506 return status;
4507 }
4508
4509 /* Return variables */
4510
4511 /* Return result */
4512 if (werror) {
4513 *werror = r.out.result;
4514 }
4515
4516 return werror_to_ntstatus(r.out.result);
4517 }
4518
reg import