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