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