?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make 3.0.x in sync with 3.2 here.
[Samba.git] / source / rpc_client / cli_spoolss.c
blob76a5e0b8ad48423960e689bb4bdf6e67dc0b6dcd
1 /*
2 Unix SMB/CIFS implementation.
3 RPC pipe client
4
5 Copyright (C) Gerald Carter 2001-2005,
6 Copyright (C) Tim Potter 2000-2002,
7 Copyright (C) Andrew Tridgell 1994-2000,
8 Copyright (C) Jean-Francois Micouleau 1999-2000.
9 Copyright (C) Jeremy Allison 2005.
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 */
25
26 #include "includes.h"
27 #include "rpc_client.h"
28
29 /*********************************************************************
30 Decode various spoolss rpc's and info levels
31 ********************************************************************/
32
33 /**********************************************************************
34 **********************************************************************/
35
36 static BOOL decode_printer_info_0(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
37 uint32 returned, PRINTER_INFO_0 **info)
38 {
39 uint32 i;
40 PRINTER_INFO_0 *inf;
41
42 if (returned) {
43 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_0, returned);
44 if (!inf) {
45 return False;
46 }
47 memset(inf, 0, returned*sizeof(PRINTER_INFO_0));
48 } else {
49 inf = NULL;
50 }
51
52 prs_set_offset(&buffer->prs,0);
53
54 for (i=0; i<returned; i++) {
55 if (!smb_io_printer_info_0("", buffer, &inf[i], 0)) {
56 return False;
57 }
58 }
59
60 *info=inf;
61 return True;
62 }
63
64 /**********************************************************************
65 **********************************************************************/
66
67 static BOOL decode_printer_info_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
68 uint32 returned, PRINTER_INFO_1 **info)
69 {
70 uint32 i;
71 PRINTER_INFO_1 *inf;
72
73 if (returned) {
74 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_1, returned);
75 if (!inf) {
76 return False;
77 }
78 memset(inf, 0, returned*sizeof(PRINTER_INFO_1));
79 } else {
80 inf = NULL;
81 }
82
83 prs_set_offset(&buffer->prs,0);
84
85 for (i=0; i<returned; i++) {
86 if (!smb_io_printer_info_1("", buffer, &inf[i], 0)) {
87 return False;
88 }
89 }
90
91 *info=inf;
92 return True;
93 }
94
95 /**********************************************************************
96 **********************************************************************/
97
98 static BOOL decode_printer_info_2(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
99 uint32 returned, PRINTER_INFO_2 **info)
100 {
101 uint32 i;
102 PRINTER_INFO_2 *inf;
103
104 if (returned) {
105 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_2, returned);
106 if (!inf) {
107 return False;
108 }
109 memset(inf, 0, returned*sizeof(PRINTER_INFO_2));
110 } else {
111 inf = NULL;
112 }
113
114 prs_set_offset(&buffer->prs,0);
115
116 for (i=0; i<returned; i++) {
117 /* a little initialization as we go */
118 inf[i].secdesc = NULL;
119 if (!smb_io_printer_info_2("", buffer, &inf[i], 0)) {
120 return False;
121 }
122 }
123
124 *info=inf;
125 return True;
126 }
127
128 /**********************************************************************
129 **********************************************************************/
130
131 static BOOL decode_printer_info_3(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
132 uint32 returned, PRINTER_INFO_3 **info)
133 {
134 uint32 i;
135 PRINTER_INFO_3 *inf;
136
137 if (returned) {
138 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_3, returned);
139 if (!inf) {
140 return False;
141 }
142 memset(inf, 0, returned*sizeof(PRINTER_INFO_3));
143 } else {
144 inf = NULL;
145 }
146
147 prs_set_offset(&buffer->prs,0);
148
149 for (i=0; i<returned; i++) {
150 inf[i].secdesc = NULL;
151 if (!smb_io_printer_info_3("", buffer, &inf[i], 0)) {
152 return False;
153 }
154 }
155
156 *info=inf;
157 return True;
158 }
159
160 /**********************************************************************
161 **********************************************************************/
162
163 static BOOL decode_printer_info_7(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
164 uint32 returned, PRINTER_INFO_7 **info)
165 {
166 uint32 i;
167 PRINTER_INFO_7 *inf;
168
169 if (returned) {
170 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_7, returned);
171 if (!inf) {
172 return False;
173 }
174 memset(inf, 0, returned*sizeof(PRINTER_INFO_7));
175 } else {
176 inf = NULL;
177 }
178
179 prs_set_offset(&buffer->prs,0);
180
181 for (i=0; i<returned; i++) {
182 if (!smb_io_printer_info_7("", buffer, &inf[i], 0)) {
183 return False;
184 }
185 }
186
187 *info=inf;
188 return True;
189 }
190
191
192 /**********************************************************************
193 **********************************************************************/
194
195 static BOOL decode_port_info_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
196 uint32 returned, PORT_INFO_1 **info)
197 {
198 uint32 i;
199 PORT_INFO_1 *inf;
200
201 if (returned) {
202 inf=TALLOC_ARRAY(mem_ctx, PORT_INFO_1, returned);
203 if (!inf) {
204 return False;
205 }
206 memset(inf, 0, returned*sizeof(PORT_INFO_1));
207 } else {
208 inf = NULL;
209 }
210
211 prs_set_offset(&buffer->prs, 0);
212
213 for (i=0; i<returned; i++) {
214 if (!smb_io_port_info_1("", buffer, &(inf[i]), 0)) {
215 return False;
216 }
217 }
218
219 *info=inf;
220 return True;
221 }
222
223 /**********************************************************************
224 **********************************************************************/
225
226 static BOOL decode_port_info_2(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
227 uint32 returned, PORT_INFO_2 **info)
228 {
229 uint32 i;
230 PORT_INFO_2 *inf;
231
232 if (returned) {
233 inf=TALLOC_ARRAY(mem_ctx, PORT_INFO_2, returned);
234 if (!inf) {
235 return False;
236 }
237 memset(inf, 0, returned*sizeof(PORT_INFO_2));
238 } else {
239 inf = NULL;
240 }
241
242 prs_set_offset(&buffer->prs, 0);
243
244 for (i=0; i<returned; i++) {
245 if (!smb_io_port_info_2("", buffer, &(inf[i]), 0)) {
246 return False;
247 }
248 }
249
250 *info=inf;
251 return True;
252 }
253
254 /**********************************************************************
255 **********************************************************************/
256
257 static BOOL decode_printer_driver_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
258 uint32 returned, DRIVER_INFO_1 **info)
259 {
260 uint32 i;
261 DRIVER_INFO_1 *inf;
262
263 if (returned) {
264 inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_1, returned);
265 if (!inf) {
266 return False;
267 }
268 memset(inf, 0, returned*sizeof(DRIVER_INFO_1));
269 } else {
270 inf = NULL;
271 }
272
273 prs_set_offset(&buffer->prs,0);
274
275 for (i=0; i<returned; i++) {
276 if (!smb_io_printer_driver_info_1("", buffer, &(inf[i]), 0)) {
277 return False;
278 }
279 }
280
281 *info=inf;
282 return True;
283 }
284
285 /**********************************************************************
286 **********************************************************************/
287
288 static BOOL decode_printer_driver_2(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
289 uint32 returned, DRIVER_INFO_2 **info)
290 {
291 uint32 i;
292 DRIVER_INFO_2 *inf;
293
294 if (returned) {
295 inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_2, returned);
296 if (!inf) {
297 return False;
298 }
299 memset(inf, 0, returned*sizeof(DRIVER_INFO_2));
300 } else {
301 inf = NULL;
302 }
303
304 prs_set_offset(&buffer->prs,0);
305
306 for (i=0; i<returned; i++) {
307 if (!smb_io_printer_driver_info_2("", buffer, &(inf[i]), 0)) {
308 return False;
309 }
310 }
311
312 *info=inf;
313 return True;
314 }
315
316 /**********************************************************************
317 **********************************************************************/
318
319 static BOOL decode_printer_driver_3(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
320 uint32 returned, DRIVER_INFO_3 **info)
321 {
322 uint32 i;
323 DRIVER_INFO_3 *inf;
324
325 if (returned) {
326 inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_3, returned);
327 if (!inf) {
328 return False;
329 }
330 memset(inf, 0, returned*sizeof(DRIVER_INFO_3));
331 } else {
332 inf = NULL;
333 }
334
335 prs_set_offset(&buffer->prs,0);
336
337 for (i=0; i<returned; i++) {
338 if (!smb_io_printer_driver_info_3("", buffer, &(inf[i]), 0)) {
339 return False;
340 }
341 }
342
343 *info=inf;
344 return True;
345 }
346
347 /**********************************************************************
348 **********************************************************************/
349
350 static BOOL decode_printerdriverdir_1 (TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
351 uint32 returned, DRIVER_DIRECTORY_1 **info
352 )
353 {
354 DRIVER_DIRECTORY_1 *inf;
355
356 inf=TALLOC_P(mem_ctx, DRIVER_DIRECTORY_1);
357 if (!inf) {
358 return False;
359 }
360 memset(inf, 0, sizeof(DRIVER_DIRECTORY_1));
361
362 prs_set_offset(&buffer->prs, 0);
363
364 if (!smb_io_driverdir_1("", buffer, inf, 0)) {
365 return False;
366 }
367
368 *info=inf;
369 return True;
370 }
371
372 /**********************************************************************
373 **********************************************************************/
374
375 static BOOL decode_jobs_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
376 uint32 num_jobs, JOB_INFO_1 **jobs)
377 {
378 uint32 i;
379
380 if (num_jobs) {
381 *jobs = TALLOC_ARRAY(mem_ctx, JOB_INFO_1, num_jobs);
382 if (*jobs == NULL) {
383 return False;
384 }
385 } else {
386 *jobs = NULL;
387 }
388 prs_set_offset(&buffer->prs,0);
389
390 for (i = 0; i < num_jobs; i++) {
391 if (!smb_io_job_info_1("", buffer, &((*jobs)[i]), 0)) {
392 return False;
393 }
394 }
395
396 return True;
397 }
398
399 /**********************************************************************
400 **********************************************************************/
401
402 static BOOL decode_jobs_2(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
403 uint32 num_jobs, JOB_INFO_2 **jobs)
404 {
405 uint32 i;
406
407 if (num_jobs) {
408 *jobs = TALLOC_ARRAY(mem_ctx, JOB_INFO_2, num_jobs);
409 if (*jobs == NULL) {
410 return False;
411 }
412 } else {
413 *jobs = NULL;
414 }
415 prs_set_offset(&buffer->prs,0);
416
417 for (i = 0; i < num_jobs; i++) {
418 if (!smb_io_job_info_2("", buffer, &((*jobs)[i]), 0)) {
419 return False;
420 }
421 }
422
423 return True;
424 }
425
426 /**********************************************************************
427 **********************************************************************/
428
429 static BOOL decode_forms_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
430 uint32 num_forms, FORM_1 **forms)
431 {
432 int i;
433
434 if (num_forms) {
435 *forms = TALLOC_ARRAY(mem_ctx, FORM_1, num_forms);
436 if (*forms == NULL) {
437 return False;
438 }
439 } else {
440 *forms = NULL;
441 }
442
443 prs_set_offset(&buffer->prs,0);
444
445 for (i = 0; i < num_forms; i++) {
446 if (!smb_io_form_1("", buffer, &((*forms)[i]), 0)) {
447 return False;
448 }
449 }
450
451 return True;
452 }
453
454 /**********************************************************************
455 **********************************************************************/
456
457 WERROR rpccli_spoolss_open_printer_ex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
458 const char *printername, const char *datatype, uint32 access_required,
459 const char *station, const char *username, POLICY_HND *pol)
460 {
461 prs_struct qbuf, rbuf;
462 SPOOL_Q_OPEN_PRINTER_EX in;
463 SPOOL_R_OPEN_PRINTER_EX out;
464
465 ZERO_STRUCT(in);
466 ZERO_STRUCT(out);
467
468 make_spoolss_q_open_printer_ex( &in, printername, datatype,
469 access_required, station, username );
470
471 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_OPENPRINTEREX,
472 in, out,
473 qbuf, rbuf,
474 spoolss_io_q_open_printer_ex,
475 spoolss_io_r_open_printer_ex,
476 WERR_GENERAL_FAILURE );
477
478 memcpy( pol, &out.handle, sizeof(POLICY_HND) );
479
480 return out.status;
481 }
482
483 /**********************************************************************
484 **********************************************************************/
485
486 WERROR rpccli_spoolss_close_printer(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
487 POLICY_HND *pol)
488 {
489 prs_struct qbuf, rbuf;
490 SPOOL_Q_CLOSEPRINTER in;
491 SPOOL_R_CLOSEPRINTER out;
492
493 ZERO_STRUCT(in);
494 ZERO_STRUCT(out);
495
496 make_spoolss_q_closeprinter( &in, pol );
497
498 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_CLOSEPRINTER,
499 in, out,
500 qbuf, rbuf,
501 spoolss_io_q_closeprinter,
502 spoolss_io_r_closeprinter,
503 WERR_GENERAL_FAILURE );
504
505 return out.status;
506 }
507
508 /**********************************************************************
509 **********************************************************************/
510
511 WERROR rpccli_spoolss_enum_printers(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
512 char *name, uint32 flags, uint32 level,
513 uint32 *num_printers, PRINTER_INFO_CTR *ctr)
514 {
515 prs_struct qbuf, rbuf;
516 SPOOL_Q_ENUMPRINTERS in;
517 SPOOL_R_ENUMPRINTERS out;
518 RPC_BUFFER buffer;
519 uint32 offered;
520
521 ZERO_STRUCT(in);
522 ZERO_STRUCT(out);
523
524 offered = 0;
525 rpcbuf_init(&buffer, offered, mem_ctx);
526 make_spoolss_q_enumprinters( &in, flags, name, level, &buffer, offered );
527
528 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERS,
529 in, out,
530 qbuf, rbuf,
531 spoolss_io_q_enumprinters,
532 spoolss_io_r_enumprinters,
533 WERR_GENERAL_FAILURE );
534
535 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
536 offered = out.needed;
537
538 ZERO_STRUCT(in);
539 ZERO_STRUCT(out);
540
541 rpcbuf_init(&buffer, offered, mem_ctx);
542 make_spoolss_q_enumprinters( &in, flags, name, level, &buffer, offered );
543
544 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERS,
545 in, out,
546 qbuf, rbuf,
547 spoolss_io_q_enumprinters,
548 spoolss_io_r_enumprinters,
549 WERR_GENERAL_FAILURE );
550 }
551
552 if ( !W_ERROR_IS_OK(out.status) )
553 return out.status;
554
555 switch (level) {
556 case 0:
557 if (!decode_printer_info_0(mem_ctx, out.buffer, out.returned, &ctr->printers_0)) {
558 return WERR_GENERAL_FAILURE;
559 }
560 break;
561 case 1:
562 if (!decode_printer_info_1(mem_ctx, out.buffer, out.returned, &ctr->printers_1)) {
563 return WERR_GENERAL_FAILURE;
564 }
565 break;
566 case 2:
567 if (!decode_printer_info_2(mem_ctx, out.buffer, out.returned, &ctr->printers_2)) {
568 return WERR_GENERAL_FAILURE;
569 }
570 break;
571 case 3:
572 if (!decode_printer_info_3(mem_ctx, out.buffer, out.returned, &ctr->printers_3)) {
573 return WERR_GENERAL_FAILURE;
574 }
575 break;
576 default:
577 return WERR_UNKNOWN_LEVEL;
578 }
579
580 *num_printers = out.returned;
581
582 return out.status;
583 }
584
585 /**********************************************************************
586 **********************************************************************/
587
588 WERROR rpccli_spoolss_enum_ports(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
589 uint32 level, uint32 *num_ports, PORT_INFO_CTR *ctr)
590 {
591 prs_struct qbuf, rbuf;
592 SPOOL_Q_ENUMPORTS in;
593 SPOOL_R_ENUMPORTS out;
594 RPC_BUFFER buffer;
595 fstring server;
596 uint32 offered;
597
598 ZERO_STRUCT(in);
599 ZERO_STRUCT(out);
600
601 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
602 strupper_m(server);
603
604 offered = 0;
605 rpcbuf_init(&buffer, offered, mem_ctx);
606 make_spoolss_q_enumports( &in, server, level, &buffer, offered );
607
608 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPORTS,
609 in, out,
610 qbuf, rbuf,
611 spoolss_io_q_enumports,
612 spoolss_io_r_enumports,
613 WERR_GENERAL_FAILURE );
614
615 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
616 offered = out.needed;
617
618 ZERO_STRUCT(in);
619 ZERO_STRUCT(out);
620
621 rpcbuf_init(&buffer, offered, mem_ctx);
622 make_spoolss_q_enumports( &in, server, level, &buffer, offered );
623
624 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPORTS,
625 in, out,
626 qbuf, rbuf,
627 spoolss_io_q_enumports,
628 spoolss_io_r_enumports,
629 WERR_GENERAL_FAILURE );
630 }
631
632 if ( !W_ERROR_IS_OK(out.status) )
633 return out.status;
634
635 switch (level) {
636 case 1:
637 if (!decode_port_info_1(mem_ctx, out.buffer, out.returned, &ctr->port.info_1)) {
638 return WERR_GENERAL_FAILURE;
639 }
640 break;
641 case 2:
642 if (!decode_port_info_2(mem_ctx, out.buffer, out.returned, &ctr->port.info_2)) {
643 return WERR_GENERAL_FAILURE;
644 }
645 break;
646 default:
647 return WERR_UNKNOWN_LEVEL;
648 }
649
650 *num_ports = out.returned;
651
652 return out.status;
653 }
654
655 /**********************************************************************
656 **********************************************************************/
657
658 WERROR rpccli_spoolss_getprinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
659 POLICY_HND *pol, uint32 level,
660 PRINTER_INFO_CTR *ctr)
661 {
662 prs_struct qbuf, rbuf;
663 SPOOL_Q_GETPRINTER in;
664 SPOOL_R_GETPRINTER out;
665 RPC_BUFFER buffer;
666 uint32 offered;
667
668 ZERO_STRUCT(in);
669 ZERO_STRUCT(out);
670
671 /* Initialise input parameters */
672
673 offered = 0;
674 rpcbuf_init(&buffer, offered, mem_ctx);
675 make_spoolss_q_getprinter( mem_ctx, &in, pol, level, &buffer, offered );
676
677 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTER,
678 in, out,
679 qbuf, rbuf,
680 spoolss_io_q_getprinter,
681 spoolss_io_r_getprinter,
682 WERR_GENERAL_FAILURE );
683
684 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
685 offered = out.needed;
686
687 ZERO_STRUCT(in);
688 ZERO_STRUCT(out);
689
690 rpcbuf_init(&buffer, offered, mem_ctx);
691 make_spoolss_q_getprinter( mem_ctx, &in, pol, level, &buffer, offered );
692
693 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTER,
694 in, out,
695 qbuf, rbuf,
696 spoolss_io_q_getprinter,
697 spoolss_io_r_getprinter,
698 WERR_GENERAL_FAILURE );
699 }
700
701 if ( !W_ERROR_IS_OK(out.status) )
702 return out.status;
703
704 switch (level) {
705 case 0:
706 if (!decode_printer_info_0(mem_ctx, out.buffer, 1, &ctr->printers_0)) {
707 return WERR_GENERAL_FAILURE;
708 }
709 break;
710 case 1:
711 if (!decode_printer_info_1(mem_ctx, out.buffer, 1, &ctr->printers_1)) {
712 return WERR_GENERAL_FAILURE;
713 }
714 break;
715 case 2:
716 if (!decode_printer_info_2(mem_ctx, out.buffer, 1, &ctr->printers_2)) {
717 return WERR_GENERAL_FAILURE;
718 }
719 break;
720 case 3:
721 if (!decode_printer_info_3(mem_ctx, out.buffer, 1, &ctr->printers_3)) {
722 return WERR_GENERAL_FAILURE;
723 }
724 break;
725 case 7:
726 if (!decode_printer_info_7(mem_ctx, out.buffer, 1, &ctr->printers_7)) {
727 return WERR_GENERAL_FAILURE;
728 }
729 break;
730 default:
731 return WERR_UNKNOWN_LEVEL;
732 }
733
734 return out.status;
735 }
736
737 /**********************************************************************
738 **********************************************************************/
739
740 WERROR rpccli_spoolss_setprinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
741 POLICY_HND *pol, uint32 level,
742 PRINTER_INFO_CTR *ctr, uint32 command)
743 {
744 prs_struct qbuf, rbuf;
745 SPOOL_Q_SETPRINTER in;
746 SPOOL_R_SETPRINTER out;
747
748 ZERO_STRUCT(in);
749 ZERO_STRUCT(out);
750
751 make_spoolss_q_setprinter( mem_ctx, &in, pol, level, ctr, command );
752
753 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETPRINTER,
754 in, out,
755 qbuf, rbuf,
756 spoolss_io_q_setprinter,
757 spoolss_io_r_setprinter,
758 WERR_GENERAL_FAILURE );
759
760 return out.status;
761 }
762
763 /**********************************************************************
764 **********************************************************************/
765
766 WERROR rpccli_spoolss_getprinterdriver(struct rpc_pipe_client *cli,
767 TALLOC_CTX *mem_ctx,
768 POLICY_HND *pol, uint32 level,
769 const char *env, int version, PRINTER_DRIVER_CTR *ctr)
770 {
771 prs_struct qbuf, rbuf;
772 SPOOL_Q_GETPRINTERDRIVER2 in;
773 SPOOL_R_GETPRINTERDRIVER2 out;
774 RPC_BUFFER buffer;
775 fstring server;
776 uint32 offered;
777
778 ZERO_STRUCT(in);
779 ZERO_STRUCT(out);
780
781 fstrcpy(server, cli->cli->desthost);
782 strupper_m(server);
783
784 offered = 0;
785 rpcbuf_init(&buffer, offered, mem_ctx);
786 make_spoolss_q_getprinterdriver2( &in, pol, env, level,
787 version, 2, &buffer, offered);
788
789 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDRIVER2,
790 in, out,
791 qbuf, rbuf,
792 spoolss_io_q_getprinterdriver2,
793 spoolss_io_r_getprinterdriver2,
794 WERR_GENERAL_FAILURE );
795
796 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
797 offered = out.needed;
798
799 ZERO_STRUCT(in);
800 ZERO_STRUCT(out);
801
802 rpcbuf_init(&buffer, offered, mem_ctx);
803 make_spoolss_q_getprinterdriver2( &in, pol, env, level,
804 version, 2, &buffer, offered);
805
806 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDRIVER2,
807 in, out,
808 qbuf, rbuf,
809 spoolss_io_q_getprinterdriver2,
810 spoolss_io_r_getprinterdriver2,
811 WERR_GENERAL_FAILURE );
812 }
813
814 if ( !W_ERROR_IS_OK(out.status) )
815 return out.status;
816
817 switch (level) {
818 case 1:
819 if (!decode_printer_driver_1(mem_ctx, out.buffer, 1, &ctr->info1)) {
820 return WERR_GENERAL_FAILURE;
821 }
822 break;
823 case 2:
824 if (!decode_printer_driver_2(mem_ctx, out.buffer, 1, &ctr->info2)) {
825 return WERR_GENERAL_FAILURE;
826 }
827 break;
828 case 3:
829 if (!decode_printer_driver_3(mem_ctx, out.buffer, 1, &ctr->info3)) {
830 return WERR_GENERAL_FAILURE;
831 }
832 break;
833 default:
834 return WERR_UNKNOWN_LEVEL;
835 }
836
837 return out.status;
838 }
839
840 /**********************************************************************
841 **********************************************************************/
842
843 WERROR rpccli_spoolss_enumprinterdrivers (struct rpc_pipe_client *cli,
844 TALLOC_CTX *mem_ctx,
845 uint32 level, const char *env,
846 uint32 *num_drivers,
847 PRINTER_DRIVER_CTR *ctr)
848 {
849 prs_struct qbuf, rbuf;
850 SPOOL_Q_ENUMPRINTERDRIVERS in;
851 SPOOL_R_ENUMPRINTERDRIVERS out;
852 RPC_BUFFER buffer;
853 fstring server;
854 uint32 offered;
855
856 ZERO_STRUCT(in);
857 ZERO_STRUCT(out);
858
859 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
860 strupper_m(server);
861
862 offered = 0;
863 rpcbuf_init(&buffer, offered, mem_ctx);
864 make_spoolss_q_enumprinterdrivers( &in, server, env, level,
865 &buffer, offered);
866
867 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDRIVERS,
868 in, out,
869 qbuf, rbuf,
870 spoolss_io_q_enumprinterdrivers,
871 spoolss_io_r_enumprinterdrivers,
872 WERR_GENERAL_FAILURE );
873
874 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
875 offered = out.needed;
876
877 ZERO_STRUCT(in);
878 ZERO_STRUCT(out);
879
880 rpcbuf_init(&buffer, offered, mem_ctx);
881 make_spoolss_q_enumprinterdrivers( &in, server, env, level,
882 &buffer, offered);
883
884 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDRIVERS,
885 in, out,
886 qbuf, rbuf,
887 spoolss_io_q_enumprinterdrivers,
888 spoolss_io_r_enumprinterdrivers,
889 WERR_GENERAL_FAILURE );
890 }
891
892 *num_drivers = out.returned;
893
894 if ( !W_ERROR_IS_OK(out.status) )
895 return out.status;
896
897 if ( out.returned ) {
898
899 switch (level) {
900 case 1:
901 if (!decode_printer_driver_1(mem_ctx, out.buffer, out.returned, &ctr->info1)) {
902 return WERR_GENERAL_FAILURE;
903 }
904 break;
905 case 2:
906 if (!decode_printer_driver_2(mem_ctx, out.buffer, out.returned, &ctr->info2)) {
907 return WERR_GENERAL_FAILURE;
908 }
909 break;
910 case 3:
911 if (!decode_printer_driver_3(mem_ctx, out.buffer, out.returned, &ctr->info3)) {
912 return WERR_GENERAL_FAILURE;
913 }
914 break;
915 default:
916 return WERR_UNKNOWN_LEVEL;
917 }
918 }
919
920 return out.status;
921 }
922
923
924 /**********************************************************************
925 **********************************************************************/
926
927 WERROR rpccli_spoolss_getprinterdriverdir (struct rpc_pipe_client *cli,
928 TALLOC_CTX *mem_ctx,
929 uint32 level, char *env,
930 DRIVER_DIRECTORY_CTR *ctr)
931 {
932 prs_struct qbuf, rbuf;
933 SPOOL_Q_GETPRINTERDRIVERDIR in;
934 SPOOL_R_GETPRINTERDRIVERDIR out;
935 RPC_BUFFER buffer;
936 fstring server;
937 uint32 offered;
938
939 ZERO_STRUCT(in);
940 ZERO_STRUCT(out);
941
942 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
943 strupper_m(server);
944
945 offered = 0;
946 rpcbuf_init(&buffer, offered, mem_ctx);
947 make_spoolss_q_getprinterdriverdir( &in, server, env, level,
948 &buffer, offered );
949
950 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDRIVERDIRECTORY,
951 in, out,
952 qbuf, rbuf,
953 spoolss_io_q_getprinterdriverdir,
954 spoolss_io_r_getprinterdriverdir,
955 WERR_GENERAL_FAILURE );
956
957 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
958 offered = out.needed;
959
960 ZERO_STRUCT(in);
961 ZERO_STRUCT(out);
962
963 rpcbuf_init(&buffer, offered, mem_ctx);
964 make_spoolss_q_getprinterdriverdir( &in, server, env, level,
965 &buffer, offered );
966
967 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDRIVERDIRECTORY,
968 in, out,
969 qbuf, rbuf,
970 spoolss_io_q_getprinterdriverdir,
971 spoolss_io_r_getprinterdriverdir,
972 WERR_GENERAL_FAILURE );
973 }
974
975 if (!W_ERROR_IS_OK(out.status))
976 return out.status;
977
978 if (!decode_printerdriverdir_1(mem_ctx, out.buffer, 1, &ctr->info1)) {
979 return WERR_GENERAL_FAILURE;
980 }
981
982 return out.status;
983 }
984
985 /**********************************************************************
986 **********************************************************************/
987
988 WERROR rpccli_spoolss_addprinterdriver (struct rpc_pipe_client *cli,
989 TALLOC_CTX *mem_ctx, uint32 level,
990 PRINTER_DRIVER_CTR *ctr)
991 {
992 prs_struct qbuf, rbuf;
993 SPOOL_Q_ADDPRINTERDRIVER in;
994 SPOOL_R_ADDPRINTERDRIVER out;
995 fstring server;
996
997 ZERO_STRUCT(in);
998 ZERO_STRUCT(out);
999
1000 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
1001 strupper_m(server);
1002
1003 make_spoolss_q_addprinterdriver( mem_ctx, &in, server, level, ctr );
1004
1005 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ADDPRINTERDRIVER,
1006 in, out,
1007 qbuf, rbuf,
1008 spoolss_io_q_addprinterdriver,
1009 spoolss_io_r_addprinterdriver,
1010 WERR_GENERAL_FAILURE );
1011
1012 return out.status;
1013 }
1014
1015 /**********************************************************************
1016 **********************************************************************/
1017
1018 WERROR rpccli_spoolss_addprinterex (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1019 uint32 level, PRINTER_INFO_CTR*ctr)
1020 {
1021 prs_struct qbuf, rbuf;
1022 SPOOL_Q_ADDPRINTEREX in;
1023 SPOOL_R_ADDPRINTEREX out;
1024 fstring server, client, user;
1025
1026 ZERO_STRUCT(in);
1027 ZERO_STRUCT(out);
1028
1029 slprintf(client, sizeof(fstring)-1, "\\\\%s", global_myname());
1030 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
1031
1032 strupper_m(client);
1033 strupper_m(server);
1034
1035 fstrcpy (user, cli->user_name);
1036
1037 make_spoolss_q_addprinterex( mem_ctx, &in, server, client,
1038 user, level, ctr);
1039
1040 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ADDPRINTEREX,
1041 in, out,
1042 qbuf, rbuf,
1043 spoolss_io_q_addprinterex,
1044 spoolss_io_r_addprinterex,
1045 WERR_GENERAL_FAILURE );
1046
1047 return out.status;
1048 }
1049
1050 /**********************************************************************
1051 **********************************************************************/
1052
1053 WERROR rpccli_spoolss_deleteprinterdriverex(struct rpc_pipe_client *cli,
1054 TALLOC_CTX *mem_ctx, const char *arch,
1055 const char *driver, int version)
1056 {
1057 prs_struct qbuf, rbuf;
1058 SPOOL_Q_DELETEPRINTERDRIVEREX in;
1059 SPOOL_R_DELETEPRINTERDRIVEREX out;
1060 fstring server;
1061
1062 ZERO_STRUCT(in);
1063 ZERO_STRUCT(out);
1064
1065 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
1066 strupper_m(server);
1067
1068 make_spoolss_q_deleteprinterdriverex( mem_ctx, &in, server, arch, driver, version );
1069
1070 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDRIVEREX,
1071 in, out,
1072 qbuf, rbuf,
1073 spoolss_io_q_deleteprinterdriverex,
1074 spoolss_io_r_deleteprinterdriverex,
1075 WERR_GENERAL_FAILURE );
1076
1077 return out.status;
1078 }
1079
1080 /**********************************************************************
1081 **********************************************************************/
1082
1083 WERROR rpccli_spoolss_deleteprinterdriver (struct rpc_pipe_client *cli,
1084 TALLOC_CTX *mem_ctx, const char *arch,
1085 const char *driver)
1086 {
1087 prs_struct qbuf, rbuf;
1088 SPOOL_Q_DELETEPRINTERDRIVER in;
1089 SPOOL_R_DELETEPRINTERDRIVER out;
1090 fstring server;
1091
1092 ZERO_STRUCT(in);
1093 ZERO_STRUCT(out);
1094
1095 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
1096 strupper_m(server);
1097
1098 make_spoolss_q_deleteprinterdriver( mem_ctx, &in, server, arch, driver );
1099
1100 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDRIVER,
1101 in, out,
1102 qbuf, rbuf,
1103 spoolss_io_q_deleteprinterdriver,
1104 spoolss_io_r_deleteprinterdriver,
1105 WERR_GENERAL_FAILURE );
1106
1107 return out.status;
1108 }
1109
1110 /**********************************************************************
1111 **********************************************************************/
1112
1113 WERROR rpccli_spoolss_getprintprocessordirectory(struct rpc_pipe_client *cli,
1114 TALLOC_CTX *mem_ctx,
1115 char *name, char *environment,
1116 fstring procdir)
1117 {
1118 prs_struct qbuf, rbuf;
1119 SPOOL_Q_GETPRINTPROCESSORDIRECTORY in;
1120 SPOOL_R_GETPRINTPROCESSORDIRECTORY out;
1121 int level = 1;
1122 RPC_BUFFER buffer;
1123 uint32 offered;
1124
1125 ZERO_STRUCT(in);
1126 ZERO_STRUCT(out);
1127
1128 offered = 0;
1129 rpcbuf_init(&buffer, offered, mem_ctx);
1130 make_spoolss_q_getprintprocessordirectory( &in, name,
1131 environment, level, &buffer, offered );
1132
1133 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTPROCESSORDIRECTORY,
1134 in, out,
1135 qbuf, rbuf,
1136 spoolss_io_q_getprintprocessordirectory,
1137 spoolss_io_r_getprintprocessordirectory,
1138 WERR_GENERAL_FAILURE );
1139
1140 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
1141 offered = out.needed;
1142
1143 ZERO_STRUCT(in);
1144 ZERO_STRUCT(out);
1145
1146 rpcbuf_init(&buffer, offered, mem_ctx);
1147 make_spoolss_q_getprintprocessordirectory( &in, name,
1148 environment, level, &buffer, offered );
1149
1150 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTPROCESSORDIRECTORY,
1151 in, out,
1152 qbuf, rbuf,
1153 spoolss_io_q_getprintprocessordirectory,
1154 spoolss_io_r_getprintprocessordirectory,
1155 WERR_GENERAL_FAILURE );
1156 }
1157
1158 if ( !W_ERROR_IS_OK(out.status) )
1159 return out.status;
1160
1161 fstrcpy(procdir, "Not implemented!");
1162
1163 return out.status;
1164 }
1165
1166 /**********************************************************************
1167 **********************************************************************/
1168
1169 WERROR rpccli_spoolss_addform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1170 POLICY_HND *handle, uint32 level, FORM *form)
1171 {
1172 prs_struct qbuf, rbuf;
1173 SPOOL_Q_ADDFORM in;
1174 SPOOL_R_ADDFORM out;
1175
1176 ZERO_STRUCT(in);
1177 ZERO_STRUCT(out);
1178
1179 make_spoolss_q_addform( &in, handle, level, form );
1180
1181 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ADDFORM,
1182 in, out,
1183 qbuf, rbuf,
1184 spoolss_io_q_addform,
1185 spoolss_io_r_addform,
1186 WERR_GENERAL_FAILURE );
1187
1188 return out.status;
1189 }
1190
1191 /**********************************************************************
1192 **********************************************************************/
1193
1194 WERROR rpccli_spoolss_setform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1195 POLICY_HND *handle, uint32 level,
1196 const char *form_name, FORM *form)
1197 {
1198 prs_struct qbuf, rbuf;
1199 SPOOL_Q_SETFORM in;
1200 SPOOL_R_SETFORM out;
1201
1202 ZERO_STRUCT(in);
1203 ZERO_STRUCT(out);
1204
1205 make_spoolss_q_setform( &in, handle, level, form_name, form );
1206
1207 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETFORM,
1208 in, out,
1209 qbuf, rbuf,
1210 spoolss_io_q_setform,
1211 spoolss_io_r_setform,
1212 WERR_GENERAL_FAILURE );
1213
1214 return out.status;
1215 }
1216
1217 /**********************************************************************
1218 **********************************************************************/
1219
1220 WERROR rpccli_spoolss_getform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1221 POLICY_HND *handle, const char *formname,
1222 uint32 level, FORM_1 *form)
1223 {
1224 prs_struct qbuf, rbuf;
1225 SPOOL_Q_GETFORM in;
1226 SPOOL_R_GETFORM out;
1227 RPC_BUFFER buffer;
1228 uint32 offered;
1229
1230 ZERO_STRUCT(in);
1231 ZERO_STRUCT(out);
1232
1233 offered = 0;
1234 rpcbuf_init(&buffer, offered, mem_ctx);
1235 make_spoolss_q_getform( &in, handle, formname, level, &buffer, offered );
1236
1237 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETFORM,
1238 in, out,
1239 qbuf, rbuf,
1240 spoolss_io_q_getform,
1241 spoolss_io_r_getform,
1242 WERR_GENERAL_FAILURE );
1243
1244 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
1245 offered = out.needed;
1246
1247 ZERO_STRUCT(in);
1248 ZERO_STRUCT(out);
1249
1250 rpcbuf_init(&buffer, offered, mem_ctx);
1251 make_spoolss_q_getform( &in, handle, formname, level, &buffer, offered );
1252
1253 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETFORM,
1254 in, out,
1255 qbuf, rbuf,
1256 spoolss_io_q_getform,
1257 spoolss_io_r_getform,
1258 WERR_GENERAL_FAILURE );
1259 }
1260
1261 if (!W_ERROR_IS_OK(out.status))
1262 return out.status;
1263
1264 if (!smb_io_form_1("", out.buffer, form, 0)) {
1265 return WERR_GENERAL_FAILURE;
1266 }
1267
1268 return out.status;
1269 }
1270
1271 /**********************************************************************
1272 **********************************************************************/
1273
1274 WERROR rpccli_spoolss_deleteform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1275 POLICY_HND *handle, const char *form_name)
1276 {
1277 prs_struct qbuf, rbuf;
1278 SPOOL_Q_DELETEFORM in;
1279 SPOOL_R_DELETEFORM out;
1280
1281 ZERO_STRUCT(in);
1282 ZERO_STRUCT(out);
1283
1284 make_spoolss_q_deleteform( &in, handle, form_name );
1285
1286 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEFORM,
1287 in, out,
1288 qbuf, rbuf,
1289 spoolss_io_q_deleteform,
1290 spoolss_io_r_deleteform,
1291 WERR_GENERAL_FAILURE );
1292
1293 return out.status;
1294 }
1295
1296 /**********************************************************************
1297 **********************************************************************/
1298
1299 WERROR rpccli_spoolss_enumforms(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1300 POLICY_HND *handle, int level, uint32 *num_forms,
1301 FORM_1 **forms)
1302 {
1303 prs_struct qbuf, rbuf;
1304 SPOOL_Q_ENUMFORMS in;
1305 SPOOL_R_ENUMFORMS out;
1306 RPC_BUFFER buffer;
1307 uint32 offered;
1308
1309 ZERO_STRUCT(in);
1310 ZERO_STRUCT(out);
1311
1312 offered = 0;
1313 rpcbuf_init(&buffer, offered, mem_ctx);
1314 make_spoolss_q_enumforms( &in, handle, level, &buffer, offered );
1315
1316 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMFORMS,
1317 in, out,
1318 qbuf, rbuf,
1319 spoolss_io_q_enumforms,
1320 spoolss_io_r_enumforms,
1321 WERR_GENERAL_FAILURE );
1322
1323 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
1324 offered = out.needed;
1325
1326 ZERO_STRUCT(in);
1327 ZERO_STRUCT(out);
1328
1329 rpcbuf_init(&buffer, offered, mem_ctx);
1330 make_spoolss_q_enumforms( &in, handle, level, &buffer, offered );
1331
1332 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMFORMS,
1333 in, out,
1334 qbuf, rbuf,
1335 spoolss_io_q_enumforms,
1336 spoolss_io_r_enumforms,
1337 WERR_GENERAL_FAILURE );
1338 }
1339
1340 if (!W_ERROR_IS_OK(out.status))
1341 return out.status;
1342
1343 *num_forms = out.numofforms;
1344
1345 if (!decode_forms_1(mem_ctx, out.buffer, *num_forms, forms)) {
1346 return WERR_GENERAL_FAILURE;
1347 }
1348
1349 return out.status;
1350 }
1351
1352 /**********************************************************************
1353 **********************************************************************/
1354
1355 WERROR rpccli_spoolss_enumjobs(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1356 POLICY_HND *hnd, uint32 level, uint32 firstjob,
1357 uint32 num_jobs, uint32 *returned, JOB_INFO_CTR *ctr)
1358 {
1359 prs_struct qbuf, rbuf;
1360 SPOOL_Q_ENUMJOBS in;
1361 SPOOL_R_ENUMJOBS out;
1362 RPC_BUFFER buffer;
1363 uint32 offered;
1364
1365 ZERO_STRUCT(in);
1366 ZERO_STRUCT(out);
1367
1368 offered = 0;
1369 rpcbuf_init(&buffer, offered, mem_ctx);
1370 make_spoolss_q_enumjobs( &in, hnd, firstjob, num_jobs, level,
1371 &buffer, offered );
1372
1373 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMJOBS,
1374 in, out,
1375 qbuf, rbuf,
1376 spoolss_io_q_enumjobs,
1377 spoolss_io_r_enumjobs,
1378 WERR_GENERAL_FAILURE );
1379
1380 if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
1381 offered = out.needed;
1382
1383 ZERO_STRUCT(in);
1384 ZERO_STRUCT(out);
1385
1386 rpcbuf_init(&buffer, offered, mem_ctx);
1387 make_spoolss_q_enumjobs( &in, hnd, firstjob, num_jobs, level,
1388 &buffer, offered );
1389
1390 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMJOBS,
1391 in, out,
1392 qbuf, rbuf,
1393 spoolss_io_q_enumjobs,
1394 spoolss_io_r_enumjobs,
1395 WERR_GENERAL_FAILURE );
1396 }
1397
1398 if (!W_ERROR_IS_OK(out.status))
1399 return out.status;
1400
1401 switch(level) {
1402 case 1:
1403 if (!decode_jobs_1(mem_ctx, out.buffer, out.returned, &ctr->job.job_info_1)) {
1404 return WERR_GENERAL_FAILURE;
1405 }
1406 break;
1407 case 2:
1408 if (!decode_jobs_2(mem_ctx, out.buffer, out.returned, &ctr->job.job_info_2)) {
1409 return WERR_GENERAL_FAILURE;
1410 }
1411 break;
1412 default:
1413 DEBUG(3, ("unsupported info level %d", level));
1414 return WERR_UNKNOWN_LEVEL;
1415 }
1416
1417 *returned = out.returned;
1418
1419 return out.status;
1420 }
1421
1422 /**********************************************************************
1423 **********************************************************************/
1424
1425 WERROR rpccli_spoolss_setjob(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1426 POLICY_HND *hnd, uint32 jobid, uint32 level,
1427 uint32 command)
1428 {
1429 prs_struct qbuf, rbuf;
1430 SPOOL_Q_SETJOB in;
1431 SPOOL_R_SETJOB out;
1432
1433 ZERO_STRUCT(in);
1434 ZERO_STRUCT(out);
1435
1436 make_spoolss_q_setjob( &in, hnd, jobid, level, command );
1437
1438 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETJOB,
1439 in, out,
1440 qbuf, rbuf,
1441 spoolss_io_q_setjob,
1442 spoolss_io_r_setjob,
1443 WERR_GENERAL_FAILURE );
1444
1445 return out.status;
1446 }
1447
1448 /**********************************************************************
1449 **********************************************************************/
1450
1451 WERROR rpccli_spoolss_getjob(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1452 POLICY_HND *hnd, uint32 jobid, uint32 level,
1453 JOB_INFO_CTR *ctr)
1454 {
1455 prs_struct qbuf, rbuf;
1456 SPOOL_Q_GETJOB in;
1457 SPOOL_R_GETJOB out;
1458 RPC_BUFFER buffer;
1459 uint32 offered;
1460
1461 ZERO_STRUCT(in);
1462 ZERO_STRUCT(out);
1463
1464 offered = 0;
1465 rpcbuf_init(&buffer, offered, mem_ctx);
1466 make_spoolss_q_getjob( &in, hnd, jobid, level, &buffer, offered );
1467
1468 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETJOB,
1469 in, out,
1470 qbuf, rbuf,
1471 spoolss_io_q_getjob,
1472 spoolss_io_r_getjob,
1473 WERR_GENERAL_FAILURE );
1474
1475 if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1476 offered = out.needed;
1477
1478 ZERO_STRUCT(in);
1479 ZERO_STRUCT(out);
1480
1481 rpcbuf_init(&buffer, offered, mem_ctx);
1482 make_spoolss_q_getjob( &in, hnd, jobid, level, &buffer, offered );
1483
1484 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETJOB,
1485 in, out,
1486 qbuf, rbuf,
1487 spoolss_io_q_getjob,
1488 spoolss_io_r_getjob,
1489 WERR_GENERAL_FAILURE );
1490 }
1491
1492 if (!W_ERROR_IS_OK(out.status))
1493 return out.status;
1494
1495 switch(level) {
1496 case 1:
1497 if (!decode_jobs_1(mem_ctx, out.buffer, 1, &ctr->job.job_info_1)) {
1498 return WERR_GENERAL_FAILURE;
1499 }
1500 break;
1501 case 2:
1502 if (!decode_jobs_2(mem_ctx, out.buffer, 1, &ctr->job.job_info_2)) {
1503 return WERR_GENERAL_FAILURE;
1504 }
1505 break;
1506 default:
1507 return WERR_UNKNOWN_LEVEL;
1508 }
1509
1510 return out.status;
1511 }
1512
1513 /**********************************************************************
1514 **********************************************************************/
1515
1516 WERROR rpccli_spoolss_startpageprinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1517 POLICY_HND *hnd)
1518 {
1519 prs_struct qbuf, rbuf;
1520 SPOOL_Q_STARTPAGEPRINTER in;
1521 SPOOL_R_STARTPAGEPRINTER out;
1522
1523 ZERO_STRUCT(in);
1524 ZERO_STRUCT(out);
1525
1526 make_spoolss_q_startpageprinter( &in, hnd );
1527
1528 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_STARTPAGEPRINTER,
1529 in, out,
1530 qbuf, rbuf,
1531 spoolss_io_q_startpageprinter,
1532 spoolss_io_r_startpageprinter,
1533 WERR_GENERAL_FAILURE );
1534
1535 return out.status;
1536 }
1537
1538 /**********************************************************************
1539 **********************************************************************/
1540
1541 WERROR rpccli_spoolss_endpageprinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1542 POLICY_HND *hnd)
1543 {
1544 prs_struct qbuf, rbuf;
1545 SPOOL_Q_ENDPAGEPRINTER in;
1546 SPOOL_R_ENDPAGEPRINTER out;
1547
1548 ZERO_STRUCT(in);
1549 ZERO_STRUCT(out);
1550
1551 make_spoolss_q_endpageprinter( &in, hnd );
1552
1553 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENDPAGEPRINTER,
1554 in, out,
1555 qbuf, rbuf,
1556 spoolss_io_q_endpageprinter,
1557 spoolss_io_r_endpageprinter,
1558 WERR_GENERAL_FAILURE );
1559
1560 return out.status;
1561 }
1562
1563 /**********************************************************************
1564 **********************************************************************/
1565
1566 WERROR rpccli_spoolss_startdocprinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1567 POLICY_HND *hnd, char *docname,
1568 char *outputfile, char *datatype,
1569 uint32 *jobid)
1570 {
1571 prs_struct qbuf, rbuf;
1572 SPOOL_Q_STARTDOCPRINTER in;
1573 SPOOL_R_STARTDOCPRINTER out;
1574 uint32 level = 1;
1575
1576 ZERO_STRUCT(in);
1577 ZERO_STRUCT(out);
1578
1579 make_spoolss_q_startdocprinter( &in, hnd, level, docname,
1580 outputfile, datatype );
1581
1582 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_STARTDOCPRINTER,
1583 in, out,
1584 qbuf, rbuf,
1585 spoolss_io_q_startdocprinter,
1586 spoolss_io_r_startdocprinter,
1587 WERR_GENERAL_FAILURE );
1588
1589 *jobid = out.jobid;
1590
1591 return out.status;
1592 }
1593
1594 /**********************************************************************
1595 **********************************************************************/
1596
1597 WERROR rpccli_spoolss_enddocprinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1598 POLICY_HND *hnd)
1599 {
1600 prs_struct qbuf, rbuf;
1601 SPOOL_Q_ENDDOCPRINTER in;
1602 SPOOL_R_ENDDOCPRINTER out;
1603
1604 ZERO_STRUCT(in);
1605 ZERO_STRUCT(out);
1606
1607 make_spoolss_q_enddocprinter( &in, hnd );
1608
1609 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENDDOCPRINTER,
1610 in, out,
1611 qbuf, rbuf,
1612 spoolss_io_q_enddocprinter,
1613 spoolss_io_r_enddocprinter,
1614 WERR_GENERAL_FAILURE );
1615
1616 return out.status;
1617 }
1618
1619 /**********************************************************************
1620 **********************************************************************/
1621
1622 WERROR rpccli_spoolss_getprinterdata(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1623 POLICY_HND *hnd, const char *valuename,
1624 REGISTRY_VALUE *value)
1625 {
1626 prs_struct qbuf, rbuf;
1627 SPOOL_Q_GETPRINTERDATA in;
1628 SPOOL_R_GETPRINTERDATA out;
1629 uint32 offered;
1630
1631 ZERO_STRUCT(in);
1632 ZERO_STRUCT(out);
1633
1634 offered = 0;
1635 make_spoolss_q_getprinterdata( &in, hnd, valuename, offered );
1636
1637 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDATA,
1638 in, out,
1639 qbuf, rbuf,
1640 spoolss_io_q_getprinterdata,
1641 spoolss_io_r_getprinterdata,
1642 WERR_GENERAL_FAILURE );
1643
1644 if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1645 offered = out.needed;
1646
1647 ZERO_STRUCT(in);
1648 ZERO_STRUCT(out);
1649
1650 make_spoolss_q_getprinterdata( &in, hnd, valuename, offered );
1651
1652 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDATA,
1653 in, out,
1654 qbuf, rbuf,
1655 spoolss_io_q_getprinterdata,
1656 spoolss_io_r_getprinterdata,
1657 WERR_GENERAL_FAILURE );
1658 }
1659
1660 if (!W_ERROR_IS_OK(out.status))
1661 return out.status;
1662
1663 /* Return output parameters */
1664
1665 if (out.needed) {
1666 value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data, out.needed);
1667 } else {
1668 value->data_p = NULL;
1669 }
1670 value->type = out.type;
1671 value->size = out.size;
1672
1673 return out.status;
1674 }
1675
1676 /**********************************************************************
1677 **********************************************************************/
1678
1679 WERROR rpccli_spoolss_getprinterdataex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1680 POLICY_HND *hnd, const char *keyname,
1681 const char *valuename,
1682 REGISTRY_VALUE *value)
1683 {
1684 prs_struct qbuf, rbuf;
1685 SPOOL_Q_GETPRINTERDATAEX in;
1686 SPOOL_R_GETPRINTERDATAEX out;
1687 uint32 offered = 0;
1688
1689 ZERO_STRUCT(in);
1690 ZERO_STRUCT(out);
1691
1692 make_spoolss_q_getprinterdataex( &in, hnd, keyname, valuename, offered );
1693
1694 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDATAEX,
1695 in, out,
1696 qbuf, rbuf,
1697 spoolss_io_q_getprinterdataex,
1698 spoolss_io_r_getprinterdataex,
1699 WERR_GENERAL_FAILURE );
1700
1701 if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1702 offered = out.needed;
1703
1704 ZERO_STRUCT(in);
1705 ZERO_STRUCT(out);
1706
1707 make_spoolss_q_getprinterdataex( &in, hnd, keyname, valuename, offered );
1708
1709 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDATAEX,
1710 in, out,
1711 qbuf, rbuf,
1712 spoolss_io_q_getprinterdataex,
1713 spoolss_io_r_getprinterdataex,
1714 WERR_GENERAL_FAILURE );
1715 }
1716
1717 if (!W_ERROR_IS_OK(out.status))
1718 return out.status;
1719
1720 /* Return output parameters */
1721
1722 if (out.needed) {
1723 value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data, out.needed);
1724 } else {
1725 value->data_p = NULL;
1726 }
1727 value->type = out.type;
1728 value->size = out.needed;
1729
1730 return out.status;
1731 }
1732
1733 /**********************************************************************
1734 **********************************************************************/
1735
1736 WERROR rpccli_spoolss_setprinterdata(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1737 POLICY_HND *hnd, REGISTRY_VALUE *value)
1738 {
1739 prs_struct qbuf, rbuf;
1740 SPOOL_Q_SETPRINTERDATA in;
1741 SPOOL_R_SETPRINTERDATA out;
1742
1743 ZERO_STRUCT(in);
1744 ZERO_STRUCT(out);
1745
1746 make_spoolss_q_setprinterdata( &in, hnd, value->valuename,
1747 value->type, (char *)value->data_p, value->size);
1748
1749 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETPRINTERDATA,
1750 in, out,
1751 qbuf, rbuf,
1752 spoolss_io_q_setprinterdata,
1753 spoolss_io_r_setprinterdata,
1754 WERR_GENERAL_FAILURE );
1755
1756 return out.status;
1757 }
1758
1759 /**********************************************************************
1760 **********************************************************************/
1761
1762 WERROR rpccli_spoolss_setprinterdataex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1763 POLICY_HND *hnd, char *keyname,
1764 REGISTRY_VALUE *value)
1765 {
1766 prs_struct qbuf, rbuf;
1767 SPOOL_Q_SETPRINTERDATAEX in;
1768 SPOOL_R_SETPRINTERDATAEX out;
1769
1770 ZERO_STRUCT(in);
1771 ZERO_STRUCT(out);
1772
1773 make_spoolss_q_setprinterdataex( &in, hnd, keyname, value->valuename,
1774 value->type, (char *)value->data_p, value->size);
1775
1776 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETPRINTERDATAEX,
1777 in, out,
1778 qbuf, rbuf,
1779 spoolss_io_q_setprinterdataex,
1780 spoolss_io_r_setprinterdataex,
1781 WERR_GENERAL_FAILURE );
1782
1783 return out.status;
1784 }
1785
1786 /**********************************************************************
1787 **********************************************************************/
1788
1789 WERROR rpccli_spoolss_enumprinterdata(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1790 POLICY_HND *hnd, uint32 ndx,
1791 uint32 value_offered, uint32 data_offered,
1792 uint32 *value_needed, uint32 *data_needed,
1793 REGISTRY_VALUE *value)
1794 {
1795 prs_struct qbuf, rbuf;
1796 SPOOL_Q_ENUMPRINTERDATA in;
1797 SPOOL_R_ENUMPRINTERDATA out;
1798
1799 ZERO_STRUCT(in);
1800 ZERO_STRUCT(out);
1801
1802 make_spoolss_q_enumprinterdata( &in, hnd, ndx, value_offered, data_offered );
1803
1804 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDATA,
1805 in, out,
1806 qbuf, rbuf,
1807 spoolss_io_q_enumprinterdata,
1808 spoolss_io_r_enumprinterdata,
1809 WERR_GENERAL_FAILURE );
1810
1811 if ( value_needed )
1812 *value_needed = out.realvaluesize;
1813 if ( data_needed )
1814 *data_needed = out.realdatasize;
1815
1816 if (!W_ERROR_IS_OK(out.status))
1817 return out.status;
1818
1819 if (value) {
1820 rpcstr_pull(value->valuename, out.value, sizeof(value->valuename), -1,
1821 STR_TERMINATE);
1822 if (out.realdatasize) {
1823 value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data,
1824 out.realdatasize);
1825 } else {
1826 value->data_p = NULL;
1827 }
1828 value->type = out.type;
1829 value->size = out.realdatasize;
1830 }
1831
1832 return out.status;
1833 }
1834
1835 /**********************************************************************
1836 **********************************************************************/
1837
1838 WERROR rpccli_spoolss_enumprinterdataex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1839 POLICY_HND *hnd, const char *keyname,
1840 REGVAL_CTR *ctr)
1841 {
1842 prs_struct qbuf, rbuf;
1843 SPOOL_Q_ENUMPRINTERDATAEX in;
1844 SPOOL_R_ENUMPRINTERDATAEX out;
1845 int i;
1846 uint32 offered;
1847
1848 ZERO_STRUCT(in);
1849 ZERO_STRUCT(out);
1850
1851 offered = 0;
1852 make_spoolss_q_enumprinterdataex( &in, hnd, keyname, offered );
1853
1854 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDATAEX,
1855 in, out,
1856 qbuf, rbuf,
1857 spoolss_io_q_enumprinterdataex,
1858 spoolss_io_r_enumprinterdataex,
1859 WERR_GENERAL_FAILURE );
1860
1861 if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1862 offered = out.needed;
1863
1864 ZERO_STRUCT(in);
1865 ZERO_STRUCT(out);
1866
1867 make_spoolss_q_enumprinterdataex( &in, hnd, keyname, offered );
1868
1869 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDATAEX,
1870 in, out,
1871 qbuf, rbuf,
1872 spoolss_io_q_enumprinterdataex,
1873 spoolss_io_r_enumprinterdataex,
1874 WERR_GENERAL_FAILURE );
1875 }
1876
1877 if (!W_ERROR_IS_OK(out.status))
1878 return out.status;
1879
1880 for (i = 0; i < out.returned; i++) {
1881 PRINTER_ENUM_VALUES *v = &out.ctr.values[i];
1882 fstring name;
1883
1884 rpcstr_pull(name, v->valuename.buffer, sizeof(name), -1,
1885 STR_TERMINATE);
1886 regval_ctr_addvalue(ctr, name, v->type, (const char *)v->data, v->data_len);
1887 }
1888
1889 return out.status;
1890 }
1891
1892 /**********************************************************************
1893 **********************************************************************/
1894
1895 WERROR rpccli_spoolss_writeprinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1896 POLICY_HND *hnd, uint32 data_size, char *data,
1897 uint32 *num_written)
1898 {
1899 prs_struct qbuf, rbuf;
1900 SPOOL_Q_WRITEPRINTER in;
1901 SPOOL_R_WRITEPRINTER out;
1902
1903 ZERO_STRUCT(in);
1904 ZERO_STRUCT(out);
1905
1906 make_spoolss_q_writeprinter( &in, hnd, data_size, data );
1907
1908 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_WRITEPRINTER,
1909 in, out,
1910 qbuf, rbuf,
1911 spoolss_io_q_writeprinter,
1912 spoolss_io_r_writeprinter,
1913 WERR_GENERAL_FAILURE );
1914
1915 if (num_written)
1916 *num_written = out.buffer_written;
1917
1918 return out.status;
1919 }
1920
1921 /**********************************************************************
1922 **********************************************************************/
1923
1924 WERROR rpccli_spoolss_deleteprinterdata(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1925 POLICY_HND *hnd, char *valuename)
1926 {
1927 prs_struct qbuf, rbuf;
1928 SPOOL_Q_DELETEPRINTERDATA in;
1929 SPOOL_R_DELETEPRINTERDATA out;
1930
1931 ZERO_STRUCT(in);
1932 ZERO_STRUCT(out);
1933
1934 make_spoolss_q_deleteprinterdata( &in, hnd, valuename );
1935
1936 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDATA,
1937 in, out,
1938 qbuf, rbuf,
1939 spoolss_io_q_deleteprinterdata,
1940 spoolss_io_r_deleteprinterdata,
1941 WERR_GENERAL_FAILURE );
1942
1943 return out.status;
1944 }
1945
1946 /**********************************************************************
1947 **********************************************************************/
1948
1949 WERROR rpccli_spoolss_deleteprinterdataex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1950 POLICY_HND *hnd, char *keyname,
1951 char *valuename)
1952 {
1953 prs_struct qbuf, rbuf;
1954 SPOOL_Q_DELETEPRINTERDATAEX in;
1955 SPOOL_R_DELETEPRINTERDATAEX out;
1956
1957 ZERO_STRUCT(in);
1958 ZERO_STRUCT(out);
1959
1960 make_spoolss_q_deleteprinterdataex( &in, hnd, keyname, valuename );
1961
1962 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDATAEX,
1963 in, out,
1964 qbuf, rbuf,
1965 spoolss_io_q_deleteprinterdataex,
1966 spoolss_io_r_deleteprinterdataex,
1967 WERR_GENERAL_FAILURE );
1968
1969 return out.status;
1970 }
1971
1972 /**********************************************************************
1973 **********************************************************************/
1974
1975 WERROR rpccli_spoolss_enumprinterkey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1976 POLICY_HND *hnd, const char *keyname,
1977 uint16 **keylist, uint32 *len)
1978 {
1979 prs_struct qbuf, rbuf;
1980 SPOOL_Q_ENUMPRINTERKEY in;
1981 SPOOL_R_ENUMPRINTERKEY out;
1982 uint32 offered = 0;
1983
1984 ZERO_STRUCT(in);
1985 ZERO_STRUCT(out);
1986
1987 make_spoolss_q_enumprinterkey( &in, hnd, keyname, offered );
1988
1989 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERKEY,
1990 in, out,
1991 qbuf, rbuf,
1992 spoolss_io_q_enumprinterkey,
1993 spoolss_io_r_enumprinterkey,
1994 WERR_GENERAL_FAILURE );
1995
1996 if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1997 offered = out.needed;
1998
1999 ZERO_STRUCT(in);
2000 ZERO_STRUCT(out);
2001
2002 make_spoolss_q_enumprinterkey( &in, hnd, keyname, offered );
2003
2004 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERKEY,
2005 in, out,
2006 qbuf, rbuf,
2007 spoolss_io_q_enumprinterkey,
2008 spoolss_io_r_enumprinterkey,
2009 WERR_GENERAL_FAILURE );
2010 }
2011
2012 if ( !W_ERROR_IS_OK(out.status) )
2013 return out.status;
2014
2015 if (keylist) {
2016 *keylist = SMB_MALLOC_ARRAY(uint16, out.keys.buf_len);
2017 if (!*keylist) {
2018 return WERR_NOMEM;
2019 }
2020 memcpy(*keylist, out.keys.buffer, out.keys.buf_len * 2);
2021 if (len)
2022 *len = out.keys.buf_len * 2;
2023 }
2024
2025 return out.status;
2026 }
2027
2028 /**********************************************************************
2029 **********************************************************************/
2030
2031 WERROR rpccli_spoolss_deleteprinterkey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
2032 POLICY_HND *hnd, char *keyname)
2033 {
2034 prs_struct qbuf, rbuf;
2035 SPOOL_Q_DELETEPRINTERKEY in;
2036 SPOOL_R_DELETEPRINTERKEY out;
2037
2038 ZERO_STRUCT(in);
2039 ZERO_STRUCT(out);
2040
2041 make_spoolss_q_deleteprinterkey( &in, hnd, keyname );
2042
2043 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERKEY,
2044 in, out,
2045 qbuf, rbuf,
2046 spoolss_io_q_deleteprinterkey,
2047 spoolss_io_r_deleteprinterkey,
2048 WERR_GENERAL_FAILURE );
2049
2050 return out.status;
2051 }
2052
2053 /** @} **/
Samba GIT mirror