s3-registry: use pull_reg_sz() where appropriate.
[ira/wip.git] / source3 / rpcclient / cmd_spoolss.c
1 /*
2    Unix SMB/CIFS implementation.
3    RPC pipe client
4
5    Copyright (C) Gerald Carter                2001-2005
6    Copyright (C) Tim Potter                        2000
7    Copyright (C) Andrew Tridgell              1992-1999
8    Copyright (C) Luke Kenneth Casson Leighton 1996-1999
9    Copyright (C) Guenther Deschner                 2009
10
11    This program is free software; you can redistribute it and/or modify
12    it under the terms of the GNU General Public License as published by
13    the Free Software Foundation; either version 3 of the License, or
14    (at your option) any later version.
15
16    This program is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19    GNU General Public License for more details.
20
21    You should have received a copy of the GNU General Public License
22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
23 */
24
25 #include "includes.h"
26 #include "rpcclient.h"
27
28 #define RPCCLIENT_PRINTERNAME(_printername, _cli, _arg) \
29 { \
30         _printername = talloc_asprintf_strupper_m(mem_ctx, "%s\\%s", \
31                 _cli->srv_name_slash, _arg); \
32         W_ERROR_HAVE_NO_MEMORY(_printername); \
33 }
34
35 /* The version int is used by getdrivers.  Note that
36    all architecture strings that support mutliple
37    versions must be grouped together since enumdrivers
38    uses this property to prevent issuing multiple
39    enumdriver calls for the same arch */
40
41
42 static const struct print_architecture_table_node archi_table[]= {
43
44         {"Windows 4.0",          "WIN40",       0 },
45         {"Windows NT x86",       "W32X86",      2 },
46         {"Windows NT x86",       "W32X86",      3 },
47         {"Windows NT R4000",     "W32MIPS",     2 },
48         {"Windows NT Alpha_AXP", "W32ALPHA",    2 },
49         {"Windows NT PowerPC",   "W32PPC",      2 },
50         {"Windows IA64",         "IA64",        3 },
51         {"Windows x64",          "x64",         3 },
52         {NULL,                   "",            -1 }
53 };
54
55 /**
56  * @file
57  *
58  * rpcclient module for SPOOLSS rpc pipe.
59  *
60  * This generally just parses and checks command lines, and then calls
61  * a cli_spoolss function.
62  **/
63
64 /****************************************************************************
65  function to do the mapping between the long architecture name and
66  the short one.
67 ****************************************************************************/
68
69 static const char *cmd_spoolss_get_short_archi(const char *long_archi)
70 {
71         int i=-1;
72
73         DEBUG(107,("Getting architecture dependant directory\n"));
74         do {
75                 i++;
76         } while ( (archi_table[i].long_archi!=NULL ) &&
77                   StrCaseCmp(long_archi, archi_table[i].long_archi) );
78
79         if (archi_table[i].long_archi==NULL) {
80                 DEBUGADD(10,("Unknown architecture [%s] !\n", long_archi));
81                 return NULL;
82         }
83
84         /* this might be client code - but shouldn't this be an fstrcpy etc? */
85
86
87         DEBUGADD(108,("index: [%d]\n", i));
88         DEBUGADD(108,("long architecture: [%s]\n", archi_table[i].long_archi));
89         DEBUGADD(108,("short architecture: [%s]\n", archi_table[i].short_archi));
90
91         return archi_table[i].short_archi;
92 }
93
94 /****************************************************************************
95 ****************************************************************************/
96
97 static WERROR cmd_spoolss_open_printer_ex(struct rpc_pipe_client *cli,
98                                             TALLOC_CTX *mem_ctx,
99                                             int argc, const char **argv)
100 {
101         WERROR          werror;
102         struct policy_handle    hnd;
103
104         if (argc != 2) {
105                 printf("Usage: %s <printername>\n", argv[0]);
106                 return WERR_OK;
107         }
108
109         if (!cli)
110             return WERR_GENERAL_FAILURE;
111
112         /* Open the printer handle */
113
114         werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
115                                                argv[1],
116                                                PRINTER_ALL_ACCESS,
117                                                &hnd);
118         if (W_ERROR_IS_OK(werror)) {
119                 printf("Printer %s opened successfully\n", argv[1]);
120                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, &werror);
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 werror;
129 }
130
131
132 /****************************************************************************
133 ****************************************************************************/
134
135 static void display_print_info0(struct spoolss_PrinterInfo0 *r)
136 {
137         if (!r)
138                 return;
139
140         printf("\tprintername:[%s]\n", r->printername);
141         printf("\tservername:[%s]\n", r->servername);
142         printf("\tcjobs:[0x%x]\n", r->cjobs);
143         printf("\ttotal_jobs:[0x%x]\n", r->total_jobs);
144         printf("\ttotal_bytes:[0x%x]\n", r->total_bytes);
145         printf("\t:date: [%d]-[%d]-[%d] (%d)\n", r->time.year, r->time.month,
146                r->time.day, r->time.day_of_week);
147         printf("\t:time: [%d]-[%d]-[%d]-[%d]\n", r->time.hour, r->time.minute,
148                r->time.second, r->time.millisecond);
149
150         printf("\tglobal_counter:[0x%x]\n", r->global_counter);
151         printf("\ttotal_pages:[0x%x]\n", r->total_pages);
152
153         printf("\tversion:[0x%x]\n", r->version);
154         printf("\tfree_build:[0x%x]\n", r->free_build);
155         printf("\tspooling:[0x%x]\n", r->spooling);
156         printf("\tmax_spooling:[0x%x]\n", r->max_spooling);
157         printf("\tsession_counter:[0x%x]\n", r->session_counter);
158         printf("\tnum_error_out_of_paper:[0x%x]\n", r->num_error_out_of_paper);
159         printf("\tnum_error_not_ready:[0x%x]\n", r->num_error_not_ready);
160         printf("\tjob_error:[0x%x]\n", r->job_error);
161         printf("\tnumber_of_processors:[0x%x]\n", r->number_of_processors);
162         printf("\tprocessor_type:[0x%x]\n", r->processor_type);
163         printf("\thigh_part_total_bytes:[0x%x]\n", r->high_part_total_bytes);
164         printf("\tchange_id:[0x%x]\n", r->change_id);
165         printf("\tlast_error: %s\n", win_errstr(r->last_error));
166         printf("\tstatus:[0x%x]\n", r->status);
167         printf("\tenumerate_network_printers:[0x%x]\n", r->enumerate_network_printers);
168         printf("\tc_setprinter:[0x%x]\n", r->c_setprinter);
169         printf("\tprocessor_architecture:[0x%x]\n", r->processor_architecture);
170         printf("\tprocessor_level:[0x%x]\n", r->processor_level);
171         printf("\tref_ic:[0x%x]\n", r->ref_ic);
172         printf("\treserved2:[0x%x]\n", r->reserved2);
173         printf("\treserved3:[0x%x]\n", r->reserved3);
174
175         printf("\n");
176 }
177
178 /****************************************************************************
179 ****************************************************************************/
180
181 static void display_print_info1(struct spoolss_PrinterInfo1 *r)
182 {
183         printf("\tflags:[0x%x]\n", r->flags);
184         printf("\tname:[%s]\n", r->name);
185         printf("\tdescription:[%s]\n", r->description);
186         printf("\tcomment:[%s]\n", r->comment);
187
188         printf("\n");
189 }
190
191 /****************************************************************************
192 ****************************************************************************/
193
194 static void display_print_info2(struct spoolss_PrinterInfo2 *r)
195 {
196         printf("\tservername:[%s]\n", r->servername);
197         printf("\tprintername:[%s]\n", r->printername);
198         printf("\tsharename:[%s]\n", r->sharename);
199         printf("\tportname:[%s]\n", r->portname);
200         printf("\tdrivername:[%s]\n", r->drivername);
201         printf("\tcomment:[%s]\n", r->comment);
202         printf("\tlocation:[%s]\n", r->location);
203         printf("\tsepfile:[%s]\n", r->sepfile);
204         printf("\tprintprocessor:[%s]\n", r->printprocessor);
205         printf("\tdatatype:[%s]\n", r->datatype);
206         printf("\tparameters:[%s]\n", r->parameters);
207         printf("\tattributes:[0x%x]\n", r->attributes);
208         printf("\tpriority:[0x%x]\n", r->priority);
209         printf("\tdefaultpriority:[0x%x]\n", r->defaultpriority);
210         printf("\tstarttime:[0x%x]\n", r->starttime);
211         printf("\tuntiltime:[0x%x]\n", r->untiltime);
212         printf("\tstatus:[0x%x]\n", r->status);
213         printf("\tcjobs:[0x%x]\n", r->cjobs);
214         printf("\taverageppm:[0x%x]\n", r->averageppm);
215
216         if (r->secdesc)
217                 display_sec_desc(r->secdesc);
218
219         printf("\n");
220 }
221
222 /****************************************************************************
223 ****************************************************************************/
224
225 static void display_print_info3(struct spoolss_PrinterInfo3 *r)
226 {
227         display_sec_desc(r->secdesc);
228
229         printf("\n");
230 }
231
232 /****************************************************************************
233 ****************************************************************************/
234
235 static void display_print_info4(struct spoolss_PrinterInfo4 *r)
236 {
237         printf("\tservername:[%s]\n", r->servername);
238         printf("\tprintername:[%s]\n", r->printername);
239         printf("\tattributes:[0x%x]\n", r->attributes);
240         printf("\n");
241 }
242
243 /****************************************************************************
244 ****************************************************************************/
245
246 static void display_print_info5(struct spoolss_PrinterInfo5 *r)
247 {
248         printf("\tprintername:[%s]\n", r->printername);
249         printf("\tportname:[%s]\n", r->portname);
250         printf("\tattributes:[0x%x]\n", r->attributes);
251         printf("\tdevice_not_selected_timeout:[0x%x]\n", r->device_not_selected_timeout);
252         printf("\ttransmission_retry_timeout:[0x%x]\n", r->transmission_retry_timeout);
253         printf("\n");
254 }
255
256 /****************************************************************************
257 ****************************************************************************/
258
259 static void display_print_info6(struct spoolss_PrinterInfo6 *r)
260 {
261         printf("\tstatus:[0x%x]\n", r->status);
262         printf("\n");
263 }
264
265 /****************************************************************************
266 ****************************************************************************/
267
268 static void display_print_info7(struct spoolss_PrinterInfo7 *r)
269 {
270         printf("\tguid:[%s]\n", r->guid);
271         printf("\taction:[0x%x]\n", r->action);
272         printf("\n");
273 }
274
275 /****************************************************************************
276 ****************************************************************************/
277
278 static WERROR cmd_spoolss_enum_printers(struct rpc_pipe_client *cli,
279                                         TALLOC_CTX *mem_ctx,
280                                         int argc, const char **argv)
281 {
282         WERROR                  result;
283         uint32_t                level = 1;
284         union spoolss_PrinterInfo *info;
285         uint32_t                i, count;
286         const char *name;
287         uint32_t flags = PRINTER_ENUM_LOCAL;
288
289         if (argc > 4) {
290                 printf("Usage: %s [level] [name] [flags]\n", argv[0]);
291                 return WERR_OK;
292         }
293
294         if (argc >= 2) {
295                 level = atoi(argv[1]);
296         }
297
298         if (argc >= 3) {
299                 name = argv[2];
300         } else {
301                 name = cli->srv_name_slash;
302         }
303
304         if (argc == 4) {
305                 flags = atoi(argv[3]);
306         }
307
308         result = rpccli_spoolss_enumprinters(cli, mem_ctx,
309                                              flags,
310                                              name,
311                                              level,
312                                              0,
313                                              &count,
314                                              &info);
315         if (W_ERROR_IS_OK(result)) {
316
317                 if (!count) {
318                         printf ("No printers returned.\n");
319                         goto done;
320                 }
321
322                 for (i = 0; i < count; i++) {
323                         switch (level) {
324                         case 0:
325                                 display_print_info0(&info[i].info0);
326                                 break;
327                         case 1:
328                                 display_print_info1(&info[i].info1);
329                                 break;
330                         case 2:
331                                 display_print_info2(&info[i].info2);
332                                 break;
333                         case 3:
334                                 display_print_info3(&info[i].info3);
335                                 break;
336                         case 4:
337                                 display_print_info4(&info[i].info4);
338                                 break;
339                         case 5:
340                                 display_print_info5(&info[i].info5);
341                                 break;
342                         case 6:
343                                 display_print_info6(&info[i].info6);
344                                 break;
345                         default:
346                                 printf("unknown info level %d\n", level);
347                                 goto done;
348                         }
349                 }
350         }
351  done:
352
353         return result;
354 }
355
356 /****************************************************************************
357 ****************************************************************************/
358
359 static void display_port_info_1(struct spoolss_PortInfo1 *r)
360 {
361         printf("\tPort Name:\t[%s]\n", r->port_name);
362 }
363
364 /****************************************************************************
365 ****************************************************************************/
366
367 static void display_port_info_2(struct spoolss_PortInfo2 *r)
368 {
369         printf("\tPort Name:\t[%s]\n", r->port_name);
370         printf("\tMonitor Name:\t[%s]\n", r->monitor_name);
371         printf("\tDescription:\t[%s]\n", r->description);
372         printf("\tPort Type:\t" );
373         if (r->port_type) {
374                 int comma = 0; /* hack */
375                 printf( "[" );
376                 if (r->port_type & SPOOLSS_PORT_TYPE_READ) {
377                         printf( "Read" );
378                         comma = 1;
379                 }
380                 if (r->port_type & SPOOLSS_PORT_TYPE_WRITE) {
381                         printf( "%sWrite", comma ? ", " : "" );
382                         comma = 1;
383                 }
384                 /* These two have slightly different interpretations
385                  on 95/98/ME but I'm disregarding that for now */
386                 if (r->port_type & SPOOLSS_PORT_TYPE_REDIRECTED) {
387                         printf( "%sRedirected", comma ? ", " : "" );
388                         comma = 1;
389                 }
390                 if (r->port_type & SPOOLSS_PORT_TYPE_NET_ATTACHED) {
391                         printf( "%sNet-Attached", comma ? ", " : "" );
392                 }
393                 printf( "]\n" );
394         } else {
395                 printf( "[Unset]\n" );
396         }
397         printf("\tReserved:\t[%d]\n", r->reserved);
398         printf("\n");
399 }
400
401 /****************************************************************************
402 ****************************************************************************/
403
404 static WERROR cmd_spoolss_enum_ports(struct rpc_pipe_client *cli,
405                                        TALLOC_CTX *mem_ctx, int argc,
406                                        const char **argv)
407 {
408         WERROR                  result;
409         uint32_t                level = 1;
410         uint32_t                count;
411         union spoolss_PortInfo *info;
412
413         if (argc > 2) {
414                 printf("Usage: %s [level]\n", argv[0]);
415                 return WERR_OK;
416         }
417
418         if (argc == 2) {
419                 level = atoi(argv[1]);
420         }
421
422         /* Enumerate ports */
423
424         result = rpccli_spoolss_enumports(cli, mem_ctx,
425                                           cli->srv_name_slash,
426                                           level,
427                                           0,
428                                           &count,
429                                           &info);
430         if (W_ERROR_IS_OK(result)) {
431                 int i;
432
433                 for (i = 0; i < count; i++) {
434                         switch (level) {
435                         case 1:
436                                 display_port_info_1(&info[i].info1);
437                                 break;
438                         case 2:
439                                 display_port_info_2(&info[i].info2);
440                                 break;
441                         default:
442                                 printf("unknown info level %d\n", level);
443                                 break;
444                         }
445                 }
446         }
447
448         return result;
449 }
450
451 /****************************************************************************
452 ****************************************************************************/
453
454 static WERROR cmd_spoolss_setprinter(struct rpc_pipe_client *cli,
455                                        TALLOC_CTX *mem_ctx,
456                                        int argc, const char **argv)
457 {
458         struct policy_handle pol;
459         WERROR          result;
460         NTSTATUS        status;
461         uint32_t        info_level = 2;
462         union spoolss_PrinterInfo info;
463         struct spoolss_SetPrinterInfoCtr info_ctr;
464         const char      *printername, *comment = NULL;
465         struct spoolss_DevmodeContainer devmode_ctr;
466         struct sec_desc_buf secdesc_ctr;
467
468         if (argc == 1 || argc > 3) {
469                 printf("Usage: %s printername comment\n", argv[0]);
470
471                 return WERR_OK;
472         }
473
474         /* Open a printer handle */
475         if (argc == 3) {
476                 comment = argv[2];
477         }
478
479         ZERO_STRUCT(devmode_ctr);
480         ZERO_STRUCT(secdesc_ctr);
481
482         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
483
484         /* get a printer handle */
485         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
486                                                printername,
487                                                PRINTER_ALL_ACCESS,
488                                                &pol);
489         if (!W_ERROR_IS_OK(result))
490                 goto done;
491
492         /* Get printer info */
493         result = rpccli_spoolss_getprinter(cli, mem_ctx,
494                                            &pol,
495                                            info_level,
496                                            0,
497                                            &info);
498         if (!W_ERROR_IS_OK(result))
499                 goto done;
500
501
502         /* Modify the comment. */
503         info.info2.comment = comment;
504         info.info2.secdesc = NULL;
505         info.info2.devmode = NULL;
506
507         info_ctr.level = 2;
508         info_ctr.info.info2 = (struct spoolss_SetPrinterInfo2 *)&info.info2;
509
510         status = rpccli_spoolss_SetPrinter(cli, mem_ctx,
511                                            &pol,
512                                            &info_ctr,
513                                            &devmode_ctr,
514                                            &secdesc_ctr,
515                                            0, /* command */
516                                            &result);
517         if (W_ERROR_IS_OK(result))
518                 printf("Success in setting comment.\n");
519
520  done:
521         if (is_valid_policy_hnd(&pol))
522                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
523
524         return result;
525 }
526
527 /****************************************************************************
528 ****************************************************************************/
529
530 static WERROR cmd_spoolss_setprintername(struct rpc_pipe_client *cli,
531                                        TALLOC_CTX *mem_ctx,
532                                        int argc, const char **argv)
533 {
534         struct policy_handle pol;
535         WERROR          result;
536         NTSTATUS        status;
537         uint32_t        info_level = 2;
538         union spoolss_PrinterInfo info;
539         const char      *printername,
540                         *new_printername = NULL;
541         struct spoolss_SetPrinterInfoCtr info_ctr;
542         struct spoolss_DevmodeContainer devmode_ctr;
543         struct sec_desc_buf secdesc_ctr;
544
545         ZERO_STRUCT(devmode_ctr);
546         ZERO_STRUCT(secdesc_ctr);
547
548         if (argc == 1 || argc > 3) {
549                 printf("Usage: %s printername new_printername\n", argv[0]);
550
551                 return WERR_OK;
552         }
553
554         /* Open a printer handle */
555         if (argc == 3) {
556                 new_printername = argv[2];
557         }
558
559         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
560
561         /* get a printer handle */
562         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
563                                                printername,
564                                                PRINTER_ALL_ACCESS,
565                                                &pol);
566         if (!W_ERROR_IS_OK(result))
567                 goto done;
568
569         /* Get printer info */
570         result = rpccli_spoolss_getprinter(cli, mem_ctx,
571                                            &pol,
572                                            info_level,
573                                            0,
574                                            &info);
575         if (!W_ERROR_IS_OK(result))
576                 goto done;
577
578         /* Modify the printername. */
579         info.info2.printername = new_printername;
580         info.info2.devmode = NULL;
581         info.info2.secdesc = NULL;
582
583         info_ctr.level = info_level;
584         info_ctr.info.info2 = (struct spoolss_SetPrinterInfo2 *)&info.info2;
585
586         status = rpccli_spoolss_SetPrinter(cli, mem_ctx,
587                                            &pol,
588                                            &info_ctr,
589                                            &devmode_ctr,
590                                            &secdesc_ctr,
591                                            0, /* command */
592                                            &result);
593         if (W_ERROR_IS_OK(result))
594                 printf("Success in setting printername.\n");
595
596  done:
597         if (is_valid_policy_hnd(&pol))
598                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
599
600         return result;
601 }
602
603 /****************************************************************************
604 ****************************************************************************/
605
606 static WERROR cmd_spoolss_getprinter(struct rpc_pipe_client *cli,
607                                        TALLOC_CTX *mem_ctx,
608                                        int argc, const char **argv)
609 {
610         struct policy_handle pol;
611         WERROR          result;
612         uint32_t        level = 1;
613         const char      *printername;
614         union spoolss_PrinterInfo info;
615
616         if (argc == 1 || argc > 3) {
617                 printf("Usage: %s <printername> [level]\n", argv[0]);
618                 return WERR_OK;
619         }
620
621         /* Open a printer handle */
622         if (argc == 3) {
623                 level = atoi(argv[2]);
624         }
625
626         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
627
628         /* get a printer handle */
629
630         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
631                                                printername,
632                                                SEC_FLAG_MAXIMUM_ALLOWED,
633                                                &pol);
634         if (!W_ERROR_IS_OK(result)) {
635                 goto done;
636         }
637
638         /* Get printer info */
639
640         result = rpccli_spoolss_getprinter(cli, mem_ctx,
641                                            &pol,
642                                            level,
643                                            0,
644                                            &info);
645         if (!W_ERROR_IS_OK(result)) {
646                 goto done;
647         }
648
649         /* Display printer info */
650         switch (level) {
651         case 0:
652                 display_print_info0(&info.info0);
653                 break;
654         case 1:
655                 display_print_info1(&info.info1);
656                 break;
657         case 2:
658                 display_print_info2(&info.info2);
659                 break;
660         case 3:
661                 display_print_info3(&info.info3);
662                 break;
663         case 4:
664                 display_print_info4(&info.info4);
665                 break;
666         case 5:
667                 display_print_info5(&info.info5);
668                 break;
669         case 6:
670                 display_print_info6(&info.info6);
671                 break;
672         case 7:
673                 display_print_info7(&info.info7);
674                 break;
675         default:
676                 printf("unknown info level %d\n", level);
677                 break;
678         }
679  done:
680         if (is_valid_policy_hnd(&pol)) {
681                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
682         }
683
684         return result;
685 }
686
687 /****************************************************************************
688 ****************************************************************************/
689
690 static void display_reg_value(struct regval_blob value)
691 {
692         const char *text = NULL;
693         DATA_BLOB blob;
694
695         switch(value.type) {
696         case REG_DWORD:
697                 printf("%s: REG_DWORD: 0x%08x\n", value.valuename,
698                        *((uint32_t *) value.data_p));
699                 break;
700         case REG_SZ:
701                 blob = data_blob_const(value.data_p, value.size);
702                 pull_reg_sz(talloc_tos(), &blob, &text);
703                 printf("%s: REG_SZ: %s\n", value.valuename, text ? text : "");
704                 break;
705         case REG_BINARY: {
706                 char *hex = hex_encode_talloc(NULL, value.data_p, value.size);
707                 size_t i, len;
708                 printf("%s: REG_BINARY:", value.valuename);
709                 len = strlen(hex);
710                 for (i=0; i<len; i++) {
711                         if (hex[i] == '\0') {
712                                 break;
713                         }
714                         if (i%40 == 0) {
715                                 putchar('\n');
716                         }
717                         putchar(hex[i]);
718                 }
719                 TALLOC_FREE(hex);
720                 putchar('\n');
721                 break;
722         }
723         case REG_MULTI_SZ: {
724                 uint32_t i;
725                 const char **values;
726                 blob = data_blob_const(value.data_p, value.size);
727
728                 if (!pull_reg_multi_sz(NULL, &blob, &values)) {
729                         d_printf("pull_reg_multi_sz failed\n");
730                         break;
731                 }
732
733                 printf("%s: REG_MULTI_SZ: \n", value.valuename);
734                 for (i=0; values[i] != NULL; i++) {
735                         d_printf("%s\n", values[i]);
736                 }
737                 TALLOC_FREE(values);
738                 break;
739         }
740         default:
741                 printf("%s: unknown type %d\n", value.valuename, value.type);
742         }
743
744 }
745
746 /****************************************************************************
747 ****************************************************************************/
748
749 static void display_printer_data(const char *v,
750                                  enum winreg_Type type,
751                                  union spoolss_PrinterData *r)
752 {
753         int i;
754
755         switch (type) {
756         case REG_DWORD:
757                 printf("%s: REG_DWORD: 0x%08x\n", v, r->value);
758                 break;
759         case REG_SZ:
760                 printf("%s: REG_SZ: %s\n", v, r->string);
761                 break;
762         case REG_BINARY: {
763                 char *hex = hex_encode_talloc(NULL,
764                         r->binary.data, r->binary.length);
765                 size_t len;
766                 printf("%s: REG_BINARY:", v);
767                 len = strlen(hex);
768                 for (i=0; i<len; i++) {
769                         if (hex[i] == '\0') {
770                                 break;
771                         }
772                         if (i%40 == 0) {
773                                 putchar('\n');
774                         }
775                         putchar(hex[i]);
776                 }
777                 TALLOC_FREE(hex);
778                 putchar('\n');
779                 break;
780         }
781         case REG_MULTI_SZ:
782                 printf("%s: REG_MULTI_SZ: ", v);
783                 for (i=0; r->string_array[i] != NULL; i++) {
784                         printf("%s ", r->string_array[i]);
785                 }
786                 printf("\n");
787                 break;
788         default:
789                 printf("%s: unknown type 0x%02x:\n", v, type);
790                 break;
791         }
792 }
793
794 /****************************************************************************
795 ****************************************************************************/
796
797 static WERROR cmd_spoolss_getprinterdata(struct rpc_pipe_client *cli,
798                                            TALLOC_CTX *mem_ctx,
799                                            int argc, const char **argv)
800 {
801         struct policy_handle pol;
802         WERROR          result;
803         fstring         printername;
804         const char *valuename;
805         enum winreg_Type type;
806         union spoolss_PrinterData data;
807
808         if (argc != 3) {
809                 printf("Usage: %s <printername> <valuename>\n", argv[0]);
810                 printf("<printername> of . queries print server\n");
811                 return WERR_OK;
812         }
813         valuename = argv[2];
814
815         /* Open a printer handle */
816
817         if (strncmp(argv[1], ".", sizeof(".")) == 0)
818                 fstrcpy(printername, cli->srv_name_slash);
819         else
820                 slprintf(printername, sizeof(printername)-1, "%s\\%s",
821                           cli->srv_name_slash, argv[1]);
822
823         /* get a printer handle */
824
825         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
826                                                printername,
827                                                SEC_FLAG_MAXIMUM_ALLOWED,
828                                                &pol);
829         if (!W_ERROR_IS_OK(result))
830                 goto done;
831
832         /* Get printer info */
833
834         result = rpccli_spoolss_getprinterdata(cli, mem_ctx,
835                                                &pol,
836                                                valuename,
837                                                0,
838                                                &type,
839                                                &data);
840         if (!W_ERROR_IS_OK(result))
841                 goto done;
842
843         /* Display printer data */
844
845         display_printer_data(valuename, type, &data);
846
847  done:
848         if (is_valid_policy_hnd(&pol))
849                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
850
851         return result;
852 }
853
854 /****************************************************************************
855 ****************************************************************************/
856
857 static WERROR cmd_spoolss_getprinterdataex(struct rpc_pipe_client *cli,
858                                              TALLOC_CTX *mem_ctx,
859                                              int argc, const char **argv)
860 {
861         struct policy_handle pol;
862         WERROR          result;
863         NTSTATUS        status;
864         fstring         printername;
865         const char *valuename, *keyname;
866         struct regval_blob value;
867
868         enum winreg_Type type;
869         uint8_t *buffer = NULL;
870         uint32_t offered = 0;
871         uint32_t needed;
872
873         if (argc != 4) {
874                 printf("Usage: %s <printername> <keyname> <valuename>\n",
875                        argv[0]);
876                 printf("<printername> of . queries print server\n");
877                 return WERR_OK;
878         }
879         valuename = argv[3];
880         keyname = argv[2];
881
882         /* Open a printer handle */
883
884         if (strncmp(argv[1], ".", sizeof(".")) == 0)
885                 fstrcpy(printername, cli->srv_name_slash);
886         else
887                 slprintf(printername, sizeof(printername)-1, "%s\\%s",
888                           cli->srv_name_slash, argv[1]);
889
890         /* get a printer handle */
891
892         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
893                                                printername,
894                                                SEC_FLAG_MAXIMUM_ALLOWED,
895                                                &pol);
896         if (!W_ERROR_IS_OK(result))
897                 goto done;
898
899         /* Get printer info */
900
901         status = rpccli_spoolss_GetPrinterDataEx(cli, mem_ctx,
902                                                  &pol,
903                                                  keyname,
904                                                  valuename,
905                                                  &type,
906                                                  buffer,
907                                                  offered,
908                                                  &needed,
909                                                  &result);
910         if (W_ERROR_EQUAL(result, WERR_MORE_DATA)) {
911                 offered = needed;
912                 buffer = talloc_array(mem_ctx, uint8_t, needed);
913                 status = rpccli_spoolss_GetPrinterDataEx(cli, mem_ctx,
914                                                          &pol,
915                                                          keyname,
916                                                          valuename,
917                                                          &type,
918                                                          buffer,
919                                                          offered,
920                                                          &needed,
921                                                          &result);
922         }
923
924         if (!NT_STATUS_IS_OK(status)) {
925                 goto done;
926         }
927
928         if (!W_ERROR_IS_OK(result)) {
929                 goto done;
930         }
931
932
933         if (!W_ERROR_IS_OK(result))
934                 goto done;
935
936         /* Display printer data */
937
938         fstrcpy(value.valuename, valuename);
939         value.type = type;
940         value.size = needed;
941         value.data_p = buffer;
942
943         display_reg_value(value);
944
945  done:
946         if (is_valid_policy_hnd(&pol))
947                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
948
949         return result;
950 }
951
952 /****************************************************************************
953 ****************************************************************************/
954
955 static void display_print_driver1(struct spoolss_DriverInfo1 *r)
956 {
957         if (!r) {
958                 return;
959         }
960
961         printf("Printer Driver Info 1:\n");
962         printf("\tDriver Name: [%s]\n", r->driver_name);
963         printf("\n");
964 }
965
966 /****************************************************************************
967 ****************************************************************************/
968
969 static void display_print_driver2(struct spoolss_DriverInfo2 *r)
970 {
971         if (!r) {
972                 return;
973         }
974
975         printf("Printer Driver Info 2:\n");
976         printf("\tVersion: [%x]\n", r->version);
977         printf("\tDriver Name: [%s]\n", r->driver_name);
978         printf("\tArchitecture: [%s]\n", r->architecture);
979         printf("\tDriver Path: [%s]\n", r->driver_path);
980         printf("\tDatafile: [%s]\n", r->data_file);
981         printf("\tConfigfile: [%s]\n", r->config_file);
982         printf("\n");
983 }
984
985 /****************************************************************************
986 ****************************************************************************/
987
988 static void display_print_driver3(struct spoolss_DriverInfo3 *r)
989 {
990         int i;
991
992         if (!r) {
993                 return;
994         }
995
996         printf("Printer Driver Info 3:\n");
997         printf("\tVersion: [%x]\n", r->version);
998         printf("\tDriver Name: [%s]\n", r->driver_name);
999         printf("\tArchitecture: [%s]\n", r->architecture);
1000         printf("\tDriver Path: [%s]\n", r->driver_path);
1001         printf("\tDatafile: [%s]\n", r->data_file);
1002         printf("\tConfigfile: [%s]\n", r->config_file);
1003         printf("\tHelpfile: [%s]\n", r->help_file);
1004
1005         for (i=0; r->dependent_files && r->dependent_files[i] != NULL; i++) {
1006                 printf("\tDependentfiles: [%s]\n", r->dependent_files[i]);
1007         }
1008
1009         printf("\tMonitorname: [%s]\n", r->monitor_name);
1010         printf("\tDefaultdatatype: [%s]\n", r->default_datatype);
1011         printf("\n");
1012 }
1013
1014 /****************************************************************************
1015 ****************************************************************************/
1016
1017 static void display_print_driver4(struct spoolss_DriverInfo4 *r)
1018 {
1019         int i;
1020
1021         if (!r) {
1022                 return;
1023         }
1024
1025         printf("Printer Driver Info 4:\n");
1026         printf("\tVersion: [%x]\n", r->version);
1027         printf("\tDriver Name: [%s]\n", r->driver_name);
1028         printf("\tArchitecture: [%s]\n", r->architecture);
1029         printf("\tDriver Path: [%s]\n", r->driver_path);
1030         printf("\tDatafile: [%s]\n", r->data_file);
1031         printf("\tConfigfile: [%s]\n", r->config_file);
1032         printf("\tHelpfile: [%s]\n", r->help_file);
1033
1034         for (i=0; r->dependent_files && r->dependent_files[i] != NULL; i++) {
1035                 printf("\tDependentfiles: [%s]\n", r->dependent_files[i]);
1036         }
1037
1038         printf("\tMonitorname: [%s]\n", r->monitor_name);
1039         printf("\tDefaultdatatype: [%s]\n", r->default_datatype);
1040
1041         for (i=0; r->previous_names && r->previous_names[i] != NULL; i++) {
1042                 printf("\tPrevious Names: [%s]\n", r->previous_names[i]);
1043         }
1044         printf("\n");
1045 }
1046
1047 /****************************************************************************
1048 ****************************************************************************/
1049
1050 static void display_print_driver5(struct spoolss_DriverInfo5 *r)
1051 {
1052         if (!r) {
1053                 return;
1054         }
1055
1056         printf("Printer Driver Info 5:\n");
1057         printf("\tVersion: [%x]\n", r->version);
1058         printf("\tDriver Name: [%s]\n", r->driver_name);
1059         printf("\tArchitecture: [%s]\n", r->architecture);
1060         printf("\tDriver Path: [%s]\n", r->driver_path);
1061         printf("\tDatafile: [%s]\n", r->data_file);
1062         printf("\tConfigfile: [%s]\n", r->config_file);
1063         printf("\tDriver Attributes: [0x%x]\n", r->driver_attributes);
1064         printf("\tConfig Version: [0x%x]\n", r->config_version);
1065         printf("\tDriver Version: [0x%x]\n", r->driver_version);
1066         printf("\n");
1067 }
1068
1069 /****************************************************************************
1070 ****************************************************************************/
1071
1072 static void display_print_driver6(struct spoolss_DriverInfo6 *r)
1073 {
1074         int i;
1075
1076         if (!r) {
1077                 return;
1078         }
1079
1080         printf("Printer Driver Info 6:\n");
1081         printf("\tVersion: [%x]\n", r->version);
1082         printf("\tDriver Name: [%s]\n", r->driver_name);
1083         printf("\tArchitecture: [%s]\n", r->architecture);
1084         printf("\tDriver Path: [%s]\n", r->driver_path);
1085         printf("\tDatafile: [%s]\n", r->data_file);
1086         printf("\tConfigfile: [%s]\n", r->config_file);
1087         printf("\tHelpfile: [%s]\n", r->help_file);
1088
1089         for (i=0; r->dependent_files && r->dependent_files[i] != NULL; i++) {
1090                 printf("\tDependentfiles: [%s]\n", r->dependent_files[i]);
1091         }
1092
1093         printf("\tMonitorname: [%s]\n", r->monitor_name);
1094         printf("\tDefaultdatatype: [%s]\n", r->default_datatype);
1095
1096         for (i=0; r->previous_names && r->previous_names[i] != NULL; i++) {
1097                 printf("\tPrevious Names: [%s]\n", r->previous_names[i]);
1098         }
1099
1100         printf("\tDriver Date: [%s]\n", nt_time_string(talloc_tos(), r->driver_date));
1101         printf("\tDriver Version: [0x%016llx]\n", (long long unsigned int)r->driver_version);
1102         printf("\tManufacturer Name: [%s]\n", r->manufacturer_name);
1103         printf("\tManufacturer Url: [%s]\n", r->manufacturer_url);
1104         printf("\tHardware ID: [%s]\n", r->hardware_id);
1105         printf("\tProvider: [%s]\n", r->provider);
1106
1107         printf("\n");
1108 }
1109
1110 /****************************************************************************
1111 ****************************************************************************/
1112
1113 static void display_print_driver8(struct spoolss_DriverInfo8 *r)
1114 {
1115         int i;
1116
1117         if (!r) {
1118                 return;
1119         }
1120
1121         printf("Printer Driver Info 8:\n");
1122         printf("\tVersion: [%x]\n", r->version);
1123         printf("\tDriver Name: [%s]\n", r->driver_name);
1124         printf("\tArchitecture: [%s]\n", r->architecture);
1125         printf("\tDriver Path: [%s]\n", r->driver_path);
1126         printf("\tDatafile: [%s]\n", r->data_file);
1127         printf("\tConfigfile: [%s]\n", r->config_file);
1128         printf("\tHelpfile: [%s]\n", r->help_file);
1129         printf("\tMonitorname: [%s]\n", r->monitor_name);
1130         printf("\tDefaultdatatype: [%s]\n", r->default_datatype);
1131
1132         for (i=0; r->dependent_files && r->dependent_files[i] != NULL; i++) {
1133                 printf("\tDependentfiles: [%s]\n", r->dependent_files[i]);
1134         }
1135
1136         for (i=0; r->previous_names && r->previous_names[i] != NULL; i++) {
1137                 printf("\tPrevious Names: [%s]\n", r->previous_names[i]);
1138         }
1139
1140         printf("\tDriver Date: [%s]\n", nt_time_string(talloc_tos(), r->driver_date));
1141         printf("\tDriver Version: [0x%016llx]\n", (long long unsigned int)r->driver_version);
1142         printf("\tManufacturer Name: [%s]\n", r->manufacturer_name);
1143         printf("\tManufacturer Url: [%s]\n", r->manufacturer_url);
1144         printf("\tHardware ID: [%s]\n", r->hardware_id);
1145         printf("\tProvider: [%s]\n", r->provider);
1146         printf("\tPrint Processor: [%s]\n", r->print_processor);
1147         printf("\tVendor Setup: [%s]\n", r->vendor_setup);
1148         for (i=0; r->color_profiles && r->color_profiles[i] != NULL; i++) {
1149                 printf("\tColor Profiles: [%s]\n", r->color_profiles[i]);
1150         }
1151         printf("\tInf Path: [%s]\n", r->inf_path);
1152         printf("\tPrinter Driver Attributes: [0x%x]\n", r->printer_driver_attributes);
1153         for (i=0; r->core_driver_dependencies && r->core_driver_dependencies[i] != NULL; i++) {
1154                 printf("\tCore Driver Dependencies: [%s]\n", r->core_driver_dependencies[i]);
1155         }
1156         printf("\tMin Driver Inbox Driver Version Date: [%s]\n", nt_time_string(talloc_tos(), r->min_inbox_driver_ver_date));
1157         printf("\tMin Driver Inbox Driver Version Version: [0x%016llx]\n",
1158                 (long long unsigned int)r->min_inbox_driver_ver_version);
1159
1160         printf("\n");
1161 }
1162
1163 /****************************************************************************
1164 ****************************************************************************/
1165
1166 static WERROR cmd_spoolss_getdriver(struct rpc_pipe_client *cli,
1167                                     TALLOC_CTX *mem_ctx,
1168                                     int argc, const char **argv)
1169 {
1170         struct policy_handle pol;
1171         WERROR          werror;
1172         uint32_t        level = 3;
1173         const char      *printername;
1174         uint32_t        i;
1175         bool            success = false;
1176         union spoolss_DriverInfo info;
1177         uint32_t server_major_version;
1178         uint32_t server_minor_version;
1179
1180         if ((argc == 1) || (argc > 3)) {
1181                 printf("Usage: %s <printername> [level]\n", argv[0]);
1182                 return WERR_OK;
1183         }
1184
1185         /* get the arguments need to open the printer handle */
1186
1187         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
1188
1189         if (argc == 3) {
1190                 level = atoi(argv[2]);
1191         }
1192
1193         /* Open a printer handle */
1194
1195         werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
1196                                                printername,
1197                                                PRINTER_ACCESS_USE,
1198                                                &pol);
1199         if (!W_ERROR_IS_OK(werror)) {
1200                 printf("Error opening printer handle for %s!\n", printername);
1201                 return werror;
1202         }
1203
1204         /* loop through and print driver info level for each architecture */
1205
1206         for (i=0; archi_table[i].long_archi!=NULL; i++) {
1207
1208                 werror = rpccli_spoolss_getprinterdriver2(cli, mem_ctx,
1209                                                           &pol,
1210                                                           archi_table[i].long_archi,
1211                                                           level,
1212                                                           0, /* offered */
1213                                                           archi_table[i].version,
1214                                                           2,
1215                                                           &info,
1216                                                           &server_major_version,
1217                                                           &server_minor_version);
1218                 if (!W_ERROR_IS_OK(werror)) {
1219                         continue;
1220                 }
1221
1222                 /* need at least one success */
1223
1224                 success = true;
1225
1226                 printf("\n[%s]\n", archi_table[i].long_archi);
1227
1228                 switch (level) {
1229                 case 1:
1230                         display_print_driver1(&info.info1);
1231                         break;
1232                 case 2:
1233                         display_print_driver2(&info.info2);
1234                         break;
1235                 case 3:
1236                         display_print_driver3(&info.info3);
1237                         break;
1238                 case 4:
1239                         display_print_driver4(&info.info4);
1240                         break;
1241                 case 5:
1242                         display_print_driver5(&info.info5);
1243                         break;
1244                 case 6:
1245                         display_print_driver6(&info.info6);
1246                         break;
1247                 case 8:
1248                         display_print_driver8(&info.info8);
1249                         break;
1250                 default:
1251                         printf("unknown info level %d\n", level);
1252                         break;
1253                 }
1254         }
1255
1256         /* Cleanup */
1257
1258         if (is_valid_policy_hnd(&pol)) {
1259                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
1260         }
1261
1262         if (success) {
1263                 werror = WERR_OK;
1264         }
1265
1266         return werror;
1267 }
1268
1269 /****************************************************************************
1270 ****************************************************************************/
1271
1272 static WERROR enum_driver_by_architecture(struct rpc_pipe_client *cli,
1273                                           TALLOC_CTX *mem_ctx,
1274                                           const char *architecture,
1275                                           uint32_t level)
1276 {
1277         WERROR werror;
1278         uint32_t count = 0;
1279         union spoolss_DriverInfo *info = NULL;
1280         uint32_t j;
1281
1282         werror = rpccli_spoolss_enumprinterdrivers(cli, mem_ctx,
1283                                                    cli->srv_name_slash,
1284                                                    architecture,
1285                                                    level,
1286                                                    0,
1287                                                    &count,
1288                                                    &info);
1289
1290         if (W_ERROR_EQUAL(werror, WERR_INVALID_ENVIRONMENT)) {
1291                 printf("Server does not support environment [%s]\n",
1292                         architecture);
1293                 return WERR_OK;
1294         }
1295
1296         if (count == 0) {
1297                 return WERR_OK;
1298         }
1299
1300         if (!W_ERROR_IS_OK(werror)) {
1301                 printf("Error getting driver for environment [%s] - %s\n",
1302                         architecture, win_errstr(werror));
1303                 return werror;
1304         }
1305
1306         printf("\n[%s]\n", architecture);
1307
1308         switch (level) {
1309         case 1:
1310                 for (j=0; j < count; j++) {
1311                         display_print_driver1(&info[j].info1);
1312                 }
1313                 break;
1314         case 2:
1315                 for (j=0; j < count; j++) {
1316                         display_print_driver2(&info[j].info2);
1317                 }
1318                 break;
1319         case 3:
1320                 for (j=0; j < count; j++) {
1321                         display_print_driver3(&info[j].info3);
1322                 }
1323                 break;
1324         case 4:
1325                 for (j=0; j < count; j++) {
1326                         display_print_driver4(&info[j].info4);
1327                 }
1328                 break;
1329         case 5:
1330                 for (j=0; j < count; j++) {
1331                         display_print_driver5(&info[j].info5);
1332                 }
1333                 break;
1334         case 6:
1335                 for (j=0; j < count; j++) {
1336                         display_print_driver6(&info[j].info6);
1337                 }
1338                 break;
1339         case 8:
1340                 for (j=0; j < count; j++) {
1341                         display_print_driver8(&info[j].info8);
1342                 }
1343                 break;
1344         default:
1345                 printf("unknown info level %d\n", level);
1346                 return WERR_UNKNOWN_LEVEL;
1347         }
1348
1349         return werror;
1350 }
1351
1352 static WERROR cmd_spoolss_enum_drivers(struct rpc_pipe_client *cli,
1353                                          TALLOC_CTX *mem_ctx,
1354                                          int argc, const char **argv)
1355 {
1356         WERROR werror = WERR_OK;
1357         uint32_t        level = 1;
1358         uint32_t        i;
1359         const char *architecture = NULL;
1360
1361         if (argc > 3) {
1362                 printf("Usage: enumdrivers [level] [architecture]\n");
1363                 return WERR_OK;
1364         }
1365
1366         if (argc >= 2) {
1367                 level = atoi(argv[1]);
1368         }
1369
1370         if (argc == 3) {
1371                 architecture = argv[2];
1372         }
1373
1374         if (architecture) {
1375                 return enum_driver_by_architecture(cli, mem_ctx,
1376                                                    architecture,
1377                                                    level);
1378         }
1379
1380         /* loop through and print driver info level for each architecture */
1381         for (i=0; archi_table[i].long_archi!=NULL; i++) {
1382                 /* check to see if we already asked for this architecture string */
1383
1384                 if (i>0 && strequal(archi_table[i].long_archi, archi_table[i-1].long_archi)) {
1385                         continue;
1386                 }
1387
1388                 werror = enum_driver_by_architecture(cli, mem_ctx,
1389                                                      archi_table[i].long_archi,
1390                                                      level);
1391                 if (!W_ERROR_IS_OK(werror)) {
1392                         break;
1393                 }
1394         }
1395
1396         return werror;
1397 }
1398
1399 /****************************************************************************
1400 ****************************************************************************/
1401
1402 static void display_printdriverdir_1(struct spoolss_DriverDirectoryInfo1 *r)
1403 {
1404         printf("\tDirectory Name:[%s]\n", r->directory_name);
1405 }
1406
1407 /****************************************************************************
1408 ****************************************************************************/
1409
1410 static WERROR cmd_spoolss_getdriverdir(struct rpc_pipe_client *cli,
1411                                          TALLOC_CTX *mem_ctx,
1412                                          int argc, const char **argv)
1413 {
1414         WERROR result;
1415         NTSTATUS status;
1416         const char *env = SPOOLSS_ARCHITECTURE_NT_X86;
1417         DATA_BLOB buffer;
1418         uint32_t offered;
1419         union spoolss_DriverDirectoryInfo info;
1420         uint32_t needed;
1421
1422         if (argc > 2) {
1423                 printf("Usage: %s [environment]\n", argv[0]);
1424                 return WERR_OK;
1425         }
1426
1427         /* Get the arguments need to open the printer handle */
1428
1429         if (argc == 2) {
1430                 env = argv[1];
1431         }
1432
1433         /* Get the directory.  Only use Info level 1 */
1434
1435         status = rpccli_spoolss_GetPrinterDriverDirectory(cli, mem_ctx,
1436                                                           cli->srv_name_slash,
1437                                                           env,
1438                                                           1,
1439                                                           NULL, /* buffer */
1440                                                           0, /* offered */
1441                                                           NULL, /* info */
1442                                                           &needed,
1443                                                           &result);
1444         if (W_ERROR_EQUAL(result, WERR_INSUFFICIENT_BUFFER)) {
1445                 offered = needed;
1446                 buffer = data_blob_talloc_zero(mem_ctx, needed);
1447
1448                 status = rpccli_spoolss_GetPrinterDriverDirectory(cli, mem_ctx,
1449                                                                   cli->srv_name_slash,
1450                                                                   env,
1451                                                                   1,
1452                                                                   &buffer,
1453                                                                   offered,
1454                                                                   &info,
1455                                                                   &needed,
1456                                                                   &result);
1457         }
1458
1459         if (W_ERROR_IS_OK(result)) {
1460                 display_printdriverdir_1(&info.info1);
1461         }
1462
1463         return result;
1464 }
1465
1466 /****************************************************************************
1467 ****************************************************************************/
1468
1469 static void set_drv_info_3_env(TALLOC_CTX *mem_ctx,
1470                                struct spoolss_AddDriverInfo3 *info,
1471                                const char *arch)
1472 {
1473
1474         int i;
1475
1476         for (i=0; archi_table[i].long_archi != NULL; i++)
1477         {
1478                 if (strcmp(arch, archi_table[i].short_archi) == 0)
1479                 {
1480                         info->version = archi_table[i].version;
1481                         info->architecture = talloc_strdup(mem_ctx, archi_table[i].long_archi);
1482                         break;
1483                 }
1484         }
1485
1486         if (archi_table[i].long_archi == NULL)
1487         {
1488                 DEBUG(0, ("set_drv_info_3_env: Unknown arch [%s]\n", arch));
1489         }
1490
1491         return;
1492 }
1493
1494
1495 /**************************************************************************
1496  wrapper for strtok to get the next parameter from a delimited list.
1497  Needed to handle the empty parameter string denoted by "NULL"
1498  *************************************************************************/
1499
1500 static char *get_driver_3_param(TALLOC_CTX *mem_ctx, char *str,
1501                                 const char *delim, const char **dest,
1502                                 char **saveptr)
1503 {
1504         char    *ptr;
1505
1506         /* get the next token */
1507         ptr = strtok_r(str, delim, saveptr);
1508
1509         /* a string of 'NULL' is used to represent an empty
1510            parameter because two consecutive delimiters
1511            will not return an empty string.  See man strtok(3)
1512            for details */
1513         if (ptr && (StrCaseCmp(ptr, "NULL") == 0)) {
1514                 ptr = NULL;
1515         }
1516
1517         if (dest != NULL) {
1518                 *dest = talloc_strdup(mem_ctx, ptr);
1519         }
1520
1521         return ptr;
1522 }
1523
1524 /********************************************************************************
1525  fill in the members of a spoolss_AddDriverInfo3 struct using a character
1526  string in the form of
1527          <Long Printer Name>:<Driver File Name>:<Data File Name>:\
1528              <Config File Name>:<Help File Name>:<Language Monitor Name>:\
1529              <Default Data Type>:<Comma Separated list of Files>
1530  *******************************************************************************/
1531
1532 static bool init_drv_info_3_members(TALLOC_CTX *mem_ctx, struct spoolss_AddDriverInfo3 *r,
1533                                     char *args)
1534 {
1535         char    *str, *str2;
1536         int count = 0;
1537         char *saveptr = NULL;
1538         struct spoolss_StringArray *deps;
1539         const char **file_array = NULL;
1540         int i;
1541
1542         /* fill in the UNISTR fields */
1543         str = get_driver_3_param(mem_ctx, args, ":", &r->driver_name, &saveptr);
1544         str = get_driver_3_param(mem_ctx, NULL, ":", &r->driver_path, &saveptr);
1545         str = get_driver_3_param(mem_ctx, NULL, ":", &r->data_file, &saveptr);
1546         str = get_driver_3_param(mem_ctx, NULL, ":", &r->config_file, &saveptr);
1547         str = get_driver_3_param(mem_ctx, NULL, ":", &r->help_file, &saveptr);
1548         str = get_driver_3_param(mem_ctx, NULL, ":", &r->monitor_name, &saveptr);
1549         str = get_driver_3_param(mem_ctx, NULL, ":", &r->default_datatype, &saveptr);
1550
1551         /* <Comma Separated List of Dependent Files> */
1552         /* save the beginning of the string */
1553         str2 = get_driver_3_param(mem_ctx, NULL, ":", NULL, &saveptr);
1554         str = str2;
1555
1556         /* begin to strip out each filename */
1557         str = strtok_r(str, ",", &saveptr);
1558
1559         /* no dependent files, we are done */
1560         if (!str) {
1561                 return true;
1562         }
1563
1564         deps = talloc_zero(mem_ctx, struct spoolss_StringArray);
1565         if (!deps) {
1566                 return false;
1567         }
1568
1569         while (str != NULL) {
1570                 add_string_to_array(deps, str, &file_array, &count);
1571                 str = strtok_r(NULL, ",", &saveptr);
1572         }
1573
1574         deps->string = talloc_zero_array(deps, const char *, count + 1);
1575         if (!deps->string) {
1576                 return false;
1577         }
1578
1579         for (i=0; i < count; i++) {
1580                 deps->string[i] = file_array[i];
1581         }
1582
1583         r->dependent_files = deps;
1584
1585         return true;
1586 }
1587
1588 /****************************************************************************
1589 ****************************************************************************/
1590
1591 static WERROR cmd_spoolss_addprinterdriver(struct rpc_pipe_client *cli,
1592                                              TALLOC_CTX *mem_ctx,
1593                                              int argc, const char **argv)
1594 {
1595         WERROR result;
1596         NTSTATUS status;
1597         uint32_t                  level = 3;
1598         struct spoolss_AddDriverInfoCtr info_ctr;
1599         struct spoolss_AddDriverInfo3 info3;
1600         const char              *arch;
1601         char                    *driver_args;
1602
1603         /* parse the command arguments */
1604         if (argc != 3 && argc != 4)
1605         {
1606                 printf ("Usage: %s <Environment> \\\n", argv[0]);
1607                 printf ("\t<Long Printer Name>:<Driver File Name>:<Data File Name>:\\\n");
1608                 printf ("\t<Config File Name>:<Help File Name>:<Language Monitor Name>:\\\n");
1609                 printf ("\t<Default Data Type>:<Comma Separated list of Files> \\\n");
1610                 printf ("\t[version]\n");
1611
1612             return WERR_OK;
1613         }
1614
1615         /* Fill in the spoolss_AddDriverInfo3 struct */
1616         ZERO_STRUCT(info3);
1617
1618         arch = cmd_spoolss_get_short_archi(argv[1]);
1619         if (!arch) {
1620                 printf ("Error Unknown architechture [%s]\n", argv[1]);
1621                 return WERR_INVALID_PARAM;
1622         }
1623
1624         set_drv_info_3_env(mem_ctx, &info3, arch);
1625
1626         driver_args = talloc_strdup( mem_ctx, argv[2] );
1627         if (!init_drv_info_3_members(mem_ctx, &info3, driver_args ))
1628         {
1629                 printf ("Error Invalid parameter list - %s.\n", argv[2]);
1630                 return WERR_INVALID_PARAM;
1631         }
1632
1633         /* if printer driver version specified, override the default version
1634          * used by the architecture.  This allows installation of Windows
1635          * 2000 (version 3) printer drivers. */
1636         if (argc == 4)
1637         {
1638                 info3.version = atoi(argv[3]);
1639         }
1640
1641
1642         info_ctr.level          = level;
1643         info_ctr.info.info3     = &info3;
1644
1645         status = rpccli_spoolss_AddPrinterDriver(cli, mem_ctx,
1646                                                  cli->srv_name_slash,
1647                                                  &info_ctr,
1648                                                  &result);
1649         if (!NT_STATUS_IS_OK(status)) {
1650                 return ntstatus_to_werror(status);
1651         }
1652         if (W_ERROR_IS_OK(result)) {
1653                 printf ("Printer Driver %s successfully installed.\n",
1654                         info3.driver_name);
1655         }
1656
1657         return result;
1658 }
1659
1660
1661 /****************************************************************************
1662 ****************************************************************************/
1663
1664 static WERROR cmd_spoolss_addprinterex(struct rpc_pipe_client *cli,
1665                                          TALLOC_CTX *mem_ctx,
1666                                          int argc, const char **argv)
1667 {
1668         WERROR result;
1669         struct spoolss_SetPrinterInfoCtr info_ctr;
1670         struct spoolss_SetPrinterInfo2 info2;
1671
1672         /* parse the command arguments */
1673         if (argc != 5)
1674         {
1675                 printf ("Usage: %s <name> <shared name> <driver> <port>\n", argv[0]);
1676                 return WERR_OK;
1677         }
1678
1679         /* Fill in the DRIVER_INFO_2 struct */
1680         ZERO_STRUCT(info2);
1681
1682         info2.printername       = argv[1];
1683         info2.drivername        = argv[3];
1684         info2.sharename         = argv[2];
1685         info2.portname          = argv[4];
1686         info2.comment           = "Created by rpcclient";
1687         info2.printprocessor    = "winprint";
1688         info2.datatype          = "RAW";
1689         info2.devmode           = NULL;
1690         info2.secdesc           = NULL;
1691         info2.attributes        = PRINTER_ATTRIBUTE_SHARED;
1692         info2.priority          = 0;
1693         info2.defaultpriority   = 0;
1694         info2.starttime         = 0;
1695         info2.untiltime         = 0;
1696
1697         /* These three fields must not be used by AddPrinter()
1698            as defined in the MS Platform SDK documentation..
1699            --jerry
1700         info2.status            = 0;
1701         info2.cjobs             = 0;
1702         info2.averageppm        = 0;
1703         */
1704
1705         info_ctr.level = 2;
1706         info_ctr.info.info2 = &info2;
1707
1708         result = rpccli_spoolss_addprinterex(cli, mem_ctx,
1709                                              &info_ctr);
1710         if (W_ERROR_IS_OK(result))
1711                 printf ("Printer %s successfully installed.\n", argv[1]);
1712
1713         return result;
1714 }
1715
1716 /****************************************************************************
1717 ****************************************************************************/
1718
1719 static WERROR cmd_spoolss_setdriver(struct rpc_pipe_client *cli,
1720                                       TALLOC_CTX *mem_ctx,
1721                                       int argc, const char **argv)
1722 {
1723         struct policy_handle    pol;
1724         WERROR                  result;
1725         NTSTATUS                status;
1726         uint32_t                level = 2;
1727         const char              *printername;
1728         union spoolss_PrinterInfo info;
1729         struct spoolss_SetPrinterInfoCtr info_ctr;
1730         struct spoolss_DevmodeContainer devmode_ctr;
1731         struct sec_desc_buf secdesc_ctr;
1732
1733         ZERO_STRUCT(devmode_ctr);
1734         ZERO_STRUCT(secdesc_ctr);
1735
1736         /* parse the command arguments */
1737         if (argc != 3)
1738         {
1739                 printf ("Usage: %s <printer> <driver>\n", argv[0]);
1740                 return WERR_OK;
1741         }
1742
1743         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
1744
1745         /* Get a printer handle */
1746
1747         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
1748                                                printername,
1749                                                PRINTER_ALL_ACCESS,
1750                                                &pol);
1751         if (!W_ERROR_IS_OK(result))
1752                 goto done;
1753
1754         /* Get printer info */
1755
1756         result = rpccli_spoolss_getprinter(cli, mem_ctx,
1757                                            &pol,
1758                                            level,
1759                                            0,
1760                                            &info);
1761         if (!W_ERROR_IS_OK(result)) {
1762                 printf ("Unable to retrieve printer information!\n");
1763                 goto done;
1764         }
1765
1766         /* Set the printer driver */
1767
1768         info.info2.drivername = argv[2];
1769         info.info2.devmode = NULL;
1770         info.info2.secdesc = NULL;
1771
1772         info_ctr.level = 2;
1773         info_ctr.info.info2 = (struct spoolss_SetPrinterInfo2 *)&info.info2;
1774
1775         status = rpccli_spoolss_SetPrinter(cli, mem_ctx,
1776                                            &pol,
1777                                            &info_ctr,
1778                                            &devmode_ctr,
1779                                            &secdesc_ctr,
1780                                            0, /* command */
1781                                            &result);
1782         if (!W_ERROR_IS_OK(result)) {
1783                 printf("SetPrinter call failed!\n");
1784                 goto done;;
1785         }
1786
1787         printf("Successfully set %s to driver %s.\n", argv[1], argv[2]);
1788
1789 done:
1790         /* Cleanup */
1791
1792         if (is_valid_policy_hnd(&pol))
1793                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
1794
1795         return result;
1796 }
1797
1798
1799 /****************************************************************************
1800 ****************************************************************************/
1801
1802 static WERROR cmd_spoolss_deletedriverex(struct rpc_pipe_client *cli,
1803                                          TALLOC_CTX *mem_ctx,
1804                                          int argc, const char **argv)
1805 {
1806         WERROR result, ret = WERR_UNKNOWN_PRINTER_DRIVER;
1807         NTSTATUS status;
1808
1809         int   i;
1810         int vers = -1;
1811
1812         const char *arch = NULL;
1813         uint32_t delete_flags = 0;
1814
1815         /* parse the command arguments */
1816         if (argc < 2 || argc > 4) {
1817                 printf ("Usage: %s <driver> [arch] [version]\n", argv[0]);
1818                 return WERR_OK;
1819         }
1820
1821         if (argc >= 3)
1822                 arch = argv[2];
1823         if (argc == 4)
1824                 vers = atoi (argv[3]);
1825
1826         if (vers >= 0) {
1827                 delete_flags |= DPD_DELETE_SPECIFIC_VERSION;
1828         }
1829
1830         /* delete the driver for all architectures */
1831         for (i=0; archi_table[i].long_archi; i++) {
1832
1833                 if (arch &&  !strequal( archi_table[i].long_archi, arch))
1834                         continue;
1835
1836                 if (vers >= 0 && archi_table[i].version != vers)
1837                         continue;
1838
1839                 /* make the call to remove the driver */
1840                 status = rpccli_spoolss_DeletePrinterDriverEx(cli, mem_ctx,
1841                                                               cli->srv_name_slash,
1842                                                               archi_table[i].long_archi,
1843                                                               argv[1],
1844                                                               delete_flags,
1845                                                               archi_table[i].version,
1846                                                               &result);
1847
1848                 if ( !W_ERROR_IS_OK(result) )
1849                 {
1850                         if ( !W_ERROR_EQUAL(result, WERR_UNKNOWN_PRINTER_DRIVER) ) {
1851                                 printf ("Failed to remove driver %s for arch [%s] (version: %d): %s\n",
1852                                         argv[1], archi_table[i].long_archi, archi_table[i].version, win_errstr(result));
1853                         }
1854                 }
1855                 else
1856                 {
1857                         printf ("Driver %s and files removed for arch [%s] (version: %d).\n", argv[1],
1858                         archi_table[i].long_archi, archi_table[i].version);
1859                         ret = WERR_OK;
1860                 }
1861         }
1862
1863         return ret;
1864 }
1865
1866
1867 /****************************************************************************
1868 ****************************************************************************/
1869
1870 static WERROR cmd_spoolss_deletedriver(struct rpc_pipe_client *cli,
1871                                          TALLOC_CTX *mem_ctx,
1872                                          int argc, const char **argv)
1873 {
1874         WERROR result = WERR_OK;
1875         NTSTATUS status;
1876         int                     i;
1877
1878         /* parse the command arguments */
1879         if (argc != 2) {
1880                 printf ("Usage: %s <driver>\n", argv[0]);
1881                 return WERR_OK;
1882         }
1883
1884         /* delete the driver for all architectures */
1885         for (i=0; archi_table[i].long_archi; i++) {
1886                 /* make the call to remove the driver */
1887                 status = rpccli_spoolss_DeletePrinterDriver(cli, mem_ctx,
1888                                                             cli->srv_name_slash,
1889                                                             archi_table[i].long_archi,
1890                                                             argv[1],
1891                                                             &result);
1892                 if (!NT_STATUS_IS_OK(status)) {
1893                         return result;
1894                 }
1895                 if ( !W_ERROR_IS_OK(result) ) {
1896                         if ( !W_ERROR_EQUAL(result, WERR_UNKNOWN_PRINTER_DRIVER) ) {
1897                                 printf ("Failed to remove driver %s for arch [%s] - error 0x%x!\n",
1898                                         argv[1], archi_table[i].long_archi,
1899                                         W_ERROR_V(result));
1900                         }
1901                 } else {
1902                         printf ("Driver %s removed for arch [%s].\n", argv[1],
1903                                 archi_table[i].long_archi);
1904                 }
1905         }
1906
1907         return result;
1908 }
1909
1910 /****************************************************************************
1911 ****************************************************************************/
1912
1913 static WERROR cmd_spoolss_getprintprocdir(struct rpc_pipe_client *cli,
1914                                             TALLOC_CTX *mem_ctx,
1915                                             int argc, const char **argv)
1916 {
1917         WERROR result;
1918         NTSTATUS status;
1919         const char *environment = SPOOLSS_ARCHITECTURE_NT_X86;
1920         DATA_BLOB buffer;
1921         uint32_t offered;
1922         union spoolss_PrintProcessorDirectoryInfo info;
1923         uint32_t needed;
1924
1925         /* parse the command arguments */
1926         if (argc > 2) {
1927                 printf ("Usage: %s [environment]\n", argv[0]);
1928                 return WERR_OK;
1929         }
1930
1931         if (argc == 2) {
1932                 environment = argv[1];
1933         }
1934
1935         status = rpccli_spoolss_GetPrintProcessorDirectory(cli, mem_ctx,
1936                                                            cli->srv_name_slash,
1937                                                            environment,
1938                                                            1,
1939                                                            NULL, /* buffer */
1940                                                            0, /* offered */
1941                                                            NULL, /* info */
1942                                                            &needed,
1943                                                            &result);
1944         if (W_ERROR_EQUAL(result, WERR_INSUFFICIENT_BUFFER)) {
1945                 offered = needed;
1946                 buffer = data_blob_talloc_zero(mem_ctx, needed);
1947
1948                 status = rpccli_spoolss_GetPrintProcessorDirectory(cli, mem_ctx,
1949                                                                    cli->srv_name_slash,
1950                                                                    environment,
1951                                                                    1,
1952                                                                    &buffer,
1953                                                                    offered,
1954                                                                    &info,
1955                                                                    &needed,
1956                                                                    &result);
1957         }
1958
1959         if (W_ERROR_IS_OK(result)) {
1960                 printf("%s\n", info.info1.directory_name);
1961         }
1962
1963         return result;
1964 }
1965
1966 /****************************************************************************
1967 ****************************************************************************/
1968
1969 static WERROR cmd_spoolss_addform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1970                                     int argc, const char **argv)
1971 {
1972         struct policy_handle handle;
1973         WERROR werror;
1974         NTSTATUS status;
1975         const char *printername;
1976         union spoolss_AddFormInfo info;
1977         struct spoolss_AddFormInfo1 info1;
1978         struct spoolss_AddFormInfo2 info2;
1979         uint32_t level = 1;
1980
1981         /* Parse the command arguments */
1982
1983         if (argc < 3 || argc > 5) {
1984                 printf ("Usage: %s <printer> <formname> [level]\n", argv[0]);
1985                 return WERR_OK;
1986         }
1987
1988         /* Get a printer handle */
1989
1990         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
1991
1992         werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
1993                                                printername,
1994                                                PRINTER_ALL_ACCESS,
1995                                                &handle);
1996         if (!W_ERROR_IS_OK(werror))
1997                 goto done;
1998
1999         /* Dummy up some values for the form data */
2000
2001         if (argc == 4) {
2002                 level = atoi(argv[3]);
2003         }
2004
2005         switch (level) {
2006         case 1:
2007                 info1.flags             = SPOOLSS_FORM_USER;
2008                 info1.form_name         = argv[2];
2009                 info1.size.width        = 100;
2010                 info1.size.height       = 100;
2011                 info1.area.left         = 0;
2012                 info1.area.top          = 10;
2013                 info1.area.right        = 20;
2014                 info1.area.bottom       = 30;
2015
2016                 info.info1 = &info1;
2017
2018                 break;
2019         case 2:
2020                 info2.flags             = SPOOLSS_FORM_USER;
2021                 info2.form_name         = argv[2];
2022                 info2.size.width        = 100;
2023                 info2.size.height       = 100;
2024                 info2.area.left         = 0;
2025                 info2.area.top          = 10;
2026                 info2.area.right        = 20;
2027                 info2.area.bottom       = 30;
2028                 info2.keyword           = argv[2];
2029                 info2.string_type       = SPOOLSS_FORM_STRING_TYPE_NONE;
2030                 info2.mui_dll           = NULL;
2031                 info2.ressource_id      = 0;
2032                 info2.display_name      = argv[2];
2033                 info2.lang_id           = 0;
2034
2035                 info.info2 = &info2;
2036
2037                 break;
2038         }
2039
2040         /* Add the form */
2041
2042
2043         status = rpccli_spoolss_AddForm(cli, mem_ctx,
2044                                         &handle,
2045                                         level,
2046                                         info,
2047                                         &werror);
2048
2049  done:
2050         if (is_valid_policy_hnd(&handle))
2051                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
2052
2053         return werror;
2054 }
2055
2056 /****************************************************************************
2057 ****************************************************************************/
2058
2059 static WERROR cmd_spoolss_setform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
2060                                     int argc, const char **argv)
2061 {
2062         struct policy_handle handle;
2063         WERROR werror;
2064         NTSTATUS status;
2065         const char *printername;
2066         union spoolss_AddFormInfo info;
2067         struct spoolss_AddFormInfo1 info1;
2068
2069         /* Parse the command arguments */
2070
2071         if (argc != 3) {
2072                 printf ("Usage: %s <printer> <formname>\n", argv[0]);
2073                 return WERR_OK;
2074         }
2075
2076         /* Get a printer handle */
2077
2078         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2079
2080         werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2081                                                printername,
2082                                                SEC_FLAG_MAXIMUM_ALLOWED,
2083                                                &handle);
2084         if (!W_ERROR_IS_OK(werror))
2085                 goto done;
2086
2087         /* Dummy up some values for the form data */
2088
2089         info1.flags             = SPOOLSS_FORM_PRINTER;
2090         info1.size.width        = 100;
2091         info1.size.height       = 100;
2092         info1.area.left         = 0;
2093         info1.area.top          = 1000;
2094         info1.area.right        = 2000;
2095         info1.area.bottom       = 3000;
2096         info1.form_name         = argv[2];
2097
2098         info.info1 = &info1;
2099
2100         /* Set the form */
2101
2102         status = rpccli_spoolss_SetForm(cli, mem_ctx,
2103                                         &handle,
2104                                         argv[2],
2105                                         1,
2106                                         info,
2107                                         &werror);
2108
2109  done:
2110         if (is_valid_policy_hnd(&handle))
2111                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
2112
2113         return werror;
2114 }
2115
2116 /****************************************************************************
2117 ****************************************************************************/
2118
2119 static const char *get_form_flag(int form_flag)
2120 {
2121         switch (form_flag) {
2122         case SPOOLSS_FORM_USER:
2123                 return "FORM_USER";
2124         case SPOOLSS_FORM_BUILTIN:
2125                 return "FORM_BUILTIN";
2126         case SPOOLSS_FORM_PRINTER:
2127                 return "FORM_PRINTER";
2128         default:
2129                 return "unknown";
2130         }
2131 }
2132
2133 /****************************************************************************
2134 ****************************************************************************/
2135
2136 static void display_form_info1(struct spoolss_FormInfo1 *r)
2137 {
2138         printf("%s\n" \
2139                 "\tflag: %s (%d)\n" \
2140                 "\twidth: %d, length: %d\n" \
2141                 "\tleft: %d, right: %d, top: %d, bottom: %d\n\n",
2142                 r->form_name, get_form_flag(r->flags), r->flags,
2143                 r->size.width, r->size.height,
2144                 r->area.left, r->area.right,
2145                 r->area.top, r->area.bottom);
2146 }
2147
2148 /****************************************************************************
2149 ****************************************************************************/
2150
2151 static void display_form_info2(struct spoolss_FormInfo2 *r)
2152 {
2153         printf("%s\n" \
2154                 "\tflag: %s (%d)\n" \
2155                 "\twidth: %d, length: %d\n" \
2156                 "\tleft: %d, right: %d, top: %d, bottom: %d\n",
2157                 r->form_name, get_form_flag(r->flags), r->flags,
2158                 r->size.width, r->size.height,
2159                 r->area.left, r->area.right,
2160                 r->area.top, r->area.bottom);
2161         printf("\tkeyword: %s\n", r->keyword);
2162         printf("\tstring_type: 0x%08x\n", r->string_type);
2163         printf("\tmui_dll: %s\n", r->mui_dll);
2164         printf("\tressource_id: 0x%08x\n", r->ressource_id);
2165         printf("\tdisplay_name: %s\n", r->display_name);
2166         printf("\tlang_id: %d\n", r->lang_id);
2167         printf("\n");
2168 }
2169
2170 /****************************************************************************
2171 ****************************************************************************/
2172
2173 static WERROR cmd_spoolss_getform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
2174                                     int argc, const char **argv)
2175 {
2176         struct policy_handle handle;
2177         WERROR werror;
2178         NTSTATUS status;
2179         const char *printername;
2180         DATA_BLOB buffer;
2181         uint32_t offered = 0;
2182         union spoolss_FormInfo info;
2183         uint32_t needed;
2184         uint32_t level = 1;
2185
2186         /* Parse the command arguments */
2187
2188         if (argc < 3 || argc > 5) {
2189                 printf ("Usage: %s <printer> <formname> [level]\n", argv[0]);
2190                 return WERR_OK;
2191         }
2192
2193         /* Get a printer handle */
2194
2195         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2196
2197         werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2198                                                printername,
2199                                                SEC_FLAG_MAXIMUM_ALLOWED,
2200                                                &handle);
2201         if (!W_ERROR_IS_OK(werror))
2202                 goto done;
2203
2204         if (argc == 4) {
2205                 level = atoi(argv[3]);
2206         }
2207
2208         /* Get the form */
2209
2210         status = rpccli_spoolss_GetForm(cli, mem_ctx,
2211                                         &handle,
2212                                         argv[2],
2213                                         level,
2214                                         NULL,
2215                                         offered,
2216                                         &info,
2217                                         &needed,
2218                                         &werror);
2219         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
2220                 buffer = data_blob_talloc_zero(mem_ctx, needed);
2221                 offered = needed;
2222                 status = rpccli_spoolss_GetForm(cli, mem_ctx,
2223                                                 &handle,
2224                                                 argv[2],
2225                                                 level,
2226                                                 &buffer,
2227                                                 offered,
2228                                                 &info,
2229                                                 &needed,
2230                                                 &werror);
2231         }
2232
2233         if (!NT_STATUS_IS_OK(status)) {
2234                 return werror;
2235         }
2236
2237         switch (level) {
2238         case 1:
2239                 display_form_info1(&info.info1);
2240                 break;
2241         case 2:
2242                 display_form_info2(&info.info2);
2243                 break;
2244         }
2245
2246  done:
2247         if (is_valid_policy_hnd(&handle))
2248                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
2249
2250         return werror;
2251 }
2252
2253 /****************************************************************************
2254 ****************************************************************************/
2255
2256 static WERROR cmd_spoolss_deleteform(struct rpc_pipe_client *cli,
2257                                        TALLOC_CTX *mem_ctx, int argc,
2258                                        const char **argv)
2259 {
2260         struct policy_handle handle;
2261         WERROR werror;
2262         NTSTATUS status;
2263         const char *printername;
2264
2265         /* Parse the command arguments */
2266
2267         if (argc != 3) {
2268                 printf ("Usage: %s <printer> <formname>\n", argv[0]);
2269                 return WERR_OK;
2270         }
2271
2272         /* Get a printer handle */
2273
2274         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2275
2276         werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2277                                                printername,
2278                                                SEC_FLAG_MAXIMUM_ALLOWED,
2279                                                &handle);
2280         if (!W_ERROR_IS_OK(werror))
2281                 goto done;
2282
2283         /* Delete the form */
2284
2285         status = rpccli_spoolss_DeleteForm(cli, mem_ctx,
2286                                            &handle,
2287                                            argv[2],
2288                                            &werror);
2289         if (!NT_STATUS_IS_OK(status)) {
2290                 return ntstatus_to_werror(status);
2291         }
2292
2293  done:
2294         if (is_valid_policy_hnd(&handle))
2295                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
2296
2297         return werror;
2298 }
2299
2300 /****************************************************************************
2301 ****************************************************************************/
2302
2303 static WERROR cmd_spoolss_enum_forms(struct rpc_pipe_client *cli,
2304                                        TALLOC_CTX *mem_ctx, int argc,
2305                                        const char **argv)
2306 {
2307         struct policy_handle handle;
2308         WERROR werror;
2309         const char *printername;
2310         uint32_t num_forms, level = 1, i;
2311         union spoolss_FormInfo *forms;
2312
2313         /* Parse the command arguments */
2314
2315         if (argc < 2 || argc > 4) {
2316                 printf ("Usage: %s <printer> [level]\n", argv[0]);
2317                 return WERR_OK;
2318         }
2319
2320         /* Get a printer handle */
2321
2322         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2323
2324         werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2325                                                printername,
2326                                                SEC_FLAG_MAXIMUM_ALLOWED,
2327                                                &handle);
2328         if (!W_ERROR_IS_OK(werror))
2329                 goto done;
2330
2331         if (argc == 3) {
2332                 level = atoi(argv[2]);
2333         }
2334
2335         /* Enumerate forms */
2336
2337         werror = rpccli_spoolss_enumforms(cli, mem_ctx,
2338                                           &handle,
2339                                           level,
2340                                           0,
2341                                           &num_forms,
2342                                           &forms);
2343
2344         if (!W_ERROR_IS_OK(werror))
2345                 goto done;
2346
2347         /* Display output */
2348
2349         for (i = 0; i < num_forms; i++) {
2350                 switch (level) {
2351                 case 1:
2352                         display_form_info1(&forms[i].info1);
2353                         break;
2354                 case 2:
2355                         display_form_info2(&forms[i].info2);
2356                         break;
2357                 }
2358         }
2359
2360  done:
2361         if (is_valid_policy_hnd(&handle))
2362                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
2363
2364         return werror;
2365 }
2366
2367 /****************************************************************************
2368 ****************************************************************************/
2369
2370 static WERROR cmd_spoolss_setprinterdata(struct rpc_pipe_client *cli,
2371                                             TALLOC_CTX *mem_ctx,
2372                                             int argc, const char **argv)
2373 {
2374         WERROR result;
2375         NTSTATUS status;
2376         const char *printername;
2377         struct policy_handle pol;
2378         union spoolss_PrinterInfo info;
2379         enum winreg_Type type;
2380         union spoolss_PrinterData data;
2381
2382         /* parse the command arguments */
2383         if (argc < 5) {
2384                 printf ("Usage: %s <printer> <string|binary|dword|multistring>"
2385                         " <value> <data>\n",
2386                         argv[0]);
2387                 result = WERR_INVALID_PARAM;
2388                 goto done;
2389         }
2390
2391         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2392
2393         type = REG_NONE;
2394
2395         if (strequal(argv[2], "string")) {
2396                 type = REG_SZ;
2397         }
2398
2399         if (strequal(argv[2], "binary")) {
2400                 type = REG_BINARY;
2401         }
2402
2403         if (strequal(argv[2], "dword")) {
2404                 type = REG_DWORD;
2405         }
2406
2407         if (strequal(argv[2], "multistring")) {
2408                 type = REG_MULTI_SZ;
2409         }
2410
2411         if (type == REG_NONE) {
2412                 printf("Unknown data type: %s\n", argv[2]);
2413                 result =  WERR_INVALID_PARAM;
2414                 goto done;
2415         }
2416
2417         /* get a printer handle */
2418
2419         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2420                                                printername,
2421                                                SEC_FLAG_MAXIMUM_ALLOWED,
2422                                                &pol);
2423         if (!W_ERROR_IS_OK(result)) {
2424                 goto done;
2425         }
2426
2427         result = rpccli_spoolss_getprinter(cli, mem_ctx,
2428                                            &pol,
2429                                            0,
2430                                            0,
2431                                            &info);
2432         if (!W_ERROR_IS_OK(result)) {
2433                 goto done;
2434         }
2435
2436         printf("%s\n", current_timestring(mem_ctx, true));
2437         printf("\tchange_id (before set)\t:[0x%x]\n", info.info0.change_id);
2438
2439         /* Set the printer data */
2440
2441         switch (type) {
2442         case REG_SZ:
2443                 data.string = talloc_strdup(mem_ctx, argv[4]);
2444                 W_ERROR_HAVE_NO_MEMORY(data.string);
2445                 break;
2446         case REG_DWORD:
2447                 data.value = strtoul(argv[4], NULL, 10);
2448                 break;
2449         case REG_BINARY:
2450                 data.binary = strhex_to_data_blob(mem_ctx, argv[4]);
2451                 break;
2452         case REG_MULTI_SZ: {
2453                 int i, num_strings;
2454                 const char **strings = NULL;
2455
2456                 for (i=4; i<argc; i++) {
2457                         if (strcmp(argv[i], "NULL") == 0) {
2458                                 argv[i] = "";
2459                         }
2460                         if (!add_string_to_array(mem_ctx, argv[i],
2461                                                  &strings,
2462                                                  &num_strings)) {
2463                                 result = WERR_NOMEM;
2464                                 goto done;
2465                         }
2466                 }
2467                 data.string_array = talloc_zero_array(mem_ctx, const char *, num_strings + 1);
2468                 if (!data.string_array) {
2469                         result = WERR_NOMEM;
2470                         goto done;
2471                 }
2472                 for (i=0; i < num_strings; i++) {
2473                         data.string_array[i] = strings[i];
2474                 }
2475                 break;
2476                 }
2477         default:
2478                 printf("Unknown data type: %s\n", argv[2]);
2479                 result = WERR_INVALID_PARAM;
2480                 goto done;
2481         }
2482
2483         status = rpccli_spoolss_SetPrinterData(cli, mem_ctx,
2484                                                &pol,
2485                                                argv[3], /* value_name */
2486                                                type,
2487                                                data,
2488                                                0, /* autocalculated size */
2489                                                &result);
2490         if (!W_ERROR_IS_OK(result)) {
2491                 printf ("Unable to set [%s=%s]!\n", argv[3], argv[4]);
2492                 goto done;
2493         }
2494         printf("\tSetPrinterData succeeded [%s: %s]\n", argv[3], argv[4]);
2495
2496         result = rpccli_spoolss_getprinter(cli, mem_ctx,
2497                                            &pol,
2498                                            0,
2499                                            0,
2500                                            &info);
2501         if (!W_ERROR_IS_OK(result)) {
2502                 goto done;
2503         }
2504
2505         printf("%s\n", current_timestring(mem_ctx, true));
2506         printf("\tchange_id (after set)\t:[0x%x]\n", info.info0.change_id);
2507
2508 done:
2509         /* cleanup */
2510         if (is_valid_policy_hnd(&pol)) {
2511                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
2512         }
2513
2514         return result;
2515 }
2516
2517 /****************************************************************************
2518 ****************************************************************************/
2519
2520 static void display_job_info1(struct spoolss_JobInfo1 *r)
2521 {
2522         printf("%d: jobid[%d]: %s %s %s %d/%d pages\n", r->position, r->job_id,
2523                r->user_name, r->document_name, r->text_status, r->pages_printed,
2524                r->total_pages);
2525 }
2526
2527 /****************************************************************************
2528 ****************************************************************************/
2529
2530 static void display_job_info2(struct spoolss_JobInfo2 *r)
2531 {
2532         printf("%d: jobid[%d]: %s %s %s %d/%d pages, %d bytes\n",
2533                r->position, r->job_id,
2534                r->user_name, r->document_name, r->text_status, r->pages_printed,
2535                r->total_pages, r->size);
2536 }
2537
2538 /****************************************************************************
2539 ****************************************************************************/
2540
2541 static void display_job_info3(struct spoolss_JobInfo3 *r)
2542 {
2543         printf("jobid[%d], next_jobid[%d]\n",
2544                 r->job_id, r->next_job_id);
2545 }
2546
2547 /****************************************************************************
2548 ****************************************************************************/
2549
2550 static void display_job_info4(struct spoolss_JobInfo4 *r)
2551 {
2552         printf("%d: jobid[%d]: %s %s %s %d/%d pages, %d/%d bytes\n",
2553                r->position, r->job_id,
2554                r->user_name, r->document_name, r->text_status, r->pages_printed,
2555                r->total_pages, r->size, r->size_high);
2556 }
2557
2558 /****************************************************************************
2559 ****************************************************************************/
2560
2561 static WERROR cmd_spoolss_enum_jobs(struct rpc_pipe_client *cli,
2562                                       TALLOC_CTX *mem_ctx, int argc,
2563                                       const char **argv)
2564 {
2565         WERROR result;
2566         uint32_t level = 1, count, i;
2567         const char *printername;
2568         struct policy_handle hnd;
2569         union spoolss_JobInfo *info;
2570
2571         if (argc < 2 || argc > 3) {
2572                 printf("Usage: %s printername [level]\n", argv[0]);
2573                 return WERR_OK;
2574         }
2575
2576         if (argc == 3) {
2577                 level = atoi(argv[2]);
2578         }
2579
2580         /* Open printer handle */
2581
2582         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2583
2584         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2585                                                printername,
2586                                                SEC_FLAG_MAXIMUM_ALLOWED,
2587                                                &hnd);
2588         if (!W_ERROR_IS_OK(result))
2589                 goto done;
2590
2591         /* Enumerate ports */
2592
2593         result = rpccli_spoolss_enumjobs(cli, mem_ctx,
2594                                          &hnd,
2595                                          0, /* firstjob */
2596                                          1000, /* numjobs */
2597                                          level,
2598                                          0,
2599                                          &count,
2600                                          &info);
2601         if (!W_ERROR_IS_OK(result)) {
2602                 goto done;
2603         }
2604
2605         for (i = 0; i < count; i++) {
2606                 switch (level) {
2607                 case 1:
2608                         display_job_info1(&info[i].info1);
2609                         break;
2610                 case 2:
2611                         display_job_info2(&info[i].info2);
2612                         break;
2613                 default:
2614                         d_printf("unknown info level %d\n", level);
2615                         break;
2616                 }
2617         }
2618
2619 done:
2620         if (is_valid_policy_hnd(&hnd)) {
2621                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2622         }
2623
2624         return result;
2625 }
2626
2627 /****************************************************************************
2628 ****************************************************************************/
2629
2630 static WERROR cmd_spoolss_get_job(struct rpc_pipe_client *cli,
2631                                   TALLOC_CTX *mem_ctx, int argc,
2632                                   const char **argv)
2633 {
2634         WERROR result;
2635         const char *printername;
2636         struct policy_handle hnd;
2637         uint32_t job_id;
2638         uint32_t level = 1;
2639         union spoolss_JobInfo info;
2640
2641         if (argc < 3 || argc > 4) {
2642                 printf("Usage: %s printername job_id [level]\n", argv[0]);
2643                 return WERR_OK;
2644         }
2645
2646         job_id = atoi(argv[2]);
2647
2648         if (argc == 4) {
2649                 level = atoi(argv[3]);
2650         }
2651
2652         /* Open printer handle */
2653
2654         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2655
2656         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2657                                                printername,
2658                                                SEC_FLAG_MAXIMUM_ALLOWED,
2659                                                &hnd);
2660         if (!W_ERROR_IS_OK(result)) {
2661                 goto done;
2662         }
2663
2664         /* Enumerate ports */
2665
2666         result = rpccli_spoolss_getjob(cli, mem_ctx,
2667                                        &hnd,
2668                                        job_id,
2669                                        level,
2670                                        0,
2671                                        &info);
2672
2673         if (!W_ERROR_IS_OK(result)) {
2674                 goto done;
2675         }
2676
2677         switch (level) {
2678         case 1:
2679                 display_job_info1(&info.info1);
2680                 break;
2681         case 2:
2682                 display_job_info2(&info.info2);
2683                 break;
2684         case 3:
2685                 display_job_info3(&info.info3);
2686                 break;
2687         case 4:
2688                 display_job_info4(&info.info4);
2689                 break;
2690         default:
2691                 d_printf("unknown info level %d\n", level);
2692                 break;
2693         }
2694
2695 done:
2696         if (is_valid_policy_hnd(&hnd)) {
2697                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2698         }
2699
2700         return result;
2701 }
2702
2703 /****************************************************************************
2704 ****************************************************************************/
2705
2706 static WERROR cmd_spoolss_set_job(struct rpc_pipe_client *cli,
2707                                   TALLOC_CTX *mem_ctx, int argc,
2708                                   const char **argv)
2709 {
2710         WERROR result;
2711         NTSTATUS status;
2712         const char *printername;
2713         struct policy_handle hnd;
2714         uint32_t job_id;
2715         enum spoolss_JobControl command;
2716
2717         if (argc != 4) {
2718                 printf("Usage: %s printername job_id command\n", argv[0]);
2719                 return WERR_OK;
2720         }
2721
2722         job_id = atoi(argv[2]);
2723         command = atoi(argv[3]);
2724
2725         /* Open printer handle */
2726
2727         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2728
2729         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2730                                                printername,
2731                                                SEC_FLAG_MAXIMUM_ALLOWED,
2732                                                &hnd);
2733         if (!W_ERROR_IS_OK(result)) {
2734                 goto done;
2735         }
2736
2737         /* Set Job */
2738
2739         status = rpccli_spoolss_SetJob(cli, mem_ctx,
2740                                        &hnd,
2741                                        job_id,
2742                                        NULL,
2743                                        command,
2744                                        &result);
2745
2746         if (!W_ERROR_IS_OK(result)) {
2747                 goto done;
2748         }
2749
2750 done:
2751         if (is_valid_policy_hnd(&hnd)) {
2752                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2753         }
2754
2755         return result;
2756 }
2757
2758 /****************************************************************************
2759 ****************************************************************************/
2760
2761 static WERROR cmd_spoolss_enum_data(struct rpc_pipe_client *cli,
2762                                     TALLOC_CTX *mem_ctx, int argc,
2763                                     const char **argv)
2764 {
2765         WERROR result;
2766         NTSTATUS status;
2767         uint32_t i = 0;
2768         const char *printername;
2769         struct policy_handle hnd;
2770         uint32_t value_offered = 0;
2771         const char *value_name = NULL;
2772         uint32_t value_needed;
2773         enum winreg_Type type;
2774         uint8_t *data = NULL;
2775         uint32_t data_offered = 0;
2776         uint32_t data_needed;
2777
2778         if (argc != 2) {
2779                 printf("Usage: %s printername\n", argv[0]);
2780                 return WERR_OK;
2781         }
2782
2783         /* Open printer handle */
2784
2785         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2786
2787         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2788                                                printername,
2789                                                SEC_FLAG_MAXIMUM_ALLOWED,
2790                                                &hnd);
2791         if (!W_ERROR_IS_OK(result)) {
2792                 goto done;
2793         }
2794
2795         /* Enumerate data */
2796
2797         status = rpccli_spoolss_EnumPrinterData(cli, mem_ctx,
2798                                                 &hnd,
2799                                                 i,
2800                                                 value_name,
2801                                                 value_offered,
2802                                                 &value_needed,
2803                                                 &type,
2804                                                 data,
2805                                                 data_offered,
2806                                                 &data_needed,
2807                                                 &result);
2808
2809         data_offered    = data_needed;
2810         value_offered   = value_needed;
2811         data            = talloc_zero_array(mem_ctx, uint8_t, data_needed);
2812         value_name      = talloc_zero_array(mem_ctx, char, value_needed);
2813
2814         while (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(result)) {
2815
2816                 status = rpccli_spoolss_EnumPrinterData(cli, mem_ctx,
2817                                                         &hnd,
2818                                                         i++,
2819                                                         value_name,
2820                                                         value_offered,
2821                                                         &value_needed,
2822                                                         &type,
2823                                                         data,
2824                                                         data_offered,
2825                                                         &data_needed,
2826                                                         &result);
2827                 if (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(result)) {
2828                         struct regval_blob v;
2829                         fstrcpy(v.valuename, value_name);
2830                         v.type = type;
2831                         v.size = data_offered;
2832                         v.data_p = data;
2833                         display_reg_value(v);
2834                 }
2835         }
2836
2837         if (W_ERROR_V(result) == ERRnomoreitems) {
2838                 result = W_ERROR(ERRsuccess);
2839         }
2840
2841 done:
2842         if (is_valid_policy_hnd(&hnd)) {
2843                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2844         }
2845
2846         return result;
2847 }
2848
2849 /****************************************************************************
2850 ****************************************************************************/
2851
2852 static WERROR cmd_spoolss_enum_data_ex( struct rpc_pipe_client *cli,
2853                                           TALLOC_CTX *mem_ctx, int argc,
2854                                           const char **argv)
2855 {
2856         WERROR result;
2857         uint32_t i;
2858         const char *printername;
2859         struct policy_handle hnd;
2860         uint32_t count;
2861         struct spoolss_PrinterEnumValues *info;
2862
2863         if (argc != 3) {
2864                 printf("Usage: %s printername <keyname>\n", argv[0]);
2865                 return WERR_OK;
2866         }
2867
2868         /* Open printer handle */
2869
2870         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2871
2872         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2873                                                printername,
2874                                                SEC_FLAG_MAXIMUM_ALLOWED,
2875                                                &hnd);
2876         if (!W_ERROR_IS_OK(result)) {
2877                 goto done;
2878         }
2879
2880         /* Enumerate subkeys */
2881
2882         result = rpccli_spoolss_enumprinterdataex(cli, mem_ctx,
2883                                                   &hnd,
2884                                                   argv[2],
2885                                                   0,
2886                                                   &count,
2887                                                   &info);
2888         if (!W_ERROR_IS_OK(result)) {
2889                 goto done;
2890         }
2891
2892         for (i=0; i < count; i++) {
2893                 display_printer_data(info[i].value_name,
2894                                      info[i].type,
2895                                      info[i].data);
2896         }
2897
2898  done:
2899         if (is_valid_policy_hnd(&hnd)) {
2900                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2901         }
2902
2903         return result;
2904 }
2905
2906 /****************************************************************************
2907 ****************************************************************************/
2908
2909 static WERROR cmd_spoolss_enum_printerkey(struct rpc_pipe_client *cli,
2910                                           TALLOC_CTX *mem_ctx, int argc,
2911                                           const char **argv)
2912 {
2913         WERROR result;
2914         const char *printername;
2915         const char *keyname = NULL;
2916         struct policy_handle hnd;
2917         const char **key_buffer = NULL;
2918         int i;
2919
2920         if (argc < 2 || argc > 3) {
2921                 printf("Usage: %s printername [keyname]\n", argv[0]);
2922                 return WERR_OK;
2923         }
2924
2925         if (argc == 3) {
2926                 keyname = argv[2];
2927         } else {
2928                 keyname = "";
2929         }
2930
2931         /* Open printer handle */
2932
2933         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2934
2935         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2936                                                printername,
2937                                                SEC_FLAG_MAXIMUM_ALLOWED,
2938                                                &hnd);
2939         if (!W_ERROR_IS_OK(result)) {
2940                 goto done;
2941         }
2942
2943         /* Enumerate subkeys */
2944
2945         result = rpccli_spoolss_enumprinterkey(cli, mem_ctx,
2946                                                &hnd,
2947                                                keyname,
2948                                                &key_buffer,
2949                                                0);
2950
2951         if (!W_ERROR_IS_OK(result)) {
2952                 goto done;
2953         }
2954
2955         for (i=0; key_buffer && key_buffer[i]; i++) {
2956                 printf("%s\n", key_buffer[i]);
2957         }
2958
2959  done:
2960
2961         if (is_valid_policy_hnd(&hnd)) {
2962                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2963         }
2964
2965         return result;
2966 }
2967
2968 /****************************************************************************
2969 ****************************************************************************/
2970
2971 static WERROR cmd_spoolss_rffpcnex(struct rpc_pipe_client *cli,
2972                                      TALLOC_CTX *mem_ctx, int argc,
2973                                      const char **argv)
2974 {
2975         const char *printername;
2976         const char *clientname;
2977         struct policy_handle hnd;
2978         WERROR result;
2979         NTSTATUS status;
2980         struct spoolss_NotifyOption option;
2981
2982         if (argc != 2) {
2983                 printf("Usage: %s printername\n", argv[0]);
2984                 result = WERR_OK;
2985                 goto done;
2986         }
2987
2988         /* Open printer */
2989
2990         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2991
2992         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2993                                                printername,
2994                                                SEC_FLAG_MAXIMUM_ALLOWED,
2995                                                &hnd);
2996         if (!W_ERROR_IS_OK(result)) {
2997                 printf("Error opening %s\n", argv[1]);
2998                 goto done;
2999         }
3000
3001         /* Create spool options */
3002
3003         option.version = 2;
3004         option.count = 2;
3005
3006         option.types = talloc_array(mem_ctx, struct spoolss_NotifyOptionType, 2);
3007         if (option.types == NULL) {
3008                 result = WERR_NOMEM;
3009                 goto done;
3010         }
3011
3012         option.types[0].type = PRINTER_NOTIFY_TYPE;
3013         option.types[0].count = 1;
3014         option.types[0].fields = talloc_array(mem_ctx, union spoolss_Field, 1);
3015         if (option.types[0].fields == NULL) {
3016                 result = WERR_NOMEM;
3017                 goto done;
3018         }
3019         option.types[0].fields[0].field = PRINTER_NOTIFY_FIELD_SERVER_NAME;
3020
3021         option.types[1].type = JOB_NOTIFY_TYPE;
3022         option.types[1].count = 1;
3023         option.types[1].fields = talloc_array(mem_ctx, union spoolss_Field, 1);
3024         if (option.types[1].fields == NULL) {
3025                 result = WERR_NOMEM;
3026                 goto done;
3027         }
3028         option.types[1].fields[0].field = JOB_NOTIFY_FIELD_PRINTER_NAME;
3029
3030         clientname = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
3031         if (!clientname) {
3032                 result = WERR_NOMEM;
3033                 goto done;
3034         }
3035
3036         /* Send rffpcnex */
3037
3038         status = rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx(cli, mem_ctx,
3039                                                                      &hnd,
3040                                                                      0,
3041                                                                      0,
3042                                                                      clientname,
3043                                                                      123,
3044                                                                      &option,
3045                                                                      &result);
3046         if (!W_ERROR_IS_OK(result)) {
3047                 printf("Error rffpcnex %s\n", argv[1]);
3048                 goto done;
3049         }
3050
3051 done:
3052         if (is_valid_policy_hnd(&hnd))
3053                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
3054
3055         return result;
3056 }
3057
3058 /****************************************************************************
3059 ****************************************************************************/
3060
3061 static bool compare_printer( struct rpc_pipe_client *cli1, struct policy_handle *hnd1,
3062                              struct rpc_pipe_client *cli2, struct policy_handle *hnd2 )
3063 {
3064         union spoolss_PrinterInfo info1, info2;
3065         WERROR werror;
3066         TALLOC_CTX *mem_ctx = talloc_init("compare_printer");
3067
3068         printf("Retrieving printer propertiesfor %s...", cli1->desthost);
3069         werror = rpccli_spoolss_getprinter(cli1, mem_ctx,
3070                                            hnd1,
3071                                            2,
3072                                            0,
3073                                            &info1);
3074         if ( !W_ERROR_IS_OK(werror) ) {
3075                 printf("failed (%s)\n", win_errstr(werror));
3076                 talloc_destroy(mem_ctx);
3077                 return false;
3078         }
3079         printf("ok\n");
3080
3081         printf("Retrieving printer properties for %s...", cli2->desthost);
3082         werror = rpccli_spoolss_getprinter(cli2, mem_ctx,
3083                                            hnd2,
3084                                            2,
3085                                            0,
3086                                            &info2);
3087         if ( !W_ERROR_IS_OK(werror) ) {
3088                 printf("failed (%s)\n", win_errstr(werror));
3089                 talloc_destroy(mem_ctx);
3090                 return false;
3091         }
3092         printf("ok\n");
3093
3094         talloc_destroy(mem_ctx);
3095
3096         return true;
3097 }
3098
3099 /*******************************************