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