2 Unix SMB/CIFS implementation.
5 Copyright (C) Gerald Carter 2001
6 Copyright (C) Tim Potter 2000
7 Copyright (C) Andrew Tridgell 1992-1999
8 Copyright (C) Luke Kenneth Casson Leighton 1996-1999
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 #include "rpcclient.h"
29 const char *long_archi
;
30 const char *short_archi
;
34 static const struct table_node archi_table
[]= {
36 {"Windows 4.0", "WIN40", 0 },
37 {"Windows NT x86", "W32X86", 2 },
38 {"Windows NT R4000", "W32MIPS", 2 },
39 {"Windows NT Alpha_AXP", "W32ALPHA", 2 },
40 {"Windows NT PowerPC", "W32PPC", 2 },
44 /****************************************************************************
45 function to do the mapping between the long architecture name and
47 ****************************************************************************/
48 BOOL
get_short_archi(char *short_archi
, const char *long_archi
)
52 DEBUG(107,("Getting architecture dependant directory\n"));
55 } while ( (archi_table
[i
].long_archi
!=NULL
) &&
56 StrCaseCmp(long_archi
, archi_table
[i
].long_archi
) );
58 if (archi_table
[i
].long_archi
==NULL
) {
59 DEBUGADD(10,("Unknown architecture [%s] !\n", long_archi
));
63 /* this might be client code - but shouldn't this be an fstrcpy etc? */
65 StrnCpy (short_archi
, archi_table
[i
].short_archi
, strlen(archi_table
[i
].short_archi
));
67 DEBUGADD(108,("index: [%d]\n", i
));
68 DEBUGADD(108,("long architecture: [%s]\n", long_archi
));
69 DEBUGADD(108,("short architecture: [%s]\n", short_archi
));
75 /**********************************************************************
76 * dummy function -- placeholder
78 static NTSTATUS
cmd_spoolss_not_implemented(struct cli_state
*cli
,
80 int argc
, char **argv
)
82 printf ("(*) This command is not currently implemented.\n");
87 /***********************************************************************
88 * Get printer information
90 static NTSTATUS
cmd_spoolss_open_printer_ex(struct cli_state
*cli
,
92 int argc
, char **argv
)
96 fstring servername
, user
;
100 printf("Usage: %s <printername>\n", argv
[0]);
105 return NT_STATUS_UNSUCCESSFUL
;
107 slprintf (servername
, sizeof(servername
)-1, "\\\\%s", cli
->desthost
);
108 strupper (servername
);
109 fstrcpy (user
, cli
->user_name
);
110 fstrcpy (printername
, argv
[1]);
112 /* Open the printer handle */
114 werror
= cli_spoolss_open_printer_ex(cli
, mem_ctx
, printername
,
115 "", MAXIMUM_ALLOWED_ACCESS
,
116 servername
, user
, &hnd
);
118 if (W_ERROR_IS_OK(werror
)) {
119 printf("Printer %s opened successfully\n", printername
);
120 werror
= cli_spoolss_close_printer(cli
, mem_ctx
, &hnd
);
122 if (!W_ERROR_IS_OK(werror
)) {
123 printf("Error closing printer handle! (%s)\n",
124 get_dos_error_msg(werror
));
128 return W_ERROR_IS_OK(werror
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
132 /****************************************************************************
133 printer info level 0 display function
134 ****************************************************************************/
135 static void display_print_info_0(PRINTER_INFO_0
*i0
)
138 fstring servername
= "";
143 if (i0
->printername
.buffer
)
144 rpcstr_pull(name
, i0
->printername
.buffer
, sizeof(name
), -1, STR_TERMINATE
);
146 if (i0
->servername
.buffer
)
147 rpcstr_pull(servername
, i0
->servername
.buffer
, sizeof(servername
), -1,STR_TERMINATE
);
149 printf("\tprintername:[%s]\n", name
);
150 printf("\tservername:[%s]\n", servername
);
151 printf("\tcjobs:[0x%x]\n", i0
->cjobs
);
152 printf("\ttotal_jobs:[0x%x]\n", i0
->total_jobs
);
154 printf("\t:date: [%d]-[%d]-[%d] (%d)\n", i0
->year
, i0
->month
,
155 i0
->day
, i0
->dayofweek
);
156 printf("\t:time: [%d]-[%d]-[%d]-[%d]\n", i0
->hour
, i0
->minute
,
157 i0
->second
, i0
->milliseconds
);
159 printf("\tglobal_counter:[0x%x]\n", i0
->global_counter
);
160 printf("\ttotal_pages:[0x%x]\n", i0
->total_pages
);
162 printf("\tmajorversion:[0x%x]\n", i0
->major_version
);
163 printf("\tbuildversion:[0x%x]\n", i0
->build_version
);
165 printf("\tunknown7:[0x%x]\n", i0
->unknown7
);
166 printf("\tunknown8:[0x%x]\n", i0
->unknown8
);
167 printf("\tunknown9:[0x%x]\n", i0
->unknown9
);
168 printf("\tsession_counter:[0x%x]\n", i0
->session_counter
);
169 printf("\tunknown11:[0x%x]\n", i0
->unknown11
);
170 printf("\tprinter_errors:[0x%x]\n", i0
->printer_errors
);
171 printf("\tunknown13:[0x%x]\n", i0
->unknown13
);
172 printf("\tunknown14:[0x%x]\n", i0
->unknown14
);
173 printf("\tunknown15:[0x%x]\n", i0
->unknown15
);
174 printf("\tunknown16:[0x%x]\n", i0
->unknown16
);
175 printf("\tchange_id:[0x%x]\n", i0
->change_id
);
176 printf("\tunknown18:[0x%x]\n", i0
->unknown18
);
177 printf("\tstatus:[0x%x]\n", i0
->status
);
178 printf("\tunknown20:[0x%x]\n", i0
->unknown20
);
179 printf("\tc_setprinter:[0x%x]\n", i0
->c_setprinter
);
180 printf("\tunknown22:[0x%x]\n", i0
->unknown22
);
181 printf("\tunknown23:[0x%x]\n", i0
->unknown23
);
182 printf("\tunknown24:[0x%x]\n", i0
->unknown24
);
183 printf("\tunknown25:[0x%x]\n", i0
->unknown25
);
184 printf("\tunknown26:[0x%x]\n", i0
->unknown26
);
185 printf("\tunknown27:[0x%x]\n", i0
->unknown27
);
186 printf("\tunknown28:[0x%x]\n", i0
->unknown28
);
187 printf("\tunknown29:[0x%x]\n", i0
->unknown29
);
192 /****************************************************************************
193 printer info level 1 display function
194 ****************************************************************************/
195 static void display_print_info_1(PRINTER_INFO_1
*i1
)
201 if (i1
->description
.buffer
)
202 rpcstr_pull(desc
, i1
->description
.buffer
, sizeof(desc
), -1,
206 rpcstr_pull(name
, i1
->name
.buffer
, sizeof(name
), -1,
209 if (i1
->comment
.buffer
)
210 rpcstr_pull(comm
, i1
->comment
.buffer
, sizeof(comm
), -1,
213 printf("\tflags:[0x%x]\n", i1
->flags
);
214 printf("\tname:[%s]\n", name
);
215 printf("\tdescription:[%s]\n", desc
);
216 printf("\tcomment:[%s]\n", comm
);
221 /****************************************************************************
222 printer info level 2 display function
223 ****************************************************************************/
224 static void display_print_info_2(PRINTER_INFO_2
*i2
)
226 fstring servername
= "";
227 fstring printername
= "";
228 fstring sharename
= "";
229 fstring portname
= "";
230 fstring drivername
= "";
231 fstring comment
= "";
232 fstring location
= "";
233 fstring sepfile
= "";
234 fstring printprocessor
= "";
235 fstring datatype
= "";
236 fstring parameters
= "";
238 if (i2
->servername
.buffer
)
239 rpcstr_pull(servername
, i2
->servername
.buffer
,sizeof(servername
), -1, STR_TERMINATE
);
241 if (i2
->printername
.buffer
)
242 rpcstr_pull(printername
, i2
->printername
.buffer
,sizeof(printername
), -1, STR_TERMINATE
);
244 if (i2
->sharename
.buffer
)
245 rpcstr_pull(sharename
, i2
->sharename
.buffer
,sizeof(sharename
), -1, STR_TERMINATE
);
247 if (i2
->portname
.buffer
)
248 rpcstr_pull(portname
, i2
->portname
.buffer
,sizeof(portname
), -1, STR_TERMINATE
);
250 if (i2
->drivername
.buffer
)
251 rpcstr_pull(drivername
, i2
->drivername
.buffer
,sizeof(drivername
), -1, STR_TERMINATE
);
253 if (i2
->comment
.buffer
)
254 rpcstr_pull(comment
, i2
->comment
.buffer
,sizeof(comment
), -1, STR_TERMINATE
);
256 if (i2
->location
.buffer
)
257 rpcstr_pull(location
, i2
->location
.buffer
,sizeof(location
), -1, STR_TERMINATE
);
259 if (i2
->sepfile
.buffer
)
260 rpcstr_pull(sepfile
, i2
->sepfile
.buffer
,sizeof(sepfile
), -1, STR_TERMINATE
);
262 if (i2
->printprocessor
.buffer
)
263 rpcstr_pull(printprocessor
, i2
->printprocessor
.buffer
,sizeof(printprocessor
), -1, STR_TERMINATE
);
265 if (i2
->datatype
.buffer
)
266 rpcstr_pull(datatype
, i2
->datatype
.buffer
,sizeof(datatype
), -1, STR_TERMINATE
);
268 if (i2
->parameters
.buffer
)
269 rpcstr_pull(parameters
, i2
->parameters
.buffer
,sizeof(parameters
), -1, STR_TERMINATE
);
271 printf("\tservername:[%s]\n", servername
);
272 printf("\tprintername:[%s]\n", printername
);
273 printf("\tsharename:[%s]\n", sharename
);
274 printf("\tportname:[%s]\n", portname
);
275 printf("\tdrivername:[%s]\n", drivername
);
276 printf("\tcomment:[%s]\n", comment
);
277 printf("\tlocation:[%s]\n", location
);
278 printf("\tsepfile:[%s]\n", sepfile
);
279 printf("\tprintprocessor:[%s]\n", printprocessor
);
280 printf("\tdatatype:[%s]\n", datatype
);
281 printf("\tparameters:[%s]\n", parameters
);
282 printf("\tattributes:[0x%x]\n", i2
->attributes
);
283 printf("\tpriority:[0x%x]\n", i2
->priority
);
284 printf("\tdefaultpriority:[0x%x]\n", i2
->defaultpriority
);
285 printf("\tstarttime:[0x%x]\n", i2
->starttime
);
286 printf("\tuntiltime:[0x%x]\n", i2
->untiltime
);
287 printf("\tstatus:[0x%x]\n", i2
->status
);
288 printf("\tcjobs:[0x%x]\n", i2
->cjobs
);
289 printf("\taverageppm:[0x%x]\n", i2
->averageppm
);
292 display_sec_desc(i2
->secdesc
);
297 /****************************************************************************
298 printer info level 3 display function
299 ****************************************************************************/
300 static void display_print_info_3(PRINTER_INFO_3
*i3
)
302 printf("\tflags:[0x%x]\n", i3
->flags
);
304 display_sec_desc(i3
->secdesc
);
309 /* Enumerate printers */
311 static NTSTATUS
cmd_spoolss_enum_printers(struct cli_state
*cli
,
313 int argc
, char **argv
)
316 uint32 info_level
= 1;
317 PRINTER_INFO_CTR ctr
;
318 uint32 i
= 0, num_printers
, needed
;
323 printf("Usage: %s [level] [name]\n", argv
[0]);
328 info_level
= atoi(argv
[1]);
331 fstrcpy(name
, argv
[2]);
333 slprintf(name
, sizeof(name
)-1, "\\\\%s", cli
->desthost
);
337 /* Enumerate printers -- Should we enumerate types other
338 than PRINTER_ENUM_LOCAL? Maybe accept as a parameter? --jerry */
342 result
= cli_spoolss_enum_printers(
343 cli
, mem_ctx
, 0, &needed
, name
, PRINTER_ENUM_LOCAL
,
344 info_level
, &num_printers
, &ctr
);
346 if (W_ERROR_V(result
) == ERRinsufficientbuffer
)
347 result
= cli_spoolss_enum_printers(
348 cli
, mem_ctx
, needed
, NULL
, name
, PRINTER_ENUM_LOCAL
,
349 info_level
, &num_printers
, &ctr
);
351 if (W_ERROR_IS_OK(result
)) {
354 printf ("No printers returned.\n");
358 for (i
= 0; i
< num_printers
; i
++) {
361 display_print_info_0(&ctr
.printers_0
[i
]);
364 display_print_info_1(&ctr
.printers_1
[i
]);
367 display_print_info_2(&ctr
.printers_2
[i
]);
370 display_print_info_3(&ctr
.printers_3
[i
]);
373 printf("unknown info level %d\n", info_level
);
380 return W_ERROR_IS_OK(result
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
383 /****************************************************************************
384 port info level 1 display function
385 ****************************************************************************/
386 static void display_port_info_1(PORT_INFO_1
*i1
)
390 rpcstr_pull(buffer
, i1
->port_name
.buffer
, sizeof(buffer
), -1, STR_TERMINATE
);
391 printf("\tPort Name:\t[%s]\n", buffer
);
394 /****************************************************************************
395 port info level 2 display function
396 ****************************************************************************/
397 static void display_port_info_2(PORT_INFO_2
*i2
)
401 rpcstr_pull(buffer
, i2
->port_name
.buffer
, sizeof(buffer
), -1, STR_TERMINATE
);
402 printf("\tPort Name:\t[%s]\n", buffer
);
403 rpcstr_pull(buffer
, i2
->monitor_name
.buffer
, sizeof(buffer
), -1, STR_TERMINATE
);
405 printf("\tMonitor Name:\t[%s]\n", buffer
);
406 rpcstr_pull(buffer
, i2
->description
.buffer
, sizeof(buffer
), -1, STR_TERMINATE
);
408 printf("\tDescription:\t[%s]\n", buffer
);
409 printf("\tPort Type:\t[%d]\n", i2
->port_type
);
410 printf("\tReserved:\t[%d]\n", i2
->reserved
);
414 /* Enumerate ports */
416 static NTSTATUS
cmd_spoolss_enum_ports(struct cli_state
*cli
,
417 TALLOC_CTX
*mem_ctx
, int argc
,
421 uint32 needed
, info_level
= 1;
426 printf("Usage: %s [level]\n", argv
[0]);
431 info_level
= atoi(argv
[1]);
433 /* Enumerate ports */
437 result
= cli_spoolss_enum_ports(cli
, mem_ctx
, 0, &needed
, info_level
,
440 if (W_ERROR_V(result
) == ERRinsufficientbuffer
)
441 result
= cli_spoolss_enum_ports(cli
, mem_ctx
, needed
, NULL
,
442 info_level
, &returned
, &ctr
);
444 if (W_ERROR_IS_OK(result
)) {
447 for (i
= 0; i
< returned
; i
++) {
448 switch (info_level
) {
450 display_port_info_1(&ctr
.port
.info_1
[i
]);
453 display_port_info_2(&ctr
.port
.info_2
[i
]);
456 printf("unknown info level %d\n", info_level
);
462 return W_ERROR_IS_OK(result
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
465 /***********************************************************************
466 * Set printer comment - use a level2 set.
468 static NTSTATUS
cmd_spoolss_setprinter(struct cli_state
*cli
,
470 int argc
, char **argv
)
475 uint32 info_level
= 2;
476 BOOL opened_hnd
= False
;
477 PRINTER_INFO_CTR ctr
;
483 if (argc
== 1 || argc
> 3) {
484 printf("Usage: %s printername comment\n", argv
[0]);
489 /* Open a printer handle */
491 fstrcpy(comment
, argv
[2]);
494 slprintf (servername
, sizeof(servername
)-1, "\\\\%s", cli
->desthost
);
495 strupper (servername
);
496 fstrcpy (printername
, argv
[1]);
497 fstrcpy (user
, cli
->user_name
);
499 /* get a printer handle */
500 result
= cli_spoolss_open_printer_ex(cli
, mem_ctx
, printername
, "",
501 MAXIMUM_ALLOWED_ACCESS
, servername
,
504 if (!W_ERROR_IS_OK(result
))
509 /* Get printer info */
510 result
= cli_spoolss_getprinter(cli
, mem_ctx
, 0, &needed
, &pol
, info_level
, &ctr
);
512 if (W_ERROR_V(result
) == ERRinsufficientbuffer
)
513 result
= cli_spoolss_getprinter(cli
, mem_ctx
, needed
, NULL
, &pol
, info_level
, &ctr
);
515 if (!W_ERROR_IS_OK(result
))
519 /* Modify the comment. */
520 init_unistr(&ctr
.printers_2
->comment
, comment
);
521 ctr
.printers_2
->devmode
= NULL
;
522 ctr
.printers_2
->secdesc
= NULL
;
524 result
= cli_spoolss_setprinter(cli
, mem_ctx
, &pol
, info_level
, &ctr
, 0);
525 if (W_ERROR_IS_OK(result
))
526 printf("Success in setting comment.\n");
530 cli_spoolss_close_printer(cli
, mem_ctx
, &pol
);
532 return W_ERROR_IS_OK(result
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
535 /***********************************************************************
536 * Get printer information
538 static NTSTATUS
cmd_spoolss_getprinter(struct cli_state
*cli
,
540 int argc
, char **argv
)
544 uint32 info_level
= 1;
545 BOOL opened_hnd
= False
;
546 PRINTER_INFO_CTR ctr
;
552 if (argc
== 1 || argc
> 3) {
553 printf("Usage: %s <printername> [level]\n", argv
[0]);
557 /* Open a printer handle */
559 info_level
= atoi(argv
[2]);
562 slprintf (servername
, sizeof(servername
)-1, "\\\\%s", cli
->desthost
);
563 strupper (servername
);
564 slprintf (printername
, sizeof(printername
)-1, "%s\\%s", servername
, argv
[1]);
565 fstrcpy (user
, cli
->user_name
);
567 /* get a printer handle */
569 result
= cli_spoolss_open_printer_ex(cli
, mem_ctx
, printername
,
570 "", MAXIMUM_ALLOWED_ACCESS
,
571 servername
, user
, &pol
);
573 if (!W_ERROR_IS_OK(result
))
578 /* Get printer info */
580 result
= cli_spoolss_getprinter(cli
, mem_ctx
, 0, &needed
,
581 &pol
, info_level
, &ctr
);
583 if (W_ERROR_V(result
) == ERRinsufficientbuffer
)
584 result
= cli_spoolss_getprinter(
585 cli
, mem_ctx
, needed
, NULL
, &pol
, info_level
, &ctr
);
587 if (!W_ERROR_IS_OK(result
))
590 /* Display printer info */
592 switch (info_level
) {
594 display_print_info_0(ctr
.printers_0
);
597 display_print_info_1(ctr
.printers_1
);
600 display_print_info_2(ctr
.printers_2
);
603 display_print_info_3(ctr
.printers_3
);
606 printf("unknown info level %d\n", info_level
);
612 cli_spoolss_close_printer(cli
, mem_ctx
, &pol
);
614 return W_ERROR_IS_OK(result
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
617 static void display_reg_value(REGISTRY_VALUE value
)
623 printf("%s: REG_DWORD: 0x%08x\n", value
.valuename
,
624 *((uint32
*) value
.data_p
));
627 rpcstr_pull(text
, value
.data_p
, sizeof(text
), value
.size
,
629 printf("%s: REG_SZ: %s\n", value
.valuename
, text
);
632 printf("%s: REG_BINARY: unknown length value not displayed\n",
636 uint16
*curstr
= (uint16
*) value
.data_p
;
637 uint8
*start
= value
.data_p
;
638 printf("%s: REG_MULTI_SZ:\n", value
.valuename
);
639 while ((*curstr
!= 0) &&
640 ((uint8
*) curstr
< start
+ value
.size
)) {
641 rpcstr_pull(text
, curstr
, sizeof(text
), -1,
643 printf(" %s\n", text
);
644 curstr
+= strlen(text
) + 1;
649 printf("%s: unknown type %d\n", value
.valuename
, value
.type
);
654 /***********************************************************************
657 static NTSTATUS
cmd_spoolss_getprinterdata(struct cli_state
*cli
,
659 int argc
, char **argv
)
663 BOOL opened_hnd
= False
;
669 REGISTRY_VALUE value
;
672 printf("Usage: %s <printername> <valuename>\n", argv
[0]);
673 printf("<printername> of . queries print server\n");
678 /* Open a printer handle */
680 slprintf (servername
, sizeof(servername
)-1, "\\\\%s", cli
->desthost
);
681 strupper (servername
);
682 if (strncmp(argv
[1], ".", sizeof(".")) == 0)
683 fstrcpy(printername
, servername
);
685 slprintf (printername
, sizeof(servername
)-1, "%s\\%s",
686 servername
, argv
[1]);
687 fstrcpy (user
, cli
->user_name
);
689 /* get a printer handle */
691 result
= cli_spoolss_open_printer_ex(cli
, mem_ctx
, printername
,
692 "", MAXIMUM_ALLOWED_ACCESS
,
693 servername
, user
, &pol
);
695 if (!W_ERROR_IS_OK(result
))
700 /* Get printer info */
702 result
= cli_spoolss_getprinterdata(cli
, mem_ctx
, 0, &needed
,
703 &pol
, valuename
, &value
);
705 if (W_ERROR_V(result
) == ERRmoredata
)
706 result
= cli_spoolss_getprinterdata(
707 cli
, mem_ctx
, needed
, NULL
, &pol
, valuename
, &value
);
709 if (!W_ERROR_IS_OK(result
))
712 /* Display printer data */
714 fstrcpy(value
.valuename
, valuename
);
715 display_reg_value(value
);
720 cli_spoolss_close_printer(cli
, mem_ctx
, &pol
);
722 return W_ERROR_IS_OK(result
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
725 /***********************************************************************
728 static NTSTATUS
cmd_spoolss_getprinterdataex(struct cli_state
*cli
,
730 int argc
, char **argv
)
734 BOOL opened_hnd
= False
;
739 char *valuename
, *keyname
;
740 REGISTRY_VALUE value
;
743 printf("Usage: %s <printername> <keyname> <valuename>\n",
745 printf("<printername> of . queries print server\n");
751 /* Open a printer handle */
753 slprintf (servername
, sizeof(servername
)-1, "\\\\%s", cli
->desthost
);
754 strupper (servername
);
755 if (strncmp(argv
[1], ".", sizeof(".")) == 0)
756 fstrcpy(printername
, servername
);
758 slprintf (printername
, sizeof(printername
)-1, "%s\\%s",
759 servername
, argv
[1]);
760 fstrcpy (user
, cli
->user_name
);
762 /* get a printer handle */
764 result
= cli_spoolss_open_printer_ex(cli
, mem_ctx
, printername
,
765 "", MAXIMUM_ALLOWED_ACCESS
,
766 servername
, user
, &pol
);
768 if (!W_ERROR_IS_OK(result
))
773 /* Get printer info */
775 result
= cli_spoolss_getprinterdataex(cli
, mem_ctx
, 0, &needed
,
776 &pol
, keyname
, valuename
,
779 if (W_ERROR_V(result
) == ERRmoredata
)
780 result
= cli_spoolss_getprinterdataex(cli
, mem_ctx
, needed
,
784 if (!W_ERROR_IS_OK(result
))
787 /* Display printer data */
789 fstrcpy(value
.valuename
, valuename
);
790 display_reg_value(value
);
795 cli_spoolss_close_printer(cli
, mem_ctx
, &pol
);
797 return W_ERROR_IS_OK(result
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
800 /****************************************************************************
801 printer info level 0 display function
802 ****************************************************************************/
803 static void display_print_driver_1(DRIVER_INFO_1
*i1
)
809 rpcstr_pull(name
, i1
->name
.buffer
, sizeof(name
), -1, STR_TERMINATE
);
811 printf ("Printer Driver Info 1:\n");
812 printf ("\tDriver Name: [%s]\n\n", name
);
817 /****************************************************************************
818 printer info level 1 display function
819 ****************************************************************************/
820 static void display_print_driver_2(DRIVER_INFO_2
*i1
)
823 fstring architecture
;
830 rpcstr_pull(name
, i1
->name
.buffer
, sizeof(name
), -1, STR_TERMINATE
);
831 rpcstr_pull(architecture
, i1
->architecture
.buffer
, sizeof(architecture
), -1, STR_TERMINATE
);
832 rpcstr_pull(driverpath
, i1
->driverpath
.buffer
, sizeof(driverpath
), -1, STR_TERMINATE
);
833 rpcstr_pull(datafile
, i1
->datafile
.buffer
, sizeof(datafile
), -1, STR_TERMINATE
);
834 rpcstr_pull(configfile
, i1
->configfile
.buffer
, sizeof(configfile
), -1, STR_TERMINATE
);
836 printf ("Printer Driver Info 2:\n");
837 printf ("\tVersion: [%x]\n", i1
->version
);
838 printf ("\tDriver Name: [%s]\n", name
);
839 printf ("\tArchitecture: [%s]\n", architecture
);
840 printf ("\tDriver Path: [%s]\n", driverpath
);
841 printf ("\tDatafile: [%s]\n", datafile
);
842 printf ("\tConfigfile: [%s]\n\n", configfile
);
847 /****************************************************************************
848 printer info level 2 display function
849 ****************************************************************************/
850 static void display_print_driver_3(DRIVER_INFO_3
*i1
)
853 fstring architecture
;
858 fstring dependentfiles
;
860 fstring defaultdatatype
;
868 rpcstr_pull(name
, i1
->name
.buffer
, sizeof(name
), -1, STR_TERMINATE
);
869 rpcstr_pull(architecture
, i1
->architecture
.buffer
, sizeof(architecture
), -1, STR_TERMINATE
);
870 rpcstr_pull(driverpath
, i1
->driverpath
.buffer
, sizeof(driverpath
), -1, STR_TERMINATE
);
871 rpcstr_pull(datafile
, i1
->datafile
.buffer
, sizeof(datafile
), -1, STR_TERMINATE
);
872 rpcstr_pull(configfile
, i1
->configfile
.buffer
, sizeof(configfile
), -1, STR_TERMINATE
);
873 rpcstr_pull(helpfile
, i1
->helpfile
.buffer
, sizeof(helpfile
), -1, STR_TERMINATE
);
874 rpcstr_pull(monitorname
, i1
->monitorname
.buffer
, sizeof(monitorname
), -1, STR_TERMINATE
);
875 rpcstr_pull(defaultdatatype
, i1
->defaultdatatype
.buffer
, sizeof(defaultdatatype
), -1, STR_TERMINATE
);
877 printf ("Printer Driver Info 3:\n");
878 printf ("\tVersion: [%x]\n", i1
->version
);
879 printf ("\tDriver Name: [%s]\n",name
);
880 printf ("\tArchitecture: [%s]\n", architecture
);
881 printf ("\tDriver Path: [%s]\n", driverpath
);
882 printf ("\tDatafile: [%s]\n", datafile
);
883 printf ("\tConfigfile: [%s]\n", configfile
);
884 printf ("\tHelpfile: [%s]\n\n", helpfile
);
888 rpcstr_pull(dependentfiles
, i1
->dependentfiles
+length
, sizeof(dependentfiles
), -1, STR_TERMINATE
);
890 length
+=strlen(dependentfiles
)+1;
892 if (strlen(dependentfiles
) > 0)
894 printf ("\tDependentfiles: [%s]\n", dependentfiles
);
904 printf ("\tMonitorname: [%s]\n", monitorname
);
905 printf ("\tDefaultdatatype: [%s]\n\n", defaultdatatype
);
910 /***********************************************************************
911 * Get printer information
913 static NTSTATUS
cmd_spoolss_getdriver(struct cli_state
*cli
,
915 int argc
, char **argv
)
920 uint32 info_level
= 3;
921 BOOL opened_hnd
= False
;
922 PRINTER_DRIVER_CTR ctr
;
928 if ((argc
== 1) || (argc
> 3))
930 printf("Usage: %s <printername> [level]\n", argv
[0]);
934 /* get the arguments need to open the printer handle */
935 slprintf (servername
, sizeof(servername
)-1, "\\\\%s", cli
->desthost
);
936 strupper (servername
);
937 fstrcpy (user
, cli
->user_name
);
938 fstrcpy (printername
, argv
[1]);
940 info_level
= atoi(argv
[2]);
942 /* Open a printer handle */
944 werror
= cli_spoolss_open_printer_ex(cli
, mem_ctx
, printername
, "",
946 servername
, user
, &pol
);
948 result
= W_ERROR_IS_OK(werror
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
950 if (!NT_STATUS_IS_OK(result
)) {
951 printf("Error opening printer handle for %s!\n", printername
);
957 /* loop through and print driver info level for each architecture */
959 for (i
=0; archi_table
[i
].long_archi
!=NULL
; i
++) {
962 werror
= cli_spoolss_getprinterdriver(
963 cli
, mem_ctx
, 0, &needed
, &pol
, info_level
,
964 archi_table
[i
].long_archi
, &ctr
);
966 if (W_ERROR_V(werror
) == ERRinsufficientbuffer
)
967 werror
= cli_spoolss_getprinterdriver(
968 cli
, mem_ctx
, needed
, NULL
, &pol
, info_level
,
969 archi_table
[i
].long_archi
, &ctr
);
971 if (!W_ERROR_IS_OK(werror
))
974 printf ("\n[%s]\n", archi_table
[i
].long_archi
);
976 switch (info_level
) {
978 display_print_driver_1 (ctr
.info1
);
981 display_print_driver_2 (ctr
.info2
);
984 display_print_driver_3 (ctr
.info3
);
987 printf("unknown info level %d\n", info_level
);
995 cli_spoolss_close_printer (cli
, mem_ctx
, &pol
);
997 return W_ERROR_IS_OK(result
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
1000 /***********************************************************************
1001 * Get printer information
1003 static NTSTATUS
cmd_spoolss_enum_drivers(struct cli_state
*cli
,
1004 TALLOC_CTX
*mem_ctx
,
1005 int argc
, char **argv
)
1008 uint32 info_level
= 1;
1009 PRINTER_DRIVER_CTR ctr
;
1015 printf("Usage: enumdrivers [level]\n");
1016 return NT_STATUS_OK
;
1020 info_level
= atoi(argv
[1]);
1023 /* loop through and print driver info level for each architecture */
1024 for (i
=0; archi_table
[i
].long_archi
!=NULL
; i
++)
1028 werror
= cli_spoolss_enumprinterdrivers(
1029 cli
, mem_ctx
, 0, &needed
, info_level
,
1030 archi_table
[i
].long_archi
, &returned
, &ctr
);
1032 if (W_ERROR_V(werror
) == ERRinsufficientbuffer
)
1033 werror
= cli_spoolss_enumprinterdrivers(
1034 cli
, mem_ctx
, needed
, NULL
, info_level
,
1035 archi_table
[i
].long_archi
, &returned
, &ctr
);
1040 if (!W_ERROR_IS_OK(werror
)) {
1041 printf ("Error getting driver for environment [%s] - %d\n",
1042 archi_table
[i
].long_archi
, W_ERROR_V(werror
));
1046 printf ("\n[%s]\n", archi_table
[i
].long_archi
);
1051 for (j
=0; j
< returned
; j
++) {
1052 display_print_driver_1 (&(ctr
.info1
[j
]));
1056 for (j
=0; j
< returned
; j
++) {
1057 display_print_driver_2 (&(ctr
.info2
[j
]));
1061 for (j
=0; j
< returned
; j
++) {
1062 display_print_driver_3 (&(ctr
.info3
[j
]));
1066 printf("unknown info level %d\n", info_level
);
1071 return W_ERROR_IS_OK(werror
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
1074 /****************************************************************************
1075 printer info level 1 display function
1076 ****************************************************************************/
1077 static void display_printdriverdir_1(DRIVER_DIRECTORY_1
*i1
)
1083 rpcstr_pull(name
, i1
->name
.buffer
, sizeof(name
), -1, STR_TERMINATE
);
1085 printf ("\tDirectory Name:[%s]\n", name
);
1088 /***********************************************************************
1089 * Get printer driver directory information
1091 static NTSTATUS
cmd_spoolss_getdriverdir(struct cli_state
*cli
,
1092 TALLOC_CTX
*mem_ctx
,
1093 int argc
, char **argv
)
1097 DRIVER_DIRECTORY_CTR ctr
;
1101 printf("Usage: %s [environment]\n", argv
[0]);
1102 return NT_STATUS_OK
;
1105 /* Get the arguments need to open the printer handle */
1108 fstrcpy (env
, argv
[1]);
1110 fstrcpy (env
, "Windows NT x86");
1112 /* Get the directory. Only use Info level 1 */
1114 result
= cli_spoolss_getprinterdriverdir(
1115 cli
, mem_ctx
, 0, &needed
, 1, env
, &ctr
);
1117 if (W_ERROR_V(result
) == ERRinsufficientbuffer
)
1118 result
= cli_spoolss_getprinterdriverdir(
1119 cli
, mem_ctx
, needed
, NULL
, 1, env
, &ctr
);
1121 if (W_ERROR_IS_OK(result
))
1122 display_printdriverdir_1(ctr
.info1
);
1124 return W_ERROR_IS_OK(result
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
1127 /*******************************************************************************
1128 set the version and environment fields of a DRIVER_INFO_3 struct
1129 ******************************************************************************/
1130 void set_drv_info_3_env (DRIVER_INFO_3
*info
, const char *arch
)
1135 for (i
=0; archi_table
[i
].long_archi
!= NULL
; i
++)
1137 if (strcmp(arch
, archi_table
[i
].short_archi
) == 0)
1139 info
->version
= archi_table
[i
].version
;
1140 init_unistr (&info
->architecture
, archi_table
[i
].long_archi
);
1145 if (archi_table
[i
].long_archi
== NULL
)
1147 DEBUG(0, ("set_drv_info_3_env: Unknown arch [%s]\n", arch
));
1154 /**************************************************************************
1155 wrapper for strtok to get the next parameter from a delimited list.
1156 Needed to handle the empty parameter string denoted by "NULL"
1157 *************************************************************************/
1158 static char* get_driver_3_param (char* str
, const char* delim
, UNISTR
* dest
)
1162 /* get the next token */
1163 ptr
= strtok(str
, delim
);
1165 /* a string of 'NULL' is used to represent an empty
1166 parameter because two consecutive delimiters
1167 will not return an empty string. See man strtok(3)
1169 if (StrCaseCmp(ptr
, "NULL") == 0)
1173 init_unistr(dest
, ptr
);
1178 /********************************************************************************
1179 fill in the members of a DRIVER_INFO_3 struct using a character
1180 string in the form of
1181 <Long Printer Name>:<Driver File Name>:<Data File Name>:\
1182 <Config File Name>:<Help File Name>:<Language Monitor Name>:\
1183 <Default Data Type>:<Comma Separated list of Files>
1184 *******************************************************************************/
1185 static BOOL
init_drv_info_3_members (
1186 TALLOC_CTX
*mem_ctx
,
1187 DRIVER_INFO_3
*info
,
1194 /* fill in the UNISTR fields */
1195 str
= get_driver_3_param (args
, ":", &info
->name
);
1196 str
= get_driver_3_param (NULL
, ":", &info
->driverpath
);
1197 str
= get_driver_3_param (NULL
, ":", &info
->datafile
);
1198 str
= get_driver_3_param (NULL
, ":", &info
->configfile
);
1199 str
= get_driver_3_param (NULL
, ":", &info
->helpfile
);
1200 str
= get_driver_3_param (NULL
, ":", &info
->monitorname
);
1201 str
= get_driver_3_param (NULL
, ":", &info
->defaultdatatype
);
1203 /* <Comma Separated List of Dependent Files> */
1204 str2
= get_driver_3_param (NULL
, ":", NULL
); /* save the beginning of the string */
1207 /* begin to strip out each filename */
1208 str
= strtok(str
, ",");
1212 /* keep a cumlative count of the str lengths */
1213 len
+= strlen(str
)+1;
1214 str
= strtok(NULL
, ",");
1217 /* allocate the space; add one extra slot for a terminating NULL.
1218 Each filename is NULL terminated and the end contains a double
1220 if ((info
->dependentfiles
=(uint16
*)talloc(mem_ctx
, (len
+1)*sizeof(uint16
))) == NULL
)
1222 DEBUG(0,("init_drv_info_3_members: Unable to malloc memory for dependenfiles\n"));
1225 for (i
=0; i
<len
; i
++)
1227 info
->dependentfiles
[i
] = SSVAL(&info
->dependentfiles
[i
], 0, str2
[i
]);
1229 info
->dependentfiles
[len
] = '\0';
1235 static NTSTATUS
cmd_spoolss_addprinterdriver(struct cli_state
*cli
,
1236 TALLOC_CTX
*mem_ctx
,
1237 int argc
, char **argv
)
1241 PRINTER_DRIVER_CTR ctr
;
1242 DRIVER_INFO_3 info3
;
1244 fstring driver_name
;
1246 /* parse the command arguements */
1249 printf ("Usage: %s <Environment>\\\n", argv
[0]);
1250 printf ("\t<Long Printer Name>:<Driver File Name>:<Data File Name>:\\\n");
1251 printf ("\t<Config File Name>:<Help File Name>:<Language Monitor Name>:\\\n");
1252 printf ("\t<Default Data Type>:<Comma Separated list of Files>\n");
1254 return NT_STATUS_OK
;
1257 /* Fill in the DRIVER_INFO_3 struct */
1259 if (!get_short_archi(arch
, argv
[1]))
1261 printf ("Error Unknown architechture [%s]\n", argv
[1]);
1262 return NT_STATUS_INVALID_PARAMETER
;
1265 set_drv_info_3_env(&info3
, arch
);
1267 if (!init_drv_info_3_members(mem_ctx
, &info3
, argv
[2]))
1269 printf ("Error Invalid parameter list - %s.\n", argv
[2]);
1270 return NT_STATUS_INVALID_PARAMETER
;
1275 result
= cli_spoolss_addprinterdriver (cli
, mem_ctx
, level
, &ctr
);
1277 if (W_ERROR_IS_OK(result
)) {
1278 rpcstr_pull(driver_name
, info3
.name
.buffer
,
1279 sizeof(driver_name
), -1, STR_TERMINATE
);
1280 printf ("Printer Driver %s successfully installed.\n",
1284 return W_ERROR_IS_OK(result
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
1288 static NTSTATUS
cmd_spoolss_addprinterex(struct cli_state
*cli
,
1289 TALLOC_CTX
*mem_ctx
,
1290 int argc
, char **argv
)
1294 PRINTER_INFO_CTR ctr
;
1295 PRINTER_INFO_2 info2
;
1298 /* parse the command arguements */
1301 printf ("Usage: %s <name> <shared name> <driver> <port>\n", argv
[0]);
1302 return NT_STATUS_OK
;
1305 slprintf (servername
, sizeof(servername
)-1, "\\\\%s", cli
->desthost
);
1306 strupper (servername
);
1308 /* Fill in the DRIVER_INFO_3 struct */
1311 init_unistr( &info2
.servername
, servername
);
1313 init_unistr( &info2
.printername
, argv
[1]);
1314 init_unistr( &info2
.sharename
, argv
[2]);
1315 init_unistr( &info2
.drivername
, argv
[3]);
1316 init_unistr( &info2
.portname
, argv
[4]);
1317 init_unistr( &info2
.comment
, "Created by rpcclient");
1318 init_unistr( &info2
.printprocessor
, "winprint");
1319 init_unistr( &info2
.datatype
, "RAW");
1320 info2
.devmode
= NULL
;
1321 info2
.secdesc
= NULL
;
1322 info2
.attributes
= PRINTER_ATTRIBUTE_SHARED
;
1324 info2
.defaultpriority
= 0;
1325 info2
.starttime
= 0;
1326 info2
.untiltime
= 0;
1328 /* These three fields must not be used by AddPrinter()
1329 as defined in the MS Platform SDK documentation..
1333 info2.averageppm = 0;
1336 ctr
.printers_2
= &info2
;
1337 result
= cli_spoolss_addprinterex (cli
, mem_ctx
, level
, &ctr
);
1339 if (W_ERROR_IS_OK(result
))
1340 printf ("Printer %s successfully installed.\n", argv
[1]);
1342 return W_ERROR_IS_OK(result
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
1345 static NTSTATUS
cmd_spoolss_setdriver(struct cli_state
*cli
,
1346 TALLOC_CTX
*mem_ctx
,
1347 int argc
, char **argv
)
1352 BOOL opened_hnd
= False
;
1353 PRINTER_INFO_CTR ctr
;
1354 PRINTER_INFO_2 info2
;
1360 /* parse the command arguements */
1363 printf ("Usage: %s <printer> <driver>\n", argv
[0]);
1364 return NT_STATUS_OK
;
1367 slprintf (servername
, sizeof(servername
)-1, "\\\\%s", cli
->desthost
);
1368 strupper (servername
);
1369 slprintf (printername
, sizeof(printername
)-1, "%s\\%s", servername
, argv
[1]);
1370 fstrcpy (user
, cli
->user_name
);
1372 /* Get a printer handle */
1374 result
= cli_spoolss_open_printer_ex(cli
, mem_ctx
, printername
, "",
1375 MAXIMUM_ALLOWED_ACCESS
,
1376 servername
, user
, &pol
);
1378 if (!W_ERROR_IS_OK(result
))
1383 /* Get printer info */
1385 ZERO_STRUCT (info2
);
1386 ctr
.printers_2
= &info2
;
1388 result
= cli_spoolss_getprinter(cli
, mem_ctx
, 0, &needed
,
1391 if (W_ERROR_V(result
) == ERRinsufficientbuffer
)
1392 result
= cli_spoolss_getprinter(
1393 cli
, mem_ctx
, needed
, NULL
, &pol
, level
, &ctr
);
1395 if (!W_ERROR_IS_OK(result
)) {
1396 printf ("Unable to retrieve printer information!\n");
1400 /* Set the printer driver */
1402 init_unistr(&ctr
.printers_2
->drivername
, argv
[2]);
1404 result
= cli_spoolss_setprinter(cli
, mem_ctx
, &pol
, level
, &ctr
, 0);
1406 if (!W_ERROR_IS_OK(result
)) {
1407 printf("SetPrinter call failed!\n");
1411 printf("Succesfully set %s to driver %s.\n", argv
[1], argv
[2]);
1417 cli_spoolss_close_printer(cli
, mem_ctx
, &pol
);
1419 return W_ERROR_IS_OK(result
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
1423 static NTSTATUS
cmd_spoolss_deletedriver(struct cli_state
*cli
,
1424 TALLOC_CTX
*mem_ctx
,
1425 int argc
, char **argv
)
1431 /* parse the command arguements */
1434 printf ("Usage: %s <driver>\n", argv
[0]);
1435 return NT_STATUS_OK
;
1438 slprintf (servername
, sizeof(servername
)-1, "\\\\%s", cli
->desthost
);
1439 strupper (servername
);
1441 /* delete the driver for all architectures */
1442 for (i
=0; archi_table
[i
].long_archi
; i
++)
1444 /* make the call to remove the driver */
1445 result
= cli_spoolss_deleteprinterdriver(
1446 cli
, mem_ctx
, archi_table
[i
].long_archi
, argv
[1]);
1448 if ( !W_ERROR_IS_OK(result
) ) {
1449 if ( !W_ERROR_EQUAL(result
, WERR_UNKNOWN_PRINTER_DRIVER
) ) {
1450 printf ("Failed to remove driver %s for arch [%s] - error 0x%x!\n",
1451 argv
[1], archi_table
[i
].long_archi
,
1457 printf ("Driver %s removed for arch [%s].\n", argv
[1],
1458 archi_table
[i
].long_archi
);
1462 return W_ERROR_IS_OK(result
) || W_ERROR_EQUAL(result
, WERR_UNKNOWN_PRINTER_DRIVER
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
1465 static NTSTATUS
cmd_spoolss_getprintprocdir(struct cli_state
*cli
,
1466 TALLOC_CTX
*mem_ctx
,
1467 int argc
, char **argv
)
1470 char *servername
= NULL
, *environment
= NULL
;
1474 /* parse the command arguements */
1476 printf ("Usage: %s [environment]\n", argv
[0]);
1477 return NT_STATUS_OK
;
1480 if (asprintf(&servername
, "\\\\%s", cli
->desthost
) < 0)
1481 return NT_STATUS_NO_MEMORY
;
1482 strupper(servername
);
1484 if (asprintf(&environment
, "%s", (argc
== 2) ? argv
[1] :
1485 PRINTER_DRIVER_ARCHITECTURE
) < 0) {
1486 SAFE_FREE(servername
);
1487 return NT_STATUS_NO_MEMORY
;
1490 result
= cli_spoolss_getprintprocessordirectory(
1491 cli
, mem_ctx
, 0, &needed
, servername
, environment
, procdir
);
1493 if (W_ERROR_V(result
) == ERRinsufficientbuffer
)
1494 result
= cli_spoolss_getprintprocessordirectory(
1495 cli
, mem_ctx
, needed
, NULL
, servername
, environment
,
1498 if (W_ERROR_IS_OK(result
))
1499 printf("%s\n", procdir
);
1501 SAFE_FREE(servername
);
1502 SAFE_FREE(environment
);
1504 return W_ERROR_IS_OK(result
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
1509 static NTSTATUS
cmd_spoolss_addform(struct cli_state
*cli
, TALLOC_CTX
*mem_ctx
,
1510 int argc
, char **argv
)
1514 char *servername
= NULL
, *printername
= NULL
;
1516 BOOL got_handle
= False
;
1518 /* Parse the command arguements */
1521 printf ("Usage: %s <printer> <formname>\n", argv
[0]);
1522 return NT_STATUS_OK
;
1525 /* Get a printer handle */
1527 asprintf(&servername
, "\\\\%s", cli
->desthost
);
1528 strupper(servername
);
1529 asprintf(&printername
, "%s\\%s", servername
, argv
[1]);
1531 werror
= cli_spoolss_open_printer_ex(cli
, mem_ctx
, printername
, "",
1532 MAXIMUM_ALLOWED_ACCESS
,
1533 servername
, cli
->user_name
, &handle
);
1535 if (!W_ERROR_IS_OK(werror
))
1540 /* Dummy up some values for the form data */
1542 form
.flags
= FORM_USER
;
1543 form
.size_x
= form
.size_y
= 100;
1549 init_unistr2(&form
.name
, argv
[2], strlen(argv
[2]) + 1);
1554 werror
= cli_spoolss_addform(cli
, mem_ctx
, &handle
, 1, &form
);
1558 cli_spoolss_close_printer(cli
, mem_ctx
, &handle
);
1560 SAFE_FREE(servername
);
1561 SAFE_FREE(printername
);
1563 return W_ERROR_IS_OK(werror
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
1568 static NTSTATUS
cmd_spoolss_setform(struct cli_state
*cli
, TALLOC_CTX
*mem_ctx
,
1569 int argc
, char **argv
)
1573 char *servername
= NULL
, *printername
= NULL
;
1575 BOOL got_handle
= False
;
1577 /* Parse the command arguements */
1580 printf ("Usage: %s <printer> <formname>\n", argv
[0]);
1581 return NT_STATUS_OK
;
1584 /* Get a printer handle */
1586 asprintf(&servername
, "\\\\%s", cli
->desthost
);
1587 strupper(servername
);
1588 asprintf(&printername
, "%s\\%s", servername
, argv
[1]);
1590 werror
= cli_spoolss_open_printer_ex(
1591 cli
, mem_ctx
, printername
, "", MAXIMUM_ALLOWED_ACCESS
,
1592 servername
, cli
->user_name
, &handle
);
1594 if (!W_ERROR_IS_OK(werror
))
1599 /* Dummy up some values for the form data */
1601 form
.flags
= FORM_PRINTER
;
1602 form
.size_x
= form
.size_y
= 100;
1608 init_unistr2(&form
.name
, argv
[2], strlen(argv
[2]) + 1);
1612 werror
= cli_spoolss_setform(cli
, mem_ctx
, &handle
, 1, argv
[2], &form
);
1616 cli_spoolss_close_printer(cli
, mem_ctx
, &handle
);
1618 SAFE_FREE(servername
);
1619 SAFE_FREE(printername
);
1621 return W_ERROR_IS_OK(werror
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
1626 static NTSTATUS
cmd_spoolss_getform(struct cli_state
*cli
, TALLOC_CTX
*mem_ctx
,
1627 int argc
, char **argv
)
1631 char *servername
= NULL
, *printername
= NULL
;
1633 BOOL got_handle
= False
;
1636 /* Parse the command arguements */
1639 printf ("Usage: %s <printer> <formname>\n", argv
[0]);
1640 return NT_STATUS_OK
;
1643 /* Get a printer handle */
1645 asprintf(&servername
, "\\\\%s", cli
->desthost
);
1646 strupper(servername
);
1647 asprintf(&printername
, "%s\\%s", servername
, argv
[1]);
1649 werror
= cli_spoolss_open_printer_ex(
1650 cli
, mem_ctx
, printername
, "", MAXIMUM_ALLOWED_ACCESS
,
1651 servername
, cli
->user_name
, &handle
);
1653 if (!W_ERROR_IS_OK(werror
))
1660 werror
= cli_spoolss_getform(cli
, mem_ctx
, 0, &needed
,
1661 &handle
, argv
[2], 1, &form
);
1663 if (W_ERROR_V(werror
) == ERRinsufficientbuffer
)
1664 werror
= cli_spoolss_getform(cli
, mem_ctx
, needed
, NULL
,
1665 &handle
, argv
[2], 1, &form
);
1667 if (!W_ERROR_IS_OK(werror
))
1670 printf("width: %d\n", form
.width
);
1671 printf("length: %d\n", form
.length
);
1672 printf("left: %d\n", form
.left
);
1673 printf("top: %d\n", form
.top
);
1674 printf("right: %d\n", form
.right
);
1675 printf("bottom: %d\n", form
.bottom
);
1679 cli_spoolss_close_printer(cli
, mem_ctx
, &handle
);
1681 SAFE_FREE(servername
);
1682 SAFE_FREE(printername
);
1684 return W_ERROR_IS_OK(werror
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
1689 static NTSTATUS
cmd_spoolss_deleteform(struct cli_state
*cli
,
1690 TALLOC_CTX
*mem_ctx
, int argc
,
1695 char *servername
= NULL
, *printername
= NULL
;
1696 BOOL got_handle
= False
;
1698 /* Parse the command arguements */
1701 printf ("Usage: %s <printer> <formname>\n", argv
[0]);
1702 return NT_STATUS_OK
;
1705 /* Get a printer handle */
1707 asprintf(&servername
, "\\\\%s", cli
->desthost
);
1708 strupper(servername
);
1709 asprintf(&printername
, "%s\\%s", servername
, argv
[1]);
1711 werror
= cli_spoolss_open_printer_ex(
1712 cli
, mem_ctx
, printername
, "", MAXIMUM_ALLOWED_ACCESS
,
1713 servername
, cli
->user_name
, &handle
);
1715 if (!W_ERROR_IS_OK(werror
))
1720 /* Delete the form */
1722 werror
= cli_spoolss_deleteform(cli
, mem_ctx
, &handle
, argv
[2]);
1726 cli_spoolss_close_printer(cli
, mem_ctx
, &handle
);
1728 SAFE_FREE(servername
);
1729 SAFE_FREE(printername
);
1731 return W_ERROR_IS_OK(werror
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
1734 /* Enumerate forms */
1736 static NTSTATUS
cmd_spoolss_enum_forms(struct cli_state
*cli
,
1737 TALLOC_CTX
*mem_ctx
, int argc
,
1742 char *servername
= NULL
, *printername
= NULL
;
1743 BOOL got_handle
= False
;
1744 uint32 needed
, num_forms
, level
= 1, i
;
1747 /* Parse the command arguements */
1750 printf ("Usage: %s <printer>\n", argv
[0]);
1751 return NT_STATUS_OK
;
1754 /* Get a printer handle */
1756 asprintf(&servername
, "\\\\%s", cli
->desthost
);
1757 strupper(servername
);
1758 asprintf(&printername
, "%s\\%s", servername
, argv
[1]);
1760 werror
= cli_spoolss_open_printer_ex(
1761 cli
, mem_ctx
, printername
, "", MAXIMUM_ALLOWED_ACCESS
,
1762 servername
, cli
->user_name
, &handle
);
1764 if (!W_ERROR_IS_OK(werror
))
1769 /* Enumerate forms */
1771 werror
= cli_spoolss_enumforms(
1772 cli
, mem_ctx
, 0, &needed
, &handle
, level
, &num_forms
, &forms
);
1774 if (W_ERROR_V(werror
) == ERRinsufficientbuffer
)
1775 werror
= cli_spoolss_enumforms(
1776 cli
, mem_ctx
, needed
, NULL
, &handle
, level
,
1777 &num_forms
, &forms
);
1779 if (!W_ERROR_IS_OK(werror
))
1782 /* Display output */
1784 for (i
= 0; i
< num_forms
; i
++) {
1787 if (forms
[i
].name
.buffer
)
1788 rpcstr_pull(form_name
, forms
[i
].name
.buffer
,
1789 sizeof(form_name
), -1, STR_TERMINATE
);
1791 printf("%s\n", form_name
);
1796 cli_spoolss_close_printer(cli
, mem_ctx
, &handle
);
1798 SAFE_FREE(servername
);
1799 SAFE_FREE(printername
);
1801 return W_ERROR_IS_OK(werror
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
1804 static NTSTATUS
cmd_spoolss_setprinterdata(struct cli_state
*cli
,
1805 TALLOC_CTX
*mem_ctx
,
1806 int argc
, char **argv
)
1810 fstring servername
, printername
, user
;
1812 BOOL opened_hnd
= False
;
1813 PRINTER_INFO_CTR ctr
;
1814 PRINTER_INFO_0 info
;
1815 REGISTRY_VALUE value
;
1817 /* parse the command arguements */
1819 printf ("Usage: %s <printer> <value> <data>\n", argv
[0]);
1820 return NT_STATUS_OK
;
1823 slprintf (servername
, sizeof(servername
)-1, "\\\\%s", cli
->desthost
);
1824 strupper (servername
);
1825 slprintf (printername
, sizeof(servername
)-1, "%s\\%s", servername
, argv
[1]);
1826 fstrcpy (user
, cli
->user_name
);
1828 /* get a printer handle */
1829 result
= cli_spoolss_open_printer_ex(cli
, mem_ctx
, printername
, "",
1830 MAXIMUM_ALLOWED_ACCESS
, servername
,
1832 if (!W_ERROR_IS_OK(result
))
1837 ctr
.printers_0
= &info
;
1839 result
= cli_spoolss_getprinter(cli
, mem_ctx
, 0, &needed
,
1842 if (W_ERROR_V(result
) == ERRinsufficientbuffer
)
1843 result
= cli_spoolss_getprinter(cli
, mem_ctx
, needed
, NULL
, &pol
, 0, &ctr
);
1845 if (!W_ERROR_IS_OK(result
))
1848 printf("%s\n", timestring(True
));
1849 printf("\tchange_id (before set)\t:[0x%x]\n", info
.change_id
);
1851 /* Set the printer data */
1853 fstrcpy(value
.valuename
, argv
[2]);
1854 value
.type
= REG_SZ
;
1855 value
.size
= strlen(argv
[3]) + 1;
1856 value
.data_p
= talloc_memdup(mem_ctx
, argv
[3], value
.size
);
1858 result
= cli_spoolss_setprinterdata(cli
, mem_ctx
, &pol
, &value
);
1860 if (!W_ERROR_IS_OK(result
)) {
1861 printf ("Unable to set [%s=%s]!\n", argv
[2], argv
[3]);
1864 printf("\tSetPrinterData succeeded [%s: %s]\n", argv
[2], argv
[3]);
1866 result
= cli_spoolss_getprinter(cli
, mem_ctx
, 0, &needed
, &pol
, 0, &ctr
);
1868 if (W_ERROR_V(result
) == ERRinsufficientbuffer
)
1869 result
= cli_spoolss_getprinter(cli
, mem_ctx
, needed
, NULL
, &pol
, 0, &ctr
);
1871 if (!W_ERROR_IS_OK(result
))
1874 printf("%s\n", timestring(True
));
1875 printf("\tchange_id (after set)\t:[0x%x]\n", info
.change_id
);
1880 cli_spoolss_close_printer(cli
, mem_ctx
, &pol
);
1882 return W_ERROR_IS_OK(result
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
1885 static void display_job_info_1(JOB_INFO_1
*job
)
1887 fstring username
= "", document
= "", text_status
= "";
1889 if (job
->username
.buffer
)
1890 rpcstr_pull(username
, job
->username
.buffer
,
1891 sizeof(username
), -1, STR_TERMINATE
);
1893 if (job
->document
.buffer
)
1894 rpcstr_pull(document
, job
->document
.buffer
,
1895 sizeof(document
), -1, STR_TERMINATE
);
1897 if (job
->text_status
.buffer
)
1898 rpcstr_pull(text_status
, job
->text_status
.buffer
,
1899 sizeof(text_status
), -1, STR_TERMINATE
);
1901 printf("%d: jobid[%d]: %s %s %s %d/%d pages\n", job
->position
, job
->jobid
,
1902 username
, document
, text_status
, job
->pagesprinted
,
1906 static void display_job_info_2(JOB_INFO_2
*job
)
1908 fstring username
= "", document
= "", text_status
= "";
1910 if (job
->username
.buffer
)
1911 rpcstr_pull(username
, job
->username
.buffer
,
1912 sizeof(username
), -1, STR_TERMINATE
);
1914 if (job
->document
.buffer
)
1915 rpcstr_pull(document
, job
->document
.buffer
,
1916 sizeof(document
), -1, STR_TERMINATE
);
1918 if (job
->text_status
.buffer
)
1919 rpcstr_pull(text_status
, job
->text_status
.buffer
,
1920 sizeof(text_status
), -1, STR_TERMINATE
);
1922 printf("%d: jobid[%d]: %s %s %s %d/%d pages, %d bytes\n", job
->position
, job
->jobid
,
1923 username
, document
, text_status
, job
->pagesprinted
,
1924 job
->totalpages
, job
->size
);
1927 /* Enumerate jobs */
1929 static NTSTATUS
cmd_spoolss_enum_jobs(struct cli_state
*cli
,
1930 TALLOC_CTX
*mem_ctx
, int argc
,
1934 uint32 needed
, level
= 1, num_jobs
, i
;
1935 BOOL got_hnd
= False
;
1936 pstring printername
;
1937 fstring servername
, user
;
1941 if (argc
< 2 || argc
> 3) {
1942 printf("Usage: %s printername [level]\n", argv
[0]);
1943 return NT_STATUS_OK
;
1947 level
= atoi(argv
[2]);
1949 /* Open printer handle */
1951 slprintf(servername
, sizeof(servername
)-1, "\\\\%s", cli
->desthost
);
1952 strupper(servername
);
1953 fstrcpy(user
, cli
->user_name
);
1954 slprintf(printername
, sizeof(servername
)-1, "\\\\%s\\", cli
->desthost
);
1955 strupper(printername
);
1956 pstrcat(printername
, argv
[1]);
1958 result
= cli_spoolss_open_printer_ex(cli
, mem_ctx
, printername
,
1959 "", MAXIMUM_ALLOWED_ACCESS
,
1960 servername
, user
, &hnd
);
1962 if (!W_ERROR_IS_OK(result
))
1967 /* Enumerate ports */
1969 result
= cli_spoolss_enumjobs(
1970 cli
, mem_ctx
, 0, &needed
, &hnd
, level
, 0, 1000,
1973 if (W_ERROR_V(result
) == ERRinsufficientbuffer
)
1974 result
= cli_spoolss_enumjobs(
1975 cli
, mem_ctx
, needed
, NULL
, &hnd
, level
, 0,
1976 1000, &num_jobs
, &ctr
);
1978 if (!W_ERROR_IS_OK(result
))
1981 for (i
= 0; i
< num_jobs
; i
++) {
1984 display_job_info_1(&ctr
.job
.job_info_1
[i
]);
1987 display_job_info_2(&ctr
.job
.job_info_2
[i
]);
1990 d_printf("unknown info level %d\n", level
);
1997 cli_spoolss_close_printer(cli
, mem_ctx
, &hnd
);
1999 return W_ERROR_IS_OK(result
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
2002 /* enumerate data */
2004 static NTSTATUS
cmd_spoolss_enum_data( struct cli_state
*cli
,
2005 TALLOC_CTX
*mem_ctx
, int argc
,
2009 uint32 i
=0, val_needed
, data_needed
;
2010 BOOL got_hnd
= False
;
2011 pstring printername
;
2012 fstring servername
, user
;
2016 printf("Usage: %s printername\n", argv
[0]);
2017 return NT_STATUS_OK
;
2020 /* Open printer handle */
2022 slprintf(servername
, sizeof(servername
)-1, "\\\\%s", cli
->desthost
);
2023 strupper(servername
);
2024 fstrcpy(user
, cli
->user_name
);
2025 slprintf(printername
, sizeof(printername
)-1, "\\\\%s\\", cli
->desthost
);
2026 strupper(printername
);
2027 pstrcat(printername
, argv
[1]);
2029 result
= cli_spoolss_open_printer_ex(cli
, mem_ctx
, printername
,
2030 "", MAXIMUM_ALLOWED_ACCESS
,
2031 servername
, user
, &hnd
);
2033 if (!W_ERROR_IS_OK(result
))
2038 /* Enumerate data */
2040 result
= cli_spoolss_enumprinterdata(cli
, mem_ctx
, &hnd
, i
, 0, 0,
2041 &val_needed
, &data_needed
,
2043 while (W_ERROR_IS_OK(result
)) {
2044 REGISTRY_VALUE value
;
2045 result
= cli_spoolss_enumprinterdata(
2046 cli
, mem_ctx
, &hnd
, i
++, val_needed
,
2047 data_needed
, 0, 0, &value
);
2048 if (W_ERROR_IS_OK(result
))
2049 display_reg_value(value
);
2051 if (W_ERROR_V(result
) == ERRnomoreitems
)
2052 result
= W_ERROR(ERRsuccess
);
2056 cli_spoolss_close_printer(cli
, mem_ctx
, &hnd
);
2058 return W_ERROR_IS_OK(result
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
2061 /* enumerate data for a given key */
2063 static NTSTATUS
cmd_spoolss_enum_data_ex( struct cli_state
*cli
,
2064 TALLOC_CTX
*mem_ctx
, int argc
,
2069 BOOL got_hnd
= False
;
2070 pstring printername
;
2071 fstring servername
, user
;
2072 char *keyname
= NULL
;
2077 printf("Usage: %s printername <keyname>\n", argv
[0]);
2078 return NT_STATUS_OK
;
2083 /* Open printer handle */
2085 slprintf(servername
, sizeof(servername
)-1, "\\\\%s", cli
->desthost
);
2086 strupper(servername
);
2087 fstrcpy(user
, cli
->user_name
);
2088 slprintf(printername
, sizeof(printername
)-1, "\\\\%s\\", cli
->desthost
);
2089 strupper(printername
);
2090 pstrcat(printername
, argv
[1]);
2092 result
= cli_spoolss_open_printer_ex(cli
, mem_ctx
, printername
,
2093 "", MAXIMUM_ALLOWED_ACCESS
,
2094 servername
, user
, &hnd
);
2096 if (!W_ERROR_IS_OK(result
))
2101 /* Enumerate subkeys */
2103 result
= cli_spoolss_enumprinterdataex(
2104 cli
, mem_ctx
, 0, &needed
, &hnd
, keyname
, NULL
);
2106 if (W_ERROR_V(result
) == ERRmoredata
)
2107 result
= cli_spoolss_enumprinterdataex(
2108 cli
, mem_ctx
, needed
, NULL
, &hnd
, keyname
, &ctr
);
2110 if (!W_ERROR_IS_OK(result
))
2113 for (i
=0; i
< ctr
.num_values
; i
++) {
2114 display_reg_value(*(ctr
.values
[i
]));
2117 regval_ctr_destroy(&ctr
);
2121 cli_spoolss_close_printer(cli
, mem_ctx
, &hnd
);
2123 return W_ERROR_IS_OK(result
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
2126 /* enumerate subkeys */
2128 static NTSTATUS
cmd_spoolss_enum_printerkey( struct cli_state
*cli
,
2129 TALLOC_CTX
*mem_ctx
, int argc
,
2133 uint32 needed
, returned
;
2134 BOOL got_hnd
= False
;
2135 pstring printername
;
2136 fstring servername
, user
;
2137 const char *keyname
= NULL
;
2139 uint16
*keylist
= NULL
, *curkey
;
2141 if (argc
< 2 || argc
> 3) {
2142 printf("Usage: %s printername [keyname]\n", argv
[0]);
2143 return NT_STATUS_OK
;
2151 /* Open printer handle */
2153 slprintf(servername
, sizeof(servername
)-1, "\\\\%s", cli
->desthost
);
2154 strupper(servername
);
2155 fstrcpy(user
, cli
->user_name
);
2156 slprintf(printername
, sizeof(printername
)-1, "\\\\%s\\", cli
->desthost
);
2157 strupper(printername
);
2158 pstrcat(printername
, argv
[1]);
2160 result
= cli_spoolss_open_printer_ex(cli
, mem_ctx
, printername
,
2161 "", MAXIMUM_ALLOWED_ACCESS
,
2162 servername
, user
, &hnd
);
2164 if (!W_ERROR_IS_OK(result
))
2169 /* Enumerate subkeys */
2171 result
= cli_spoolss_enumprinterkey(
2172 cli
, mem_ctx
, 0, &needed
, &hnd
, keyname
, NULL
, NULL
);
2174 if (W_ERROR_V(result
) == ERRmoredata
)
2175 result
= cli_spoolss_enumprinterkey(
2176 cli
, mem_ctx
, needed
, NULL
, &hnd
, keyname
, &keylist
,
2179 if (!W_ERROR_IS_OK(result
))
2183 while (*curkey
!= 0) {
2185 rpcstr_pull(subkey
, curkey
, sizeof(subkey
), -1,
2187 printf("%s\n", subkey
);
2188 curkey
+= strlen(subkey
) + 1;
2195 cli_spoolss_close_printer(cli
, mem_ctx
, &hnd
);
2197 return W_ERROR_IS_OK(result
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
2200 static NTSTATUS
cmd_spoolss_rffpcnex(struct cli_state
*cli
,
2201 TALLOC_CTX
*mem_ctx
, int argc
,
2204 fstring servername
, printername
;
2206 BOOL got_hnd
= False
;
2208 SPOOL_NOTIFY_OPTION option
;
2211 printf("Usage: %s printername\n", argv
[0]);
2218 slprintf(servername
, sizeof(servername
) - 1, "\\\\%s", cli
->desthost
);
2219 strupper(servername
);
2221 slprintf(printername
, sizeof(printername
) - 1, "\\\\%s\\%s", cli
->desthost
,
2223 strupper(printername
);
2225 result
= cli_spoolss_open_printer_ex(
2226 cli
, mem_ctx
, printername
, "", MAXIMUM_ALLOWED_ACCESS
,
2227 servername
, cli
->user_name
, &hnd
);
2229 if (!W_ERROR_IS_OK(result
)) {
2230 printf("Error opening %s\n", argv
[1]);
2236 /* Create spool options */
2238 ZERO_STRUCT(option
);
2241 option
.option_type_ptr
= 1;
2242 option
.count
= option
.ctr
.count
= 2;
2244 option
.ctr
.type
= (SPOOL_NOTIFY_OPTION_TYPE
*)talloc(
2245 mem_ctx
, sizeof(SPOOL_NOTIFY_OPTION_TYPE
) * 2);
2247 ZERO_STRUCT(option
.ctr
.type
[0]);
2248 option
.ctr
.type
[0].type
= PRINTER_NOTIFY_TYPE
;
2249 option
.ctr
.type
[0].count
= option
.ctr
.type
[0].count2
= 1;
2250 option
.ctr
.type
[0].fields_ptr
= 1;
2251 option
.ctr
.type
[0].fields
[0] = PRINTER_NOTIFY_SERVER_NAME
;
2253 ZERO_STRUCT(option
.ctr
.type
[1]);
2254 option
.ctr
.type
[1].type
= JOB_NOTIFY_TYPE
;
2255 option
.ctr
.type
[1].count
= option
.ctr
.type
[1].count2
= 1;
2256 option
.ctr
.type
[1].fields_ptr
= 1;
2257 option
.ctr
.type
[1].fields
[0] = JOB_NOTIFY_PRINTER_NAME
;
2261 slprintf(servername
, sizeof(servername
) - 1, "\\\\%s", myhostname());
2262 strupper(servername
);
2264 result
= cli_spoolss_rffpcnex(
2265 cli
, mem_ctx
, &hnd
, 0, 0, servername
, 123, &option
);
2267 if (!W_ERROR_IS_OK(result
)) {
2268 printf("Error rffpcnex %s\n", argv
[1]);
2274 cli_spoolss_close_printer(cli
, mem_ctx
, &hnd
);
2276 return W_ERROR_IS_OK(result
) ? NT_STATUS_OK
: NT_STATUS_UNSUCCESSFUL
;
2279 /* List of commands exported by this module */
2280 struct cmd_set spoolss_commands
[] = {
2284 { "adddriver", cmd_spoolss_addprinterdriver
, PI_SPOOLSS
, "Add a print driver", "" },
2285 { "addprinter", cmd_spoolss_addprinterex
, PI_SPOOLSS
, "Add a printer", "" },
2286 { "deldriver", cmd_spoolss_deletedriver
, PI_SPOOLSS
, "Delete a printer driver", "" },
2287 { "enumdata", cmd_spoolss_enum_data
, PI_SPOOLSS
, "Enumerate printer data", "" },
2288 { "enumdataex", cmd_spoolss_enum_data_ex
, PI_SPOOLSS
, "Enumerate printer data for a key", "" },
2289 { "enumkey", cmd_spoolss_enum_printerkey
, PI_SPOOLSS
, "Enumerate printer keys", "" },
2290 { "enumjobs", cmd_spoolss_enum_jobs
, PI_SPOOLSS
, "Enumerate print jobs", "" },
2291 { "enumports", cmd_spoolss_enum_ports
, PI_SPOOLSS
, "Enumerate printer ports", "" },
2292 { "enumdrivers", cmd_spoolss_enum_drivers
, PI_SPOOLSS
, "Enumerate installed printer drivers", "" },
2293 { "enumprinters", cmd_spoolss_enum_printers
, PI_SPOOLSS
, "Enumerate printers", "" },
2294 { "getdata", cmd_spoolss_getprinterdata
, PI_SPOOLSS
, "Get print driver data", "" },
2295 { "getdataex", cmd_spoolss_getprinterdataex
, PI_SPOOLSS
, "Get printer driver data with keyname", ""},
2296 { "getdriver", cmd_spoolss_getdriver
, PI_SPOOLSS
, "Get print driver information", "" },
2297 { "getdriverdir", cmd_spoolss_getdriverdir
, PI_SPOOLSS
, "Get print driver upload directory", "" },
2298 { "getprinter", cmd_spoolss_getprinter
, PI_SPOOLSS
, "Get printer info", "" },
2299 { "getprintprocdir", cmd_spoolss_getprintprocdir
, PI_SPOOLSS
, "Get print processor directory", "" },
2300 { "openprinter", cmd_spoolss_open_printer_ex
, PI_SPOOLSS
, "Open printer handle", "" },
2301 { "setdriver", cmd_spoolss_setdriver
, PI_SPOOLSS
, "Set printer driver", "" },
2302 { "getprintprocdir", cmd_spoolss_getprintprocdir
, PI_SPOOLSS
, "Get print processor directory", "" },
2303 { "addform", cmd_spoolss_addform
, PI_SPOOLSS
, "Add form", "" },
2304 { "setform", cmd_spoolss_setform
, PI_SPOOLSS
, "Set form", "" },
2305 { "getform", cmd_spoolss_getform
, PI_SPOOLSS
, "Get form", "" },
2306 { "deleteform", cmd_spoolss_deleteform
, PI_SPOOLSS
, "Delete form", "" },
2307 { "enumforms", cmd_spoolss_enum_forms
, PI_SPOOLSS
, "Enumerate forms", "" },
2308 { "setprinter", cmd_spoolss_setprinter
, PI_SPOOLSS
, "Set printer comment", "" },
2309 { "setprinterdata", cmd_spoolss_setprinterdata
, PI_SPOOLSS
, "Set REG_SZ printer data", "" },
2310 { "rffpcnex", cmd_spoolss_rffpcnex
, PI_SPOOLSS
, "Rffpcnex test", "" },