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