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