s3: re-run make samba3-idl.
[samba.git] / librpc / gen_ndr / cli_spoolss.c
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                                      union spoolss_PrinterInfo *info /* [out] [unique,switch_is(level),size_is(count)] */,
17                                      uint32_t *needed /* [out] [ref] */,
18                                      uint32_t count /* [out]  */,
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         if (info && r.out.info) {
55                 memcpy(info, r.out.info, count * sizeof(*info));
56         }
57         *needed = *r.out.needed;
58         return NT_STATUS_NOT_SUPPORTED;
59
60         /* Return result */
61         if (werror) {
62                 *werror = r.out.result;
63         }
64
65         return werror_to_ntstatus(r.out.result);
66 }
67
68 NTSTATUS rpccli_spoolss_OpenPrinter(struct rpc_pipe_client *cli,
69                                     TALLOC_CTX *mem_ctx,
70                                     const char *printername /* [in] [unique,charset(UTF16)] */,
71                                     const char *datatype /* [in] [unique,charset(UTF16)] */,
72                                     struct spoolss_DevmodeContainer devmode_ctr /* [in]  */,
73                                     uint32_t access_mask /* [in]  */,
74                                     struct policy_handle *handle /* [out] [ref] */,
75                                     WERROR *werror)
76 {
77         struct spoolss_OpenPrinter r;
78         NTSTATUS status;
79
80         /* In parameters */
81         r.in.printername = printername;
82         r.in.datatype = datatype;
83         r.in.devmode_ctr = devmode_ctr;
84         r.in.access_mask = access_mask;
85
86         if (DEBUGLEVEL >= 10) {
87                 NDR_PRINT_IN_DEBUG(spoolss_OpenPrinter, &r);
88         }
89
90         status = cli->dispatch(cli,
91                                 mem_ctx,
92                                 &ndr_table_spoolss,
93                                 NDR_SPOOLSS_OPENPRINTER,
94                                 &r);
95
96         if (!NT_STATUS_IS_OK(status)) {
97                 return status;
98         }
99
100         if (DEBUGLEVEL >= 10) {
101                 NDR_PRINT_OUT_DEBUG(spoolss_OpenPrinter, &r);
102         }
103
104         if (NT_STATUS_IS_ERR(status)) {
105                 return status;
106         }
107
108         /* Return variables */
109         *handle = *r.out.handle;
110
111         /* Return result */
112         if (werror) {
113                 *werror = r.out.result;
114         }
115
116         return werror_to_ntstatus(r.out.result);
117 }
118
119 NTSTATUS rpccli_spoolss_SetJob(struct rpc_pipe_client *cli,
120                                TALLOC_CTX *mem_ctx,
121                                struct policy_handle *handle /* [in] [ref] */,
122                                uint32_t job_id /* [in]  */,
123                                struct spoolss_JobInfoContainer *ctr /* [in] [unique] */,
124                                enum spoolss_JobControl command /* [in]  */,
125                                WERROR *werror)
126 {
127         struct spoolss_SetJob r;
128         NTSTATUS status;
129
130         /* In parameters */
131         r.in.handle = handle;
132         r.in.job_id = job_id;
133         r.in.ctr = ctr;
134         r.in.command = command;
135
136         if (DEBUGLEVEL >= 10) {
137                 NDR_PRINT_IN_DEBUG(spoolss_SetJob, &r);
138         }
139
140         status = cli->dispatch(cli,
141                                 mem_ctx,
142                                 &ndr_table_spoolss,
143                                 NDR_SPOOLSS_SETJOB,
144                                 &r);
145
146         if (!NT_STATUS_IS_OK(status)) {
147                 return status;
148         }
149
150         if (DEBUGLEVEL >= 10) {
151                 NDR_PRINT_OUT_DEBUG(spoolss_SetJob, &r);
152         }
153
154         if (NT_STATUS_IS_ERR(status)) {
155                 return status;
156         }
157
158         /* Return variables */
159
160         /* Return result */
161         if (werror) {
162                 *werror = r.out.result;
163         }
164
165         return werror_to_ntstatus(r.out.result);
166 }
167
168 NTSTATUS rpccli_spoolss_GetJob(struct rpc_pipe_client *cli,
169                                TALLOC_CTX *mem_ctx,
170                                struct policy_handle *handle /* [in] [ref] */,
171                                uint32_t job_id /* [in]  */,
172                                uint32_t level /* [in]  */,
173                                DATA_BLOB *buffer /* [in] [unique] */,
174                                uint32_t offered /* [in]  */,
175                                union spoolss_JobInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
176                                uint32_t *needed /* [out] [ref] */,
177                                WERROR *werror)
178 {
179         struct spoolss_GetJob r;
180         NTSTATUS status;
181
182         /* In parameters */
183         r.in.handle = handle;
184         r.in.job_id = job_id;
185         r.in.level = level;
186         r.in.buffer = buffer;
187         r.in.offered = offered;
188
189         if (DEBUGLEVEL >= 10) {
190                 NDR_PRINT_IN_DEBUG(spoolss_GetJob, &r);
191         }
192
193         status = cli->dispatch(cli,
194                                 mem_ctx,
195                                 &ndr_table_spoolss,
196                                 NDR_SPOOLSS_GETJOB,
197                                 &r);
198
199         if (!NT_STATUS_IS_OK(status)) {
200                 return status;
201         }
202
203         if (DEBUGLEVEL >= 10) {
204                 NDR_PRINT_OUT_DEBUG(spoolss_GetJob, &r);
205         }
206
207         if (NT_STATUS_IS_ERR(status)) {
208                 return status;
209         }
210
211         /* Return variables */
212         if (info && r.out.info) {
213                 *info = *r.out.info;
214         }
215         *needed = *r.out.needed;
216
217         /* Return result */
218         if (werror) {
219                 *werror = r.out.result;
220         }
221
222         return werror_to_ntstatus(r.out.result);
223 }
224
225 NTSTATUS rpccli_spoolss_EnumJobs(struct rpc_pipe_client *cli,
226                                  TALLOC_CTX *mem_ctx,
227                                  struct policy_handle *handle /* [in] [ref] */,
228                                  uint32_t firstjob /* [in]  */,
229                                  uint32_t numjobs /* [in]  */,
230                                  uint32_t level /* [in]  */,
231                                  DATA_BLOB *buffer /* [in] [unique] */,
232                                  uint32_t offered /* [in]  */,
233                                  union spoolss_JobInfo *info /* [out] [unique,switch_is(level),size_is(count)] */,
234                                  uint32_t *needed /* [out] [ref] */,
235                                  uint32_t count /* [out]  */,
236                                  WERROR *werror)
237 {
238         struct spoolss_EnumJobs r;
239         NTSTATUS status;
240
241         /* In parameters */
242         r.in.handle = handle;
243         r.in.firstjob = firstjob;
244         r.in.numjobs = numjobs;
245         r.in.level = level;
246         r.in.buffer = buffer;
247         r.in.offered = offered;
248
249         if (DEBUGLEVEL >= 10) {
250                 NDR_PRINT_IN_DEBUG(spoolss_EnumJobs, &r);
251         }
252
253         status = cli->dispatch(cli,
254                                 mem_ctx,
255                                 &ndr_table_spoolss,
256                                 NDR_SPOOLSS_ENUMJOBS,
257                                 &r);
258
259         if (!NT_STATUS_IS_OK(status)) {
260                 return status;
261         }
262
263         if (DEBUGLEVEL >= 10) {
264                 NDR_PRINT_OUT_DEBUG(spoolss_EnumJobs, &r);
265         }
266
267         if (NT_STATUS_IS_ERR(status)) {
268                 return status;
269         }
270
271         /* Return variables */
272         if (info && r.out.info) {
273                 memcpy(info, r.out.info, count * sizeof(*info));
274         }
275         *needed = *r.out.needed;
276         return NT_STATUS_NOT_SUPPORTED;
277
278         /* Return result */
279         if (werror) {
280                 *werror = r.out.result;
281         }
282
283         return werror_to_ntstatus(r.out.result);
284 }
285
286 NTSTATUS rpccli_spoolss_AddPrinter(struct rpc_pipe_client *cli,
287                                    TALLOC_CTX *mem_ctx,
288                                    WERROR *werror)
289 {
290         struct spoolss_AddPrinter r;
291         NTSTATUS status;
292
293         /* In parameters */
294
295         if (DEBUGLEVEL >= 10) {
296                 NDR_PRINT_IN_DEBUG(spoolss_AddPrinter, &r);
297         }
298
299         status = cli->dispatch(cli,
300                                 mem_ctx,
301                                 &ndr_table_spoolss,
302                                 NDR_SPOOLSS_ADDPRINTER,
303                                 &r);
304
305         if (!NT_STATUS_IS_OK(status)) {
306                 return status;
307         }
308
309         if (DEBUGLEVEL >= 10) {
310                 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinter, &r);
311         }
312
313         if (NT_STATUS_IS_ERR(status)) {
314                 return status;
315         }
316
317         /* Return variables */
318
319         /* Return result */
320         if (werror) {
321                 *werror = r.out.result;
322         }
323
324         return werror_to_ntstatus(r.out.result);
325 }
326
327 NTSTATUS rpccli_spoolss_DeletePrinter(struct rpc_pipe_client *cli,
328                                       TALLOC_CTX *mem_ctx,
329                                       struct policy_handle *handle /* [in] [ref] */,
330                                       WERROR *werror)
331 {
332         struct spoolss_DeletePrinter r;
333         NTSTATUS status;
334
335         /* In parameters */
336         r.in.handle = handle;
337
338         if (DEBUGLEVEL >= 10) {
339                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinter, &r);
340         }
341
342         status = cli->dispatch(cli,
343                                 mem_ctx,
344                                 &ndr_table_spoolss,
345                                 NDR_SPOOLSS_DELETEPRINTER,
346                                 &r);
347
348         if (!NT_STATUS_IS_OK(status)) {
349                 return status;
350         }
351
352         if (DEBUGLEVEL >= 10) {
353                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinter, &r);
354         }
355
356         if (NT_STATUS_IS_ERR(status)) {
357                 return status;
358         }
359
360         /* Return variables */
361
362         /* Return result */
363         if (werror) {
364                 *werror = r.out.result;
365         }
366
367         return werror_to_ntstatus(r.out.result);
368 }
369
370 NTSTATUS rpccli_spoolss_SetPrinter(struct rpc_pipe_client *cli,
371                                    TALLOC_CTX *mem_ctx,
372                                    struct policy_handle *handle /* [in] [ref] */,
373                                    uint32_t level /* [in]  */,
374                                    union spoolss_SetPrinterInfo info /* [in] [switch_is(level)] */,
375                                    struct spoolss_DevmodeContainer devmode_ctr /* [in]  */,
376                                    struct sec_desc_buf secdesc_ctr /* [in]  */,
377                                    enum spoolss_PrinterControl command /* [in]  */,
378                                    WERROR *werror)
379 {
380         struct spoolss_SetPrinter r;
381         NTSTATUS status;
382
383         /* In parameters */
384         r.in.handle = handle;
385         r.in.level = level;
386         r.in.info = info;
387         r.in.devmode_ctr = devmode_ctr;
388         r.in.secdesc_ctr = secdesc_ctr;
389         r.in.command = command;
390
391         if (DEBUGLEVEL >= 10) {
392                 NDR_PRINT_IN_DEBUG(spoolss_SetPrinter, &r);
393         }
394
395         status = cli->dispatch(cli,
396                                 mem_ctx,
397                                 &ndr_table_spoolss,
398                                 NDR_SPOOLSS_SETPRINTER,
399                                 &r);
400
401         if (!NT_STATUS_IS_OK(status)) {
402                 return status;
403         }
404
405         if (DEBUGLEVEL >= 10) {
406                 NDR_PRINT_OUT_DEBUG(spoolss_SetPrinter, &r);
407         }
408
409         if (NT_STATUS_IS_ERR(status)) {
410                 return status;
411         }
412
413         /* Return variables */
414
415         /* Return result */
416         if (werror) {
417                 *werror = r.out.result;
418         }
419
420         return werror_to_ntstatus(r.out.result);
421 }
422
423 NTSTATUS rpccli_spoolss_GetPrinter(struct rpc_pipe_client *cli,
424                                    TALLOC_CTX *mem_ctx,
425                                    struct policy_handle *handle /* [in] [ref] */,
426                                    uint32_t level /* [in]  */,
427                                    DATA_BLOB *buffer /* [in] [unique] */,
428                                    uint32_t offered /* [in]  */,
429                                    union spoolss_PrinterInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
430                                    uint32_t *needed /* [out] [ref] */,
431                                    WERROR *werror)
432 {
433         struct spoolss_GetPrinter r;
434         NTSTATUS status;
435
436         /* In parameters */
437         r.in.handle = handle;
438         r.in.level = level;
439         r.in.buffer = buffer;
440         r.in.offered = offered;
441
442         if (DEBUGLEVEL >= 10) {
443                 NDR_PRINT_IN_DEBUG(spoolss_GetPrinter, &r);
444         }
445
446         status = cli->dispatch(cli,
447                                 mem_ctx,
448                                 &ndr_table_spoolss,
449                                 NDR_SPOOLSS_GETPRINTER,
450                                 &r);
451
452         if (!NT_STATUS_IS_OK(status)) {
453                 return status;
454         }
455
456         if (DEBUGLEVEL >= 10) {
457                 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinter, &r);
458         }
459
460         if (NT_STATUS_IS_ERR(status)) {
461                 return status;
462         }
463
464         /* Return variables */
465         if (info && r.out.info) {
466                 *info = *r.out.info;
467         }
468         *needed = *r.out.needed;
469
470         /* Return result */
471         if (werror) {
472                 *werror = r.out.result;
473         }
474
475         return werror_to_ntstatus(r.out.result);
476 }
477
478 NTSTATUS rpccli_spoolss_AddPrinterDriver(struct rpc_pipe_client *cli,
479                                          TALLOC_CTX *mem_ctx,
480                                          WERROR *werror)
481 {
482         struct spoolss_AddPrinterDriver r;
483         NTSTATUS status;
484
485         /* In parameters */
486
487         if (DEBUGLEVEL >= 10) {
488                 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterDriver, &r);
489         }
490
491         status = cli->dispatch(cli,
492                                 mem_ctx,
493                                 &ndr_table_spoolss,
494                                 NDR_SPOOLSS_ADDPRINTERDRIVER,
495                                 &r);
496
497         if (!NT_STATUS_IS_OK(status)) {
498                 return status;
499         }
500
501         if (DEBUGLEVEL >= 10) {
502                 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterDriver, &r);
503         }
504
505         if (NT_STATUS_IS_ERR(status)) {
506                 return status;
507         }
508
509         /* Return variables */
510
511         /* Return result */
512         if (werror) {
513                 *werror = r.out.result;
514         }
515
516         return werror_to_ntstatus(r.out.result);
517 }
518
519 NTSTATUS rpccli_spoolss_EnumPrinterDrivers(struct rpc_pipe_client *cli,
520                                            TALLOC_CTX *mem_ctx,
521                                            const char *server /* [in] [unique,charset(UTF16)] */,
522                                            const char *environment /* [in] [unique,charset(UTF16)] */,
523                                            uint32_t level /* [in]  */,
524                                            DATA_BLOB *buffer /* [in] [unique] */,
525                                            uint32_t offered /* [in]  */,
526                                            union spoolss_DriverInfo *info /* [out] [unique,switch_is(level),size_is(count)] */,
527                                            uint32_t *needed /* [out] [ref] */,
528                                            uint32_t count /* [out]  */,
529                                            WERROR *werror)
530 {
531         struct spoolss_EnumPrinterDrivers r;
532         NTSTATUS status;
533
534         /* In parameters */
535         r.in.server = server;
536         r.in.environment = environment;
537         r.in.level = level;
538         r.in.buffer = buffer;
539         r.in.offered = offered;
540
541         if (DEBUGLEVEL >= 10) {
542                 NDR_PRINT_IN_DEBUG(spoolss_EnumPrinterDrivers, &r);
543         }
544
545         status = cli->dispatch(cli,
546                                 mem_ctx,
547                                 &ndr_table_spoolss,
548                                 NDR_SPOOLSS_ENUMPRINTERDRIVERS,
549                                 &r);
550
551         if (!NT_STATUS_IS_OK(status)) {
552                 return status;
553         }
554
555         if (DEBUGLEVEL >= 10) {
556                 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrinterDrivers, &r);
557         }
558
559         if (NT_STATUS_IS_ERR(status)) {
560                 return status;
561         }
562
563         /* Return variables */
564         if (info && r.out.info) {
565                 memcpy(info, r.out.info, count * sizeof(*info));
566         }
567         *needed = *r.out.needed;
568         return NT_STATUS_NOT_SUPPORTED;
569
570         /* Return result */
571         if (werror) {
572                 *werror = r.out.result;
573         }
574
575         return werror_to_ntstatus(r.out.result);
576 }
577
578 NTSTATUS rpccli_spoolss_GetPrinterDriver(struct rpc_pipe_client *cli,
579                                          TALLOC_CTX *mem_ctx,
580                                          WERROR *werror)
581 {
582         struct spoolss_GetPrinterDriver r;
583         NTSTATUS status;
584
585         /* In parameters */
586
587         if (DEBUGLEVEL >= 10) {
588                 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriver, &r);
589         }
590
591         status = cli->dispatch(cli,
592                                 mem_ctx,
593                                 &ndr_table_spoolss,
594                                 NDR_SPOOLSS_GETPRINTERDRIVER,
595                                 &r);
596
597         if (!NT_STATUS_IS_OK(status)) {
598                 return status;
599         }
600
601         if (DEBUGLEVEL >= 10) {
602                 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriver, &r);
603         }
604
605         if (NT_STATUS_IS_ERR(status)) {
606                 return status;
607         }
608
609         /* Return variables */
610
611         /* Return result */
612         if (werror) {
613                 *werror = r.out.result;
614         }
615
616         return werror_to_ntstatus(r.out.result);
617 }
618
619 NTSTATUS rpccli_spoolss_GetPrinterDriverDirectory(struct rpc_pipe_client *cli,
620                                                   TALLOC_CTX *mem_ctx,
621                                                   const char *server /* [in] [unique,charset(UTF16)] */,
622                                                   const char *environment /* [in] [unique,charset(UTF16)] */,
623                                                   uint32_t level /* [in]  */,
624                                                   DATA_BLOB *buffer /* [in] [unique] */,
625                                                   uint32_t offered /* [in]  */,
626                                                   union spoolss_DriverDirectoryInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
627                                                   uint32_t *needed /* [out] [ref] */,
628                                                   WERROR *werror)
629 {
630         struct spoolss_GetPrinterDriverDirectory r;
631         NTSTATUS status;
632
633         /* In parameters */
634         r.in.server = server;
635         r.in.environment = environment;
636         r.in.level = level;
637         r.in.buffer = buffer;
638         r.in.offered = offered;
639
640         if (DEBUGLEVEL >= 10) {
641                 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriverDirectory, &r);
642         }
643
644         status = cli->dispatch(cli,
645                                 mem_ctx,
646                                 &ndr_table_spoolss,
647                                 NDR_SPOOLSS_GETPRINTERDRIVERDIRECTORY,
648                                 &r);
649
650         if (!NT_STATUS_IS_OK(status)) {
651                 return status;
652         }
653
654         if (DEBUGLEVEL >= 10) {
655                 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriverDirectory, &r);
656         }
657
658         if (NT_STATUS_IS_ERR(status)) {
659                 return status;
660         }
661
662         /* Return variables */
663         if (info && r.out.info) {
664                 *info = *r.out.info;
665         }
666         *needed = *r.out.needed;
667
668         /* Return result */
669         if (werror) {
670                 *werror = r.out.result;
671         }
672
673         return werror_to_ntstatus(r.out.result);
674 }
675
676 NTSTATUS rpccli_spoolss_DeletePrinterDriver(struct rpc_pipe_client *cli,
677                                             TALLOC_CTX *mem_ctx,
678                                             const char *server /* [in] [unique,charset(UTF16)] */,
679                                             const char *architecture /* [in] [charset(UTF16)] */,
680                                             const char *driver /* [in] [charset(UTF16)] */,
681                                             WERROR *werror)
682 {
683         struct spoolss_DeletePrinterDriver r;
684         NTSTATUS status;
685
686         /* In parameters */
687         r.in.server = server;
688         r.in.architecture = architecture;
689         r.in.driver = driver;
690
691         if (DEBUGLEVEL >= 10) {
692                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterDriver, &r);
693         }
694
695         status = cli->dispatch(cli,
696                                 mem_ctx,
697                                 &ndr_table_spoolss,
698                                 NDR_SPOOLSS_DELETEPRINTERDRIVER,
699                                 &r);
700
701         if (!NT_STATUS_IS_OK(status)) {
702                 return status;
703         }
704
705         if (DEBUGLEVEL >= 10) {
706                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterDriver, &r);
707         }
708
709         if (NT_STATUS_IS_ERR(status)) {
710                 return status;
711         }
712
713         /* Return variables */
714
715         /* Return result */
716         if (werror) {
717                 *werror = r.out.result;
718         }
719
720         return werror_to_ntstatus(r.out.result);
721 }
722
723 NTSTATUS rpccli_spoolss_AddPrintProcessor(struct rpc_pipe_client *cli,
724                                           TALLOC_CTX *mem_ctx,
725                                           const char *server /* [in] [unique,charset(UTF16)] */,
726                                           const char *architecture /* [in] [charset(UTF16)] */,
727                                           const char *path_name /* [in] [charset(UTF16)] */,
728                                           const char *print_processor_name /* [in] [charset(UTF16)] */,
729                                           WERROR *werror)
730 {
731         struct spoolss_AddPrintProcessor r;
732         NTSTATUS status;
733
734         /* In parameters */
735         r.in.server = server;
736         r.in.architecture = architecture;
737         r.in.path_name = path_name;
738         r.in.print_processor_name = print_processor_name;
739
740         if (DEBUGLEVEL >= 10) {
741                 NDR_PRINT_IN_DEBUG(spoolss_AddPrintProcessor, &r);
742         }
743
744         status = cli->dispatch(cli,
745                                 mem_ctx,
746                                 &ndr_table_spoolss,
747                                 NDR_SPOOLSS_ADDPRINTPROCESSOR,
748                                 &r);
749
750         if (!NT_STATUS_IS_OK(status)) {
751                 return status;
752         }
753
754         if (DEBUGLEVEL >= 10) {
755                 NDR_PRINT_OUT_DEBUG(spoolss_AddPrintProcessor, &r);
756         }
757
758         if (NT_STATUS_IS_ERR(status)) {
759                 return status;
760         }
761
762         /* Return variables */
763
764         /* Return result */
765         if (werror) {
766                 *werror = r.out.result;
767         }
768
769         return werror_to_ntstatus(r.out.result);
770 }
771
772 NTSTATUS rpccli_spoolss_EnumPrintProcessors(struct rpc_pipe_client *cli,
773                                             TALLOC_CTX *mem_ctx,
774                                             const char *servername /* [in] [unique,charset(UTF16)] */,
775                                             const char *environment /* [in] [unique,charset(UTF16)] */,
776                                             uint32_t level /* [in]  */,
777                                             DATA_BLOB *buffer /* [in] [unique] */,
778                                             uint32_t offered /* [in]  */,
779                                             union spoolss_PrintProcessorInfo *info /* [out] [unique,switch_is(level),size_is(count)] */,
780                                             uint32_t *needed /* [out] [ref] */,
781                                             uint32_t count /* [out]  */,
782                                             WERROR *werror)
783 {
784         struct spoolss_EnumPrintProcessors r;
785         NTSTATUS status;
786
787         /* In parameters */
788         r.in.servername = servername;
789         r.in.environment = environment;
790         r.in.level = level;
791         r.in.buffer = buffer;
792         r.in.offered = offered;
793
794         if (DEBUGLEVEL >= 10) {
795                 NDR_PRINT_IN_DEBUG(spoolss_EnumPrintProcessors, &r);
796         }
797
798         status = cli->dispatch(cli,
799                                 mem_ctx,
800                                 &ndr_table_spoolss,
801                                 NDR_SPOOLSS_ENUMPRINTPROCESSORS,
802                                 &r);
803
804         if (!NT_STATUS_IS_OK(status)) {
805                 return status;
806         }
807
808         if (DEBUGLEVEL >= 10) {
809                 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrintProcessors, &r);
810         }
811
812         if (NT_STATUS_IS_ERR(status)) {
813                 return status;
814         }
815
816         /* Return variables */
817         if (info && r.out.info) {
818                 memcpy(info, r.out.info, count * sizeof(*info));
819         }
820         *needed = *r.out.needed;
821         return NT_STATUS_NOT_SUPPORTED;
822
823         /* Return result */
824         if (werror) {
825                 *werror = r.out.result;
826         }
827
828         return werror_to_ntstatus(r.out.result);
829 }
830
831 NTSTATUS rpccli_spoolss_GetPrintProcessorDirectory(struct rpc_pipe_client *cli,
832                                                    TALLOC_CTX *mem_ctx,
833                                                    WERROR *werror)
834 {
835         struct spoolss_GetPrintProcessorDirectory r;
836         NTSTATUS status;
837
838         /* In parameters */
839
840         if (DEBUGLEVEL >= 10) {
841                 NDR_PRINT_IN_DEBUG(spoolss_GetPrintProcessorDirectory, &r);
842         }
843
844         status = cli->dispatch(cli,
845                                 mem_ctx,
846                                 &ndr_table_spoolss,
847                                 NDR_SPOOLSS_GETPRINTPROCESSORDIRECTORY,
848                                 &r);
849
850         if (!NT_STATUS_IS_OK(status)) {
851                 return status;
852         }
853
854         if (DEBUGLEVEL >= 10) {
855                 NDR_PRINT_OUT_DEBUG(spoolss_GetPrintProcessorDirectory, &r);
856         }
857
858         if (NT_STATUS_IS_ERR(status)) {
859                 return status;
860         }
861
862         /* Return variables */
863
864         /* Return result */
865         if (werror) {
866                 *werror = r.out.result;
867         }
868
869         return werror_to_ntstatus(r.out.result);
870 }
871
872 NTSTATUS rpccli_spoolss_StartDocPrinter(struct rpc_pipe_client *cli,
873                                         TALLOC_CTX *mem_ctx,
874                                         struct policy_handle *handle /* [in] [ref] */,
875                                         uint32_t level /* [in]  */,
876                                         union spoolss_DocumentInfo info /* [in] [switch_is(level)] */,
877                                         uint32_t *job_id /* [out] [ref] */,
878                                         WERROR *werror)
879 {
880         struct spoolss_StartDocPrinter r;
881         NTSTATUS status;
882
883         /* In parameters */
884         r.in.handle = handle;
885         r.in.level = level;
886         r.in.info = info;
887
888         if (DEBUGLEVEL >= 10) {
889                 NDR_PRINT_IN_DEBUG(spoolss_StartDocPrinter, &r);
890         }
891
892         status = cli->dispatch(cli,
893                                 mem_ctx,
894                                 &ndr_table_spoolss,
895                                 NDR_SPOOLSS_STARTDOCPRINTER,
896                                 &r);
897
898         if (!NT_STATUS_IS_OK(status)) {
899                 return status;
900         }
901
902         if (DEBUGLEVEL >= 10) {
903                 NDR_PRINT_OUT_DEBUG(spoolss_StartDocPrinter, &r);
904         }
905
906         if (NT_STATUS_IS_ERR(status)) {
907                 return status;
908         }
909
910         /* Return variables */
911         *job_id = *r.out.job_id;
912
913         /* Return result */
914         if (werror) {
915                 *werror = r.out.result;
916         }
917
918         return werror_to_ntstatus(r.out.result);
919 }
920
921 NTSTATUS rpccli_spoolss_StartPagePrinter(struct rpc_pipe_client *cli,
922                                          TALLOC_CTX *mem_ctx,
923                                          struct policy_handle *handle /* [in] [ref] */,
924                                          WERROR *werror)
925 {
926         struct spoolss_StartPagePrinter r;
927         NTSTATUS status;
928
929         /* In parameters */
930         r.in.handle = handle;
931
932         if (DEBUGLEVEL >= 10) {
933                 NDR_PRINT_IN_DEBUG(spoolss_StartPagePrinter, &r);
934         }
935
936         status = cli->dispatch(cli,
937                                 mem_ctx,
938                                 &ndr_table_spoolss,
939                                 NDR_SPOOLSS_STARTPAGEPRINTER,
940                                 &r);
941
942         if (!NT_STATUS_IS_OK(status)) {
943                 return status;
944         }
945
946         if (DEBUGLEVEL >= 10) {
947                 NDR_PRINT_OUT_DEBUG(spoolss_StartPagePrinter, &r);
948         }
949
950         if (NT_STATUS_IS_ERR(status)) {
951                 return status;
952         }
953
954         /* Return variables */
955
956         /* Return result */
957         if (werror) {
958                 *werror = r.out.result;
959         }
960
961         return werror_to_ntstatus(r.out.result);
962 }
963
964 NTSTATUS rpccli_spoolss_WritePrinter(struct rpc_pipe_client *cli,
965                                      TALLOC_CTX *mem_ctx,
966                                      struct policy_handle *handle /* [in] [ref] */,
967                                      DATA_BLOB data /* [in]  */,
968                                      uint32_t _data_size /* [in] [value(r->in.data.length)] */,
969                                      uint32_t *num_written /* [out] [ref] */,
970                                      WERROR *werror)
971 {
972         struct spoolss_WritePrinter r;
973         NTSTATUS status;
974
975         /* In parameters */
976         r.in.handle = handle;
977         r.in.data = data;
978         r.in._data_size = _data_size;
979
980         if (DEBUGLEVEL >= 10) {
981                 NDR_PRINT_IN_DEBUG(spoolss_WritePrinter, &r);
982         }
983
984         status = cli->dispatch(cli,
985                                 mem_ctx,
986                                 &ndr_table_spoolss,
987                                 NDR_SPOOLSS_WRITEPRINTER,
988                                 &r);
989
990         if (!NT_STATUS_IS_OK(status)) {
991                 return status;
992         }
993
994         if (DEBUGLEVEL >= 10) {
995                 NDR_PRINT_OUT_DEBUG(spoolss_WritePrinter, &r);
996         }
997
998         if (NT_STATUS_IS_ERR(status)) {
999                 return status;
1000         }
1001
1002         /* Return variables */
1003         *num_written = *r.out.num_written;
1004
1005         /* Return result */
1006         if (werror) {
1007                 *werror = r.out.result;
1008         }
1009
1010         return werror_to_ntstatus(r.out.result);
1011 }
1012
1013 NTSTATUS rpccli_spoolss_EndPagePrinter(struct rpc_pipe_client *cli,
1014                                        TALLOC_CTX *mem_ctx,
1015                                        struct policy_handle *handle /* [in] [ref] */,
1016                                        WERROR *werror)
1017 {
1018         struct spoolss_EndPagePrinter r;
1019         NTSTATUS status;
1020
1021         /* In parameters */
1022         r.in.handle = handle;
1023
1024         if (DEBUGLEVEL >= 10) {
1025                 NDR_PRINT_IN_DEBUG(spoolss_EndPagePrinter, &r);
1026         }
1027
1028         status = cli->dispatch(cli,
1029                                 mem_ctx,
1030                                 &ndr_table_spoolss,
1031                                 NDR_SPOOLSS_ENDPAGEPRINTER,
1032                                 &r);
1033
1034         if (!NT_STATUS_IS_OK(status)) {
1035                 return status;
1036         }
1037
1038         if (DEBUGLEVEL >= 10) {
1039                 NDR_PRINT_OUT_DEBUG(spoolss_EndPagePrinter, &r);
1040         }
1041
1042         if (NT_STATUS_IS_ERR(status)) {
1043                 return status;
1044         }
1045
1046         /* Return variables */
1047
1048         /* Return result */
1049         if (werror) {
1050                 *werror = r.out.result;
1051         }
1052
1053         return werror_to_ntstatus(r.out.result);
1054 }
1055
1056 NTSTATUS rpccli_spoolss_AbortPrinter(struct rpc_pipe_client *cli,
1057                                      TALLOC_CTX *mem_ctx,
1058                                      struct policy_handle *handle /* [in] [ref] */,
1059                                      WERROR *werror)
1060 {
1061         struct spoolss_AbortPrinter r;
1062         NTSTATUS status;
1063
1064         /* In parameters */
1065         r.in.handle = handle;
1066
1067         if (DEBUGLEVEL >= 10) {
1068                 NDR_PRINT_IN_DEBUG(spoolss_AbortPrinter, &r);
1069         }
1070
1071         status = cli->dispatch(cli,
1072                                 mem_ctx,
1073                                 &ndr_table_spoolss,
1074                                 NDR_SPOOLSS_ABORTPRINTER,
1075                                 &r);
1076
1077         if (!NT_STATUS_IS_OK(status)) {
1078                 return status;
1079         }
1080
1081         if (DEBUGLEVEL >= 10) {
1082                 NDR_PRINT_OUT_DEBUG(spoolss_AbortPrinter, &r);
1083         }
1084
1085         if (NT_STATUS_IS_ERR(status)) {
1086                 return status;
1087         }
1088
1089         /* Return variables */
1090
1091         /* Return result */
1092         if (werror) {
1093                 *werror = r.out.result;
1094         }
1095
1096         return werror_to_ntstatus(r.out.result);
1097 }
1098
1099 NTSTATUS rpccli_spoolss_ReadPrinter(struct rpc_pipe_client *cli,
1100                                     TALLOC_CTX *mem_ctx,
1101                                     struct policy_handle *handle /* [in] [ref] */,
1102                                     uint8_t *data /* [out] [ref,size_is(data_size)] */,
1103                                     uint32_t data_size /* [in]  */,
1104                                     uint32_t *_data_size /* [out] [ref] */,
1105                                     WERROR *werror)
1106 {
1107         struct spoolss_ReadPrinter r;
1108         NTSTATUS status;
1109
1110         /* In parameters */
1111         r.in.handle = handle;
1112         r.in.data_size = data_size;
1113
1114         if (DEBUGLEVEL >= 10) {
1115                 NDR_PRINT_IN_DEBUG(spoolss_ReadPrinter, &r);
1116         }
1117
1118         status = cli->dispatch(cli,
1119                                 mem_ctx,
1120                                 &ndr_table_spoolss,
1121                                 NDR_SPOOLSS_READPRINTER,
1122                                 &r);
1123
1124         if (!NT_STATUS_IS_OK(status)) {
1125                 return status;
1126         }
1127
1128         if (DEBUGLEVEL >= 10) {
1129                 NDR_PRINT_OUT_DEBUG(spoolss_ReadPrinter, &r);
1130         }
1131
1132         if (NT_STATUS_IS_ERR(status)) {
1133                 return status;
1134         }
1135
1136         /* Return variables */
1137         memcpy(data, r.out.data, r.in.data_size * sizeof(*data));
1138         *_data_size = *r.out._data_size;
1139
1140         /* Return result */
1141         if (werror) {
1142                 *werror = r.out.result;
1143         }
1144
1145         return werror_to_ntstatus(r.out.result);
1146 }
1147
1148 NTSTATUS rpccli_spoolss_EndDocPrinter(struct rpc_pipe_client *cli,
1149                                       TALLOC_CTX *mem_ctx,
1150                                       struct policy_handle *handle /* [in] [ref] */,
1151                                       WERROR *werror)
1152 {
1153         struct spoolss_EndDocPrinter r;
1154         NTSTATUS status;
1155
1156         /* In parameters */
1157         r.in.handle = handle;
1158
1159         if (DEBUGLEVEL >= 10) {
1160                 NDR_PRINT_IN_DEBUG(spoolss_EndDocPrinter, &r);
1161         }
1162
1163         status = cli->dispatch(cli,
1164                                 mem_ctx,
1165                                 &ndr_table_spoolss,
1166                                 NDR_SPOOLSS_ENDDOCPRINTER,
1167                                 &r);
1168
1169         if (!NT_STATUS_IS_OK(status)) {
1170                 return status;
1171         }
1172
1173         if (DEBUGLEVEL >= 10) {
1174                 NDR_PRINT_OUT_DEBUG(spoolss_EndDocPrinter, &r);
1175         }
1176
1177         if (NT_STATUS_IS_ERR(status)) {
1178                 return status;
1179         }
1180
1181         /* Return variables */
1182
1183         /* Return result */
1184         if (werror) {
1185                 *werror = r.out.result;
1186         }
1187
1188         return werror_to_ntstatus(r.out.result);
1189 }
1190
1191 NTSTATUS rpccli_spoolss_AddJob(struct rpc_pipe_client *cli,
1192                                TALLOC_CTX *mem_ctx,
1193                                WERROR *werror)
1194 {
1195         struct spoolss_AddJob r;
1196         NTSTATUS status;
1197
1198         /* In parameters */
1199
1200         if (DEBUGLEVEL >= 10) {
1201                 NDR_PRINT_IN_DEBUG(spoolss_AddJob, &r);
1202         }
1203
1204         status = cli->dispatch(cli,
1205                                 mem_ctx,
1206                                 &ndr_table_spoolss,
1207                                 NDR_SPOOLSS_ADDJOB,
1208                                 &r);
1209
1210         if (!NT_STATUS_IS_OK(status)) {
1211                 return status;
1212         }
1213
1214         if (DEBUGLEVEL >= 10) {
1215                 NDR_PRINT_OUT_DEBUG(spoolss_AddJob, &r);
1216         }
1217
1218         if (NT_STATUS_IS_ERR(status)) {
1219                 return status;
1220         }
1221
1222         /* Return variables */
1223
1224         /* Return result */
1225         if (werror) {
1226                 *werror = r.out.result;
1227         }
1228
1229         return werror_to_ntstatus(r.out.result);
1230 }
1231
1232 NTSTATUS rpccli_spoolss_ScheduleJob(struct rpc_pipe_client *cli,
1233                                     TALLOC_CTX *mem_ctx,
1234                                     WERROR *werror)
1235 {
1236         struct spoolss_ScheduleJob r;
1237         NTSTATUS status;
1238
1239         /* In parameters */
1240
1241         if (DEBUGLEVEL >= 10) {
1242                 NDR_PRINT_IN_DEBUG(spoolss_ScheduleJob, &r);
1243         }
1244
1245         status = cli->dispatch(cli,
1246                                 mem_ctx,
1247                                 &ndr_table_spoolss,
1248                                 NDR_SPOOLSS_SCHEDULEJOB,
1249                                 &r);
1250
1251         if (!NT_STATUS_IS_OK(status)) {
1252                 return status;
1253         }
1254
1255         if (DEBUGLEVEL >= 10) {
1256                 NDR_PRINT_OUT_DEBUG(spoolss_ScheduleJob, &r);
1257         }
1258
1259         if (NT_STATUS_IS_ERR(status)) {
1260                 return status;
1261         }
1262
1263         /* Return variables */
1264
1265         /* Return result */
1266         if (werror) {
1267                 *werror = r.out.result;
1268         }
1269
1270         return werror_to_ntstatus(r.out.result);
1271 }
1272
1273 NTSTATUS rpccli_spoolss_GetPrinterData(struct rpc_pipe_client *cli,
1274                                        TALLOC_CTX *mem_ctx,
1275                                        struct policy_handle *handle /* [in] [ref] */,
1276                                        const char *value_name /* [in] [charset(UTF16)] */,
1277                                        uint32_t offered /* [in]  */,
1278                                        enum spoolss_PrinterDataType *type /* [out] [ref] */,
1279                                        union spoolss_PrinterData data /* [out] [subcontext_size(offered),subcontext(4),switch_is(*type)] */,
1280                                        uint32_t *needed /* [out] [ref] */,
1281                                        WERROR *werror)
1282 {
1283         struct spoolss_GetPrinterData r;
1284         NTSTATUS status;
1285
1286         /* In parameters */
1287         r.in.handle = handle;
1288         r.in.value_name = value_name;
1289         r.in.offered = offered;
1290
1291         if (DEBUGLEVEL >= 10) {
1292                 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterData, &r);
1293         }
1294
1295         status = cli->dispatch(cli,
1296                                 mem_ctx,
1297                                 &ndr_table_spoolss,
1298                                 NDR_SPOOLSS_GETPRINTERDATA,
1299                                 &r);
1300
1301         if (!NT_STATUS_IS_OK(status)) {
1302                 return status;
1303         }
1304
1305         if (DEBUGLEVEL >= 10) {
1306                 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterData, &r);
1307         }
1308
1309         if (NT_STATUS_IS_ERR(status)) {
1310                 return status;
1311         }
1312
1313         /* Return variables */
1314         *type = *r.out.type;
1315         return NT_STATUS_NOT_SUPPORTED;
1316         *needed = *r.out.needed;
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_SetPrinterData(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                                        enum spoolss_PrinterDataType type /* [in]  */,
1331                                        union spoolss_PrinterData data /* [in] [subcontext(4),switch_is(type)] */,
1332                                        uint32_t _offered /* [in] [value(ndr_size_spoolss_PrinterData(&data,type,ndr->iconv_convenience,flags))] */,
1333                                        WERROR *werror)
1334 {
1335         struct spoolss_SetPrinterData r;
1336         NTSTATUS status;
1337
1338         /* In parameters */
1339         r.in.handle = handle;
1340         r.in.value_name = value_name;
1341         r.in.type = type;
1342         r.in.data = data;
1343         r.in._offered = _offered;
1344
1345         if (DEBUGLEVEL >= 10) {
1346                 NDR_PRINT_IN_DEBUG(spoolss_SetPrinterData, &r);
1347         }
1348
1349         status = cli->dispatch(cli,
1350                                 mem_ctx,
1351                                 &ndr_table_spoolss,
1352                                 NDR_SPOOLSS_SETPRINTERDATA,
1353                                 &r);
1354
1355         if (!NT_STATUS_IS_OK(status)) {
1356                 return status;
1357         }
1358
1359         if (DEBUGLEVEL >= 10) {
1360                 NDR_PRINT_OUT_DEBUG(spoolss_SetPrinterData, &r);
1361         }
1362
1363         if (NT_STATUS_IS_ERR(status)) {
1364                 return status;
1365         }
1366
1367         /* Return variables */
1368
1369         /* Return result */
1370         if (werror) {
1371                 *werror = r.out.result;
1372         }
1373
1374         return werror_to_ntstatus(r.out.result);
1375 }
1376
1377 NTSTATUS rpccli_spoolss_WaitForPrinterChange(struct rpc_pipe_client *cli,
1378                                              TALLOC_CTX *mem_ctx,
1379                                              WERROR *werror)
1380 {
1381         struct spoolss_WaitForPrinterChange r;
1382         NTSTATUS status;
1383
1384         /* In parameters */
1385
1386         if (DEBUGLEVEL >= 10) {
1387                 NDR_PRINT_IN_DEBUG(spoolss_WaitForPrinterChange, &r);
1388         }
1389
1390         status = cli->dispatch(cli,
1391                                 mem_ctx,
1392                                 &ndr_table_spoolss,
1393                                 NDR_SPOOLSS_WAITFORPRINTERCHANGE,
1394                                 &r);
1395
1396         if (!NT_STATUS_IS_OK(status)) {
1397                 return status;
1398         }
1399
1400         if (DEBUGLEVEL >= 10) {
1401                 NDR_PRINT_OUT_DEBUG(spoolss_WaitForPrinterChange, &r);
1402         }
1403
1404         if (NT_STATUS_IS_ERR(status)) {
1405                 return status;
1406         }
1407
1408         /* Return variables */
1409
1410         /* Return result */
1411         if (werror) {
1412                 *werror = r.out.result;
1413         }
1414
1415         return werror_to_ntstatus(r.out.result);
1416 }
1417
1418 NTSTATUS rpccli_spoolss_ClosePrinter(struct rpc_pipe_client *cli,
1419                                      TALLOC_CTX *mem_ctx,
1420                                      struct policy_handle *handle /* [in,out] [ref] */,
1421                                      WERROR *werror)
1422 {
1423         struct spoolss_ClosePrinter r;
1424         NTSTATUS status;
1425
1426         /* In parameters */
1427         r.in.handle = handle;
1428
1429         if (DEBUGLEVEL >= 10) {
1430                 NDR_PRINT_IN_DEBUG(spoolss_ClosePrinter, &r);
1431         }
1432
1433         status = cli->dispatch(cli,
1434                                 mem_ctx,
1435                                 &ndr_table_spoolss,
1436                                 NDR_SPOOLSS_CLOSEPRINTER,
1437                                 &r);
1438
1439         if (!NT_STATUS_IS_OK(status)) {
1440                 return status;
1441         }
1442
1443         if (DEBUGLEVEL >= 10) {
1444                 NDR_PRINT_OUT_DEBUG(spoolss_ClosePrinter, &r);
1445         }
1446
1447         if (NT_STATUS_IS_ERR(status)) {
1448                 return status;
1449         }
1450
1451         /* Return variables */
1452         *handle = *r.out.handle;
1453
1454         /* Return result */
1455         if (werror) {
1456                 *werror = r.out.result;
1457         }
1458
1459         return werror_to_ntstatus(r.out.result);
1460 }
1461
1462 NTSTATUS rpccli_spoolss_AddForm(struct rpc_pipe_client *cli,
1463                                 TALLOC_CTX *mem_ctx,
1464                                 struct policy_handle *handle /* [in] [ref] */,
1465                                 uint32_t level /* [in]  */,
1466                                 union spoolss_AddFormInfo info /* [in] [switch_is(level)] */,
1467                                 WERROR *werror)
1468 {
1469         struct spoolss_AddForm r;
1470         NTSTATUS status;
1471
1472         /* In parameters */
1473         r.in.handle = handle;
1474         r.in.level = level;
1475         r.in.info = info;
1476
1477         if (DEBUGLEVEL >= 10) {
1478                 NDR_PRINT_IN_DEBUG(spoolss_AddForm, &r);
1479         }
1480
1481         status = cli->dispatch(cli,
1482                                 mem_ctx,
1483                                 &ndr_table_spoolss,
1484                                 NDR_SPOOLSS_ADDFORM,
1485                                 &r);
1486
1487         if (!NT_STATUS_IS_OK(status)) {
1488                 return status;
1489         }
1490
1491         if (DEBUGLEVEL >= 10) {
1492                 NDR_PRINT_OUT_DEBUG(spoolss_AddForm, &r);
1493         }
1494
1495         if (NT_STATUS_IS_ERR(status)) {
1496                 return status;
1497         }
1498
1499         /* Return variables */
1500
1501         /* Return result */
1502         if (werror) {
1503                 *werror = r.out.result;
1504         }
1505
1506         return werror_to_ntstatus(r.out.result);
1507 }
1508
1509 NTSTATUS rpccli_spoolss_DeleteForm(struct rpc_pipe_client *cli,
1510                                    TALLOC_CTX *mem_ctx,
1511                                    struct policy_handle *handle /* [in] [ref] */,
1512                                    const char *form_name /* [in] [charset(UTF16)] */,
1513                                    WERROR *werror)
1514 {
1515         struct spoolss_DeleteForm r;
1516         NTSTATUS status;
1517
1518         /* In parameters */
1519         r.in.handle = handle;
1520         r.in.form_name = form_name;
1521
1522         if (DEBUGLEVEL >= 10) {
1523                 NDR_PRINT_IN_DEBUG(spoolss_DeleteForm, &r);
1524         }
1525
1526         status = cli->dispatch(cli,
1527                                 mem_ctx,
1528                                 &ndr_table_spoolss,
1529                                 NDR_SPOOLSS_DELETEFORM,
1530                                 &r);
1531
1532         if (!NT_STATUS_IS_OK(status)) {
1533                 return status;
1534         }
1535
1536         if (DEBUGLEVEL >= 10) {
1537                 NDR_PRINT_OUT_DEBUG(spoolss_DeleteForm, &r);
1538         }
1539
1540         if (NT_STATUS_IS_ERR(status)) {
1541                 return status;
1542         }
1543
1544         /* Return variables */
1545
1546         /* Return result */
1547         if (werror) {
1548                 *werror = r.out.result;
1549         }
1550
1551         return werror_to_ntstatus(r.out.result);
1552 }
1553
1554 NTSTATUS rpccli_spoolss_GetForm(struct rpc_pipe_client *cli,
1555                                 TALLOC_CTX *mem_ctx,
1556                                 struct policy_handle *handle /* [in] [ref] */,
1557                                 const char *form_name /* [in] [charset(UTF16)] */,
1558                                 uint32_t level /* [in]  */,
1559                                 DATA_BLOB *buffer /* [in] [unique] */,
1560                                 uint32_t offered /* [in]  */,
1561                                 union spoolss_FormInfo *info /* [out] [unique,subcontext_size(offered),subcontext(4),switch_is(level)] */,
1562                                 uint32_t *needed /* [out] [ref] */,
1563                                 WERROR *werror)
1564 {
1565         struct spoolss_GetForm r;
1566         NTSTATUS status;
1567
1568         /* In parameters */
1569         r.in.handle = handle;
1570         r.in.form_name = form_name;
1571         r.in.level = level;
1572         r.in.buffer = buffer;
1573         r.in.offered = offered;
1574
1575         if (DEBUGLEVEL >= 10) {
1576                 NDR_PRINT_IN_DEBUG(spoolss_GetForm, &r);
1577         }
1578
1579         status = cli->dispatch(cli,
1580                                 mem_ctx,
1581                                 &ndr_table_spoolss,
1582                                 NDR_SPOOLSS_GETFORM,
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_GetForm, &r);
1591         }
1592
1593         if (NT_STATUS_IS_ERR(status)) {
1594                 return status;
1595         }
1596
1597         /* Return variables */
1598         if (info && r.out.info) {
1599                 *info = *r.out.info;
1600         }
1601         *needed = *r.out.needed;
1602
1603         /* Return result */
1604         if (werror) {
1605                 *werror = r.out.result;
1606         }
1607
1608         return werror_to_ntstatus(r.out.result);
1609 }
1610
1611 NTSTATUS rpccli_spoolss_SetForm(struct rpc_pipe_client *cli,
1612                                 TALLOC_CTX *mem_ctx,
1613                                 struct policy_handle *handle /* [in] [ref] */,
1614                                 const char *form_name /* [in] [charset(UTF16)] */,
1615                                 uint32_t level /* [in]  */,
1616                                 union spoolss_AddFormInfo info /* [in] [switch_is(level)] */,
1617                                 WERROR *werror)
1618 {
1619         struct spoolss_SetForm r;
1620         NTSTATUS status;
1621
1622         /* In parameters */
1623         r.in.handle = handle;
1624         r.in.form_name = form_name;
1625         r.in.level = level;
1626         r.in.info = info;
1627
1628         if (DEBUGLEVEL >= 10) {
1629                 NDR_PRINT_IN_DEBUG(spoolss_SetForm, &r);
1630         }
1631
1632         status = cli->dispatch(cli,
1633                                 mem_ctx,
1634                                 &ndr_table_spoolss,
1635                                 NDR_SPOOLSS_SETFORM,
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_SetForm, &r);
1644         }
1645
1646         if (NT_STATUS_IS_ERR(status)) {
1647                 return status;
1648         }
1649
1650         /* Return variables */
1651
1652         /* Return result */
1653         if (werror) {
1654                 *werror = r.out.result;
1655         }
1656
1657         return werror_to_ntstatus(r.out.result);
1658 }
1659
1660 NTSTATUS rpccli_spoolss_EnumForms(struct rpc_pipe_client *cli,
1661                                   TALLOC_CTX *mem_ctx,
1662                                   struct policy_handle *handle /* [in] [ref] */,
1663                                   uint32_t level /* [in]  */,
1664                                   DATA_BLOB *buffer /* [in] [unique] */,
1665                                   uint32_t offered /* [in]  */,
1666                                   union spoolss_FormInfo *info /* [out] [unique,switch_is(level),size_is(count)] */,
1667                                   uint32_t *needed /* [out] [ref] */,
1668                                   uint32_t count /* [out]  */,
1669                                   WERROR *werror)
1670 {
1671         struct spoolss_EnumForms r;
1672         NTSTATUS status;
1673
1674         /* In parameters */
1675         r.in.handle = handle;
1676         r.in.level = level;
1677         r.in.buffer = buffer;
1678         r.in.offered = offered;
1679
1680         if (DEBUGLEVEL >= 10) {
1681                 NDR_PRINT_IN_DEBUG(spoolss_EnumForms, &r);
1682         }
1683
1684         status = cli->dispatch(cli,
1685                                 mem_ctx,
1686                                 &ndr_table_spoolss,
1687                                 NDR_SPOOLSS_ENUMFORMS,
1688                                 &r);
1689
1690         if (!NT_STATUS_IS_OK(status)) {
1691                 return status;
1692         }
1693
1694         if (DEBUGLEVEL >= 10) {
1695                 NDR_PRINT_OUT_DEBUG(spoolss_EnumForms, &r);
1696         }
1697
1698         if (NT_STATUS_IS_ERR(status)) {
1699                 return status;
1700         }
1701
1702         /* Return variables */
1703         if (info && r.out.info) {
1704                 memcpy(info, r.out.info, count * sizeof(*info));
1705         }
1706         *needed = *r.out.needed;
1707         return NT_STATUS_NOT_SUPPORTED;
1708
1709         /* Return result */
1710         if (werror) {
1711                 *werror = r.out.result;
1712         }
1713
1714         return werror_to_ntstatus(r.out.result);
1715 }
1716
1717 NTSTATUS rpccli_spoolss_EnumPorts(struct rpc_pipe_client *cli,
1718                                   TALLOC_CTX *mem_ctx,
1719                                   const char *servername /* [in] [unique,charset(UTF16)] */,
1720                                   uint32_t level /* [in]  */,
1721                                   DATA_BLOB *buffer /* [in] [unique] */,
1722                                   uint32_t offered /* [in]  */,
1723                                   union spoolss_PortInfo *info /* [out] [unique,switch_is(level),size_is(count)] */,
1724                                   uint32_t *needed /* [out] [ref] */,
1725                                   uint32_t count /* [out]  */,
1726                                   WERROR *werror)
1727 {
1728         struct spoolss_EnumPorts r;
1729         NTSTATUS status;
1730
1731         /* In parameters */
1732         r.in.servername = servername;
1733         r.in.level = level;
1734         r.in.buffer = buffer;
1735         r.in.offered = offered;
1736
1737         if (DEBUGLEVEL >= 10) {
1738                 NDR_PRINT_IN_DEBUG(spoolss_EnumPorts, &r);
1739         }
1740
1741         status = cli->dispatch(cli,
1742                                 mem_ctx,
1743                                 &ndr_table_spoolss,
1744                                 NDR_SPOOLSS_ENUMPORTS,
1745                                 &r);
1746
1747         if (!NT_STATUS_IS_OK(status)) {
1748                 return status;
1749         }
1750
1751         if (DEBUGLEVEL >= 10) {
1752                 NDR_PRINT_OUT_DEBUG(spoolss_EnumPorts, &r);
1753         }
1754
1755         if (NT_STATUS_IS_ERR(status)) {
1756                 return status;
1757         }
1758
1759         /* Return variables */
1760         if (info && r.out.info) {
1761                 memcpy(info, r.out.info, count * sizeof(*info));
1762         }
1763         *needed = *r.out.needed;
1764         return NT_STATUS_NOT_SUPPORTED;
1765
1766         /* Return result */
1767         if (werror) {
1768                 *werror = r.out.result;
1769         }
1770
1771         return werror_to_ntstatus(r.out.result);
1772 }
1773
1774 NTSTATUS rpccli_spoolss_EnumMonitors(struct rpc_pipe_client *cli,
1775                                      TALLOC_CTX *mem_ctx,
1776                                      const char *servername /* [in] [unique,charset(UTF16)] */,
1777                                      uint32_t level /* [in]  */,
1778                                      DATA_BLOB *buffer /* [in] [unique] */,
1779                                      uint32_t offered /* [in]  */,
1780                                      union spoolss_MonitorInfo *info /* [out] [unique,switch_is(level),size_is(count)] */,
1781                                      uint32_t *needed /* [out] [ref] */,
1782                                      uint32_t count /* [out]  */,
1783                                      WERROR *werror)
1784 {
1785         struct spoolss_EnumMonitors r;
1786         NTSTATUS status;
1787
1788         /* In parameters */
1789         r.in.servername = servername;
1790         r.in.level = level;
1791         r.in.buffer = buffer;
1792         r.in.offered = offered;
1793
1794         if (DEBUGLEVEL >= 10) {
1795                 NDR_PRINT_IN_DEBUG(spoolss_EnumMonitors, &r);
1796         }
1797
1798         status = cli->dispatch(cli,
1799                                 mem_ctx,
1800                                 &ndr_table_spoolss,
1801                                 NDR_SPOOLSS_ENUMMONITORS,
1802                                 &r);
1803
1804         if (!NT_STATUS_IS_OK(status)) {
1805                 return status;
1806         }
1807
1808         if (DEBUGLEVEL >= 10) {
1809                 NDR_PRINT_OUT_DEBUG(spoolss_EnumMonitors, &r);
1810         }
1811
1812         if (NT_STATUS_IS_ERR(status)) {
1813                 return status;
1814         }
1815
1816         /* Return variables */
1817         if (info && r.out.info) {
1818                 memcpy(info, r.out.info, count * sizeof(*info));
1819         }
1820         *needed = *r.out.needed;
1821         return NT_STATUS_NOT_SUPPORTED;
1822
1823         /* Return result */
1824         if (werror) {
1825                 *werror = r.out.result;
1826         }
1827
1828         return werror_to_ntstatus(r.out.result);
1829 }
1830
1831 NTSTATUS rpccli_spoolss_AddPort(struct rpc_pipe_client *cli,
1832                                 TALLOC_CTX *mem_ctx,
1833                                 const char *server_name /* [in] [unique,charset(UTF16)] */,
1834                                 uint32_t unknown /* [in]  */,
1835                                 const char *monitor_name /* [in] [charset(UTF16)] */,
1836                                 WERROR *werror)
1837 {
1838         struct spoolss_AddPort r;
1839         NTSTATUS status;
1840
1841         /* In parameters */
1842         r.in.server_name = server_name;
1843         r.in.unknown = unknown;
1844         r.in.monitor_name = monitor_name;
1845
1846         if (DEBUGLEVEL >= 10) {
1847                 NDR_PRINT_IN_DEBUG(spoolss_AddPort, &r);
1848         }
1849
1850         status = cli->dispatch(cli,
1851                                 mem_ctx,
1852                                 &ndr_table_spoolss,
1853                                 NDR_SPOOLSS_ADDPORT,
1854                                 &r);
1855
1856         if (!NT_STATUS_IS_OK(status)) {
1857                 return status;
1858         }
1859
1860         if (DEBUGLEVEL >= 10) {
1861                 NDR_PRINT_OUT_DEBUG(spoolss_AddPort, &r);
1862         }
1863
1864         if (NT_STATUS_IS_ERR(status)) {
1865                 return status;
1866         }
1867
1868         /* Return variables */
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_ConfigurePort(struct rpc_pipe_client *cli,
1879                                       TALLOC_CTX *mem_ctx,
1880                                       WERROR *werror)
1881 {
1882         struct spoolss_ConfigurePort r;
1883         NTSTATUS status;
1884
1885         /* In parameters */
1886
1887         if (DEBUGLEVEL >= 10) {
1888                 NDR_PRINT_IN_DEBUG(spoolss_ConfigurePort, &r);
1889         }
1890
1891         status = cli->dispatch(cli,
1892                                 mem_ctx,
1893                                 &ndr_table_spoolss,
1894                                 NDR_SPOOLSS_CONFIGUREPORT,
1895                                 &r);
1896
1897         if (!NT_STATUS_IS_OK(status)) {
1898                 return status;
1899         }
1900
1901         if (DEBUGLEVEL >= 10) {
1902                 NDR_PRINT_OUT_DEBUG(spoolss_ConfigurePort, &r);
1903         }
1904
1905         if (NT_STATUS_IS_ERR(status)) {
1906                 return status;
1907         }
1908
1909         /* Return variables */
1910
1911         /* Return result */
1912         if (werror) {
1913                 *werror = r.out.result;
1914         }
1915
1916         return werror_to_ntstatus(r.out.result);
1917 }
1918
1919 NTSTATUS rpccli_spoolss_DeletePort(struct rpc_pipe_client *cli,
1920                                    TALLOC_CTX *mem_ctx,
1921                                    WERROR *werror)
1922 {
1923         struct spoolss_DeletePort r;
1924         NTSTATUS status;
1925
1926         /* In parameters */
1927
1928         if (DEBUGLEVEL >= 10) {
1929                 NDR_PRINT_IN_DEBUG(spoolss_DeletePort, &r);
1930         }
1931
1932         status = cli->dispatch(cli,
1933                                 mem_ctx,
1934                                 &ndr_table_spoolss,
1935                                 NDR_SPOOLSS_DELETEPORT,
1936                                 &r);
1937
1938         if (!NT_STATUS_IS_OK(status)) {
1939                 return status;
1940         }
1941
1942         if (DEBUGLEVEL >= 10) {
1943                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePort, &r);
1944         }
1945
1946         if (NT_STATUS_IS_ERR(status)) {
1947                 return status;
1948         }
1949
1950         /* Return variables */
1951
1952         /* Return result */
1953         if (werror) {
1954                 *werror = r.out.result;
1955         }
1956
1957         return werror_to_ntstatus(r.out.result);
1958 }
1959
1960 NTSTATUS rpccli_spoolss_CreatePrinterIC(struct rpc_pipe_client *cli,
1961                                         TALLOC_CTX *mem_ctx,
1962                                         WERROR *werror)
1963 {
1964         struct spoolss_CreatePrinterIC r;
1965         NTSTATUS status;
1966
1967         /* In parameters */
1968
1969         if (DEBUGLEVEL >= 10) {
1970                 NDR_PRINT_IN_DEBUG(spoolss_CreatePrinterIC, &r);
1971         }
1972
1973         status = cli->dispatch(cli,
1974                                 mem_ctx,
1975                                 &ndr_table_spoolss,
1976                                 NDR_SPOOLSS_CREATEPRINTERIC,
1977                                 &r);
1978
1979         if (!NT_STATUS_IS_OK(status)) {
1980                 return status;
1981         }
1982
1983         if (DEBUGLEVEL >= 10) {
1984                 NDR_PRINT_OUT_DEBUG(spoolss_CreatePrinterIC, &r);
1985         }
1986
1987         if (NT_STATUS_IS_ERR(status)) {
1988                 return status;
1989         }
1990
1991         /* Return variables */
1992
1993         /* Return result */
1994         if (werror) {
1995                 *werror = r.out.result;
1996         }
1997
1998         return werror_to_ntstatus(r.out.result);
1999 }
2000
2001 NTSTATUS rpccli_spoolss_PlayGDIScriptOnPrinterIC(struct rpc_pipe_client *cli,
2002                                                  TALLOC_CTX *mem_ctx,
2003                                                  WERROR *werror)
2004 {
2005         struct spoolss_PlayGDIScriptOnPrinterIC r;
2006         NTSTATUS status;
2007
2008         /* In parameters */
2009
2010         if (DEBUGLEVEL >= 10) {
2011                 NDR_PRINT_IN_DEBUG(spoolss_PlayGDIScriptOnPrinterIC, &r);
2012         }
2013
2014         status = cli->dispatch(cli,
2015                                 mem_ctx,
2016                                 &ndr_table_spoolss,
2017                                 NDR_SPOOLSS_PLAYGDISCRIPTONPRINTERIC,
2018                                 &r);
2019
2020         if (!NT_STATUS_IS_OK(status)) {
2021                 return status;
2022         }
2023
2024         if (DEBUGLEVEL >= 10) {
2025                 NDR_PRINT_OUT_DEBUG(spoolss_PlayGDIScriptOnPrinterIC, &r);
2026         }
2027
2028         if (NT_STATUS_IS_ERR(status)) {
2029                 return status;
2030         }
2031
2032         /* Return variables */
2033
2034         /* Return result */
2035         if (werror) {
2036                 *werror = r.out.result;
2037         }
2038
2039         return werror_to_ntstatus(r.out.result);
2040 }
2041
2042 NTSTATUS rpccli_spoolss_DeletePrinterIC(struct rpc_pipe_client *cli,
2043                                         TALLOC_CTX *mem_ctx,
2044                                         WERROR *werror)
2045 {
2046         struct spoolss_DeletePrinterIC r;
2047         NTSTATUS status;
2048
2049         /* In parameters */
2050
2051         if (DEBUGLEVEL >= 10) {
2052                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterIC, &r);
2053         }
2054
2055         status = cli->dispatch(cli,
2056                                 mem_ctx,
2057                                 &ndr_table_spoolss,
2058                                 NDR_SPOOLSS_DELETEPRINTERIC,
2059                                 &r);
2060
2061         if (!NT_STATUS_IS_OK(status)) {
2062                 return status;
2063         }
2064
2065         if (DEBUGLEVEL >= 10) {
2066                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterIC, &r);
2067         }
2068
2069         if (NT_STATUS_IS_ERR(status)) {
2070                 return status;
2071         }
2072
2073         /* Return variables */
2074
2075         /* Return result */
2076         if (werror) {
2077                 *werror = r.out.result;
2078         }
2079
2080         return werror_to_ntstatus(r.out.result);
2081 }
2082
2083 NTSTATUS rpccli_spoolss_AddPrinterConnection(struct rpc_pipe_client *cli,
2084                                              TALLOC_CTX *mem_ctx,
2085                                              WERROR *werror)
2086 {
2087         struct spoolss_AddPrinterConnection r;
2088         NTSTATUS status;
2089
2090         /* In parameters */
2091
2092         if (DEBUGLEVEL >= 10) {
2093                 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterConnection, &r);
2094         }
2095
2096         status = cli->dispatch(cli,
2097                                 mem_ctx,
2098                                 &ndr_table_spoolss,
2099                                 NDR_SPOOLSS_ADDPRINTERCONNECTION,
2100                                 &r);
2101
2102         if (!NT_STATUS_IS_OK(status)) {
2103                 return status;
2104         }
2105
2106         if (DEBUGLEVEL >= 10) {
2107                 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterConnection, &r);
2108         }
2109
2110         if (NT_STATUS_IS_ERR(status)) {
2111                 return status;
2112         }
2113
2114         /* Return variables */
2115
2116         /* Return result */
2117         if (werror) {
2118                 *werror = r.out.result;
2119         }
2120
2121         return werror_to_ntstatus(r.out.result);
2122 }
2123
2124 NTSTATUS rpccli_spoolss_DeletePrinterConnection(struct rpc_pipe_client *cli,
2125                                                 TALLOC_CTX *mem_ctx,
2126                                                 WERROR *werror)
2127 {
2128         struct spoolss_DeletePrinterConnection r;
2129         NTSTATUS status;
2130
2131         /* In parameters */
2132
2133         if (DEBUGLEVEL >= 10) {
2134                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrinterConnection, &r);
2135         }
2136
2137         status = cli->dispatch(cli,
2138                                 mem_ctx,
2139                                 &ndr_table_spoolss,
2140                                 NDR_SPOOLSS_DELETEPRINTERCONNECTION,
2141                                 &r);
2142
2143         if (!NT_STATUS_IS_OK(status)) {
2144                 return status;
2145         }
2146
2147         if (DEBUGLEVEL >= 10) {
2148                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrinterConnection, &r);
2149         }
2150
2151         if (NT_STATUS_IS_ERR(status)) {
2152                 return status;
2153         }
2154
2155         /* Return variables */
2156
2157         /* Return result */
2158         if (werror) {
2159                 *werror = r.out.result;
2160         }
2161
2162         return werror_to_ntstatus(r.out.result);
2163 }
2164
2165 NTSTATUS rpccli_spoolss_PrinterMessageBox(struct rpc_pipe_client *cli,
2166                                           TALLOC_CTX *mem_ctx,
2167                                           WERROR *werror)
2168 {
2169         struct spoolss_PrinterMessageBox r;
2170         NTSTATUS status;
2171
2172         /* In parameters */
2173
2174         if (DEBUGLEVEL >= 10) {
2175                 NDR_PRINT_IN_DEBUG(spoolss_PrinterMessageBox, &r);
2176         }
2177
2178         status = cli->dispatch(cli,
2179                                 mem_ctx,
2180                                 &ndr_table_spoolss,
2181                                 NDR_SPOOLSS_PRINTERMESSAGEBOX,
2182                                 &r);
2183
2184         if (!NT_STATUS_IS_OK(status)) {
2185                 return status;
2186         }
2187
2188         if (DEBUGLEVEL >= 10) {
2189                 NDR_PRINT_OUT_DEBUG(spoolss_PrinterMessageBox, &r);
2190         }
2191
2192         if (NT_STATUS_IS_ERR(status)) {
2193                 return status;
2194         }
2195
2196         /* Return variables */
2197
2198         /* Return result */
2199         if (werror) {
2200                 *werror = r.out.result;
2201         }
2202
2203         return werror_to_ntstatus(r.out.result);
2204 }
2205
2206 NTSTATUS rpccli_spoolss_AddMonitor(struct rpc_pipe_client *cli,
2207                                    TALLOC_CTX *mem_ctx,
2208                                    WERROR *werror)
2209 {
2210         struct spoolss_AddMonitor r;
2211         NTSTATUS status;
2212
2213         /* In parameters */
2214
2215         if (DEBUGLEVEL >= 10) {
2216                 NDR_PRINT_IN_DEBUG(spoolss_AddMonitor, &r);
2217         }
2218
2219         status = cli->dispatch(cli,
2220                                 mem_ctx,
2221                                 &ndr_table_spoolss,
2222                                 NDR_SPOOLSS_ADDMONITOR,
2223                                 &r);
2224
2225         if (!NT_STATUS_IS_OK(status)) {
2226                 return status;
2227         }
2228
2229         if (DEBUGLEVEL >= 10) {
2230                 NDR_PRINT_OUT_DEBUG(spoolss_AddMonitor, &r);
2231         }
2232
2233         if (NT_STATUS_IS_ERR(status)) {
2234                 return status;
2235         }
2236
2237         /* Return variables */
2238
2239         /* Return result */
2240         if (werror) {
2241                 *werror = r.out.result;
2242         }
2243
2244         return werror_to_ntstatus(r.out.result);
2245 }
2246
2247 NTSTATUS rpccli_spoolss_DeleteMonitor(struct rpc_pipe_client *cli,
2248                                       TALLOC_CTX *mem_ctx,
2249                                       WERROR *werror)
2250 {
2251         struct spoolss_DeleteMonitor r;
2252         NTSTATUS status;
2253
2254         /* In parameters */
2255
2256         if (DEBUGLEVEL >= 10) {
2257                 NDR_PRINT_IN_DEBUG(spoolss_DeleteMonitor, &r);
2258         }
2259
2260         status = cli->dispatch(cli,
2261                                 mem_ctx,
2262                                 &ndr_table_spoolss,
2263                                 NDR_SPOOLSS_DELETEMONITOR,
2264                                 &r);
2265
2266         if (!NT_STATUS_IS_OK(status)) {
2267                 return status;
2268         }
2269
2270         if (DEBUGLEVEL >= 10) {
2271                 NDR_PRINT_OUT_DEBUG(spoolss_DeleteMonitor, &r);
2272         }
2273
2274         if (NT_STATUS_IS_ERR(status)) {
2275                 return status;
2276         }
2277
2278         /* Return variables */
2279
2280         /* Return result */
2281         if (werror) {
2282                 *werror = r.out.result;
2283         }
2284
2285         return werror_to_ntstatus(r.out.result);
2286 }
2287
2288 NTSTATUS rpccli_spoolss_DeletePrintProcessor(struct rpc_pipe_client *cli,
2289                                              TALLOC_CTX *mem_ctx,
2290                                              WERROR *werror)
2291 {
2292         struct spoolss_DeletePrintProcessor r;
2293         NTSTATUS status;
2294
2295         /* In parameters */
2296
2297         if (DEBUGLEVEL >= 10) {
2298                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrintProcessor, &r);
2299         }
2300
2301         status = cli->dispatch(cli,
2302                                 mem_ctx,
2303                                 &ndr_table_spoolss,
2304                                 NDR_SPOOLSS_DELETEPRINTPROCESSOR,
2305                                 &r);
2306
2307         if (!NT_STATUS_IS_OK(status)) {
2308                 return status;
2309         }
2310
2311         if (DEBUGLEVEL >= 10) {
2312                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrintProcessor, &r);
2313         }
2314
2315         if (NT_STATUS_IS_ERR(status)) {
2316                 return status;
2317         }
2318
2319         /* Return variables */
2320
2321         /* Return result */
2322         if (werror) {
2323                 *werror = r.out.result;
2324         }
2325
2326         return werror_to_ntstatus(r.out.result);
2327 }
2328
2329 NTSTATUS rpccli_spoolss_AddPrintProvidor(struct rpc_pipe_client *cli,
2330                                          TALLOC_CTX *mem_ctx,
2331                                          WERROR *werror)
2332 {
2333         struct spoolss_AddPrintProvidor r;
2334         NTSTATUS status;
2335
2336         /* In parameters */
2337
2338         if (DEBUGLEVEL >= 10) {
2339                 NDR_PRINT_IN_DEBUG(spoolss_AddPrintProvidor, &r);
2340         }
2341
2342         status = cli->dispatch(cli,
2343                                 mem_ctx,
2344                                 &ndr_table_spoolss,
2345                                 NDR_SPOOLSS_ADDPRINTPROVIDOR,
2346                                 &r);
2347
2348         if (!NT_STATUS_IS_OK(status)) {
2349                 return status;
2350         }
2351
2352         if (DEBUGLEVEL >= 10) {
2353                 NDR_PRINT_OUT_DEBUG(spoolss_AddPrintProvidor, &r);
2354         }
2355
2356         if (NT_STATUS_IS_ERR(status)) {
2357                 return status;
2358         }
2359
2360         /* Return variables */
2361
2362         /* Return result */
2363         if (werror) {
2364                 *werror = r.out.result;
2365         }
2366
2367         return werror_to_ntstatus(r.out.result);
2368 }
2369
2370 NTSTATUS rpccli_spoolss_DeletePrintProvidor(struct rpc_pipe_client *cli,
2371                                             TALLOC_CTX *mem_ctx,
2372                                             WERROR *werror)
2373 {
2374         struct spoolss_DeletePrintProvidor r;
2375         NTSTATUS status;
2376
2377         /* In parameters */
2378
2379         if (DEBUGLEVEL >= 10) {
2380                 NDR_PRINT_IN_DEBUG(spoolss_DeletePrintProvidor, &r);
2381         }
2382
2383         status = cli->dispatch(cli,
2384                                 mem_ctx,
2385                                 &ndr_table_spoolss,
2386                                 NDR_SPOOLSS_DELETEPRINTPROVIDOR,
2387                                 &r);
2388
2389         if (!NT_STATUS_IS_OK(status)) {
2390                 return status;
2391         }
2392
2393         if (DEBUGLEVEL >= 10) {
2394                 NDR_PRINT_OUT_DEBUG(spoolss_DeletePrintProvidor, &r);
2395         }
2396
2397         if (NT_STATUS_IS_ERR(status)) {
2398                 return status;
2399         }
2400
2401         /* Return variables */
2402
2403         /* Return result */
2404         if (werror) {
2405                 *werror = r.out.result;
2406         }
2407
2408         return werror_to_ntstatus(r.out.result);
2409 }
2410
2411 NTSTATUS rpccli_spoolss_EnumPrintProcDataTypes(struct rpc_pipe_client *cli,
2412                                                TALLOC_CTX *mem_ctx,
2413                                                WERROR *werror)
2414 {
2415         struct spoolss_EnumPrintProcDataTypes r;
2416         NTSTATUS status;
2417
2418         /* In parameters */
2419
2420         if (DEBUGLEVEL >= 10) {
2421                 NDR_PRINT_IN_DEBUG(spoolss_EnumPrintProcDataTypes, &r);
2422         }
2423
2424         status = cli->dispatch(cli,
2425                                 mem_ctx,
2426                                 &ndr_table_spoolss,
2427                                 NDR_SPOOLSS_ENUMPRINTPROCDATATYPES,
2428                                 &r);
2429
2430         if (!NT_STATUS_IS_OK(status)) {
2431                 return status;
2432         }
2433
2434         if (DEBUGLEVEL >= 10) {
2435                 NDR_PRINT_OUT_DEBUG(spoolss_EnumPrintProcDataTypes, &r);
2436         }
2437
2438         if (NT_STATUS_IS_ERR(status)) {
2439                 return status;
2440         }
2441
2442         /* Return variables */
2443
2444         /* Return result */
2445         if (werror) {
2446                 *werror = r.out.result;
2447         }
2448
2449         return werror_to_ntstatus(r.out.result);
2450 }
2451
2452 NTSTATUS rpccli_spoolss_ResetPrinter(struct rpc_pipe_client *cli,
2453                                      TALLOC_CTX *mem_ctx,
2454                                      WERROR *werror)
2455 {
2456         struct spoolss_ResetPrinter r;
2457         NTSTATUS status;
2458
2459         /* In parameters */
2460
2461         if (DEBUGLEVEL >= 10) {
2462                 NDR_PRINT_IN_DEBUG(spoolss_ResetPrinter, &r);
2463         }
2464
2465         status = cli->dispatch(cli,
2466                                 mem_ctx,
2467                                 &ndr_table_spoolss,
2468                                 NDR_SPOOLSS_RESETPRINTER,
2469                                 &r);
2470
2471         if (!NT_STATUS_IS_OK(status)) {
2472                 return status;
2473         }
2474
2475         if (DEBUGLEVEL >= 10) {
2476                 NDR_PRINT_OUT_DEBUG(spoolss_ResetPrinter, &r);
2477         }
2478
2479         if (NT_STATUS_IS_ERR(status)) {
2480                 return status;
2481         }
2482
2483         /* Return variables */
2484
2485         /* Return result */
2486         if (werror) {
2487                 *werror = r.out.result;
2488         }
2489
2490         return werror_to_ntstatus(r.out.result);
2491 }
2492
2493 NTSTATUS rpccli_spoolss_GetPrinterDriver2(struct rpc_pipe_client *cli,
2494                                           TALLOC_CTX *mem_ctx,
2495                                           struct policy_handle *handle /* [in] [ref] */,
2496                                           const char *architecture /* [in] [unique,charset(UTF16)] */,
2497                                           uint32_t level /* [in]  */,
2498                                           DATA_BLOB *buffer /* [in] [unique] */,
2499                                           uint32_t offered /* [in]  */,
2500                                           uint32_t client_major_version /* [in]  */,
2501                                           uint32_t client_minor_version /* [in]  */,
2502                                           DATA_BLOB *info /* [out] [unique] */,
2503                                           uint32_t *needed /* [out] [ref] */,
2504                                           uint32_t *server_major_version /* [out] [ref] */,
2505                                           uint32_t *server_minor_version /* [out] [ref] */,
2506                                           WERROR *werror)
2507 {
2508         struct spoolss_GetPrinterDriver2 r;
2509         NTSTATUS status;
2510
2511         /* In parameters */
2512         r.in.handle = handle;
2513         r.in.architecture = architecture;
2514         r.in.level = level;
2515         r.in.buffer = buffer;
2516         r.in.offered = offered;
2517         r.in.client_major_version = client_major_version;
2518         r.in.client_minor_version = client_minor_version;
2519
2520         if (DEBUGLEVEL >= 10) {
2521                 NDR_PRINT_IN_DEBUG(spoolss_GetPrinterDriver2, &r);
2522         }
2523
2524         status = cli->dispatch(cli,
2525                                 mem_ctx,
2526                                 &ndr_table_spoolss,
2527                                 NDR_SPOOLSS_GETPRINTERDRIVER2,
2528                                 &r);
2529
2530         if (!NT_STATUS_IS_OK(status)) {
2531                 return status;
2532         }
2533
2534         if (DEBUGLEVEL >= 10) {
2535                 NDR_PRINT_OUT_DEBUG(spoolss_GetPrinterDriver2, &r);
2536         }
2537
2538         if (NT_STATUS_IS_ERR(status)) {
2539                 return status;
2540         }
2541
2542         /* Return variables */
2543         if (info && r.out.info) {
2544                 *info = *r.out.info;
2545         }
2546         *needed = *r.out.needed;
2547         *server_major_version = *r.out.server_major_version;
2548         *server_minor_version = *r.out.server_minor_version;
2549
2550         /* Return result */
2551         if (werror) {
2552                 *werror = r.out.result;
2553         }
2554
2555         return werror_to_ntstatus(r.out.result);
2556 }
2557
2558 NTSTATUS rpccli_spoolss_FindFirstPrinterChangeNotification(struct rpc_pipe_client *cli,
2559                                                            TALLOC_CTX *mem_ctx,
2560                                                            WERROR *werror)
2561 {
2562         struct spoolss_FindFirstPrinterChangeNotification r;
2563         NTSTATUS status;
2564
2565         /* In parameters */
2566
2567         if (DEBUGLEVEL >= 10) {
2568                 NDR_PRINT_IN_DEBUG(spoolss_FindFirstPrinterChangeNotification, &r);
2569         }
2570
2571         status = cli->dispatch(cli,
2572                                 mem_ctx,
2573                                 &ndr_table_spoolss,
2574                                 NDR_SPOOLSS_FINDFIRSTPRINTERCHANGENOTIFICATION,
2575                                 &r);
2576
2577         if (!NT_STATUS_IS_OK(status)) {
2578                 return status;
2579         }
2580
2581         if (DEBUGLEVEL >= 10) {
2582                 NDR_PRINT_OUT_DEBUG(spoolss_FindFirstPrinterChangeNotification, &r);
2583         }
2584
2585         if (NT_STATUS_IS_ERR(status)) {
2586                 return status;
2587         }
2588
2589         /* Return variables */
2590
2591         /* Return result */
2592         if (werror) {
2593                 *werror = r.out.result;
2594         }
2595
2596         return werror_to_ntstatus(r.out.result);
2597 }
2598
2599 NTSTATUS rpccli_spoolss_FindNextPrinterChangeNotification(struct rpc_pipe_client *cli,
2600                                                           TALLOC_CTX *mem_ctx,
2601                                                           WERROR *werror)
2602 {
2603         struct spoolss_FindNextPrinterChangeNotification r;
2604         NTSTATUS status;
2605
2606         /* In parameters */
2607
2608         if (DEBUGLEVEL >= 10) {
2609                 NDR_PRINT_IN_DEBUG(spoolss_FindNextPrinterChangeNotification, &r);
2610         }
2611
2612         status = cli->dispatch(cli,
2613                                 mem_ctx,
2614                                 &ndr_table_spoolss,
2615                                 NDR_SPOOLSS_FINDNEXTPRINTERCHANGENOTIFICATION,
2616                                 &r);
2617
2618         if (!NT_STATUS_IS_OK(status)) {
2619                 return status;
2620         }
2621
2622         if (DEBUGLEVEL >= 10) {
2623                 NDR_PRINT_OUT_DEBUG(spoolss_FindNextPrinterChangeNotification, &r);
2624         }
2625
2626         if (NT_STATUS_IS_ERR(status)) {
2627                 return status;
2628         }
2629
2630         /* Return variables */
2631
2632         /* Return result */
2633         if (werror) {
2634                 *werror = r.out.result;
2635         }
2636
2637         return werror_to_ntstatus(r.out.result);
2638 }
2639
2640 NTSTATUS rpccli_spoolss_FindClosePrinterNotify(struct rpc_pipe_client *cli,
2641                                                TALLOC_CTX *mem_ctx,
2642                                                struct policy_handle *handle /* [in] [ref] */,
2643                                                WERROR *werror)
2644 {
2645         struct spoolss_FindClosePrinterNotify r;
2646         NTSTATUS status;
2647
2648         /* In parameters */
2649         r.in.handle = handle;
2650
2651         if (DEBUGLEVEL >= 10) {
2652                 NDR_PRINT_IN_DEBUG(spoolss_FindClosePrinterNotify, &r);
2653         }
2654
2655         status = cli->dispatch(cli,
2656                                 mem_ctx,
2657                                 &ndr_table_spoolss,
2658                                 NDR_SPOOLSS_FINDCLOSEPRINTERNOTIFY,
2659                                 &r);
2660
2661         if (!NT_STATUS_IS_OK(status)) {
2662                 return status;
2663         }
2664
2665         if (DEBUGLEVEL >= 10) {
2666                 NDR_PRINT_OUT_DEBUG(spoolss_FindClosePrinterNotify, &r);
2667         }
2668
2669         if (NT_STATUS_IS_ERR(status)) {
2670                 return status;
2671         }
2672
2673         /* Return variables */
2674
2675         /* Return result */
2676         if (werror) {
2677                 *werror = r.out.result;
2678         }
2679
2680         return werror_to_ntstatus(r.out.result);
2681 }
2682
2683 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct rpc_pipe_client *cli,
2684                                                                     TALLOC_CTX *mem_ctx,
2685                                                                     WERROR *werror)
2686 {
2687         struct spoolss_RouterFindFirstPrinterChangeNotificationOld r;
2688         NTSTATUS status;
2689
2690         /* In parameters */
2691
2692         if (DEBUGLEVEL >= 10) {
2693                 NDR_PRINT_IN_DEBUG(spoolss_RouterFindFirstPrinterChangeNotificationOld, &r);
2694         }
2695
2696         status = cli->dispatch(cli,
2697                                 mem_ctx,
2698                                 &ndr_table_spoolss,
2699                                 NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATIONOLD,
2700                                 &r);
2701
2702         if (!NT_STATUS_IS_OK(status)) {
2703                 return status;
2704         }
2705
2706         if (DEBUGLEVEL >= 10) {
2707                 NDR_PRINT_OUT_DEBUG(spoolss_RouterFindFirstPrinterChangeNotificationOld, &r);
2708         }
2709
2710         if (NT_STATUS_IS_ERR(status)) {
2711                 return status;
2712         }
2713
2714         /* Return variables */
2715
2716         /* Return result */
2717         if (werror) {
2718                 *werror = r.out.result;
2719         }
2720
2721         return werror_to_ntstatus(r.out.result);
2722 }
2723
2724 NTSTATUS rpccli_spoolss_ReplyOpenPrinter(struct rpc_pipe_client *cli,
2725                                          TALLOC_CTX *mem_ctx,
2726                                          const char *server_name /* [in] [charset(UTF16)] */,
2727                                          uint32_t printer_local /* [in]  */,
2728                                          enum winreg_Type type /* [in]  */,
2729                                          uint32_t unknown1 /* [in]  */,
2730                                          uint32_t unknown2 /* [in]  */,
2731                                          struct policy_handle *handle /* [out] [ref] */,
2732                                          WERROR *werror)
2733 {
2734         struct spoolss_ReplyOpenPrinter r;
2735         NTSTATUS status;
2736
2737         /* In parameters */
2738         r.in.server_name = server_name;
2739         r.in.printer_local = printer_local;
2740         r.in.type = type;
2741         r.in.unknown1 = unknown1;
2742         r.in.unknown2 = unknown2;
2743
2744         if (DEBUGLEVEL >= 10) {
2745                 NDR_PRINT_IN_DEBUG(spoolss_ReplyOpenPrinter, &r);
2746         }
2747
2748         status = cli->dispatch(cli,
2749                                 mem_ctx,
2750                                 &ndr_table_spoolss,
2751                                 NDR_SPOOLSS_REPLYOPENPRINTER,
2752                                 &r);
2753
2754         if (!NT_STATUS_IS_OK(status)) {
2755                 return status;
2756         }
2757
2758         if (DEBUGLEVEL >= 10) {
2759                 NDR_PRINT_OUT_DEBUG(spoolss_ReplyOpenPrinter, &r);
2760         }
2761
2762         if (NT_STATUS_IS_ERR(status)) {
2763                 return status;
2764         }
2765
2766         /* Return variables */
2767         *handle = *r.out.handle;
2768
2769         /* Return result */
2770         if (werror) {
2771                 *werror = r.out.result;
2772         }
2773
2774         return werror_to_ntstatus(r.out.result);
2775 }
2776
2777 NTSTATUS rpccli_spoolss_RouterReplyPrinter(struct rpc_pipe_client *cli,
2778                                            TALLOC_CTX *mem_ctx,
2779                                            struct policy_handle *handle /* [in] [ref] */,
2780                                            uint32_t flags /* [in]  */,
2781                                            uint32_t bufsize /* [in] [range(0,512)] */,
2782                                            uint8_t *buffer /* [in] [unique,size_is(bufsize)] */,
2783                                            WERROR *werror)
2784 {
2785         struct spoolss_RouterReplyPrinter r;
2786         NTSTATUS status;
2787
2788         /* In parameters */
2789         r.in.handle = handle;
2790         r.in.flags = flags;
2791         r.in.bufsize = bufsize;
2792         r.in.buffer = buffer;
2793
2794         if (DEBUGLEVEL >= 10) {
2795                 NDR_PRINT_IN_DEBUG(spoolss_RouterReplyPrinter, &r);
2796         }
2797
2798         status = cli->dispatch(cli,
2799                                 mem_ctx,
2800                                 &ndr_table_spoolss,
2801                                 NDR_SPOOLSS_ROUTERREPLYPRINTER,
2802                                 &r);
2803
2804         if (!NT_STATUS_IS_OK(status)) {
2805                 return status;
2806         }
2807
2808         if (DEBUGLEVEL >= 10) {
2809                 NDR_PRINT_OUT_DEBUG(spoolss_RouterReplyPrinter, &r);
2810         }
2811
2812         if (NT_STATUS_IS_ERR(status)) {
2813                 return status;
2814         }
2815
2816         /* Return variables */
2817
2818         /* Return result */
2819         if (werror) {
2820                 *werror = r.out.result;
2821         }
2822
2823         return werror_to_ntstatus(r.out.result);
2824 }
2825
2826 NTSTATUS rpccli_spoolss_ReplyClosePrinter(struct rpc_pipe_client *cli,
2827                                           TALLOC_CTX *mem_ctx,
2828                                           struct policy_handle *handle /* [in,out] [ref] */,
2829                                           WERROR *werror)
2830 {
2831         struct spoolss_ReplyClosePrinter r;
2832         NTSTATUS status;
2833
2834         /* In parameters */
2835         r.in.handle = handle;
2836
2837         if (DEBUGLEVEL >= 10) {
2838                 NDR_PRINT_IN_DEBUG(spoolss_ReplyClosePrinter, &r);
2839         }
2840
2841         status = cli->dispatch(cli,
2842                                 mem_ctx,
2843                                 &ndr_table_spoolss,
2844                                 NDR_SPOOLSS_REPLYCLOSEPRINTER,
2845                                 &r);
2846
2847         if (!NT_STATUS_IS_OK(status)) {
2848                 return status;
2849         }
2850
2851         if (DEBUGLEVEL >= 10) {
2852                 NDR_PRINT_OUT_DEBUG(spoolss_ReplyClosePrinter, &r);
2853         }
2854
2855         if (NT_STATUS_IS_ERR(status)) {
2856                 return status;
2857         }
2858
2859         /* Return variables */
2860         *handle = *r.out.handle;
2861
2862         /* Return result */
2863         if (werror) {
2864                 *werror = r.out.result;
2865         }
2866
2867         return werror_to_ntstatus(r.out.result);
2868 }
2869
2870 NTSTATUS rpccli_spoolss_AddPortEx(struct rpc_pipe_client *cli,
2871                                   TALLOC_CTX *mem_ctx,
2872                                   WERROR *werror)
2873 {
2874         struct spoolss_AddPortEx r;
2875         NTSTATUS status;
2876
2877         /* In parameters */
2878
2879         if (DEBUGLEVEL >= 10) {
2880                 NDR_PRINT_IN_DEBUG(spoolss_AddPortEx, &r);
2881         }
2882
2883         status = cli->dispatch(cli,
2884                                 mem_ctx,
2885                                 &ndr_table_spoolss,
2886                                 NDR_SPOOLSS_ADDPORTEX,
2887                                 &r);
2888
2889         if (!NT_STATUS_IS_OK(status)) {
2890                 return status;
2891         }
2892
2893         if (DEBUGLEVEL >= 10) {
2894                 NDR_PRINT_OUT_DEBUG(spoolss_AddPortEx, &r);
2895         }
2896
2897         if (NT_STATUS_IS_ERR(status)) {
2898                 return status;
2899         }
2900
2901         /* Return variables */
2902
2903         /* Return result */
2904         if (werror) {
2905                 *werror = r.out.result;
2906         }
2907
2908         return werror_to_ntstatus(r.out.result);
2909 }
2910
2911 NTSTATUS rpccli_spoolss_RouterFindFirstPrinterChangeNotification(struct rpc_pipe_client *cli,
2912                                                                  TALLOC_CTX *mem_ctx,
2913                                                                  WERROR *werror)
2914 {
2915         struct spoolss_RouterFindFirstPrinterChangeNotification r;
2916         NTSTATUS status;
2917
2918         /* In parameters */
2919
2920         if (DEBUGLEVEL >= 10) {
2921                 NDR_PRINT_IN_DEBUG(spoolss_RouterFindFirstPrinterChangeNotification, &r);
2922         }
2923
2924         status = cli->dispatch(cli,
2925                                 mem_ctx,
2926                                 &ndr_table_spoolss,
2927                                 NDR_SPOOLSS_ROUTERFINDFIRSTPRINTERCHANGENOTIFICATION,
2928                                 &r);
2929
2930         if (!NT_STATUS_IS_OK(status)) {
2931                 return status;
2932         }
2933
2934         if (DEBUGLEVEL >= 10) {
2935                 NDR_PRINT_OUT_DEBUG(spoolss_RouterFindFirstPrinterChangeNotification, &r);
2936         }
2937
2938         if (NT_STATUS_IS_ERR(status)) {
2939                 return status;
2940         }
2941
2942         /* Return variables */
2943
2944         /* Return result */
2945         if (werror) {
2946                 *werror = r.out.result;
2947         }
2948
2949         return werror_to_ntstatus(r.out.result);
2950 }
2951
2952 NTSTATUS rpccli_spoolss_SpoolerInit(struct rpc_pipe_client *cli,
2953                                     TALLOC_CTX *mem_ctx,
2954                                     WERROR *werror)
2955 {
2956         struct spoolss_SpoolerInit r;
2957         NTSTATUS status;
2958
2959         /* In parameters */
2960
2961         if (DEBUGLEVEL >= 10) {
2962                 NDR_PRINT_IN_DEBUG(spoolss_SpoolerInit, &r);
2963         }
2964
2965         status = cli->dispatch(cli,
2966                                 mem_ctx,
2967                                 &ndr_table_spoolss,
2968                                 NDR_SPOOLSS_SPOOLERINIT,
2969                                 &r);
2970
2971         if (!NT_STATUS_IS_OK(status)) {
2972                 return status;
2973         }
2974
2975         if (DEBUGLEVEL >= 10) {
2976                 NDR_PRINT_OUT_DEBUG(spoolss_SpoolerInit, &r);
2977         }
2978
2979         if (NT_STATUS_IS_ERR(status)) {
2980                 return status;
2981         }
2982
2983         /* Return variables */
2984
2985         /* Return result */
2986         if (werror) {
2987                 *werror = r.out.result;
2988         }
2989
2990         return werror_to_ntstatus(r.out.result);
2991 }
2992
2993 NTSTATUS rpccli_spoolss_ResetPrinterEx(struct rpc_pipe_client *cli,
2994                                        TALLOC_CTX *mem_ctx,
2995                                        WERROR *werror)
2996 {
2997         struct spoolss_ResetPrinterEx r;
2998         NTSTATUS status;
2999
3000         /* In parameters */
3001
3002         if (DEBUGLEVEL >= 10) {
3003                 NDR_PRINT_IN_DEBUG(spoolss_ResetPrinterEx, &r);
3004         }
3005
3006         status = cli->dispatch(cli,
3007                                 mem_ctx,
3008                                 &ndr_table_spoolss,
3009                                 NDR_SPOOLSS_RESETPRINTEREX,
3010                                 &r);
3011
3012         if (!NT_STATUS_IS_OK(status)) {
3013                 return status;
3014         }
3015
3016         if (DEBUGLEVEL >= 10) {
3017                 NDR_PRINT_OUT_DEBUG(spoolss_ResetPrinterEx, &r);
3018         }
3019
3020         if (NT_STATUS_IS_ERR(status)) {
3021                 return status;
3022         }
3023
3024         /* Return variables */
3025
3026         /* Return result */
3027         if (werror) {
3028                 *werror = r.out.result;
3029         }
3030
3031         return werror_to_ntstatus(r.out.result);
3032 }
3033
3034 NTSTATUS rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct rpc_pipe_client *cli,
3035                                                              TALLOC_CTX *mem_ctx,
3036                                                              struct policy_handle *handle /* [in] [ref] */,
3037                                                              uint32_t flags /* [in]  */,
3038                                                              uint32_t options /* [in]  */,
3039                                                              const char *str /* [in] [unique,charset(UTF16)] */,
3040                                                              uint32_t printer_local /* [in]  */,
3041                                                              struct spoolss_NotifyOptionsContainer *t1 /* [in] [unique] */,
3042                                                              WERROR *werror)
3043 {
3044         struct spoolss_RemoteFindFirstPrinterChangeNotifyEx r;
3045         NTSTATUS status;
3046
3047         /* In parameters */
3048         r.in.handle = handle;
3049         r.in.flags = flags;
3050         r.in.options = options;
3051         r.in.str = str;
3052         r.in.printer_local = printer_local;
3053         r.in.t1 = t1;
3054
3055         if (DEBUGLEVEL >= 10) {
3056                 NDR_PRINT_IN_DEBUG(spoolss_RemoteFindFirstPrinterChangeNotifyEx, &r);
3057         }
3058
3059         status = cli->dispatch(cli,
3060                                 mem_ctx,
3061                                 &ndr_table_spoolss,
3062                                 NDR_SPOOLSS_REMOTEFINDFIRSTPRINTERCHANGENOTIFYEX,
3063                                 &r);
3064
3065         if (!NT_STATUS_IS_OK(status)) {
3066                 return status;
3067         }
3068
3069         if (DEBUGLEVEL >= 10) {
3070                 NDR_PRINT_OUT_DEBUG(spoolss_RemoteFindFirstPrinterChangeNotifyEx, &r);
3071         }
3072
3073         if (NT_STATUS_IS_ERR(status)) {
3074                 return status;
3075         }
3076
3077         /* Return variables */
3078
3079         /* Return result */
3080         if (werror) {
3081                 *werror = r.out.result;
3082         }
3083
3084         return werror_to_ntstatus(r.out.result);
3085 }
3086
3087 NTSTATUS rpccli_spoolss_RouterRefreshPrinterChangeNotification(struct rpc_pipe_client *cli,
3088                                                                TALLOC_CTX *mem_ctx,
3089                                                                WERROR *werror)
3090 {
3091         struct spoolss_RouterRefreshPrinterChangeNotification r;
3092         NTSTATUS status;
3093
3094         /* In parameters */
3095
3096         if (DEBUGLEVEL >= 10) {
3097                 NDR_PRINT_IN_DEBUG(spoolss_RouterRefreshPrinterChangeNotification, &r);
3098         }
3099
3100         status = cli->dispatch(cli,
3101                                 mem_ctx,
3102                                 &ndr_table_spoolss,
3103                                 NDR_SPOOLSS_ROUTERREFRESHPRINTERCHANGENOTIFICATION,
3104                                 &r);
3105
3106         if (!NT_STATUS_IS_OK(status)) {
3107                 return status;
3108         }
3109
3110         if (DEBUGLEVEL >= 10) {
3111                 NDR_PRINT_OUT_DEBUG(spoolss_RouterRefreshPrinterChangeNotification, &r);
3112         }
3113
3114         if (NT_STATUS_IS_ERR(status)) {
3115                 return status;
3116         }
3117
3118         /* Return variables */
3119
3120         /* Return result */
3121         if (werror) {
3122                 *werror = r.out.result;
3123         }
3124
3125         return werror_to_ntstatus(r.out.result);
3126 }
3127
3128 NTSTATUS rpccli_spoolss_RemoteFindNextPrinterChangeNotifyEx(struct rpc_pipe_client *cli,
3129                                                             TALLOC_CTX *mem_ctx,
3130                                                             struct policy_handle *handle /* [in] [ref] */,
3131                                                             uint32_t change_low /* [in]  */,
3132                                                             struct spoolss_NotifyOptionsContainer *container /* [in] [unique] */,
3133                                                             struct spoolss_NotifyInfo **info /* [out] [ref] */,
3134                                                             WERROR *werror)
3135 {
3136         struct spoolss_RemoteFindNextPrinterChangeNotifyEx r;
3137         NTSTATUS status;
3138
3139         /* In parameters */
3140         r.in.handle = handle;
3141         r.in.change_low = change_low;
3142         r.in.container = container;
3143
3144         if (DEBUGLEVEL >= 10) {
3145                 NDR_PRINT_IN_DEBUG(spoolss_RemoteFindNextPrinterChangeNotifyEx, &r);
3146         }
3147
3148         status = cli->dispatch(cli,
3149                                 mem_ctx,
3150                                 &ndr_table_spoolss,
3151                                 NDR_SPOOLSS_REMOTEFINDNEXTPRINTERCHANGENOTIFYEX,
3152                                 &r);
3153
3154         if (!NT_STATUS_IS_OK(status)) {
3155                 return status;
3156         }
3157
3158         if (DEBUGLEVEL >= 10) {
3159                 NDR_PRINT_OUT_DEBUG(spoolss_RemoteFindNextPrinterChangeNotifyEx, &r);
3160         }
3161
3162         if (NT_STATUS_IS_ERR(status)) {
3163                 return status;
3164         }
3165
3166         /* Return variables */
3167         *info = *r.out.info;
3168
3169         /* Return result */
3170         if (werror) {
3171                 *werror = r.out.result;
3172         }
3173
3174         return werror_to_ntstatus(r.out.result);
3175 }
3176
3177 NTSTATUS rpccli_spoolss_44(struct rpc_pipe_client *cli,
3178                            TALLOC_CTX *mem_ctx,
3179                            WERROR *werror)
3180 {
3181         struct spoolss_44 r;
3182         NTSTATUS status;
3183
3184         /* In parameters */
3185
3186         if (DEBUGLEVEL >= 10) {
3187                 NDR_PRINT_IN_DEBUG(spoolss_44, &r);
3188         }
3189
3190         status = cli->dispatch(cli,
3191                                 mem_ctx,
3192                                 &ndr_table_spoolss,
3193                                 NDR_SPOOLSS_44,
3194                                 &r);
3195
3196         if (!NT_STATUS_IS_OK(status)) {
3197                 return status;
3198         }
3199
3200         if (DEBUGLEVEL >= 10) {
3201                 NDR_PRINT_OUT_DEBUG(spoolss_44, &r);
3202         }
3203
3204         if (NT_STATUS_IS_ERR(status)) {
3205                 return status;
3206         }
3207
3208         /* Return variables */
3209
3210         /* Return result */
3211         if (werror) {
3212                 *werror = r.out.result;
3213         }
3214
3215         return werror_to_ntstatus(r.out.result);
3216 }
3217
3218 NTSTATUS rpccli_spoolss_OpenPrinterEx(struct rpc_pipe_client *cli,
3219                                       TALLOC_CTX *mem_ctx,
3220                                       const char *printername /* [in] [unique,charset(UTF16)] */,
3221                                       const char *datatype /* [in] [unique,charset(UTF16)] */,
3222                                       struct spoolss_DevmodeContainer devmode_ctr /* [in]  */,
3223                                       uint32_t access_mask /* [in]  */,
3224                                       uint32_t level /* [in]  */,
3225                                       union spoolss_UserLevel userlevel /* [in] [switch_is(level)] */,
3226                                       struct policy_handle *handle /* [out] [ref] */,
3227                                       WERROR *werror)
3228 {
3229         struct spoolss_OpenPrinterEx r;
3230         NTSTATUS status;
3231
3232         /* In parameters */
3233         r.in.printername = printername;
3234         r.in.datatype = datatype;
3235         r.in.devmode_ctr = devmode_ctr;
3236         r.in.access_mask = access_mask;
3237         r.in.level = level;
3238         r.in.userlevel = userlevel;
3239
3240         if (DEBUGLEVEL >= 10) {
3241                 NDR_PRINT_IN_DEBUG(spoolss_OpenPrinterEx, &r);
3242         }
3243
3244         status = cli->dispatch(cli,
3245                                 mem_ctx,
3246                                 &ndr_table_spoolss,
3247                                 NDR_SPOOLSS_OPENPRINTEREX,
3248                                 &r);
3249
3250         if (!NT_STATUS_IS_OK(status)) {
3251                 return status;
3252         }
3253
3254         if (DEBUGLEVEL >= 10) {
3255                 NDR_PRINT_OUT_DEBUG(spoolss_OpenPrinterEx, &r);
3256         }
3257
3258         if (NT_STATUS_IS_ERR(status)) {
3259                 return status;
3260         }
3261
3262         /* Return variables */
3263         *handle = *r.out.handle;
3264
3265         /* Return result */
3266         if (werror) {
3267                 *werror = r.out.result;
3268         }
3269
3270         return werror_to_ntstatus(r.out.result);
3271 }
3272
3273 NTSTATUS rpccli_spoolss_AddPrinterEx(struct rpc_pipe_client *cli,
3274                                      TALLOC_CTX *mem_ctx,
3275                                      const char *server /* [in] [unique,charset(UTF16)] */,
3276                                      uint32_t level /* [in]  */,
3277                                      union spoolss_PrinterInfo *info /* [in] [unique,switch_is(level)] */,
3278                                      struct spoolss_DevmodeContainer devmode_ctr /* [in]  */,
3279                                      struct security_descriptor *secdesc /* [in] [unique] */,
3280                                      uint32_t ulevel /* [in]  */,
3281                                      union spoolss_UserLevel userlevel /* [in] [switch_is(ulevel)] */,
3282                                      WERROR *werror)
3283 {
3284         struct spoolss_AddPrinterEx r;
3285         NTSTATUS status;
3286
3287         /* In parameters */
3288         r.in.server = server;
3289         r.in.level = level;
3290         r.in.info = info;
3291         r.in.devmode_ctr = devmode_ctr;
3292         r.in.secdesc = secdesc;
3293         r.in.ulevel = ulevel;
3294         r.in.userlevel = userlevel;
3295
3296         if (DEBUGLEVEL >= 10) {
3297                 NDR_PRINT_IN_DEBUG(spoolss_AddPrinterEx, &r);
3298         }
3299
3300         status = cli->dispatch(cli,
3301                                 mem_ctx,
3302                                 &ndr_table_spoolss,
3303                                 NDR_SPOOLSS_ADDPRINTEREX,
3304                                 &r);
3305
3306         if (!NT_STATUS_IS_OK(status)) {
3307                 return status;
3308         }
3309
3310         if (DEBUGLEVEL >= 10) {
3311                 NDR_PRINT_OUT_DEBUG(spoolss_AddPrinterEx, &r);
3312         }
3313
3314         if (NT_STATUS_IS_ERR(status)) {
3315                 return status;
3316         }
3317
3318         /* Return variables */
3319
3320         /* Return result */
3321         if (werror) {
3322                 *werror = r.out.result;
3323         }
3324
3325         return werror_to_ntstatus(r.out.result);
3326 }
3327
3328 NTSTATUS rpccli_spoolss_47(struct rpc_pipe_client *cli,
3329                            TALLOC_CTX *mem_ctx,
3330                            WERROR *werror)
3331 {
3332         struct spoolss_47 r;
3333         NTSTATUS status;
3334
3335         /* In parameters */
3336
3337         if (DEBUGLEVEL >= 10) {
3338                 NDR_PRINT_IN_DEBUG(spoolss_47, &r);
3339         }
3340
3341         status = cli->dispatch(cli,
3342                                 mem_ctx,
3343                                 &ndr_table_spoolss,
3344                                 NDR_SPOOLSS_47,
3345                                 &r);
3346
3347         if (!NT_STATUS_IS_OK(status)) {
3348                 return status;
3349         }
3350
3351         if (DEBUGLEVEL >= 10) {
3352                 NDR_PRINT_OUT_DEBUG(spoolss_47, &r);
3353         }
3354
3355         if (NT_STATUS_IS_ERR(status)) {
3356                 return status;
3357         }
3358
3359         /* Return variables */
3360
3361         /* Return result */
3362         if (werror) {
3363                 *werror = r.out.result;
3364         }
3365
3366         return werror_to_ntstatus(r.out.result);
3367 }
3368
3369 NTSTATUS rpccli_spoolss_EnumPrinterData(struct rpc_pipe_client *cli,
3370                                         TALLOC_CTX *mem_ctx,
3371                                         struct policy_handle *handle /* [in] [ref] */,
3372                                         uint32_t enum_index /* [in]  */,
3373                                         const char *value_name /* [out] [ref,charset(UTF16),size_is(value_offered/2)] */,
3374                                         uint32_t value_offered /* [in]  */,
3375                                         uint32_t *value_needed /* [out] [ref] */,
3376                             &