2 Unix SMB/CIFS implementation.
5 Copyright (C) Gerald Carter 2001-2005
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 3 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, see <http://www.gnu.org/licenses/>.
25 #include "rpcclient.h"
28 const char *long_archi;
29 const char *short_archi;
33 /* The version int is used by getdrivers. Note that
34 all architecture strings that support mutliple
35 versions must be grouped together since enumdrivers
36 uses this property to prevent issuing multiple
37 enumdriver calls for the same arch */
40 static const struct table_node archi_table[]= {
42 {"Windows 4.0", "WIN40", 0 },
43 {"Windows NT x86", "W32X86", 2 },
44 {"Windows NT x86", "W32X86", 3 },
45 {"Windows NT R4000", "W32MIPS", 2 },
46 {"Windows NT Alpha_AXP", "W32ALPHA", 2 },
47 {"Windows NT PowerPC", "W32PPC", 2 },
48 {"Windows IA64", "IA64", 3 },
49 {"Windows x64", "x64", 3 },
56 * rpcclient module for SPOOLSS rpc pipe.
58 * This generally just parses and checks command lines, and then calls
59 * a cli_spoolss function.
62 /****************************************************************************
63 function to do the mapping between the long architecture name and
65 ****************************************************************************/
67 static const char *cmd_spoolss_get_short_archi(const char *long_archi)
71 DEBUG(107,("Getting architecture dependant directory\n"));
74 } while ( (archi_table[i].long_archi!=NULL ) &&
75 StrCaseCmp(long_archi, archi_table[i].long_archi) );
77 if (archi_table[i].long_archi==NULL) {
78 DEBUGADD(10,("Unknown architecture [%s] !\n", long_archi));
82 /* this might be client code - but shouldn't this be an fstrcpy etc? */
85 DEBUGADD(108,("index: [%d]\n", i));
86 DEBUGADD(108,("long architecture: [%s]\n", archi_table[i].long_archi));
87 DEBUGADD(108,("short architecture: [%s]\n", archi_table[i].short_archi));
89 return archi_table[i].short_archi;
92 /****************************************************************************
93 ****************************************************************************/
95 static WERROR cmd_spoolss_open_printer_ex(struct rpc_pipe_client *cli,
97 int argc, const char **argv)
101 fstring servername, user;
105 printf("Usage: %s <printername>\n", argv[0]);
110 return WERR_GENERAL_FAILURE;
112 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
113 strupper_m(servername);
114 fstrcpy(user, cli->auth->user_name);
115 fstrcpy(printername, argv[1]);
117 /* Open the printer handle */
119 werror = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
120 "", PRINTER_ALL_ACCESS,
121 servername, user, &hnd);
123 if (W_ERROR_IS_OK(werror)) {
124 printf("Printer %s opened successfully\n", printername);
125 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, &werror);
127 if (!W_ERROR_IS_OK(werror)) {
128 printf("Error closing printer handle! (%s)\n",
129 get_dos_error_msg(werror));
137 /****************************************************************************
138 ****************************************************************************/
140 static void display_print_info_0(PRINTER_INFO_0 *i0)
143 fstring servername = "";
148 rpcstr_pull(name, i0->printername.buffer, sizeof(name), -1, STR_TERMINATE);
150 rpcstr_pull(servername, i0->servername.buffer, sizeof(servername), -1,STR_TERMINATE);
152 printf("\tprintername:[%s]\n", name);
153 printf("\tservername:[%s]\n", servername);
154 printf("\tcjobs:[0x%x]\n", i0->cjobs);
155 printf("\ttotal_jobs:[0x%x]\n", i0->total_jobs);
157 printf("\t:date: [%d]-[%d]-[%d] (%d)\n", i0->year, i0->month,
158 i0->day, i0->dayofweek);
159 printf("\t:time: [%d]-[%d]-[%d]-[%d]\n", i0->hour, i0->minute,
160 i0->second, i0->milliseconds);
162 printf("\tglobal_counter:[0x%x]\n", i0->global_counter);
163 printf("\ttotal_pages:[0x%x]\n", i0->total_pages);
165 printf("\tmajorversion:[0x%x]\n", i0->major_version);
166 printf("\tbuildversion:[0x%x]\n", i0->build_version);
168 printf("\tunknown7:[0x%x]\n", i0->unknown7);
169 printf("\tunknown8:[0x%x]\n", i0->unknown8);
170 printf("\tunknown9:[0x%x]\n", i0->unknown9);
171 printf("\tsession_counter:[0x%x]\n", i0->session_counter);
172 printf("\tunknown11:[0x%x]\n", i0->unknown11);
173 printf("\tprinter_errors:[0x%x]\n", i0->printer_errors);
174 printf("\tunknown13:[0x%x]\n", i0->unknown13);
175 printf("\tunknown14:[0x%x]\n", i0->unknown14);
176 printf("\tunknown15:[0x%x]\n", i0->unknown15);
177 printf("\tunknown16:[0x%x]\n", i0->unknown16);
178 printf("\tchange_id:[0x%x]\n", i0->change_id);
179 printf("\tunknown18:[0x%x]\n", i0->unknown18);
180 printf("\tstatus:[0x%x]\n", i0->status);
181 printf("\tunknown20:[0x%x]\n", i0->unknown20);
182 printf("\tc_setprinter:[0x%x]\n", i0->c_setprinter);
183 printf("\tunknown22:[0x%x]\n", i0->unknown22);
184 printf("\tunknown23:[0x%x]\n", i0->unknown23);
185 printf("\tunknown24:[0x%x]\n", i0->unknown24);
186 printf("\tunknown25:[0x%x]\n", i0->unknown25);
187 printf("\tunknown26:[0x%x]\n", i0->unknown26);
188 printf("\tunknown27:[0x%x]\n", i0->unknown27);
189 printf("\tunknown28:[0x%x]\n", i0->unknown28);
190 printf("\tunknown29:[0x%x]\n", i0->unknown29);
195 /****************************************************************************
196 ****************************************************************************/
198 static void display_print_info_1(PRINTER_INFO_1 *i1)
204 rpcstr_pull(desc, i1->description.buffer, sizeof(desc), -1,
207 rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
208 rpcstr_pull(comm, i1->comment.buffer, sizeof(comm), -1, STR_TERMINATE);
210 printf("\tflags:[0x%x]\n", i1->flags);
211 printf("\tname:[%s]\n", name);
212 printf("\tdescription:[%s]\n", desc);
213 printf("\tcomment:[%s]\n", comm);
218 /****************************************************************************
219 ****************************************************************************/
221 static void display_print_info_2(PRINTER_INFO_2 *i2)
223 fstring servername = "";
224 fstring printername = "";
225 fstring sharename = "";
226 fstring portname = "";
227 fstring drivername = "";
228 fstring comment = "";
229 fstring location = "";
230 fstring sepfile = "";
231 fstring printprocessor = "";
232 fstring datatype = "";
233 fstring parameters = "";
235 rpcstr_pull(servername, i2->servername.buffer,sizeof(servername), -1, STR_TERMINATE);
236 rpcstr_pull(printername, i2->printername.buffer,sizeof(printername), -1, STR_TERMINATE);
237 rpcstr_pull(sharename, i2->sharename.buffer,sizeof(sharename), -1, STR_TERMINATE);
238 rpcstr_pull(portname, i2->portname.buffer,sizeof(portname), -1, STR_TERMINATE);
239 rpcstr_pull(drivername, i2->drivername.buffer,sizeof(drivername), -1, STR_TERMINATE);
240 rpcstr_pull(comment, i2->comment.buffer,sizeof(comment), -1, STR_TERMINATE);
241 rpcstr_pull(location, i2->location.buffer,sizeof(location), -1, STR_TERMINATE);
242 rpcstr_pull(sepfile, i2->sepfile.buffer,sizeof(sepfile), -1, STR_TERMINATE);
243 rpcstr_pull(printprocessor, i2->printprocessor.buffer,sizeof(printprocessor), -1, STR_TERMINATE);
244 rpcstr_pull(datatype, i2->datatype.buffer,sizeof(datatype), -1, STR_TERMINATE);
245 rpcstr_pull(parameters, i2->parameters.buffer,sizeof(parameters), -1, STR_TERMINATE);
247 printf("\tservername:[%s]\n", servername);
248 printf("\tprintername:[%s]\n", printername);
249 printf("\tsharename:[%s]\n", sharename);
250 printf("\tportname:[%s]\n", portname);
251 printf("\tdrivername:[%s]\n", drivername);
252 printf("\tcomment:[%s]\n", comment);
253 printf("\tlocation:[%s]\n", location);
254 printf("\tsepfile:[%s]\n", sepfile);
255 printf("\tprintprocessor:[%s]\n", printprocessor);
256 printf("\tdatatype:[%s]\n", datatype);
257 printf("\tparameters:[%s]\n", parameters);
258 printf("\tattributes:[0x%x]\n", i2->attributes);
259 printf("\tpriority:[0x%x]\n", i2->priority);
260 printf("\tdefaultpriority:[0x%x]\n", i2->defaultpriority);
261 printf("\tstarttime:[0x%x]\n", i2->starttime);
262 printf("\tuntiltime:[0x%x]\n", i2->untiltime);
263 printf("\tstatus:[0x%x]\n", i2->status);
264 printf("\tcjobs:[0x%x]\n", i2->cjobs);
265 printf("\taverageppm:[0x%x]\n", i2->averageppm);
268 display_sec_desc(i2->secdesc);
273 /****************************************************************************
274 ****************************************************************************/
276 static void display_print_info_3(PRINTER_INFO_3 *i3)
278 display_sec_desc(i3->secdesc);
283 /****************************************************************************
284 ****************************************************************************/
286 static void display_print_info_7(PRINTER_INFO_7 *i7)
289 rpcstr_pull(guid, i7->guid.buffer,sizeof(guid), -1, STR_TERMINATE);
290 printf("\tguid:[%s]\n", guid);
291 printf("\taction:[0x%x]\n", i7->action);
295 /****************************************************************************
296 ****************************************************************************/
298 static WERROR cmd_spoolss_enum_printers(struct rpc_pipe_client *cli,
300 int argc, const char **argv)
303 uint32 info_level = 1;
304 PRINTER_INFO_CTR ctr;
305 uint32 i = 0, num_printers;
310 printf("Usage: %s [level] [name]\n", argv[0]);
315 info_level = atoi(argv[1]);
318 fstrcpy(name, argv[2]);
320 slprintf(name, sizeof(name)-1, "\\\\%s", cli->desthost);
326 result = rpccli_spoolss_enum_printers(cli, mem_ctx, name, PRINTER_ENUM_LOCAL,
327 info_level, &num_printers, &ctr);
329 if (W_ERROR_IS_OK(result)) {
332 printf ("No printers returned.\n");
336 for (i = 0; i < num_printers; i++) {
339 display_print_info_0(&ctr.printers_0[i]);
342 display_print_info_1(&ctr.printers_1[i]);
345 display_print_info_2(&ctr.printers_2[i]);
348 display_print_info_3(&ctr.printers_3[i]);
351 printf("unknown info level %d\n", info_level);
361 /****************************************************************************
362 ****************************************************************************/
364 static void display_port_info_1(PORT_INFO_1 *i1)
368 rpcstr_pull(buffer, i1->port_name.buffer, sizeof(buffer), -1, STR_TERMINATE);
369 printf("\tPort Name:\t[%s]\n", buffer);
372 /****************************************************************************
373 ****************************************************************************/
375 static void display_port_info_2(PORT_INFO_2 *i2)
379 rpcstr_pull(buffer, i2->port_name.buffer, sizeof(buffer), -1, STR_TERMINATE);
380 printf("\tPort Name:\t[%s]\n", buffer);
381 rpcstr_pull(buffer, i2->monitor_name.buffer, sizeof(buffer), -1, STR_TERMINATE);
383 printf("\tMonitor Name:\t[%s]\n", buffer);
384 rpcstr_pull(buffer, i2->description.buffer, sizeof(buffer), -1, STR_TERMINATE);
386 printf("\tDescription:\t[%s]\n", buffer);
387 printf("\tPort Type:\t" );
388 if ( i2->port_type ) {
389 int comma = 0; /* hack */
391 if ( i2->port_type & PORT_TYPE_READ ) {
395 if ( i2->port_type & PORT_TYPE_WRITE ) {
396 printf( "%sWrite", comma ? ", " : "" );
399 /* These two have slightly different interpretations
400 on 95/98/ME but I'm disregarding that for now */
401 if ( i2->port_type & PORT_TYPE_REDIRECTED ) {
402 printf( "%sRedirected", comma ? ", " : "" );
405 if ( i2->port_type & PORT_TYPE_NET_ATTACHED ) {
406 printf( "%sNet-Attached", comma ? ", " : "" );
410 printf( "[Unset]\n" );
412 printf("\tReserved:\t[%d]\n", i2->reserved);
416 /****************************************************************************
417 ****************************************************************************/
419 static WERROR cmd_spoolss_enum_ports(struct rpc_pipe_client *cli,
420 TALLOC_CTX *mem_ctx, int argc,
424 uint32 info_level = 1;
429 printf("Usage: %s [level]\n", argv[0]);
434 info_level = atoi(argv[1]);
436 /* Enumerate ports */
440 result = rpccli_spoolss_enum_ports(cli, mem_ctx, info_level, &returned, &ctr);
442 if (W_ERROR_IS_OK(result)) {
445 for (i = 0; i < returned; i++) {
446 switch (info_level) {
448 display_port_info_1(&ctr.port.info_1[i]);
451 display_port_info_2(&ctr.port.info_2[i]);
454 printf("unknown info level %d\n", info_level);
463 /****************************************************************************
464 ****************************************************************************/
466 static WERROR cmd_spoolss_setprinter(struct rpc_pipe_client *cli,
468 int argc, const char **argv)
472 uint32 info_level = 2;
473 bool opened_hnd = False;
474 PRINTER_INFO_CTR ctr;
480 if (argc == 1 || argc > 3) {
481 printf("Usage: %s printername comment\n", argv[0]);
486 /* Open a printer handle */
488 fstrcpy(comment, argv[2]);
491 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
492 strupper_m(servername);
493 slprintf(printername, sizeof(servername)-1, "%s\\%s", servername, argv[1]);
494 fstrcpy(user, cli->auth->user_name);
496 /* get a printer handle */
497 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
498 PRINTER_ALL_ACCESS, servername,
501 if (!W_ERROR_IS_OK(result))
506 /* Get printer info */
507 result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, info_level, &ctr);
509 if (!W_ERROR_IS_OK(result))
513 /* Modify the comment. */
514 init_unistr(&ctr.printers_2->comment, comment);
515 ctr.printers_2->devmode = NULL;
516 ctr.printers_2->secdesc = NULL;
518 result = rpccli_spoolss_setprinter(cli, mem_ctx, &pol, info_level, &ctr, 0);
519 if (W_ERROR_IS_OK(result))
520 printf("Success in setting comment.\n");
524 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
529 /****************************************************************************
530 ****************************************************************************/
532 static WERROR cmd_spoolss_setprintername(struct rpc_pipe_client *cli,
534 int argc, const char **argv)
538 uint32 info_level = 2;
539 bool opened_hnd = False;
540 PRINTER_INFO_CTR ctr;
546 if (argc == 1 || argc > 3) {
547 printf("Usage: %s printername new_printername\n", argv[0]);
552 /* Open a printer handle */
554 fstrcpy(new_printername, argv[2]);
557 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
558 strupper_m(servername);
559 slprintf(printername, sizeof(printername)-1, "%s\\%s", servername, argv[1]);
560 fstrcpy(user, cli->auth->user_name);
562 /* get a printer handle */
563 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
564 PRINTER_ALL_ACCESS, servername,
567 if (!W_ERROR_IS_OK(result))
572 /* Get printer info */
573 result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, info_level, &ctr);
575 if (!W_ERROR_IS_OK(result))
578 /* Modify the printername. */
579 init_unistr(&ctr.printers_2->printername, new_printername);
580 ctr.printers_2->devmode = NULL;
581 ctr.printers_2->secdesc = NULL;
583 result = rpccli_spoolss_setprinter(cli, mem_ctx, &pol, info_level, &ctr, 0);
584 if (W_ERROR_IS_OK(result))
585 printf("Success in setting printername.\n");
589 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
594 /****************************************************************************
595 ****************************************************************************/
597 static WERROR cmd_spoolss_getprinter(struct rpc_pipe_client *cli,
599 int argc, const char **argv)
603 uint32 info_level = 1;
604 bool opened_hnd = False;
605 PRINTER_INFO_CTR ctr;
610 if (argc == 1 || argc > 3) {
611 printf("Usage: %s <printername> [level]\n", argv[0]);
615 /* Open a printer handle */
617 info_level = atoi(argv[2]);
620 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
621 strupper_m(servername);
622 slprintf(printername, sizeof(printername)-1, "%s\\%s", servername, argv[1]);
623 fstrcpy(user, cli->auth->user_name);
625 /* get a printer handle */
627 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
628 "", MAXIMUM_ALLOWED_ACCESS,
629 servername, user, &pol);
631 if (!W_ERROR_IS_OK(result))
636 /* Get printer info */
638 result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, info_level, &ctr);
640 if (!W_ERROR_IS_OK(result))
643 /* Display printer info */
645 switch (info_level) {
647 display_print_info_0(ctr.printers_0);
650 display_print_info_1(ctr.printers_1);
653 display_print_info_2(ctr.printers_2);
656 display_print_info_3(ctr.printers_3);
659 display_print_info_7(ctr.printers_7);
662 printf("unknown info level %d\n", info_level);
668 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
673 /****************************************************************************
674 ****************************************************************************/
676 static void display_reg_value(REGISTRY_VALUE value)
682 printf("%s: REG_DWORD: 0x%08x\n", value.valuename,
683 *((uint32 *) value.data_p));
686 rpcstr_pull_talloc(talloc_tos(),
691 printf("%s: REG_SZ: %s\n", value.valuename, text ? text : "");
694 char *hex = hex_encode_talloc(NULL, value.data_p, value.size);
696 printf("%s: REG_BINARY:", value.valuename);
698 for (i=0; i<len; i++) {
699 if (hex[i] == '\0') {
712 uint32 i, num_values;
715 if (!W_ERROR_IS_OK(reg_pull_multi_sz(NULL, value.data_p,
716 value.size, &num_values,
718 d_printf("reg_pull_multi_sz failed\n");
722 for (i=0; i<num_values; i++) {
723 d_printf("%s\n", values[i]);
729 printf("%s: unknown type %d\n", value.valuename, value.type);
734 /****************************************************************************
735 ****************************************************************************/
737 static WERROR cmd_spoolss_getprinterdata(struct rpc_pipe_client *cli,
739 int argc, const char **argv)
743 bool opened_hnd = False;
747 const char *valuename;
748 REGISTRY_VALUE value;
751 printf("Usage: %s <printername> <valuename>\n", argv[0]);
752 printf("<printername> of . queries print server\n");
757 /* Open a printer handle */
759 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
760 strupper_m(servername);
761 if (strncmp(argv[1], ".", sizeof(".")) == 0)
762 fstrcpy(printername, servername);
764 slprintf(printername, sizeof(servername)-1, "%s\\%s",
765 servername, argv[1]);
766 fstrcpy(user, cli->auth->user_name);
768 /* get a printer handle */
770 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
771 "", MAXIMUM_ALLOWED_ACCESS,
772 servername, user, &pol);
774 if (!W_ERROR_IS_OK(result))
779 /* Get printer info */
781 result = rpccli_spoolss_getprinterdata(cli, mem_ctx, &pol, valuename, &value);
783 if (!W_ERROR_IS_OK(result))
786 /* Display printer data */
788 fstrcpy(value.valuename, valuename);
789 display_reg_value(value);
794 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
799 /****************************************************************************
800 ****************************************************************************/
802 static WERROR cmd_spoolss_getprinterdataex(struct rpc_pipe_client *cli,
804 int argc, const char **argv)
808 bool opened_hnd = False;
812 const char *valuename, *keyname;
813 REGISTRY_VALUE value;
816 printf("Usage: %s <printername> <keyname> <valuename>\n",
818 printf("<printername> of . queries print server\n");
824 /* Open a printer handle */
826 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
827 strupper_m(servername);
828 if (strncmp(argv[1], ".", sizeof(".")) == 0)
829 fstrcpy(printername, servername);
831 slprintf(printername, sizeof(printername)-1, "%s\\%s",
832 servername, argv[1]);
833 fstrcpy(user, cli->auth->user_name);
835 /* get a printer handle */
837 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
838 "", MAXIMUM_ALLOWED_ACCESS,
839 servername, user, &pol);
841 if (!W_ERROR_IS_OK(result))
846 /* Get printer info */
848 result = rpccli_spoolss_getprinterdataex(cli, mem_ctx, &pol, keyname,
851 if (!W_ERROR_IS_OK(result))
854 /* Display printer data */
856 fstrcpy(value.valuename, valuename);
857 display_reg_value(value);
862 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
867 /****************************************************************************
868 ****************************************************************************/
870 static void display_print_driver_1(DRIVER_INFO_1 *i1)
876 rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
878 printf ("Printer Driver Info 1:\n");
879 printf ("\tDriver Name: [%s]\n\n", name);
884 /****************************************************************************
885 ****************************************************************************/
887 static void display_print_driver_2(DRIVER_INFO_2 *i1)
890 fstring architecture;
897 rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
898 rpcstr_pull(architecture, i1->architecture.buffer, sizeof(architecture), -1, STR_TERMINATE);
899 rpcstr_pull(driverpath, i1->driverpath.buffer, sizeof(driverpath), -1, STR_TERMINATE);
900 rpcstr_pull(datafile, i1->datafile.buffer, sizeof(datafile), -1, STR_TERMINATE);
901 rpcstr_pull(configfile, i1->configfile.buffer, sizeof(configfile), -1, STR_TERMINATE);
903 printf ("Printer Driver Info 2:\n");
904 printf ("\tVersion: [%x]\n", i1->version);
905 printf ("\tDriver Name: [%s]\n", name);
906 printf ("\tArchitecture: [%s]\n", architecture);
907 printf ("\tDriver Path: [%s]\n", driverpath);
908 printf ("\tDatafile: [%s]\n", datafile);
909 printf ("\tConfigfile: [%s]\n\n", configfile);
914 /****************************************************************************
915 ****************************************************************************/
917 static void display_print_driver_3(DRIVER_INFO_3 *i1)
920 fstring architecture = "";
921 fstring driverpath = "";
922 fstring datafile = "";
923 fstring configfile = "";
924 fstring helpfile = "";
925 fstring dependentfiles = "";
926 fstring monitorname = "";
927 fstring defaultdatatype = "";
935 rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
936 rpcstr_pull(architecture, i1->architecture.buffer, sizeof(architecture), -1, STR_TERMINATE);
937 rpcstr_pull(driverpath, i1->driverpath.buffer, sizeof(driverpath), -1, STR_TERMINATE);
938 rpcstr_pull(datafile, i1->datafile.buffer, sizeof(datafile), -1, STR_TERMINATE);
939 rpcstr_pull(configfile, i1->configfile.buffer, sizeof(configfile), -1, STR_TERMINATE);
940 rpcstr_pull(helpfile, i1->helpfile.buffer, sizeof(helpfile), -1, STR_TERMINATE);
941 rpcstr_pull(monitorname, i1->monitorname.buffer, sizeof(monitorname), -1, STR_TERMINATE);
942 rpcstr_pull(defaultdatatype, i1->defaultdatatype.buffer, sizeof(defaultdatatype), -1, STR_TERMINATE);
944 printf ("Printer Driver Info 3:\n");
945 printf ("\tVersion: [%x]\n", i1->version);
946 printf ("\tDriver Name: [%s]\n",name);
947 printf ("\tArchitecture: [%s]\n", architecture);
948 printf ("\tDriver Path: [%s]\n", driverpath);
949 printf ("\tDatafile: [%s]\n", datafile);
950 printf ("\tConfigfile: [%s]\n", configfile);
951 printf ("\tHelpfile: [%s]\n\n", helpfile);
955 rpcstr_pull(dependentfiles, i1->dependentfiles+length, sizeof(dependentfiles), -1, STR_TERMINATE);
957 length+=strlen(dependentfiles)+1;
959 if (strlen(dependentfiles) > 0)
961 printf ("\tDependentfiles: [%s]\n", dependentfiles);
971 printf ("\tMonitorname: [%s]\n", monitorname);
972 printf ("\tDefaultdatatype: [%s]\n\n", defaultdatatype);
977 /****************************************************************************
978 ****************************************************************************/
980 static WERROR cmd_spoolss_getdriver(struct rpc_pipe_client *cli,
982 int argc, const char **argv)
986 uint32 info_level = 3;
987 bool opened_hnd = False;
988 PRINTER_DRIVER_CTR ctr;
993 bool success = False;
995 if ((argc == 1) || (argc > 3))
997 printf("Usage: %s <printername> [level]\n", argv[0]);
1001 /* get the arguments need to open the printer handle */
1002 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
1003 strupper_m(servername);
1004 fstrcpy(user, cli->auth->user_name);
1005 slprintf(printername, sizeof(servername)-1, "%s\\%s", servername, argv[1]);
1007 info_level = atoi(argv[2]);
1009 /* Open a printer handle */
1011 werror = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
1013 servername, user, &pol);
1015 if (!W_ERROR_IS_OK(werror)) {
1016 printf("Error opening printer handle for %s!\n", printername);
1022 /* loop through and print driver info level for each architecture */
1024 for (i=0; archi_table[i].long_archi!=NULL; i++) {
1026 werror = rpccli_spoolss_getprinterdriver( cli, mem_ctx, &pol, info_level,
1027 archi_table[i].long_archi, archi_table[i].version,
1030 if (!W_ERROR_IS_OK(werror))
1033 /* need at least one success */
1037 printf ("\n[%s]\n", archi_table[i].long_archi);
1039 switch (info_level) {
1041 display_print_driver_1 (ctr.info1);
1044 display_print_driver_2 (ctr.info2);
1047 display_print_driver_3 (ctr.info3);
1050 printf("unknown info level %d\n", info_level);
1058 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
1066 /****************************************************************************
1067 ****************************************************************************/
1069 static WERROR cmd_spoolss_enum_drivers(struct rpc_pipe_client *cli,
1070 TALLOC_CTX *mem_ctx,
1071 int argc, const char **argv)
1073 WERROR werror = WERR_OK;
1074 uint32 info_level = 1;
1075 PRINTER_DRIVER_CTR ctr;
1080 printf("Usage: enumdrivers [level]\n");
1085 info_level = atoi(argv[1]);
1088 /* loop through and print driver info level for each architecture */
1089 for (i=0; archi_table[i].long_archi!=NULL; i++) {
1090 /* check to see if we already asked for this architecture string */
1092 if ( i>0 && strequal(archi_table[i].long_archi, archi_table[i-1].long_archi) )
1095 werror = rpccli_spoolss_enumprinterdrivers(
1096 cli, mem_ctx, info_level,
1097 archi_table[i].long_archi, &returned, &ctr);
1099 if (W_ERROR_V(werror) == W_ERROR_V(WERR_INVALID_ENVIRONMENT)) {
1100 printf ("Server does not support environment [%s]\n",
1101 archi_table[i].long_archi);
1109 if (!W_ERROR_IS_OK(werror)) {
1110 printf ("Error getting driver for environment [%s] - %d\n",
1111 archi_table[i].long_archi, W_ERROR_V(werror));
1115 printf ("\n[%s]\n", archi_table[i].long_archi);
1120 for (j=0; j < returned; j++) {
1121 display_print_driver_1 (&ctr.info1[j]);
1125 for (j=0; j < returned; j++) {
1126 display_print_driver_2 (&ctr.info2[j]);
1130 for (j=0; j < returned; j++) {
1131 display_print_driver_3 (&ctr.info3[j]);
1135 printf("unknown info level %d\n", info_level);
1136 return WERR_UNKNOWN_LEVEL;
1143 /****************************************************************************
1144 ****************************************************************************/
1146 static void display_printdriverdir_1(DRIVER_DIRECTORY_1 *i1)
1152 rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
1154 printf ("\tDirectory Name:[%s]\n", name);
1157 /****************************************************************************
1158 ****************************************************************************/
1160 static WERROR cmd_spoolss_getdriverdir(struct rpc_pipe_client *cli,
1161 TALLOC_CTX *mem_ctx,
1162 int argc, const char **argv)
1166 DRIVER_DIRECTORY_CTR ctr;
1169 printf("Usage: %s [environment]\n", argv[0]);
1173 /* Get the arguments need to open the printer handle */
1176 fstrcpy (env, argv[1]);
1178 fstrcpy (env, "Windows NT x86");
1180 /* Get the directory. Only use Info level 1 */
1182 result = rpccli_spoolss_getprinterdriverdir(cli, mem_ctx, 1, env, &ctr);
1184 if (W_ERROR_IS_OK(result))
1185 display_printdriverdir_1(ctr.info1);
1190 /****************************************************************************
1191 ****************************************************************************/
1193 void set_drv_info_3_env (DRIVER_INFO_3 *info, const char *arch)
1198 for (i=0; archi_table[i].long_archi != NULL; i++)
1200 if (strcmp(arch, archi_table[i].short_archi) == 0)
1202 info->version = archi_table[i].version;
1203 init_unistr (&info->architecture, archi_table[i].long_archi);
1208 if (archi_table[i].long_archi == NULL)
1210 DEBUG(0, ("set_drv_info_3_env: Unknown arch [%s]\n", arch));
1217 /**************************************************************************
1218 wrapper for strtok to get the next parameter from a delimited list.
1219 Needed to handle the empty parameter string denoted by "NULL"
1220 *************************************************************************/
1222 static char* get_driver_3_param (char* str, const char* delim, UNISTR* dest,
1227 /* get the next token */
1228 ptr = strtok_r(str, delim, saveptr);
1230 /* a string of 'NULL' is used to represent an empty
1231 parameter because two consecutive delimiters
1232 will not return an empty string. See man strtok(3)
1234 if (ptr && (StrCaseCmp(ptr, "NULL") == 0))
1238 init_unistr(dest, ptr);
1243 /********************************************************************************
1244 fill in the members of a DRIVER_INFO_3 struct using a character
1245 string in the form of
1246 <Long Printer Name>:<Driver File Name>:<Data File Name>:\
1247 <Config File Name>:<Help File Name>:<Language Monitor Name>:\
1248 <Default Data Type>:<Comma Separated list of Files>
1249 *******************************************************************************/
1250 static bool init_drv_info_3_members ( TALLOC_CTX *mem_ctx, DRIVER_INFO_3 *info,
1255 char *saveptr = NULL;
1257 /* fill in the UNISTR fields */
1258 str = get_driver_3_param (args, ":", &info->name, &saveptr);
1259 str = get_driver_3_param (NULL, ":", &info->driverpath, &saveptr);
1260 str = get_driver_3_param (NULL, ":", &info->datafile, &saveptr);
1261 str = get_driver_3_param (NULL, ":", &info->configfile, &saveptr);
1262 str = get_driver_3_param (NULL, ":", &info->helpfile, &saveptr);
1263 str = get_driver_3_param (NULL, ":", &info->monitorname, &saveptr);
1264 str = get_driver_3_param (NULL, ":", &info->defaultdatatype, &saveptr);
1266 /* <Comma Separated List of Dependent Files> */
1267 /* save the beginning of the string */
1268 str2 = get_driver_3_param (NULL, ":", NULL, &saveptr);
1271 /* begin to strip out each filename */
1272 str = strtok_r(str, ",", &saveptr);
1276 /* keep a cumlative count of the str lengths */
1277 len += strlen(str)+1;
1278 str = strtok_r(NULL, ",", &saveptr);
1281 /* allocate the space; add one extra slot for a terminating NULL.
1282 Each filename is NULL terminated and the end contains a double
1284 if ((info->dependentfiles=TALLOC_ARRAY(mem_ctx, uint16, len+1)) == NULL)
1286 DEBUG(0,("init_drv_info_3_members: Unable to malloc memory for dependenfiles\n"));
1289 for (i=0; i<len; i++)
1291 SSVAL(&info->dependentfiles[i], 0, str2[i]);
1293 info->dependentfiles[len] = '\0';
1299 /****************************************************************************
1300 ****************************************************************************/
1302 static WERROR cmd_spoolss_addprinterdriver(struct rpc_pipe_client *cli,
1303 TALLOC_CTX *mem_ctx,
1304 int argc, const char **argv)
1308 PRINTER_DRIVER_CTR ctr;
1309 DRIVER_INFO_3 info3;
1311 fstring driver_name;
1314 /* parse the command arguments */
1315 if (argc != 3 && argc != 4)
1317 printf ("Usage: %s <Environment> \\\n", argv[0]);
1318 printf ("\t<Long Printer Name>:<Driver File Name>:<Data File Name>:\\\n");
1319 printf ("\t<Config File Name>:<Help File Name>:<Language Monitor Name>:\\\n");
1320 printf ("\t<Default Data Type>:<Comma Separated list of Files> \\\n");
1321 printf ("\t[version]\n");
1326 /* Fill in the DRIVER_INFO_3 struct */
1328 if (!(arch = cmd_spoolss_get_short_archi(argv[1])))
1330 printf ("Error Unknown architechture [%s]\n", argv[1]);
1331 return WERR_INVALID_PARAM;
1334 set_drv_info_3_env(&info3, arch);
1336 driver_args = talloc_strdup( mem_ctx, argv[2] );
1337 if (!init_drv_info_3_members(mem_ctx, &info3, driver_args ))
1339 printf ("Error Invalid parameter list - %s.\n", argv[2]);
1340 return WERR_INVALID_PARAM;
1343 /* if printer driver version specified, override the default version
1344 * used by the architecture. This allows installation of Windows
1345 * 2000 (version 3) printer drivers. */
1348 info3.version = atoi(argv[3]);
1353 result = rpccli_spoolss_addprinterdriver (cli, mem_ctx, level, &ctr);
1355 if (W_ERROR_IS_OK(result)) {
1356 rpcstr_pull(driver_name, info3.name.buffer,
1357 sizeof(driver_name), -1, STR_TERMINATE);
1358 printf ("Printer Driver %s successfully installed.\n",
1366 /****************************************************************************
1367 ****************************************************************************/
1369 static WERROR cmd_spoolss_addprinterex(struct rpc_pipe_client *cli,
1370 TALLOC_CTX *mem_ctx,
1371 int argc, const char **argv)
1375 PRINTER_INFO_CTR ctr;
1376 PRINTER_INFO_2 info2;
1379 /* parse the command arguments */
1382 printf ("Usage: %s <name> <shared name> <driver> <port>\n", argv[0]);
1386 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
1387 strupper_m(servername);
1389 /* Fill in the DRIVER_INFO_2 struct */
1392 init_unistr( &info2.printername, argv[1]);
1393 init_unistr( &info2.sharename, argv[2]);
1394 init_unistr( &info2.drivername, argv[3]);
1395 init_unistr( &info2.portname, argv[4]);
1396 init_unistr( &info2.comment, "Created by rpcclient");
1397 init_unistr( &info2.printprocessor, "winprint");
1398 init_unistr( &info2.datatype, "RAW");
1399 info2.devmode = NULL;
1400 info2.secdesc = NULL;
1401 info2.attributes = PRINTER_ATTRIBUTE_SHARED;
1403 info2.defaultpriority = 0;
1404 info2.starttime = 0;
1405 info2.untiltime = 0;
1407 /* These three fields must not be used by AddPrinter()
1408 as defined in the MS Platform SDK documentation..
1412 info2.averageppm = 0;
1415 ctr.printers_2 = &info2;
1416 result = rpccli_spoolss_addprinterex (cli, mem_ctx, level, &ctr);
1418 if (W_ERROR_IS_OK(result))
1419 printf ("Printer %s successfully installed.\n", argv[1]);
1424 /****************************************************************************
1425 ****************************************************************************/
1427 static WERROR cmd_spoolss_setdriver(struct rpc_pipe_client *cli,
1428 TALLOC_CTX *mem_ctx,
1429 int argc, const char **argv)
1434 bool opened_hnd = False;
1435 PRINTER_INFO_CTR ctr;
1436 PRINTER_INFO_2 info2;
1441 /* parse the command arguments */
1444 printf ("Usage: %s <printer> <driver>\n", argv[0]);
1448 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
1449 strupper_m(servername);
1450 slprintf(printername, sizeof(printername)-1, "%s\\%s", servername, argv[1]);
1451 fstrcpy(user, cli->auth->user_name);
1453 /* Get a printer handle */
1455 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
1457 servername, user, &pol);
1459 if (!W_ERROR_IS_OK(result))
1464 /* Get printer info */
1466 ZERO_STRUCT (info2);
1467 ctr.printers_2 = &info2;
1469 result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, level, &ctr);
1471 if (!W_ERROR_IS_OK(result)) {
1472 printf ("Unable to retrieve printer information!\n");
1476 /* Set the printer driver */
1478 init_unistr(&ctr.printers_2->drivername, argv[2]);
1480 result = rpccli_spoolss_setprinter(cli, mem_ctx, &pol, level, &ctr, 0);
1482 if (!W_ERROR_IS_OK(result)) {
1483 printf("SetPrinter call failed!\n");
1487 printf("Successfully set %s to driver %s.\n", argv[1], argv[2]);
1493 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
1499 /****************************************************************************
1500 ****************************************************************************/
1502 static WERROR cmd_spoolss_deletedriverex(struct rpc_pipe_client *cli,
1503 TALLOC_CTX *mem_ctx,
1504 int argc, const char **argv)
1506 WERROR result, ret = WERR_UNKNOWN_PRINTER_DRIVER;
1511 const char *arch = NULL;
1513 /* parse the command arguments */
1514 if (argc < 2 || argc > 4) {
1515 printf ("Usage: %s <driver> [arch] [version]\n", argv[0]);
1522 vers = atoi (argv[3]);
1525 /* delete the driver for all architectures */
1526 for (i=0; archi_table[i].long_archi; i++) {
1528 if (arch && !strequal( archi_table[i].long_archi, arch))
1531 if (vers >= 0 && archi_table[i].version != vers)
1534 /* make the call to remove the driver */
1535 result = rpccli_spoolss_deleteprinterdriverex(
1536 cli, mem_ctx, archi_table[i].long_archi, argv[1], archi_table[i].version);
1538 if ( !W_ERROR_IS_OK(result) )
1540 if ( !W_ERROR_EQUAL(result, WERR_UNKNOWN_PRINTER_DRIVER) ) {
1541 printf ("Failed to remove driver %s for arch [%s] (version: %d): %s\n",
1542 argv[1], archi_table[i].long_archi, archi_table[i].version, win_errstr(result));
1547 printf ("Driver %s and files removed for arch [%s] (version: %d).\n", argv[1],
1548 archi_table[i].long_archi, archi_table[i].version);
1557 /****************************************************************************
1558 ****************************************************************************/
1560 static WERROR cmd_spoolss_deletedriver(struct rpc_pipe_client *cli,
1561 TALLOC_CTX *mem_ctx,
1562 int argc, const char **argv)
1564 WERROR result = WERR_OK;
1568 /* parse the command arguments */
1570 printf ("Usage: %s <driver>\n", argv[0]);
1574 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
1575 strupper_m(servername);
1577 /* delete the driver for all architectures */
1578 for (i=0; archi_table[i].long_archi; i++) {
1579 /* make the call to remove the driver */
1580 result = rpccli_spoolss_deleteprinterdriver(
1581 cli, mem_ctx, archi_table[i].long_archi, argv[1]);
1583 if ( !W_ERROR_IS_OK(result) ) {
1584 if ( !W_ERROR_EQUAL(result, WERR_UNKNOWN_PRINTER_DRIVER) ) {
1585 printf ("Failed to remove driver %s for arch [%s] - error 0x%x!\n",
1586 argv[1], archi_table[i].long_archi,
1590 printf ("Driver %s removed for arch [%s].\n", argv[1],
1591 archi_table[i].long_archi);
1598 /****************************************************************************
1599 ****************************************************************************/
1601 static WERROR cmd_spoolss_getprintprocdir(struct rpc_pipe_client *cli,
1602 TALLOC_CTX *mem_ctx,
1603 int argc, const char **argv)
1606 char *servername = NULL, *environment = NULL;
1609 /* parse the command arguments */
1611 printf ("Usage: %s [environment]\n", argv[0]);
1615 if (asprintf(&servername, "\\\\%s", cli->desthost) < 0)
1617 strupper_m(servername);
1619 if (asprintf(&environment, "%s", (argc == 2) ? argv[1] :
1620 PRINTER_DRIVER_ARCHITECTURE) < 0) {
1621 SAFE_FREE(servername);
1625 result = rpccli_spoolss_getprintprocessordirectory(
1626 cli, mem_ctx, servername, environment, procdir);
1628 if (W_ERROR_IS_OK(result))
1629 printf("%s\n", procdir);
1631 SAFE_FREE(servername);
1632 SAFE_FREE(environment);
1637 /****************************************************************************
1638 ****************************************************************************/
1640 static WERROR cmd_spoolss_addform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1641 int argc, const char **argv)
1646 char *servername = NULL, *printername = NULL;
1647 bool got_handle = False;
1648 union spoolss_AddFormInfo info;
1649 struct spoolss_AddFormInfo1 info1;
1651 /* Parse the command arguments */
1654 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1658 /* Get a printer handle */
1660 if (asprintf(&servername, "\\\\%s", cli->desthost) == -1) {
1663 strupper_m(servername);
1664 if (asprintf(&printername, "%s\\%s", servername, argv[1]) == -1) {
1665 SAFE_FREE(servername);
1669 werror = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
1671 servername, cli->auth->user_name,
1674 if (!W_ERROR_IS_OK(werror))
1679 /* Dummy up some values for the form data */
1681 info1.flags = FORM_USER;
1682 info1.form_name = argv[2];
1683 info1.size.width = 100;
1684 info1.size.height = 100;
1685 info1.area.left = 0;
1686 info1.area.top = 10;
1687 info1.area.right = 20;
1688 info1.area.bottom = 30;
1690 info.info1 = &info1;
1695 status = rpccli_spoolss_AddForm(cli, mem_ctx,
1703 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
1705 SAFE_FREE(servername);
1706 SAFE_FREE(printername);
1711 /****************************************************************************
1712 ****************************************************************************/
1714 static WERROR cmd_spoolss_setform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1715 int argc, const char **argv)
1720 char *servername = NULL, *printername = NULL;
1721 bool got_handle = False;
1722 union spoolss_AddFormInfo info;
1723 struct spoolss_AddFormInfo1 info1;
1725 /* Parse the command arguments */
1728 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1732 /* Get a printer handle */
1734 if (asprintf(&servername, "\\\\%s", cli->desthost)) {
1737 strupper_m(servername);
1738 if (asprintf(&printername, "%s\\%s", servername, argv[1]) == -1) {
1739 SAFE_FREE(servername);
1743 werror = rpccli_spoolss_open_printer_ex(
1744 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1745 servername, cli->auth->user_name, &handle);
1747 if (!W_ERROR_IS_OK(werror))
1752 /* Dummy up some values for the form data */
1754 info1.flags = FORM_PRINTER;
1755 info1.size.width = 100;
1756 info1.size.height = 100;
1757 info1.area.left = 0;
1758 info1.area.top = 1000;
1759 info1.area.right = 2000;
1760 info1.area.bottom = 3000;
1761 info1.form_name = argv[2];
1763 info.info1 = &info1;
1767 status = rpccli_spoolss_SetForm(cli, mem_ctx,
1776 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
1778 SAFE_FREE(servername);
1779 SAFE_FREE(printername);
1784 /****************************************************************************
1785 ****************************************************************************/
1787 static const char *get_form_flag(int form_flag)
1789 switch (form_flag) {
1793 return "FORM_BUILTIN";
1795 return "FORM_PRINTER";
1801 /****************************************************************************
1802 ****************************************************************************/
1804 static void display_form(FORM_1 *form)
1806 fstring form_name = "";
1808 if (form->name.buffer)
1809 rpcstr_pull(form_name, form->name.buffer,
1810 sizeof(form_name), -1, STR_TERMINATE);
1813 "\tflag: %s (%d)\n" \
1814 "\twidth: %d, length: %d\n" \
1815 "\tleft: %d, right: %d, top: %d, bottom: %d\n\n",
1816 form_name, get_form_flag(form->flag), form->flag,
1817 form->width, form->length,
1818 form->left, form->right,
1819 form->top, form->bottom);
1822 /****************************************************************************
1823 ****************************************************************************/
1825 static WERROR cmd_spoolss_getform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1826 int argc, const char **argv)
1830 char *servername = NULL, *printername = NULL;
1832 bool got_handle = False;
1834 /* Parse the command arguments */
1837 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1841 /* Get a printer handle */
1843 if (asprintf(&servername, "\\\\%s", cli->desthost) == -1) {
1846 strupper_m(servername);
1847 if (asprintf(&printername, "%s\\%s", servername, argv[1]) == -1) {
1848 SAFE_FREE(servername);
1852 werror = rpccli_spoolss_open_printer_ex(
1853 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1854 servername, cli->auth->user_name, &handle);
1856 if (!W_ERROR_IS_OK(werror))
1863 werror = rpccli_spoolss_getform(cli, mem_ctx, &handle, argv[2], 1, &form);
1865 if (!W_ERROR_IS_OK(werror))
1868 display_form(&form);
1872 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
1874 SAFE_FREE(servername);
1875 SAFE_FREE(printername);
1880 /****************************************************************************
1881 ****************************************************************************/
1883 static WERROR cmd_spoolss_deleteform(struct rpc_pipe_client *cli,
1884 TALLOC_CTX *mem_ctx, int argc,
1890 char *servername = NULL, *printername = NULL;
1891 bool got_handle = False;
1893 /* Parse the command arguments */
1896 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1900 /* Get a printer handle */
1902 if (asprintf(&servername, "\\\\%s", cli->desthost) == -1) {
1905 strupper_m(servername);
1906 if (asprintf(&printername, "%s\\%s", servername, argv[1]) == -1) {
1907 SAFE_FREE(servername);
1911 werror = rpccli_spoolss_open_printer_ex(
1912 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1913 servername, cli->auth->user_name, &handle);
1915 if (!W_ERROR_IS_OK(werror))
1920 /* Delete the form */
1922 status = rpccli_spoolss_DeleteForm(cli, mem_ctx,
1926 if (!NT_STATUS_IS_OK(status)) {
1927 return ntstatus_to_werror(status);
1932 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
1934 SAFE_FREE(servername);
1935 SAFE_FREE(printername);
1940 /****************************************************************************
1941 ****************************************************************************/
1943 static WERROR cmd_spoolss_enum_forms(struct rpc_pipe_client *cli,
1944 TALLOC_CTX *mem_ctx, int argc,
1949 char *servername = NULL, *printername = NULL;
1950 bool got_handle = False;
1951 uint32 num_forms, level = 1, i;
1954 /* Parse the command arguments */
1957 printf ("Usage: %s <printer>\n", argv[0]);
1961 /* Get a printer handle */
1963 if (asprintf(&servername, "\\\\%s", cli->desthost) == -1) {
1966 strupper_m(servername);
1967 if (asprintf(&printername, "%s\\%s", servername, argv[1]) == -1) {
1968 SAFE_FREE(servername);
1972 werror = rpccli_spoolss_open_printer_ex(
1973 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1974 servername, cli->auth->user_name, &handle);
1976 if (!W_ERROR_IS_OK(werror))
1981 /* Enumerate forms */
1983 werror = rpccli_spoolss_enumforms(cli, mem_ctx, &handle, level, &num_forms, &forms);
1985 if (!W_ERROR_IS_OK(werror))
1988 /* Display output */
1990 for (i = 0; i < num_forms; i++) {
1992 display_form(&forms[i]);
1998 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
2000 SAFE_FREE(servername);
2001 SAFE_FREE(printername);
2006 /****************************************************************************
2007 ****************************************************************************/
2009 static WERROR cmd_spoolss_setprinterdata(struct rpc_pipe_client *cli,
2010 TALLOC_CTX *mem_ctx,
2011 int argc, const char **argv)
2014 fstring servername, printername, user;
2016 bool opened_hnd = False;
2017 PRINTER_INFO_CTR ctr;
2018 PRINTER_INFO_0 info;
2019 REGISTRY_VALUE value;
2020 TALLOC_CTX *tmp_ctx = talloc_stackframe();
2022 /* parse the command arguments */
2024 printf ("Usage: %s <printer> <string|binary|dword|multistring>"
2025 " <value> <data>\n",
2027 result = WERR_INVALID_PARAM;
2031 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
2032 strupper_m(servername);
2033 slprintf(printername, sizeof(servername)-1, "%s\\%s", servername, argv[1]);
2034 fstrcpy(user, cli->auth->user_name);
2036 value.type = REG_NONE;
2038 if (strequal(argv[2], "string")) {
2039 value.type = REG_SZ;
2042 if (strequal(argv[2], "binary")) {
2043 value.type = REG_BINARY;
2046 if (strequal(argv[2], "dword")) {
2047 value.type = REG_DWORD;
2050 if (strequal(argv[2], "multistring")) {
2051 value.type = REG_MULTI_SZ;
2054 if (value.type == REG_NONE) {
2055 printf("Unknown data type: %s\n", argv[2]);
2056 result = WERR_INVALID_PARAM;
2060 /* get a printer handle */
2061 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
2062 MAXIMUM_ALLOWED_ACCESS, servername,
2064 if (!W_ERROR_IS_OK(result))
2069 ctr.printers_0 = &info;
2071 result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, 0, &ctr);
2073 if (!W_ERROR_IS_OK(result))
2076 printf("%s\n", current_timestring(tmp_ctx, True));
2077 printf("\tchange_id (before set)\t:[0x%x]\n", info.change_id);
2079 /* Set the printer data */
2081 fstrcpy(value.valuename, argv[3]);
2083 switch (value.type) {
2086 init_unistr2(&data, argv[4], UNI_STR_TERMINATE);
2087 value.size = data.uni_str_len * 2;
2089 value.data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, data.buffer,
2092 value.data_p = NULL;
2097 uint32 data = strtoul(argv[4], NULL, 10);
2098 value.size = sizeof(data);
2100 value.data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, &data,
2103 value.data_p = NULL;
2108 DATA_BLOB data = strhex_to_data_blob(mem_ctx, argv[4]);
2109 value.data_p = data.data;
2110 value.size = data.length;
2113 case REG_MULTI_SZ: {
2118 for (i=4; i<argc; i++) {
2119 if (strcmp(argv[i], "NULL") == 0) {
2122 len += strlen(argv[i])+1;
2126 value.data_p = TALLOC_ARRAY(mem_ctx, unsigned char, value.size);
2127 if (value.data_p == NULL) {
2128 result = WERR_NOMEM;
2132 p = (char *)value.data_p;
2134 for (i=4; i<argc; i++) {
2135 size_t l = (strlen(argv[i])+1)*2;
2136 rpcstr_push(p, argv[i], len, STR_TERMINATE);
2140 SMB_ASSERT(len == 0);
2144 printf("Unknown data type: %s\n", argv[2]);
2145 result = WERR_INVALID_PARAM;
2149 result = rpccli_spoolss_setprinterdata(cli, mem_ctx, &pol, &value);
2151 if (!W_ERROR_IS_OK(result)) {
2152 printf ("Unable to set [%s=%s]!\n", argv[3], argv[4]);
2155 printf("\tSetPrinterData succeeded [%s: %s]\n", argv[3], argv[4]);
2157 result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, 0, &ctr);
2159 if (!W_ERROR_IS_OK(result))
2162 printf("%s\n", current_timestring(tmp_ctx, True));
2163 printf("\tchange_id (after set)\t:[0x%x]\n", info.change_id);
2167 TALLOC_FREE(tmp_ctx);
2169 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
2174 /****************************************************************************
2175 ****************************************************************************/
2177 static void display_job_info_1(JOB_INFO_1 *job)
2179 fstring username = "", document = "", text_status = "";
2181 rpcstr_pull(username, job->username.buffer,
2182 sizeof(username), -1, STR_TERMINATE);
2184 rpcstr_pull(document, job->document.buffer,
2185 sizeof(document), -1, STR_TERMINATE);
2187 rpcstr_pull(text_status, job->text_status.buffer,
2188 sizeof(text_status), -1, STR_TERMINATE);
2190 printf("%d: jobid[%d]: %s %s %s %d/%d pages\n", job->position, job->jobid,
2191 username, document, text_status, job->pagesprinted,
2195 /****************************************************************************
2196 ****************************************************************************/
2198 static void display_job_info_2(JOB_INFO_2 *job)
2200 fstring username = "", document = "", text_status = "";
2202 rpcstr_pull(username, job->username.buffer,
2203 sizeof(username), -1, STR_TERMINATE);
2205 rpcstr_pull(document, job->document.buffer,
2206 sizeof(document), -1, STR_TERMINATE);
2208 rpcstr_pull(text_status, job->text_status.buffer,
2209 sizeof(text_status), -1, STR_TERMINATE);
2211 printf("%d: jobid[%d]: %s %s %s %d/%d pages, %d bytes\n", job->position, job->jobid,
2212 username, document, text_status, job->pagesprinted,
2213 job->totalpages, job->size);
2216 /****************************************************************************
2217 ****************************************************************************/
2219 static WERROR cmd_spoolss_enum_jobs(struct rpc_pipe_client *cli,
2220 TALLOC_CTX *mem_ctx, int argc,
2224 uint32 level = 1, num_jobs, i;
2225 bool got_hnd = False;
2226 char *printername = NULL;
2227 fstring servername, user;
2231 if (argc < 2 || argc > 3) {
2232 printf("Usage: %s printername [level]\n", argv[0]);
2237 level = atoi(argv[2]);
2239 /* Open printer handle */
2241 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
2242 strupper_m(servername);
2243 fstrcpy(user, cli->auth->user_name);
2244 printername = talloc_asprintf(mem_ctx, "\\\\%s\\", cli->desthost);
2248 strupper_m(printername);
2249 printername = talloc_asprintf_append(printername, "%s", argv[1]);
2254 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
2255 "", MAXIMUM_ALLOWED_ACCESS,
2256 servername, user, &hnd);
2258 if (!W_ERROR_IS_OK(result))
2263 /* Enumerate ports */
2265 result = rpccli_spoolss_enumjobs(cli, mem_ctx, &hnd, level, 0, 1000,
2268 if (!W_ERROR_IS_OK(result))
2271 for (i = 0; i < num_jobs; i++) {
2274 display_job_info_1(&ctr.job.job_info_1[i]);
2277 display_job_info_2(&ctr.job.job_info_2[i]);
2280 d_printf("unknown info level %d\n", level);
2287 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2292 /****************************************************************************
2293 ****************************************************************************/
2295 static WERROR cmd_spoolss_enum_data( struct rpc_pipe_client *cli,
2296 TALLOC_CTX *mem_ctx, int argc,
2300 uint32 i=0, val_needed, data_needed;
2301 bool got_hnd = False;
2302 char *printername = NULL;
2303 fstring servername, user;
2307 printf("Usage: %s printername\n", argv[0]);
2311 /* Open printer handle */
2313 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
2314 strupper_m(servername);
2315 fstrcpy(user, cli->auth->user_name);
2316 printername = talloc_asprintf(mem_ctx, "\\\\%s\\", cli->desthost);
2320 strupper_m(printername);
2321 printername = talloc_asprintf_append(printername, "%s", argv[1]);
2326 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
2327 "", MAXIMUM_ALLOWED_ACCESS,
2328 servername, user, &hnd);
2330 if (!W_ERROR_IS_OK(result))
2335 /* Enumerate data */
2337 result = rpccli_spoolss_enumprinterdata(cli, mem_ctx, &hnd, i, 0, 0,
2338 &val_needed, &data_needed,
2340 while (W_ERROR_IS_OK(result)) {
2341 REGISTRY_VALUE value;
2342 result = rpccli_spoolss_enumprinterdata(
2343 cli, mem_ctx, &hnd, i++, val_needed,
2344 data_needed, 0, 0, &value);
2345 if (W_ERROR_IS_OK(result))
2346 display_reg_value(value);
2348 if (W_ERROR_V(result) == ERRnomoreitems)
2349 result = W_ERROR(ERRsuccess);
2353 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2358 /****************************************************************************
2359 ****************************************************************************/
2361 static WERROR cmd_spoolss_enum_data_ex( struct rpc_pipe_client *cli,
2362 TALLOC_CTX *mem_ctx, int argc,
2367 bool got_hnd = False;
2368 char *printername = NULL;
2369 fstring servername, user;
2370 const char *keyname = NULL;
2372 REGVAL_CTR *ctr = NULL;
2375 printf("Usage: %s printername <keyname>\n", argv[0]);
2381 /* Open printer handle */
2383 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
2384 strupper_m(servername);
2385 fstrcpy(user, cli->auth->user_name);
2387 printername = talloc_asprintf(mem_ctx, "\\\\%s\\", cli->desthost);
2391 strupper_m(printername);
2392 printername = talloc_asprintf_append(printername, "%s", argv[1]);
2397 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
2398 "", MAXIMUM_ALLOWED_ACCESS,
2399 servername, user, &hnd);
2401 if (!W_ERROR_IS_OK(result))
2406 /* Enumerate subkeys */
2408 if ( !(ctr = TALLOC_ZERO_P( mem_ctx, REGVAL_CTR )) )
2411 result = rpccli_spoolss_enumprinterdataex(cli, mem_ctx, &hnd, keyname, ctr);
2413 if (!W_ERROR_IS_OK(result))
2416 for (i=0; i < ctr->num_values; i++) {
2417 display_reg_value(*(ctr->values[i]));
2424 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2429 /****************************************************************************
2430 ****************************************************************************/
2432 static WERROR cmd_spoolss_enum_printerkey( struct rpc_pipe_client *cli,
2433 TALLOC_CTX *mem_ctx, int argc,
2437 bool got_hnd = False;
2438 char *printername = NULL;
2439 fstring servername, user;
2440 const char *keyname = NULL;
2442 uint16 *keylist = NULL, *curkey;
2444 if (argc < 2 || argc > 3) {
2445 printf("Usage: %s printername [keyname]\n", argv[0]);
2454 /* Open printer handle */
2456 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
2457 strupper_m(servername);
2458 fstrcpy(user, cli->auth->user_name);
2460 printername = talloc_asprintf(mem_ctx, "\\\\%s\\", cli->desthost);
2464 strupper_m(printername);
2465 printername = talloc_asprintf_append(printername, "%s", argv[1]);
2471 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
2472 "", MAXIMUM_ALLOWED_ACCESS,
2473 servername, user, &hnd);
2475 if (!W_ERROR_IS_OK(result))
2480 /* Enumerate subkeys */
2482 result = rpccli_spoolss_enumprinterkey(cli, mem_ctx, &hnd, keyname, &keylist, NULL);
2484 if (!W_ERROR_IS_OK(result))
2488 while (*curkey != 0) {
2489 char *subkey = NULL;
2490 rpcstr_pull_talloc(mem_ctx, &subkey, curkey, -1,
2495 printf("%s\n", subkey);
2496 curkey += strlen(subkey) + 1;
2504 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2509 /****************************************************************************
2510 ****************************************************************************/
2512 static WERROR cmd_spoolss_rffpcnex(struct rpc_pipe_client *cli,
2513 TALLOC_CTX *mem_ctx, int argc,
2516 fstring servername, printername;
2518 bool got_hnd = False;
2520 SPOOL_NOTIFY_OPTION option;
2523 printf("Usage: %s printername\n", argv[0]);
2530 slprintf(servername, sizeof(servername) - 1, "\\\\%s", cli->desthost);
2531 strupper_m(servername);
2533 slprintf(printername, sizeof(printername) - 1, "\\\\%s\\%s",
2534 cli->desthost, argv[1]);
2535 strupper_m(printername);
2537 result = rpccli_spoolss_open_printer_ex(
2538 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
2539 servername, cli->auth->user_name, &hnd);
2541 if (!W_ERROR_IS_OK(result)) {
2542 printf("Error opening %s\n", argv[1]);
2548 /* Create spool options */
2550 ZERO_STRUCT(option);
2553 option.option_type_ptr = 1;
2554 option.count = option.ctr.count = 2;
2556 option.ctr.type = TALLOC_ARRAY(mem_ctx, SPOOL_NOTIFY_OPTION_TYPE, 2);
2557 if (option.ctr.type == NULL) {
2558 result = WERR_NOMEM;
2562 ZERO_STRUCT(option.ctr.type[0]);
2563 option.ctr.type[0].type = PRINTER_NOTIFY_TYPE;
2564 option.ctr.type[0].count = option.ctr.type[0].count2 = 1;
2565 option.ctr.type[0].fields_ptr = 1;
2566 option.ctr.type[0].fields[0] = PRINTER_NOTIFY_SERVER_NAME;
2568 ZERO_STRUCT(option.ctr.type[1]);
2569 option.ctr.type[1].type = JOB_NOTIFY_TYPE;
2570 option.ctr.type[1].count = option.ctr.type[1].count2 = 1;
2571 option.ctr.type[1].fields_ptr = 1;
2572 option.ctr.type[1].fields[0] = JOB_NOTIFY_PRINTER_NAME;
2576 slprintf(servername, sizeof(servername) - 1, "\\\\%s", myhostname());
2577 strupper_m(servername);
2579 result = rpccli_spoolss_rffpcnex(
2580 cli, mem_ctx, &hnd, 0, 0, servername, 123, &option);
2582 if (!W_ERROR_IS_OK(result)) {
2583 printf("Error rffpcnex %s\n", argv[1]);
2589 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2594 /****************************************************************************
2595 ****************************************************************************/
2597 static bool compare_printer( struct rpc_pipe_client *cli1, POLICY_HND *hnd1,
2598 struct rpc_pipe_client *cli2, POLICY_HND *hnd2 )
2600 PRINTER_INFO_CTR ctr1, ctr2;
2602 TALLOC_CTX *mem_ctx = talloc_init("compare_printer");
2604 printf("Retrieving printer propertiesfor %s...", cli1->desthost);
2605 werror = rpccli_spoolss_getprinter( cli1, mem_ctx, hnd1, 2, &ctr1);
2606 if ( !W_ERROR_IS_OK(werror) ) {
2607 printf("failed (%s)\n", win_errstr(werror));
2608 talloc_destroy(mem_ctx);
2613 printf("Retrieving printer properties for %s...", cli2->desthost);
2614 werror = rpccli_spoolss_getprinter( cli2, mem_ctx, hnd2, 2, &ctr2);
2615 if ( !W_ERROR_IS_OK(werror) ) {
2616 printf("failed (%s)\n", win_errstr(werror));
2617 talloc_destroy(mem_ctx);
2622 talloc_destroy(mem_ctx);
2627 /****************************************************************************
2628 ****************************************************************************/
2630 static bool compare_printer_secdesc( struct rpc_pipe_client *cli1, POLICY_HND *hnd1,
2631 struct rpc_pipe_client *cli2, POLICY_HND *hnd2 )
2633 PRINTER_INFO_CTR ctr1, ctr2;
2635 TALLOC_CTX *mem_ctx = talloc_init("compare_printer_secdesc");
2636 SEC_DESC *sd1, *sd2;
2640 printf("Retrieving printer security for %s...", cli1->desthost);
2641 werror = rpccli_spoolss_getprinter( cli1, mem_ctx, hnd1, 3, &ctr1);
2642 if ( !W_ERROR_IS_OK(werror) ) {
2643 printf("failed (%s)\n", win_errstr(werror));
2649 printf("Retrieving printer security for %s...", cli2->desthost);
2650 werror = rpccli_spoolss_getprinter( cli2, mem_ctx, hnd2, 3, &ctr2);
2651 if ( !W_ERROR_IS_OK(werror) ) {
2652 printf("failed (%s)\n", win_errstr(werror));
2661 if ( (ctr1.printers_3 != ctr2.printers_3) && (!ctr1.printers_3 || !ctr2.printers_3) ) {
2662 printf("NULL PRINTER_INFO_3!\n");
2667 sd1 = ctr1.printers_3->secdesc;
2668 sd2 = ctr2.printers_3->secdesc;
2670 if ( (sd1 != sd2) && ( !sd1 || !sd2 ) ) {
2671 printf("NULL secdesc!\n");
2676 if (!sec_desc_equal( sd1, sd2 ) ) {
2677 printf("Security Descriptors *not* equal!\n");
2682 printf("Security descriptors match\n");
2685 talloc_destroy(mem_ctx);
2690 /****************************************************************************
2691 ****************************************************************************/
2693 extern struct user_auth_info *rpcclient_auth_info;
2695 static WERROR cmd_spoolss_printercmp(struct rpc_pipe_client *cli,
2696 TALLOC_CTX *mem_ctx, int argc,
2699 fstring printername, servername1, servername2;
2700 char *printername_path = NULL;
2701 struct cli_state *cli_server1 = rpc_pipe_np_smb_conn(cli);
2702 struct cli_state *cli_server2 = NULL;
2703 struct rpc_pipe_client *cli2 = NULL;
2704 POLICY_HND hPrinter1, hPrinter2;
2709 printf("Usage: %s <printer> <server>\n", argv[0]);
2713 fstrcpy( printername, argv[1] );
2715 fstrcpy( servername1, cli->desthost );
2716 fstrcpy( servername2, argv[2] );
2717 strupper_m( servername1 );
2718 strupper_m( servername2 );
2720 /* first get the connection to the remote server */
2722 nt_status = cli_full_connection(&cli_server2, global_myname(), servername2,
2725 get_cmdline_auth_info_username(rpcclient_auth_info),
2727 get_cmdline_auth_info_password(rpcclient_auth_info),
2728 get_cmdline_auth_info_use_kerberos(rpcclient_auth_info) ? CLI_FULL_CONNECTION_USE_KERBEROS : 0,
2729 get_cmdline_auth_info_signing_state(rpcclient_auth_info), NULL);
2731 if ( !NT_STATUS_IS_OK(nt_status) )
2732 return WERR_GENERAL_FAILURE;
2734 nt_status = cli_rpc_pipe_open_noauth(cli_server2, &syntax_spoolss,
2736 if (!NT_STATUS_IS_OK(nt_status)) {
2737 printf("failed to open spoolss pipe on server %s (%s)\n",
2738 servername2, nt_errstr(nt_status));
2739 return WERR_GENERAL_FAILURE;
2742 /* now open up both printers */
2744 printername_path = talloc_asprintf(mem_ctx,
2748 if (!printername_path) {
2751 printf("Opening %s...", printername_path);
2752 werror = rpccli_spoolss_open_printer_ex( cli, mem_ctx, printername_path,
2753 "", PRINTER_ALL_ACCESS, servername1, cli_server1->user_name, &hPrinter1);
2754 if ( !W_ERROR_IS_OK(werror) ) {
2755 printf("failed (%s)\n", win_errstr(werror));
2760 printername_path = talloc_asprintf(mem_ctx,
2764 if (!printername_path) {
2767 printf("Opening %s...", printername_path);
2768 werror = rpccli_spoolss_open_printer_ex( cli2, mem_ctx, printername_path,
2769 "", PRINTER_ALL_ACCESS, servername2, cli_server2->user_name, &hPrinter2 );
2770 if ( !W_ERROR_IS_OK(werror) ) {
2771 printf("failed (%s)\n", win_errstr(werror));
2776 compare_printer( cli, &hPrinter1, cli2, &hPrinter2 );
2777 compare_printer_secdesc( cli, &hPrinter1, cli2, &hPrinter2 );
2779 compare_printerdata( cli_server1, &hPrinter1, cli_server2, &hPrinter2 );
2786 printf("Closing printers...");
2787 rpccli_spoolss_ClosePrinter( cli, mem_ctx, &hPrinter1, NULL );
2788 rpccli_spoolss_ClosePrinter( cli2, mem_ctx, &hPrinter2, NULL );
2791 /* close the second remote connection */
2793 cli_shutdown( cli_server2 );
2797 /* List of commands exported by this module */
2798 struct cmd_set spoolss_commands[] = {
2802 { "adddriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterdriver, &syntax_spoolss, NULL, "Add a print driver", "" },
2803 { "addprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterex, &syntax_spoolss, NULL, "Add a printer", "" },
2804 { "deldriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deletedriver, &syntax_spoolss, NULL, "Delete a printer driver", "" },
2805 { "deldriverex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deletedriverex, &syntax_spoolss, NULL, "Delete a printer driver with files", "" },
2806 { "enumdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data, &syntax_spoolss, NULL, "Enumerate printer data", "" },
2807 { "enumdataex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data_ex, &syntax_spoolss, NULL, "Enumerate printer data for a key", "" },
2808 { "enumkey", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printerkey, &syntax_spoolss, NULL, "Enumerate printer keys", "" },
2809 { "enumjobs", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_jobs, &syntax_spoolss, NULL, "Enumerate print jobs", "" },
2810 { "enumports", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_ports, &syntax_spoolss, NULL, "Enumerate printer ports", "" },
2811 { "enumdrivers", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_drivers, &syntax_spoolss, NULL, "Enumerate installed printer drivers", "" },
2812 { "enumprinters", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printers, &syntax_spoolss, NULL, "Enumerate printers", "" },
2813 { "getdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdata, &syntax_spoolss, NULL, "Get print driver data", "" },
2814 { "getdataex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdataex, &syntax_spoolss, NULL, "Get printer driver data with keyname", ""},
2815 { "getdriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriver, &syntax_spoolss, NULL, "Get print driver information", "" },
2816 { "getdriverdir", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriverdir, &syntax_spoolss, NULL, "Get print driver upload directory", "" },
2817 { "getprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinter, &syntax_spoolss, NULL, "Get printer info", "" },
2818 { "openprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_open_printer_ex, &syntax_spoolss, NULL, "Open printer handle", "" },
2819 { "setdriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setdriver, &syntax_spoolss, NULL, "Set printer driver", "" },
2820 { "getprintprocdir", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprintprocdir, &syntax_spoolss, NULL, "Get print processor directory", "" },
2821 { "addform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addform, &syntax_spoolss, NULL, "Add form", "" },
2822 { "setform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setform, &syntax_spoolss, NULL, "Set form", "" },
2823 { "getform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getform, &syntax_spoolss, NULL, "Get form", "" },
2824 { "deleteform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deleteform, &syntax_spoolss, NULL, "Delete form", "" },
2825 { "enumforms", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_forms, &syntax_spoolss, NULL, "Enumerate forms", "" },
2826 { "setprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinter, &syntax_spoolss, NULL, "Set printer comment", "" },
2827 { "setprintername", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprintername, &syntax_spoolss, NULL, "Set printername", "" },
2828 { "setprinterdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinterdata, &syntax_spoolss, NULL, "Set REG_SZ printer data", "" },
2829 { "rffpcnex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_rffpcnex, &syntax_spoolss, NULL, "Rffpcnex test", "" },
2830 { "printercmp", RPC_RTYPE_WERROR, NULL, cmd_spoolss_printercmp, &syntax_spoolss, NULL, "Printer comparison test", "" },