?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Correctly return NULL from messaging_ctdbd_connection if messaging_init failed
[Samba/gebeck_regimport.git] / source3 / rpcclient / cmd_spoolss.c
blob2a9f2b82bb2c0bf1ba8c7dd2bfa86296736f66c3
1 /*
2 Unix SMB/CIFS implementation.
3 RPC pipe client
4
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
9
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.
14
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.
19
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/>.
22 */
23
24 #include "includes.h"
25 #include "rpcclient.h"
26
27 struct table_node {
28 const char *long_archi;
29 const char *short_archi;
30 int version;
31 };
32
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 */
38
39
40 static const struct table_node archi_table[]= {
41
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 },
50 {NULL, "", -1 }
51 };
52
53 /**
54 * @file
55 *
56 * rpcclient module for SPOOLSS rpc pipe.
57 *
58 * This generally just parses and checks command lines, and then calls
59 * a cli_spoolss function.
60 **/
61
62 /****************************************************************************
63 function to do the mapping between the long architecture name and
64 the short one.
65 ****************************************************************************/
66
67 static const char *cmd_spoolss_get_short_archi(const char *long_archi)
68 {
69 int i=-1;
70
71 DEBUG(107,("Getting architecture dependant directory\n"));
72 do {
73 i++;
74 } while ( (archi_table[i].long_archi!=NULL ) &&
75 StrCaseCmp(long_archi, archi_table[i].long_archi) );
76
77 if (archi_table[i].long_archi==NULL) {
78 DEBUGADD(10,("Unknown architecture [%s] !\n", long_archi));
79 return NULL;
80 }
81
82 /* this might be client code - but shouldn't this be an fstrcpy etc? */
83
84
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));
88
89 return archi_table[i].short_archi;
90 }
91
92 /****************************************************************************
93 ****************************************************************************/
94
95 static WERROR cmd_spoolss_open_printer_ex(struct rpc_pipe_client *cli,
96 TALLOC_CTX *mem_ctx,
97 int argc, const char **argv)
98 {
99 WERROR werror;
100 fstring printername;
101 fstring servername, user;
102 POLICY_HND hnd;
103
104 if (argc != 2) {
105 printf("Usage: %s <printername>\n", argv[0]);
106 return WERR_OK;
107 }
108
109 if (!cli)
110 return WERR_GENERAL_FAILURE;
111
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]);
116
117 /* Open the printer handle */
118
119 werror = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
120 "", PRINTER_ALL_ACCESS,
121 servername, user, &hnd);
122
123 if (W_ERROR_IS_OK(werror)) {
124 printf("Printer %s opened successfully\n", printername);
125 werror = rpccli_spoolss_close_printer(cli, mem_ctx, &hnd);
126
127 if (!W_ERROR_IS_OK(werror)) {
128 printf("Error closing printer handle! (%s)\n",
129 get_dos_error_msg(werror));
130 }
131 }
132
133 return werror;
134 }
135
136
137 /****************************************************************************
138 ****************************************************************************/
139
140 static void display_print_info_0(PRINTER_INFO_0 *i0)
141 {
142 fstring name = "";
143 fstring servername = "";
144
145 if (!i0)
146 return;
147
148 rpcstr_pull(name, i0->printername.buffer, sizeof(name), -1, STR_TERMINATE);
149
150 rpcstr_pull(servername, i0->servername.buffer, sizeof(servername), -1,STR_TERMINATE);
151
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);
156
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);
161
162 printf("\tglobal_counter:[0x%x]\n", i0->global_counter);
163 printf("\ttotal_pages:[0x%x]\n", i0->total_pages);
164
165 printf("\tmajorversion:[0x%x]\n", i0->major_version);
166 printf("\tbuildversion:[0x%x]\n", i0->build_version);
167
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);
191
192 printf("\n");
193 }
194
195 /****************************************************************************
196 ****************************************************************************/
197
198 static void display_print_info_1(PRINTER_INFO_1 *i1)
199 {
200 fstring desc = "";
201 fstring name = "";
202 fstring comm = "";
203
204 rpcstr_pull(desc, i1->description.buffer, sizeof(desc), -1,
205 STR_TERMINATE);
206
207 rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
208 rpcstr_pull(comm, i1->comment.buffer, sizeof(comm), -1, STR_TERMINATE);
209
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);
214
215 printf("\n");
216 }
217
218 /****************************************************************************
219 ****************************************************************************/
220
221 static void display_print_info_2(PRINTER_INFO_2 *i2)
222 {
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 = "";
234
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);
246
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);
266
267 if (i2->secdesc)
268 display_sec_desc(i2->secdesc);
269
270 printf("\n");
271 }
272
273 /****************************************************************************
274 ****************************************************************************/
275
276 static void display_print_info_3(PRINTER_INFO_3 *i3)
277 {
278 display_sec_desc(i3->secdesc);
279
280 printf("\n");
281 }
282
283 /****************************************************************************
284 ****************************************************************************/
285
286 static void display_print_info_7(PRINTER_INFO_7 *i7)
287 {
288 fstring guid = "";
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);
292 }
293
294
295 /****************************************************************************
296 ****************************************************************************/
297
298 static WERROR cmd_spoolss_enum_printers(struct rpc_pipe_client *cli,
299 TALLOC_CTX *mem_ctx,
300 int argc, const char **argv)
301 {
302 WERROR result;
303 uint32 info_level = 1;
304 PRINTER_INFO_CTR ctr;
305 uint32 i = 0, num_printers;
306 fstring name;
307
308 if (argc > 3)
309 {
310 printf("Usage: %s [level] [name]\n", argv[0]);
311 return WERR_OK;
312 }
313
314 if (argc >= 2)
315 info_level = atoi(argv[1]);
316
317 if (argc == 3)
318 fstrcpy(name, argv[2]);
319 else {
320 slprintf(name, sizeof(name)-1, "\\\\%s", cli->desthost);
321 strupper_m(name);
322 }
323
324 ZERO_STRUCT(ctr);
325
326 result = rpccli_spoolss_enum_printers(cli, mem_ctx, name, PRINTER_ENUM_LOCAL,
327 info_level, &num_printers, &ctr);
328
329 if (W_ERROR_IS_OK(result)) {
330
331 if (!num_printers) {
332 printf ("No printers returned.\n");
333 goto done;
334 }
335
336 for (i = 0; i < num_printers; i++) {
337 switch(info_level) {
338 case 0:
339 display_print_info_0(&ctr.printers_0[i]);
340 break;
341 case 1:
342 display_print_info_1(&ctr.printers_1[i]);
343 break;
344 case 2:
345 display_print_info_2(&ctr.printers_2[i]);
346 break;
347 case 3:
348 display_print_info_3(&ctr.printers_3[i]);
349 break;
350 default:
351 printf("unknown info level %d\n", info_level);
352 goto done;
353 }
354 }
355 }
356 done:
357
358 return result;
359 }
360
361 /****************************************************************************
362 ****************************************************************************/
363
364 static void display_port_info_1(PORT_INFO_1 *i1)
365 {
366 fstring buffer;
367
368 rpcstr_pull(buffer, i1->port_name.buffer, sizeof(buffer), -1, STR_TERMINATE);
369 printf("\tPort Name:\t[%s]\n", buffer);
370 }
371
372 /****************************************************************************
373 ****************************************************************************/
374
375 static void display_port_info_2(PORT_INFO_2 *i2)
376 {
377 fstring buffer;
378
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);
382
383 printf("\tMonitor Name:\t[%s]\n", buffer);
384 rpcstr_pull(buffer, i2->description.buffer, sizeof(buffer), -1, STR_TERMINATE);
385
386 printf("\tDescription:\t[%s]\n", buffer);
387 printf("\tPort Type:\t" );
388 if ( i2->port_type ) {
389 int comma = 0; /* hack */
390 printf( "[" );
391 if ( i2->port_type & PORT_TYPE_READ ) {
392 printf( "Read" );
393 comma = 1;
394 }
395 if ( i2->port_type & PORT_TYPE_WRITE ) {
396 printf( "%sWrite", comma ? ", " : "" );
397 comma = 1;
398 }
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 ? ", " : "" );
403 comma = 1;
404 }
405 if ( i2->port_type & PORT_TYPE_NET_ATTACHED ) {
406 printf( "%sNet-Attached", comma ? ", " : "" );
407 }
408 printf( "]\n" );
409 } else {
410 printf( "[Unset]\n" );
411 }
412 printf("\tReserved:\t[%d]\n", i2->reserved);
413 printf("\n");
414 }
415
416 /****************************************************************************
417 ****************************************************************************/
418
419 static WERROR cmd_spoolss_enum_ports(struct rpc_pipe_client *cli,
420 TALLOC_CTX *mem_ctx, int argc,
421 const char **argv)
422 {
423 WERROR result;
424 uint32 info_level = 1;
425 PORT_INFO_CTR ctr;
426 uint32 returned;
427
428 if (argc > 2) {
429 printf("Usage: %s [level]\n", argv[0]);
430 return WERR_OK;
431 }
432
433 if (argc == 2)
434 info_level = atoi(argv[1]);
435
436 /* Enumerate ports */
437
438 ZERO_STRUCT(ctr);
439
440 result = rpccli_spoolss_enum_ports(cli, mem_ctx, info_level, &returned, &ctr);
441
442 if (W_ERROR_IS_OK(result)) {
443 int i;
444
445 for (i = 0; i < returned; i++) {
446 switch (info_level) {
447 case 1:
448 display_port_info_1(&ctr.port.info_1[i]);
449 break;
450 case 2:
451 display_port_info_2(&ctr.port.info_2[i]);
452 break;
453 default:
454 printf("unknown info level %d\n", info_level);
455 break;
456 }
457 }
458 }
459
460 return result;
461 }
462
463 /****************************************************************************
464 ****************************************************************************/
465
466 static WERROR cmd_spoolss_setprinter(struct rpc_pipe_client *cli,
467 TALLOC_CTX *mem_ctx,
468 int argc, const char **argv)
469 {
470 POLICY_HND pol;
471 WERROR result;
472 uint32 info_level = 2;
473 bool opened_hnd = False;
474 PRINTER_INFO_CTR ctr;
475 fstring printername,
476 servername,
477 user,
478 comment;
479
480 if (argc == 1 || argc > 3) {
481 printf("Usage: %s printername comment\n", argv[0]);
482
483 return WERR_OK;
484 }
485
486 /* Open a printer handle */
487 if (argc == 3) {
488 fstrcpy(comment, argv[2]);
489 }
490
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);
495
496 /* get a printer handle */
497 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
498 PRINTER_ALL_ACCESS, servername,
499 user, &pol);
500
501 if (!W_ERROR_IS_OK(result))
502 goto done;
503
504 opened_hnd = True;
505
506 /* Get printer info */
507 result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, info_level, &ctr);
508
509 if (!W_ERROR_IS_OK(result))
510 goto done;
511
512
513 /* Modify the comment. */
514 init_unistr(&ctr.printers_2->comment, comment);
515 ctr.printers_2->devmode = NULL;
516 ctr.printers_2->secdesc = NULL;
517
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");
521
522 done:
523 if (opened_hnd)
524 rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
525
526 return result;
527 }
528
529 /****************************************************************************
530 ****************************************************************************/
531
532 static WERROR cmd_spoolss_setprintername(struct rpc_pipe_client *cli,
533 TALLOC_CTX *mem_ctx,
534 int argc, const char **argv)
535 {
536 POLICY_HND pol;
537 WERROR result;
538 uint32 info_level = 2;
539 bool opened_hnd = False;
540 PRINTER_INFO_CTR ctr;
541 fstring printername,
542 servername,
543 user,
544 new_printername;
545
546 if (argc == 1 || argc > 3) {
547 printf("Usage: %s printername new_printername\n", argv[0]);
548
549 return WERR_OK;
550 }
551
552 /* Open a printer handle */
553 if (argc == 3) {
554 fstrcpy(new_printername, argv[2]);
555 }
556
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);
561
562 /* get a printer handle */
563 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
564 PRINTER_ALL_ACCESS, servername,
565 user, &pol);
566
567 if (!W_ERROR_IS_OK(result))
568 goto done;
569
570 opened_hnd = True;
571
572 /* Get printer info */
573 result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, info_level, &ctr);
574
575 if (!W_ERROR_IS_OK(result))
576 goto done;
577
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;
582
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");
586
587 done:
588 if (opened_hnd)
589 rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
590
591 return result;
592 }
593
594 /****************************************************************************
595 ****************************************************************************/
596
597 static WERROR cmd_spoolss_getprinter(struct rpc_pipe_client *cli,
598 TALLOC_CTX *mem_ctx,
599 int argc, const char **argv)
600 {
601 POLICY_HND pol;
602 WERROR result;
603 uint32 info_level = 1;
604 bool opened_hnd = False;
605 PRINTER_INFO_CTR ctr;
606 fstring printername,
607 servername,
608 user;
609
610 if (argc == 1 || argc > 3) {
611 printf("Usage: %s <printername> [level]\n", argv[0]);
612 return WERR_OK;
613 }
614
615 /* Open a printer handle */
616 if (argc == 3) {
617 info_level = atoi(argv[2]);
618 }
619
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);
624
625 /* get a printer handle */
626
627 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
628 "", MAXIMUM_ALLOWED_ACCESS,
629 servername, user, &pol);
630
631 if (!W_ERROR_IS_OK(result))
632 goto done;
633
634 opened_hnd = True;
635
636 /* Get printer info */
637
638 result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, info_level, &ctr);
639
640 if (!W_ERROR_IS_OK(result))
641 goto done;
642
643 /* Display printer info */
644
645 switch (info_level) {
646 case 0:
647 display_print_info_0(ctr.printers_0);
648 break;
649 case 1:
650 display_print_info_1(ctr.printers_1);
651 break;
652 case 2:
653 display_print_info_2(ctr.printers_2);
654 break;
655 case 3:
656 display_print_info_3(ctr.printers_3);
657 break;
658 case 7:
659 display_print_info_7(ctr.printers_7);
660 break;
661 default:
662 printf("unknown info level %d\n", info_level);
663 break;
664 }
665
666 done:
667 if (opened_hnd)
668 rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
669
670 return result;
671 }
672
673 /****************************************************************************
674 ****************************************************************************/
675
676 static void display_reg_value(REGISTRY_VALUE value)
677 {
678 char *text = NULL;
679
680 switch(value.type) {
681 case REG_DWORD:
682 printf("%s: REG_DWORD: 0x%08x\n", value.valuename,
683 *((uint32 *) value.data_p));
684 break;
685 case REG_SZ:
686 rpcstr_pull_talloc(talloc_tos(),
687 &text,
688 value.data_p,
689 value.size,
690 STR_TERMINATE);
691 printf("%s: REG_SZ: %s\n", value.valuename, text ? text : "");
692 break;
693 case REG_BINARY: {
694 char *hex = hex_encode(NULL, value.data_p, value.size);
695 size_t i, len;
696 printf("%s: REG_BINARY:", value.valuename);
697 len = strlen(hex);
698 for (i=0; i<len; i++) {
699 if (hex[i] == '\0') {
700 break;
701 }
702 if (i%40 == 0) {
703 putchar('\n');
704 }
705 putchar(hex[i]);
706 }
707 TALLOC_FREE(hex);
708 putchar('\n');
709 break;
710 }
711 case REG_MULTI_SZ: {
712 uint32 i, num_values;
713 char **values;
714
715 if (!W_ERROR_IS_OK(reg_pull_multi_sz(NULL, value.data_p,
716 value.size, &num_values,
717 &values))) {
718 d_printf("reg_pull_multi_sz failed\n");
719 break;
720 }
721
722 for (i=0; i<num_values; i++) {
723 d_printf("%s\n", values[i]);
724 }
725 TALLOC_FREE(values);
726 break;
727 }
728 default:
729 printf("%s: unknown type %d\n", value.valuename, value.type);
730 }
731
732 }
733
734 /****************************************************************************
735 ****************************************************************************/
736
737 static WERROR cmd_spoolss_getprinterdata(struct rpc_pipe_client *cli,
738 TALLOC_CTX *mem_ctx,
739 int argc, const char **argv)
740 {
741 POLICY_HND pol;
742 WERROR result;
743 bool opened_hnd = False;
744 fstring printername,
745 servername,
746 user;
747 const char *valuename;
748 REGISTRY_VALUE value;
749
750 if (argc != 3) {
751 printf("Usage: %s <printername> <valuename>\n", argv[0]);
752 printf("<printername> of . queries print server\n");
753 return WERR_OK;
754 }
755 valuename = argv[2];
756
757 /* Open a printer handle */
758
759 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
760 strupper_m(servername);
761 if (strncmp(argv[1], ".", sizeof(".")) == 0)
762 fstrcpy(printername, servername);
763 else
764 slprintf(printername, sizeof(servername)-1, "%s\\%s",
765 servername, argv[1]);
766 fstrcpy(user, cli->auth->user_name);
767
768 /* get a printer handle */
769
770 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
771 "", MAXIMUM_ALLOWED_ACCESS,
772 servername, user, &pol);
773
774 if (!W_ERROR_IS_OK(result))
775 goto done;
776
777 opened_hnd = True;
778
779 /* Get printer info */
780
781 result = rpccli_spoolss_getprinterdata(cli, mem_ctx, &pol, valuename, &value);
782
783 if (!W_ERROR_IS_OK(result))
784 goto done;
785
786 /* Display printer data */
787
788 fstrcpy(value.valuename, valuename);
789 display_reg_value(value);
790
791
792 done:
793 if (opened_hnd)
794 rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
795
796 return result;
797 }
798
799 /****************************************************************************
800 ****************************************************************************/
801
802 static WERROR cmd_spoolss_getprinterdataex(struct rpc_pipe_client *cli,
803 TALLOC_CTX *mem_ctx,
804 int argc, const char **argv)
805 {
806 POLICY_HND pol;
807 WERROR result;
808 bool opened_hnd = False;
809 fstring printername,
810 servername,
811 user;
812 const char *valuename, *keyname;
813 REGISTRY_VALUE value;
814
815 if (argc != 4) {
816 printf("Usage: %s <printername> <keyname> <valuename>\n",
817 argv[0]);
818 printf("<printername> of . queries print server\n");
819 return WERR_OK;
820 }
821 valuename = argv[3];
822 keyname = argv[2];
823
824 /* Open a printer handle */
825
826 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
827 strupper_m(servername);
828 if (strncmp(argv[1], ".", sizeof(".")) == 0)
829 fstrcpy(printername, servername);
830 else
831 slprintf(printername, sizeof(printername)-1, "%s\\%s",
832 servername, argv[1]);
833 fstrcpy(user, cli->auth->user_name);
834
835 /* get a printer handle */
836
837 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
838 "", MAXIMUM_ALLOWED_ACCESS,
839 servername, user, &pol);
840
841 if (!W_ERROR_IS_OK(result))
842 goto done;
843
844 opened_hnd = True;
845
846 /* Get printer info */
847
848 result = rpccli_spoolss_getprinterdataex(cli, mem_ctx, &pol, keyname,
849 valuename, &value);
850
851 if (!W_ERROR_IS_OK(result))
852 goto done;
853
854 /* Display printer data */
855
856 fstrcpy(value.valuename, valuename);
857 display_reg_value(value);
858
859
860 done:
861 if (opened_hnd)
862 rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
863
864 return result;
865 }
866
867 /****************************************************************************
868 ****************************************************************************/
869
870 static void display_print_driver_1(DRIVER_INFO_1 *i1)
871 {
872 fstring name;
873 if (i1 == NULL)
874 return;
875
876 rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
877
878 printf ("Printer Driver Info 1:\n");
879 printf ("\tDriver Name: [%s]\n\n", name);
880
881 return;
882 }
883
884 /****************************************************************************
885 ****************************************************************************/
886
887 static void display_print_driver_2(DRIVER_INFO_2 *i1)
888 {
889 fstring name;
890 fstring architecture;
891 fstring driverpath;
892 fstring datafile;
893 fstring configfile;
894 if (i1 == NULL)
895 return;
896
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);
902
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);
910
911 return;
912 }
913
914 /****************************************************************************
915 ****************************************************************************/
916
917 static void display_print_driver_3(DRIVER_INFO_3 *i1)
918 {
919 fstring name = "";
920 fstring architecture = "";
921 fstring driverpath = "";
922 fstring datafile = "";
923 fstring configfile = "";
924 fstring helpfile = "";
925 fstring dependentfiles = "";
926 fstring monitorname = "";
927 fstring defaultdatatype = "";
928
929 int length=0;
930 bool valid = True;
931
932 if (i1 == NULL)
933 return;
934
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);
943
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);
952
953 while (valid)
954 {
955 rpcstr_pull(dependentfiles, i1->dependentfiles+length, sizeof(dependentfiles), -1, STR_TERMINATE);
956
957 length+=strlen(dependentfiles)+1;
958
959 if (strlen(dependentfiles) > 0)
960 {
961 printf ("\tDependentfiles: [%s]\n", dependentfiles);
962 }
963 else
964 {
965 valid = False;
966 }
967 }
968
969 printf ("\n");
970
971 printf ("\tMonitorname: [%s]\n", monitorname);
972 printf ("\tDefaultdatatype: [%s]\n\n", defaultdatatype);
973
974 return;
975 }
976
977 /****************************************************************************
978 ****************************************************************************/
979
980 static WERROR cmd_spoolss_getdriver(struct rpc_pipe_client *cli,
981 TALLOC_CTX *mem_ctx,
982 int argc, const char **argv)
983 {
984 POLICY_HND pol;
985 WERROR werror;
986 uint32 info_level = 3;
987 bool opened_hnd = False;
988 PRINTER_DRIVER_CTR ctr;
989 fstring printername,
990 servername,
991 user;
992 uint32 i;
993 bool success = False;
994
995 if ((argc == 1) || (argc > 3))
996 {
997 printf("Usage: %s <printername> [level]\n", argv[0]);
998 return WERR_OK;
999 }
1000
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]);
1006 if (argc == 3)
1007 info_level = atoi(argv[2]);
1008
1009 /* Open a printer handle */
1010
1011 werror = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
1012 PRINTER_ACCESS_USE,
1013 servername, user, &pol);
1014
1015 if (!W_ERROR_IS_OK(werror)) {
1016 printf("Error opening printer handle for %s!\n", printername);
1017 return werror;
1018 }
1019
1020 opened_hnd = True;
1021
1022 /* loop through and print driver info level for each architecture */
1023
1024 for (i=0; archi_table[i].long_archi!=NULL; i++) {
1025
1026 werror = rpccli_spoolss_getprinterdriver( cli, mem_ctx, &pol, info_level,
1027 archi_table[i].long_archi, archi_table[i].version,
1028 &ctr);
1029
1030 if (!W_ERROR_IS_OK(werror))
1031 continue;
1032
1033 /* need at least one success */
1034
1035 success = True;
1036
1037 printf ("\n[%s]\n", archi_table[i].long_archi);
1038
1039 switch (info_level) {
1040 case 1:
1041 display_print_driver_1 (ctr.info1);
1042 break;
1043 case 2:
1044 display_print_driver_2 (ctr.info2);
1045 break;
1046 case 3:
1047 display_print_driver_3 (ctr.info3);
1048 break;
1049 default:
1050 printf("unknown info level %d\n", info_level);
1051 break;
1052 }
1053 }
1054
1055 /* Cleanup */
1056
1057 if (opened_hnd)
1058 rpccli_spoolss_close_printer (cli, mem_ctx, &pol);
1059
1060 if ( success )
1061 werror = WERR_OK;
1062
1063 return werror;
1064 }
1065
1066 /****************************************************************************
1067 ****************************************************************************/
1068
1069 static WERROR cmd_spoolss_enum_drivers(struct rpc_pipe_client *cli,
1070 TALLOC_CTX *mem_ctx,
1071 int argc, const char **argv)
1072 {
1073 WERROR werror = WERR_OK;
1074 uint32 info_level = 1;
1075 PRINTER_DRIVER_CTR ctr;
1076 uint32 i, j,
1077 returned;
1078
1079 if (argc > 2) {
1080 printf("Usage: enumdrivers [level]\n");
1081 return WERR_OK;
1082 }
1083
1084 if (argc == 2)
1085 info_level = atoi(argv[1]);
1086
1087
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 */
1091
1092 if ( i>0 && strequal(archi_table[i].long_archi, archi_table[i-1].long_archi) )
1093 continue;
1094
1095 werror = rpccli_spoolss_enumprinterdrivers(
1096 cli, mem_ctx, info_level,
1097 archi_table[i].long_archi, &returned, &ctr);
1098
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);
1102 werror = WERR_OK;
1103 continue;
1104 }
1105
1106 if (returned == 0)
1107 continue;
1108
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));
1112 continue;
1113 }
1114
1115 printf ("\n[%s]\n", archi_table[i].long_archi);
1116 switch (info_level)
1117 {
1118
1119 case 1:
1120 for (j=0; j < returned; j++) {
1121 display_print_driver_1 (&ctr.info1[j]);
1122 }
1123 break;
1124 case 2:
1125 for (j=0; j < returned; j++) {
1126 display_print_driver_2 (&ctr.info2[j]);
1127 }
1128 break;
1129 case 3:
1130 for (j=0; j < returned; j++) {
1131 display_print_driver_3 (&ctr.info3[j]);
1132 }
1133 break;
1134 default:
1135 printf("unknown info level %d\n", info_level);
1136 return WERR_UNKNOWN_LEVEL;
1137 }
1138 }
1139
1140 return werror;
1141 }
1142
1143 /****************************************************************************
1144 ****************************************************************************/
1145
1146 static void display_printdriverdir_1(DRIVER_DIRECTORY_1 *i1)
1147 {
1148 fstring name;
1149 if (i1 == NULL)
1150 return;
1151
1152 rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
1153
1154 printf ("\tDirectory Name:[%s]\n", name);
1155 }
1156
1157 /****************************************************************************
1158 ****************************************************************************/
1159
1160 static WERROR cmd_spoolss_getdriverdir(struct rpc_pipe_client *cli,
1161 TALLOC_CTX *mem_ctx,
1162 int argc, const char **argv)
1163 {
1164 WERROR result;
1165 fstring env;
1166 DRIVER_DIRECTORY_CTR ctr;
1167
1168 if (argc > 2) {
1169 printf("Usage: %s [environment]\n", argv[0]);
1170 return WERR_OK;
1171 }
1172
1173 /* Get the arguments need to open the printer handle */
1174
1175 if (argc == 2)
1176 fstrcpy (env, argv[1]);
1177 else
1178 fstrcpy (env, "Windows NT x86");
1179
1180 /* Get the directory. Only use Info level 1 */
1181
1182 result = rpccli_spoolss_getprinterdriverdir(cli, mem_ctx, 1, env, &ctr);
1183
1184 if (W_ERROR_IS_OK(result))
1185 display_printdriverdir_1(ctr.info1);
1186
1187 return result;
1188 }
1189
1190 /****************************************************************************
1191 ****************************************************************************/
1192
1193 void set_drv_info_3_env (DRIVER_INFO_3 *info, const char *arch)
1194 {
1195
1196 int i;
1197
1198 for (i=0; archi_table[i].long_archi != NULL; i++)
1199 {
1200 if (strcmp(arch, archi_table[i].short_archi) == 0)
1201 {
1202 info->version = archi_table[i].version;
1203 init_unistr (&info->architecture, archi_table[i].long_archi);
1204 break;
1205 }
1206 }
1207
1208 if (archi_table[i].long_archi == NULL)
1209 {
1210 DEBUG(0, ("set_drv_info_3_env: Unknown arch [%s]\n", arch));
1211 }
1212
1213 return;
1214 }
1215
1216
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 *************************************************************************/
1221
1222 static char* get_driver_3_param (char* str, const char* delim, UNISTR* dest,
1223 char **saveptr)
1224 {
1225 char *ptr;
1226
1227 /* get the next token */
1228 ptr = strtok_r(str, delim, saveptr);
1229
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)
1233 for details */
1234 if (ptr && (StrCaseCmp(ptr, "NULL") == 0))
1235 ptr = NULL;
1236
1237 if (dest != NULL)
1238 init_unistr(dest, ptr);
1239
1240 return ptr;
1241 }
1242
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,
1251 char *args )
1252 {
1253 char *str, *str2;
1254 uint32 len, i;
1255 char *saveptr = NULL;
1256
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);
1265
1266 /* <Comma Separated List of Dependent Files> */
1267 /* save the beginning of the string */
1268 str2 = get_driver_3_param (NULL, ":", NULL, &saveptr);
1269 str = str2;
1270
1271 /* begin to strip out each filename */
1272 str = strtok_r(str, ",", &saveptr);
1273 len = 0;
1274 while (str != NULL)
1275 {
1276 /* keep a cumlative count of the str lengths */
1277 len += strlen(str)+1;
1278 str = strtok_r(NULL, ",", &saveptr);
1279 }
1280
1281 /* allocate the space; add one extra slot for a terminating NULL.
1282 Each filename is NULL terminated and the end contains a double
1283 NULL */
1284 if ((info->dependentfiles=TALLOC_ARRAY(mem_ctx, uint16, len+1)) == NULL)
1285 {
1286 DEBUG(0,("init_drv_info_3_members: Unable to malloc memory for dependenfiles\n"));
1287 return False;
1288 }
1289 for (i=0; i<len; i++)
1290 {
1291 SSVAL(&info->dependentfiles[i], 0, str2[i]);
1292 }
1293 info->dependentfiles[len] = '\0';
1294
1295 return True;
1296 }
1297
1298
1299 /****************************************************************************
1300 ****************************************************************************/
1301
1302 static WERROR cmd_spoolss_addprinterdriver(struct rpc_pipe_client *cli,
1303 TALLOC_CTX *mem_ctx,
1304 int argc, const char **argv)
1305 {
1306 WERROR result;
1307 uint32 level = 3;
1308 PRINTER_DRIVER_CTR ctr;
1309 DRIVER_INFO_3 info3;
1310 const char *arch;
1311 fstring driver_name;
1312 char *driver_args;
1313
1314 /* parse the command arguments */
1315 if (argc != 3 && argc != 4)
1316 {
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");
1322
1323 return WERR_OK;
1324 }
1325
1326 /* Fill in the DRIVER_INFO_3 struct */
1327 ZERO_STRUCT(info3);
1328 if (!(arch = cmd_spoolss_get_short_archi(argv[1])))
1329 {
1330 printf ("Error Unknown architechture [%s]\n", argv[1]);
1331 return WERR_INVALID_PARAM;
1332 }
1333 else
1334 set_drv_info_3_env(&info3, arch);
1335
1336 driver_args = talloc_strdup( mem_ctx, argv[2] );
1337 if (!init_drv_info_3_members(mem_ctx, &info3, driver_args ))
1338 {
1339 printf ("Error Invalid parameter list - %s.\n", argv[2]);
1340 return WERR_INVALID_PARAM;
1341 }
1342
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. */
1346 if (argc == 4)
1347 {
1348 info3.version = atoi(argv[3]);
1349 }
1350
1351
1352 ctr.info3 = &info3;
1353 result = rpccli_spoolss_addprinterdriver (cli, mem_ctx, level, &ctr);
1354
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",
1359 driver_name);
1360 }
1361
1362 return result;
1363 }
1364
1365
1366 /****************************************************************************
1367 ****************************************************************************/
1368
1369 static WERROR cmd_spoolss_addprinterex(struct rpc_pipe_client *cli,
1370 TALLOC_CTX *mem_ctx,
1371 int argc, const char **argv)
1372 {
1373 WERROR result;
1374 uint32 level = 2;
1375 PRINTER_INFO_CTR ctr;
1376 PRINTER_INFO_2 info2;
1377 fstring servername;
1378
1379 /* parse the command arguments */
1380 if (argc != 5)
1381 {
1382 printf ("Usage: %s <name> <shared name> <driver> <port>\n", argv[0]);
1383 return WERR_OK;
1384 }
1385
1386 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
1387 strupper_m(servername);
1388
1389 /* Fill in the DRIVER_INFO_2 struct */
1390 ZERO_STRUCT(info2);
1391
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;
1402 info2.priority = 0;
1403 info2.defaultpriority = 0;
1404 info2.starttime = 0;
1405 info2.untiltime = 0;
1406
1407 /* These three fields must not be used by AddPrinter()
1408 as defined in the MS Platform SDK documentation..
1409 --jerry
1410 info2.status = 0;
1411 info2.cjobs = 0;
1412 info2.averageppm = 0;
1413 */
1414
1415 ctr.printers_2 = &info2;
1416 result = rpccli_spoolss_addprinterex (cli, mem_ctx, level, &ctr);
1417
1418 if (W_ERROR_IS_OK(result))
1419 printf ("Printer %s successfully installed.\n", argv[1]);
1420
1421 return result;
1422 }
1423
1424 /****************************************************************************
1425 ****************************************************************************/
1426
1427 static WERROR cmd_spoolss_setdriver(struct rpc_pipe_client *cli,
1428 TALLOC_CTX *mem_ctx,
1429 int argc, const char **argv)
1430 {
1431 POLICY_HND pol;
1432 WERROR result;
1433 uint32 level = 2;
1434 bool opened_hnd = False;
1435 PRINTER_INFO_CTR ctr;
1436 PRINTER_INFO_2 info2;
1437 fstring servername,
1438 printername,
1439 user;
1440
1441 /* parse the command arguments */
1442 if (argc != 3)
1443 {
1444 printf ("Usage: %s <printer> <driver>\n", argv[0]);
1445 return WERR_OK;
1446 }
1447
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);
1452
1453 /* Get a printer handle */
1454
1455 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
1456 PRINTER_ALL_ACCESS,
1457 servername, user, &pol);
1458
1459 if (!W_ERROR_IS_OK(result))
1460 goto done;
1461
1462 opened_hnd = True;
1463
1464 /* Get printer info */
1465
1466 ZERO_STRUCT (info2);
1467 ctr.printers_2 = &info2;
1468
1469 result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, level, &ctr);
1470
1471 if (!W_ERROR_IS_OK(result)) {
1472 printf ("Unable to retrieve printer information!\n");
1473 goto done;
1474 }
1475
1476 /* Set the printer driver */
1477
1478 init_unistr(&ctr.printers_2->drivername, argv[2]);
1479
1480 result = rpccli_spoolss_setprinter(cli, mem_ctx, &pol, level, &ctr, 0);
1481
1482 if (!W_ERROR_IS_OK(result)) {
1483 printf("SetPrinter call failed!\n");
1484 goto done;;
1485 }
1486
1487 printf("Successfully set %s to driver %s.\n", argv[1], argv[2]);
1488
1489 done:
1490 /* Cleanup */
1491
1492 if (opened_hnd)
1493 rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
1494
1495 return result;
1496 }
1497
1498
1499 /****************************************************************************
1500 ****************************************************************************/
1501
1502 static WERROR cmd_spoolss_deletedriverex(struct rpc_pipe_client *cli,
1503 TALLOC_CTX *mem_ctx,
1504 int argc, const char **argv)
1505 {
1506 WERROR result, ret = WERR_UNKNOWN_PRINTER_DRIVER;
1507
1508 int i;
1509 int vers = -1;
1510
1511 const char *arch = NULL;
1512
1513 /* parse the command arguments */
1514 if (argc < 2 || argc > 4) {
1515 printf ("Usage: %s <driver> [arch] [version]\n", argv[0]);
1516 return WERR_OK;
1517 }
1518
1519 if (argc >= 3)
1520 arch = argv[2];
1521 if (argc == 4)
1522 vers = atoi (argv[3]);
1523
1524
1525 /* delete the driver for all architectures */
1526 for (i=0; archi_table[i].long_archi; i++) {
1527
1528 if (arch && !strequal( archi_table[i].long_archi, arch))
1529 continue;
1530
1531 if (vers >= 0 && archi_table[i].version != vers)
1532 continue;
1533
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);
1537
1538 if ( !W_ERROR_IS_OK(result) )
1539 {
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, dos_errstr(result));
1543 }
1544 }
1545 else
1546 {
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);
1549 ret = WERR_OK;
1550 }
1551 }
1552
1553 return ret;
1554 }
1555
1556
1557 /****************************************************************************
1558 ****************************************************************************/
1559
1560 static WERROR cmd_spoolss_deletedriver(struct rpc_pipe_client *cli,
1561 TALLOC_CTX *mem_ctx,
1562 int argc, const char **argv)
1563 {
1564 WERROR result = WERR_OK;
1565 fstring servername;
1566 int i;
1567
1568 /* parse the command arguments */
1569 if (argc != 2) {
1570 printf ("Usage: %s <driver>\n", argv[0]);
1571 return WERR_OK;
1572 }
1573
1574 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
1575 strupper_m(servername);
1576
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]);
1582
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,
1587 W_ERROR_V(result));
1588 }
1589 } else {
1590 printf ("Driver %s removed for arch [%s].\n", argv[1],
1591 archi_table[i].long_archi);
1592 }
1593 }
1594
1595 return result;
1596 }
1597
1598 /****************************************************************************
1599 ****************************************************************************/
1600
1601 static WERROR cmd_spoolss_getprintprocdir(struct rpc_pipe_client *cli,
1602 TALLOC_CTX *mem_ctx,
1603 int argc, const char **argv)
1604 {
1605 WERROR result;
1606 char *servername = NULL, *environment = NULL;
1607 fstring procdir;
1608
1609 /* parse the command arguments */
1610 if (argc > 2) {
1611 printf ("Usage: %s [environment]\n", argv[0]);
1612 return WERR_OK;
1613 }
1614
1615 if (asprintf(&servername, "\\\\%s", cli->desthost) < 0)
1616 return WERR_NOMEM;
1617 strupper_m(servername);
1618
1619 if (asprintf(&environment, "%s", (argc == 2) ? argv[1] :
1620 PRINTER_DRIVER_ARCHITECTURE) < 0) {
1621 SAFE_FREE(servername);
1622 return WERR_NOMEM;
1623 }
1624
1625 result = rpccli_spoolss_getprintprocessordirectory(
1626 cli, mem_ctx, servername, environment, procdir);
1627
1628 if (W_ERROR_IS_OK(result))
1629 printf("%s\n", procdir);
1630
1631 SAFE_FREE(servername);
1632 SAFE_FREE(environment);
1633
1634 return result;
1635 }
1636
1637 /****************************************************************************
1638 ****************************************************************************/
1639
1640 static WERROR cmd_spoolss_addform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1641 int argc, const char **argv)
1642 {
1643 POLICY_HND handle;
1644 WERROR werror;
1645 char *servername = NULL, *printername = NULL;
1646 FORM form;
1647 bool got_handle = False;
1648
1649 /* Parse the command arguments */
1650
1651 if (argc != 3) {
1652 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1653 return WERR_OK;
1654 }
1655
1656 /* Get a printer handle */
1657
1658 asprintf(&servername, "\\\\%s", cli->desthost);
1659 strupper_m(servername);
1660 asprintf(&printername, "%s\\%s", servername, argv[1]);
1661
1662 werror = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
1663 PRINTER_ALL_ACCESS,
1664 servername, cli->auth->user_name,
1665 &handle);
1666
1667 if (!W_ERROR_IS_OK(werror))
1668 goto done;
1669
1670 got_handle = True;
1671
1672 /* Dummy up some values for the form data */
1673
1674 form.flags = FORM_USER;
1675 form.size_x = form.size_y = 100;
1676 form.left = 0;
1677 form.top = 10;
1678 form.right = 20;
1679 form.bottom = 30;
1680
1681 init_unistr2(&form.name, argv[2], UNI_STR_TERMINATE);
1682
1683 /* Add the form */
1684
1685
1686 werror = rpccli_spoolss_addform(cli, mem_ctx, &handle, 1, &form);
1687
1688 done:
1689 if (got_handle)
1690 rpccli_spoolss_close_printer(cli, mem_ctx, &handle);
1691
1692 SAFE_FREE(servername);
1693 SAFE_FREE(printername);
1694
1695 return werror;
1696 }
1697
1698 /****************************************************************************
1699 ****************************************************************************/
1700
1701 static WERROR cmd_spoolss_setform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1702 int argc, const char **argv)
1703 {
1704 POLICY_HND handle;
1705 WERROR werror;
1706 char *servername = NULL, *printername = NULL;
1707 FORM form;
1708 bool got_handle = False;
1709
1710 /* Parse the command arguments */
1711
1712 if (argc != 3) {
1713 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1714 return WERR_OK;
1715 }
1716
1717 /* Get a printer handle */
1718
1719 asprintf(&servername, "\\\\%s", cli->desthost);
1720 strupper_m(servername);
1721 asprintf(&printername, "%s\\%s", servername, argv[1]);
1722
1723 werror = rpccli_spoolss_open_printer_ex(
1724 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1725 servername, cli->auth->user_name, &handle);
1726
1727 if (!W_ERROR_IS_OK(werror))
1728 goto done;
1729
1730 got_handle = True;
1731
1732 /* Dummy up some values for the form data */
1733
1734 form.flags = FORM_PRINTER;
1735 form.size_x = form.size_y = 100;
1736 form.left = 0;
1737 form.top = 1000;
1738 form.right = 2000;
1739 form.bottom = 3000;
1740
1741 init_unistr2(&form.name, argv[2], UNI_STR_TERMINATE);
1742
1743 /* Set the form */
1744
1745 werror = rpccli_spoolss_setform(cli, mem_ctx, &handle, 1, argv[2], &form);
1746
1747 done:
1748 if (got_handle)
1749 rpccli_spoolss_close_printer(cli, mem_ctx, &handle);
1750
1751 SAFE_FREE(servername);
1752 SAFE_FREE(printername);
1753
1754 return werror;
1755 }
1756
1757 /****************************************************************************
1758 ****************************************************************************/
1759
1760 static const char *get_form_flag(int form_flag)
1761 {
1762 switch (form_flag) {
1763 case FORM_USER:
1764 return "FORM_USER";
1765 case FORM_BUILTIN:
1766 return "FORM_BUILTIN";
1767 case FORM_PRINTER:
1768 return "FORM_PRINTER";
1769 default:
1770 return "unknown";
1771 }
1772 }
1773
1774 /****************************************************************************
1775 ****************************************************************************/
1776
1777 static void display_form(FORM_1 *form)
1778 {
1779 fstring form_name = "";
1780
1781 if (form->name.buffer)
1782 rpcstr_pull(form_name, form->name.buffer,
1783 sizeof(form_name), -1, STR_TERMINATE);
1784
1785 printf("%s\n" \
1786 "\tflag: %s (%d)\n" \
1787 "\twidth: %d, length: %d\n" \
1788 "\tleft: %d, right: %d, top: %d, bottom: %d\n\n",
1789 form_name, get_form_flag(form->flag), form->flag,
1790 form->width, form->length,
1791 form->left, form->right,
1792 form->top, form->bottom);
1793 }
1794
1795 /****************************************************************************
1796 ****************************************************************************/
1797
1798 static WERROR cmd_spoolss_getform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1799 int argc, const char **argv)
1800 {
1801 POLICY_HND handle;
1802 WERROR werror;
1803 char *servername = NULL, *printername = NULL;
1804 FORM_1 form;
1805 bool got_handle = False;
1806
1807 /* Parse the command arguments */
1808
1809 if (argc != 3) {
1810 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1811 return WERR_OK;
1812 }
1813
1814 /* Get a printer handle */
1815
1816 asprintf(&servername, "\\\\%s", cli->desthost);
1817 strupper_m(servername);
1818 asprintf(&printername, "%s\\%s", servername, argv[1]);
1819
1820 werror = rpccli_spoolss_open_printer_ex(
1821 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1822 servername, cli->auth->user_name, &handle);
1823
1824 if (!W_ERROR_IS_OK(werror))
1825 goto done;
1826
1827 got_handle = True;
1828
1829 /* Get the form */
1830
1831 werror = rpccli_spoolss_getform(cli, mem_ctx, &handle, argv[2], 1, &form);
1832
1833 if (!W_ERROR_IS_OK(werror))
1834 goto done;
1835
1836 display_form(&form);
1837
1838 done:
1839 if (got_handle)
1840 rpccli_spoolss_close_printer(cli, mem_ctx, &handle);
1841
1842 SAFE_FREE(servername);
1843 SAFE_FREE(printername);
1844
1845 return werror;
1846 }
1847
1848 /****************************************************************************
1849 ****************************************************************************/
1850
1851 static WERROR cmd_spoolss_deleteform(struct rpc_pipe_client *cli,
1852 TALLOC_CTX *mem_ctx, int argc,
1853 const char **argv)
1854 {
1855 POLICY_HND handle;
1856 WERROR werror;
1857 char *servername = NULL, *printername = NULL;
1858 bool got_handle = False;
1859
1860 /* Parse the command arguments */
1861
1862 if (argc != 3) {
1863 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1864 return WERR_OK;
1865 }
1866
1867 /* Get a printer handle */
1868
1869 asprintf(&servername, "\\\\%s", cli->desthost);
1870 strupper_m(servername);
1871 asprintf(&printername, "%s\\%s", servername, argv[1]);
1872
1873 werror = rpccli_spoolss_open_printer_ex(
1874 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1875 servername, cli->auth->user_name, &handle);
1876
1877 if (!W_ERROR_IS_OK(werror))
1878 goto done;
1879
1880 got_handle = True;
1881
1882 /* Delete the form */
1883
1884 werror = rpccli_spoolss_deleteform(cli, mem_ctx, &handle, argv[2]);
1885
1886 done:
1887 if (got_handle)
1888 rpccli_spoolss_close_printer(cli, mem_ctx, &handle);
1889
1890 SAFE_FREE(servername);
1891 SAFE_FREE(printername);
1892
1893 return werror;
1894 }
1895
1896 /****************************************************************************
1897 ****************************************************************************/
1898
1899 static WERROR cmd_spoolss_enum_forms(struct rpc_pipe_client *cli,
1900 TALLOC_CTX *mem_ctx, int argc,
1901 const char **argv)
1902 {
1903 POLICY_HND handle;
1904 WERROR werror;
1905 char *servername = NULL, *printername = NULL;
1906 bool got_handle = False;
1907 uint32 num_forms, level = 1, i;
1908 FORM_1 *forms;
1909
1910 /* Parse the command arguments */
1911
1912 if (argc != 2) {
1913 printf ("Usage: %s <printer>\n", argv[0]);
1914 return WERR_OK;
1915 }
1916
1917 /* Get a printer handle */
1918
1919 asprintf(&servername, "\\\\%s", cli->desthost);
1920 strupper_m(servername);
1921 asprintf(&printername, "%s\\%s", servername, argv[1]);
1922
1923 werror = rpccli_spoolss_open_printer_ex(
1924 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1925 servername, cli->auth->user_name, &handle);
1926
1927 if (!W_ERROR_IS_OK(werror))
1928 goto done;
1929
1930 got_handle = True;
1931
1932 /* Enumerate forms */
1933
1934 werror = rpccli_spoolss_enumforms(cli, mem_ctx, &handle, level, &num_forms, &forms);
1935
1936 if (!W_ERROR_IS_OK(werror))
1937 goto done;
1938
1939 /* Display output */
1940
1941 for (i = 0; i < num_forms; i++) {
1942
1943 display_form(&forms[i]);
1944
1945 }
1946
1947 done:
1948 if (got_handle)
1949 rpccli_spoolss_close_printer(cli, mem_ctx, &handle);
1950
1951 SAFE_FREE(servername);
1952 SAFE_FREE(printername);
1953
1954 return werror;
1955 }
1956
1957 /****************************************************************************
1958 ****************************************************************************/
1959
1960 static WERROR cmd_spoolss_setprinterdata(struct rpc_pipe_client *cli,
1961 TALLOC_CTX *mem_ctx,
1962 int argc, const char **argv)
1963 {
1964 WERROR result;
1965 fstring servername, printername, user;
1966 POLICY_HND pol;
1967 bool opened_hnd = False;
1968 PRINTER_INFO_CTR ctr;
1969 PRINTER_INFO_0 info;
1970 REGISTRY_VALUE value;
1971 TALLOC_CTX *tmp_ctx = talloc_stackframe();
1972
1973 /* parse the command arguments */
1974 if (argc < 5) {
1975 printf ("Usage: %s <printer> <string|binary|dword|multistring>"
1976 " <value> <data>\n",
1977 argv[0]);
1978 result = WERR_INVALID_PARAM;
1979 goto done;
1980 }
1981
1982 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
1983 strupper_m(servername);
1984 slprintf(printername, sizeof(servername)-1, "%s\\%s", servername, argv[1]);
1985 fstrcpy(user, cli->auth->user_name);
1986
1987 value.type = REG_NONE;
1988
1989 if (strequal(argv[2], "string")) {
1990 value.type = REG_SZ;
1991 }
1992
1993 if (strequal(argv[2], "binary")) {
1994 value.type = REG_BINARY;
1995 }
1996
1997 if (strequal(argv[2], "dword")) {
1998 value.type = REG_DWORD;
1999 }
2000
2001 if (strequal(argv[2], "multistring")) {
2002 value.type = REG_MULTI_SZ;
2003 }
2004
2005 if (value.type == REG_NONE) {
2006 printf("Unknown data type: %s\n", argv[2]);
2007 result = WERR_INVALID_PARAM;
2008 goto done;
2009 }
2010
2011 /* get a printer handle */
2012 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
2013 MAXIMUM_ALLOWED_ACCESS, servername,
2014 user, &pol);
2015 if (!W_ERROR_IS_OK(result))
2016 goto done;
2017
2018 opened_hnd = True;
2019
2020 ctr.printers_0 = &info;
2021
2022 result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, 0, &ctr);
2023
2024 if (!W_ERROR_IS_OK(result))
2025 goto done;
2026
2027 printf("%s\n", current_timestring(tmp_ctx, True));
2028 printf("\tchange_id (before set)\t:[0x%x]\n", info.change_id);
2029
2030 /* Set the printer data */
2031
2032 fstrcpy(value.valuename, argv[3]);
2033
2034 switch (value.type) {
2035 case REG_SZ: {
2036 UNISTR2 data;
2037 init_unistr2(&data, argv[4], UNI_STR_TERMINATE);
2038 value.size = data.uni_str_len * 2;
2039 if (value.size) {
2040 value.data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, data.buffer,
2041 value.size);
2042 } else {
2043 value.data_p = NULL;
2044 }
2045 break;
2046 }
2047 case REG_DWORD: {
2048 uint32 data = strtoul(argv[4], NULL, 10);
2049 value.size = sizeof(data);
2050 if (sizeof(data)) {
2051 value.data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, &data,
2052 sizeof(data));
2053 } else {
2054 value.data_p = NULL;
2055 }
2056 break;
2057 }
2058 case REG_BINARY: {
2059 DATA_BLOB data = strhex_to_data_blob(mem_ctx, argv[4]);
2060 value.data_p = data.data;
2061 value.size = data.length;
2062 break;
2063 }
2064 case REG_MULTI_SZ: {
2065 int i;
2066 size_t len = 0;
2067 char *p;
2068
2069 for (i=4; i<argc; i++) {
2070 if (strcmp(argv[i], "NULL") == 0) {
2071 argv[i] = "";
2072 }
2073 len += strlen(argv[i])+1;
2074 }
2075
2076 value.size = len*2;
2077 value.data_p = TALLOC_ARRAY(mem_ctx, unsigned char, value.size);
2078 if (value.data_p == NULL) {
2079 result = WERR_NOMEM;
2080 goto done;
2081 }
2082
2083 p = (char *)value.data_p;
2084 len = value.size;
2085 for (i=4; i<argc; i++) {
2086 size_t l = (strlen(argv[i])+1)*2;
2087 rpcstr_push(p, argv[i], len, STR_TERMINATE);
2088 p += l;
2089 len -= l;
2090 }
2091 SMB_ASSERT(len == 0);
2092 break;
2093 }
2094 default:
2095 printf("Unknown data type: %s\n", argv[2]);
2096 result = WERR_INVALID_PARAM;
2097 goto done;
2098 }
2099
2100 result = rpccli_spoolss_setprinterdata(cli, mem_ctx, &pol, &value);
2101
2102 if (!W_ERROR_IS_OK(result)) {
2103 printf ("Unable to set [%s=%s]!\n", argv[3], argv[4]);
2104 goto done;
2105 }
2106 printf("\tSetPrinterData succeeded [%s: %s]\n", argv[3], argv[4]);
2107
2108 result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, 0, &ctr);
2109
2110 if (!W_ERROR_IS_OK(result))
2111 goto done;
2112
2113 printf("%s\n", current_timestring(tmp_ctx, True));
2114 printf("\tchange_id (after set)\t:[0x%x]\n", info.change_id);
2115
2116 done:
2117 /* cleanup */
2118 TALLOC_FREE(tmp_ctx);
2119 if (opened_hnd)
2120 rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
2121
2122 return result;
2123 }
2124
2125 /****************************************************************************
2126 ****************************************************************************/
2127
2128 static void display_job_info_1(JOB_INFO_1 *job)
2129 {
2130 fstring username = "", document = "", text_status = "";
2131
2132 rpcstr_pull(username, job->username.buffer,
2133 sizeof(username), -1, STR_TERMINATE);
2134
2135 rpcstr_pull(document, job->document.buffer,
2136 sizeof(document), -1, STR_TERMINATE);
2137
2138 rpcstr_pull(text_status, job->text_status.buffer,
2139 sizeof(text_status), -1, STR_TERMINATE);
2140
2141 printf("%d: jobid[%d]: %s %s %s %d/%d pages\n", job->position, job->jobid,
2142 username, document, text_status, job->pagesprinted,
2143 job->totalpages);
2144 }
2145
2146 /****************************************************************************
2147 ****************************************************************************/
2148
2149 static void display_job_info_2(JOB_INFO_2 *job)
2150 {
2151 fstring username = "", document = "", text_status = "";
2152
2153 rpcstr_pull(username, job->username.buffer,
2154 sizeof(username), -1, STR_TERMINATE);
2155
2156 rpcstr_pull(document, job->document.buffer,
2157 sizeof(document), -1, STR_TERMINATE);
2158
2159 rpcstr_pull(text_status, job->text_status.buffer,
2160 sizeof(text_status), -1, STR_TERMINATE);
2161
2162 printf("%d: jobid[%d]: %s %s %s %d/%d pages, %d bytes\n", job->position, job->jobid,
2163 username, document, text_status, job->pagesprinted,
2164 job->totalpages, job->size);
2165 }
2166
2167 /****************************************************************************
2168 ****************************************************************************/
2169
2170 static WERROR cmd_spoolss_enum_jobs(struct rpc_pipe_client *cli,
2171 TALLOC_CTX *mem_ctx, int argc,
2172 const char **argv)
2173 {
2174 WERROR result;
2175 uint32 level = 1, num_jobs, i;
2176 bool got_hnd = False;
2177 char *printername = NULL;
2178 fstring servername, user;
2179 POLICY_HND hnd;
2180 JOB_INFO_CTR ctr;
2181
2182 if (argc < 2 || argc > 3) {
2183 printf("Usage: %s printername [level]\n", argv[0]);
2184 return WERR_OK;
2185 }
2186
2187 if (argc == 3)
2188 level = atoi(argv[2]);
2189
2190 /* Open printer handle */
2191
2192 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
2193 strupper_m(servername);
2194 fstrcpy(user, cli->auth->user_name);
2195 printername = talloc_asprintf(mem_ctx, "\\\\%s\\", cli->desthost);
2196 if (!printername) {
2197 return WERR_NOMEM;
2198 }
2199 strupper_m(printername);
2200 printername = talloc_asprintf_append(printername, "%s", argv[1]);
2201 if (!printername) {
2202 return WERR_NOMEM;
2203 }
2204
2205 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
2206 "", MAXIMUM_ALLOWED_ACCESS,
2207 servername, user, &hnd);
2208
2209 if (!W_ERROR_IS_OK(result))
2210 goto done;
2211
2212 got_hnd = True;
2213
2214 /* Enumerate ports */
2215
2216 result = rpccli_spoolss_enumjobs(cli, mem_ctx, &hnd, level, 0, 1000,
2217 &num_jobs, &ctr);
2218
2219 if (!W_ERROR_IS_OK(result))
2220 goto done;
2221
2222 for (i = 0; i < num_jobs; i++) {
2223 switch(level) {
2224 case 1:
2225 display_job_info_1(&ctr.job.job_info_1[i]);
2226 break;
2227 case 2:
2228 display_job_info_2(&ctr.job.job_info_2[i]);
2229 break;
2230 default:
2231 d_printf("unknown info level %d\n", level);
2232 break;
2233 }
2234 }
2235
2236 done:
2237 if (got_hnd)
2238 rpccli_spoolss_close_printer(cli, mem_ctx, &hnd);
2239
2240 return result;
2241 }
2242
2243 /****************************************************************************
2244 ****************************************************************************/
2245
2246 static WERROR cmd_spoolss_enum_data( struct rpc_pipe_client *cli,
2247 TALLOC_CTX *mem_ctx, int argc,
2248 const char **argv)
2249 {
2250 WERROR result;
2251 uint32 i=0, val_needed, data_needed;
2252 bool got_hnd = False;
2253 char *printername = NULL;
2254 fstring servername, user;
2255 POLICY_HND hnd;
2256
2257 if (argc != 2) {
2258 printf("Usage: %s printername\n", argv[0]);
2259 return WERR_OK;
2260 }
2261
2262 /* Open printer handle */
2263
2264 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
2265 strupper_m(servername);
2266 fstrcpy(user, cli->auth->user_name);
2267 printername = talloc_asprintf(mem_ctx, "\\\\%s\\", cli->desthost);
2268 if (!printername) {
2269 return WERR_NOMEM;
2270 }
2271 strupper_m(printername);
2272 printername = talloc_asprintf_append(printername, "%s", argv[1]);
2273 if (!printername) {
2274 return WERR_NOMEM;
2275 }
2276
2277 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
2278 "", MAXIMUM_ALLOWED_ACCESS,
2279 servername, user, &hnd);
2280
2281 if (!W_ERROR_IS_OK(result))
2282 goto done;
2283
2284 got_hnd = True;
2285
2286 /* Enumerate data */
2287
2288 result = rpccli_spoolss_enumprinterdata(cli, mem_ctx, &hnd, i, 0, 0,
2289 &val_needed, &data_needed,
2290 NULL);
2291 while (W_ERROR_IS_OK(result)) {
2292 REGISTRY_VALUE value;
2293 result = rpccli_spoolss_enumprinterdata(
2294 cli, mem_ctx, &hnd, i++, val_needed,
2295 data_needed, 0, 0, &value);
2296 if (W_ERROR_IS_OK(result))
2297 display_reg_value(value);
2298 }
2299 if (W_ERROR_V(result) == ERRnomoreitems)
2300 result = W_ERROR(ERRsuccess);
2301
2302 done:
2303 if (got_hnd)
2304 rpccli_spoolss_close_printer(cli, mem_ctx, &hnd);
2305
2306 return result;
2307 }
2308
2309 /****************************************************************************
2310 ****************************************************************************/
2311
2312 static WERROR cmd_spoolss_enum_data_ex( struct rpc_pipe_client *cli,
2313 TALLOC_CTX *mem_ctx, int argc,
2314 const char **argv)
2315 {
2316 WERROR result;
2317 uint32 i;
2318 bool got_hnd = False;
2319 char *printername = NULL;
2320 fstring servername, user;
2321 const char *keyname = NULL;
2322 POLICY_HND hnd;
2323 REGVAL_CTR *ctr = NULL;
2324
2325 if (argc != 3) {
2326 printf("Usage: %s printername <keyname>\n", argv[0]);
2327 return WERR_OK;
2328 }
2329
2330 keyname = argv[2];
2331
2332 /* Open printer handle */
2333
2334 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
2335 strupper_m(servername);
2336 fstrcpy(user, cli->auth->user_name);
2337
2338 printername = talloc_asprintf(mem_ctx, "\\\\%s\\", cli->desthost);
2339 if (!printername) {
2340 return WERR_NOMEM;
2341 }
2342 strupper_m(printername);
2343 printername = talloc_asprintf_append(printername, "%s", argv[1]);
2344 if (!printername) {
2345 return WERR_NOMEM;
2346 }
2347
2348 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
2349 "", MAXIMUM_ALLOWED_ACCESS,
2350 servername, user, &hnd);
2351
2352 if (!W_ERROR_IS_OK(result))
2353 goto done;
2354
2355 got_hnd = True;
2356
2357 /* Enumerate subkeys */
2358
2359 if ( !(ctr = TALLOC_ZERO_P( mem_ctx, REGVAL_CTR )) )
2360 return WERR_NOMEM;
2361
2362 result = rpccli_spoolss_enumprinterdataex(cli, mem_ctx, &hnd, keyname, ctr);
2363
2364 if (!W_ERROR_IS_OK(result))
2365 goto done;
2366
2367 for (i=0; i < ctr->num_values; i++) {
2368 display_reg_value(*(ctr->values[i]));
2369 }
2370
2371 TALLOC_FREE( ctr );
2372
2373 done:
2374 if (got_hnd)
2375 rpccli_spoolss_close_printer(cli, mem_ctx, &hnd);
2376
2377 return result;
2378 }
2379
2380 /****************************************************************************
2381 ****************************************************************************/
2382
2383 static WERROR cmd_spoolss_enum_printerkey( struct rpc_pipe_client *cli,
2384 TALLOC_CTX *mem_ctx, int argc,
2385 const char **argv)
2386 {
2387 WERROR result;
2388 bool got_hnd = False;
2389 char *printername = NULL;
2390 fstring servername, user;
2391 const char *keyname = NULL;
2392 POLICY_HND hnd;
2393 uint16 *keylist = NULL, *curkey;
2394
2395 if (argc < 2 || argc > 3) {
2396 printf("Usage: %s printername [keyname]\n", argv[0]);
2397 return WERR_OK;
2398 }
2399
2400 if (argc == 3)
2401 keyname = argv[2];
2402 else
2403 keyname = "";
2404
2405 /* Open printer handle */
2406
2407 slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
2408 strupper_m(servername);
2409 fstrcpy(user, cli->auth->user_name);
2410
2411 printername = talloc_asprintf(mem_ctx, "\\\\%s\\", cli->desthost);
2412 if (!printername) {
2413 return WERR_NOMEM;
2414 }
2415 strupper_m(printername);
2416 printername = talloc_asprintf_append(printername, "%s", argv[1]);
2417 if (!printername) {
2418 return WERR_NOMEM;
2419 }
2420
2421
2422 result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
2423 "", MAXIMUM_ALLOWED_ACCESS,
2424 servername, user, &hnd);
2425
2426 if (!W_ERROR_IS_OK(result))
2427 goto done;
2428
2429 got_hnd = True;
2430
2431 /* Enumerate subkeys */
2432
2433 result = rpccli_spoolss_enumprinterkey(cli, mem_ctx, &hnd, keyname, &keylist, NULL);
2434
2435 if (!W_ERROR_IS_OK(result))
2436 goto done;
2437
2438 curkey = keylist;
2439 while (*curkey != 0) {
2440 char *subkey = NULL;
2441 rpcstr_pull_talloc(mem_ctx, &subkey, curkey, -1,
2442 STR_TERMINATE);
2443 if (!subkey) {
2444 break;
2445 }
2446 printf("%s\n", subkey);
2447 curkey += strlen(subkey) + 1;
2448 }
2449
2450 done:
2451
2452 SAFE_FREE(keylist);
2453
2454 if (got_hnd)
2455 rpccli_spoolss_close_printer(cli, mem_ctx, &hnd);
2456
2457 return result;
2458 }
2459
2460 /****************************************************************************
2461 ****************************************************************************/
2462
2463 static WERROR cmd_spoolss_rffpcnex(struct rpc_pipe_client *cli,
2464 TALLOC_CTX *mem_ctx, int argc,
2465 const char **argv)
2466 {
2467 fstring servername, printername;
2468 POLICY_HND hnd;
2469 bool got_hnd = False;
2470 WERROR result;
2471 SPOOL_NOTIFY_OPTION option;
2472
2473 if (argc != 2) {
2474 printf("Usage: %s printername\n", argv[0]);
2475 result = WERR_OK;
2476 goto done;
2477 }
2478
2479 /* Open printer */
2480
2481 slprintf(servername, sizeof(servername) - 1, "\\\\%s", cli->desthost);
2482 strupper_m(servername);
2483
2484 slprintf(printername, sizeof(printername) - 1, "\\\\%s\\%s",
2485 cli->desthost, argv[1]);
2486 strupper_m(printername);
2487
2488 result = rpccli_spoolss_open_printer_ex(
2489 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
2490 servername, cli->auth->user_name, &hnd);
2491
2492 if (!W_ERROR_IS_OK(result)) {
2493 printf("Error opening %s\n", argv[1]);
2494 goto done;
2495 }
2496
2497 got_hnd = True;
2498
2499 /* Create spool options */
2500
2501 ZERO_STRUCT(option);
2502
2503 option.version = 2;
2504 option.option_type_ptr = 1;
2505 option.count = option.ctr.count = 2;
2506
2507 option.ctr.type = TALLOC_ARRAY(mem_ctx, SPOOL_NOTIFY_OPTION_TYPE, 2);
2508 if (option.ctr.type == NULL) {
2509 result = WERR_NOMEM;
2510 goto done;
2511 }
2512
2513 ZERO_STRUCT(option.ctr.type[0]);
2514 option.ctr.type[0].type = PRINTER_NOTIFY_TYPE;
2515 option.ctr.type[0].count = option.ctr.type[0].count2 = 1;
2516 option.ctr.type[0].fields_ptr = 1;
2517 option.ctr.type[0].fields[0] = PRINTER_NOTIFY_SERVER_NAME;
2518
2519 ZERO_STRUCT(option.ctr.type[1]);
2520 option.ctr.type[1].type = JOB_NOTIFY_TYPE;
2521 option.ctr.type[1].count = option.ctr.type[1].count2 = 1;
2522 option.ctr.type[1].fields_ptr = 1;
2523 option.ctr.type[1].fields[0] = JOB_NOTIFY_PRINTER_NAME;
2524
2525 /* Send rffpcnex */
2526
2527 slprintf(servername, sizeof(servername) - 1, "\\\\%s", myhostname());
2528 strupper_m(servername);
2529
2530 result = rpccli_spoolss_rffpcnex(
2531 cli, mem_ctx, &hnd, 0, 0, servername, 123, &option);
2532
2533 if (!W_ERROR_IS_OK(result)) {
2534 printf("Error rffpcnex %s\n", argv[1]);
2535 goto done;
2536 }
2537
2538 done:
2539 if (got_hnd)
2540 rpccli_spoolss_close_printer(cli, mem_ctx, &hnd);
2541
2542 return result;
2543 }
2544
2545 /****************************************************************************
2546 ****************************************************************************/
2547
2548 static bool compare_printer( struct rpc_pipe_client *cli1, POLICY_HND *hnd1,
2549 struct rpc_pipe_client *cli2, POLICY_HND *hnd2 )
2550 {
2551 PRINTER_INFO_CTR ctr1, ctr2;
2552 WERROR werror;
2553 TALLOC_CTX *mem_ctx = talloc_init("compare_printer");
2554
2555 printf("Retrieving printer propertiesfor %s...", cli1->desthost);
2556 werror = rpccli_spoolss_getprinter( cli1, mem_ctx, hnd1, 2, &ctr1);
2557 if ( !W_ERROR_IS_OK(werror) ) {
2558 printf("failed (%s)\n", dos_errstr(werror));
2559 talloc_destroy(mem_ctx);
2560 return False;
2561 }
2562 printf("ok\n");
2563
2564 printf("Retrieving printer properties for %s...", cli2->desthost);
2565 werror = rpccli_spoolss_getprinter( cli2, mem_ctx, hnd2, 2, &ctr2);
2566 if ( !W_ERROR_IS_OK(werror) ) {
2567 printf("failed (%s)\n", dos_errstr(werror));
2568 talloc_destroy(mem_ctx);
2569 return False;
2570 }
2571 printf("ok\n");
2572
2573 talloc_destroy(mem_ctx);
2574
2575 return True;
2576 }
2577
2578 /****************************************************************************
2579 ****************************************************************************/
2580
2581 static bool compare_printer_secdesc( struct rpc_pipe_client *cli1, POLICY_HND *hnd1,
2582 struct rpc_pipe_client *cli2, POLICY_HND *hnd2 )
2583 {
2584 PRINTER_INFO_CTR ctr1, ctr2;
2585 WERROR werror;
2586 TALLOC_CTX *mem_ctx = talloc_init("compare_printer_secdesc");
2587 SEC_DESC *sd1, *sd2;
2588 bool result = True;
2589
2590
2591 printf("Retrieving printer security for %s...", cli1->desthost);
2592 werror = rpccli_spoolss_getprinter( cli1, mem_ctx, hnd1, 3, &ctr1);
2593 if ( !W_ERROR_IS_OK(werror) ) {
2594 printf("failed (%s)\n", dos_errstr(werror));
2595 result = False;
2596 goto done;
2597 }
2598 printf("ok\n");
2599
2600 printf("Retrieving printer security for %s...", cli2->desthost);
2601 werror = rpccli_spoolss_getprinter( cli2, mem_ctx, hnd2, 3, &ctr2);
2602 if ( !W_ERROR_IS_OK(werror) ) {
2603 printf("failed (%s)\n", dos_errstr(werror));
2604 result = False;
2605 goto done;
2606 }
2607 printf("ok\n");
2608
2609
2610 printf("++ ");
2611
2612 if ( (ctr1.printers_3 != ctr2.printers_3) && (!ctr1.printers_3 || !ctr2.printers_3) ) {
2613 printf("NULL PRINTER_INFO_3!\n");
2614 result = False;
2615 goto done;
2616 }
2617
2618 sd1 = ctr1.printers_3->secdesc;
2619 sd2 = ctr2.printers_3->secdesc;
2620
2621 if ( (sd1 != sd2) && ( !sd1 || !sd2 ) ) {
2622 printf("NULL secdesc!\n");
2623 result = False;
2624 goto done;
2625 }
2626
2627 if (!sec_desc_equal( sd1, sd2 ) ) {
2628 printf("Security Descriptors *not* equal!\n");
2629 result = False;
2630 goto done;
2631 }
2632
2633 printf("Security descriptors match\n");
2634
2635 done:
2636 talloc_destroy(mem_ctx);
2637 return result;
2638 }
2639
2640
2641 /****************************************************************************
2642 ****************************************************************************/
2643
2644 static WERROR cmd_spoolss_printercmp(struct rpc_pipe_client *cli,
2645 TALLOC_CTX *mem_ctx, int argc,
2646 const char **argv)
2647 {
2648 fstring printername, servername1, servername2;
2649 char *printername_path = NULL;
2650 struct cli_state *cli_server1 = rpc_pipe_np_smb_conn(cli);
2651 struct cli_state *cli_server2 = NULL;
2652 struct rpc_pipe_client *cli2 = NULL;
2653 POLICY_HND hPrinter1, hPrinter2;
2654 NTSTATUS nt_status;
2655 WERROR werror;
2656
2657 if ( argc != 3 ) {
2658 printf("Usage: %s <printer> <server>\n", argv[0]);
2659 return WERR_OK;
2660 }
2661
2662 fstrcpy( printername, argv[1] );
2663
2664 fstrcpy( servername1, cli->desthost );
2665 fstrcpy( servername2, argv[2] );
2666 strupper_m( servername1 );
2667 strupper_m( servername2 );
2668
2669 /* first get the connection to the remote server */
2670
2671 nt_status = cli_full_connection(&cli_server2, global_myname(), servername2,
2672 NULL, 0,
2673 "IPC$", "IPC",
2674 get_cmdline_auth_info_username(),
2675 lp_workgroup(),
2676 get_cmdline_auth_info_password(),
2677 get_cmdline_auth_info_use_kerberos() ? CLI_FULL_CONNECTION_USE_KERBEROS : 0,
2678 get_cmdline_auth_info_signing_state(), NULL);
2679
2680 if ( !NT_STATUS_IS_OK(nt_status) )
2681 return WERR_GENERAL_FAILURE;
2682
2683 nt_status = cli_rpc_pipe_open_noauth(cli_server2, &syntax_spoolss,
2684 &cli2);
2685 if (!NT_STATUS_IS_OK(nt_status)) {
2686 printf("failed to open spoolss pipe on server %s (%s)\n",
2687 servername2, nt_errstr(nt_status));
2688 return WERR_GENERAL_FAILURE;
2689 }
2690
2691 /* now open up both printers */
2692
2693 printername_path = talloc_asprintf(mem_ctx,
2694 "\\\\%s\\%s",
2695 servername1,
2696 printername);
2697 if (!printername_path) {
2698 return WERR_NOMEM;
2699 }
2700 printf("Opening %s...", printername_path);
2701 werror = rpccli_spoolss_open_printer_ex( cli, mem_ctx, printername_path,
2702 "", PRINTER_ALL_ACCESS, servername1, cli_server1->user_name, &hPrinter1);
2703 if ( !W_ERROR_IS_OK(werror) ) {
2704 printf("failed (%s)\n", dos_errstr(werror));
2705 goto done;
2706 }
2707 printf("ok\n");
2708
2709 printername_path = talloc_asprintf(mem_ctx,
2710 "\\\\%s\\%s",
2711 servername2,
2712 printername);
2713 if (!printername_path) {
2714 return WERR_NOMEM;
2715 }
2716 printf("Opening %s...", printername_path);
2717 werror = rpccli_spoolss_open_printer_ex( cli2, mem_ctx, printername_path,
2718 "", PRINTER_ALL_ACCESS, servername2, cli_server2->user_name, &hPrinter2 );
2719 if ( !W_ERROR_IS_OK(werror) ) {
2720 printf("failed (%s)\n", dos_errstr(werror));
2721 goto done;
2722 }
2723 printf("ok\n");
2724
2725 compare_printer( cli, &hPrinter1, cli2, &hPrinter2 );
2726 compare_printer_secdesc( cli, &hPrinter1, cli2, &hPrinter2 );
2727 #if 0
2728 compare_printerdata( cli_server1, &hPrinter1, cli_server2, &hPrinter2 );
2729 #endif
2730
2731
2732 done:
2733 /* cleanup */
2734
2735 printf("Closing printers...");
2736 rpccli_spoolss_close_printer( cli, mem_ctx, &hPrinter1 );
2737 rpccli_spoolss_close_printer( cli2, mem_ctx, &hPrinter2 );
2738 printf("ok\n");
2739
2740 /* close the second remote connection */
2741
2742 cli_shutdown( cli_server2 );
2743 return WERR_OK;
2744 }
2745
2746 /* List of commands exported by this module */
2747 struct cmd_set spoolss_commands[] = {
2748
2749 { "SPOOLSS" },
2750
2751 { "adddriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterdriver, &syntax_spoolss, NULL, "Add a print driver", "" },
2752 { "addprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterex, &syntax_spoolss, NULL, "Add a printer", "" },
2753 { "deldriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deletedriver, &syntax_spoolss, NULL, "Delete a printer driver", "" },
2754 { "deldriverex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deletedriverex, &syntax_spoolss, NULL, "Delete a printer driver with files", "" },
2755 { "enumdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data, &syntax_spoolss, NULL, "Enumerate printer data", "" },
2756 { "enumdataex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data_ex, &syntax_spoolss, NULL, "Enumerate printer data for a key", "" },
2757 { "enumkey", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printerkey, &syntax_spoolss, NULL, "Enumerate printer keys", "" },
2758 { "enumjobs", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_jobs, &syntax_spoolss, NULL, "Enumerate print jobs", "" },
2759 { "enumports", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_ports, &syntax_spoolss, NULL, "Enumerate printer ports", "" },
2760 { "enumdrivers", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_drivers, &syntax_spoolss, NULL, "Enumerate installed printer drivers", "" },
2761 { "enumprinters", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printers, &syntax_spoolss, NULL, "Enumerate printers", "" },
2762 { "getdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdata, &syntax_spoolss, NULL, "Get print driver data", "" },
2763 { "getdataex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdataex, &syntax_spoolss, NULL, "Get printer driver data with keyname", ""},
2764 { "getdriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriver, &syntax_spoolss, NULL, "Get print driver information", "" },
2765 { "getdriverdir", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriverdir, &syntax_spoolss, NULL, "Get print driver upload directory", "" },
2766 { "getprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinter, &syntax_spoolss, NULL, "Get printer info", "" },
2767 { "openprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_open_printer_ex, &syntax_spoolss, NULL, "Open printer handle", "" },
2768 { "setdriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setdriver, &syntax_spoolss, NULL, "Set printer driver", "" },
2769 { "getprintprocdir", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprintprocdir, &syntax_spoolss, NULL, "Get print processor directory", "" },
2770 { "addform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addform, &syntax_spoolss, NULL, "Add form", "" },
2771 { "setform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setform, &syntax_spoolss, NULL, "Set form", "" },
2772 { "getform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getform, &syntax_spoolss, NULL, "Get form", "" },
2773 { "deleteform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deleteform, &syntax_spoolss, NULL, "Delete form", "" },
2774 { "enumforms", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_forms, &syntax_spoolss, NULL, "Enumerate forms", "" },
2775 { "setprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinter, &syntax_spoolss, NULL, "Set printer comment", "" },
2776 { "setprintername", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprintername, &syntax_spoolss, NULL, "Set printername", "" },
2777 { "setprinterdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinterdata, &syntax_spoolss, NULL, "Set REG_SZ printer data", "" },
2778 { "rffpcnex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_rffpcnex, &syntax_spoolss, NULL, "Rffpcnex test", "" },
2779 { "printercmp", RPC_RTYPE_WERROR, NULL, cmd_spoolss_printercmp, &syntax_spoolss, NULL, "Printer comparison test", "" },
2780
2781 { NULL }
2782 };
reg import