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