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