2 Unix SMB/CIFS implementation.
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.
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.
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.
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.
28 /** @defgroup spoolss SPOOLSS - NT printing routines
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)
39 buffer->ptr = (size != 0);
41 buffer->string_at_end = size;
42 prs_init(&buffer->prs, size, ctx, MARSHALL);
43 buffer->struct_start = prs_offset(&buffer->prs);
46 /*********************************************************************
47 Decode various spoolss rpc's and info levels
48 ********************************************************************/
50 /**********************************************************************
51 **********************************************************************/
52 static void decode_printer_info_0(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
53 uint32 returned, PRINTER_INFO_0 **info)
58 inf=(PRINTER_INFO_0 *)talloc(mem_ctx, returned*sizeof(PRINTER_INFO_0));
59 memset(inf, 0, returned*sizeof(PRINTER_INFO_0));
61 prs_set_offset(&buffer->prs,0);
63 for (i=0; i<returned; i++) {
64 smb_io_printer_info_0("", buffer, &inf[i], 0);
70 /**********************************************************************
71 **********************************************************************/
72 static void decode_printer_info_1(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
73 uint32 returned, PRINTER_INFO_1 **info)
78 inf=(PRINTER_INFO_1 *)talloc(mem_ctx, returned*sizeof(PRINTER_INFO_1));
79 memset(inf, 0, returned*sizeof(PRINTER_INFO_1));
81 prs_set_offset(&buffer->prs,0);
83 for (i=0; i<returned; i++) {
84 smb_io_printer_info_1("", buffer, &inf[i], 0);
90 /**********************************************************************
91 **********************************************************************/
92 static void decode_printer_info_2(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
93 uint32 returned, PRINTER_INFO_2 **info)
98 inf=(PRINTER_INFO_2 *)talloc(mem_ctx, returned*sizeof(PRINTER_INFO_2));
99 memset(inf, 0, returned*sizeof(PRINTER_INFO_2));
101 prs_set_offset(&buffer->prs,0);
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);
112 /**********************************************************************
113 **********************************************************************/
114 static void decode_printer_info_3(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
115 uint32 returned, PRINTER_INFO_3 **info)
120 inf=(PRINTER_INFO_3 *)talloc(mem_ctx, returned*sizeof(PRINTER_INFO_3));
121 memset(inf, 0, returned*sizeof(PRINTER_INFO_3));
123 prs_set_offset(&buffer->prs,0);
125 for (i=0; i<returned; i++) {
126 inf[i].secdesc = NULL;
127 smb_io_printer_info_3("", buffer, &inf[i], 0);
133 /**********************************************************************
134 **********************************************************************/
135 static void decode_printer_info_7(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
136 uint32 returned, PRINTER_INFO_7 **info)
141 inf=(PRINTER_INFO_7 *)talloc(mem_ctx, returned*sizeof(PRINTER_INFO_7));
142 memset(inf, 0, returned*sizeof(PRINTER_INFO_7));
144 prs_set_offset(&buffer->prs,0);
146 for (i=0; i<returned; i++) {
147 smb_io_printer_info_7("", buffer, &inf[i], 0);
154 /**********************************************************************
155 **********************************************************************/
156 static void decode_port_info_1(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
157 uint32 returned, PORT_INFO_1 **info)
162 inf=(PORT_INFO_1*)talloc(mem_ctx, returned*sizeof(PORT_INFO_1));
163 memset(inf, 0, returned*sizeof(PORT_INFO_1));
165 prs_set_offset(&buffer->prs, 0);
167 for (i=0; i<returned; i++) {
168 smb_io_port_info_1("", buffer, &(inf[i]), 0);
174 /**********************************************************************
175 **********************************************************************/
176 static void decode_port_info_2(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
177 uint32 returned, PORT_INFO_2 **info)
182 inf=(PORT_INFO_2*)talloc(mem_ctx, returned*sizeof(PORT_INFO_2));
183 memset(inf, 0, returned*sizeof(PORT_INFO_2));
185 prs_set_offset(&buffer->prs, 0);
187 for (i=0; i<returned; i++) {
188 smb_io_port_info_2("", buffer, &(inf[i]), 0);
194 /**********************************************************************
195 **********************************************************************/
196 static void decode_printer_driver_1(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
197 uint32 returned, DRIVER_INFO_1 **info)
202 inf=(DRIVER_INFO_1 *)talloc(mem_ctx, returned*sizeof(DRIVER_INFO_1));
203 memset(inf, 0, returned*sizeof(DRIVER_INFO_1));
205 prs_set_offset(&buffer->prs,0);
207 for (i=0; i<returned; i++) {
208 smb_io_printer_driver_info_1("", buffer, &(inf[i]), 0);
214 /**********************************************************************
215 **********************************************************************/
216 static void decode_printer_driver_2(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
217 uint32 returned, DRIVER_INFO_2 **info)
222 inf=(DRIVER_INFO_2 *)talloc(mem_ctx, returned*sizeof(DRIVER_INFO_2));
223 memset(inf, 0, returned*sizeof(DRIVER_INFO_2));
225 prs_set_offset(&buffer->prs,0);
227 for (i=0; i<returned; i++) {
228 smb_io_printer_driver_info_2("", buffer, &(inf[i]), 0);
234 /**********************************************************************
235 **********************************************************************/
236 static void decode_printer_driver_3(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
237 uint32 returned, DRIVER_INFO_3 **info)
242 inf=(DRIVER_INFO_3 *)talloc(mem_ctx, returned*sizeof(DRIVER_INFO_3));
243 memset(inf, 0, returned*sizeof(DRIVER_INFO_3));
245 prs_set_offset(&buffer->prs,0);
247 for (i=0; i<returned; i++) {
248 smb_io_printer_driver_info_3("", buffer, &(inf[i]), 0);
254 /**********************************************************************
255 **********************************************************************/
256 static void decode_printerdriverdir_1 (TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
257 uint32 returned, DRIVER_DIRECTORY_1 **info
260 DRIVER_DIRECTORY_1 *inf;
262 inf=(DRIVER_DIRECTORY_1 *)talloc(mem_ctx, sizeof(DRIVER_DIRECTORY_1));
263 memset(inf, 0, sizeof(DRIVER_DIRECTORY_1));
265 prs_set_offset(&buffer->prs, 0);
267 smb_io_driverdir_1("", buffer, inf, 0);
272 /** Return a handle to the specified printer or print server.
274 * @param cli Pointer to client state structure which is open
275 * on the SPOOLSS pipe.
277 * @param mem_ctx Pointer to an initialised talloc context.
279 * @param printername The name of the printer or print server to be
280 * opened in UNC format.
282 * @param datatype Specifies the default data type for the printer.
284 * @param access_required The access rights requested on the printer or
287 * @param station The UNC name of the requesting workstation.
289 * @param username The name of the user requesting the open.
291 * @param pol Returned policy handle.
294 /*********************************************************************************
295 Win32 API - OpenPrinter()
296 ********************************************************************************/
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)
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);
310 /* Initialise parse structures */
312 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
313 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
315 /* Initialise input parameters */
317 make_spoolss_q_open_printer_ex(&q, printername, datatype,
318 access_required, station, username);
320 /* Marshall data and send request */
322 if (!spoolss_io_q_open_printer_ex("", &q, &qbuf, 0) ||
323 !rpc_api_pipe_req(cli, SPOOLSS_OPENPRINTEREX, &qbuf, &rbuf))
326 /* Unmarshall response */
328 if (!spoolss_io_r_open_printer_ex("", &r, &rbuf, 0))
331 /* Return output parameters */
335 if (W_ERROR_IS_OK(result))
345 /** Close a printer handle
347 * @param cli Pointer to client state structure which is open
348 * on the SPOOLSS pipe.
350 * @param mem_ctx Pointer to an initialised talloc context.
352 * @param pol Policy handle of printer or print server to close.
354 /*********************************************************************************
355 Win32 API - ClosePrinter()
356 ********************************************************************************/
358 WERROR cli_spoolss_close_printer(struct cli_state *cli, TALLOC_CTX *mem_ctx,
361 prs_struct qbuf, rbuf;
362 SPOOL_Q_CLOSEPRINTER q;
363 SPOOL_R_CLOSEPRINTER r;
364 WERROR result = W_ERROR(ERRgeneral);
369 /* Initialise parse structures */
371 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
372 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
374 /* Initialise input parameters */
376 make_spoolss_q_closeprinter(&q, pol);
378 /* Marshall data and send request */
380 if (!spoolss_io_q_closeprinter("", &q, &qbuf, 0) ||
381 !rpc_api_pipe_req(cli, SPOOLSS_CLOSEPRINTER, &qbuf, &rbuf))
384 /* Unmarshall response */
386 if (!spoolss_io_r_closeprinter("", &r, &rbuf, 0))
389 /* Return output parameters */
393 if (W_ERROR_IS_OK(result))
403 /** Enumerate printers on a print server.
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.
409 * @param offered Buffer size offered in the request.
410 * @param needed Number of bytes needed to complete the request.
413 * @param flags Selected from PRINTER_ENUM_* flags.
414 * @param level Request information level.
416 * @param num_printers Pointer to number of printers returned. May be
418 * @param ctr Return structure for printer information. May
421 /*********************************************************************************
422 Win32 API - EnumPrinters()
423 ********************************************************************************/
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)
430 prs_struct qbuf, rbuf;
431 SPOOL_Q_ENUMPRINTERS q;
432 SPOOL_R_ENUMPRINTERS r;
434 WERROR result = W_ERROR(ERRgeneral);
439 /* Initialise input parameters */
441 init_buffer(&buffer, offered, mem_ctx);
443 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
444 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
446 make_spoolss_q_enumprinters(&q, flags, name, level, &buffer,
449 /* Marshall data and send request */
451 if (!spoolss_io_q_enumprinters("", &q, &qbuf, 0) ||
452 !rpc_api_pipe_req(cli, SPOOLSS_ENUMPRINTERS, &qbuf, &rbuf))
455 /* Unmarshall response */
457 if (spoolss_io_r_enumprinters("", &r, &rbuf, 0)) {
464 /* Return output parameters */
466 if (!W_ERROR_IS_OK(r.status))
470 *num_printers = r.returned;
477 decode_printer_info_0(mem_ctx, r.buffer, r.returned,
481 decode_printer_info_1(mem_ctx, r.buffer, r.returned,
485 decode_printer_info_2(mem_ctx, r.buffer, r.returned,
489 decode_printer_info_3(mem_ctx, r.buffer, r.returned,
501 /*********************************************************************************
502 Win32 API - EnumPorts()
503 ********************************************************************************/
504 /** Enumerate printer ports on a print server.
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.
510 * @param offered Buffer size offered in the request.
511 * @param needed Number of bytes needed to complete the request.
514 * @param level Requested information level.
516 * @param num_ports Pointer to number of ports returned. May be NULL.
517 * @param ctr Pointer to structure holding port information.
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)
525 prs_struct qbuf, rbuf;
529 WERROR result = W_ERROR(ERRgeneral);
535 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
538 /* Initialise input parameters */
540 init_buffer(&buffer, offered, mem_ctx);
542 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
543 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
545 make_spoolss_q_enumports(&q, server, level, &buffer, offered);
547 /* Marshall data and send request */
549 if (!spoolss_io_q_enumports("", &q, &qbuf, 0) ||
550 !rpc_api_pipe_req(cli, SPOOLSS_ENUMPORTS, &qbuf, &rbuf))
553 /* Unmarshall response */
555 if (spoolss_io_r_enumports("", &r, &rbuf, 0)) {
562 /* Return output parameters */
564 if (!W_ERROR_IS_OK(result))
568 *num_ports = r.returned;
575 decode_port_info_1(mem_ctx, r.buffer, r.returned,
579 decode_port_info_2(mem_ctx, r.buffer, r.returned,
591 /*********************************************************************************
592 Win32 API - GetPrinter()
593 ********************************************************************************/
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)
600 prs_struct qbuf, rbuf;
601 SPOOL_Q_GETPRINTER q;
602 SPOOL_R_GETPRINTER r;
604 WERROR result = W_ERROR(ERRgeneral);
609 /* Initialise input parameters */
611 init_buffer(&buffer, offered, mem_ctx);
613 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
614 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
616 make_spoolss_q_getprinter(mem_ctx, &q, pol, level, &buffer, offered);
618 /* Marshall data and send request */
620 if (!spoolss_io_q_getprinter("", &q, &qbuf, 0) ||
621 !rpc_api_pipe_req(cli, SPOOLSS_GETPRINTER, &qbuf, &rbuf))
624 /* Unmarshall response */
626 if (!spoolss_io_r_getprinter("", &r, &rbuf, 0))
632 /* Return output parameters */
636 if (W_ERROR_IS_OK(result)) {
639 decode_printer_info_0(mem_ctx, r.buffer, 1, &ctr->printers_0);
642 decode_printer_info_1(mem_ctx, r.buffer, 1, &ctr->printers_1);
645 decode_printer_info_2(mem_ctx, r.buffer, 1, &ctr->printers_2);
648 decode_printer_info_3(mem_ctx, r.buffer, 1, &ctr->printers_3);
651 decode_printer_info_7(mem_ctx, r.buffer, 1, &ctr->printers_7);
663 /*********************************************************************************
664 Win32 API - SetPrinter()
665 ********************************************************************************/
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.
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
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)
685 prs_struct qbuf, rbuf;
686 SPOOL_Q_SETPRINTER q;
687 SPOOL_R_SETPRINTER r;
688 WERROR result = W_ERROR(ERRgeneral);
693 /* Initialise input parameters */
695 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
696 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
698 if (!make_spoolss_q_setprinter(mem_ctx, &q, pol, level, ctr, command))
701 /* Marshall data and send request */
703 if (!spoolss_io_q_setprinter("", &q, &qbuf, 0) ||
704 !rpc_api_pipe_req(cli, SPOOLSS_SETPRINTER, &qbuf, &rbuf))
707 /* Unmarshall response */
709 if (!spoolss_io_r_setprinter("", &r, &rbuf, 0))
721 /*********************************************************************************
722 Win32 API - GetPrinterDriver()
723 ********************************************************************************/
724 /** Get installed printer drivers for a given printer
726 * @param cli Pointer to client state structure which is open
727 * on the SPOOLSS pipe.
729 * @param mem_ctx Pointer to an initialised talloc context.
731 * @param offered Buffer size offered in the request.
732 * @param needed Number of bytes needed to complete the request.
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.
743 WERROR cli_spoolss_getprinterdriver(struct cli_state *cli,
745 uint32 offered, uint32 *needed,
746 POLICY_HND *pol, uint32 level,
747 const char *env, int version, PRINTER_DRIVER_CTR *ctr)
749 prs_struct qbuf, rbuf;
750 SPOOL_Q_GETPRINTERDRIVER2 q;
751 SPOOL_R_GETPRINTERDRIVER2 r;
753 WERROR result = W_ERROR(ERRgeneral);
759 fstrcpy(server, cli->desthost);
762 /* Initialise input parameters */
764 init_buffer(&buffer, offered, mem_ctx);
766 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
767 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
769 make_spoolss_q_getprinterdriver2(&q, pol, env, level, version, 2,
772 /* Marshall data and send request */
774 if (!spoolss_io_q_getprinterdriver2 ("", &q, &qbuf, 0) ||
775 !rpc_api_pipe_req (cli, SPOOLSS_GETPRINTERDRIVER2, &qbuf, &rbuf))
778 /* Unmarshall response */
780 if (spoolss_io_r_getprinterdriver2 ("", &r, &rbuf, 0)) {
787 /* Return output parameters */
789 if (!W_ERROR_IS_OK(result))
797 decode_printer_driver_1(mem_ctx, r.buffer, 1, &ctr->info1);
800 decode_printer_driver_2(mem_ctx, r.buffer, 1, &ctr->info2);
803 decode_printer_driver_3(mem_ctx, r.buffer, 1, &ctr->info3);
806 DEBUG(10, ("cli_spoolss_getprinterdriver: unknown info level %d", level));
807 return WERR_UNKNOWN_LEVEL;
817 /*********************************************************************************
818 Win32 API - EnumPrinterDrivers()
819 ********************************************************************************/
820 /**********************************************************************
821 * Get installed printer drivers for a given printer
823 WERROR cli_spoolss_enumprinterdrivers (struct cli_state *cli,
825 uint32 offered, uint32 *needed,
826 uint32 level, const char *env,
828 PRINTER_DRIVER_CTR *ctr)
830 prs_struct qbuf, rbuf;
831 SPOOL_Q_ENUMPRINTERDRIVERS q;
832 SPOOL_R_ENUMPRINTERDRIVERS r;
834 WERROR result = W_ERROR(ERRgeneral);
840 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
843 /* Initialise input parameters */
845 init_buffer(&buffer, offered, mem_ctx);
847 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
848 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
850 /* Write the request */
852 make_spoolss_q_enumprinterdrivers(&q, server, env, level, &buffer,
855 /* Marshall data and send request */
857 if (!spoolss_io_q_enumprinterdrivers ("", &q, &qbuf, 0) ||
858 !rpc_api_pipe_req (cli, SPOOLSS_ENUMPRINTERDRIVERS, &qbuf, &rbuf))
861 /* Unmarshall response */
863 if (!spoolss_io_r_enumprinterdrivers ("", &r, &rbuf, 0))
870 *num_drivers = r.returned;
874 /* Return output parameters */
876 if (W_ERROR_IS_OK(result) && (r.returned != 0)) {
877 *num_drivers = r.returned;
881 decode_printer_driver_1(mem_ctx, r.buffer, r.returned, &ctr->info1);
884 decode_printer_driver_2(mem_ctx, r.buffer, r.returned, &ctr->info2);
887 decode_printer_driver_3(mem_ctx, r.buffer, r.returned, &ctr->info3);
890 DEBUG(10, ("cli_spoolss_enumprinterdrivers: unknown info level %d\n",
892 return WERR_UNKNOWN_LEVEL;
904 /*********************************************************************************
905 Win32 API - GetPrinterDriverDirectory()
906 ********************************************************************************/
907 /**********************************************************************
908 * Get installed printer drivers for a given printer
910 WERROR cli_spoolss_getprinterdriverdir (struct cli_state *cli,
912 uint32 offered, uint32 *needed,
913 uint32 level, char *env,
914 DRIVER_DIRECTORY_CTR *ctr)
916 prs_struct qbuf, rbuf;
917 SPOOL_Q_GETPRINTERDRIVERDIR q;
918 SPOOL_R_GETPRINTERDRIVERDIR r;
920 WERROR result = W_ERROR(ERRgeneral);
926 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
929 /* Initialise input parameters */
931 init_buffer(&buffer, offered, mem_ctx);
933 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
934 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
936 /* Write the request */
938 make_spoolss_q_getprinterdriverdir(&q, server, env, level, &buffer,
941 /* Marshall data and send request */
943 if (!spoolss_io_q_getprinterdriverdir ("", &q, &qbuf, 0) ||
944 !rpc_api_pipe_req (cli, SPOOLSS_GETPRINTERDRIVERDIRECTORY,
948 /* Unmarshall response */
950 if (spoolss_io_r_getprinterdriverdir ("", &r, &rbuf, 0)) {
955 /* Return output parameters */
959 if (W_ERROR_IS_OK(result)) {
962 decode_printerdriverdir_1(mem_ctx, r.buffer, 1,
975 /*********************************************************************************
976 Win32 API - AddPrinterDriver()
977 ********************************************************************************/
978 /**********************************************************************
979 * Install a printer driver
981 WERROR cli_spoolss_addprinterdriver (struct cli_state *cli,
982 TALLOC_CTX *mem_ctx, uint32 level,
983 PRINTER_DRIVER_CTR *ctr)
985 prs_struct qbuf, rbuf;
986 SPOOL_Q_ADDPRINTERDRIVER q;
987 SPOOL_R_ADDPRINTERDRIVER r;
988 WERROR result = W_ERROR(ERRgeneral);
994 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
997 /* Initialise input parameters */
999 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1000 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1002 /* Write the request */
1004 make_spoolss_q_addprinterdriver (mem_ctx, &q, server, level, ctr);
1006 /* Marshall data and send request */
1008 if (!spoolss_io_q_addprinterdriver ("", &q, &qbuf, 0) ||
1009 !rpc_api_pipe_req (cli, SPOOLSS_ADDPRINTERDRIVER, &qbuf, &rbuf))
1012 /* Unmarshall response */
1014 if (!spoolss_io_r_addprinterdriver ("", &r, &rbuf, 0))
1017 /* Return output parameters */
1022 prs_mem_free(&qbuf);
1023 prs_mem_free(&rbuf);
1028 /*********************************************************************************
1029 Win32 API - AddPrinter()
1030 ********************************************************************************/
1031 /**********************************************************************
1034 WERROR cli_spoolss_addprinterex (struct cli_state *cli, TALLOC_CTX *mem_ctx,
1035 uint32 level, PRINTER_INFO_CTR*ctr)
1037 prs_struct qbuf, rbuf;
1038 SPOOL_Q_ADDPRINTEREX q;
1039 SPOOL_R_ADDPRINTEREX r;
1040 WERROR result = W_ERROR(ERRgeneral);
1048 slprintf(client, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1050 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1052 fstrcpy (user, cli->user_name);
1054 /* Initialise input parameters */
1056 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1057 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1059 /* Write the request */
1061 make_spoolss_q_addprinterex (mem_ctx, &q, server, client, user,
1064 /* Marshall data and send request */
1066 if (!spoolss_io_q_addprinterex ("", &q, &qbuf, 0) ||
1067 !rpc_api_pipe_req (cli, SPOOLSS_ADDPRINTEREX, &qbuf, &rbuf))
1070 /* Unmarshall response */
1072 if (!spoolss_io_r_addprinterex ("", &r, &rbuf, 0))
1075 /* Return output parameters */
1080 prs_mem_free(&qbuf);
1081 prs_mem_free(&rbuf);
1086 /**********************************************************************
1087 * Delete a Printer Driver from the server (DOES remove
1090 WERROR cli_spoolss_deleteprinterdriverex(struct cli_state *cli,
1091 TALLOC_CTX *mem_ctx, const char *arch,
1094 prs_struct qbuf, rbuf;
1095 SPOOL_Q_DELETEPRINTERDRIVEREX q;
1096 SPOOL_R_DELETEPRINTERDRIVEREX r;
1097 WERROR result = W_ERROR(ERRgeneral);
1104 /* Initialise input parameters */
1105 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1106 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1108 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1111 /* Write the request */
1112 make_spoolss_q_deleteprinterdriverex(mem_ctx, &q, server, arch, driver);
1114 /* Marshall data and send request */
1116 if (!spoolss_io_q_deleteprinterdriverex ("", &q, &qbuf, 0)
1117 || !rpc_api_pipe_req (cli,SPOOLSS_DELETEPRINTERDRIVEREX , &qbuf, &rbuf))
1122 /* Unmarshall response */
1124 if (!spoolss_io_r_deleteprinterdriverex ("", &r, &rbuf, 0))
1127 /* Return output parameters */
1132 prs_mem_free(&qbuf);
1133 prs_mem_free(&rbuf);
1138 /*********************************************************************************
1139 Win32 API - DeltePrinterDriver()
1140 ********************************************************************************/
1141 /**********************************************************************
1142 * Delete a Printer Driver from the server (does not remove
1145 WERROR cli_spoolss_deleteprinterdriver (struct cli_state *cli,
1146 TALLOC_CTX *mem_ctx, const char *arch,
1149 prs_struct qbuf, rbuf;
1150 SPOOL_Q_DELETEPRINTERDRIVER q;
1151 SPOOL_R_DELETEPRINTERDRIVER r;
1152 WERROR result = W_ERROR(ERRgeneral);
1159 /* Initialise input parameters */
1160 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1161 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1163 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1166 /* Write the request */
1168 make_spoolss_q_deleteprinterdriver(mem_ctx, &q, server, arch, driver);
1170 /* Marshall data and send request */
1172 if (!spoolss_io_q_deleteprinterdriver ("", &q, &qbuf, 0) ||
1173 !rpc_api_pipe_req (cli,SPOOLSS_DELETEPRINTERDRIVER , &qbuf, &rbuf))
1176 /* Unmarshall response */
1178 if (!spoolss_io_r_deleteprinterdriver ("", &r, &rbuf, 0))
1181 /* Return output parameters */
1186 prs_mem_free(&qbuf);
1187 prs_mem_free(&rbuf);
1192 /*********************************************************************************
1193 Win32 API - GetPrinterProcessorDirectory()
1194 ********************************************************************************/
1196 WERROR cli_spoolss_getprintprocessordirectory(struct cli_state *cli,
1197 TALLOC_CTX *mem_ctx,
1198 uint32 offered, uint32 *needed,
1199 char *name, char *environment,
1202 prs_struct qbuf, rbuf;
1203 SPOOL_Q_GETPRINTPROCESSORDIRECTORY q;
1204 SPOOL_R_GETPRINTPROCESSORDIRECTORY r;
1206 WERROR result = W_ERROR(ERRgeneral);
1212 /* Initialise parse structures */
1214 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1215 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1217 /* Initialise input parameters */
1219 init_buffer(&buffer, offered, mem_ctx);
1221 make_spoolss_q_getprintprocessordirectory(
1222 &q, name, environment, level, &buffer, offered);
1224 /* Marshall data and send request */
1226 if (!spoolss_io_q_getprintprocessordirectory("", &q, &qbuf, 0) ||
1227 !rpc_api_pipe_req(cli, SPOOLSS_GETPRINTPROCESSORDIRECTORY,
1231 /* Unmarshall response */
1233 if (!spoolss_io_r_getprintprocessordirectory("", &r, &rbuf, 0))
1236 /* Return output parameters */
1243 if (W_ERROR_IS_OK(result))
1244 fstrcpy(procdir, "Not implemented!");
1247 prs_mem_free(&qbuf);
1248 prs_mem_free(&rbuf);
1253 /** Add a form to a printer.
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.
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.
1266 WERROR cli_spoolss_addform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1267 POLICY_HND *handle, uint32 level, FORM *form)
1269 prs_struct qbuf, rbuf;
1272 WERROR result = W_ERROR(ERRgeneral);
1277 /* Initialise parse structures */
1279 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1280 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1282 /* Initialise input parameters */
1284 make_spoolss_q_addform(&q, handle, level, form);
1286 /* Marshall data and send request */
1288 if (!spoolss_io_q_addform("", &q, &qbuf, 0) ||
1289 !rpc_api_pipe_req(cli, SPOOLSS_ADDFORM, &qbuf, &rbuf))
1292 /* Unmarshall response */
1294 if (!spoolss_io_r_addform("", &r, &rbuf, 0))
1297 /* Return output parameters */
1302 prs_mem_free(&qbuf);
1303 prs_mem_free(&rbuf);
1308 /** Set a form on a printer.
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.
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.
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)
1325 prs_struct qbuf, rbuf;
1328 WERROR result = W_ERROR(ERRgeneral);
1333 /* Initialise parse structures */
1335 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1336 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1338 /* Initialise input parameters */
1340 make_spoolss_q_setform(&q, handle, level, form_name, form);
1342 /* Marshall data and send request */
1344 if (!spoolss_io_q_setform("", &q, &qbuf, 0) ||
1345 !rpc_api_pipe_req(cli, SPOOLSS_SETFORM, &qbuf, &rbuf))
1348 /* Unmarshall response */
1350 if (!spoolss_io_r_setform("", &r, &rbuf, 0))
1353 /* Return output parameters */
1357 if (!W_ERROR_IS_OK(result))
1363 prs_mem_free(&qbuf);
1364 prs_mem_free(&rbuf);
1369 /** Get a form on a printer.
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.
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.
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)
1387 prs_struct qbuf, rbuf;
1390 WERROR result = W_ERROR(ERRgeneral);
1396 /* Initialise parse structures */
1398 init_buffer(&buffer, offered, mem_ctx);
1400 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1401 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1403 /* Initialise input parameters */
1405 make_spoolss_q_getform(&q, handle, formname, level, &buffer, offered);
1407 /* Marshall data and send request */
1409 if (!spoolss_io_q_getform("", &q, &qbuf, 0) ||
1410 !rpc_api_pipe_req(cli, SPOOLSS_GETFORM, &qbuf, &rbuf))
1413 /* Unmarshall response */
1415 if (!spoolss_io_r_getform("", &r, &rbuf, 0))
1418 /* Return output parameters */
1425 if (W_ERROR_IS_OK(result)) {
1428 smb_io_form_1("", r.buffer, form, 0);
1431 DEBUG(10, ("cli_spoolss_getform: unknown info level %d", level));
1432 return WERR_UNKNOWN_LEVEL;
1437 prs_mem_free(&qbuf);
1438 prs_mem_free(&rbuf);
1443 /** Delete a form on a printer.
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.
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.
1455 WERROR cli_spoolss_deleteform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1456 POLICY_HND *handle, const char *form_name)
1458 prs_struct qbuf, rbuf;
1459 SPOOL_Q_DELETEFORM q;
1460 SPOOL_R_DELETEFORM r;
1461 WERROR result = W_ERROR(ERRgeneral);
1466 /* Initialise parse structures */
1468 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1469 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1471 /* Initialise input parameters */
1473 make_spoolss_q_deleteform(&q, handle, form_name);
1475 /* Marshall data and send request */
1477 if (!spoolss_io_q_deleteform("", &q, &qbuf, 0) ||
1478 !rpc_api_pipe_req(cli, SPOOLSS_DELETEFORM, &qbuf, &rbuf))
1481 /* Unmarshall response */
1483 if (!spoolss_io_r_deleteform("", &r, &rbuf, 0))
1486 /* Return output parameters */
1491 prs_mem_free(&qbuf);
1492 prs_mem_free(&rbuf);
1497 static void decode_forms_1(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
1498 uint32 num_forms, FORM_1 **forms)
1502 *forms = (FORM_1 *)talloc(mem_ctx, num_forms * sizeof(FORM_1));
1503 prs_set_offset(&buffer->prs,0);
1505 for (i = 0; i < num_forms; i++)
1506 smb_io_form_1("", buffer, &((*forms)[i]), 0);
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.
1515 * @param offered Buffer size offered in the request.
1516 * @param needed Number of bytes needed to complete the request.
1518 * or cli_spoolss_addprinterex.
1519 * @param level Form info level to get - should always be 1.
1520 * @param handle Open policy handle
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,
1529 prs_struct qbuf, rbuf;
1530 SPOOL_Q_ENUMFORMS q;
1531 SPOOL_R_ENUMFORMS r;
1532 WERROR result = W_ERROR(ERRgeneral);
1538 /* Initialise parse structures */
1540 init_buffer(&buffer, offered, mem_ctx);
1542 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1543 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1545 /* Initialise input parameters */
1547 make_spoolss_q_enumforms(&q, handle, level, &buffer, offered);
1549 /* Marshall data and send request */
1551 if (!spoolss_io_q_enumforms("", &q, &qbuf, 0) ||
1552 !rpc_api_pipe_req(cli, SPOOLSS_ENUMFORMS, &qbuf, &rbuf))
1555 /* Unmarshall response */
1557 if (!spoolss_io_r_enumforms("", &r, &rbuf, 0))
1560 /* Return output parameters */
1568 *num_forms = r.numofforms;
1570 decode_forms_1(mem_ctx, r.buffer, *num_forms, forms);
1573 prs_mem_free(&qbuf);
1574 prs_mem_free(&rbuf);
1579 static void decode_jobs_1(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
1580 uint32 num_jobs, JOB_INFO_1 **jobs)
1584 *jobs = (JOB_INFO_1 *)talloc(mem_ctx, num_jobs * sizeof(JOB_INFO_1));
1585 prs_set_offset(&buffer->prs,0);
1587 for (i = 0; i < num_jobs; i++)
1588 smb_io_job_info_1("", buffer, &((*jobs)[i]), 0);
1591 static void decode_jobs_2(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
1592 uint32 num_jobs, JOB_INFO_2 **jobs)
1596 *jobs = (JOB_INFO_2 *)talloc(mem_ctx, num_jobs * sizeof(JOB_INFO_2));
1597 prs_set_offset(&buffer->prs,0);
1599 for (i = 0; i < num_jobs; i++)
1600 smb_io_job_info_2("", buffer, &((*jobs)[i]), 0);
1603 /* Enumerate jobs */
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)
1610 prs_struct qbuf, rbuf;
1613 WERROR result = W_ERROR(ERRgeneral);
1619 /* Initialise parse structures */
1621 init_buffer(&buffer, offered, mem_ctx);
1623 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1624 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1626 /* Initialise input parameters */
1628 make_spoolss_q_enumjobs(&q, hnd, firstjob, num_jobs, level, &buffer,
1631 /* Marshall data and send request */
1633 if (!spoolss_io_q_enumjobs("", &q, &qbuf, 0) ||
1634 !rpc_api_pipe_req(cli, SPOOLSS_ENUMJOBS, &qbuf, &rbuf))
1637 /* Unmarshall response */
1639 if (!spoolss_io_r_enumjobs("", &r, &rbuf, 0))
1642 /* Return output parameters */
1649 if (!W_ERROR_IS_OK(r.status))
1652 *returned = r.returned;
1656 decode_jobs_1(mem_ctx, r.buffer, r.returned,
1657 &ctr->job.job_info_1);
1660 decode_jobs_2(mem_ctx, r.buffer, r.returned,
1661 &ctr->job.job_info_2);
1664 DEBUG(3, ("unsupported info level %d", level));
1669 prs_mem_free(&qbuf);
1670 prs_mem_free(&rbuf);
1677 WERROR cli_spoolss_setjob(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1678 POLICY_HND *hnd, uint32 jobid, uint32 level,
1681 prs_struct qbuf, rbuf;
1684 WERROR result = W_ERROR(ERRgeneral);
1689 /* Initialise parse structures */
1691 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1692 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1694 /* Initialise input parameters */
1696 make_spoolss_q_setjob(&q, hnd, jobid, level, command);
1698 /* Marshall data and send request */
1700 if (!spoolss_io_q_setjob("", &q, &qbuf, 0) ||
1701 !rpc_api_pipe_req(cli, SPOOLSS_SETJOB, &qbuf, &rbuf))
1704 /* Unmarshall response */
1706 if (!spoolss_io_r_setjob("", &r, &rbuf, 0))
1709 /* Return output parameters */
1714 prs_mem_free(&qbuf);
1715 prs_mem_free(&rbuf);
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,
1727 prs_struct qbuf, rbuf;
1730 WERROR result = W_ERROR(ERRgeneral);
1736 /* Initialise parse structures */
1738 init_buffer(&buffer, offered, mem_ctx);
1740 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1741 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1743 /* Initialise input parameters */
1745 make_spoolss_q_getjob(&q, hnd, jobid, level, &buffer, offered);
1747 /* Marshall data and send request */
1749 if (!spoolss_io_q_getjob("", &q, &qbuf, 0) ||
1750 !rpc_api_pipe_req(cli, SPOOLSS_GETJOB, &qbuf, &rbuf))
1753 /* Unmarshall response */
1755 if (!spoolss_io_r_getjob("", &r, &rbuf, 0))
1758 /* Return output parameters */
1765 if (!W_ERROR_IS_OK(r.status))
1770 decode_jobs_1(mem_ctx, r.buffer, 1, &ctr->job.job_info_1);
1773 decode_jobs_2(mem_ctx, r.buffer, 1, &ctr->job.job_info_2);
1776 DEBUG(3, ("unsupported info level %d", level));
1781 prs_mem_free(&qbuf);
1782 prs_mem_free(&rbuf);
1787 /* Startpageprinter. Sent to notify the spooler when a page is about to be
1788 sent to a printer. */
1790 WERROR cli_spoolss_startpageprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1793 prs_struct qbuf, rbuf;
1794 SPOOL_Q_STARTPAGEPRINTER q;
1795 SPOOL_R_STARTPAGEPRINTER r;
1796 WERROR result = W_ERROR(ERRgeneral);
1801 /* Initialise parse structures */
1803 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1804 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1806 /* Initialise input parameters */
1808 make_spoolss_q_startpageprinter(&q, hnd);
1810 /* Marshall data and send request */
1812 if (!spoolss_io_q_startpageprinter("", &q, &qbuf, 0) ||
1813 !rpc_api_pipe_req(cli, SPOOLSS_STARTPAGEPRINTER, &qbuf, &rbuf))
1816 /* Unmarshall response */
1818 if (!spoolss_io_r_startpageprinter("", &r, &rbuf, 0))
1821 /* Return output parameters */
1826 prs_mem_free(&qbuf);
1827 prs_mem_free(&rbuf);
1832 /* Endpageprinter. Sent to notify the spooler when a page has finished
1833 being sent to a printer. */
1835 WERROR cli_spoolss_endpageprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1838 prs_struct qbuf, rbuf;
1839 SPOOL_Q_ENDPAGEPRINTER q;
1840 SPOOL_R_ENDPAGEPRINTER r;
1841 WERROR result = W_ERROR(ERRgeneral);
1846 /* Initialise parse structures */
1848 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1849 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1851 /* Initialise input parameters */
1853 make_spoolss_q_endpageprinter(&q, hnd);
1855 /* Marshall data and send request */
1857 if (!spoolss_io_q_endpageprinter("", &q, &qbuf, 0) ||
1858 !rpc_api_pipe_req(cli, SPOOLSS_ENDPAGEPRINTER, &qbuf, &rbuf))
1861 /* Unmarshall response */
1863 if (!spoolss_io_r_endpageprinter("", &r, &rbuf, 0))
1866 /* Return output parameters */
1871 prs_mem_free(&qbuf);
1872 prs_mem_free(&rbuf);
1877 /* Startdocprinter. Sent to notify the spooler that a document is about
1878 to be spooled for printing. */
1880 WERROR cli_spoolss_startdocprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1881 POLICY_HND *hnd, char *docname,
1882 char *outputfile, char *datatype,
1885 prs_struct qbuf, rbuf;
1886 SPOOL_Q_STARTDOCPRINTER q;
1887 SPOOL_R_STARTDOCPRINTER r;
1888 WERROR result = W_ERROR(ERRgeneral);
1894 /* Initialise parse structures */
1896 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1897 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1899 /* Initialise input parameters */
1901 make_spoolss_q_startdocprinter(&q, hnd, level, docname, outputfile,
1904 /* Marshall data and send request */
1906 if (!spoolss_io_q_startdocprinter("", &q, &qbuf, 0) ||
1907 !rpc_api_pipe_req(cli, SPOOLSS_STARTDOCPRINTER, &qbuf, &rbuf))
1910 /* Unmarshall response */
1912 if (!spoolss_io_r_startdocprinter("", &r, &rbuf, 0))
1915 /* Return output parameters */
1919 if (W_ERROR_IS_OK(result))
1923 prs_mem_free(&qbuf);
1924 prs_mem_free(&rbuf);
1929 /* Enddocprinter. Sent to notify the spooler that a document has finished
1932 WERROR cli_spoolss_enddocprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1935 prs_struct qbuf, rbuf;
1936 SPOOL_Q_ENDDOCPRINTER q;
1937 SPOOL_R_ENDDOCPRINTER r;
1938 WERROR result = W_ERROR(ERRgeneral);
1943 /* Initialise parse structures */
1945 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1946 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1948 /* Initialise input parameters */
1950 make_spoolss_q_enddocprinter(&q, hnd);
1952 /* Marshall data and send request */
1954 if (!spoolss_io_q_enddocprinter("", &q, &qbuf, 0) ||
1955 !rpc_api_pipe_req(cli, SPOOLSS_ENDDOCPRINTER, &qbuf, &rbuf))
1958 /* Unmarshall response */
1960 if (!spoolss_io_r_enddocprinter("", &r, &rbuf, 0))
1963 /* Return output parameters */
1968 prs_mem_free(&qbuf);
1969 prs_mem_free(&rbuf);
1974 /* Get printer data */
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)
1981 prs_struct qbuf, rbuf;
1982 SPOOL_Q_GETPRINTERDATA q;
1983 SPOOL_R_GETPRINTERDATA r;
1984 WERROR result = W_ERROR(ERRgeneral);
1989 /* Initialise parse structures */
1991 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1992 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1994 /* Initialise input parameters */
1996 make_spoolss_q_getprinterdata(&q, hnd, valuename, offered);
1998 /* Marshall data and send request */
2000 if (!spoolss_io_q_getprinterdata("", &q, &qbuf, 0) ||
2001 !rpc_api_pipe_req(cli, SPOOLSS_GETPRINTERDATA, &qbuf, &rbuf))
2004 /* Unmarshall response */
2006 if (!spoolss_io_r_getprinterdata("", &r, &rbuf, 0))
2014 if (!W_ERROR_IS_OK(r.status))
2017 /* Return output parameters */
2019 value->data_p = talloc_memdup(mem_ctx, r.data, r.needed);
2020 value->type = r.type;
2021 value->size = r.size;
2024 prs_mem_free(&qbuf);
2025 prs_mem_free(&rbuf);
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)
2036 prs_struct qbuf, rbuf;
2037 SPOOL_Q_GETPRINTERDATAEX q;
2038 SPOOL_R_GETPRINTERDATAEX r;
2039 WERROR result = W_ERROR(ERRgeneral);
2044 /* Initialise parse structures */
2046 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2047 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2049 /* Initialise input parameters */
2051 make_spoolss_q_getprinterdataex(&q, hnd, keyname, valuename, offered);
2053 /* Marshall data and send request */
2055 if (!spoolss_io_q_getprinterdataex("", &q, &qbuf, 0) ||
2056 !rpc_api_pipe_req(cli, SPOOLSS_GETPRINTERDATAEX, &qbuf, &rbuf))
2059 /* Unmarshall response */
2061 if (!spoolss_io_r_getprinterdataex("", &r, &rbuf, 0))
2069 if (!W_ERROR_IS_OK(r.status))
2072 /* Return output parameters */
2074 value->data_p = talloc_memdup(mem_ctx, r.data, r.needed);
2075 value->type = r.type;
2076 value->size = r.needed;
2079 prs_mem_free(&qbuf);
2080 prs_mem_free(&rbuf);
2085 /* Set printer data */
2087 WERROR cli_spoolss_setprinterdata(struct cli_state *cli, TALLOC_CTX *mem_ctx,
2088 POLICY_HND *hnd, REGISTRY_VALUE *value)
2090 prs_struct qbuf, rbuf;
2091 SPOOL_Q_SETPRINTERDATA q;
2092 SPOOL_R_SETPRINTERDATA r;
2093 WERROR result = W_ERROR(ERRgeneral);
2098 /* Initialise parse structures */
2100 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2101 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2103 /* Initialise input parameters */
2105 make_spoolss_q_setprinterdata(
2106 &q, hnd, value->valuename, value->type, (char *)value->data_p, value->size);
2108 /* Marshall data and send request */
2110 if (!spoolss_io_q_setprinterdata("", &q, &qbuf, 0) ||
2111 !rpc_api_pipe_req(cli, SPOOLSS_SETPRINTERDATA, &qbuf, &rbuf))
2114 /* Unmarshall response */
2116 if (!spoolss_io_r_setprinterdata("", &r, &rbuf, 0))
2121 if (!W_ERROR_IS_OK(r.status))
2125 prs_mem_free(&qbuf);
2126 prs_mem_free(&rbuf);
2131 WERROR cli_spoolss_setprinterdataex(struct cli_state *cli, TALLOC_CTX *mem_ctx,
2132 POLICY_HND *hnd, char *keyname,
2133 REGISTRY_VALUE *value)
2135 prs_struct qbuf, rbuf;
2136 SPOOL_Q_SETPRINTERDATAEX q;
2137 SPOOL_R_SETPRINTERDATAEX r;
2138 WERROR result = W_ERROR(ERRgeneral);
2143 /* Initialise parse structures */
2145 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2146 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2148 /* Initialise input parameters */
2150 make_spoolss_q_setprinterdataex(
2151 &q, hnd, keyname, value->valuename, value->type, (char *)value->data_p,
2154 /* Marshall data and send request */
2156 if (!spoolss_io_q_setprinterdataex("", &q, &qbuf, 0) ||
2157 !rpc_api_pipe_req(cli, SPOOLSS_SETPRINTERDATAEX, &qbuf, &rbuf))
2160 /* Unmarshall response */
2162 if (!spoolss_io_r_setprinterdataex("", &r, &rbuf, 0))
2167 if (!W_ERROR_IS_OK(r.status))
2171 prs_mem_free(&qbuf);
2172 prs_mem_free(&rbuf);
2177 /* Enum printer data */
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)
2185 prs_struct qbuf, rbuf;
2186 SPOOL_Q_ENUMPRINTERDATA q;
2187 SPOOL_R_ENUMPRINTERDATA r;
2188 WERROR result = W_ERROR(ERRgeneral);
2193 /* Initialise parse structures */
2195 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2196 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2198 /* Initialise input parameters */
2200 make_spoolss_q_enumprinterdata(&q, hnd, ndx, value_offered, data_offered);
2202 /* Marshall data and send request */
2204 if (!spoolss_io_q_enumprinterdata("", &q, &qbuf, 0) ||
2205 !rpc_api_pipe_req(cli, SPOOLSS_ENUMPRINTERDATA, &qbuf, &rbuf))
2208 /* Unmarshall response */
2210 if (!spoolss_io_r_enumprinterdata("", &r, &rbuf, 0))
2215 if (!W_ERROR_IS_OK(r.status))
2221 *value_needed = r.realvaluesize;
2224 *data_needed = r.realdatasize;
2227 rpcstr_pull(value->valuename, r.value, sizeof(value->valuename), -1,
2229 value->data_p = talloc_memdup(mem_ctx, r.data, r.realdatasize);
2230 value->type = r.type;
2231 value->size = r.realdatasize;
2235 prs_mem_free(&qbuf);
2236 prs_mem_free(&rbuf);
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,
2246 prs_struct qbuf, rbuf;
2247 SPOOL_Q_ENUMPRINTERDATAEX q;
2248 SPOOL_R_ENUMPRINTERDATAEX r;
2249 WERROR result = W_ERROR(ERRgeneral);
2255 /* Initialise parse structures */
2257 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2258 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2260 /* Initialise input parameters */
2262 make_spoolss_q_enumprinterdataex(&q, hnd, keyname, offered);
2264 /* Marshall data and send request */
2266 if (!spoolss_io_q_enumprinterdataex("", &q, &qbuf, 0) ||
2267 !rpc_api_pipe_req(cli, SPOOLSS_ENUMPRINTERDATAEX, &qbuf, &rbuf))
2270 /* Unmarshall response */
2272 if (!spoolss_io_r_enumprinterdataex("", &r, &rbuf, 0))
2280 if (!W_ERROR_IS_OK(r.status))
2286 regval_ctr_init(ctr);
2288 for (i = 0; i < r.returned; i++) {
2289 PRINTER_ENUM_VALUES *v = &r.ctr.values[i];
2292 rpcstr_pull(name, v->valuename.buffer, sizeof(name), -1,
2294 regval_ctr_addvalue(ctr, name, v->type, (const char *)v->data, v->data_len);
2298 prs_mem_free(&qbuf);
2299 prs_mem_free(&rbuf);
2304 /* Write data to printer */
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)
2310 prs_struct qbuf, rbuf;
2311 SPOOL_Q_WRITEPRINTER q;
2312 SPOOL_R_WRITEPRINTER r;
2313 WERROR result = W_ERROR(ERRgeneral);
2318 /* Initialise parse structures */
2320 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2321 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2323 /* Initialise input parameters */
2325 make_spoolss_q_writeprinter(&q, hnd, data_size, data);
2327 /* Marshall data and send request */
2329 if (!spoolss_io_q_writeprinter("", &q, &qbuf, 0) ||
2330 !rpc_api_pipe_req(cli, SPOOLSS_WRITEPRINTER, &qbuf, &rbuf))
2333 /* Unmarshall response */
2335 if (!spoolss_io_r_writeprinter("", &r, &rbuf, 0))
2340 if (!W_ERROR_IS_OK(r.status))
2344 *num_written = r.buffer_written;
2347 prs_mem_free(&qbuf);
2348 prs_mem_free(&rbuf);
2353 /* Delete printer data */
2355 WERROR cli_spoolss_deleteprinterdata(struct cli_state *cli, TALLOC_CTX *mem_ctx,
2356 POLICY_HND *hnd, char *valuename)
2358 prs_struct qbuf, rbuf;
2359 SPOOL_Q_DELETEPRINTERDATA q;
2360 SPOOL_R_DELETEPRINTERDATA r;
2361 WERROR result = W_ERROR(ERRgeneral);
2366 /* Initialise parse structures */
2368 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2369 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2371 /* Initialise input parameters */
2373 make_spoolss_q_deleteprinterdata(&q, hnd, valuename);
2375 /* Marshall data and send request */
2377 if (!spoolss_io_q_deleteprinterdata("", &q, &qbuf, 0) ||
2378 !rpc_api_pipe_req(cli, SPOOLSS_DELETEPRINTERDATA, &qbuf, &rbuf))
2381 /* Unmarshall response */
2383 if (!spoolss_io_r_deleteprinterdata("", &r, &rbuf, 0))
2388 if (!W_ERROR_IS_OK(r.status))
2392 prs_mem_free(&qbuf);
2393 prs_mem_free(&rbuf);
2398 WERROR cli_spoolss_deleteprinterdataex(struct cli_state *cli, TALLOC_CTX *mem_ctx,
2399 POLICY_HND *hnd, char *keyname,
2402 prs_struct qbuf, rbuf;
2403 SPOOL_Q_DELETEPRINTERDATAEX q;
2404 SPOOL_R_DELETEPRINTERDATAEX r;
2405 WERROR result = W_ERROR(ERRgeneral);
2410 /* Initialise parse structures */
2412 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2413 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2415 /* Initialise input parameters */
2417 make_spoolss_q_deleteprinterdataex(&q, hnd, keyname, valuename);
2419 /* Marshall data and send request */
2421 if (!spoolss_io_q_deleteprinterdataex("", &q, &qbuf, 0) ||
2422 !rpc_api_pipe_req(cli, SPOOLSS_DELETEPRINTERDATAEX, &qbuf, &rbuf))
2425 /* Unmarshall response */
2427 if (!spoolss_io_r_deleteprinterdataex("", &r, &rbuf, 0))
2432 if (!W_ERROR_IS_OK(r.status))
2436 prs_mem_free(&qbuf);
2437 prs_mem_free(&rbuf);
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)
2447 prs_struct qbuf, rbuf;
2448 SPOOL_Q_ENUMPRINTERKEY q;
2449 SPOOL_R_ENUMPRINTERKEY r;
2450 WERROR result = W_ERROR(ERRgeneral);
2455 /* Initialise parse structures */
2457 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2458 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2460 /* Initialise input parameters */
2462 make_spoolss_q_enumprinterkey(&q, hnd, keyname, offered);
2464 /* Marshall data and send request */
2466 if (!spoolss_io_q_enumprinterkey("", &q, &qbuf, 0) ||
2467 !rpc_api_pipe_req(cli, SPOOLSS_ENUMPRINTERKEY, &qbuf, &rbuf))
2470 /* Unmarshall response */
2472 if (!spoolss_io_r_enumprinterkey("", &r, &rbuf, 0))
2480 if (!W_ERROR_IS_OK(r.status))
2486 *keylist = (uint16 *)malloc(r.keys.buf_len * 2);
2487 memcpy(*keylist, r.keys.buffer, r.keys.buf_len * 2);
2489 *len = r.keys.buf_len * 2;
2493 prs_mem_free(&qbuf);
2494 prs_mem_free(&rbuf);
2499 WERROR cli_spoolss_deleteprinterkey(struct cli_state *cli, TALLOC_CTX *mem_ctx,
2500 POLICY_HND *hnd, char *keyname)
2502 prs_struct qbuf, rbuf;
2503 SPOOL_Q_DELETEPRINTERKEY q;
2504 SPOOL_R_DELETEPRINTERKEY r;
2505 WERROR result = W_ERROR(ERRgeneral);
2510 /* Initialise parse structures */
2512 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2513 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2515 /* Initialise input parameters */
2517 make_spoolss_q_deleteprinterkey(&q, hnd, keyname);
2519 /* Marshall data and send request */
2521 if (!spoolss_io_q_deleteprinterkey("", &q, &qbuf, 0) ||
2522 !rpc_api_pipe_req(cli, SPOOLSS_DELETEPRINTERKEY, &qbuf, &rbuf))
2525 /* Unmarshall response */
2527 if (!spoolss_io_r_deleteprinterkey("", &r, &rbuf, 0))
2532 if (!W_ERROR_IS_OK(r.status))
2536 prs_mem_free(&qbuf);
2537 prs_mem_free(&rbuf);