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