?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fix restart option (noticed by Stanford K. Baldwin)
[Samba.git] / source / rpcclient / cmd_spoolss.c
blobde951741b73049795fc0fd02a8cad1efdac9ae1b
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 struct table_node archi_table[]= {
35
36 {"Windows 4.0", "WIN40", 0 },
37 {"Windows NT x86", "W32X86", 2 },
38 {"Windows NT R4000", "W32MIPS", 2 },
39 {"Windows NT Alpha_AXP", "W32ALPHA", 2 },
40 {"Windows NT PowerPC", "W32PPC", 2 },
41 {NULL, "", -1 }
42 };
43
44 /****************************************************************************
45 function to do the mapping between the long architecture name and
46 the short one.
47 ****************************************************************************/
48 BOOL get_short_archi(char *short_archi, const char *long_archi)
49 {
50 int i=-1;
51
52 DEBUG(107,("Getting architecture dependant directory\n"));
53 do {
54 i++;
55 } while ( (archi_table[i].long_archi!=NULL ) &&
56 StrCaseCmp(long_archi, archi_table[i].long_archi) );
57
58 if (archi_table[i].long_archi==NULL) {
59 DEBUGADD(10,("Unknown architecture [%s] !\n", long_archi));
60 return False;
61 }
62
63 StrnCpy (short_archi, archi_table[i].short_archi, strlen(archi_table[i].short_archi));
64
65 DEBUGADD(108,("index: [%d]\n", i));
66 DEBUGADD(108,("long architecture: [%s]\n", long_archi));
67 DEBUGADD(108,("short architecture: [%s]\n", short_archi));
68
69 return True;
70 }
71
72
73 /**********************************************************************
74 * dummy function -- placeholder
75 */
76 static NTSTATUS cmd_spoolss_not_implemented(struct cli_state *cli,
77 TALLOC_CTX *mem_ctx,
78 int argc, char **argv)
79 {
80 printf ("(*) This command is not currently implemented.\n");
81 return NT_STATUS_OK;
82 }
83
84 /***********************************************************************
85 * Get printer information
86 */
87 static NTSTATUS cmd_spoolss_open_printer_ex(struct cli_state *cli,
88 TALLOC_CTX *mem_ctx,
89 int argc, char **argv)
90 {
91 WERROR werror;
92 pstring printername;
93 fstring servername, user;
94 POLICY_HND hnd;
95 uint32 desired_access = MAXIMUM_ALLOWED_ACCESS;
96
97 if (argc != 2 && argc != 3) {
98 printf("Usage: %s <printername> [0xallowed_access]\n", argv[0]);
99 return NT_STATUS_OK;
100 }
101
102 if (!cli)
103 return NT_STATUS_UNSUCCESSFUL;
104
105 slprintf (servername, sizeof(fstring)-1, "\\\\%s", cli->desthost);
106 strupper (servername);
107 fstrcpy (user, cli->user_name);
108 fstrcpy (printername, argv[1]);
109
110 if (argc == 3)
111 desired_access = strtol(argv[2], NULL, 16);
112
113 /* Open the printer handle */
114
115 werror = cli_spoolss_open_printer_ex(cli, mem_ctx, printername,
116 "", desired_access,
117 servername, user, &hnd);
118
119 if (W_ERROR_IS_OK(werror)) {
120 printf("Printer %s opened successfully\n", printername);
121 werror = cli_spoolss_close_printer(cli, mem_ctx, &hnd);
122
123 if (!W_ERROR_IS_OK(werror)) {
124 printf("Error closing printer handle! (%s)\n",
125 dos_errstr(werror));
126 }
127 } else {
128 printf("Failed to open printer %s: %s\n", printername,
129 dos_errstr(werror));
130 }
131
132 return W_ERROR_IS_OK(werror) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
133 }
134
135
136 /****************************************************************************
137 printer info level 0 display function
138 ****************************************************************************/
139 static void display_print_info_0(PRINTER_INFO_0 *i0)
140 {
141 fstring name = "";
142 fstring servername = "";
143
144 if (!i0)
145 return;
146
147 if (i0->printername.buffer)
148 rpcstr_pull(name, i0->printername.buffer, sizeof(name), 0, STR_TERMINATE);
149
150 if (i0->servername.buffer)
151 rpcstr_pull(servername, i0->servername.buffer, sizeof(servername), 0,STR_TERMINATE);
152
153 printf("\tprintername:[%s]\n", name);
154 printf("\tservername:[%s]\n", servername);
155 printf("\tcjobs:[0x%x]\n", i0->cjobs);
156 printf("\ttotal_jobs:[0x%x]\n", i0->total_jobs);
157
158 printf("\t:date: [%d]-[%d]-[%d] (%d)\n", i0->year, i0->month,
159 i0->day, i0->dayofweek);
160 printf("\t:time: [%d]-[%d]-[%d]-[%d]\n", i0->hour, i0->minute,
161 i0->second, i0->milliseconds);
162
163 printf("\tglobal_counter:[0x%x]\n", i0->global_counter);
164 printf("\ttotal_pages:[0x%x]\n", i0->total_pages);
165
166 printf("\tmajorversion:[0x%x]\n", i0->major_version);
167 printf("\tbuildversion:[0x%x]\n", i0->build_version);
168
169 printf("\tunknown7:[0x%x]\n", i0->unknown7);
170 printf("\tunknown8:[0x%x]\n", i0->unknown8);
171 printf("\tunknown9:[0x%x]\n", i0->unknown9);
172 printf("\tsession_counter:[0x%x]\n", i0->session_counter);
173 printf("\tunknown11:[0x%x]\n", i0->unknown11);
174 printf("\tprinter_errors:[0x%x]\n", i0->printer_errors);
175 printf("\tunknown13:[0x%x]\n", i0->unknown13);
176 printf("\tunknown14:[0x%x]\n", i0->unknown14);
177 printf("\tunknown15:[0x%x]\n", i0->unknown15);
178 printf("\tunknown16:[0x%x]\n", i0->unknown16);
179 printf("\tchange_id:[0x%x]\n", i0->change_id);
180 printf("\tunknown18:[0x%x]\n", i0->unknown18);
181 printf("\tstatus:[0x%x]\n", i0->status);
182 printf("\tunknown20:[0x%x]\n", i0->unknown20);
183 printf("\tc_setprinter:[0x%x]\n", i0->c_setprinter);
184 printf("\tunknown22:[0x%x]\n", i0->unknown22);
185 printf("\tunknown23:[0x%x]\n", i0->unknown23);
186 printf("\tunknown24:[0x%x]\n", i0->unknown24);
187 printf("\tunknown25:[0x%x]\n", i0->unknown25);
188 printf("\tunknown26:[0x%x]\n", i0->unknown26);
189 printf("\tunknown27:[0x%x]\n", i0->unknown27);
190 printf("\tunknown28:[0x%x]\n", i0->unknown28);
191 printf("\tunknown29:[0x%x]\n", i0->unknown29);
192
193 printf("\n");
194 }
195
196 /****************************************************************************
197 printer info level 1 display function
198 ****************************************************************************/
199 static void display_print_info_1(PRINTER_INFO_1 *i1)
200 {
201 fstring desc = "";
202 fstring name = "";
203 fstring comm = "";
204
205 if (i1->description.buffer)
206 rpcstr_pull(desc, i1->description.buffer, sizeof(desc), 0,
207 STR_TERMINATE);
208
209 if (i1->name.buffer)
210 rpcstr_pull(name, i1->name.buffer, sizeof(name), 0,
211 STR_TERMINATE);
212
213 if (i1->comment.buffer)
214 rpcstr_pull(comm, i1->comment.buffer, sizeof(comm), 0,
215 STR_TERMINATE);
216
217 printf("\tflags:[0x%x]\n", i1->flags);
218 printf("\tname:[%s]\n", name);
219 printf("\tdescription:[%s]\n", desc);
220 printf("\tcomment:[%s]\n", comm);
221
222 printf("\n");
223 }
224
225 /****************************************************************************
226 printer info level 2 display function
227 ****************************************************************************/
228 static void display_print_info_2(PRINTER_INFO_2 *i2)
229 {
230 fstring servername = "";
231 fstring printername = "";
232 fstring sharename = "";
233 fstring portname = "";
234 fstring drivername = "";
235 fstring comment = "";
236 fstring location = "";
237 fstring sepfile = "";
238 fstring printprocessor = "";
239 fstring datatype = "";
240 fstring parameters = "";
241
242 if (i2->servername.buffer)
243 rpcstr_pull(servername, i2->servername.buffer,sizeof(servername), 0, STR_TERMINATE);
244
245 if (i2->printername.buffer)
246 rpcstr_pull(printername, i2->printername.buffer,sizeof(printername), 0, STR_TERMINATE);
247
248 if (i2->sharename.buffer)
249 rpcstr_pull(sharename, i2->sharename.buffer,sizeof(sharename), 0, STR_TERMINATE);
250
251 if (i2->portname.buffer)
252 rpcstr_pull(portname, i2->portname.buffer,sizeof(portname), 0, STR_TERMINATE);
253
254 if (i2->drivername.buffer)
255 rpcstr_pull(drivername, i2->drivername.buffer,sizeof(drivername), 0, STR_TERMINATE);
256
257 if (i2->comment.buffer)
258 rpcstr_pull(comment, i2->comment.buffer,sizeof(comment), 0, STR_TERMINATE);
259
260 if (i2->location.buffer)
261 rpcstr_pull(location, i2->location.buffer,sizeof(location), 0, STR_TERMINATE);
262
263 if (i2->sepfile.buffer)
264 rpcstr_pull(sepfile, i2->sepfile.buffer,sizeof(sepfile), 0, STR_TERMINATE);
265
266 if (i2->printprocessor.buffer)
267 rpcstr_pull(printprocessor, i2->printprocessor.buffer,sizeof(printprocessor), 0, STR_TERMINATE);
268
269 if (i2->datatype.buffer)
270 rpcstr_pull(datatype, i2->datatype.buffer,sizeof(datatype), 0, STR_TERMINATE);
271
272 if (i2->parameters.buffer)
273 rpcstr_pull(parameters, i2->parameters.buffer,sizeof(parameters), 0, STR_TERMINATE);
274
275 printf("\tservername:[%s]\n", servername);
276 printf("\tprintername:[%s]\n", printername);
277 printf("\tsharename:[%s]\n", sharename);
278 printf("\tportname:[%s]\n", portname);
279 printf("\tdrivername:[%s]\n", drivername);
280 printf("\tcomment:[%s]\n", comment);
281 printf("\tlocation:[%s]\n", location);
282 printf("\tsepfile:[%s]\n", sepfile);
283 printf("\tprintprocessor:[%s]\n", printprocessor);
284 printf("\tdatatype:[%s]\n", datatype);
285 printf("\tparameters:[%s]\n", parameters);
286 printf("\tattributes:[0x%x]\n", i2->attributes);
287 printf("\tpriority:[0x%x]\n", i2->priority);
288 printf("\tdefaultpriority:[0x%x]\n", i2->defaultpriority);
289 printf("\tstarttime:[0x%x]\n", i2->starttime);
290 printf("\tuntiltime:[0x%x]\n", i2->untiltime);
291 printf("\tstatus:[0x%x]\n", i2->status);
292 printf("\tcjobs:[0x%x]\n", i2->cjobs);
293 printf("\taverageppm:[0x%x]\n", i2->averageppm);
294
295 if (i2->secdesc)
296 display_sec_desc(i2->secdesc);
297
298 printf("\n");
299 }
300
301 /****************************************************************************
302 printer info level 3 display function
303 ****************************************************************************/
304 static void display_print_info_3(PRINTER_INFO_3 *i3)
305 {
306 printf("\tflags:[0x%x]\n", i3->flags);
307
308 display_sec_desc(i3->secdesc);
309
310 printf("\n");
311 }
312
313 /* Enumerate printers */
314
315 static NTSTATUS cmd_spoolss_enum_printers(struct cli_state *cli,
316 TALLOC_CTX *mem_ctx,
317 int argc, char **argv)
318 {
319 WERROR result;
320 uint32 info_level = 1;
321 PRINTER_INFO_CTR ctr;
322 uint32 i = 0, num_printers, needed;
323
324 if (argc > 2)
325 {
326 printf("Usage: %s [level]\n", argv[0]);
327 return NT_STATUS_OK;
328 }
329
330 if (argc == 2) {
331 info_level = atoi(argv[1]);
332 }
333
334 /* Enumerate printers -- Should we enumerate types other
335 than PRINTER_ENUM_LOCAL? Maybe accept as a parameter? --jerry */
336
337 ZERO_STRUCT(ctr);
338
339 result = cli_spoolss_enum_printers(
340 cli, mem_ctx, 0, &needed, PRINTER_ENUM_LOCAL,
341 info_level, &num_printers, &ctr);
342
343 if (W_ERROR_V(result) == ERRinsufficientbuffer)
344 result = cli_spoolss_enum_printers(
345 cli, mem_ctx, needed, NULL, PRINTER_ENUM_LOCAL,
346 info_level, &num_printers, &ctr);
347
348 if (W_ERROR_IS_OK(result)) {
349
350 if (!num_printers) {
351 printf ("No printers returned.\n");
352 goto done;
353 }
354
355 for (i = 0; i < num_printers; i++) {
356 switch(info_level) {
357 case 0:
358 display_print_info_0(&ctr.printers_0[i]);
359 break;
360 case 1:
361 display_print_info_1(&ctr.printers_1[i]);
362 break;
363 case 2:
364 display_print_info_2(&ctr.printers_2[i]);
365 break;
366 case 3:
367 display_print_info_3(&ctr.printers_3[i]);
368 break;
369 default:
370 printf("unknown info level %d\n", info_level);
371 goto done;
372 }
373 }
374 }
375 done:
376
377 return W_ERROR_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
378 }
379
380 /****************************************************************************
381 port info level 1 display function
382 ****************************************************************************/
383 static void display_port_info_1(PORT_INFO_1 *i1)
384 {
385 fstring buffer;
386
387 rpcstr_pull(buffer, i1->port_name.buffer, sizeof(buffer), 0, STR_TERMINATE);
388 printf("\tPort Name:\t[%s]\n", buffer);
389 }
390
391 /****************************************************************************
392 port info level 2 display function
393 ****************************************************************************/
394 static void display_port_info_2(PORT_INFO_2 *i2)
395 {
396 fstring buffer;
397
398 rpcstr_pull(buffer, i2->port_name.buffer, sizeof(buffer), 0, STR_TERMINATE);
399 printf("\tPort Name:\t[%s]\n", buffer);
400 rpcstr_pull(buffer, i2->monitor_name.buffer, sizeof(buffer), 0, STR_TERMINATE);
401
402 printf("\tMonitor Name:\t[%s]\n", buffer);
403 rpcstr_pull(buffer, i2->description.buffer, sizeof(buffer), 0, STR_TERMINATE);
404
405 printf("\tDescription:\t[%s]\n", buffer);
406 printf("\tPort Type:\t[%d]\n", i2->port_type);
407 printf("\tReserved:\t[%d]\n", i2->reserved);
408 printf("\n");
409 }
410
411 /* Enumerate ports */
412
413 static NTSTATUS cmd_spoolss_enum_ports(struct cli_state *cli,
414 TALLOC_CTX *mem_ctx, int argc,
415 char **argv)
416 {
417 WERROR result;
418 uint32 needed, info_level = 1;
419 PORT_INFO_CTR ctr;
420 int returned;
421
422 if (argc > 2) {
423 printf("Usage: %s [level]\n", argv[0]);
424 return NT_STATUS_OK;
425 }
426
427 if (argc == 2)
428 info_level = atoi(argv[1]);
429
430 /* Enumerate ports */
431
432 ZERO_STRUCT(ctr);
433
434 result = cli_spoolss_enum_ports(cli, mem_ctx, 0, &needed, info_level,
435 &returned, &ctr);
436
437 if (W_ERROR_V(result) == ERRinsufficientbuffer)
438 result = cli_spoolss_enum_ports(cli, mem_ctx, needed, NULL,
439 info_level, &returned, &ctr);
440
441 if (W_ERROR_IS_OK(result)) {
442 int i;
443
444 for (i = 0; i < returned; i++) {
445 switch (info_level) {
446 case 1:
447 display_port_info_1(&ctr.port.info_1[i]);
448 break;
449 case 2:
450 display_port_info_2(&ctr.port.info_2[i]);
451 break;
452 default:
453 printf("unknown info level %d\n", info_level);
454 break;
455 }
456 }
457 }
458
459 return W_ERROR_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
460 }
461
462 /***********************************************************************
463 * Set printer comment - use a level2 set.
464 */
465 static NTSTATUS cmd_spoolss_setprinter(struct cli_state *cli,
466 TALLOC_CTX *mem_ctx,
467 int argc, char **argv)
468 {
469 POLICY_HND pol;
470 WERROR result;
471 uint32 needed;
472 uint32 info_level = 2;
473 BOOL opened_hnd = False;
474 PRINTER_INFO_CTR ctr;
475 fstring printername,
476 servername,
477 user,
478 comment;
479
480 if (argc == 1 || argc > 3) {
481 printf("Usage: %s printername comment\n", argv[0]);
482
483 return NT_STATUS_OK;
484 }
485
486 /* Open a printer handle */
487 if (argc == 3) {
488 fstrcpy(comment, argv[2]);
489 }
490
491 slprintf (servername, sizeof(fstring)-1, "\\\\%s", cli->desthost);
492 strupper (servername);
493 fstrcpy (printername, argv[1]);
494 fstrcpy (user, cli->user_name);
495
496 /* get a printer handle */
497 result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
498 MAXIMUM_ALLOWED_ACCESS, servername,
499 user, &pol);
500
501 if (!W_ERROR_IS_OK(result))
502 goto done;
503
504 opened_hnd = True;
505
506 /* Get printer info */
507 result = cli_spoolss_getprinter(cli, mem_ctx, 0, &needed, &pol, info_level, &ctr);
508
509 if (W_ERROR_V(result) == ERRinsufficientbuffer)
510 result = cli_spoolss_getprinter(cli, mem_ctx, needed, NULL, &pol, info_level, &ctr);
511
512 if (!W_ERROR_IS_OK(result))
513 goto done;
514
515
516 /* Modify the comment. */
517 init_unistr(&ctr.printers_2->comment, comment);
518 ctr.printers_2->devmode = NULL;
519 ctr.printers_2->secdesc = NULL;
520
521 result = cli_spoolss_setprinter(cli, mem_ctx, &pol, info_level, &ctr, 0);
522 if (W_ERROR_IS_OK(result))
523 printf("Success in setting comment.\n");
524
525 done:
526 if (opened_hnd)
527 cli_spoolss_close_printer(cli, mem_ctx, &pol);
528
529 return W_ERROR_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
530 }
531
532 /***********************************************************************
533 * Get printer information
534 */
535 static NTSTATUS cmd_spoolss_getprinter(struct cli_state *cli,
536 TALLOC_CTX *mem_ctx,
537 int argc, char **argv)
538 {
539 POLICY_HND pol;
540 WERROR result;
541 uint32 info_level = 1;
542 BOOL opened_hnd = False;
543 PRINTER_INFO_CTR ctr;
544 fstring printername,
545 servername,
546 user;
547 uint32 needed;
548
549 if (argc == 1 || argc > 3) {
550 printf("Usage: %s <printername> [level]\n", argv[0]);
551 return NT_STATUS_OK;
552 }
553
554 /* Open a printer handle */
555 if (argc == 3) {
556 info_level = atoi(argv[2]);
557 }
558
559 slprintf (servername, sizeof(fstring)-1, "\\\\%s", cli->desthost);
560 strupper (servername);
561 slprintf (printername, sizeof(fstring)-1, "%s\\%s", servername, argv[1]);
562 fstrcpy (user, cli->user_name);
563
564 /* get a printer handle */
565
566 result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername,
567 "", MAXIMUM_ALLOWED_ACCESS,
568 servername, user, &pol);
569
570 if (!W_ERROR_IS_OK(result))
571 goto done;
572
573 opened_hnd = True;
574
575 /* Get printer info */
576
577 result = cli_spoolss_getprinter(cli, mem_ctx, 0, &needed,
578 &pol, info_level, &ctr);
579
580 if (W_ERROR_V(result) == ERRinsufficientbuffer)
581 result = cli_spoolss_getprinter(
582 cli, mem_ctx, needed, NULL, &pol, info_level, &ctr);
583
584 if (!W_ERROR_IS_OK(result))
585 goto done;
586
587 /* Display printer info */
588
589 switch (info_level) {
590 case 0:
591 display_print_info_0(ctr.printers_0);
592 break;
593 case 1:
594 display_print_info_1(ctr.printers_1);
595 break;
596 case 2:
597 display_print_info_2(ctr.printers_2);
598 break;
599 case 3:
600 display_print_info_3(ctr.printers_3);
601 break;
602 default:
603 printf("unknown info level %d\n", info_level);
604 break;
605 }
606
607 done:
608 if (opened_hnd)
609 cli_spoolss_close_printer(cli, mem_ctx, &pol);
610
611 return W_ERROR_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
612 }
613
614 /****************************************************************************
615 printer info level 0 display function
616 ****************************************************************************/
617 static void display_print_driver_1(DRIVER_INFO_1 *i1)
618 {
619 fstring name;
620 if (i1 == NULL)
621 return;
622
623 rpcstr_pull(name, i1->name.buffer, sizeof(name), 0, STR_TERMINATE);
624
625 printf ("Printer Driver Info 1:\n");
626 printf ("\tDriver Name: [%s]\n\n", name);
627
628 return;
629 }
630
631 /****************************************************************************
632 printer info level 1 display function
633 ****************************************************************************/
634 static void display_print_driver_2(DRIVER_INFO_2 *i1)
635 {
636 fstring name;
637 fstring architecture;
638 fstring driverpath;
639 fstring datafile;
640 fstring configfile;
641 if (i1 == NULL)
642 return;
643
644 rpcstr_pull(name, i1->name.buffer, sizeof(name), 0, STR_TERMINATE);
645 rpcstr_pull(architecture, i1->architecture.buffer, sizeof(architecture), 0, STR_TERMINATE);
646 rpcstr_pull(driverpath, i1->driverpath.buffer, sizeof(driverpath), 0, STR_TERMINATE);
647 rpcstr_pull(datafile, i1->datafile.buffer, sizeof(datafile), 0, STR_TERMINATE);
648 rpcstr_pull(configfile, i1->configfile.buffer, sizeof(configfile), 0, STR_TERMINATE);
649
650 printf ("Printer Driver Info 2:\n");
651 printf ("\tVersion: [%x]\n", i1->version);
652 printf ("\tDriver Name: [%s]\n", name);
653 printf ("\tArchitecture: [%s]\n", architecture);
654 printf ("\tDriver Path: [%s]\n", driverpath);
655 printf ("\tDatafile: [%s]\n", datafile);
656 printf ("\tConfigfile: [%s]\n\n", configfile);
657
658 return;
659 }
660
661 /****************************************************************************
662 printer info level 2 display function
663 ****************************************************************************/
664 static void display_print_driver_3(DRIVER_INFO_3 *i1)
665 {
666 fstring name;
667 fstring architecture;
668 fstring driverpath;
669 fstring datafile;
670 fstring configfile;
671 fstring helpfile;
672 fstring dependentfiles;
673 fstring monitorname;
674 fstring defaultdatatype;
675
676 int length=0;
677 BOOL valid = True;
678
679 if (i1 == NULL)
680 return;
681
682 rpcstr_pull(name, i1->name.buffer, sizeof(name), 0, STR_TERMINATE);
683 rpcstr_pull(architecture, i1->architecture.buffer, sizeof(architecture), 0, STR_TERMINATE);
684 rpcstr_pull(driverpath, i1->driverpath.buffer, sizeof(driverpath), 0, STR_TERMINATE);
685 rpcstr_pull(datafile, i1->datafile.buffer, sizeof(datafile), 0, STR_TERMINATE);
686 rpcstr_pull(configfile, i1->configfile.buffer, sizeof(configfile), 0, STR_TERMINATE);
687 rpcstr_pull(helpfile, i1->helpfile.buffer, sizeof(helpfile), 0, STR_TERMINATE);
688 rpcstr_pull(monitorname, i1->monitorname.buffer, sizeof(monitorname), 0, STR_TERMINATE);
689 rpcstr_pull(defaultdatatype, i1->defaultdatatype.buffer, sizeof(defaultdatatype), 0, STR_TERMINATE);
690
691 printf ("Printer Driver Info 3:\n");
692 printf ("\tVersion: [%x]\n", i1->version);
693 printf ("\tDriver Name: [%s]\n",name);
694 printf ("\tArchitecture: [%s]\n", architecture);
695 printf ("\tDriver Path: [%s]\n", driverpath);
696 printf ("\tDatafile: [%s]\n", datafile);
697 printf ("\tConfigfile: [%s]\n", configfile);
698 printf ("\tHelpfile: [%s]\n\n", helpfile);
699
700 while (valid)
701 {
702 rpcstr_pull(dependentfiles, i1->dependentfiles+length, sizeof(dependentfiles), 0, STR_TERMINATE);
703
704 length+=strlen(dependentfiles)+1;
705
706 if (strlen(dependentfiles) > 0)
707 {
708 printf ("\tDependentfiles: [%s]\n", dependentfiles);
709 }
710 else
711 {
712 valid = False;
713 }
714 }
715
716 printf ("\n");
717
718 printf ("\tMonitorname: [%s]\n", monitorname);
719 printf ("\tDefaultdatatype: [%s]\n\n", defaultdatatype);
720
721 return;
722 }
723
724 /***********************************************************************
725 * Get printer information
726 */
727 static NTSTATUS cmd_spoolss_getdriver(struct cli_state *cli,
728 TALLOC_CTX *mem_ctx,
729 int argc, char **argv)
730 {
731 POLICY_HND pol;
732 WERROR werror;
733 NTSTATUS result;
734 uint32 info_level = 3;
735 BOOL opened_hnd = False;
736 PRINTER_DRIVER_CTR ctr;
737 fstring printername,
738 servername,
739 user;
740 uint32 i;
741
742 if ((argc == 1) || (argc > 3))
743 {
744 printf("Usage: %s <printername> [level]\n", argv[0]);
745 return NT_STATUS_OK;
746 }
747
748 /* get the arguments need to open the printer handle */
749 slprintf (servername, sizeof(fstring)-1, "\\\\%s", cli->desthost);
750 strupper (servername);
751 fstrcpy (user, cli->user_name);
752 fstrcpy (printername, argv[1]);
753 if (argc == 3)
754 info_level = atoi(argv[2]);
755
756 /* Open a printer handle */
757
758 werror = cli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
759 PRINTER_ACCESS_USE,
760 servername, user, &pol);
761
762 result = W_ERROR_IS_OK(werror) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
763
764 if (!NT_STATUS_IS_OK(result)) {
765 printf("Error opening printer handle for %s!\n", printername);
766 return result;
767 }
768
769 opened_hnd = True;
770
771 /* loop through and print driver info level for each architecture */
772
773 for (i=0; archi_table[i].long_archi!=NULL; i++) {
774 uint32 needed;
775
776 werror = cli_spoolss_getprinterdriver(
777 cli, mem_ctx, 0, &needed, &pol, info_level,
778 archi_table[i].long_archi, &ctr);
779
780 if (W_ERROR_V(werror) == ERRinsufficientbuffer)
781 werror = cli_spoolss_getprinterdriver(
782 cli, mem_ctx, needed, NULL, &pol, info_level,
783 archi_table[i].long_archi, &ctr);
784
785 if (!W_ERROR_IS_OK(werror))
786 continue;
787
788 printf ("\n[%s]\n", archi_table[i].long_archi);
789
790 switch (info_level) {
791 case 1:
792 display_print_driver_1 (ctr.info1);
793 break;
794 case 2:
795 display_print_driver_2 (ctr.info2);
796 break;
797 case 3:
798 display_print_driver_3 (ctr.info3);
799 break;
800 default:
801 printf("unknown info level %d\n", info_level);
802 break;
803 }
804 }
805
806 /* Cleanup */
807
808 if (opened_hnd)
809 cli_spoolss_close_printer (cli, mem_ctx, &pol);
810
811 return W_ERROR_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
812 }
813
814 /***********************************************************************
815 * Get printer information
816 */
817 static NTSTATUS cmd_spoolss_enum_drivers(struct cli_state *cli,
818 TALLOC_CTX *mem_ctx,
819 int argc, char **argv)
820 {
821 WERROR werror;
822 uint32 info_level = 1;
823 PRINTER_DRIVER_CTR ctr;
824 uint32 i, j,
825 returned;
826
827 if (argc > 2)
828 {
829 printf("Usage: enumdrivers [level]\n");
830 return NT_STATUS_OK;
831 }
832
833 if (argc == 2)
834 info_level = atoi(argv[1]);
835
836
837 /* loop through and print driver info level for each architecture */
838 for (i=0; archi_table[i].long_archi!=NULL; i++)
839 {
840 uint32 needed;
841
842 werror = cli_spoolss_enumprinterdrivers(
843 cli, mem_ctx, 0, &needed, info_level,
844 archi_table[i].long_archi, &returned, &ctr);
845
846 if (W_ERROR_V(werror) == ERRinsufficientbuffer)
847 werror = cli_spoolss_enumprinterdrivers(
848 cli, mem_ctx, needed, NULL, info_level,
849 archi_table[i].long_archi, &returned, &ctr);
850
851 if (returned == 0)
852 continue;
853
854 if (!W_ERROR_IS_OK(werror)) {
855 printf ("Error getting driver for environment [%s] - %d\n",
856 archi_table[i].long_archi, W_ERROR_V(werror));
857 continue;
858 }
859
860 printf ("\n[%s]\n", archi_table[i].long_archi);
861 switch (info_level)
862 {
863
864 case 1:
865 for (j=0; j < returned; j++) {
866 display_print_driver_1 (&(ctr.info1[j]));
867 }
868 break;
869 case 2:
870 for (j=0; j < returned; j++) {
871 display_print_driver_2 (&(ctr.info2[j]));
872 }
873 break;
874 case 3:
875 for (j=0; j < returned; j++) {
876 display_print_driver_3 (&(ctr.info3[j]));
877 }
878 break;
879 default:
880 printf("unknown info level %d\n", info_level);
881 break;
882 }
883 }
884
885 return W_ERROR_IS_OK(werror) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
886 }
887
888 /****************************************************************************
889 printer info level 1 display function
890 ****************************************************************************/
891 static void display_printdriverdir_1(DRIVER_DIRECTORY_1 *i1)
892 {
893 fstring name;
894 if (i1 == NULL)
895 return;
896
897 rpcstr_pull(name, i1->name.buffer, sizeof(name), 0, STR_TERMINATE);
898
899 printf ("\tDirectory Name:[%s]\n", name);
900 }
901
902 /***********************************************************************
903 * Get printer driver directory information
904 */
905 static NTSTATUS cmd_spoolss_getdriverdir(struct cli_state *cli,
906 TALLOC_CTX *mem_ctx,
907 int argc, char **argv)
908 {
909 WERROR result;
910 fstring env;
911 DRIVER_DIRECTORY_CTR ctr;
912 uint32 needed;
913
914 if (argc > 2) {
915 printf("Usage: %s [environment]\n", argv[0]);
916 return NT_STATUS_OK;
917 }
918
919 /* Get the arguments need to open the printer handle */
920
921 if (argc == 2)
922 fstrcpy (env, argv[1]);
923 else
924 fstrcpy (env, "Windows NT x86");
925
926 /* Get the directory. Only use Info level 1 */
927
928 result = cli_spoolss_getprinterdriverdir(
929 cli, mem_ctx, 0, &needed, 1, env, &ctr);
930
931 if (W_ERROR_V(result) == ERRinsufficientbuffer)
932 result = cli_spoolss_getprinterdriverdir(
933 cli, mem_ctx, needed, NULL, 1, env, &ctr);
934
935 if (W_ERROR_IS_OK(result))
936 display_printdriverdir_1(ctr.info1);
937
938 return W_ERROR_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
939 }
940
941 /*******************************************************************************
942 set the version and environment fields of a DRIVER_INFO_3 struct
943 ******************************************************************************/
944 void set_drv_info_3_env (DRIVER_INFO_3 *info, const char *arch)
945 {
946
947 int i;
948
949 for (i=0; archi_table[i].long_archi != NULL; i++)
950 {
951 if (strcmp(arch, archi_table[i].short_archi) == 0)
952 {
953 info->version = archi_table[i].version;
954 init_unistr (&info->architecture, archi_table[i].long_archi);
955 break;
956 }
957 }
958
959 if (archi_table[i].long_archi == NULL)
960 {
961 DEBUG(0, ("set_drv_info_3_env: Unknown arch [%s]\n", arch));
962 }
963
964 return;
965 }
966
967
968 /**************************************************************************
969 wrapper for strtok to get the next parameter from a delimited list.
970 Needed to handle the empty parameter string denoted by "NULL"
971 *************************************************************************/
972 static char* get_driver_3_param (char* str, const char* delim, UNISTR* dest)
973 {
974 char *ptr;
975
976 /* get the next token */
977 ptr = strtok(str, delim);
978
979 /* a string of 'NULL' is used to represent an empty
980 parameter because two consecutive delimiters
981 will not return an empty string. See man strtok(3)
982 for details */
983 if (StrCaseCmp(ptr, "NULL") == 0)
984 ptr = NULL;
985
986 if (dest != NULL)
987 init_unistr(dest, ptr);
988
989 return ptr;
990 }
991
992 /********************************************************************************
993 fill in the members of a DRIVER_INFO_3 struct using a character
994 string in the form of
995 <Long Printer Name>:<Driver File Name>:<Data File Name>:\
996 <Config File Name>:<Help File Name>:<Language Monitor Name>:\
997 <Default Data Type>:<Comma Separated list of Files>
998 *******************************************************************************/
999 static BOOL init_drv_info_3_members (
1000 TALLOC_CTX *mem_ctx,
1001 DRIVER_INFO_3 *info,
1002 char *args
1003 )
1004 {
1005 char *str, *str2;
1006 uint32 len, i;
1007
1008 /* fill in the UNISTR fields */
1009 str = get_driver_3_param (args, ":", &info->name);
1010 str = get_driver_3_param (NULL, ":", &info->driverpath);
1011 str = get_driver_3_param (NULL, ":", &info->datafile);
1012 str = get_driver_3_param (NULL, ":", &info->configfile);
1013 str = get_driver_3_param (NULL, ":", &info->helpfile);
1014 str = get_driver_3_param (NULL, ":", &info->monitorname);
1015 str = get_driver_3_param (NULL, ":", &info->defaultdatatype);
1016
1017 /* <Comma Separated List of Dependent Files> */
1018 str2 = get_driver_3_param (NULL, ":", NULL); /* save the beginning of the string */
1019 str = str2;
1020
1021 /* begin to strip out each filename */
1022 str = strtok(str, ",");
1023 len = 0;
1024 while (str != NULL)
1025 {
1026 /* keep a cumlative count of the str lengths */
1027 len += strlen(str)+1;
1028 str = strtok(NULL, ",");
1029 }
1030
1031 /* allocate the space; add one extra slot for a terminating NULL.
1032 Each filename is NULL terminated and the end contains a double
1033 NULL */
1034 if ((info->dependentfiles=(uint16*)talloc(mem_ctx, (len+1)*sizeof(uint16))) == NULL)
1035 {
1036 DEBUG(0,("init_drv_info_3_members: Unable to malloc memory for dependenfiles\n"));
1037 return False;
1038 }
1039 for (i=0; i<len; i++)
1040 {
1041 info->dependentfiles[i] = SSVAL(&info->dependentfiles[i], 0, str2[i]);
1042 }
1043 info->dependentfiles[len] = '\0';
1044
1045 return True;
1046 }
1047
1048
1049 static NTSTATUS cmd_spoolss_addprinterdriver(struct cli_state *cli,
1050 TALLOC_CTX *mem_ctx,
1051 int argc, char **argv)
1052 {
1053 WERROR result;
1054 uint32 level = 3;
1055 PRINTER_DRIVER_CTR ctr;
1056 DRIVER_INFO_3 info3;
1057 fstring arch;
1058 fstring driver_name;
1059
1060 /* parse the command arguements */
1061 if (argc != 3)
1062 {
1063 printf ("Usage: %s <Environment>\\\n", argv[0]);
1064 printf ("\t<Long Printer Name>:<Driver File Name>:<Data File Name>:\\\n");
1065 printf ("\t<Config File Name>:<Help File Name>:<Language Monitor Name>:\\\n");
1066 printf ("\t<Default Data Type>:<Comma Separated list of Files>\n");
1067
1068 return NT_STATUS_OK;
1069 }
1070
1071 /* Fill in the DRIVER_INFO_3 struct */
1072 ZERO_STRUCT(info3);
1073 if (!get_short_archi(arch, argv[1]))
1074 {
1075 printf ("Error Unknown architechture [%s]\n", argv[1]);
1076 return NT_STATUS_INVALID_PARAMETER;
1077 }
1078 else
1079 set_drv_info_3_env(&info3, arch);
1080
1081 if (!init_drv_info_3_members(mem_ctx, &info3, argv[2]))
1082 {
1083 printf ("Error Invalid parameter list - %s.\n", argv[2]);
1084 return NT_STATUS_INVALID_PARAMETER;
1085 }
1086
1087
1088 ctr.info3 = &info3;
1089 result = cli_spoolss_addprinterdriver (cli, mem_ctx, level, &ctr);
1090
1091 if (W_ERROR_IS_OK(result)) {
1092 rpcstr_pull(driver_name, info3.name.buffer,
1093 sizeof(driver_name), 0, STR_TERMINATE);
1094 printf ("Printer Driver %s successfully installed.\n",
1095 driver_name);
1096 }
1097
1098 return W_ERROR_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1099 }
1100
1101
1102 static NTSTATUS cmd_spoolss_addprinterex(struct cli_state *cli,
1103 TALLOC_CTX *mem_ctx,
1104 int argc, char **argv)
1105 {
1106 WERROR result;
1107 uint32 level = 2;
1108 PRINTER_INFO_CTR ctr;
1109 PRINTER_INFO_2 info2;
1110 fstring servername;
1111
1112 /* parse the command arguements */
1113 if (argc != 5)
1114 {
1115 printf ("Usage: %s <name> <shared name> <driver> <port>\n", argv[0]);
1116 return NT_STATUS_OK;
1117 }
1118
1119 slprintf (servername, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1120 strupper (servername);
1121
1122 /* Fill in the DRIVER_INFO_3 struct */
1123 ZERO_STRUCT(info2);
1124 #if 0 /* JERRY */
1125 init_unistr( &info2.servername, servername);
1126 #endif
1127 init_unistr( &info2.printername, argv[1]);
1128 init_unistr( &info2.sharename, argv[2]);
1129 init_unistr( &info2.drivername, argv[3]);
1130 init_unistr( &info2.portname, argv[4]);
1131 init_unistr( &info2.comment, "Created by rpcclient");
1132 init_unistr( &info2.printprocessor, "winprint");
1133 init_unistr( &info2.datatype, "RAW");
1134 info2.devmode = NULL;
1135 info2.secdesc = NULL;
1136 info2.attributes = PRINTER_ATTRIBUTE_SHARED;
1137 info2.priority = 0;
1138 info2.defaultpriority = 0;
1139 info2.starttime = 0;
1140 info2.untiltime = 0;
1141
1142 /* These three fields must not be used by AddPrinter()
1143 as defined in the MS Platform SDK documentation..
1144 --jerry
1145 info2.status = 0;
1146 info2.cjobs = 0;
1147 info2.averageppm = 0;
1148 */
1149
1150 ctr.printers_2 = &info2;
1151 result = cli_spoolss_addprinterex (cli, mem_ctx, level, &ctr);
1152
1153 if (W_ERROR_IS_OK(result))
1154 printf ("Printer %s successfully installed.\n", argv[1]);
1155
1156 return W_ERROR_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1157 }
1158
1159 static NTSTATUS cmd_spoolss_setdriver(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1160 int argc, char **argv)
1161 {
1162 POLICY_HND pol;
1163 WERROR result;
1164 uint32 level = 2;
1165 BOOL opened_hnd = False;
1166 PRINTER_INFO_CTR ctr;
1167 PRINTER_INFO_2 info2;
1168 fstring servername,
1169 printername,
1170 user;
1171 uint32 needed;
1172
1173 /* parse the command arguements */
1174 if (argc != 3)
1175 {
1176 printf ("Usage: %s <printer> <driver>\n", argv[0]);
1177 return NT_STATUS_OK;
1178 }
1179
1180 slprintf (servername, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1181 strupper (servername);
1182 slprintf (printername, sizeof(fstring)-1, "%s\\%s", servername, argv[1]);
1183 fstrcpy (user, cli->user_name);
1184
1185 /* Get a printer handle */
1186
1187 result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
1188 PRINTER_ALL_ACCESS,
1189 servername, user, &pol);
1190
1191 if (!W_ERROR_IS_OK(result))
1192 goto done;
1193
1194 opened_hnd = True;
1195
1196 /* Get printer info */
1197
1198 ZERO_STRUCT (info2);
1199 ctr.printers_2 = &info2;
1200
1201 result = cli_spoolss_getprinter(cli, mem_ctx, 0, &needed, &pol, level, &ctr);
1202
1203 if (W_ERROR_V(result) == ERRinsufficientbuffer)
1204 result = cli_spoolss_getprinter(cli, mem_ctx, needed, NULL, &pol, level, &ctr);
1205
1206 if (!W_ERROR_IS_OK(result)) {
1207 printf ("Unable to retrieve printer information!\n");
1208 goto done;
1209 }
1210
1211 /* Set the printer driver */
1212
1213 init_unistr(&ctr.printers_2->drivername, argv[2]);
1214
1215 result = cli_spoolss_setprinter(cli, mem_ctx, &pol, level, &ctr, 0);
1216
1217 if (!W_ERROR_IS_OK(result)) {
1218 printf("SetPrinter call failed!\n");
1219 goto done;;
1220 }
1221
1222 printf("Succesfully set %s to driver %s.\n", argv[1], argv[2]);
1223
1224 done:
1225 /* Cleanup */
1226
1227 if (opened_hnd)
1228 cli_spoolss_close_printer(cli, mem_ctx, &pol);
1229
1230 return W_ERROR_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1231 }
1232
1233
1234 static NTSTATUS cmd_spoolss_deletedriver(struct cli_state *cli,
1235 TALLOC_CTX *mem_ctx,
1236 int argc, char **argv)
1237 {
1238 WERROR result;
1239 fstring servername;
1240 int i;
1241
1242 /* parse the command arguements */
1243 if (argc != 2)
1244 {
1245 printf ("Usage: %s <driver>\n", argv[0]);
1246 return NT_STATUS_OK;
1247 }
1248
1249 slprintf (servername, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1250 strupper (servername);
1251
1252 /* delete the driver for all architectures */
1253 for (i=0; archi_table[i].long_archi; i++)
1254 {
1255 /* make the call to remove the driver */
1256 result = cli_spoolss_deleteprinterdriver(
1257 cli, mem_ctx, archi_table[i].long_archi, argv[1]);
1258
1259 if ( !W_ERROR_IS_OK(result) ) {
1260 if ( !W_ERROR_EQUAL(result, WERR_UNKNOWN_PRINTER_DRIVER) ) {
1261 printf ("Failed to remove driver %s for arch [%s] - error 0x%x!\n",
1262 argv[1], archi_table[i].long_archi,
1263 W_ERROR_V(result));
1264 }
1265 }
1266 else
1267 {
1268 printf ("Driver %s removed for arch [%s].\n", argv[1],
1269 archi_table[i].long_archi);
1270 }
1271 }
1272
1273 return W_ERROR_IS_OK(result) || W_ERROR_EQUAL(result, WERR_UNKNOWN_PRINTER_DRIVER) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1274 }
1275
1276 static NTSTATUS cmd_spoolss_getprintprocdir(struct cli_state *cli,
1277 TALLOC_CTX *mem_ctx,
1278 int argc, char **argv)
1279 {
1280 WERROR result;
1281 char *servername = NULL, *environment = NULL;
1282 fstring procdir;
1283 uint32 needed;
1284
1285 /* parse the command arguements */
1286 if (argc > 2) {
1287 printf ("Usage: %s [environment]\n", argv[0]);
1288 return NT_STATUS_OK;
1289 }
1290
1291 if (asprintf(&servername, "\\\\%s", cli->desthost) < 0)
1292 return NT_STATUS_NO_MEMORY;
1293 strupper(servername);
1294
1295 if (asprintf(&environment, "%s", (argc == 2) ? argv[1] :
1296 PRINTER_DRIVER_ARCHITECTURE) < 0) {
1297 SAFE_FREE(servername);
1298 return NT_STATUS_NO_MEMORY;
1299 }
1300
1301 result = cli_spoolss_getprintprocessordirectory(
1302 cli, mem_ctx, 0, &needed, servername, environment, procdir);
1303
1304 if (W_ERROR_V(result) == ERRinsufficientbuffer)
1305 result = cli_spoolss_getprintprocessordirectory(
1306 cli, mem_ctx, needed, NULL, servername, environment,
1307 procdir);
1308
1309 if (W_ERROR_IS_OK(result))
1310 printf("%s\n", procdir);
1311
1312 SAFE_FREE(servername);
1313 SAFE_FREE(environment);
1314
1315 return W_ERROR_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1316 }
1317
1318 /* Add a form */
1319
1320 static NTSTATUS cmd_spoolss_addform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1321 int argc, char **argv)
1322 {
1323 POLICY_HND handle;
1324 WERROR werror;
1325 char *servername = NULL, *printername = NULL;
1326 FORM form;
1327 BOOL got_handle = False;
1328
1329 /* Parse the command arguements */
1330
1331 if (argc != 3) {
1332 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1333 return NT_STATUS_OK;
1334 }
1335
1336 /* Get a printer handle */
1337
1338 asprintf(&servername, "\\\\%s", cli->desthost);
1339 strupper(servername);
1340 asprintf(&printername, "%s\\%s", servername, argv[1]);
1341
1342 werror = cli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
1343 MAXIMUM_ALLOWED_ACCESS,
1344 servername, cli->user_name, &handle);
1345
1346 if (!W_ERROR_IS_OK(werror))
1347 goto done;
1348
1349 got_handle = True;
1350
1351 /* Dummy up some values for the form data */
1352
1353 form.flags = FORM_USER;
1354 form.size_x = form.size_y = 100;
1355 form.left = 0;
1356 form.top = 10;
1357 form.right = 20;
1358 form.bottom = 30;
1359
1360 init_unistr2(&form.name, argv[2], strlen(argv[2]) + 1);
1361
1362 /* Add the form */
1363
1364
1365 werror = cli_spoolss_addform(cli, mem_ctx, &handle, 1, &form);
1366
1367 done:
1368 if (got_handle)
1369 cli_spoolss_close_printer(cli, mem_ctx, &handle);
1370
1371 SAFE_FREE(servername);
1372 SAFE_FREE(printername);
1373
1374 return W_ERROR_IS_OK(werror) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1375 }
1376
1377 /* Set a form */
1378
1379 static NTSTATUS cmd_spoolss_setform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1380 int argc, char **argv)
1381 {
1382 POLICY_HND handle;
1383 WERROR werror;
1384 char *servername = NULL, *printername = NULL;
1385 FORM form;
1386 BOOL got_handle = False;
1387
1388 /* Parse the command arguements */
1389
1390 if (argc != 3) {
1391 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1392 return NT_STATUS_OK;
1393 }
1394
1395 /* Get a printer handle */
1396
1397 asprintf(&servername, "\\\\%s", cli->desthost);
1398 strupper(servername);
1399 asprintf(&printername, "%s\\%s", servername, argv[1]);
1400
1401 werror = cli_spoolss_open_printer_ex(
1402 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1403 servername, cli->user_name, &handle);
1404
1405 if (!W_ERROR_IS_OK(werror))
1406 goto done;
1407
1408 got_handle = True;
1409
1410 /* Dummy up some values for the form data */
1411
1412 form.flags = FORM_PRINTER;
1413 form.size_x = form.size_y = 100;
1414 form.left = 0;
1415 form.top = 1000;
1416 form.right = 2000;
1417 form.bottom = 3000;
1418
1419 init_unistr2(&form.name, argv[2], strlen(argv[2]) + 1);
1420
1421 /* Set the form */
1422
1423 werror = cli_spoolss_setform(cli, mem_ctx, &handle, 1, argv[2], &form);
1424
1425 done:
1426 if (got_handle)
1427 cli_spoolss_close_printer(cli, mem_ctx, &handle);
1428
1429 SAFE_FREE(servername);
1430 SAFE_FREE(printername);
1431
1432 return W_ERROR_IS_OK(werror) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1433 }
1434
1435 /* Get a form */
1436
1437 static NTSTATUS cmd_spoolss_getform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1438 int argc, char **argv)
1439 {
1440 POLICY_HND handle;
1441 WERROR werror;
1442 char *servername = NULL, *printername = NULL;
1443 FORM_1 form;
1444 BOOL got_handle = False;
1445 uint32 needed;
1446
1447 /* Parse the command arguements */
1448
1449 if (argc != 3) {
1450 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1451 return NT_STATUS_OK;
1452 }
1453
1454 /* Get a printer handle */
1455
1456 asprintf(&servername, "\\\\%s", cli->desthost);
1457 strupper(servername);
1458 asprintf(&printername, "%s\\%s", servername, argv[1]);
1459
1460 werror = cli_spoolss_open_printer_ex(
1461 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1462 servername, cli->user_name, &handle);
1463
1464 if (!W_ERROR_IS_OK(werror))
1465 goto done;
1466
1467 got_handle = True;
1468
1469 /* Set the form */
1470
1471 werror = cli_spoolss_getform(cli, mem_ctx, 0, &needed,
1472 &handle, argv[2], 1, &form);
1473
1474 if (W_ERROR_V(werror) == ERRinsufficientbuffer)
1475 werror = cli_spoolss_getform(cli, mem_ctx, needed, NULL,
1476 &handle, argv[2], 1, &form);
1477
1478 if (!W_ERROR_IS_OK(werror))
1479 goto done;
1480
1481 printf("width: %d\n", form.width);
1482 printf("length: %d\n", form.length);
1483 printf("left: %d\n", form.left);
1484 printf("top: %d\n", form.top);
1485 printf("right: %d\n", form.right);
1486 printf("bottom: %d\n", form.bottom);
1487
1488 done:
1489 if (got_handle)
1490 cli_spoolss_close_printer(cli, mem_ctx, &handle);
1491
1492 SAFE_FREE(servername);
1493 SAFE_FREE(printername);
1494
1495 return W_ERROR_IS_OK(werror) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1496 }
1497
1498 /* Delete a form */
1499
1500 static NTSTATUS cmd_spoolss_deleteform(struct cli_state *cli,
1501 TALLOC_CTX *mem_ctx, int argc,
1502 char **argv)
1503 {
1504 POLICY_HND handle;
1505 WERROR werror;
1506 char *servername = NULL, *printername = NULL;
1507 BOOL got_handle = False;
1508
1509 /* Parse the command arguements */
1510
1511 if (argc != 3) {
1512 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1513 return NT_STATUS_OK;
1514 }
1515
1516 /* Get a printer handle */
1517
1518 asprintf(&servername, "\\\\%s", cli->desthost);
1519 strupper(servername);
1520 asprintf(&printername, "%s\\%s", servername, argv[1]);
1521
1522 werror = cli_spoolss_open_printer_ex(
1523 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1524 servername, cli->user_name, &handle);
1525
1526 if (!W_ERROR_IS_OK(werror))
1527 goto done;
1528
1529 got_handle = True;
1530
1531 /* Delete the form */
1532
1533 werror = cli_spoolss_deleteform(cli, mem_ctx, &handle, argv[2]);
1534
1535 done:
1536 if (got_handle)
1537 cli_spoolss_close_printer(cli, mem_ctx, &handle);
1538
1539 SAFE_FREE(servername);
1540 SAFE_FREE(printername);
1541
1542 return W_ERROR_IS_OK(werror) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1543 }
1544
1545 /* Enumerate forms */
1546
1547 static NTSTATUS cmd_spoolss_enum_forms(struct cli_state *cli,
1548 TALLOC_CTX *mem_ctx, int argc,
1549 char **argv)
1550 {
1551 POLICY_HND handle;
1552 WERROR werror;
1553 char *servername = NULL, *printername = NULL;
1554 BOOL got_handle = False;
1555 uint32 needed, num_forms, level = 1, i;
1556 FORM_1 *forms;
1557
1558 /* Parse the command arguements */
1559
1560 if (argc != 2) {
1561 printf ("Usage: %s <printer>\n", argv[0]);
1562 return NT_STATUS_OK;
1563 }
1564
1565 /* Get a printer handle */
1566
1567 asprintf(&servername, "\\\\%s", cli->desthost);
1568 strupper(servername);
1569 asprintf(&printername, "%s\\%s", servername, argv[1]);
1570
1571 werror = cli_spoolss_open_printer_ex(
1572 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1573 servername, cli->user_name, &handle);
1574
1575 if (!W_ERROR_IS_OK(werror))
1576 goto done;
1577
1578 got_handle = True;
1579
1580 /* Enumerate forms */
1581
1582 werror = cli_spoolss_enumforms(
1583 cli, mem_ctx, 0, &needed, &handle, level, &num_forms, &forms);
1584
1585 if (W_ERROR_V(werror) == ERRinsufficientbuffer)
1586 werror = cli_spoolss_enumforms(
1587 cli, mem_ctx, needed, NULL, &handle, level,
1588 &num_forms, &forms);
1589
1590 if (!W_ERROR_IS_OK(werror))
1591 goto done;
1592
1593 /* Display output */
1594
1595 for (i = 0; i < num_forms; i++) {
1596 fstring form_name;
1597
1598 if (forms[i].name.buffer)
1599 rpcstr_pull(form_name, forms[i].name.buffer,
1600 sizeof(form_name), 0, STR_TERMINATE);
1601
1602 printf("%s\n", form_name);
1603 }
1604
1605 done:
1606 if (got_handle)
1607 cli_spoolss_close_printer(cli, mem_ctx, &handle);
1608
1609 SAFE_FREE(servername);
1610 SAFE_FREE(printername);
1611
1612 return W_ERROR_IS_OK(werror) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1613 }
1614
1615 static NTSTATUS cmd_spoolss_setprinterdata(struct cli_state *cli,
1616 TALLOC_CTX *mem_ctx,
1617 int argc, char **argv)
1618 {
1619 WERROR result;
1620 uint32 needed;
1621 fstring servername, printername, user;
1622 POLICY_HND pol;
1623 BOOL opened_hnd = False;
1624 PRINTER_INFO_CTR ctr;
1625 PRINTER_INFO_0 *info = NULL;
1626
1627 /* parse the command arguements */
1628 if (argc != 4) {
1629 printf ("Usage: %s <printer> <value> <data>\n", argv[0]);
1630 return NT_STATUS_OK;
1631 }
1632
1633 slprintf (servername, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1634 strupper (servername);
1635 slprintf (printername, sizeof(fstring)-1, "%s\\%s", servername, argv[1]);
1636 fstrcpy (user, cli->user_name);
1637
1638 /* get a printer handle */
1639 result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
1640 MAXIMUM_ALLOWED_ACCESS, servername,
1641 user, &pol);
1642 if (!W_ERROR_IS_OK(result))
1643 goto done;
1644
1645 opened_hnd = True;
1646
1647 result = cli_spoolss_getprinter(cli, mem_ctx, 0, &needed,
1648 &pol, 0, &ctr);
1649
1650 if (W_ERROR_V(result) == ERRinsufficientbuffer)
1651 result = cli_spoolss_getprinter(cli, mem_ctx, needed, NULL, &pol, 0, &ctr);
1652
1653 if (!W_ERROR_IS_OK(result))
1654 goto done;
1655
1656 printf("%s\n", timestring(True));
1657 printf("\tchange_id (before set)\t:[0x%x]\n", info->change_id);
1658
1659
1660 /* Set the printer data */
1661
1662 result = cli_spoolss_setprinterdata(cli, mem_ctx, &pol, argv[2], argv[3]);
1663 if (!W_ERROR_IS_OK(result)) {
1664 printf ("Unable to set [%s=%s]!\n", argv[2], argv[3]);
1665 goto done;
1666 }
1667 printf("\tSetPrinterData succeeded [%s: %s]\n", argv[2], argv[3]);
1668
1669 result = cli_spoolss_getprinter(cli, mem_ctx, 0, &needed, &pol, 0, &ctr);
1670
1671 if (W_ERROR_V(result) == ERRinsufficientbuffer)
1672 result = cli_spoolss_getprinter(cli, mem_ctx, needed, NULL, &pol, 0, &ctr);
1673
1674 if (!W_ERROR_IS_OK(result))
1675 goto done;
1676
1677 printf("%s\n", timestring(True));
1678 printf("\tchange_id (after set)\t:[0x%x]\n", info->change_id);
1679
1680 done:
1681 /* cleanup */
1682 if (opened_hnd)
1683 cli_spoolss_close_printer(cli, mem_ctx, &pol);
1684
1685 return W_ERROR_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1686 }
1687
1688 /* List of commands exported by this module */
1689 struct cmd_set spoolss_commands[] = {
1690
1691 { "SPOOLSS" },
1692
1693 { "adddriver", cmd_spoolss_addprinterdriver, PIPE_SPOOLSS, "Add a print driver", "" },
1694 { "addprinter", cmd_spoolss_addprinterex, PIPE_SPOOLSS, "Add a printer", "" },
1695 { "deldriver", cmd_spoolss_deletedriver, PIPE_SPOOLSS, "Delete a printer driver", "" },
1696 { "enumdata", cmd_spoolss_not_implemented, PIPE_SPOOLSS, "Enumerate printer data (*)", "" },
1697 { "enumjobs", cmd_spoolss_not_implemented, PIPE_SPOOLSS, "Enumerate print jobs (*)", "" },
1698 { "enumports", cmd_spoolss_enum_ports, PIPE_SPOOLSS, "Enumerate printer ports", "" },
1699 { "enumdrivers", cmd_spoolss_enum_drivers, PIPE_SPOOLSS, "Enumerate installed printer drivers", "" },
1700 { "enumprinters", cmd_spoolss_enum_printers, PIPE_SPOOLSS, "Enumerate printers", "" },
1701 { "getdata", cmd_spoolss_not_implemented, PIPE_SPOOLSS, "Get print driver data (*)", "" },
1702 { "getdriver", cmd_spoolss_getdriver, PIPE_SPOOLSS, "Get print driver information", "" },
1703 { "getdriverdir", cmd_spoolss_getdriverdir, PIPE_SPOOLSS, "Get print driver upload directory", "" },
1704 { "getprinter", cmd_spoolss_getprinter, PIPE_SPOOLSS, "Get printer info", "" },
1705 { "getprintprocdir", cmd_spoolss_getprintprocdir, PIPE_SPOOLSS, "Get print processor directory", "" },
1706 { "openprinter", cmd_spoolss_open_printer_ex, PIPE_SPOOLSS, "Open printer handle", "" },
1707 { "setdriver", cmd_spoolss_setdriver, PIPE_SPOOLSS, "Set printer driver", "" },
1708 { "getprintprocdir", cmd_spoolss_getprintprocdir, PIPE_SPOOLSS, "Get print processor directory", "" },
1709 { "addform", cmd_spoolss_addform, PIPE_SPOOLSS, "Add form", "" },
1710 { "setform", cmd_spoolss_setform, PIPE_SPOOLSS, "Set form", "" },
1711 { "getform", cmd_spoolss_getform, PIPE_SPOOLSS, "Get form", "" },
1712 { "deleteform", cmd_spoolss_deleteform, PIPE_SPOOLSS, "Delete form", "" },
1713 { "enumforms", cmd_spoolss_enum_forms, PIPE_SPOOLSS, "Enumerate forms", "" },
1714 { "setprinter", cmd_spoolss_setprinter, PIPE_SPOOLSS, "Set printer comment", "" },
1715 { "setprinterdata", cmd_spoolss_setprinterdata, PIPE_SPOOLSS, "Set REG_SZ printer data", "" },
1716
1717 { NULL }
1718 };
Samba GIT mirror