?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r4904: sync up with 3.0 for 3.0.11pre2
[Samba.git] / source / rpc_client / cli_spoolss.c
blob8094b2bf087fa987b122ad39324018ff05b586a6
1 /*
2 Unix SMB/CIFS implementation.
3 RPC pipe client
4
5 Copyright (C) Gerald Carter 2001-2002,
6 Copyright (C) Tim Potter 2000-2002,
7 Copyright (C) Andrew Tridgell 1994-2000,
8 Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
9 Copyright (C) Jean-Francois Micouleau 1999-2000.
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
28 /** @defgroup spoolss SPOOLSS - NT printing routines
29 * @ingroup rpc_client
30 *
31 * @{
32 **/
33
34 /**********************************************************************
35 Initialize a new spoolss buff for use by a client rpc
36 **********************************************************************/
37 static void init_buffer(NEW_BUFFER *buffer, uint32 size, TALLOC_CTX *ctx)
38 {
39 buffer->ptr = (size != 0);
40 buffer->size = size;
41 buffer->string_at_end = size;
42 prs_init(&buffer->prs, size, ctx, MARSHALL);
43 buffer->struct_start = prs_offset(&buffer->prs);
44 }
45
46 /*********************************************************************
47 Decode various spoolss rpc's and info levels
48 ********************************************************************/
49
50 /**********************************************************************
51 **********************************************************************/
52 static void decode_printer_info_0(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
53 uint32 returned, PRINTER_INFO_0 **info)
54 {
55 uint32 i;
56 PRINTER_INFO_0 *inf;
57
58 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_0, returned);
59 memset(inf, 0, returned*sizeof(PRINTER_INFO_0));
60
61 prs_set_offset(&buffer->prs,0);
62
63 for (i=0; i<returned; i++) {
64 smb_io_printer_info_0("", buffer, &inf[i], 0);
65 }
66
67 *info=inf;
68 }
69
70 /**********************************************************************
71 **********************************************************************/
72 static void decode_printer_info_1(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
73 uint32 returned, PRINTER_INFO_1 **info)
74 {
75 uint32 i;
76 PRINTER_INFO_1 *inf;
77
78 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_1, returned);
79 memset(inf, 0, returned*sizeof(PRINTER_INFO_1));
80
81 prs_set_offset(&buffer->prs,0);
82
83 for (i=0; i<returned; i++) {
84 smb_io_printer_info_1("", buffer, &inf[i], 0);
85 }
86
87 *info=inf;
88 }
89
90 /**********************************************************************
91 **********************************************************************/
92 static void decode_printer_info_2(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
93 uint32 returned, PRINTER_INFO_2 **info)
94 {
95 uint32 i;
96 PRINTER_INFO_2 *inf;
97
98 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_2, returned);
99 memset(inf, 0, returned*sizeof(PRINTER_INFO_2));
100
101 prs_set_offset(&buffer->prs,0);
102
103 for (i=0; i<returned; i++) {
104 /* a little initialization as we go */
105 inf[i].secdesc = NULL;
106 smb_io_printer_info_2("", buffer, &inf[i], 0);
107 }
108
109 *info=inf;
110 }
111
112 /**********************************************************************
113 **********************************************************************/
114 static void decode_printer_info_3(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
115 uint32 returned, PRINTER_INFO_3 **info)
116 {
117 uint32 i;
118 PRINTER_INFO_3 *inf;
119
120 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_3, returned);
121 memset(inf, 0, returned*sizeof(PRINTER_INFO_3));
122
123 prs_set_offset(&buffer->prs,0);
124
125 for (i=0; i<returned; i++) {
126 inf[i].secdesc = NULL;
127 smb_io_printer_info_3("", buffer, &inf[i], 0);
128 }
129
130 *info=inf;
131 }
132
133 /**********************************************************************
134 **********************************************************************/
135 static void decode_printer_info_7(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
136 uint32 returned, PRINTER_INFO_7 **info)
137 {
138 uint32 i;
139 PRINTER_INFO_7 *inf;
140
141 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_7, returned);
142 memset(inf, 0, returned*sizeof(PRINTER_INFO_7));
143
144 prs_set_offset(&buffer->prs,0);
145
146 for (i=0; i<returned; i++) {
147 smb_io_printer_info_7("", buffer, &inf[i], 0);
148 }
149
150 *info=inf;
151 }
152
153
154 /**********************************************************************
155 **********************************************************************/
156 static void decode_port_info_1(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
157 uint32 returned, PORT_INFO_1 **info)
158 {
159 uint32 i;
160 PORT_INFO_1 *inf;
161
162 inf=TALLOC_ARRAY(mem_ctx, PORT_INFO_1, returned);
163 memset(inf, 0, returned*sizeof(PORT_INFO_1));
164
165 prs_set_offset(&buffer->prs, 0);
166
167 for (i=0; i<returned; i++) {
168 smb_io_port_info_1("", buffer, &(inf[i]), 0);
169 }
170
171 *info=inf;
172 }
173
174 /**********************************************************************
175 **********************************************************************/
176 static void decode_port_info_2(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
177 uint32 returned, PORT_INFO_2 **info)
178 {
179 uint32 i;
180 PORT_INFO_2 *inf;
181
182 inf=TALLOC_ARRAY(mem_ctx, PORT_INFO_2, returned);
183 memset(inf, 0, returned*sizeof(PORT_INFO_2));
184
185 prs_set_offset(&buffer->prs, 0);
186
187 for (i=0; i<returned; i++) {
188 smb_io_port_info_2("", buffer, &(inf[i]), 0);
189 }
190
191 *info=inf;
192 }
193
194 /**********************************************************************
195 **********************************************************************/
196 static void decode_printer_driver_1(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
197 uint32 returned, DRIVER_INFO_1 **info)
198 {
199 uint32 i;
200 DRIVER_INFO_1 *inf;
201
202 inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_1, returned);
203 memset(inf, 0, returned*sizeof(DRIVER_INFO_1));
204
205 prs_set_offset(&buffer->prs,0);
206
207 for (i=0; i<returned; i++) {
208 smb_io_printer_driver_info_1("", buffer, &(inf[i]), 0);
209 }
210
211 *info=inf;
212 }
213
214 /**********************************************************************
215 **********************************************************************/
216 static void decode_printer_driver_2(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
217 uint32 returned, DRIVER_INFO_2 **info)
218 {
219 uint32 i;
220 DRIVER_INFO_2 *inf;
221
222 inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_2, returned);
223 memset(inf, 0, returned*sizeof(DRIVER_INFO_2));
224
225 prs_set_offset(&buffer->prs,0);
226
227 for (i=0; i<returned; i++) {
228 smb_io_printer_driver_info_2("", buffer, &(inf[i]), 0);
229 }
230
231 *info=inf;
232 }
233
234 /**********************************************************************
235 **********************************************************************/
236 static void decode_printer_driver_3(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
237 uint32 returned, DRIVER_INFO_3 **info)
238 {
239 uint32 i;
240 DRIVER_INFO_3 *inf;
241
242 inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_3, returned);
243 memset(inf, 0, returned*sizeof(DRIVER_INFO_3));
244
245 prs_set_offset(&buffer->prs,0);
246
247 for (i=0; i<returned; i++) {
248 smb_io_printer_driver_info_3("", buffer, &(inf[i]), 0);
249 }
250
251 *info=inf;
252 }
253
254 /**********************************************************************
255 **********************************************************************/
256 static void decode_printerdriverdir_1 (TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
257 uint32 returned, DRIVER_DIRECTORY_1 **info
258 )
259 {
260 DRIVER_DIRECTORY_1 *inf;
261
262 inf=TALLOC_P(mem_ctx, DRIVER_DIRECTORY_1);
263 memset(inf, 0, sizeof(DRIVER_DIRECTORY_1));
264
265 prs_set_offset(&buffer->prs, 0);
266
267 smb_io_driverdir_1("", buffer, inf, 0);
268
269 *info=inf;
270 }
271
272 /** Return a handle to the specified printer or print server.
273 *
274 * @param cli Pointer to client state structure which is open
275 * on the SPOOLSS pipe.
276 *
277 * @param mem_ctx Pointer to an initialised talloc context.
278 *
279 * @param printername The name of the printer or print server to be
280 * opened in UNC format.
281 *
282 * @param datatype Specifies the default data type for the printer.
283 *
284 * @param access_required The access rights requested on the printer or
285 * print server.
286 *
287 * @param station The UNC name of the requesting workstation.
288 *
289 * @param username The name of the user requesting the open.
290 *
291 * @param pol Returned policy handle.
292 */
293
294 /*********************************************************************************
295 Win32 API - OpenPrinter()
296 ********************************************************************************/
297
298 WERROR cli_spoolss_open_printer_ex(struct cli_state *cli, TALLOC_CTX *mem_ctx,
299 const char *printername, const char *datatype, uint32 access_required,
300 const char *station, const char *username, POLICY_HND *pol)
301 {
302 prs_struct qbuf, rbuf;
303 SPOOL_Q_OPEN_PRINTER_EX q;
304 SPOOL_R_OPEN_PRINTER_EX r;
305 WERROR result = W_ERROR(ERRgeneral);
306
307 ZERO_STRUCT(q);
308 ZERO_STRUCT(r);
309
310 /* Initialise parse structures */
311
312 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
313 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
314
315 /* Initialise input parameters */
316
317 make_spoolss_q_open_printer_ex(&q, printername, datatype,
318 access_required, station, username);
319
320 /* Marshall data and send request */
321
322 if (!spoolss_io_q_open_printer_ex("", &q, &qbuf, 0) ||
323 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_OPENPRINTEREX, &qbuf, &rbuf))
324 goto done;
325
326 /* Unmarshall response */
327
328 if (!spoolss_io_r_open_printer_ex("", &r, &rbuf, 0))
329 goto done;
330
331 /* Return output parameters */
332
333 result = r.status;
334
335 if (W_ERROR_IS_OK(result))
336 *pol = r.handle;
337
338 done:
339 prs_mem_free(&qbuf);
340 prs_mem_free(&rbuf);
341
342 return result;
343 }
344
345 /** Close a printer handle
346 *
347 * @param cli Pointer to client state structure which is open
348 * on the SPOOLSS pipe.
349 *
350 * @param mem_ctx Pointer to an initialised talloc context.
351 *
352 * @param pol Policy handle of printer or print server to close.
353 */
354 /*********************************************************************************
355 Win32 API - ClosePrinter()
356 ********************************************************************************/
357
358 WERROR cli_spoolss_close_printer(struct cli_state *cli, TALLOC_CTX *mem_ctx,
359 POLICY_HND *pol)
360 {
361 prs_struct qbuf, rbuf;
362 SPOOL_Q_CLOSEPRINTER q;
363 SPOOL_R_CLOSEPRINTER r;
364 WERROR result = W_ERROR(ERRgeneral);
365
366 ZERO_STRUCT(q);
367 ZERO_STRUCT(r);
368
369 /* Initialise parse structures */
370
371 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
372 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
373
374 /* Initialise input parameters */
375
376 make_spoolss_q_closeprinter(&q, pol);
377
378 /* Marshall data and send request */
379
380 if (!spoolss_io_q_closeprinter("", &q, &qbuf, 0) ||
381 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_CLOSEPRINTER, &qbuf, &rbuf))
382 goto done;
383
384 /* Unmarshall response */
385
386 if (!spoolss_io_r_closeprinter("", &r, &rbuf, 0))
387 goto done;
388
389 /* Return output parameters */
390
391 result = r.status;
392
393 if (W_ERROR_IS_OK(result))
394 *pol = r.handle;
395
396 done:
397 prs_mem_free(&qbuf);
398 prs_mem_free(&rbuf);
399
400 return result;
401 }
402
403 /** Enumerate printers on a print server.
404 *
405 * @param cli Pointer to client state structure which is open
406 * on the SPOOLSS pipe.
407 * @param mem_ctx Pointer to an initialised talloc context.
408 *
409 * @param offered Buffer size offered in the request.
410 * @param needed Number of bytes needed to complete the request.
411 * may be NULL.
412 *
413 * @param flags Selected from PRINTER_ENUM_* flags.
414 * @param level Request information level.
415 *
416 * @param num_printers Pointer to number of printers returned. May be
417 * NULL.
418 * @param ctr Return structure for printer information. May
419 * be NULL.
420 */
421 /*********************************************************************************
422 Win32 API - EnumPrinters()
423 ********************************************************************************/
424
425 WERROR cli_spoolss_enum_printers(struct cli_state *cli, TALLOC_CTX *mem_ctx,
426 uint32 offered, uint32 *needed,
427 char *name, uint32 flags, uint32 level,
428 uint32 *num_printers, PRINTER_INFO_CTR *ctr)
429 {
430 prs_struct qbuf, rbuf;
431 SPOOL_Q_ENUMPRINTERS q;
432 SPOOL_R_ENUMPRINTERS r;
433 NEW_BUFFER buffer;
434 WERROR result = W_ERROR(ERRgeneral);
435
436 ZERO_STRUCT(q);
437 ZERO_STRUCT(r);
438
439 /* Initialise input parameters */
440
441 init_buffer(&buffer, offered, mem_ctx);
442
443 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
444 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
445
446 make_spoolss_q_enumprinters(&q, flags, name, level, &buffer,
447 offered);
448
449 /* Marshall data and send request */
450
451 if (!spoolss_io_q_enumprinters("", &q, &qbuf, 0) ||
452 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_ENUMPRINTERS, &qbuf, &rbuf))
453 goto done;
454
455 /* Unmarshall response */
456
457 if (spoolss_io_r_enumprinters("", &r, &rbuf, 0)) {
458 if (needed)
459 *needed = r.needed;
460 }
461
462 result = r.status;
463
464 /* Return output parameters */
465
466 if (!W_ERROR_IS_OK(r.status))
467 goto done;
468
469 if (num_printers)
470 *num_printers = r.returned;
471
472 if (!ctr)
473 goto done;
474
475 switch (level) {
476 case 0:
477 decode_printer_info_0(mem_ctx, r.buffer, r.returned,
478 &ctr->printers_0);
479 break;
480 case 1:
481 decode_printer_info_1(mem_ctx, r.buffer, r.returned,
482 &ctr->printers_1);
483 break;
484 case 2:
485 decode_printer_info_2(mem_ctx, r.buffer, r.returned,
486 &ctr->printers_2);
487 break;
488 case 3:
489 decode_printer_info_3(mem_ctx, r.buffer, r.returned,
490 &ctr->printers_3);
491 break;
492 }
493
494 done:
495 prs_mem_free(&qbuf);
496 prs_mem_free(&rbuf);
497
498 return result;
499 }
500
501 /*********************************************************************************
502 Win32 API - EnumPorts()
503 ********************************************************************************/
504 /** Enumerate printer ports on a print server.
505 *
506 * @param cli Pointer to client state structure which is open
507 * on the SPOOLSS pipe.
508 * @param mem_ctx Pointer to an initialised talloc context.
509 *
510 * @param offered Buffer size offered in the request.
511 * @param needed Number of bytes needed to complete the request.
512 * May be NULL.
513 *
514 * @param level Requested information level.
515 *
516 * @param num_ports Pointer to number of ports returned. May be NULL.
517 * @param ctr Pointer to structure holding port information.
518 * May be NULL.
519 */
520
521 WERROR cli_spoolss_enum_ports(struct cli_state *cli, TALLOC_CTX *mem_ctx,
522 uint32 offered, uint32 *needed,
523 uint32 level, uint32 *num_ports, PORT_INFO_CTR *ctr)
524 {
525 prs_struct qbuf, rbuf;
526 SPOOL_Q_ENUMPORTS q;
527 SPOOL_R_ENUMPORTS r;
528 NEW_BUFFER buffer;
529 WERROR result = W_ERROR(ERRgeneral);
530 fstring server;
531
532 ZERO_STRUCT(q);
533 ZERO_STRUCT(r);
534
535 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
536 strupper_m(server);
537
538 /* Initialise input parameters */
539
540 init_buffer(&buffer, offered, mem_ctx);
541
542 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
543 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
544
545 make_spoolss_q_enumports(&q, server, level, &buffer, offered);
546
547 /* Marshall data and send request */
548
549 if (!spoolss_io_q_enumports("", &q, &qbuf, 0) ||
550 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_ENUMPORTS, &qbuf, &rbuf))
551 goto done;
552
553 /* Unmarshall response */
554
555 if (spoolss_io_r_enumports("", &r, &rbuf, 0)) {
556 if (needed)
557 *needed = r.needed;
558 }
559
560 result = r.status;
561
562 /* Return output parameters */
563
564 if (!W_ERROR_IS_OK(result))
565 goto done;
566
567 if (num_ports)
568 *num_ports = r.returned;
569
570 if (!ctr)
571 goto done;
572
573 switch (level) {
574 case 1:
575 decode_port_info_1(mem_ctx, r.buffer, r.returned,
576 &ctr->port.info_1);
577 break;
578 case 2:
579 decode_port_info_2(mem_ctx, r.buffer, r.returned,
580 &ctr->port.info_2);
581 break;
582 }
583
584 done:
585 prs_mem_free(&qbuf);
586 prs_mem_free(&rbuf);
587
588 return result;
589 }
590
591 /*********************************************************************************
592 Win32 API - GetPrinter()
593 ********************************************************************************/
594
595 WERROR cli_spoolss_getprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
596 uint32 offered, uint32 *needed,
597 POLICY_HND *pol, uint32 level,
598 PRINTER_INFO_CTR *ctr)
599 {
600 prs_struct qbuf, rbuf;
601 SPOOL_Q_GETPRINTER q;
602 SPOOL_R_GETPRINTER r;
603 NEW_BUFFER buffer;
604 WERROR result = W_ERROR(ERRgeneral);
605
606 ZERO_STRUCT(q);
607 ZERO_STRUCT(r);
608
609 /* Initialise input parameters */
610
611 init_buffer(&buffer, offered, mem_ctx);
612
613 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
614 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
615
616 make_spoolss_q_getprinter(mem_ctx, &q, pol, level, &buffer, offered);
617
618 /* Marshall data and send request */
619
620 if (!spoolss_io_q_getprinter("", &q, &qbuf, 0) ||
621 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_GETPRINTER, &qbuf, &rbuf))
622 goto done;
623
624 /* Unmarshall response */
625
626 if (!spoolss_io_r_getprinter("", &r, &rbuf, 0))
627 goto done;
628
629 if (needed)
630 *needed = r.needed;
631
632 /* Return output parameters */
633
634 result = r.status;
635
636 if (W_ERROR_IS_OK(result)) {
637 switch (level) {
638 case 0:
639 decode_printer_info_0(mem_ctx, r.buffer, 1, &ctr->printers_0);
640 break;
641 case 1:
642 decode_printer_info_1(mem_ctx, r.buffer, 1, &ctr->printers_1);
643 break;
644 case 2:
645 decode_printer_info_2(mem_ctx, r.buffer, 1, &ctr->printers_2);
646 break;
647 case 3:
648 decode_printer_info_3(mem_ctx, r.buffer, 1, &ctr->printers_3);
649 break;
650 case 7:
651 decode_printer_info_7(mem_ctx, r.buffer, 1, &ctr->printers_7);
652 break;
653 }
654 }
655
656 done:
657 prs_mem_free(&qbuf);
658 prs_mem_free(&rbuf);
659
660 return result;
661 }
662
663 /*********************************************************************************
664 Win32 API - SetPrinter()
665 ********************************************************************************/
666 /** Set printer info
667 *
668 * @param cli Pointer to client state structure which is open
669 * on the SPOOLSS pipe.
670 * @param mem_ctx Pointer to an initialised talloc context.
671 *
672 * @param pol Policy handle on printer to set info.
673 * @param level Information level to set.
674 * @param ctr Pointer to structure holding printer information.
675 * @param command Specifies the action performed. See
676 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/gdi/prntspol_13ua.asp
677 * for details.
678 *
679 */
680
681 WERROR cli_spoolss_setprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
682 POLICY_HND *pol, uint32 level,
683 PRINTER_INFO_CTR *ctr, uint32 command)
684 {
685 prs_struct qbuf, rbuf;
686 SPOOL_Q_SETPRINTER q;
687 SPOOL_R_SETPRINTER r;
688 WERROR result = W_ERROR(ERRgeneral);
689
690 ZERO_STRUCT(q);
691 ZERO_STRUCT(r);
692
693 /* Initialise input parameters */
694
695 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
696 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
697
698 if (!make_spoolss_q_setprinter(mem_ctx, &q, pol, level, ctr, command))
699 goto done;
700
701 /* Marshall data and send request */
702
703 if (!spoolss_io_q_setprinter("", &q, &qbuf, 0) ||
704 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_SETPRINTER, &qbuf, &rbuf))
705 goto done;
706
707 /* Unmarshall response */
708
709 if (!spoolss_io_r_setprinter("", &r, &rbuf, 0))
710 goto done;
711
712 result = r.status;
713
714 done:
715 prs_mem_free(&qbuf);
716 prs_mem_free(&rbuf);
717
718 return result;
719 }
720
721 /*********************************************************************************
722 Win32 API - GetPrinterDriver()
723 ********************************************************************************/
724 /** Get installed printer drivers for a given printer
725 *
726 * @param cli Pointer to client state structure which is open
727 * on the SPOOLSS pipe.
728 *
729 * @param mem_ctx Pointer to an initialised talloc context.
730 *
731 * @param offered Buffer size offered in the request.
732 * @param needed Number of bytes needed to complete the request.
733 * may be NULL.
734 *
735 * @param pol Pointer to an open policy handle for the printer
736 * opened with cli_spoolss_open_printer_ex().
737 * @param level Requested information level.
738 * @param env The print environment or archictecture. This is
739 * "Windows NT x86" for NT4.
740 * @param ctr Returned printer driver information.
741 */
742
743 WERROR cli_spoolss_getprinterdriver(struct cli_state *cli,
744 TALLOC_CTX *mem_ctx,
745 uint32 offered, uint32 *needed,
746 POLICY_HND *pol, uint32 level,
747 const char *env, int version, PRINTER_DRIVER_CTR *ctr)
748 {
749 prs_struct qbuf, rbuf;
750 SPOOL_Q_GETPRINTERDRIVER2 q;
751 SPOOL_R_GETPRINTERDRIVER2 r;
752 NEW_BUFFER buffer;
753 WERROR result = W_ERROR(ERRgeneral);
754 fstring server;
755
756 ZERO_STRUCT(q);
757 ZERO_STRUCT(r);
758
759 fstrcpy(server, cli->desthost);
760 strupper_m(server);
761
762 /* Initialise input parameters */
763
764 init_buffer(&buffer, offered, mem_ctx);
765
766 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
767 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
768
769 make_spoolss_q_getprinterdriver2(&q, pol, env, level, version, 2,
770 &buffer, offered);
771
772 /* Marshall data and send request */
773
774 if (!spoolss_io_q_getprinterdriver2 ("", &q, &qbuf, 0) ||
775 !rpc_api_pipe_req (cli, PI_SPOOLSS, SPOOLSS_GETPRINTERDRIVER2, &qbuf, &rbuf))
776 goto done;
777
778 /* Unmarshall response */
779
780 if (spoolss_io_r_getprinterdriver2 ("", &r, &rbuf, 0)) {
781 if (needed)
782 *needed = r.needed;
783 }
784
785 result = r.status;
786
787 /* Return output parameters */
788
789 if (!W_ERROR_IS_OK(result))
790 goto done;
791
792 if (!ctr)
793 goto done;
794
795 switch (level) {
796 case 1:
797 decode_printer_driver_1(mem_ctx, r.buffer, 1, &ctr->info1);
798 break;
799 case 2:
800 decode_printer_driver_2(mem_ctx, r.buffer, 1, &ctr->info2);
801 break;
802 case 3:
803 decode_printer_driver_3(mem_ctx, r.buffer, 1, &ctr->info3);
804 break;
805 default:
806 DEBUG(10, ("cli_spoolss_getprinterdriver: unknown info level %d", level));
807 return WERR_UNKNOWN_LEVEL;
808 }
809
810 done:
811 prs_mem_free(&qbuf);
812 prs_mem_free(&rbuf);
813
814 return result;
815 }
816
817 /*********************************************************************************
818 Win32 API - EnumPrinterDrivers()
819 ********************************************************************************/
820 /**********************************************************************
821 * Get installed printer drivers for a given printer
822 */
823 WERROR cli_spoolss_enumprinterdrivers (struct cli_state *cli,
824 TALLOC_CTX *mem_ctx,
825 uint32 offered, uint32 *needed,
826 uint32 level, const char *env,
827 uint32 *num_drivers,
828 PRINTER_DRIVER_CTR *ctr)
829 {
830 prs_struct qbuf, rbuf;
831 SPOOL_Q_ENUMPRINTERDRIVERS q;
832 SPOOL_R_ENUMPRINTERDRIVERS r;
833 NEW_BUFFER buffer;
834 WERROR result = W_ERROR(ERRgeneral);
835 fstring server;
836
837 ZERO_STRUCT(q);
838 ZERO_STRUCT(r);
839
840 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
841 strupper_m(server);
842
843 /* Initialise input parameters */
844
845 init_buffer(&buffer, offered, mem_ctx);
846
847 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
848 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
849
850 /* Write the request */
851
852 make_spoolss_q_enumprinterdrivers(&q, server, env, level, &buffer,
853 offered);
854
855 /* Marshall data and send request */
856
857 if (!spoolss_io_q_enumprinterdrivers ("", &q, &qbuf, 0) ||
858 !rpc_api_pipe_req (cli, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDRIVERS, &qbuf, &rbuf))
859 goto done;
860
861 /* Unmarshall response */
862
863 if (!spoolss_io_r_enumprinterdrivers ("", &r, &rbuf, 0))
864 goto done;
865
866 if (needed)
867 *needed = r.needed;
868
869 if (num_drivers)
870 *num_drivers = r.returned;
871
872 result = r.status;
873
874 /* Return output parameters */
875
876 if (W_ERROR_IS_OK(result) && (r.returned != 0)) {
877 *num_drivers = r.returned;
878
879 switch (level) {
880 case 1:
881 decode_printer_driver_1(mem_ctx, r.buffer, r.returned, &ctr->info1);
882 break;
883 case 2:
884 decode_printer_driver_2(mem_ctx, r.buffer, r.returned, &ctr->info2);
885 break;
886 case 3:
887 decode_printer_driver_3(mem_ctx, r.buffer, r.returned, &ctr->info3);
888 break;
889 default:
890 DEBUG(10, ("cli_spoolss_enumprinterdrivers: unknown info level %d\n",
891 level));
892 return WERR_UNKNOWN_LEVEL;
893 }
894 }
895
896 done:
897 prs_mem_free(&qbuf);
898 prs_mem_free(&rbuf);
899
900 return result;
901 }
902
903
904 /*********************************************************************************
905 Win32 API - GetPrinterDriverDirectory()
906 ********************************************************************************/
907 /**********************************************************************
908 * Get installed printer drivers for a given printer
909 */
910 WERROR cli_spoolss_getprinterdriverdir (struct cli_state *cli,
911 TALLOC_CTX *mem_ctx,
912 uint32 offered, uint32 *needed,
913 uint32 level, char *env,
914 DRIVER_DIRECTORY_CTR *ctr)
915 {
916 prs_struct qbuf, rbuf;
917 SPOOL_Q_GETPRINTERDRIVERDIR q;
918 SPOOL_R_GETPRINTERDRIVERDIR r;
919 NEW_BUFFER buffer;
920 WERROR result = W_ERROR(ERRgeneral);
921 fstring server;
922
923 ZERO_STRUCT(q);
924 ZERO_STRUCT(r);
925
926 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
927 strupper_m(server);
928
929 /* Initialise input parameters */
930
931 init_buffer(&buffer, offered, mem_ctx);
932
933 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
934 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
935
936 /* Write the request */
937
938 make_spoolss_q_getprinterdriverdir(&q, server, env, level, &buffer,
939 offered);
940
941 /* Marshall data and send request */
942
943 if (!spoolss_io_q_getprinterdriverdir ("", &q, &qbuf, 0) ||
944 !rpc_api_pipe_req (cli, PI_SPOOLSS, SPOOLSS_GETPRINTERDRIVERDIRECTORY,
945 &qbuf, &rbuf))
946 goto done;
947
948 /* Unmarshall response */
949
950 if (spoolss_io_r_getprinterdriverdir ("", &r, &rbuf, 0)) {
951 if (needed)
952 *needed = r.needed;
953 }
954
955 /* Return output parameters */
956
957 result = r.status;
958
959 if (W_ERROR_IS_OK(result)) {
960 switch (level) {
961 case 1:
962 decode_printerdriverdir_1(mem_ctx, r.buffer, 1,
963 &ctr->info1);
964 break;
965 }
966 }
967
968 done:
969 prs_mem_free(&qbuf);
970 prs_mem_free(&rbuf);
971
972 return result;
973 }
974
975 /*********************************************************************************
976 Win32 API - AddPrinterDriver()
977 ********************************************************************************/
978 /**********************************************************************
979 * Install a printer driver
980 */
981 WERROR cli_spoolss_addprinterdriver (struct cli_state *cli,
982 TALLOC_CTX *mem_ctx, uint32 level,
983 PRINTER_DRIVER_CTR *ctr)
984 {
985 prs_struct qbuf, rbuf;
986 SPOOL_Q_ADDPRINTERDRIVER q;
987 SPOOL_R_ADDPRINTERDRIVER r;
988 WERROR result = W_ERROR(ERRgeneral);
989 fstring server;
990
991 ZERO_STRUCT(q);
992 ZERO_STRUCT(r);
993
994 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
995 strupper_m(server);
996
997 /* Initialise input parameters */
998
999 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1000 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1001
1002 /* Write the request */
1003
1004 make_spoolss_q_addprinterdriver (mem_ctx, &q, server, level, ctr);
1005
1006 /* Marshall data and send request */
1007
1008 if (!spoolss_io_q_addprinterdriver ("", &q, &qbuf, 0) ||
1009 !rpc_api_pipe_req (cli, PI_SPOOLSS, SPOOLSS_ADDPRINTERDRIVER, &qbuf, &rbuf))
1010 goto done;
1011
1012 /* Unmarshall response */
1013
1014 if (!spoolss_io_r_addprinterdriver ("", &r, &rbuf, 0))
1015 goto done;
1016
1017 /* Return output parameters */
1018
1019 result = r.status;
1020
1021 done:
1022 prs_mem_free(&qbuf);
1023 prs_mem_free(&rbuf);
1024
1025 return result;
1026 }
1027
1028 /*********************************************************************************
1029 Win32 API - AddPrinter()
1030 ********************************************************************************/
1031 /**********************************************************************
1032 * Install a printer
1033 */
1034 WERROR cli_spoolss_addprinterex (struct cli_state *cli, TALLOC_CTX *mem_ctx,
1035 uint32 level, PRINTER_INFO_CTR*ctr)
1036 {
1037 prs_struct qbuf, rbuf;
1038 SPOOL_Q_ADDPRINTEREX q;
1039 SPOOL_R_ADDPRINTEREX r;
1040 WERROR result = W_ERROR(ERRgeneral);
1041 fstring server,
1042 client,
1043 user;
1044
1045 ZERO_STRUCT(q);
1046 ZERO_STRUCT(r);
1047
1048 slprintf(client, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1049 strupper_m(client);
1050 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1051 strupper_m(server);
1052 fstrcpy (user, cli->user_name);
1053
1054 /* Initialise input parameters */
1055
1056 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1057 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1058
1059 /* Write the request */
1060
1061 make_spoolss_q_addprinterex (mem_ctx, &q, server, client, user,
1062 level, ctr);
1063
1064 /* Marshall data and send request */
1065
1066 if (!spoolss_io_q_addprinterex ("", &q, &qbuf, 0) ||
1067 !rpc_api_pipe_req (cli, PI_SPOOLSS, SPOOLSS_ADDPRINTEREX, &qbuf, &rbuf))
1068 goto done;
1069
1070 /* Unmarshall response */
1071
1072 if (!spoolss_io_r_addprinterex ("", &r, &rbuf, 0))
1073 goto done;
1074
1075 /* Return output parameters */
1076
1077 result = r.status;
1078
1079 done:
1080 prs_mem_free(&qbuf);
1081 prs_mem_free(&rbuf);
1082
1083 return result;
1084 }
1085
1086 /**********************************************************************
1087 * Delete a Printer Driver from the server (DOES remove
1088 * the driver files)
1089 */
1090 WERROR cli_spoolss_deleteprinterdriverex(struct cli_state *cli,
1091 TALLOC_CTX *mem_ctx, const char *arch,
1092 const char *driver, uint32 version)
1093 {
1094 prs_struct qbuf, rbuf;
1095 SPOOL_Q_DELETEPRINTERDRIVEREX q;
1096 SPOOL_R_DELETEPRINTERDRIVEREX r;
1097 WERROR result = W_ERROR(ERRgeneral);
1098 fstring server;
1099
1100 ZERO_STRUCT(q);
1101 ZERO_STRUCT(r);
1102
1103
1104 /* Initialise input parameters */
1105 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1106 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1107
1108 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1109 strupper_m(server);
1110
1111 /* Write the request */
1112 make_spoolss_q_deleteprinterdriverex(mem_ctx, &q, server, arch, driver, version);
1113
1114 /* Marshall data and send request */
1115
1116 if (!spoolss_io_q_deleteprinterdriverex ("", &q, &qbuf, 0)
1117 || !rpc_api_pipe_req (cli, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDRIVEREX , &qbuf, &rbuf))
1118 {
1119 goto done;
1120 }
1121
1122 /* Unmarshall response */
1123
1124 if (!spoolss_io_r_deleteprinterdriverex ("", &r, &rbuf, 0))
1125 goto done;
1126
1127 /* Return output parameters */
1128
1129 result = r.status;
1130
1131 done:
1132 prs_mem_free(&qbuf);
1133 prs_mem_free(&rbuf);
1134
1135 return result;
1136 }
1137
1138 /*********************************************************************************
1139 Win32 API - DeltePrinterDriver()
1140 ********************************************************************************/
1141 /**********************************************************************
1142 * Delete a Printer Driver from the server (does not remove
1143 * the driver files
1144 */
1145 WERROR cli_spoolss_deleteprinterdriver (struct cli_state *cli,
1146 TALLOC_CTX *mem_ctx, const char *arch,
1147 const char *driver)
1148 {
1149 prs_struct qbuf, rbuf;
1150 SPOOL_Q_DELETEPRINTERDRIVER q;
1151 SPOOL_R_DELETEPRINTERDRIVER r;
1152 WERROR result = W_ERROR(ERRgeneral);
1153 fstring server;
1154
1155 ZERO_STRUCT(q);
1156 ZERO_STRUCT(r);
1157
1158
1159 /* Initialise input parameters */
1160 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1161 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1162
1163 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1164 strupper_m(server);
1165
1166 /* Write the request */
1167
1168 make_spoolss_q_deleteprinterdriver(mem_ctx, &q, server, arch, driver);
1169
1170 /* Marshall data and send request */
1171
1172 if (!spoolss_io_q_deleteprinterdriver ("", &q, &qbuf, 0) ||
1173 !rpc_api_pipe_req (cli, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDRIVER , &qbuf, &rbuf))
1174 goto done;
1175
1176 /* Unmarshall response */
1177
1178 if (!spoolss_io_r_deleteprinterdriver ("", &r, &rbuf, 0))
1179 goto done;
1180
1181 /* Return output parameters */
1182
1183 result = r.status;
1184
1185 done:
1186 prs_mem_free(&qbuf);
1187 prs_mem_free(&rbuf);
1188
1189 return result;
1190 }
1191
1192 /*********************************************************************************
1193 Win32 API - GetPrinterProcessorDirectory()
1194 ********************************************************************************/
1195
1196 WERROR cli_spoolss_getprintprocessordirectory(struct cli_state *cli,
1197 TALLOC_CTX *mem_ctx,
1198 uint32 offered, uint32 *needed,
1199 char *name, char *environment,
1200 fstring procdir)
1201 {
1202 prs_struct qbuf, rbuf;
1203 SPOOL_Q_GETPRINTPROCESSORDIRECTORY q;
1204 SPOOL_R_GETPRINTPROCESSORDIRECTORY r;
1205 int level = 1;
1206 WERROR result = W_ERROR(ERRgeneral);
1207 NEW_BUFFER buffer;
1208
1209 ZERO_STRUCT(q);
1210 ZERO_STRUCT(r);
1211
1212 /* Initialise parse structures */
1213
1214 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1215 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1216
1217 /* Initialise input parameters */
1218
1219 init_buffer(&buffer, offered, mem_ctx);
1220
1221 make_spoolss_q_getprintprocessordirectory(
1222 &q, name, environment, level, &buffer, offered);
1223
1224 /* Marshall data and send request */
1225
1226 if (!spoolss_io_q_getprintprocessordirectory("", &q, &qbuf, 0) ||
1227 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_GETPRINTPROCESSORDIRECTORY,
1228 &qbuf, &rbuf))
1229 goto done;
1230
1231 /* Unmarshall response */
1232
1233 if (!spoolss_io_r_getprintprocessordirectory("", &r, &rbuf, 0))
1234 goto done;
1235
1236 /* Return output parameters */
1237
1238 result = r.status;
1239
1240 if (needed)
1241 *needed = r.needed;
1242
1243 if (W_ERROR_IS_OK(result))
1244 fstrcpy(procdir, "Not implemented!");
1245
1246 done:
1247 prs_mem_free(&qbuf);
1248 prs_mem_free(&rbuf);
1249
1250 return result;
1251 }
1252
1253 /** Add a form to a printer.
1254 *
1255 * @param cli Pointer to client state structure which is open
1256 * on the SPOOLSS pipe.
1257 * @param mem_ctx Pointer to an initialised talloc context.
1258 *
1259 * @param handle Policy handle opened with cli_spoolss_open_printer_ex
1260 * or cli_spoolss_addprinterex.
1261 * @param level Form info level to add - should always be 1.
1262 * @param form A pointer to the form to be added.
1263 *
1264 */
1265
1266 WERROR cli_spoolss_addform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1267 POLICY_HND *handle, uint32 level, FORM *form)
1268 {
1269 prs_struct qbuf, rbuf;
1270 SPOOL_Q_ADDFORM q;
1271 SPOOL_R_ADDFORM r;
1272 WERROR result = W_ERROR(ERRgeneral);
1273
1274 ZERO_STRUCT(q);
1275 ZERO_STRUCT(r);
1276
1277 /* Initialise parse structures */
1278
1279 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1280 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1281
1282 /* Initialise input parameters */
1283
1284 make_spoolss_q_addform(&q, handle, level, form);
1285
1286 /* Marshall data and send request */
1287
1288 if (!spoolss_io_q_addform("", &q, &qbuf, 0) ||
1289 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_ADDFORM, &qbuf, &rbuf))
1290 goto done;
1291
1292 /* Unmarshall response */
1293
1294 if (!spoolss_io_r_addform("", &r, &rbuf, 0))
1295 goto done;
1296
1297 /* Return output parameters */
1298
1299 result = r.status;
1300
1301 done:
1302 prs_mem_free(&qbuf);
1303 prs_mem_free(&rbuf);
1304
1305 return result;
1306 }
1307
1308 /** Set a form on a printer.
1309 *
1310 * @param cli Pointer to client state structure which is open
1311 * on the SPOOLSS pipe.
1312 * @param mem_ctx Pointer to an initialised talloc context.
1313 *
1314 * @param handle Policy handle opened with cli_spoolss_open_printer_ex
1315 * or cli_spoolss_addprinterex.
1316 * @param level Form info level to set - should always be 1.
1317 * @param form A pointer to the form to be set.
1318 *
1319 */
1320
1321 WERROR cli_spoolss_setform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1322 POLICY_HND *handle, uint32 level,
1323 const char *form_name, FORM *form)
1324 {
1325 prs_struct qbuf, rbuf;
1326 SPOOL_Q_SETFORM q;
1327 SPOOL_R_SETFORM r;
1328 WERROR result = W_ERROR(ERRgeneral);
1329
1330 ZERO_STRUCT(q);
1331 ZERO_STRUCT(r);
1332
1333 /* Initialise parse structures */
1334
1335 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1336 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1337
1338 /* Initialise input parameters */
1339
1340 make_spoolss_q_setform(&q, handle, level, form_name, form);
1341
1342 /* Marshall data and send request */
1343
1344 if (!spoolss_io_q_setform("", &q, &qbuf, 0) ||
1345 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_SETFORM, &qbuf, &rbuf))
1346 goto done;
1347
1348 /* Unmarshall response */
1349
1350 if (!spoolss_io_r_setform("", &r, &rbuf, 0))
1351 goto done;
1352
1353 /* Return output parameters */
1354
1355 result = r.status;
1356
1357 if (!W_ERROR_IS_OK(result))
1358 goto done;
1359
1360
1361
1362 done:
1363 prs_mem_free(&qbuf);
1364 prs_mem_free(&rbuf);
1365
1366 return result;
1367 }
1368
1369 /** Get a form on a printer.
1370 *
1371 * @param cli Pointer to client state structure which is open
1372 * on the SPOOLSS pipe.
1373 * @param mem_ctx Pointer to an initialised talloc context.
1374 *
1375 * @param handle Policy handle opened with cli_spoolss_open_printer_ex
1376 * or cli_spoolss_addprinterex.
1377 * @param formname Name of the form to get
1378 * @param level Form info level to get - should always be 1.
1379 *
1380 */
1381
1382 WERROR cli_spoolss_getform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1383 uint32 offered, uint32 *needed,
1384 POLICY_HND *handle, const char *formname,
1385 uint32 level, FORM_1 *form)
1386 {
1387 prs_struct qbuf, rbuf;
1388 SPOOL_Q_GETFORM q;
1389 SPOOL_R_GETFORM r;
1390 WERROR result = W_ERROR(ERRgeneral);
1391 NEW_BUFFER buffer;
1392
1393 ZERO_STRUCT(q);
1394 ZERO_STRUCT(r);
1395
1396 /* Initialise parse structures */
1397
1398 init_buffer(&buffer, offered, mem_ctx);
1399
1400 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1401 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1402
1403 /* Initialise input parameters */
1404
1405 make_spoolss_q_getform(&q, handle, formname, level, &buffer, offered);
1406
1407 /* Marshall data and send request */
1408
1409 if (!spoolss_io_q_getform("", &q, &qbuf, 0) ||
1410 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_GETFORM, &qbuf, &rbuf))
1411 goto done;
1412
1413 /* Unmarshall response */
1414
1415 if (!spoolss_io_r_getform("", &r, &rbuf, 0))
1416 goto done;
1417
1418 /* Return output parameters */
1419
1420 result = r.status;
1421
1422 if (needed)
1423 *needed = r.needed;
1424
1425 if (W_ERROR_IS_OK(result)) {
1426 switch(level) {
1427 case 1:
1428 smb_io_form_1("", r.buffer, form, 0);
1429 break;
1430 default:
1431 DEBUG(10, ("cli_spoolss_getform: unknown info level %d", level));
1432 return WERR_UNKNOWN_LEVEL;
1433 }
1434 }
1435
1436 done:
1437 prs_mem_free(&qbuf);
1438 prs_mem_free(&rbuf);
1439
1440 return result;
1441 }
1442
1443 /** Delete a form on a printer.
1444 *
1445 * @param cli Pointer to client state structure which is open
1446 * on the SPOOLSS pipe.
1447 * @param mem_ctx Pointer to an initialised talloc context.
1448 *
1449 * @param handle Policy handle opened with cli_spoolss_open_printer_ex
1450 * or cli_spoolss_addprinterex.
1451 * @param form The name of the form to delete.
1452 *
1453 */
1454
1455 WERROR cli_spoolss_deleteform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1456 POLICY_HND *handle, const char *form_name)
1457 {
1458 prs_struct qbuf, rbuf;
1459 SPOOL_Q_DELETEFORM q;
1460 SPOOL_R_DELETEFORM r;
1461 WERROR result = W_ERROR(ERRgeneral);
1462
1463 ZERO_STRUCT(q);
1464 ZERO_STRUCT(r);
1465
1466 /* Initialise parse structures */
1467
1468 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1469 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1470
1471 /* Initialise input parameters */
1472
1473 make_spoolss_q_deleteform(&q, handle, form_name);
1474
1475 /* Marshall data and send request */
1476
1477 if (!spoolss_io_q_deleteform("", &q, &qbuf, 0) ||
1478 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_DELETEFORM, &qbuf, &rbuf))
1479 goto done;
1480
1481 /* Unmarshall response */
1482
1483 if (!spoolss_io_r_deleteform("", &r, &rbuf, 0))
1484 goto done;
1485
1486 /* Return output parameters */
1487
1488 result = r.status;
1489
1490 done:
1491 prs_mem_free(&qbuf);
1492 prs_mem_free(&rbuf);
1493
1494 return result;
1495 }
1496
1497 static void decode_forms_1(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
1498 uint32 num_forms, FORM_1 **forms)
1499 {
1500 int i;
1501
1502 *forms = TALLOC_ARRAY(mem_ctx, FORM_1, num_forms);
1503 prs_set_offset(&buffer->prs,0);
1504
1505 for (i = 0; i < num_forms; i++)
1506 smb_io_form_1("", buffer, &((*forms)[i]), 0);
1507 }
1508
1509 /** Enumerate forms
1510 *
1511 * @param cli Pointer to client state structure which is open
1512 * on the SPOOLSS pipe.
1513 * @param mem_ctx Pointer to an initialised talloc context.
1514 *
1515 * @param offered Buffer size offered in the request.
1516 * @param needed Number of bytes needed to complete the request.
1517 * may be NULL.
1518 * or cli_spoolss_addprinterex.
1519 * @param level Form info level to get - should always be 1.
1520 * @param handle Open policy handle
1521 *
1522 */
1523
1524 WERROR cli_spoolss_enumforms(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1525 uint32 offered, uint32 *needed,
1526 POLICY_HND *handle, int level, uint32 *num_forms,
1527 FORM_1 **forms)
1528 {
1529 prs_struct qbuf, rbuf;
1530 SPOOL_Q_ENUMFORMS q;
1531 SPOOL_R_ENUMFORMS r;
1532 WERROR result = W_ERROR(ERRgeneral);
1533 NEW_BUFFER buffer;
1534
1535 ZERO_STRUCT(q);
1536 ZERO_STRUCT(r);
1537
1538 /* Initialise parse structures */
1539
1540 init_buffer(&buffer, offered, mem_ctx);
1541
1542 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1543 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1544
1545 /* Initialise input parameters */
1546
1547 make_spoolss_q_enumforms(&q, handle, level, &buffer, offered);
1548
1549 /* Marshall data and send request */
1550
1551 if (!spoolss_io_q_enumforms("", &q, &qbuf, 0) ||
1552 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_ENUMFORMS, &qbuf, &rbuf))
1553 goto done;
1554
1555 /* Unmarshall response */
1556
1557 if (!spoolss_io_r_enumforms("", &r, &rbuf, 0))
1558 goto done;
1559
1560 /* Return output parameters */
1561
1562 result = r.status;
1563
1564 if (needed)
1565 *needed = r.needed;
1566
1567 if (num_forms)
1568 *num_forms = r.numofforms;
1569
1570 decode_forms_1(mem_ctx, r.buffer, *num_forms, forms);
1571
1572 done:
1573 prs_mem_free(&qbuf);
1574 prs_mem_free(&rbuf);
1575
1576 return result;
1577 }
1578
1579 static void decode_jobs_1(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
1580 uint32 num_jobs, JOB_INFO_1 **jobs)
1581 {
1582 uint32 i;
1583
1584 *jobs = TALLOC_ARRAY(mem_ctx, JOB_INFO_1, num_jobs);
1585 prs_set_offset(&buffer->prs,0);
1586
1587 for (i = 0; i < num_jobs; i++)
1588 smb_io_job_info_1("", buffer, &((*jobs)[i]), 0);
1589 }
1590
1591 static void decode_jobs_2(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
1592 uint32 num_jobs, JOB_INFO_2 **jobs)
1593 {
1594 uint32 i;
1595
1596 *jobs = TALLOC_ARRAY(mem_ctx, JOB_INFO_2, num_jobs);
1597 prs_set_offset(&buffer->prs,0);
1598
1599 for (i = 0; i < num_jobs; i++)
1600 smb_io_job_info_2("", buffer, &((*jobs)[i]), 0);
1601 }
1602
1603 /* Enumerate jobs */
1604
1605 WERROR cli_spoolss_enumjobs(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1606 uint32 offered, uint32 *needed,
1607 POLICY_HND *hnd, uint32 level, uint32 firstjob,
1608 uint32 num_jobs, uint32 *returned, JOB_INFO_CTR *ctr)
1609 {
1610 prs_struct qbuf, rbuf;
1611 SPOOL_Q_ENUMJOBS q;
1612 SPOOL_R_ENUMJOBS r;
1613 WERROR result = W_ERROR(ERRgeneral);
1614 NEW_BUFFER buffer;
1615
1616 ZERO_STRUCT(q);
1617 ZERO_STRUCT(r);
1618
1619 /* Initialise parse structures */
1620
1621 init_buffer(&buffer, offered, mem_ctx);
1622
1623 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1624 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1625
1626 /* Initialise input parameters */
1627
1628 make_spoolss_q_enumjobs(&q, hnd, firstjob, num_jobs, level, &buffer,
1629 offered);
1630
1631 /* Marshall data and send request */
1632
1633 if (!spoolss_io_q_enumjobs("", &q, &qbuf, 0) ||
1634 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_ENUMJOBS, &qbuf, &rbuf))
1635 goto done;
1636
1637 /* Unmarshall response */
1638
1639 if (!spoolss_io_r_enumjobs("", &r, &rbuf, 0))
1640 goto done;
1641
1642 /* Return output parameters */
1643
1644 result = r.status;
1645
1646 if (needed)
1647 *needed = r.needed;
1648
1649 if (!W_ERROR_IS_OK(r.status))
1650 goto done;
1651
1652 *returned = r.returned;
1653
1654 switch(level) {
1655 case 1:
1656 decode_jobs_1(mem_ctx, r.buffer, r.returned,
1657 &ctr->job.job_info_1);
1658 break;
1659 case 2:
1660 decode_jobs_2(mem_ctx, r.buffer, r.returned,
1661 &ctr->job.job_info_2);
1662 break;
1663 default:
1664 DEBUG(3, ("unsupported info level %d", level));
1665 break;
1666 }
1667
1668 done:
1669 prs_mem_free(&qbuf);
1670 prs_mem_free(&rbuf);
1671
1672 return result;
1673 }
1674
1675 /* Set job */
1676
1677 WERROR cli_spoolss_setjob(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1678 POLICY_HND *hnd, uint32 jobid, uint32 level,
1679 uint32 command)
1680 {
1681 prs_struct qbuf, rbuf;
1682 SPOOL_Q_SETJOB q;
1683 SPOOL_R_SETJOB r;
1684 WERROR result = W_ERROR(ERRgeneral);
1685
1686 ZERO_STRUCT(q);
1687 ZERO_STRUCT(r);
1688
1689 /* Initialise parse structures */
1690
1691 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1692 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1693
1694 /* Initialise input parameters */
1695
1696 make_spoolss_q_setjob(&q, hnd, jobid, level, command);
1697
1698 /* Marshall data and send request */
1699
1700 if (!spoolss_io_q_setjob("", &q, &qbuf, 0) ||
1701 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_SETJOB, &qbuf, &rbuf))
1702 goto done;
1703
1704 /* Unmarshall response */
1705
1706 if (!spoolss_io_r_setjob("", &r, &rbuf, 0))
1707 goto done;
1708
1709 /* Return output parameters */
1710
1711 result = r.status;
1712
1713 done:
1714 prs_mem_free(&qbuf);
1715 prs_mem_free(&rbuf);
1716
1717 return result;
1718 }
1719
1720 /* Get job */
1721
1722 WERROR cli_spoolss_getjob(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1723 uint32 offered, uint32 *needed,
1724 POLICY_HND *hnd, uint32 jobid, uint32 level,
1725 JOB_INFO_CTR *ctr)
1726 {
1727 prs_struct qbuf, rbuf;
1728 SPOOL_Q_GETJOB q;
1729 SPOOL_R_GETJOB r;
1730 WERROR result = W_ERROR(ERRgeneral);
1731 NEW_BUFFER buffer;
1732
1733 ZERO_STRUCT(q);
1734 ZERO_STRUCT(r);
1735
1736 /* Initialise parse structures */
1737
1738 init_buffer(&buffer, offered, mem_ctx);
1739
1740 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1741 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1742
1743 /* Initialise input parameters */
1744
1745 make_spoolss_q_getjob(&q, hnd, jobid, level, &buffer, offered);
1746
1747 /* Marshall data and send request */
1748
1749 if (!spoolss_io_q_getjob("", &q, &qbuf, 0) ||
1750 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_GETJOB, &qbuf, &rbuf))
1751 goto done;
1752
1753 /* Unmarshall response */
1754
1755 if (!spoolss_io_r_getjob("", &r, &rbuf, 0))
1756 goto done;
1757
1758 /* Return output parameters */
1759
1760 result = r.status;
1761
1762 if (needed)
1763 *needed = r.needed;
1764
1765 if (!W_ERROR_IS_OK(r.status))
1766 goto done;
1767
1768 switch(level) {
1769 case 1:
1770 decode_jobs_1(mem_ctx, r.buffer, 1, &ctr->job.job_info_1);
1771 break;
1772 case 2:
1773 decode_jobs_2(mem_ctx, r.buffer, 1, &ctr->job.job_info_2);
1774 break;
1775 default:
1776 DEBUG(3, ("unsupported info level %d", level));
1777 break;
1778 }
1779
1780 done:
1781 prs_mem_free(&qbuf);
1782 prs_mem_free(&rbuf);
1783
1784 return result;
1785 }
1786
1787 /* Startpageprinter. Sent to notify the spooler when a page is about to be
1788 sent to a printer. */
1789
1790 WERROR cli_spoolss_startpageprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1791 POLICY_HND *hnd)
1792 {
1793 prs_struct qbuf, rbuf;
1794 SPOOL_Q_STARTPAGEPRINTER q;
1795 SPOOL_R_STARTPAGEPRINTER r;
1796 WERROR result = W_ERROR(ERRgeneral);
1797
1798 ZERO_STRUCT(q);
1799 ZERO_STRUCT(r);
1800
1801 /* Initialise parse structures */
1802
1803 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1804 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1805
1806 /* Initialise input parameters */
1807
1808 make_spoolss_q_startpageprinter(&q, hnd);
1809
1810 /* Marshall data and send request */
1811
1812 if (!spoolss_io_q_startpageprinter("", &q, &qbuf, 0) ||
1813 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_STARTPAGEPRINTER, &qbuf, &rbuf))
1814 goto done;
1815
1816 /* Unmarshall response */
1817
1818 if (!spoolss_io_r_startpageprinter("", &r, &rbuf, 0))
1819 goto done;
1820
1821 /* Return output parameters */
1822
1823 result = r.status;
1824
1825 done:
1826 prs_mem_free(&qbuf);
1827 prs_mem_free(&rbuf);
1828
1829 return result;
1830 }
1831
1832 /* Endpageprinter. Sent to notify the spooler when a page has finished
1833 being sent to a printer. */
1834
1835 WERROR cli_spoolss_endpageprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1836 POLICY_HND *hnd)
1837 {
1838 prs_struct qbuf, rbuf;
1839 SPOOL_Q_ENDPAGEPRINTER q;
1840 SPOOL_R_ENDPAGEPRINTER r;
1841 WERROR result = W_ERROR(ERRgeneral);
1842
1843 ZERO_STRUCT(q);
1844 ZERO_STRUCT(r);
1845
1846 /* Initialise parse structures */
1847
1848 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1849 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1850
1851 /* Initialise input parameters */
1852
1853 make_spoolss_q_endpageprinter(&q, hnd);
1854
1855 /* Marshall data and send request */
1856
1857 if (!spoolss_io_q_endpageprinter("", &q, &qbuf, 0) ||
1858 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_ENDPAGEPRINTER, &qbuf, &rbuf))
1859 goto done;
1860
1861 /* Unmarshall response */
1862
1863 if (!spoolss_io_r_endpageprinter("", &r, &rbuf, 0))
1864 goto done;
1865
1866 /* Return output parameters */
1867
1868 result = r.status;
1869
1870 done:
1871 prs_mem_free(&qbuf);
1872 prs_mem_free(&rbuf);
1873
1874 return result;
1875 }
1876
1877 /* Startdocprinter. Sent to notify the spooler that a document is about
1878 to be spooled for printing. */
1879
1880 WERROR cli_spoolss_startdocprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1881 POLICY_HND *hnd, char *docname,
1882 char *outputfile, char *datatype,
1883 uint32 *jobid)
1884 {
1885 prs_struct qbuf, rbuf;
1886 SPOOL_Q_STARTDOCPRINTER q;
1887 SPOOL_R_STARTDOCPRINTER r;
1888 WERROR result = W_ERROR(ERRgeneral);
1889 uint32 level = 1;
1890
1891 ZERO_STRUCT(q);
1892 ZERO_STRUCT(r);
1893
1894 /* Initialise parse structures */
1895
1896 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1897 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1898
1899 /* Initialise input parameters */
1900
1901 make_spoolss_q_startdocprinter(&q, hnd, level, docname, outputfile,
1902 datatype);
1903
1904 /* Marshall data and send request */
1905
1906 if (!spoolss_io_q_startdocprinter("", &q, &qbuf, 0) ||
1907 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_STARTDOCPRINTER, &qbuf, &rbuf))
1908 goto done;
1909
1910 /* Unmarshall response */
1911
1912 if (!spoolss_io_r_startdocprinter("", &r, &rbuf, 0))
1913 goto done;
1914
1915 /* Return output parameters */
1916
1917 result = r.status;
1918
1919 if (W_ERROR_IS_OK(result))
1920 *jobid = r.jobid;
1921
1922 done:
1923 prs_mem_free(&qbuf);
1924 prs_mem_free(&rbuf);
1925
1926 return result;
1927 }
1928
1929 /* Enddocprinter. Sent to notify the spooler that a document has finished
1930 being spooled. */
1931
1932 WERROR cli_spoolss_enddocprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1933 POLICY_HND *hnd)
1934 {
1935 prs_struct qbuf, rbuf;
1936 SPOOL_Q_ENDDOCPRINTER q;
1937 SPOOL_R_ENDDOCPRINTER r;
1938 WERROR result = W_ERROR(ERRgeneral);
1939
1940 ZERO_STRUCT(q);
1941 ZERO_STRUCT(r);
1942
1943 /* Initialise parse structures */
1944
1945 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1946 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1947
1948 /* Initialise input parameters */
1949
1950 make_spoolss_q_enddocprinter(&q, hnd);
1951
1952 /* Marshall data and send request */
1953
1954 if (!spoolss_io_q_enddocprinter("", &q, &qbuf, 0) ||
1955 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_ENDDOCPRINTER, &qbuf, &rbuf))
1956 goto done;
1957
1958 /* Unmarshall response */
1959
1960 if (!spoolss_io_r_enddocprinter("", &r, &rbuf, 0))
1961 goto done;
1962
1963 /* Return output parameters */
1964
1965 result = r.status;
1966
1967 done:
1968 prs_mem_free(&qbuf);
1969 prs_mem_free(&rbuf);
1970
1971 return result;
1972 }
1973
1974 /* Get printer data */
1975
1976 WERROR cli_spoolss_getprinterdata(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1977 uint32 offered, uint32 *needed,
1978 POLICY_HND *hnd, const char *valuename,
1979 REGISTRY_VALUE *value)
1980 {
1981 prs_struct qbuf, rbuf;
1982 SPOOL_Q_GETPRINTERDATA q;
1983 SPOOL_R_GETPRINTERDATA r;
1984 WERROR result = W_ERROR(ERRgeneral);
1985
1986 ZERO_STRUCT(q);
1987 ZERO_STRUCT(r);
1988
1989 /* Initialise parse structures */
1990
1991 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1992 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1993
1994 /* Initialise input parameters */
1995
1996 make_spoolss_q_getprinterdata(&q, hnd, valuename, offered);
1997
1998 /* Marshall data and send request */
1999
2000 if (!spoolss_io_q_getprinterdata("", &q, &qbuf, 0) ||
2001 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_GETPRINTERDATA, &qbuf, &rbuf))
2002 goto done;
2003
2004 /* Unmarshall response */
2005
2006 if (!spoolss_io_r_getprinterdata("", &r, &rbuf, 0))
2007 goto done;
2008
2009 result = r.status;
2010
2011 if (needed)
2012 *needed = r.needed;
2013
2014 if (!W_ERROR_IS_OK(r.status))
2015 goto done;
2016
2017 /* Return output parameters */
2018
2019 value->data_p = TALLOC_MEMDUP(mem_ctx, r.data, r.needed);
2020 value->type = r.type;
2021 value->size = r.size;
2022
2023 done:
2024 prs_mem_free(&qbuf);
2025 prs_mem_free(&rbuf);
2026
2027 return result;
2028 }
2029
2030 WERROR cli_spoolss_getprinterdataex(struct cli_state *cli, TALLOC_CTX *mem_ctx,
2031 uint32 offered, uint32 *needed,
2032 POLICY_HND *hnd, const char *keyname,
2033 const char *valuename,
2034 REGISTRY_VALUE *value)
2035 {
2036 prs_struct qbuf, rbuf;
2037 SPOOL_Q_GETPRINTERDATAEX q;
2038 SPOOL_R_GETPRINTERDATAEX r;
2039 WERROR result = W_ERROR(ERRgeneral);
2040
2041 ZERO_STRUCT(q);
2042 ZERO_STRUCT(r);
2043
2044 /* Initialise parse structures */
2045
2046 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2047 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2048
2049 /* Initialise input parameters */
2050
2051 make_spoolss_q_getprinterdataex(&q, hnd, keyname, valuename, offered);
2052
2053 /* Marshall data and send request */
2054
2055 if (!spoolss_io_q_getprinterdataex("", &q, &qbuf, 0) ||
2056 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_GETPRINTERDATAEX, &qbuf, &rbuf))
2057 goto done;
2058
2059 /* Unmarshall response */
2060
2061 if (!spoolss_io_r_getprinterdataex("", &r, &rbuf, 0))
2062 goto done;
2063
2064 result = r.status;
2065
2066 if (needed)
2067 *needed = r.needed;
2068
2069 if (!W_ERROR_IS_OK(r.status))
2070 goto done;
2071
2072 /* Return output parameters */
2073
2074 value->data_p = TALLOC_MEMDUP(mem_ctx, r.data, r.needed);
2075 value->type = r.type;
2076 value->size = r.needed;
2077
2078 done:
2079 prs_mem_free(&qbuf);
2080 prs_mem_free(&rbuf);
2081
2082 return result;
2083 }
2084
2085 /* Set printer data */
2086
2087 WERROR cli_spoolss_setprinterdata(struct cli_state *cli, TALLOC_CTX *mem_ctx,
2088 POLICY_HND *hnd, REGISTRY_VALUE *value)
2089 {
2090 prs_struct qbuf, rbuf;
2091 SPOOL_Q_SETPRINTERDATA q;
2092 SPOOL_R_SETPRINTERDATA r;
2093 WERROR result = W_ERROR(ERRgeneral);
2094
2095 ZERO_STRUCT(q);
2096 ZERO_STRUCT(r);
2097
2098 /* Initialise parse structures */
2099
2100 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2101 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2102
2103 /* Initialise input parameters */
2104
2105 make_spoolss_q_setprinterdata(
2106 &q, hnd, value->valuename, value->type, (char *)value->data_p, value->size);
2107
2108 /* Marshall data and send request */
2109
2110 if (!spoolss_io_q_setprinterdata("", &q, &qbuf, 0) ||
2111 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_SETPRINTERDATA, &qbuf, &rbuf))
2112 goto done;
2113
2114 /* Unmarshall response */
2115
2116 if (!spoolss_io_r_setprinterdata("", &r, &rbuf, 0))
2117 goto done;
2118
2119 result = r.status;
2120
2121 if (!W_ERROR_IS_OK(r.status))
2122 goto done;
2123
2124 done:
2125 prs_mem_free(&qbuf);
2126 prs_mem_free(&rbuf);
2127
2128 return result;
2129 }
2130
2131 WERROR cli_spoolss_setprinterdataex(struct cli_state *cli, TALLOC_CTX *mem_ctx,
2132 POLICY_HND *hnd, char *keyname,
2133 REGISTRY_VALUE *value)
2134 {
2135 prs_struct qbuf, rbuf;
2136 SPOOL_Q_SETPRINTERDATAEX q;
2137 SPOOL_R_SETPRINTERDATAEX r;
2138 WERROR result = W_ERROR(ERRgeneral);
2139
2140 ZERO_STRUCT(q);
2141 ZERO_STRUCT(r);
2142
2143 /* Initialise parse structures */
2144
2145 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2146 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2147
2148 /* Initialise input parameters */
2149
2150 make_spoolss_q_setprinterdataex(
2151 &q, hnd, keyname, value->valuename, value->type, (char *)value->data_p,
2152 value->size);
2153
2154 /* Marshall data and send request */
2155
2156 if (!spoolss_io_q_setprinterdataex("", &q, &qbuf, 0) ||
2157 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_SETPRINTERDATAEX, &qbuf, &rbuf))
2158 goto done;
2159
2160 /* Unmarshall response */
2161
2162 if (!spoolss_io_r_setprinterdataex("", &r, &rbuf, 0))
2163 goto done;
2164
2165 result = r.status;
2166
2167 if (!W_ERROR_IS_OK(r.status))
2168 goto done;
2169
2170 done:
2171 prs_mem_free(&qbuf);
2172 prs_mem_free(&rbuf);
2173
2174 return result;
2175 }
2176
2177 /* Enum printer data */
2178
2179 WERROR cli_spoolss_enumprinterdata(struct cli_state *cli, TALLOC_CTX *mem_ctx,
2180 POLICY_HND *hnd, uint32 ndx,
2181 uint32 value_offered, uint32 data_offered,
2182 uint32 *value_needed, uint32 *data_needed,
2183 REGISTRY_VALUE *value)
2184 {
2185 prs_struct qbuf, rbuf;
2186 SPOOL_Q_ENUMPRINTERDATA q;
2187 SPOOL_R_ENUMPRINTERDATA r;
2188 WERROR result = W_ERROR(ERRgeneral);
2189
2190 ZERO_STRUCT(q);
2191 ZERO_STRUCT(r);
2192
2193 /* Initialise parse structures */
2194
2195 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2196 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2197
2198 /* Initialise input parameters */
2199
2200 make_spoolss_q_enumprinterdata(&q, hnd, ndx, value_offered, data_offered);
2201
2202 /* Marshall data and send request */
2203
2204 if (!spoolss_io_q_enumprinterdata("", &q, &qbuf, 0) ||
2205 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDATA, &qbuf, &rbuf))
2206 goto done;
2207
2208 /* Unmarshall response */
2209
2210 if (!spoolss_io_r_enumprinterdata("", &r, &rbuf, 0))
2211 goto done;
2212
2213 result = r.status;
2214
2215 if (!W_ERROR_IS_OK(r.status))
2216 goto done;
2217
2218 /* Return data */
2219
2220 if (value_needed)
2221 *value_needed = r.realvaluesize;
2222
2223 if (data_needed)
2224 *data_needed = r.realdatasize;
2225
2226 if (value) {
2227 rpcstr_pull(value->valuename, r.value, sizeof(value->valuename), -1,
2228 STR_TERMINATE);
2229 value->data_p = TALLOC_MEMDUP(mem_ctx, r.data, r.realdatasize);
2230 value->type = r.type;
2231 value->size = r.realdatasize;
2232 }
2233
2234 done:
2235 prs_mem_free(&qbuf);
2236 prs_mem_free(&rbuf);
2237
2238 return result;
2239 }
2240
2241 WERROR cli_spoolss_enumprinterdataex(struct cli_state *cli, TALLOC_CTX *mem_ctx,
2242 uint32 offered, uint32 *needed,
2243 POLICY_HND *hnd, const char *keyname,
2244 REGVAL_CTR *ctr)
2245 {
2246 prs_struct qbuf, rbuf;
2247 SPOOL_Q_ENUMPRINTERDATAEX q;
2248 SPOOL_R_ENUMPRINTERDATAEX r;
2249 WERROR result = W_ERROR(ERRgeneral);
2250 int i;
2251
2252 ZERO_STRUCT(q);
2253 ZERO_STRUCT(r);
2254
2255 /* Initialise parse structures */
2256
2257 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2258 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2259
2260 /* Initialise input parameters */
2261
2262 make_spoolss_q_enumprinterdataex(&q, hnd, keyname, offered);
2263
2264 /* Marshall data and send request */
2265
2266 if (!spoolss_io_q_enumprinterdataex("", &q, &qbuf, 0) ||
2267 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDATAEX, &qbuf, &rbuf))
2268 goto done;
2269
2270 /* Unmarshall response */
2271
2272 if (!spoolss_io_r_enumprinterdataex("", &r, &rbuf, 0))
2273 goto done;
2274
2275 result = r.status;
2276
2277 if (needed)
2278 *needed = r.needed;
2279
2280 if (!W_ERROR_IS_OK(r.status))
2281 goto done;
2282
2283 /* Return data */
2284
2285 ZERO_STRUCTP(ctr);
2286 regval_ctr_init(ctr);
2287
2288 for (i = 0; i < r.returned; i++) {
2289 PRINTER_ENUM_VALUES *v = &r.ctr.values[i];
2290 fstring name;
2291
2292 rpcstr_pull(name, v->valuename.buffer, sizeof(name), -1,
2293 STR_TERMINATE);
2294 regval_ctr_addvalue(ctr, name, v->type, (const char *)v->data, v->data_len);
2295 }
2296
2297 done:
2298 prs_mem_free(&qbuf);
2299 prs_mem_free(&rbuf);
2300
2301 return result;
2302 }
2303
2304 /* Write data to printer */
2305
2306 WERROR cli_spoolss_writeprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
2307 POLICY_HND *hnd, uint32 data_size, char *data,
2308 uint32 *num_written)
2309 {
2310 prs_struct qbuf, rbuf;
2311 SPOOL_Q_WRITEPRINTER q;
2312 SPOOL_R_WRITEPRINTER r;
2313 WERROR result = W_ERROR(ERRgeneral);
2314
2315 ZERO_STRUCT(q);
2316 ZERO_STRUCT(r);
2317
2318 /* Initialise parse structures */
2319
2320 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2321 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2322
2323 /* Initialise input parameters */
2324
2325 make_spoolss_q_writeprinter(&q, hnd, data_size, data);
2326
2327 /* Marshall data and send request */
2328
2329 if (!spoolss_io_q_writeprinter("", &q, &qbuf, 0) ||
2330 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_WRITEPRINTER, &qbuf, &rbuf))
2331 goto done;
2332
2333 /* Unmarshall response */
2334
2335 if (!spoolss_io_r_writeprinter("", &r, &rbuf, 0))
2336 goto done;
2337
2338 result = r.status;
2339
2340 if (!W_ERROR_IS_OK(r.status))
2341 goto done;
2342
2343 if (num_written)
2344 *num_written = r.buffer_written;
2345
2346 done:
2347 prs_mem_free(&qbuf);
2348 prs_mem_free(&rbuf);
2349
2350 return result;
2351 }
2352
2353 /* Delete printer data */
2354
2355 WERROR cli_spoolss_deleteprinterdata(struct cli_state *cli, TALLOC_CTX *mem_ctx,
2356 POLICY_HND *hnd, char *valuename)
2357 {
2358 prs_struct qbuf, rbuf;
2359 SPOOL_Q_DELETEPRINTERDATA q;
2360 SPOOL_R_DELETEPRINTERDATA r;
2361 WERROR result = W_ERROR(ERRgeneral);
2362
2363 ZERO_STRUCT(q);
2364 ZERO_STRUCT(r);
2365
2366 /* Initialise parse structures */
2367
2368 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2369 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2370
2371 /* Initialise input parameters */
2372
2373 make_spoolss_q_deleteprinterdata(&q, hnd, valuename);
2374
2375 /* Marshall data and send request */
2376
2377 if (!spoolss_io_q_deleteprinterdata("", &q, &qbuf, 0) ||
2378 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDATA, &qbuf, &rbuf))
2379 goto done;
2380
2381 /* Unmarshall response */
2382
2383 if (!spoolss_io_r_deleteprinterdata("", &r, &rbuf, 0))
2384 goto done;
2385
2386 result = r.status;
2387
2388 if (!W_ERROR_IS_OK(r.status))
2389 goto done;
2390
2391 done:
2392 prs_mem_free(&qbuf);
2393 prs_mem_free(&rbuf);
2394
2395 return result;
2396 }
2397
2398 WERROR cli_spoolss_deleteprinterdataex(struct cli_state *cli, TALLOC_CTX *mem_ctx,
2399 POLICY_HND *hnd, char *keyname,
2400 char *valuename)
2401 {
2402 prs_struct qbuf, rbuf;
2403 SPOOL_Q_DELETEPRINTERDATAEX q;
2404 SPOOL_R_DELETEPRINTERDATAEX r;
2405 WERROR result = W_ERROR(ERRgeneral);
2406
2407 ZERO_STRUCT(q);
2408 ZERO_STRUCT(r);
2409
2410 /* Initialise parse structures */
2411
2412 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2413 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2414
2415 /* Initialise input parameters */
2416
2417 make_spoolss_q_deleteprinterdataex(&q, hnd, keyname, valuename);
2418
2419 /* Marshall data and send request */
2420
2421 if (!spoolss_io_q_deleteprinterdataex("", &q, &qbuf, 0) ||
2422 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDATAEX, &qbuf, &rbuf))
2423 goto done;
2424
2425 /* Unmarshall response */
2426
2427 if (!spoolss_io_r_deleteprinterdataex("", &r, &rbuf, 0))
2428 goto done;
2429
2430 result = r.status;
2431
2432 if (!W_ERROR_IS_OK(r.status))
2433 goto done;
2434
2435 done:
2436 prs_mem_free(&qbuf);
2437 prs_mem_free(&rbuf);
2438
2439 return result;
2440 }
2441
2442 WERROR cli_spoolss_enumprinterkey(struct cli_state *cli, TALLOC_CTX *mem_ctx,
2443 uint32 offered, uint32 *needed,
2444 POLICY_HND *hnd, const char *keyname,
2445 uint16 **keylist, uint32 *len)
2446 {
2447 prs_struct qbuf, rbuf;
2448 SPOOL_Q_ENUMPRINTERKEY q;
2449 SPOOL_R_ENUMPRINTERKEY r;
2450 WERROR result = W_ERROR(ERRgeneral);
2451
2452 ZERO_STRUCT(q);
2453 ZERO_STRUCT(r);
2454
2455 /* Initialise parse structures */
2456
2457 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2458 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2459
2460 /* Initialise input parameters */
2461
2462 make_spoolss_q_enumprinterkey(&q, hnd, keyname, offered);
2463
2464 /* Marshall data and send request */
2465
2466 if (!spoolss_io_q_enumprinterkey("", &q, &qbuf, 0) ||
2467 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_ENUMPRINTERKEY, &qbuf, &rbuf))
2468 goto done;
2469
2470 /* Unmarshall response */
2471
2472 if (!spoolss_io_r_enumprinterkey("", &r, &rbuf, 0))
2473 goto done;
2474
2475 result = r.status;
2476
2477 if (needed)
2478 *needed = r.needed;
2479
2480 if (!W_ERROR_IS_OK(r.status))
2481 goto done;
2482
2483 /* Copy results */
2484
2485 if (keylist) {
2486 *keylist = SMB_MALLOC_ARRAY(uint16, r.keys.buf_len);
2487 memcpy(*keylist, r.keys.buffer, r.keys.buf_len * 2);
2488 if (len)
2489 *len = r.keys.buf_len * 2;
2490 }
2491
2492 done:
2493 prs_mem_free(&qbuf);
2494 prs_mem_free(&rbuf);
2495
2496 return result;
2497 }
2498
2499 WERROR cli_spoolss_deleteprinterkey(struct cli_state *cli, TALLOC_CTX *mem_ctx,
2500 POLICY_HND *hnd, char *keyname)
2501 {
2502 prs_struct qbuf, rbuf;
2503 SPOOL_Q_DELETEPRINTERKEY q;
2504 SPOOL_R_DELETEPRINTERKEY r;
2505 WERROR result = W_ERROR(ERRgeneral);
2506
2507 ZERO_STRUCT(q);
2508 ZERO_STRUCT(r);
2509
2510 /* Initialise parse structures */
2511
2512 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2513 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2514
2515 /* Initialise input parameters */
2516
2517 make_spoolss_q_deleteprinterkey(&q, hnd, keyname);
2518
2519 /* Marshall data and send request */
2520
2521 if (!spoolss_io_q_deleteprinterkey("", &q, &qbuf, 0) ||
2522 !rpc_api_pipe_req(cli, PI_SPOOLSS, SPOOLSS_DELETEPRINTERKEY, &qbuf, &rbuf))
2523 goto done;
2524
2525 /* Unmarshall response */
2526
2527 if (!spoolss_io_r_deleteprinterkey("", &r, &rbuf, 0))
2528 goto done;
2529
2530 result = r.status;
2531
2532 if (!W_ERROR_IS_OK(r.status))
2533 goto done;
2534
2535 done:
2536 prs_mem_free(&qbuf);
2537 prs_mem_free(&rbuf);
2538
2539 return result;
2540 }
2541
2542 /** @} **/
Samba GIT mirror