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