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