?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WHATSNEW: Update changes.
[Samba.git] / source3 / rpcclient / cmd_spoolss.c
blob0341b93c42a0a10785c9b8aa5c11aa01f2804b22
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 Copyright (C) Guenther Deschner 2009
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 */
24
25 #include "includes.h"
26 #include "rpcclient.h"
27 #include "../librpc/gen_ndr/cli_spoolss.h"
28 #include "rpc_client/cli_spoolss.h"
29 #include "rpc_client/init_spoolss.h"
30 #include "registry.h"
31 #include "registry/reg_objects.h"
32
33 #define RPCCLIENT_PRINTERNAME(_printername, _cli, _arg) \
34 { \
35 _printername = talloc_asprintf_strupper_m(mem_ctx, "%s\\%s", \
36 _cli->srv_name_slash, _arg); \
37 W_ERROR_HAVE_NO_MEMORY(_printername); \
38 }
39
40 /* The version int is used by getdrivers. Note that
41 all architecture strings that support mutliple
42 versions must be grouped together since enumdrivers
43 uses this property to prevent issuing multiple
44 enumdriver calls for the same arch */
45
46
47 static const struct print_architecture_table_node archi_table[]= {
48
49 {"Windows 4.0", "WIN40", 0 },
50 {"Windows NT x86", "W32X86", 2 },
51 {"Windows NT x86", "W32X86", 3 },
52 {"Windows NT R4000", "W32MIPS", 2 },
53 {"Windows NT Alpha_AXP", "W32ALPHA", 2 },
54 {"Windows NT PowerPC", "W32PPC", 2 },
55 {"Windows IA64", "IA64", 3 },
56 {"Windows x64", "x64", 3 },
57 {NULL, "", -1 }
58 };
59
60 /**
61 * @file
62 *
63 * rpcclient module for SPOOLSS rpc pipe.
64 *
65 * This generally just parses and checks command lines, and then calls
66 * a cli_spoolss function.
67 **/
68
69 /****************************************************************************
70 function to do the mapping between the long architecture name and
71 the short one.
72 ****************************************************************************/
73
74 static const char *cmd_spoolss_get_short_archi(const char *long_archi)
75 {
76 int i=-1;
77
78 DEBUG(107,("Getting architecture dependant directory\n"));
79 do {
80 i++;
81 } while ( (archi_table[i].long_archi!=NULL ) &&
82 StrCaseCmp(long_archi, archi_table[i].long_archi) );
83
84 if (archi_table[i].long_archi==NULL) {
85 DEBUGADD(10,("Unknown architecture [%s] !\n", long_archi));
86 return NULL;
87 }
88
89 /* this might be client code - but shouldn't this be an fstrcpy etc? */
90
91
92 DEBUGADD(108,("index: [%d]\n", i));
93 DEBUGADD(108,("long architecture: [%s]\n", archi_table[i].long_archi));
94 DEBUGADD(108,("short architecture: [%s]\n", archi_table[i].short_archi));
95
96 return archi_table[i].short_archi;
97 }
98
99 /****************************************************************************
100 ****************************************************************************/
101
102 static WERROR cmd_spoolss_open_printer_ex(struct rpc_pipe_client *cli,
103 TALLOC_CTX *mem_ctx,
104 int argc, const char **argv)
105 {
106 WERROR werror;
107 struct policy_handle hnd;
108 uint32_t access_mask = PRINTER_ALL_ACCESS;
109
110 if (argc < 2) {
111 printf("Usage: %s <printername> [access_mask]\n", argv[0]);
112 return WERR_OK;
113 }
114
115 if (argc >= 3) {
116 sscanf(argv[2], "%x", &access_mask);
117 }
118
119 /* Open the printer handle */
120
121 werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
122 argv[1],
123 access_mask,
124 &hnd);
125 if (W_ERROR_IS_OK(werror)) {
126 printf("Printer %s opened successfully\n", argv[1]);
127 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, &werror);
128
129 if (!W_ERROR_IS_OK(werror)) {
130 printf("Error closing printer handle! (%s)\n",
131 get_dos_error_msg(werror));
132 }
133 }
134
135 return werror;
136 }
137
138
139 /****************************************************************************
140 ****************************************************************************/
141
142 static void display_print_info0(struct spoolss_PrinterInfo0 *r)
143 {
144 if (!r)
145 return;
146
147 printf("\tprintername:[%s]\n", r->printername);
148 printf("\tservername:[%s]\n", r->servername);
149 printf("\tcjobs:[0x%x]\n", r->cjobs);
150 printf("\ttotal_jobs:[0x%x]\n", r->total_jobs);
151 printf("\ttotal_bytes:[0x%x]\n", r->total_bytes);
152 printf("\t:date: [%d]-[%d]-[%d] (%d)\n", r->time.year, r->time.month,
153 r->time.day, r->time.day_of_week);
154 printf("\t:time: [%d]-[%d]-[%d]-[%d]\n", r->time.hour, r->time.minute,
155 r->time.second, r->time.millisecond);
156
157 printf("\tglobal_counter:[0x%x]\n", r->global_counter);
158 printf("\ttotal_pages:[0x%x]\n", r->total_pages);
159
160 printf("\tversion:[0x%x]\n", r->version);
161 printf("\tfree_build:[0x%x]\n", r->free_build);
162 printf("\tspooling:[0x%x]\n", r->spooling);
163 printf("\tmax_spooling:[0x%x]\n", r->max_spooling);
164 printf("\tsession_counter:[0x%x]\n", r->session_counter);
165 printf("\tnum_error_out_of_paper:[0x%x]\n", r->num_error_out_of_paper);
166 printf("\tnum_error_not_ready:[0x%x]\n", r->num_error_not_ready);
167 printf("\tjob_error:[0x%x]\n", r->job_error);
168 printf("\tnumber_of_processors:[0x%x]\n", r->number_of_processors);
169 printf("\tprocessor_type:[0x%x]\n", r->processor_type);
170 printf("\thigh_part_total_bytes:[0x%x]\n", r->high_part_total_bytes);
171 printf("\tchange_id:[0x%x]\n", r->change_id);
172 printf("\tlast_error: %s\n", win_errstr(r->last_error));
173 printf("\tstatus:[0x%x]\n", r->status);
174 printf("\tenumerate_network_printers:[0x%x]\n", r->enumerate_network_printers);
175 printf("\tc_setprinter:[0x%x]\n", r->c_setprinter);
176 printf("\tprocessor_architecture:[0x%x]\n", r->processor_architecture);
177 printf("\tprocessor_level:[0x%x]\n", r->processor_level);
178 printf("\tref_ic:[0x%x]\n", r->ref_ic);
179 printf("\treserved2:[0x%x]\n", r->reserved2);
180 printf("\treserved3:[0x%x]\n", r->reserved3);
181
182 printf("\n");
183 }
184
185 /****************************************************************************
186 ****************************************************************************/
187
188 static void display_print_info1(struct spoolss_PrinterInfo1 *r)
189 {
190 printf("\tflags:[0x%x]\n", r->flags);
191 printf("\tname:[%s]\n", r->name);
192 printf("\tdescription:[%s]\n", r->description);
193 printf("\tcomment:[%s]\n", r->comment);
194
195 printf("\n");
196 }
197
198 /****************************************************************************
199 ****************************************************************************/
200
201 static void display_print_info2(struct spoolss_PrinterInfo2 *r)
202 {
203 printf("\tservername:[%s]\n", r->servername);
204 printf("\tprintername:[%s]\n", r->printername);
205 printf("\tsharename:[%s]\n", r->sharename);
206 printf("\tportname:[%s]\n", r->portname);
207 printf("\tdrivername:[%s]\n", r->drivername);
208 printf("\tcomment:[%s]\n", r->comment);
209 printf("\tlocation:[%s]\n", r->location);
210 printf("\tsepfile:[%s]\n", r->sepfile);
211 printf("\tprintprocessor:[%s]\n", r->printprocessor);
212 printf("\tdatatype:[%s]\n", r->datatype);
213 printf("\tparameters:[%s]\n", r->parameters);
214 printf("\tattributes:[0x%x]\n", r->attributes);
215 printf("\tpriority:[0x%x]\n", r->priority);
216 printf("\tdefaultpriority:[0x%x]\n", r->defaultpriority);
217 printf("\tstarttime:[0x%x]\n", r->starttime);
218 printf("\tuntiltime:[0x%x]\n", r->untiltime);
219 printf("\tstatus:[0x%x]\n", r->status);
220 printf("\tcjobs:[0x%x]\n", r->cjobs);
221 printf("\taverageppm:[0x%x]\n", r->averageppm);
222
223 if (r->secdesc)
224 display_sec_desc(r->secdesc);
225
226 printf("\n");
227 }
228
229 /****************************************************************************
230 ****************************************************************************/
231
232 static void display_print_info3(struct spoolss_PrinterInfo3 *r)
233 {
234 display_sec_desc(r->secdesc);
235
236 printf("\n");
237 }
238
239 /****************************************************************************
240 ****************************************************************************/
241
242 static void display_print_info4(struct spoolss_PrinterInfo4 *r)
243 {
244 printf("\tservername:[%s]\n", r->servername);
245 printf("\tprintername:[%s]\n", r->printername);
246 printf("\tattributes:[0x%x]\n", r->attributes);
247 printf("\n");
248 }
249
250 /****************************************************************************
251 ****************************************************************************/
252
253 static void display_print_info5(struct spoolss_PrinterInfo5 *r)
254 {
255 printf("\tprintername:[%s]\n", r->printername);
256 printf("\tportname:[%s]\n", r->portname);
257 printf("\tattributes:[0x%x]\n", r->attributes);
258 printf("\tdevice_not_selected_timeout:[0x%x]\n", r->device_not_selected_timeout);
259 printf("\ttransmission_retry_timeout:[0x%x]\n", r->transmission_retry_timeout);
260 printf("\n");
261 }
262
263 /****************************************************************************
264 ****************************************************************************/
265
266 static void display_print_info6(struct spoolss_PrinterInfo6 *r)
267 {
268 printf("\tstatus:[0x%x]\n", r->status);
269 printf("\n");
270 }
271
272 /****************************************************************************
273 ****************************************************************************/
274
275 static void display_print_info7(struct spoolss_PrinterInfo7 *r)
276 {
277 printf("\tguid:[%s]\n", r->guid);
278 printf("\taction:[0x%x]\n", r->action);
279 printf("\n");
280 }
281
282 /****************************************************************************
283 ****************************************************************************/
284
285 static WERROR cmd_spoolss_enum_printers(struct rpc_pipe_client *cli,
286 TALLOC_CTX *mem_ctx,
287 int argc, const char **argv)
288 {
289 WERROR result;
290 uint32_t level = 1;
291 union spoolss_PrinterInfo *info;
292 uint32_t i, count;
293 const char *name;
294 uint32_t flags = PRINTER_ENUM_LOCAL;
295
296 if (argc > 4) {
297 printf("Usage: %s [level] [name] [flags]\n", argv[0]);
298 return WERR_OK;
299 }
300
301 if (argc >= 2) {
302 level = atoi(argv[1]);
303 }
304
305 if (argc >= 3) {
306 name = argv[2];
307 } else {
308 name = cli->srv_name_slash;
309 }
310
311 if (argc == 4) {
312 flags = atoi(argv[3]);
313 }
314
315 result = rpccli_spoolss_enumprinters(cli, mem_ctx,
316 flags,
317 name,
318 level,
319 0,
320 &count,
321 &info);
322 if (W_ERROR_IS_OK(result)) {
323
324 if (!count) {
325 printf ("No printers returned.\n");
326 goto done;
327 }
328
329 for (i = 0; i < count; i++) {
330 switch (level) {
331 case 0:
332 display_print_info0(&info[i].info0);
333 break;
334 case 1:
335 display_print_info1(&info[i].info1);
336 break;
337 case 2:
338 display_print_info2(&info[i].info2);
339 break;
340 case 3:
341 display_print_info3(&info[i].info3);
342 break;
343 case 4:
344 display_print_info4(&info[i].info4);
345 break;
346 case 5:
347 display_print_info5(&info[i].info5);
348 break;
349 case 6:
350 display_print_info6(&info[i].info6);
351 break;
352 default:
353 printf("unknown info level %d\n", level);
354 goto done;
355 }
356 }
357 }
358 done:
359
360 return result;
361 }
362
363 /****************************************************************************
364 ****************************************************************************/
365
366 static void display_port_info_1(struct spoolss_PortInfo1 *r)
367 {
368 printf("\tPort Name:\t[%s]\n", r->port_name);
369 }
370
371 /****************************************************************************
372 ****************************************************************************/
373
374 static void display_port_info_2(struct spoolss_PortInfo2 *r)
375 {
376 printf("\tPort Name:\t[%s]\n", r->port_name);
377 printf("\tMonitor Name:\t[%s]\n", r->monitor_name);
378 printf("\tDescription:\t[%s]\n", r->description);
379 printf("\tPort Type:\t" );
380 if (r->port_type) {
381 int comma = 0; /* hack */
382 printf( "[" );
383 if (r->port_type & SPOOLSS_PORT_TYPE_READ) {
384 printf( "Read" );
385 comma = 1;
386 }
387 if (r->port_type & SPOOLSS_PORT_TYPE_WRITE) {
388 printf( "%sWrite", comma ? ", " : "" );
389 comma = 1;
390 }
391 /* These two have slightly different interpretations
392 on 95/98/ME but I'm disregarding that for now */
393 if (r->port_type & SPOOLSS_PORT_TYPE_REDIRECTED) {
394 printf( "%sRedirected", comma ? ", " : "" );
395 comma = 1;
396 }
397 if (r->port_type & SPOOLSS_PORT_TYPE_NET_ATTACHED) {
398 printf( "%sNet-Attached", comma ? ", " : "" );
399 }
400 printf( "]\n" );
401 } else {
402 printf( "[Unset]\n" );
403 }
404 printf("\tReserved:\t[%d]\n", r->reserved);
405 printf("\n");
406 }
407
408 /****************************************************************************
409 ****************************************************************************/
410
411 static WERROR cmd_spoolss_enum_ports(struct rpc_pipe_client *cli,
412 TALLOC_CTX *mem_ctx, int argc,
413 const char **argv)
414 {
415 WERROR result;
416 uint32_t level = 1;
417 uint32_t count;
418 union spoolss_PortInfo *info;
419
420 if (argc > 2) {
421 printf("Usage: %s [level]\n", argv[0]);
422 return WERR_OK;
423 }
424
425 if (argc == 2) {
426 level = atoi(argv[1]);
427 }
428
429 /* Enumerate ports */
430
431 result = rpccli_spoolss_enumports(cli, mem_ctx,
432 cli->srv_name_slash,
433 level,
434 0,
435 &count,
436 &info);
437 if (W_ERROR_IS_OK(result)) {
438 int i;
439
440 for (i = 0; i < count; i++) {
441 switch (level) {
442 case 1:
443 display_port_info_1(&info[i].info1);
444 break;
445 case 2:
446 display_port_info_2(&info[i].info2);
447 break;
448 default:
449 printf("unknown info level %d\n", level);
450 break;
451 }
452 }
453 }
454
455 return result;
456 }
457
458 /****************************************************************************
459 ****************************************************************************/
460
461 static WERROR cmd_spoolss_setprinter(struct rpc_pipe_client *cli,
462 TALLOC_CTX *mem_ctx,
463 int argc, const char **argv)
464 {
465 struct policy_handle pol;
466 WERROR result;
467 NTSTATUS status;
468 uint32_t info_level = 2;
469 union spoolss_PrinterInfo info;
470 struct spoolss_SetPrinterInfoCtr info_ctr;
471 struct spoolss_SetPrinterInfo2 info2;
472 const char *printername, *comment = NULL;
473 struct spoolss_DevmodeContainer devmode_ctr;
474 struct sec_desc_buf secdesc_ctr;
475
476 if (argc == 1 || argc > 3) {
477 printf("Usage: %s printername comment\n", argv[0]);
478
479 return WERR_OK;
480 }
481
482 /* Open a printer handle */
483 if (argc == 3) {
484 comment = argv[2];
485 }
486
487 ZERO_STRUCT(devmode_ctr);
488 ZERO_STRUCT(secdesc_ctr);
489
490 RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
491
492 /* get a printer handle */
493 result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
494 printername,
495 PRINTER_ALL_ACCESS,
496 &pol);
497 if (!W_ERROR_IS_OK(result))
498 goto done;
499
500 /* Get printer info */
501 result = rpccli_spoolss_getprinter(cli, mem_ctx,
502 &pol,
503 info_level,
504 0,
505 &info);
506 if (!W_ERROR_IS_OK(result))
507 goto done;
508
509
510 /* Modify the comment. */
511 spoolss_printerinfo2_to_setprinterinfo2(&info.info2, &info2);
512 info2.comment = comment;
513
514 info_ctr.level = 2;
515 info_ctr.info.info2 = &info2;
516
517 status = rpccli_spoolss_SetPrinter(cli, mem_ctx,
518 &pol,
519 &info_ctr,
520 &devmode_ctr,
521 &secdesc_ctr,
522 0, /* command */
523 &result);
524 if (W_ERROR_IS_OK(result))
525 printf("Success in setting comment.\n");
526
527 done:
528 if (is_valid_policy_hnd(&pol))
529 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
530
531 return result;
532 }
533
534 /****************************************************************************
535 ****************************************************************************/
536
537 static WERROR cmd_spoolss_setprintername(struct rpc_pipe_client *cli,
538 TALLOC_CTX *mem_ctx,
539 int argc, const char **argv)
540 {
541 struct policy_handle pol;
542 WERROR result;
543 NTSTATUS status;
544 uint32_t info_level = 2;
545 union spoolss_PrinterInfo info;
546 const char *printername,
547 *new_printername = NULL;
548 struct spoolss_SetPrinterInfoCtr info_ctr;
549 struct spoolss_SetPrinterInfo2 info2;
550 struct spoolss_DevmodeContainer devmode_ctr;
551 struct sec_desc_buf secdesc_ctr;
552
553 ZERO_STRUCT(devmode_ctr);
554 ZERO_STRUCT(secdesc_ctr);
555
556 if (argc == 1 || argc > 3) {
557 printf("Usage: %s printername new_printername\n", argv[0]);
558
559 return WERR_OK;
560 }
561
562 /* Open a printer handle */
563 if (argc == 3) {
564 new_printername = argv[2];
565 }
566
567 RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
568
569 /* get a printer handle */
570 result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
571 printername,
572 PRINTER_ALL_ACCESS,
573 &pol);
574 if (!W_ERROR_IS_OK(result))
575 goto done;
576
577 /* Get printer info */
578 result = rpccli_spoolss_getprinter(cli, mem_ctx,
579 &pol,
580 info_level,
581 0,
582 &info);
583 if (!W_ERROR_IS_OK(result))
584 goto done;
585
586 /* Modify the printername. */
587 spoolss_printerinfo2_to_setprinterinfo2(&info.info2, &info2);
588 info2.printername = new_printername;
589
590 info_ctr.level = 2;
591 info_ctr.info.info2 = &info2;
592
593 status = rpccli_spoolss_SetPrinter(cli, mem_ctx,
594 &pol,
595 &info_ctr,
596 &devmode_ctr,
597 &secdesc_ctr,
598 0, /* command */
599 &result);
600 if (W_ERROR_IS_OK(result))
601 printf("Success in setting printername.\n");
602
603 done:
604 if (is_valid_policy_hnd(&pol))
605 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
606
607 return result;
608 }
609
610 /****************************************************************************
611 ****************************************************************************/
612
613 static WERROR cmd_spoolss_getprinter(struct rpc_pipe_client *cli,
614 TALLOC_CTX *mem_ctx,
615 int argc, const char **argv)
616 {
617 struct policy_handle pol;
618 WERROR result;
619 uint32_t level = 1;
620 const char *printername;
621 union spoolss_PrinterInfo info;
622
623 if (argc == 1 || argc > 3) {
624 printf("Usage: %s <printername> [level]\n", argv[0]);
625 return WERR_OK;
626 }
627
628 /* Open a printer handle */
629 if (argc == 3) {
630 level = atoi(argv[2]);
631 }
632
633 RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
634
635 /* get a printer handle */
636
637 result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
638 printername,
639 SEC_FLAG_MAXIMUM_ALLOWED,
640 &pol);
641 if (!W_ERROR_IS_OK(result)) {
642 goto done;
643 }
644
645 /* Get printer info */
646
647 result = rpccli_spoolss_getprinter(cli, mem_ctx,
648 &pol,
649 level,
650 0,
651 &info);
652 if (!W_ERROR_IS_OK(result)) {
653 goto done;
654 }
655
656 /* Display printer info */
657 switch (level) {
658 case 0:
659 display_print_info0(&info.info0);
660 break;
661 case 1:
662 display_print_info1(&info.info1);
663 break;
664 case 2:
665 display_print_info2(&info.info2);
666 break;
667 case 3:
668 display_print_info3(&info.info3);
669 break;
670 case 4:
671 display_print_info4(&info.info4);
672 break;
673 case 5:
674 display_print_info5(&info.info5);
675 break;
676 case 6:
677 display_print_info6(&info.info6);
678 break;
679 case 7:
680 display_print_info7(&info.info7);
681 break;
682 default:
683 printf("unknown info level %d\n", level);
684 break;
685 }
686 done:
687 if (is_valid_policy_hnd(&pol)) {
688 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
689 }
690
691 return result;
692 }
693
694 /****************************************************************************
695 ****************************************************************************/
696
697 static void display_reg_value(struct regval_blob *value)
698 {
699 const char *text = NULL;
700 DATA_BLOB blob;
701
702 switch(regval_type(value)) {
703 case REG_DWORD:
704 printf("%s: REG_DWORD: 0x%08x\n", regval_name(value),
705 *((uint32_t *) regval_data_p(value)));
706 break;
707 case REG_SZ:
708 blob = data_blob_const(regval_data_p(value), regval_size(value));
709 pull_reg_sz(talloc_tos(), &blob, &text);
710 printf("%s: REG_SZ: %s\n", regval_name(value), text ? text : "");
711 break;
712 case REG_BINARY: {
713 char *hex = hex_encode_talloc(NULL, regval_data_p(value), regval_size(value));
714 size_t i, len;
715 printf("%s: REG_BINARY:", regval_name(value));
716 len = strlen(hex);
717 for (i=0; i<len; i++) {
718 if (hex[i] == '\0') {
719 break;
720 }
721 if (i%40 == 0) {
722 putchar('\n');
723 }
724 putchar(hex[i]);
725 }
726 TALLOC_FREE(hex);
727 putchar('\n');
728 break;
729 }
730 case REG_MULTI_SZ: {
731 uint32_t i;
732 const char **values;
733 blob = data_blob_const(regval_data_p(value), regval_size(value));
734
735 if (!pull_reg_multi_sz(NULL, &blob, &values)) {
736 d_printf("pull_reg_multi_sz failed\n");
737 break;
738 }
739
740 printf("%s: REG_MULTI_SZ: \n", regval_name(value));
741 for (i=0; values[i] != NULL; i++) {
742 d_printf("%s\n", values[i]);
743 }
744 TALLOC_FREE(values);
745 break;
746 }
747 default:
748 printf("%s: unknown type %d\n", regval_name(value), regval_type(value));
749 }
750
751 }
752
753 /****************************************************************************
754 ****************************************************************************/
755
756 static void display_printer_data(const char *v,
757 enum winreg_Type type,
758 uint8_t *data,
759 uint32_t length)
760 {
761 int i;
762 union spoolss_PrinterData r;
763 DATA_BLOB blob = data_blob_const(data, length);
764 WERROR result;
765
766 result = pull_spoolss_PrinterData(talloc_tos(), &blob, &r, type);
767 if (!W_ERROR_IS_OK(result)) {
768 return;
769 }
770
771 switch (type) {
772 case REG_DWORD:
773 printf("%s: REG_DWORD: 0x%08x\n", v, r.value);
774 break;
775 case REG_SZ:
776 printf("%s: REG_SZ: %s\n", v, r.string);
777 break;
778 case REG_BINARY: {
779 char *hex = hex_encode_talloc(NULL,
780 r.binary.data, r.binary.length);
781 size_t len;
782 printf("%s: REG_BINARY:", v);
783 len = strlen(hex);
784 for (i=0; i<len; i++) {
785 if (hex[i] == '\0') {
786 break;
787 }
788 if (i%40 == 0) {
789 putchar('\n');
790 }
791 putchar(hex[i]);
792 }
793 TALLOC_FREE(hex);
794 putchar('\n');
795 break;
796 }
797 case REG_MULTI_SZ:
798 printf("%s: REG_MULTI_SZ: ", v);
799 for (i=0; r.string_array[i] != NULL; i++) {
800 printf("%s ", r.string_array[i]);
801 }
802 printf("\n");
803 break;
804 default:
805 printf("%s: unknown type 0x%02x:\n", v, type);
806 break;
807 }
808 }
809
810 /****************************************************************************
811 ****************************************************************************/
812
813 static WERROR cmd_spoolss_getprinterdata(struct rpc_pipe_client *cli,
814 TALLOC_CTX *mem_ctx,
815 int argc, const char **argv)
816 {
817 struct policy_handle pol;
818 WERROR result;
819 fstring printername;
820 const char *valuename;
821 enum winreg_Type type;
822 uint8_t *data;
823 uint32_t needed;
824
825 if (argc != 3) {
826 printf("Usage: %s <printername> <valuename>\n", argv[0]);
827 printf("<printername> of . queries print server\n");
828 return WERR_OK;
829 }
830 valuename = argv[2];
831
832 /* Open a printer handle */
833
834 if (strncmp(argv[1], ".", sizeof(".")) == 0)
835 fstrcpy(printername, cli->srv_name_slash);
836 else
837 slprintf(printername, sizeof(printername)-1, "%s\\%s",
838 cli->srv_name_slash, argv[1]);
839
840 /* get a printer handle */
841
842 result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
843 printername,
844 SEC_FLAG_MAXIMUM_ALLOWED,
845 &pol);
846 if (!W_ERROR_IS_OK(result))
847 goto done;
848
849 /* Get printer info */
850
851 result = rpccli_spoolss_getprinterdata(cli, mem_ctx,
852 &pol,
853 valuename,
854 0,
855 &type,
856 &needed,
857 &data);
858 if (!W_ERROR_IS_OK(result))
859 goto done;
860
861 /* Display printer data */
862
863 display_printer_data(valuename, type, data, needed);
864
865 done:
866 if (is_valid_policy_hnd(&pol))
867 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
868
869 return result;
870 }
871
872 /****************************************************************************
873 ****************************************************************************/
874
875 static WERROR cmd_spoolss_getprinterdataex(struct rpc_pipe_client *cli,
876 TALLOC_CTX *mem_ctx,
877 int argc, const char **argv)
878 {
879 struct policy_handle pol;
880 WERROR result;
881 NTSTATUS status;
882 fstring printername;
883 const char *valuename, *keyname;
884
885 enum winreg_Type type;
886 uint8_t *data = NULL;
887 uint32_t offered = 0;
888 uint32_t needed;
889
890 if (argc != 4) {
891 printf("Usage: %s <printername> <keyname> <valuename>\n",
892 argv[0]);
893 printf("<printername> of . queries print server\n");
894 return WERR_OK;
895 }
896 valuename = argv[3];
897 keyname = argv[2];
898
899 /* Open a printer handle */
900
901 if (strncmp(argv[1], ".", sizeof(".")) == 0)
902 fstrcpy(printername, cli->srv_name_slash);
903 else
904 slprintf(printername, sizeof(printername)-1, "%s\\%s",
905 cli->srv_name_slash, argv[1]);
906
907 /* get a printer handle */
908
909 result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
910 printername,
911 SEC_FLAG_MAXIMUM_ALLOWED,
912 &pol);
913 if (!W_ERROR_IS_OK(result))
914 goto done;
915
916 /* Get printer info */
917
918 data = talloc_zero_array(mem_ctx, uint8_t, offered);
919 if (!data) {
920 goto done;
921 }
922
923 status = rpccli_spoolss_GetPrinterDataEx(cli, mem_ctx,
924 &pol,
925 keyname,
926 valuename,
927 &type,
928 data,
929 offered,
930 &needed,
931 &result);
932 if (W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
933 offered = needed;
934 data = talloc_zero_array(mem_ctx, uint8_t, offered);
935 if (!data) {
936 goto done;
937 }
938 status = rpccli_spoolss_GetPrinterDataEx(cli, mem_ctx,
939 &pol,
940 keyname,
941 valuename,
942 &type,
943 data,
944 offered,
945 &needed,
946 &result);
947 }
948
949 if (!NT_STATUS_IS_OK(status)) {
950 goto done;
951 }
952
953 if (!W_ERROR_IS_OK(result))
954 goto done;
955
956 /* Display printer data */
957
958 display_printer_data(valuename, type, data, needed);
959
960
961 done:
962 if (is_valid_policy_hnd(&pol))
963 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
964
965 return result;
966 }
967
968 /****************************************************************************
969 ****************************************************************************/
970
971 static void display_print_driver1(struct spoolss_DriverInfo1 *r)
972 {
973 if (!r) {
974 return;
975 }
976
977 printf("Printer Driver Info 1:\n");
978 printf("\tDriver Name: [%s]\n", r->driver_name);
979 printf("\n");
980 }
981
982 /****************************************************************************
983 ****************************************************************************/
984
985 static void display_print_driver2(struct spoolss_DriverInfo2 *r)
986 {
987 if (!r) {
988 return;
989 }
990
991 printf("Printer Driver Info 2:\n");
992 printf("\tVersion: [%x]\n", r->version);
993 printf("\tDriver Name: [%s]\n", r->driver_name);
994 printf("\tArchitecture: [%s]\n", r->architecture);
995 printf("\tDriver Path: [%s]\n", r->driver_path);
996 printf("\tDatafile: [%s]\n", r->data_file);
997 printf("\tConfigfile: [%s]\n", r->config_file);
998 printf("\n");
999 }
1000
1001 /****************************************************************************
1002 ****************************************************************************/
1003
1004 static void display_print_driver3(struct spoolss_DriverInfo3 *r)
1005 {
1006 int i;
1007
1008 if (!r) {
1009 return;
1010 }
1011
1012 printf("Printer Driver Info 3:\n");
1013 printf("\tVersion: [%x]\n", r->version);
1014 printf("\tDriver Name: [%s]\n", r->driver_name);
1015 printf("\tArchitecture: [%s]\n", r->architecture);
1016 printf("\tDriver Path: [%s]\n", r->driver_path);
1017 printf("\tDatafile: [%s]\n", r->data_file);
1018 printf("\tConfigfile: [%s]\n", r->config_file);
1019 printf("\tHelpfile: [%s]\n", r->help_file);
1020
1021 for (i=0; r->dependent_files && r->dependent_files[i] != NULL; i++) {
1022 printf("\tDependentfiles: [%s]\n", r->dependent_files[i]);
1023 }
1024
1025 printf("\tMonitorname: [%s]\n", r->monitor_name);
1026 printf("\tDefaultdatatype: [%s]\n", r->default_datatype);
1027 printf("\n");
1028 }
1029
1030 /****************************************************************************
1031 ****************************************************************************/
1032
1033 static void display_print_driver4(struct spoolss_DriverInfo4 *r)
1034 {
1035 int i;
1036
1037 if (!r) {
1038 return;
1039 }
1040
1041 printf("Printer Driver Info 4:\n");
1042 printf("\tVersion: [%x]\n", r->version);
1043 printf("\tDriver Name: [%s]\n", r->driver_name);
1044 printf("\tArchitecture: [%s]\n", r->architecture);
1045 printf("\tDriver Path: [%s]\n", r->driver_path);
1046 printf("\tDatafile: [%s]\n", r->data_file);
1047 printf("\tConfigfile: [%s]\n", r->config_file);
1048 printf("\tHelpfile: [%s]\n", r->help_file);
1049
1050 for (i=0; r->dependent_files && r->dependent_files[i] != NULL; i++) {
1051 printf("\tDependentfiles: [%s]\n", r->dependent_files[i]);
1052 }
1053
1054 printf("\tMonitorname: [%s]\n", r->monitor_name);
1055 printf("\tDefaultdatatype: [%s]\n", r->default_datatype);
1056
1057 for (i=0; r->previous_names && r->previous_names[i] != NULL; i++) {
1058 printf("\tPrevious Names: [%s]\n", r->previous_names[i]);
1059 }
1060 printf("\n");
1061 }
1062
1063 /****************************************************************************
1064 ****************************************************************************/
1065
1066 static void display_print_driver5(struct spoolss_DriverInfo5 *r)
1067 {
1068 if (!r) {
1069 return;
1070 }
1071
1072 printf("Printer Driver Info 5:\n");
1073 printf("\tVersion: [%x]\n", r->version);
1074 printf("\tDriver Name: [%s]\n", r->driver_name);
1075 printf("\tArchitecture: [%s]\n", r->architecture);
1076 printf("\tDriver Path: [%s]\n", r->driver_path);
1077 printf("\tDatafile: [%s]\n", r->data_file);
1078 printf("\tConfigfile: [%s]\n", r->config_file);
1079 printf("\tDriver Attributes: [0x%x]\n", r->driver_attributes);
1080 printf("\tConfig Version: [0x%x]\n", r->config_version);
1081 printf("\tDriver Version: [0x%x]\n", r->driver_version);
1082 printf("\n");
1083 }
1084
1085 /****************************************************************************
1086 ****************************************************************************/
1087
1088 static void display_print_driver6(struct spoolss_DriverInfo6 *r)
1089 {
1090 int i;
1091
1092 if (!r) {
1093 return;
1094 }
1095
1096 printf("Printer Driver Info 6:\n");
1097 printf("\tVersion: [%x]\n", r->version);
1098 printf("\tDriver Name: [%s]\n", r->driver_name);
1099 printf("\tArchitecture: [%s]\n", r->architecture);
1100 printf("\tDriver Path: [%s]\n", r->driver_path);
1101 printf("\tDatafile: [%s]\n", r->data_file);
1102 printf("\tConfigfile: [%s]\n", r->config_file);
1103 printf("\tHelpfile: [%s]\n", r->help_file);
1104
1105 for (i=0; r->dependent_files && r->dependent_files[i] != NULL; i++) {
1106 printf("\tDependentfiles: [%s]\n", r->dependent_files[i]);
1107 }
1108
1109 printf("\tMonitorname: [%s]\n", r->monitor_name);
1110 printf("\tDefaultdatatype: [%s]\n", r->default_datatype);
1111
1112 for (i=0; r->previous_names && r->previous_names[i] != NULL; i++) {
1113 printf("\tPrevious Names: [%s]\n", r->previous_names[i]);
1114 }
1115
1116 printf("\tDriver Date: [%s]\n", nt_time_string(talloc_tos(), r->driver_date));
1117 printf("\tDriver Version: [0x%016llx]\n", (long long unsigned int)r->driver_version);
1118 printf("\tManufacturer Name: [%s]\n", r->manufacturer_name);
1119 printf("\tManufacturer Url: [%s]\n", r->manufacturer_url);
1120 printf("\tHardware ID: [%s]\n", r->hardware_id);
1121 printf("\tProvider: [%s]\n", r->provider);
1122
1123 printf("\n");
1124 }
1125
1126 /****************************************************************************
1127 ****************************************************************************/
1128
1129 static void display_print_driver8(struct spoolss_DriverInfo8 *r)
1130 {
1131 int i;
1132
1133 if (!r) {
1134 return;
1135 }
1136
1137 printf("Printer Driver Info 8:\n");
1138 printf("\tVersion: [%x]\n", r->version);
1139 printf("\tDriver Name: [%s]\n", r->driver_name);
1140 printf("\tArchitecture: [%s]\n", r->architecture);
1141 printf("\tDriver Path: [%s]\n", r->driver_path);
1142 printf("\tDatafile: [%s]\n", r->data_file);
1143 printf("\tConfigfile: [%s]\n", r->config_file);
1144 printf("\tHelpfile: [%s]\n", r->help_file);
1145 printf("\tMonitorname: [%s]\n", r->monitor_name);
1146 printf("\tDefaultdatatype: [%s]\n", r->default_datatype);
1147
1148 for (i=0; r->dependent_files && r->dependent_files[i] != NULL; i++) {
1149 printf("\tDependentfiles: [%s]\n", r->dependent_files[i]);
1150 }
1151
1152 for (i=0; r->previous_names && r->previous_names[i] != NULL; i++) {
1153 printf("\tPrevious Names: [%s]\n", r->previous_names[i]);
1154 }
1155
1156 printf("\tDriver Date: [%s]\n", nt_time_string(talloc_tos(), r->driver_date));
1157 printf("\tDriver Version: [0x%016llx]\n", (long long unsigned int)r->driver_version);
1158 printf("\tManufacturer Name: [%s]\n", r->manufacturer_name);
1159 printf("\tManufacturer Url: [%s]\n", r->manufacturer_url);
1160 printf("\tHardware ID: [%s]\n", r->hardware_id);
1161 printf("\tProvider: [%s]\n", r->provider);
1162 printf("\tPrint Processor: [%s]\n", r->print_processor);
1163 printf("\tVendor Setup: [%s]\n", r->vendor_setup);
1164 for (i=0; r->color_profiles && r->color_profiles[i] != NULL; i++) {
1165 printf("\tColor Profiles: [%s]\n", r->color_profiles[i]);
1166 }
1167 printf("\tInf Path: [%s]\n", r->inf_path);
1168 printf("\tPrinter Driver Attributes: [0x%x]\n", r->printer_driver_attributes);
1169 for (i=0; r->core_driver_dependencies && r->core_driver_dependencies[i] != NULL; i++) {
1170 printf("\tCore Driver Dependencies: [%s]\n", r->core_driver_dependencies[i]);
1171 }
1172 printf("\tMin Driver Inbox Driver Version Date: [%s]\n", nt_time_string(talloc_tos(), r->min_inbox_driver_ver_date));
1173 printf("\tMin Driver Inbox Driver Version Version: [0x%016llx]\n",
1174 (long long unsigned int)r->min_inbox_driver_ver_version);
1175
1176 printf("\n");
1177 }
1178
1179 /****************************************************************************
1180 ****************************************************************************/
1181
1182 static WERROR cmd_spoolss_getdriver(struct rpc_pipe_client *cli,
1183 TALLOC_CTX *mem_ctx,
1184 int argc, const char **argv)
1185 {
1186 struct policy_handle pol;
1187 WERROR werror;
1188 uint32_t level = 3;
1189 const char *printername;
1190 uint32_t i;
1191 bool success = false;
1192 union spoolss_DriverInfo info;
1193 uint32_t server_major_version;
1194 uint32_t server_minor_version;
1195
1196 if ((argc == 1) || (argc > 3)) {
1197 printf("Usage: %s <printername> [level]\n", argv[0]);
1198 return WERR_OK;
1199 }
1200
1201 /* get the arguments need to open the printer handle */
1202
1203 RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
1204
1205 if (argc == 3) {
1206 level = atoi(argv[2]);
1207 }
1208
1209 /* Open a printer handle */
1210
1211 werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
1212 printername,
1213 PRINTER_ACCESS_USE,
1214 &pol);
1215 if (!W_ERROR_IS_OK(werror)) {
1216 printf("Error opening printer handle for %s!\n", printername);
1217 return werror;
1218 }
1219
1220 /* loop through and print driver info level for each architecture */
1221
1222 for (i=0; archi_table[i].long_archi!=NULL; i++) {
1223
1224 werror = rpccli_spoolss_getprinterdriver2(cli, mem_ctx,
1225 &pol,
1226 archi_table[i].long_archi,
1227 level,
1228 0, /* offered */
1229 archi_table[i].version,
1230 2,
1231 &info,
1232 &server_major_version,
1233 &server_minor_version);
1234 if (!W_ERROR_IS_OK(werror)) {
1235 continue;
1236 }
1237
1238 /* need at least one success */
1239
1240 success = true;
1241
1242 printf("\n[%s]\n", archi_table[i].long_archi);
1243
1244 switch (level) {
1245 case 1:
1246 display_print_driver1(&info.info1);
1247 break;
1248 case 2:
1249 display_print_driver2(&info.info2);
1250 break;
1251 case 3:
1252 display_print_driver3(&info.info3);
1253 break;
1254 case 4:
1255 display_print_driver4(&info.info4);
1256 break;
1257 case 5:
1258 display_print_driver5(&info.info5);
1259 break;
1260 case 6:
1261 display_print_driver6(&info.info6);
1262 break;
1263 case 8:
1264 display_print_driver8(&info.info8);
1265 break;
1266 default:
1267 printf("unknown info level %d\n", level);
1268 break;
1269 }
1270 }
1271
1272 /* Cleanup */
1273
1274 if (is_valid_policy_hnd(&pol)) {
1275 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
1276 }
1277
1278 if (success) {
1279 werror = WERR_OK;
1280 }
1281
1282 return werror;
1283 }
1284
1285 /****************************************************************************
1286 ****************************************************************************/
1287
1288 static WERROR enum_driver_by_architecture(struct rpc_pipe_client *cli,
1289 TALLOC_CTX *mem_ctx,
1290 const char *architecture,
1291 uint32_t level)
1292 {
1293 WERROR werror;
1294 uint32_t count = 0;
1295 union spoolss_DriverInfo *info = NULL;
1296 uint32_t j;
1297
1298 werror = rpccli_spoolss_enumprinterdrivers(cli, mem_ctx,
1299 cli->srv_name_slash,
1300 architecture,
1301 level,
1302 0,
1303 &count,
1304 &info);
1305
1306 if (W_ERROR_EQUAL(werror, WERR_INVALID_ENVIRONMENT)) {
1307 printf("Server does not support environment [%s]\n",
1308 architecture);
1309 return WERR_OK;
1310 }
1311
1312 if (count == 0) {
1313 return WERR_OK;
1314 }
1315
1316 if (!W_ERROR_IS_OK(werror)) {
1317 printf("Error getting driver for environment [%s] - %s\n",
1318 architecture, win_errstr(werror));
1319 return werror;
1320 }
1321
1322 printf("\n[%s]\n", architecture);
1323
1324 switch (level) {
1325 case 1:
1326 for (j=0; j < count; j++) {
1327 display_print_driver1(&info[j].info1);
1328 }
1329 break;
1330 case 2:
1331 for (j=0; j < count; j++) {
1332 display_print_driver2(&info[j].info2);
1333 }
1334 break;
1335 case 3:
1336 for (j=0; j < count; j++) {
1337 display_print_driver3(&info[j].info3);
1338 }
1339 break;
1340 case 4:
1341 for (j=0; j < count; j++) {
1342 display_print_driver4(&info[j].info4);
1343 }
1344 break;
1345 case 5:
1346 for (j=0; j < count; j++) {
1347 display_print_driver5(&info[j].info5);
1348 }
1349 break;
1350 case 6:
1351 for (j=0; j < count; j++) {
1352 display_print_driver6(&info[j].info6);
1353 }
1354 break;
1355 case 8:
1356 for (j=0; j < count; j++) {
1357 display_print_driver8(&info[j].info8);
1358 }
1359 break;
1360 default:
1361 printf("unknown info level %d\n", level);
1362 return WERR_UNKNOWN_LEVEL;
1363 }
1364
1365 return werror;
1366 }
1367
1368 static WERROR cmd_spoolss_enum_drivers(struct rpc_pipe_client *cli,
1369 TALLOC_CTX *mem_ctx,
1370 int argc, const char **argv)
1371 {
1372 WERROR werror = WERR_OK;
1373 uint32_t level = 1;
1374 uint32_t i;
1375 const char *architecture = NULL;
1376
1377 if (argc > 3) {
1378 printf("Usage: enumdrivers [level] [architecture]\n");
1379 return WERR_OK;
1380 }
1381
1382 if (argc >= 2) {
1383 level = atoi(argv[1]);
1384 }
1385
1386 if (argc == 3) {
1387 architecture = argv[2];
1388 }
1389
1390 if (architecture) {
1391 return enum_driver_by_architecture(cli, mem_ctx,
1392 architecture,
1393 level);
1394 }
1395
1396 /* loop through and print driver info level for each architecture */
1397 for (i=0; archi_table[i].long_archi!=NULL; i++) {
1398 /* check to see if we already asked for this architecture string */
1399
1400 if (i>0 && strequal(archi_table[i].long_archi, archi_table[i-1].long_archi)) {
1401 continue;
1402 }
1403
1404 werror = enum_driver_by_architecture(cli, mem_ctx,
1405 archi_table[i].long_archi,
1406 level);
1407 if (!W_ERROR_IS_OK(werror)) {
1408 break;
1409 }
1410 }
1411
1412 return werror;
1413 }
1414
1415 /****************************************************************************
1416 ****************************************************************************/
1417
1418 static void display_printdriverdir_1(struct spoolss_DriverDirectoryInfo1 *r)
1419 {
1420 printf("\tDirectory Name:[%s]\n", r->directory_name);
1421 }
1422
1423 /****************************************************************************
1424 ****************************************************************************/
1425
1426 static WERROR cmd_spoolss_getdriverdir(struct rpc_pipe_client *cli,
1427 TALLOC_CTX *mem_ctx,
1428 int argc, const char **argv)
1429 {
1430 WERROR result;
1431 NTSTATUS status;
1432 const char *env = SPOOLSS_ARCHITECTURE_NT_X86;
1433 DATA_BLOB buffer;
1434 uint32_t offered;
1435 union spoolss_DriverDirectoryInfo info;
1436 uint32_t needed;
1437
1438 if (argc > 2) {
1439 printf("Usage: %s [environment]\n", argv[0]);
1440 return WERR_OK;
1441 }
1442
1443 /* Get the arguments need to open the printer handle */
1444
1445 if (argc == 2) {
1446 env = argv[1];
1447 }
1448
1449 /* Get the directory. Only use Info level 1 */
1450
1451 status = rpccli_spoolss_GetPrinterDriverDirectory(cli, mem_ctx,
1452 cli->srv_name_slash,
1453 env,
1454 1,
1455 NULL, /* buffer */
1456 0, /* offered */
1457 NULL, /* info */
1458 &needed,
1459 &result);
1460 if (W_ERROR_EQUAL(result, WERR_INSUFFICIENT_BUFFER)) {
1461 offered = needed;
1462 buffer = data_blob_talloc_zero(mem_ctx, needed);
1463
1464 status = rpccli_spoolss_GetPrinterDriverDirectory(cli, mem_ctx,
1465 cli->srv_name_slash,
1466 env,
1467 1,
1468 &buffer,
1469 offered,
1470 &info,
1471 &needed,
1472 &result);
1473 }
1474
1475 if (W_ERROR_IS_OK(result)) {
1476 display_printdriverdir_1(&info.info1);
1477 }
1478
1479 return result;
1480 }
1481
1482 /****************************************************************************
1483 ****************************************************************************/
1484
1485 static void set_drv_info_3_env(TALLOC_CTX *mem_ctx,
1486 struct spoolss_AddDriverInfo3 *info,
1487 const char *arch)
1488 {
1489
1490 int i;
1491
1492 for (i=0; archi_table[i].long_archi != NULL; i++)
1493 {
1494 if (strcmp(arch, archi_table[i].short_archi) == 0)
1495 {
1496 info->version = archi_table[i].version;
1497 info->architecture = talloc_strdup(mem_ctx, archi_table[i].long_archi);
1498 break;
1499 }
1500 }
1501
1502 if (archi_table[i].long_archi == NULL)
1503 {
1504 DEBUG(0, ("set_drv_info_3_env: Unknown arch [%s]\n", arch));
1505 }
1506
1507 return;
1508 }
1509
1510
1511 /**************************************************************************
1512 wrapper for strtok to get the next parameter from a delimited list.
1513 Needed to handle the empty parameter string denoted by "NULL"
1514 *************************************************************************/
1515
1516 static char *get_driver_3_param(TALLOC_CTX *mem_ctx, char *str,
1517 const char *delim, const char **dest,
1518 char **saveptr)
1519 {
1520 char *ptr;
1521
1522 /* get the next token */
1523 ptr = strtok_r(str, delim, saveptr);
1524
1525 /* a string of 'NULL' is used to represent an empty
1526 parameter because two consecutive delimiters
1527 will not return an empty string. See man strtok(3)
1528 for details */
1529 if (ptr && (StrCaseCmp(ptr, "NULL") == 0)) {
1530 ptr = NULL;
1531 }
1532
1533 if (dest != NULL) {
1534 *dest = talloc_strdup(mem_ctx, ptr);
1535 }
1536
1537 return ptr;
1538 }
1539
1540 /********************************************************************************
1541 fill in the members of a spoolss_AddDriverInfo3 struct using a character
1542 string in the form of
1543 <Long Printer Name>:<Driver File Name>:<Data File Name>:\
1544 <Config File Name>:<Help File Name>:<Language Monitor Name>:\
1545 <Default Data Type>:<Comma Separated list of Files>
1546 *******************************************************************************/
1547
1548 static bool init_drv_info_3_members(TALLOC_CTX *mem_ctx, struct spoolss_AddDriverInfo3 *r,
1549 char *args)
1550 {
1551 char *str, *str2;
1552 int count = 0;
1553 char *saveptr = NULL;
1554 struct spoolss_StringArray *deps;
1555 const char **file_array = NULL;
1556 int i;
1557
1558 /* fill in the UNISTR fields */
1559 str = get_driver_3_param(mem_ctx, args, ":", &r->driver_name, &saveptr);
1560 str = get_driver_3_param(mem_ctx, NULL, ":", &r->driver_path, &saveptr);
1561 str = get_driver_3_param(mem_ctx, NULL, ":", &r->data_file, &saveptr);
1562 str = get_driver_3_param(mem_ctx, NULL, ":", &r->config_file, &saveptr);
1563 str = get_driver_3_param(mem_ctx, NULL, ":", &r->help_file, &saveptr);
1564 str = get_driver_3_param(mem_ctx, NULL, ":", &r->monitor_name, &saveptr);
1565 str = get_driver_3_param(mem_ctx, NULL, ":", &r->default_datatype, &saveptr);
1566
1567 /* <Comma Separated List of Dependent Files> */
1568 /* save the beginning of the string */
1569 str2 = get_driver_3_param(mem_ctx, NULL, ":", NULL, &saveptr);
1570 str = str2;
1571
1572 /* begin to strip out each filename */
1573 str = strtok_r(str, ",", &saveptr);
1574
1575 /* no dependent files, we are done */
1576 if (!str) {
1577 return true;
1578 }
1579
1580 deps = talloc_zero(mem_ctx, struct spoolss_StringArray);
1581 if (!deps) {
1582 return false;
1583 }
1584
1585 while (str != NULL) {
1586 add_string_to_array(deps, str, &file_array, &count);
1587 str = strtok_r(NULL, ",", &saveptr);
1588 }
1589
1590 deps->string = talloc_zero_array(deps, const char *, count + 1);
1591 if (!deps->string) {
1592 return false;
1593 }
1594
1595 for (i=0; i < count; i++) {
1596 deps->string[i] = file_array[i];
1597 }
1598
1599 r->dependent_files = deps;
1600
1601 return true;
1602 }
1603
1604 /****************************************************************************
1605 ****************************************************************************/
1606
1607 static WERROR cmd_spoolss_addprinterdriver(struct rpc_pipe_client *cli,
1608 TALLOC_CTX *mem_ctx,
1609 int argc, const char **argv)
1610 {
1611 WERROR result;
1612 NTSTATUS status;
1613 uint32_t level = 3;
1614 struct spoolss_AddDriverInfoCtr info_ctr;
1615 struct spoolss_AddDriverInfo3 info3;
1616 const char *arch;
1617 char *driver_args;
1618
1619 /* parse the command arguments */
1620 if (argc != 3 && argc != 4)
1621 {
1622 printf ("Usage: %s <Environment> \\\n", argv[0]);
1623 printf ("\t<Long Printer Name>:<Driver File Name>:<Data File Name>:\\\n");
1624 printf ("\t<Config File Name>:<Help File Name>:<Language Monitor Name>:\\\n");
1625 printf ("\t<Default Data Type>:<Comma Separated list of Files> \\\n");
1626 printf ("\t[version]\n");
1627
1628 return WERR_OK;
1629 }
1630
1631 /* Fill in the spoolss_AddDriverInfo3 struct */
1632 ZERO_STRUCT(info3);
1633
1634 arch = cmd_spoolss_get_short_archi(argv[1]);
1635 if (!arch) {
1636 printf ("Error Unknown architechture [%s]\n", argv[1]);
1637 return WERR_INVALID_PARAM;
1638 }
1639
1640 set_drv_info_3_env(mem_ctx, &info3, arch);
1641
1642 driver_args = talloc_strdup( mem_ctx, argv[2] );
1643 if (!init_drv_info_3_members(mem_ctx, &info3, driver_args ))
1644 {
1645 printf ("Error Invalid parameter list - %s.\n", argv[2]);
1646 return WERR_INVALID_PARAM;
1647 }
1648
1649 /* if printer driver version specified, override the default version
1650 * used by the architecture. This allows installation of Windows
1651 * 2000 (version 3) printer drivers. */
1652 if (argc == 4)
1653 {
1654 info3.version = atoi(argv[3]);
1655 }
1656
1657
1658 info_ctr.level = level;
1659 info_ctr.info.info3 = &info3;
1660
1661 status = rpccli_spoolss_AddPrinterDriver(cli, mem_ctx,
1662 cli->srv_name_slash,
1663 &info_ctr,
1664 &result);
1665 if (!NT_STATUS_IS_OK(status)) {
1666 return ntstatus_to_werror(status);
1667 }
1668 if (W_ERROR_IS_OK(result)) {
1669 printf ("Printer Driver %s successfully installed.\n",
1670 info3.driver_name);
1671 }
1672
1673 return result;
1674 }
1675
1676
1677 /****************************************************************************
1678 ****************************************************************************/
1679
1680 static WERROR cmd_spoolss_addprinterex(struct rpc_pipe_client *cli,
1681 TALLOC_CTX *mem_ctx,
1682 int argc, const char **argv)
1683 {
1684 WERROR result;
1685 struct spoolss_SetPrinterInfoCtr info_ctr;
1686 struct spoolss_SetPrinterInfo2 info2;
1687
1688 /* parse the command arguments */
1689 if (argc != 5)
1690 {
1691 printf ("Usage: %s <name> <shared name> <driver> <port>\n", argv[0]);
1692 return WERR_OK;
1693 }
1694
1695 /* Fill in the DRIVER_INFO_2 struct */
1696 ZERO_STRUCT(info2);
1697
1698 info2.printername = argv[1];
1699 info2.drivername = argv[3];
1700 info2.sharename = argv[2];
1701 info2.portname = argv[4];
1702 info2.comment = "Created by rpcclient";
1703 info2.printprocessor = "winprint";
1704 info2.datatype = "RAW";
1705 info2.devmode_ptr = 0;
1706 info2.secdesc_ptr = 0;
1707 info2.attributes = PRINTER_ATTRIBUTE_SHARED;
1708 info2.priority = 0;
1709 info2.defaultpriority = 0;
1710 info2.starttime = 0;
1711 info2.untiltime = 0;
1712
1713 /* These three fields must not be used by AddPrinter()
1714 as defined in the MS Platform SDK documentation..
1715 --jerry
1716 info2.status = 0;
1717 info2.cjobs = 0;
1718 info2.averageppm = 0;
1719 */
1720
1721 info_ctr.level = 2;
1722 info_ctr.info.info2 = &info2;
1723
1724 result = rpccli_spoolss_addprinterex(cli, mem_ctx,
1725 &info_ctr);
1726 if (W_ERROR_IS_OK(result))
1727 printf ("Printer %s successfully installed.\n", argv[1]);
1728
1729 return result;
1730 }
1731
1732 /****************************************************************************
1733 ****************************************************************************/
1734
1735 static WERROR cmd_spoolss_setdriver(struct rpc_pipe_client *cli,
1736 TALLOC_CTX *mem_ctx,
1737 int argc, const char **argv)
1738 {
1739 struct policy_handle pol;
1740 WERROR result;
1741 NTSTATUS status;
1742 uint32_t level = 2;
1743 const char *printername;
1744 union spoolss_PrinterInfo info;
1745 struct spoolss_SetPrinterInfoCtr info_ctr;
1746 struct spoolss_SetPrinterInfo2 info2;
1747 struct spoolss_DevmodeContainer devmode_ctr;
1748 struct sec_desc_buf secdesc_ctr;
1749
1750 ZERO_STRUCT(devmode_ctr);
1751 ZERO_STRUCT(secdesc_ctr);
1752
1753 /* parse the command arguments */
1754 if (argc != 3)
1755 {
1756 printf ("Usage: %s <printer> <driver>\n", argv[0]);
1757 return WERR_OK;
1758 }
1759
1760 RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
1761
1762 /* Get a printer handle */
1763
1764 result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
1765 printername,
1766 PRINTER_ALL_ACCESS,
1767 &pol);
1768 if (!W_ERROR_IS_OK(result))
1769 goto done;
1770
1771 /* Get printer info */
1772
1773 result = rpccli_spoolss_getprinter(cli, mem_ctx,
1774 &pol,
1775 level,
1776 0,
1777 &info);
1778 if (!W_ERROR_IS_OK(result)) {
1779 printf ("Unable to retrieve printer information!\n");
1780 goto done;
1781 }
1782
1783 /* Set the printer driver */
1784
1785 spoolss_printerinfo2_to_setprinterinfo2(&info.info2, &info2);
1786 info2.drivername = argv[2];
1787
1788 info_ctr.level = 2;
1789 info_ctr.info.info2 = &info2;
1790
1791 status = rpccli_spoolss_SetPrinter(cli, mem_ctx,
1792 &pol,
1793 &info_ctr,
1794 &devmode_ctr,
1795 &secdesc_ctr,
1796 0, /* command */
1797 &result);
1798 if (!W_ERROR_IS_OK(result)) {
1799 printf("SetPrinter call failed!\n");
1800 goto done;;
1801 }
1802
1803 printf("Successfully set %s to driver %s.\n", argv[1], argv[2]);
1804
1805 done:
1806 /* Cleanup */
1807
1808 if (is_valid_policy_hnd(&pol))
1809 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
1810
1811 return result;
1812 }
1813
1814
1815 /****************************************************************************
1816 ****************************************************************************/
1817
1818 static WERROR cmd_spoolss_deletedriverex(struct rpc_pipe_client *cli,
1819 TALLOC_CTX *mem_ctx,
1820 int argc, const char **argv)
1821 {
1822 WERROR result, ret = WERR_UNKNOWN_PRINTER_DRIVER;
1823 NTSTATUS status;
1824
1825 int i;
1826 int vers = -1;
1827
1828 const char *arch = NULL;
1829 uint32_t delete_flags = 0;
1830
1831 /* parse the command arguments */
1832 if (argc < 2 || argc > 4) {
1833 printf ("Usage: %s <driver> [arch] [version]\n", argv[0]);
1834 return WERR_OK;
1835 }
1836
1837 if (argc >= 3)
1838 arch = argv[2];
1839 if (argc == 4)
1840 vers = atoi (argv[3]);
1841
1842 if (vers >= 0) {
1843 delete_flags |= DPD_DELETE_SPECIFIC_VERSION;
1844 }
1845
1846 /* delete the driver for all architectures */
1847 for (i=0; archi_table[i].long_archi; i++) {
1848
1849 if (arch && !strequal( archi_table[i].long_archi, arch))
1850 continue;
1851
1852 if (vers >= 0 && archi_table[i].version != vers)
1853 continue;
1854
1855 /* make the call to remove the driver */
1856 status = rpccli_spoolss_DeletePrinterDriverEx(cli, mem_ctx,
1857 cli->srv_name_slash,
1858 archi_table[i].long_archi,
1859 argv[1],
1860 delete_flags,
1861 archi_table[i].version,
1862 &result);
1863
1864 if ( !W_ERROR_IS_OK(result) )
1865 {
1866 if ( !W_ERROR_EQUAL(result, WERR_UNKNOWN_PRINTER_DRIVER) ) {
1867 printf ("Failed to remove driver %s for arch [%s] (version: %d): %s\n",
1868 argv[1], archi_table[i].long_archi, archi_table[i].version, win_errstr(result));
1869 }
1870 }
1871 else
1872 {
1873 printf ("Driver %s and files removed for arch [%s] (version: %d).\n", argv[1],
1874 archi_table[i].long_archi, archi_table[i].version);
1875 ret = WERR_OK;
1876 }
1877 }
1878
1879 return ret;
1880 }
1881
1882
1883 /****************************************************************************
1884 ****************************************************************************/
1885
1886 static WERROR cmd_spoolss_deletedriver(struct rpc_pipe_client *cli,
1887 TALLOC_CTX *mem_ctx,
1888 int argc, const char **argv)
1889 {
1890 WERROR result = WERR_OK;
1891 NTSTATUS status;
1892 int i;
1893
1894 /* parse the command arguments */
1895 if (argc != 2) {
1896 printf ("Usage: %s <driver>\n", argv[0]);
1897 return WERR_OK;
1898 }
1899
1900 /* delete the driver for all architectures */
1901 for (i=0; archi_table[i].long_archi; i++) {
1902 /* make the call to remove the driver */
1903 status = rpccli_spoolss_DeletePrinterDriver(cli, mem_ctx,
1904 cli->srv_name_slash,
1905 archi_table[i].long_archi,
1906 argv[1],
1907 &result);
1908 if (!NT_STATUS_IS_OK(status)) {
1909 return result;
1910 }
1911 if ( !W_ERROR_IS_OK(result) ) {
1912 if ( !W_ERROR_EQUAL(result, WERR_UNKNOWN_PRINTER_DRIVER) ) {
1913 printf ("Failed to remove driver %s for arch [%s] - error 0x%x!\n",
1914 argv[1], archi_table[i].long_archi,
1915 W_ERROR_V(result));
1916 }
1917 } else {
1918 printf ("Driver %s removed for arch [%s].\n", argv[1],
1919 archi_table[i].long_archi);
1920 }
1921 }
1922
1923 return result;
1924 }
1925
1926 /****************************************************************************
1927 ****************************************************************************/
1928
1929 static WERROR cmd_spoolss_getprintprocdir(struct rpc_pipe_client *cli,
1930 TALLOC_CTX *mem_ctx,
1931 int argc, const char **argv)
1932 {
1933 WERROR result;
1934 NTSTATUS status;
1935 const char *environment = SPOOLSS_ARCHITECTURE_NT_X86;
1936 DATA_BLOB buffer;
1937 uint32_t offered;
1938 union spoolss_PrintProcessorDirectoryInfo info;
1939 uint32_t needed;
1940
1941 /* parse the command arguments */
1942 if (argc > 2) {
1943 printf ("Usage: %s [environment]\n", argv[0]);
1944 return WERR_OK;
1945 }
1946
1947 if (argc == 2) {
1948 environment = argv[1];
1949 }
1950
1951 status = rpccli_spoolss_GetPrintProcessorDirectory(cli, mem_ctx,
1952 cli->srv_name_slash,
1953 environment,
1954 1,
1955 NULL, /* buffer */
1956 0, /* offered */
1957 NULL, /* info */
1958 &needed,
1959 &result);
1960 if (W_ERROR_EQUAL(result, WERR_INSUFFICIENT_BUFFER)) {
1961 offered = needed;
1962 buffer = data_blob_talloc_zero(mem_ctx, needed);
1963
1964 status = rpccli_spoolss_GetPrintProcessorDirectory(cli, mem_ctx,
1965 cli->srv_name_slash,
1966 environment,
1967 1,
1968 &buffer,
1969 offered,
1970 &info,
1971 &needed,
1972 &result);
1973 }
1974
1975 if (W_ERROR_IS_OK(result)) {
1976 printf("%s\n", info.info1.directory_name);
1977 }
1978
1979 return result;
1980 }
1981
1982 /****************************************************************************
1983 ****************************************************************************/
1984
1985 static WERROR cmd_spoolss_addform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1986 int argc, const char **argv)
1987 {
1988 struct policy_handle handle;
1989 WERROR werror;
1990 NTSTATUS status;
1991 const char *printername;
1992 union spoolss_AddFormInfo info;
1993 struct spoolss_AddFormInfo1 info1;
1994 struct spoolss_AddFormInfo2 info2;
1995 uint32_t level = 1;
1996
1997 /* Parse the command arguments */
1998
1999 if (argc < 3 || argc > 5) {
2000 printf ("Usage: %s <printer> <formname> [level]\n", argv[0]);
2001 return WERR_OK;
2002 }
2003
2004 /* Get a printer handle */
2005
2006 RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2007
2008 werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2009 printername,
2010 PRINTER_ALL_ACCESS,
2011 &handle);
2012 if (!W_ERROR_IS_OK(werror))
2013 goto done;
2014
2015 /* Dummy up some values for the form data */
2016
2017 if (argc == 4) {
2018 level = atoi(argv[3]);
2019 }
2020
2021 switch (level) {
2022 case 1:
2023 info1.flags = SPOOLSS_FORM_USER;
2024 info1.form_name = argv[2];
2025 info1.size.width = 100;
2026 info1.size.height = 100;
2027 info1.area.left = 0;
2028 info1.area.top = 10;
2029 info1.area.right = 20;
2030 info1.area.bottom = 30;
2031
2032 info.info1 = &info1;
2033
2034 break;
2035 case 2:
2036 info2.flags = SPOOLSS_FORM_USER;
2037 info2.form_name = argv[2];
2038 info2.size.width = 100;
2039 info2.size.height = 100;
2040 info2.area.left = 0;
2041 info2.area.top = 10;
2042 info2.area.right = 20;
2043 info2.area.bottom = 30;
2044 info2.keyword = argv[2];
2045 info2.string_type = SPOOLSS_FORM_STRING_TYPE_NONE;
2046 info2.mui_dll = NULL;
2047 info2.ressource_id = 0;
2048 info2.display_name = argv[2];
2049 info2.lang_id = 0;
2050
2051 info.info2 = &info2;
2052
2053 break;
2054 }
2055
2056 /* Add the form */
2057
2058
2059 status = rpccli_spoolss_AddForm(cli, mem_ctx,
2060 &handle,
2061 level,
2062 info,
2063 &werror);
2064
2065 done:
2066 if (is_valid_policy_hnd(&handle))
2067 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
2068
2069 return werror;
2070 }
2071
2072 /****************************************************************************
2073 ****************************************************************************/
2074
2075 static WERROR cmd_spoolss_setform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
2076 int argc, const char **argv)
2077 {
2078 struct policy_handle handle;
2079 WERROR werror;
2080 NTSTATUS status;
2081 const char *printername;
2082 union spoolss_AddFormInfo info;
2083 struct spoolss_AddFormInfo1 info1;
2084
2085 /* Parse the command arguments */
2086
2087 if (argc != 3) {
2088 printf ("Usage: %s <printer> <formname>\n", argv[0]);
2089 return WERR_OK;
2090 }
2091
2092 /* Get a printer handle */
2093
2094 RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2095
2096 werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2097 printername,
2098 SEC_FLAG_MAXIMUM_ALLOWED,
2099 &handle);
2100 if (!W_ERROR_IS_OK(werror))
2101 goto done;
2102
2103 /* Dummy up some values for the form data */
2104
2105 info1.flags = SPOOLSS_FORM_PRINTER;
2106 info1.size.width = 100;
2107 info1.size.height = 100;
2108 info1.area.left = 0;
2109 info1.area.top = 1000;
2110 info1.area.right = 2000;
2111 info1.area.bottom = 3000;
2112 info1.form_name = argv[2];
2113
2114 info.info1 = &info1;
2115
2116 /* Set the form */
2117
2118 status = rpccli_spoolss_SetForm(cli, mem_ctx,
2119 &handle,
2120 argv[2],
2121 1,
2122 info,
2123 &werror);
2124
2125 done:
2126 if (is_valid_policy_hnd(&handle))
2127 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
2128
2129 return werror;
2130 }
2131
2132 /****************************************************************************
2133 ****************************************************************************/
2134
2135 static const char *get_form_flag(int form_flag)
2136 {
2137 switch (form_flag) {
2138 case SPOOLSS_FORM_USER:
2139 return "FORM_USER";
2140 case SPOOLSS_FORM_BUILTIN:
2141 return "FORM_BUILTIN";
2142 case SPOOLSS_FORM_PRINTER:
2143 return "FORM_PRINTER";
2144 default:
2145 return "unknown";
2146 }
2147 }
2148
2149 /****************************************************************************
2150 ****************************************************************************/
2151
2152 static void display_form_info1(struct spoolss_FormInfo1 *r)
2153 {
2154 printf("%s\n" \
2155 "\tflag: %s (%d)\n" \
2156 "\twidth: %d, length: %d\n" \
2157 "\tleft: %d, right: %d, top: %d, bottom: %d\n\n",
2158 r->form_name, get_form_flag(r->flags), r->flags,
2159 r->size.width, r->size.height,
2160 r->area.left, r->area.right,
2161 r->area.top, r->area.bottom);
2162 }
2163
2164 /****************************************************************************
2165 ****************************************************************************/
2166
2167 static void display_form_info2(struct spoolss_FormInfo2 *r)
2168 {
2169 printf("%s\n" \
2170 "\tflag: %s (%d)\n" \
2171 "\twidth: %d, length: %d\n" \
2172 "\tleft: %d, right: %d, top: %d, bottom: %d\n",
2173 r->form_name, get_form_flag(r->flags), r->flags,
2174 r->size.width, r->size.height,
2175 r->area.left, r->area.right,
2176 r->area.top, r->area.bottom);
2177 printf("\tkeyword: %s\n", r->keyword);
2178 printf("\tstring_type: 0x%08x\n", r->string_type);
2179 printf("\tmui_dll: %s\n", r->mui_dll);
2180 printf("\tressource_id: 0x%08x\n", r->ressource_id);
2181 printf("\tdisplay_name: %s\n", r->display_name);
2182 printf("\tlang_id: %d\n", r->lang_id);
2183 printf("\n");
2184 }
2185
2186 /****************************************************************************
2187 ****************************************************************************/
2188
2189 static WERROR cmd_spoolss_getform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
2190 int argc, const char **argv)
2191 {
2192 struct policy_handle handle;
2193 WERROR werror;
2194 NTSTATUS status;
2195 const char *printername;
2196 DATA_BLOB buffer;
2197 uint32_t offered = 0;
2198 union spoolss_FormInfo info;
2199 uint32_t needed;
2200 uint32_t level = 1;
2201
2202 /* Parse the command arguments */
2203
2204 if (argc < 3 || argc > 5) {
2205 printf ("Usage: %s <printer> <formname> [level]\n", argv[0]);
2206 return WERR_OK;
2207 }
2208
2209 /* Get a printer handle */
2210
2211 RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2212
2213 werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2214 printername,
2215 SEC_FLAG_MAXIMUM_ALLOWED,
2216 &handle);
2217 if (!W_ERROR_IS_OK(werror))
2218 goto done;
2219
2220 if (argc == 4) {
2221 level = atoi(argv[3]);
2222 }
2223
2224 /* Get the form */
2225
2226 status = rpccli_spoolss_GetForm(cli, mem_ctx,
2227 &handle,
2228 argv[2],
2229 level,
2230 NULL,
2231 offered,
2232 &info,
2233 &needed,
2234 &werror);
2235 if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
2236 buffer = data_blob_talloc_zero(mem_ctx, needed);
2237 offered = needed;
2238 status = rpccli_spoolss_GetForm(cli, mem_ctx,
2239 &handle,
2240 argv[2],
2241 level,
2242 &buffer,
2243 offered,
2244 &info,
2245 &needed,
2246 &werror);
2247 }
2248
2249 if (!NT_STATUS_IS_OK(status)) {
2250 return werror;
2251 }
2252
2253 switch (level) {
2254 case 1:
2255 display_form_info1(&info.info1);
2256 break;
2257 case 2:
2258 display_form_info2(&info.info2);
2259 break;
2260 }
2261
2262 done:
2263 if (is_valid_policy_hnd(&handle))
2264 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
2265
2266 return werror;
2267 }
2268
2269 /****************************************************************************
2270 ****************************************************************************/
2271
2272 static WERROR cmd_spoolss_deleteform(struct rpc_pipe_client *cli,
2273 TALLOC_CTX *mem_ctx, int argc,
2274 const char **argv)
2275 {
2276 struct policy_handle handle;
2277 WERROR werror;
2278 NTSTATUS status;
2279 const char *printername;
2280
2281 /* Parse the command arguments */
2282
2283 if (argc != 3) {
2284 printf ("Usage: %s <printer> <formname>\n", argv[0]);
2285 return WERR_OK;
2286 }
2287
2288 /* Get a printer handle */
2289
2290 RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2291
2292 werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2293 printername,
2294 SEC_FLAG_MAXIMUM_ALLOWED,
2295 &handle);
2296 if (!W_ERROR_IS_OK(werror))
2297 goto done;
2298
2299 /* Delete the form */
2300
2301 status = rpccli_spoolss_DeleteForm(cli, mem_ctx,
2302 &handle,
2303 argv[2],
2304 &werror);
2305 if (!NT_STATUS_IS_OK(status)) {
2306 return ntstatus_to_werror(status);
2307 }
2308
2309 done:
2310 if (is_valid_policy_hnd(&handle))
2311 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
2312
2313 return werror;
2314 }
2315
2316 /****************************************************************************
2317 ****************************************************************************/
2318
2319 static WERROR cmd_spoolss_enum_forms(struct rpc_pipe_client *cli,
2320 TALLOC_CTX *mem_ctx, int argc,
2321 const char **argv)
2322 {
2323 struct policy_handle handle;
2324 WERROR werror;
2325 const char *printername;
2326 uint32_t num_forms, level = 1, i;
2327 union spoolss_FormInfo *forms;
2328
2329 /* Parse the command arguments */
2330
2331 if (argc < 2 || argc > 4) {
2332 printf ("Usage: %s <printer> [level]\n", argv[0]);
2333 return WERR_OK;
2334 }
2335
2336 /* Get a printer handle */
2337
2338 RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2339
2340 werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2341 printername,
2342 SEC_FLAG_MAXIMUM_ALLOWED,
2343 &handle);
2344 if (!W_ERROR_IS_OK(werror))
2345 goto done;
2346
2347 if (argc == 3) {
2348 level = atoi(argv[2]);
2349 }
2350
2351 /* Enumerate forms */
2352
2353 werror = rpccli_spoolss_enumforms(cli, mem_ctx,
2354 &handle,
2355 level,
2356 0,
2357 &num_forms,
2358 &forms);
2359
2360 if (!W_ERROR_IS_OK(werror))
2361 goto done;
2362
2363 /* Display output */
2364
2365 for (i = 0; i < num_forms; i++) {
2366 switch (level) {
2367 case 1:
2368 display_form_info1(&forms[i].info1);
2369 break;
2370 case 2:
2371 display_form_info2(&forms[i].info2);
2372 break;
2373 }
2374 }
2375
2376 done:
2377 if (is_valid_policy_hnd(&handle))
2378 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
2379
2380 return werror;
2381 }
2382
2383 /****************************************************************************
2384 ****************************************************************************/
2385
2386 static WERROR cmd_spoolss_setprinterdata(struct rpc_pipe_client *cli,
2387 TALLOC_CTX *mem_ctx,
2388 int argc, const char **argv)
2389 {
2390 WERROR result;
2391 NTSTATUS status;
2392 const char *printername;
2393 struct policy_handle pol;
2394 union spoolss_PrinterInfo info;
2395 enum winreg_Type type;
2396 union spoolss_PrinterData data;
2397 DATA_BLOB blob;
2398
2399 /* parse the command arguments */
2400 if (argc < 5) {
2401 printf ("Usage: %s <printer> <string|binary|dword|multistring>"
2402 " <value> <data>\n",
2403 argv[0]);
2404 return WERR_OK;
2405 }
2406
2407 RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2408
2409 type = REG_NONE;
2410
2411 if (strequal(argv[2], "string")) {
2412 type = REG_SZ;
2413 }
2414
2415 if (strequal(argv[2], "binary")) {
2416 type = REG_BINARY;
2417 }
2418
2419 if (strequal(argv[2], "dword")) {
2420 type = REG_DWORD;
2421 }
2422
2423 if (strequal(argv[2], "multistring")) {
2424 type = REG_MULTI_SZ;
2425 }
2426
2427 if (type == REG_NONE) {
2428 printf("Unknown data type: %s\n", argv[2]);
2429 result = WERR_INVALID_PARAM;
2430 goto done;
2431 }
2432
2433 /* get a printer handle */
2434
2435 result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2436 printername,
2437 SEC_FLAG_MAXIMUM_ALLOWED,
2438 &pol);
2439 if (!W_ERROR_IS_OK(result)) {
2440 goto done;
2441 }
2442
2443 result = rpccli_spoolss_getprinter(cli, mem_ctx,
2444 &pol,
2445 0,
2446 0,
2447 &info);
2448 if (!W_ERROR_IS_OK(result)) {
2449 goto done;
2450 }
2451
2452 printf("%s\n", current_timestring(mem_ctx, true));
2453 printf("\tchange_id (before set)\t:[0x%x]\n", info.info0.change_id);
2454
2455 /* Set the printer data */
2456
2457 switch (type) {
2458 case REG_SZ:
2459 data.string = talloc_strdup(mem_ctx, argv[4]);
2460 W_ERROR_HAVE_NO_MEMORY(data.string);
2461 break;
2462 case REG_DWORD:
2463 data.value = strtoul(argv[4], NULL, 10);
2464 break;
2465 case REG_BINARY:
2466 data.binary = strhex_to_data_blob(mem_ctx, argv[4]);
2467 break;
2468 case REG_MULTI_SZ: {
2469 int i, num_strings;
2470 const char **strings = NULL;
2471
2472 for (i=4; i<argc; i++) {
2473 if (strcmp(argv[i], "NULL") == 0) {
2474 argv[i] = "";
2475 }
2476 if (!add_string_to_array(mem_ctx, argv[i],
2477 &strings,
2478 &num_strings)) {
2479 result = WERR_NOMEM;
2480 goto done;
2481 }
2482 }
2483 data.string_array = talloc_zero_array(mem_ctx, const char *, num_strings + 1);
2484 if (!data.string_array) {
2485 result = WERR_NOMEM;
2486 goto done;
2487 }
2488 for (i=0; i < num_strings; i++) {
2489 data.string_array[i] = strings[i];
2490 }
2491 break;
2492 }
2493 default:
2494 printf("Unknown data type: %s\n", argv[2]);
2495 result = WERR_INVALID_PARAM;
2496 goto done;
2497 }
2498
2499 result = push_spoolss_PrinterData(mem_ctx, &blob, type, &data);
2500 if (!W_ERROR_IS_OK(result)) {
2501 goto done;
2502 }
2503
2504 status = rpccli_spoolss_SetPrinterData(cli, mem_ctx,
2505 &pol,
2506 argv[3], /* value_name */
2507 type,
2508 blob.data,
2509 blob.length,
2510 &result);
2511 if (!W_ERROR_IS_OK(result)) {
2512 printf ("Unable to set [%s=%s]!\n", argv[3], argv[4]);
2513 goto done;
2514 }
2515 printf("\tSetPrinterData succeeded [%s: %s]\n", argv[3], argv[4]);
2516
2517 result = rpccli_spoolss_getprinter(cli, mem_ctx,
2518 &pol,
2519 0,
2520 0,
2521 &info);
2522 if (!W_ERROR_IS_OK(result)) {
2523 goto done;
2524 }
2525
2526 printf("%s\n", current_timestring(mem_ctx, true));
2527 printf("\tchange_id (after set)\t:[0x%x]\n", info.info0.change_id);
2528
2529 done:
2530 /* cleanup */
2531 if (is_valid_policy_hnd(&pol)) {
2532 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
2533 }
2534
2535 return result;
2536 }
2537
2538 /****************************************************************************
2539 ****************************************************************************/
2540
2541 static void display_job_info1(struct spoolss_JobInfo1 *r)
2542 {
2543 printf("%d: jobid[%d]: %s %s %s %d/%d pages\n", r->position, r->job_id,
2544 r->user_name, r->document_name, r->text_status, r->pages_printed,
2545 r->total_pages);
2546 }
2547
2548 /****************************************************************************
2549 ****************************************************************************/
2550
2551 static void display_job_info2(struct spoolss_JobInfo2 *r)
2552 {
2553 printf("%d: jobid[%d]: %s %s %s %d/%d pages, %d bytes\n",
2554 r->position, r->job_id,
2555 r->user_name, r->document_name, r->text_status, r->pages_printed,
2556 r->total_pages, r->size);
2557 }
2558
2559 /****************************************************************************
2560 ****************************************************************************/
2561
2562 static void display_job_info3(struct spoolss_JobInfo3 *r)
2563 {
2564 printf("jobid[%d], next_jobid[%d]\n",
2565 r->job_id, r->next_job_id);
2566 }
2567
2568 /****************************************************************************
2569 ****************************************************************************/
2570
2571 static void display_job_info4(struct spoolss_JobInfo4 *r)
2572 {
2573 printf("%d: jobid[%d]: %s %s %s %d/%d pages, %d/%d bytes\n",
2574 r->position, r->job_id,
2575 r->user_name, r->document_name, r->text_status, r->pages_printed,
2576 r->total_pages, r->size, r->size_high);
2577 }
2578
2579 /****************************************************************************
2580 ****************************************************************************/
2581
2582 static WERROR cmd_spoolss_enum_jobs(struct rpc_pipe_client *cli,
2583 TALLOC_CTX *mem_ctx, int argc,
2584 const char **argv)
2585 {
2586 WERROR result;
2587 uint32_t level = 1, count, i;
2588 const char *printername;
2589 struct policy_handle hnd;
2590 union spoolss_JobInfo *info;
2591
2592 if (argc < 2 || argc > 3) {
2593 printf("Usage: %s printername [level]\n", argv[0]);
2594 return WERR_OK;
2595 }
2596
2597 if (argc == 3) {
2598 level = atoi(argv[2]);
2599 }
2600
2601 /* Open printer handle */
2602
2603 RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2604
2605 result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2606 printername,
2607 SEC_FLAG_MAXIMUM_ALLOWED,
2608 &hnd);
2609 if (!W_ERROR_IS_OK(result))
2610 goto done;
2611
2612 /* Enumerate ports */
2613
2614 result = rpccli_spoolss_enumjobs(cli, mem_ctx,
2615 &hnd,
2616 0, /* firstjob */
2617 1000, /* numjobs */
2618 level,
2619 0,
2620 &count,
2621 &info);
2622 if (!W_ERROR_IS_OK(result)) {
2623 goto done;
2624 }
2625
2626 for (i = 0; i < count; i++) {
2627 switch (level) {
2628 case 1:
2629 display_job_info1(&info[i].info1);
2630 break;
2631 case 2:
2632 display_job_info2(&info[i].info2);
2633 break;
2634 default:
2635 d_printf("unknown info level %d\n", level);
2636 break;
2637 }
2638 }
2639
2640 done:
2641 if (is_valid_policy_hnd(&hnd)) {
2642 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2643 }
2644
2645 return result;
2646 }
2647
2648 /****************************************************************************
2649 ****************************************************************************/
2650
2651 static WERROR cmd_spoolss_get_job(struct rpc_pipe_client *cli,
2652 TALLOC_CTX *mem_ctx, int argc,
2653 const char **argv)
2654 {
2655 WERROR result;
2656 const char *printername;
2657 struct policy_handle hnd;
2658 uint32_t job_id;
2659 uint32_t level = 1;
2660 union spoolss_JobInfo info;
2661
2662 if (argc < 3 || argc > 4) {
2663 printf("Usage: %s printername job_id [level]\n", argv[0]);
2664 return WERR_OK;
2665 }
2666
2667 job_id = atoi(argv[2]);
2668
2669 if (argc == 4) {
2670 level = atoi(argv[3]);
2671 }
2672
2673 /* Open printer handle */
2674
2675 RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2676
2677 result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2678 printername,
2679 SEC_FLAG_MAXIMUM_ALLOWED,
2680 &hnd);
2681 if (!W_ERROR_IS_OK(result)) {
2682 goto done;
2683 }
2684
2685 /* Enumerate ports */
2686
2687 result = rpccli_spoolss_getjob(cli, mem_ctx,
2688 &hnd,
2689 job_id,
2690 level,
2691 0,
2692 &info);
2693
2694 if (!W_ERROR_IS_OK(result)) {
2695 goto done;
2696 }
2697
2698 switch (level) {
2699 case 1:
2700 display_job_info1(&info.info1);
2701 break;
2702 case 2:
2703 display_job_info2(&info.info2);
2704 break;
2705 case 3:
2706 display_job_info3(&info.info3);
2707 break;
2708 case 4:
2709 display_job_info4(&info.info4);
2710 break;
2711 default:
2712 d_printf("unknown info level %d\n", level);
2713 break;
2714 }
2715
2716 done:
2717 if (is_valid_policy_hnd(&hnd)) {
2718 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2719 }
2720
2721 return result;
2722 }
2723
2724 /****************************************************************************
2725 ****************************************************************************/
2726
2727 static struct {
2728 const char *name;
2729 enum spoolss_JobControl val;
2730 } cmdvals[] = {
2731 {"PAUSE", SPOOLSS_JOB_CONTROL_PAUSE},
2732 {"RESUME", SPOOLSS_JOB_CONTROL_RESUME},
2733 {"CANCEL", SPOOLSS_JOB_CONTROL_CANCEL},
2734 {"RESTART", SPOOLSS_JOB_CONTROL_RESTART},
2735 {"DELETE", SPOOLSS_JOB_CONTROL_DELETE},
2736 {"SEND_TO_PRINTER", SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER},
2737 {"EJECTED", SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED},
2738 {"RETAIN", SPOOLSS_JOB_CONTROL_RETAIN},
2739 {"RELEASE", SPOOLSS_JOB_CONTROL_RELEASE}
2740 };
2741
2742 static enum spoolss_JobControl parse_setjob_command(const char *cmd)
2743 {
2744 int i;
2745
2746 for (i = 0; i < sizeof(cmdvals)/sizeof(cmdvals[0]); i++) {
2747 if (strequal(cmdvals[i].name, cmd)) {
2748 return cmdvals[i].val;
2749 }
2750 }
2751 return (enum spoolss_JobControl)atoi(cmd);
2752 }
2753
2754 static WERROR cmd_spoolss_set_job(struct rpc_pipe_client *cli,
2755 TALLOC_CTX *mem_ctx, int argc,
2756 const char **argv)
2757 {
2758 WERROR result;
2759 NTSTATUS status;
2760 const char *printername;
2761 struct policy_handle hnd;
2762 uint32_t job_id;
2763 enum spoolss_JobControl command;
2764
2765 if (argc != 4) {
2766 printf("Usage: %s printername job_id command\n", argv[0]);
2767 printf("command = [PAUSE|RESUME|CANCEL|RESTART|DELETE|"
2768 "SEND_TO_PRINTER|EJECTED|RETAIN|RELEASE]\n");
2769 return WERR_OK;
2770 }
2771
2772 job_id = atoi(argv[2]);
2773 command = parse_setjob_command(argv[3]);
2774
2775 /* Open printer handle */
2776
2777 RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2778
2779 result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2780 printername,
2781 SEC_FLAG_MAXIMUM_ALLOWED,
2782 &hnd);
2783 if (!W_ERROR_IS_OK(result)) {
2784 goto done;
2785 }
2786
2787 /* Set Job */
2788
2789 status = rpccli_spoolss_SetJob(cli, mem_ctx,
2790 &hnd,
2791 job_id,
2792 NULL,
2793 command,
2794 &result);
2795
2796 if (!W_ERROR_IS_OK(result)) {
2797 goto done;
2798 }
2799
2800 done:
2801 if (is_valid_policy_hnd(&hnd)) {
2802 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2803 }
2804
2805 return result;
2806 }
2807
2808 /****************************************************************************
2809 ****************************************************************************/
2810
2811 static WERROR cmd_spoolss_enum_data(struct rpc_pipe_client *cli,
2812 TALLOC_CTX *mem_ctx, int argc,
2813 const char **argv)
2814 {
2815 WERROR result;
2816 NTSTATUS status;
2817 uint32_t i = 0;
2818 const char *printername;
2819 struct policy_handle hnd;
2820 uint32_t value_offered = 0;
2821 const char *value_name = NULL;
2822 uint32_t value_needed;
2823 enum winreg_Type type;
2824 uint8_t *data = NULL;
2825 uint32_t data_offered = 0;
2826 uint32_t data_needed;
2827
2828 if (argc != 2) {
2829 printf("Usage: %s printername\n", argv[0]);
2830 return WERR_OK;
2831 }
2832
2833 /* Open printer handle */
2834
2835 RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2836
2837 result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2838 printername,
2839 SEC_FLAG_MAXIMUM_ALLOWED,
2840 &hnd);
2841 if (!W_ERROR_IS_OK(result)) {
2842 goto done;
2843 }
2844
2845 /* Enumerate data */
2846
2847 status = rpccli_spoolss_EnumPrinterData(cli, mem_ctx,
2848 &hnd,
2849 i,
2850 value_name,
2851 value_offered,
2852 &value_needed,
2853 &type,
2854 data,
2855 data_offered,
2856 &data_needed,
2857 &result);
2858
2859 data_offered = data_needed;
2860 value_offered = value_needed;
2861 data = talloc_zero_array(mem_ctx, uint8_t, data_needed);
2862 value_name = talloc_zero_array(mem_ctx, char, value_needed);
2863
2864 while (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(result)) {
2865
2866 status = rpccli_spoolss_EnumPrinterData(cli, mem_ctx,
2867 &hnd,
2868 i++,
2869 value_name,
2870 value_offered,
2871 &value_needed,
2872 &type,
2873 data,
2874 data_offered,
2875 &data_needed,
2876 &result);
2877 if (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(result)) {
2878 struct regval_blob *v;
2879
2880 v = regval_compose(talloc_tos(),
2881 value_name,
2882 type,
2883 data,
2884 data_offered);
2885 if (v == NULL) {
2886 result = WERR_NOMEM;
2887 goto done;
2888 }
2889
2890 display_reg_value(v);
2891 talloc_free(v);
2892 }
2893 }
2894
2895 if (W_ERROR_V(result) == ERRnomoreitems) {
2896 result = W_ERROR(ERRsuccess);
2897 }
2898
2899 done:
2900 if (is_valid_policy_hnd(&hnd)) {
2901 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2902 }
2903
2904 return result;
2905 }
2906
2907 /****************************************************************************
2908 ****************************************************************************/
2909
2910 static WERROR cmd_spoolss_enum_data_ex( struct rpc_pipe_client *cli,
2911 TALLOC_CTX *mem_ctx, int argc,
2912 const char **argv)
2913 {
2914 WERROR result;
2915 uint32_t i;
2916 const char *printername;
2917 struct policy_handle hnd;
2918 uint32_t count;
2919 struct spoolss_PrinterEnumValues *info;
2920
2921 if (argc != 3) {
2922 printf("Usage: %s printername <keyname>\n", argv[0]);
2923 return WERR_OK;
2924 }
2925
2926 /* Open printer handle */
2927
2928 RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2929
2930 result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2931 printername,
2932 SEC_FLAG_MAXIMUM_ALLOWED,
2933 &hnd);
2934 if (!W_ERROR_IS_OK(result)) {
2935 goto done;
2936 }
2937
2938 /* Enumerate subkeys */
2939
2940 result = rpccli_spoolss_enumprinterdataex(cli, mem_ctx,
2941 &hnd,
2942 argv[2],
2943 0,
2944 &count,
2945 &info);
2946 if (!W_ERROR_IS_OK(result)) {
2947 goto done;
2948 }
2949
2950 for (i=0; i < count; i++) {
2951 display_printer_data(info[i].value_name,
2952 info[i].type,
2953 info[i].data->data,
2954 info[i].data->length);
2955 }
2956
2957 done:
2958 if (is_valid_policy_hnd(&hnd)) {
2959 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2960 }
2961
2962 return result;
2963 }
2964
2965 /****************************************************************************
2966 ****************************************************************************/
2967
2968 static WERROR cmd_spoolss_enum_printerkey(struct rpc_pipe_client *cli,
2969 TALLOC_CTX *mem_ctx, int argc,
2970 const char **argv)
2971 {
2972 WERROR result;
2973 const char *printername;
2974 const char *keyname = NULL;
2975 struct policy_handle hnd;
2976 const char **key_buffer = NULL;
2977 int i;
2978 uint32_t offered = 0;
2979
2980 if (argc < 2 || argc > 4) {
2981 printf("Usage: %s printername [keyname] [offered]\n", argv[0]);
2982 return WERR_OK;
2983 }
2984
2985 if (argc >= 3) {
2986 keyname = argv[2];
2987 } else {
2988 keyname = "";
2989 }
2990
2991 if (argc == 4) {
2992 offered = atoi(argv[3]);
2993 }
2994
2995 /* Open printer handle */
2996
2997 RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2998
2999 result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
3000 printername,
3001 SEC_FLAG_MAXIMUM_ALLOWED,
3002 &hnd);
3003 if (!W_ERROR_IS_OK(result)) {
3004 goto done;
3005 }
3006
3007 /* Enumerate subkeys */
3008
3009 result = rpccli_spoolss_enumprinterkey(cli, mem_ctx,
3010 &hnd,
3011 keyname,
3012 &key_buffer,
3013 offered);
3014
3015 if (!W_ERROR_IS_OK(result)) {
3016 goto done;
3017 }
3018
3019 for (i=0; key_buffer && key_buffer[i]; i++) {
3020 printf("%s\n", key_buffer[i]);
3021 }
3022
3023 done:
3024
3025 if (is_valid_policy_hnd(&hnd)) {
3026 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
3027 }
3028
3029 return result;
3030 }
3031
3032 /****************************************************************************
3033 ****************************************************************************/
3034
3035 static WERROR cmd_spoolss_rffpcnex(struct rpc_pipe_client *cli,
3036 TALLOC_CTX *mem_ctx, int argc,
3037 const char **argv)
3038 {
3039 const char *printername;
3040 const char *clientname;
3041 struct policy_handle hnd;
3042 WERROR result;
3043 NTSTATUS status;
3044 struct spoolss_NotifyOption option;
3045
3046 if (argc != 2) {
3047 printf("Usage: %s printername\n", argv[0]);
3048 result = WERR_OK;
3049 goto done;
3050 }
3051
3052 /* Open printer */
3053
3054 RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
3055
3056 result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
3057 printername,
3058 SEC_FLAG_MAXIMUM_ALLOWED,
3059 &hnd);
3060 if (!W_ERROR_IS_OK(result)) {
3061 printf("Error opening %s\n", argv[1]);
3062 goto done;
3063 }
3064
3065 /* Create spool options */
3066
3067 option.version = 2;
3068 option.count = 2;
3069
3070 option.types = talloc_array(mem_ctx, struct spoolss_NotifyOptionType, 2);
3071 if (option.types == NULL) {
3072 result = WERR_NOMEM;
3073 goto done;
3074 }
3075
3076 option.types[0].type = PRINTER_NOTIFY_TYPE;
3077 option.types[0].count = 1;
3078 option.types[0].fields = talloc_array(mem_ctx, union spoolss_Field, 1);
3079 if (option.types[0].fields == NULL) {
3080 result = WERR_NOMEM;
3081 goto done;
3082 }
3083 option.types[0].fields[0].field = PRINTER_NOTIFY_FIELD_SERVER_NAME;
3084
3085 option.types[1].type = JOB_NOTIFY_TYPE;
3086 option.types[1].count = 1;
3087 option.types[1].fields = talloc_array(mem_ctx, union spoolss_Field, 1);
3088 if (option.types[1].fields == NULL) {
3089 result = WERR_NOMEM;
3090 goto done;
3091 }
3092 option.types[1].fields[0].field = JOB_NOTIFY_FIELD_PRINTER_NAME;
3093
3094 clientname = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
3095 if (!clientname) {
3096 result = WERR_NOMEM;
3097 goto done;
3098 }
3099
3100 /* Send rffpcnex */
3101
3102 status = rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx(cli, mem_ctx,
3103 &hnd,
3104 0,
3105 0,
3106 clientname,
3107 123,
3108 &option,
3109 &result);
3110 if (!W_ERROR_IS_OK(result)) {
3111 printf("Error rffpcnex %s\n", argv[1]);
3112 goto done;
3113 }
3114
3115 done:
3116 if (is_valid_policy_hnd(&hnd))
3117 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
3118
3119 return result;
3120 }
3121
3122 /****************************************************************************
3123 ****************************************************************************/
3124
3125 static bool compare_printer( struct rpc_pipe_client *cli1, struct policy_handle *hnd1,
3126 struct rpc_pipe_client *cli2, struct policy_handle *hnd2 )
3127 {
3128 union spoolss_PrinterInfo info1, info2;
3129 WERROR werror;
3130 TALLOC_CTX *mem_ctx = talloc_init("compare_printer");
3131
3132 printf("Retrieving printer propertiesfor %s...", cli1->desthost);
3133 werror = rpccli_spoolss_getprinter(cli1, mem_ctx,
3134 hnd1,
3135 2,
3136 0,
3137 &info1);
3138 if ( !W_ERROR_IS_OK(werror) ) {
3139 printf("failed (%s)\n", win_errstr(werror));
3140 talloc_destroy(mem_ctx);
3141 return false;
3142 }
3143 printf("ok\n");
3144
3145 printf("Retrieving printer properties for %s...", cli2->desthost);
3146 werror = rpccli_spoolss_getprinter(cli2, mem_ctx,
3147 hnd2,
3148 2,
3149 0,
3150 &info2);
3151 if ( !W_ERROR_IS_OK(werror) ) {
3152 printf("failed (%s)\n", win_errstr(werror));
3153 talloc_destroy(mem_ctx);
3154 return false;
3155 }
3156 printf("ok\n");
3157
3158 talloc_destroy(mem_ctx);
3159
3160 return true;
3161 }
3162
3163 /****************************************************************************
3164 ****************************************************************************/
3165
3166 static bool compare_printer_secdesc( struct rpc_pipe_client *cli1, struct policy_handle *hnd1,
3167 struct rpc_pipe_client *cli2, struct policy_handle *hnd2 )
3168 {
3169 union spoolss_PrinterInfo info1, info2;
3170 WERROR werror;
3171 TALLOC_CTX *mem_ctx = talloc_init("compare_printer_secdesc");
3172 struct security_descriptor *sd1, *sd2;
3173 bool result = true;
3174
3175
3176 printf("Retrieving printer security for %s...", cli1->desthost);
3177 werror = rpccli_spoolss_getprinter(cli1, mem_ctx,
3178 hnd1,
3179 3,
3180 0,
3181 &info1);
3182 if ( !W_ERROR_IS_OK(werror) ) {
3183 printf("failed (%s)\n", win_errstr(werror));
3184 result = false;
3185 goto done;
3186 }
3187 printf("ok\n");
3188
3189 printf("Retrieving printer security for %s...", cli2->desthost);
3190 werror = rpccli_spoolss_getprinter(cli2, mem_ctx,
3191 hnd2,
3192 3,
3193 0,
3194 &info2);
3195 if ( !W_ERROR_IS_OK(werror) ) {
3196 printf("failed (%s)\n", win_errstr(werror));
3197 result = false;
3198 goto done;
3199 }
3200 printf("ok\n");
3201
3202
3203 printf("++ ");
3204
3205 sd1 = info1.info3.secdesc;
3206 sd2 = info2.info3.secdesc;
3207
3208 if ( (sd1 != sd2) && ( !sd1 || !sd2 ) ) {
3209 printf("NULL secdesc!\n");
3210 result = false;
3211 goto done;
3212 }
3213
3214 if (!security_descriptor_equal( sd1, sd2 ) ) {
3215 printf("Security Descriptors *not* equal!\n");
3216 result = false;
3217 goto done;
3218 }
3219
3220 printf("Security descriptors match\n");
3221
3222 done:
3223 talloc_destroy(mem_ctx);
3224 return result;
3225 }
3226
3227
3228 /****************************************************************************
3229 ****************************************************************************/
3230
3231 extern struct user_auth_info *rpcclient_auth_info;
3232
3233 static WERROR cmd_spoolss_printercmp(struct rpc_pipe_client *cli,
3234 TALLOC_CTX *mem_ctx, int argc,
3235 const char **argv)
3236 {
3237 const char *printername;
3238 char *printername_path = NULL;
3239 struct cli_state *cli_server2 = NULL;
3240 struct rpc_pipe_client *cli2 = NULL;
3241 struct policy_handle hPrinter1, hPrinter2;
3242 NTSTATUS nt_status;
3243 WERROR werror;
3244
3245 if ( argc != 3 ) {
3246 printf("Usage: %s <printer> <server>\n", argv[0]);
3247 return WERR_OK;
3248 }
3249
3250 printername = argv[1];
3251
3252 /* first get the connection to the remote server */
3253
3254 nt_status = cli_full_connection(&cli_server2, global_myname(), argv[2],
3255 NULL, 0,
3256 "IPC$", "IPC",
3257 get_cmdline_auth_info_username(rpcclient_auth_info),
3258 lp_workgroup(),
3259 get_cmdline_auth_info_password(rpcclient_auth_info),
3260 get_cmdline_auth_info_use_kerberos(rpcclient_auth_info) ? CLI_FULL_CONNECTION_USE_KERBEROS : 0,
3261 get_cmdline_auth_info_signing_state(rpcclient_auth_info), NULL);
3262
3263 if ( !NT_STATUS_IS_OK(nt_status) )
3264 return WERR_GENERAL_FAILURE;
3265
3266 nt_status = cli_rpc_pipe_open_noauth(cli_server2, &ndr_table_spoolss.syntax_id,
3267 &cli2);
3268 if (!NT_STATUS_IS_OK(nt_status)) {
3269 printf("failed to open spoolss pipe on server %s (%s)\n",
3270 argv[2], nt_errstr(nt_status));
3271 return WERR_GENERAL_FAILURE;
3272 }
3273
3274 /* now open up both printers */
3275
3276 RPCCLIENT_PRINTERNAME(printername_path, cli, printername);
3277
3278 printf("Opening %s...", printername_path);
3279
3280 werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
3281 printername_path,
3282 PRINTER_ALL_ACCESS,
3283 &hPrinter1);
3284 if ( !W_ERROR_IS_OK(werror) ) {
3285 printf("failed (%s)\n", win_errstr(werror));
3286 goto done;
3287 }
3288 printf("ok\n");
3289
3290 RPCCLIENT_PRINTERNAME(printername_path, cli2, printername);
3291
3292 printf("Opening %s...", printername_path);
3293 werror = rpccli_spoolss_openprinter_ex(cli2, mem_ctx,
3294 printername_path,
3295 PRINTER_ALL_ACCESS,
3296 &hPrinter2);
3297 if ( !W_ERROR_IS_OK(werror) ) {
3298 printf("failed (%s)\n", win_errstr(werror));
3299 goto done;
3300 }
3301 printf("ok\n");
3302
3303 compare_printer( cli, &hPrinter1, cli2, &hPrinter2 );
3304 compare_printer_secdesc( cli, &hPrinter1, cli2, &hPrinter2 );
3305 #if 0
3306 compare_printerdata( cli_server1, &hPrinter1, cli_server2, &hPrinter2 );
3307 #endif
3308
3309
3310 done:
3311 /* cleanup */
3312
3313 printf("Closing printers...");
3314 rpccli_spoolss_ClosePrinter( cli, mem_ctx, &hPrinter1, NULL );
3315 rpccli_spoolss_ClosePrinter( cli2, mem_ctx, &hPrinter2, NULL );
3316 printf("ok\n");
3317
3318 /* close the second remote connection */
3319
3320 cli_shutdown( cli_server2 );
3321 return WERR_OK;
3322 }
3323
3324 static void display_proc_info1(struct spoolss_PrintProcessorInfo1 *r)
3325 {
3326 printf("print_processor_name: %s\n", r->print_processor_name);
3327 }
3328
3329 static WERROR cmd_spoolss_enum_procs(struct rpc_pipe_client *cli,
3330 TALLOC_CTX *mem_ctx, int argc,
3331 const char **argv)
3332 {
3333 WERROR werror;
3334 const char *environment = SPOOLSS_ARCHITECTURE_NT_X86;
3335 uint32_t num_procs, level = 1, i;
3336 union spoolss_PrintProcessorInfo *procs;
3337
3338 /* Parse the command arguments */
3339
3340 if (argc < 1 || argc > 4) {
3341 printf ("Usage: %s [environment] [level]\n", argv[0]);
3342 return WERR_OK;
3343 }
3344
3345 if (argc >= 2) {
3346 environment = argv[1];
3347 }
3348
3349 if (argc == 3) {
3350 level = atoi(argv[2]);
3351 }
3352
3353 /* Enumerate Print Processors */
3354
3355 werror = rpccli_spoolss_enumprintprocessors(cli, mem_ctx,
3356 cli->srv_name_slash,
3357 environment,
3358 level,
3359 0,
3360 &num_procs,
3361 &procs);
3362 if (!W_ERROR_IS_OK(werror))
3363 goto done;
3364
3365 /* Display output */
3366
3367 for (i = 0; i < num_procs; i++) {
3368 switch (level) {
3369 case 1:
3370 display_proc_info1(&procs[i].info1);
3371 break;
3372 }
3373 }
3374
3375 done:
3376 return werror;
3377 }
3378
3379 static void display_proc_data_types_info1(struct spoolss_PrintProcDataTypesInfo1 *r)
3380 {
3381 printf("name_array: %s\n", r->name_array);
3382 }
3383
3384 static WERROR cmd_spoolss_enum_proc_data_types(struct rpc_pipe_client *cli,
3385 TALLOC_CTX *mem_ctx, int argc,
3386 const char **argv)
3387 {
3388 WERROR werror;
3389 const char *print_processor_name = "winprint";
3390 uint32_t num_procs, level = 1, i;
3391 union spoolss_PrintProcDataTypesInfo *procs;
3392
3393 /* Parse the command arguments */
3394
3395 if (argc < 1 || argc > 4) {
3396 printf ("Usage: %s [environment] [level]\n", argv[0]);
3397 return WERR_OK;
3398 }
3399
3400 if (argc >= 2) {
3401 print_processor_name = argv[1];
3402 }
3403
3404 if (argc == 3) {
3405 level = atoi(argv[2]);
3406 }
3407
3408 /* Enumerate Print Processor Data Types */
3409
3410 werror = rpccli_spoolss_enumprintprocessordatatypes(cli, mem_ctx,
3411 cli->srv_name_slash,
3412 print_processor_name,
3413 level,
3414 0,
3415 &num_procs,
3416 &procs);
3417 if (!W_ERROR_IS_OK(werror))
3418 goto done;
3419
3420 /* Display output */
3421
3422 for (i = 0; i < num_procs; i++) {
3423 switch (level) {
3424 case 1:
3425 display_proc_data_types_info1(&procs[i].info1);
3426 break;
3427 }
3428 }
3429
3430 done:
3431 return werror;
3432 }
3433
3434 static void display_monitor1(const struct spoolss_MonitorInfo1 *r)
3435 {
3436 printf("monitor_name: %s\n", r->monitor_name);
3437 }
3438
3439 static void display_monitor2(const struct spoolss_MonitorInfo2 *r)
3440 {
3441 printf("monitor_name: %s\n", r->monitor_name);
3442 printf("environment: %s\n", r->environment);
3443 printf("dll_name: %s\n", r->dll_name);
3444 }
3445
3446 static WERROR cmd_spoolss_enum_monitors(struct rpc_pipe_client *cli,
3447 TALLOC_CTX *mem_ctx, int argc,
3448 const char **argv)
3449 {
3450 WERROR werror;
3451 uint32_t count, level = 1, i;
3452 union spoolss_MonitorInfo *info;
3453
3454 /* Parse the command arguments */
3455
3456 if (argc > 2) {
3457 printf("Usage: %s [level]\n", argv[0]);
3458 return WERR_OK;
3459 }
3460
3461 if (argc == 2) {
3462 level = atoi(argv[1]);
3463 }
3464
3465 /* Enumerate Print Monitors */
3466
3467 werror = rpccli_spoolss_enummonitors(cli, mem_ctx,
3468 cli->srv_name_slash,
3469 level,
3470 0,
3471 &count,
3472 &info);
3473 if (!W_ERROR_IS_OK(werror)) {
3474 goto done;
3475 }
3476
3477 /* Display output */
3478
3479 for (i = 0; i < count; i++) {
3480 switch (level) {
3481 case 1:
3482 display_monitor1(&info[i].info1);
3483 break;
3484 case 2:
3485 display_monitor2(&info[i].info2);
3486 break;
3487 }
3488 }
3489
3490 done:
3491 return werror;
3492 }
3493
3494 static WERROR cmd_spoolss_create_printer_ic(struct rpc_pipe_client *cli,
3495 TALLOC_CTX *mem_ctx, int argc,
3496 const char **argv)
3497 {
3498 WERROR result;
3499 NTSTATUS status;
3500 struct policy_handle handle, gdi_handle;
3501 const char *printername;
3502 struct spoolss_DevmodeContainer devmode_ctr;
3503
3504 RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
3505
3506 result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
3507 printername,
3508 SEC_FLAG_MAXIMUM_ALLOWED,
3509 &handle);
3510 if (!W_ERROR_IS_OK(result)) {
3511 return result;
3512 }
3513
3514 ZERO_STRUCT(devmode_ctr);
3515
3516 status = rpccli_spoolss_CreatePrinterIC(cli, mem_ctx,
3517 &handle,
3518 &gdi_handle,
3519 &devmode_ctr,
3520 &result);
3521 if (!W_ERROR_IS_OK(result)) {
3522 goto done;
3523 }
3524
3525 done:
3526 if (is_valid_policy_hnd(&gdi_handle)) {
3527 rpccli_spoolss_DeletePrinterIC(cli, mem_ctx, &gdi_handle, NULL);
3528 }
3529 if (is_valid_policy_hnd(&handle)) {
3530 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
3531 }
3532
3533 return result;
3534 }
3535
3536 /* List of commands exported by this module */
3537 struct cmd_set spoolss_commands[] = {
3538
3539 { "SPOOLSS" },
3540
3541 { "adddriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterdriver, &ndr_table_spoolss.syntax_id, NULL, "Add a print driver", "" },
3542 { "addprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterex, &ndr_table_spoolss.syntax_id, NULL, "Add a printer", "" },
3543 { "deldriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deletedriver, &ndr_table_spoolss.syntax_id, NULL, "Delete a printer driver", "" },
3544 { "deldriverex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deletedriverex, &ndr_table_spoolss.syntax_id, NULL, "Delete a printer driver with files", "" },
3545 { "enumdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data, &ndr_table_spoolss.syntax_id, NULL, "Enumerate printer data", "" },
3546 { "enumdataex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data_ex, &ndr_table_spoolss.syntax_id, NULL, "Enumerate printer data for a key", "" },
3547 { "enumkey", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printerkey, &ndr_table_spoolss.syntax_id, NULL, "Enumerate printer keys", "" },
3548 { "enumjobs", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_jobs, &ndr_table_spoolss.syntax_id, NULL, "Enumerate print jobs", "" },
3549 { "getjob", RPC_RTYPE_WERROR, NULL, cmd_spoolss_get_job, &ndr_table_spoolss.syntax_id, NULL, "Get print job", "" },
3550 { "setjob", RPC_RTYPE_WERROR, NULL, cmd_spoolss_set_job, &ndr_table_spoolss.syntax_id, NULL, "Set print job", "" },
3551 { "enumports", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_ports, &ndr_table_spoolss.syntax_id, NULL, "Enumerate printer ports", "" },
3552 { "enumdrivers", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_drivers, &ndr_table_spoolss.syntax_id, NULL, "Enumerate installed printer drivers", "" },
3553 { "enumprinters", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printers, &ndr_table_spoolss.syntax_id, NULL, "Enumerate printers", "" },
3554 { "getdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdata, &ndr_table_spoolss.syntax_id, NULL, "Get print driver data", "" },
3555 { "getdataex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdataex, &ndr_table_spoolss.syntax_id, NULL, "Get printer driver data with keyname", ""},
3556 { "getdriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriver, &ndr_table_spoolss.syntax_id, NULL, "Get print driver information", "" },
3557 { "getdriverdir", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriverdir, &ndr_table_spoolss.syntax_id, NULL, "Get print driver upload directory", "" },
3558 { "getprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinter, &ndr_table_spoolss.syntax_id, NULL, "Get printer info", "" },
3559 { "openprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_open_printer_ex, &ndr_table_spoolss.syntax_id, NULL, "Open printer handle", "" },
3560 { "setdriver", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setdriver, &ndr_table_spoolss.syntax_id, NULL, "Set printer driver", "" },
3561 { "getprintprocdir", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprintprocdir, &ndr_table_spoolss.syntax_id, NULL, "Get print processor directory", "" },
3562 { "addform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addform, &ndr_table_spoolss.syntax_id, NULL, "Add form", "" },
3563 { "setform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setform, &ndr_table_spoolss.syntax_id, NULL, "Set form", "" },
3564 { "getform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_getform, &ndr_table_spoolss.syntax_id, NULL, "Get form", "" },
3565 { "deleteform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deleteform, &ndr_table_spoolss.syntax_id, NULL, "Delete form", "" },
3566 { "enumforms", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_forms, &ndr_table_spoolss.syntax_id, NULL, "Enumerate forms", "" },
3567 { "setprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinter, &ndr_table_spoolss.syntax_id, NULL, "Set printer comment", "" },
3568 { "setprintername", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprintername, &ndr_table_spoolss.syntax_id, NULL, "Set printername", "" },
3569 { "setprinterdata", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinterdata, &ndr_table_spoolss.syntax_id, NULL, "Set REG_SZ printer data", "" },
3570 { "rffpcnex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_rffpcnex, &ndr_table_spoolss.syntax_id, NULL, "Rffpcnex test", "" },
3571 { "printercmp", RPC_RTYPE_WERROR, NULL, cmd_spoolss_printercmp, &ndr_table_spoolss.syntax_id, NULL, "Printer comparison test", "" },
3572 { "enumprocs", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_procs, &ndr_table_spoolss.syntax_id, NULL, "Enumerate Print Processors", "" },
3573 { "enumprocdatatypes", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_proc_data_types, &ndr_table_spoolss.syntax_id, NULL, "Enumerate Print Processor Data Types", "" },
3574 { "enummonitors", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_monitors, &ndr_table_spoolss.syntax_id, NULL, "Enumerate Print Monitors", "" },
3575 { "createprinteric", RPC_RTYPE_WERROR, NULL, cmd_spoolss_create_printer_ic, &ndr_table_spoolss.syntax_id, NULL, "Create Printer IC", "" },
3576
3577 { NULL }
3578 };
Samba GIT mirror