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