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                 result = WERR_OK;
1949
1950                 /* make the call to remove the driver */
1951                 status = rpccli_spoolss_DeletePrinterDriver(cli, mem_ctx,
1952                                                             cli->srv_name_slash,
1953                                                             archi_table[i].long_archi,
1954                                                             argv[1],
1955                                                             &result);
1956                 if (!NT_STATUS_IS_OK(status)) {
1957                         if (W_ERROR_IS_OK(result)) {
1958                                 result = ntstatus_to_werror(status);
1959                         }
1960                 }
1961                 if ( !W_ERROR_IS_OK(result) ) {
1962                         if ( !W_ERROR_EQUAL(result, WERR_UNKNOWN_PRINTER_DRIVER) ) {
1963                                 printf ("Failed to remove driver %s for arch [%s] - error 0x%x!\n",
1964                                         argv[1], archi_table[i].long_archi,
1965                                         W_ERROR_V(result));
1966                         }
1967                 } else {
1968                         printf ("Driver %s removed for arch [%s].\n", argv[1],
1969                                 archi_table[i].long_archi);
1970                 }
1971         }
1972
1973         return result;
1974 }
1975
1976 /****************************************************************************
1977 ****************************************************************************/
1978
1979 static WERROR cmd_spoolss_getprintprocdir(struct rpc_pipe_client *cli,
1980                                             TALLOC_CTX *mem_ctx,
1981                                             int argc, const char **argv)
1982 {
1983         WERROR result;
1984         NTSTATUS status;
1985         const char *environment = SPOOLSS_ARCHITECTURE_NT_X86;
1986         DATA_BLOB buffer;
1987         uint32_t offered;
1988         union spoolss_PrintProcessorDirectoryInfo info;
1989         uint32_t needed;
1990
1991         /* parse the command arguments */
1992         if (argc > 2) {
1993                 printf ("Usage: %s [environment]\n", argv[0]);
1994                 return WERR_OK;
1995         }
1996
1997         if (argc == 2) {
1998                 environment = argv[1];
1999         }
2000
2001         status = rpccli_spoolss_GetPrintProcessorDirectory(cli, mem_ctx,
2002                                                            cli->srv_name_slash,
2003                                                            environment,
2004                                                            1,
2005                                                            NULL, /* buffer */
2006                                                            0, /* offered */
2007                                                            NULL, /* info */
2008                                                            &needed,
2009                                                            &result);
2010         if (W_ERROR_EQUAL(result, WERR_INSUFFICIENT_BUFFER)) {
2011                 offered = needed;
2012                 buffer = data_blob_talloc_zero(mem_ctx, needed);
2013
2014                 status = rpccli_spoolss_GetPrintProcessorDirectory(cli, mem_ctx,
2015                                                                    cli->srv_name_slash,
2016                                                                    environment,
2017                                                                    1,
2018                                                                    &buffer,
2019                                                                    offered,
2020                                                                    &info,
2021                                                                    &needed,
2022                                                                    &result);
2023         }
2024
2025         if (W_ERROR_IS_OK(result)) {
2026                 printf("%s\n", info.info1.directory_name);
2027         }
2028
2029         return result;
2030 }
2031
2032 /****************************************************************************
2033 ****************************************************************************/
2034
2035 static WERROR cmd_spoolss_addform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
2036                                     int argc, const char **argv)
2037 {
2038         struct policy_handle handle;
2039         WERROR werror;
2040         NTSTATUS status;
2041         const char *printername;
2042         union spoolss_AddFormInfo info;
2043         struct spoolss_AddFormInfo1 info1;
2044         struct spoolss_AddFormInfo2 info2;
2045         uint32_t level = 1;
2046
2047         /* Parse the command arguments */
2048
2049         if (argc < 3 || argc > 5) {
2050                 printf ("Usage: %s <printer> <formname> [level]\n", argv[0]);
2051                 return WERR_OK;
2052         }
2053
2054         /* Get a printer handle */
2055
2056         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2057
2058         werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2059                                                printername,
2060                                                PRINTER_ALL_ACCESS,
2061                                                &handle);
2062         if (!W_ERROR_IS_OK(werror))
2063                 goto done;
2064
2065         /* Dummy up some values for the form data */
2066
2067         if (argc == 4) {
2068                 level = atoi(argv[3]);
2069         }
2070
2071         switch (level) {
2072         case 1:
2073                 info1.flags             = SPOOLSS_FORM_USER;
2074                 info1.form_name         = argv[2];
2075                 info1.size.width        = 100;
2076                 info1.size.height       = 100;
2077                 info1.area.left         = 0;
2078                 info1.area.top          = 10;
2079                 info1.area.right        = 20;
2080                 info1.area.bottom       = 30;
2081
2082                 info.info1 = &info1;
2083
2084                 break;
2085         case 2:
2086                 info2.flags             = SPOOLSS_FORM_USER;
2087                 info2.form_name         = argv[2];
2088                 info2.size.width        = 100;
2089                 info2.size.height       = 100;
2090                 info2.area.left         = 0;
2091                 info2.area.top          = 10;
2092                 info2.area.right        = 20;
2093                 info2.area.bottom       = 30;
2094                 info2.keyword           = argv[2];
2095                 info2.string_type       = SPOOLSS_FORM_STRING_TYPE_NONE;
2096                 info2.mui_dll           = NULL;
2097                 info2.ressource_id      = 0;
2098                 info2.display_name      = argv[2];
2099                 info2.lang_id           = 0;
2100
2101                 info.info2 = &info2;
2102
2103                 break;
2104         }
2105
2106         /* Add the form */
2107
2108
2109         status = rpccli_spoolss_AddForm(cli, mem_ctx,
2110                                         &handle,
2111                                         level,
2112                                         info,
2113                                         &werror);
2114
2115  done:
2116         if (is_valid_policy_hnd(&handle))
2117                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
2118
2119         return werror;
2120 }
2121
2122 /****************************************************************************
2123 ****************************************************************************/
2124
2125 static WERROR cmd_spoolss_setform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
2126                                     int argc, const char **argv)
2127 {
2128         struct policy_handle handle;
2129         WERROR werror;
2130         NTSTATUS status;
2131         const char *printername;
2132         union spoolss_AddFormInfo info;
2133         struct spoolss_AddFormInfo1 info1;
2134
2135         /* Parse the command arguments */
2136
2137         if (argc != 3) {
2138                 printf ("Usage: %s <printer> <formname>\n", argv[0]);
2139                 return WERR_OK;
2140         }
2141
2142         /* Get a printer handle */
2143
2144         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2145
2146         werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2147                                                printername,
2148                                                SEC_FLAG_MAXIMUM_ALLOWED,
2149                                                &handle);
2150         if (!W_ERROR_IS_OK(werror))
2151                 goto done;
2152
2153         /* Dummy up some values for the form data */
2154
2155         info1.flags             = SPOOLSS_FORM_PRINTER;
2156         info1.size.width        = 100;
2157         info1.size.height       = 100;
2158         info1.area.left         = 0;
2159         info1.area.top          = 1000;
2160         info1.area.right        = 2000;
2161         info1.area.bottom       = 3000;
2162         info1.form_name         = argv[2];
2163
2164         info.info1 = &info1;
2165
2166         /* Set the form */
2167
2168         status = rpccli_spoolss_SetForm(cli, mem_ctx,
2169                                         &handle,
2170                                         argv[2],
2171                                         1,
2172                                         info,
2173                                         &werror);
2174
2175  done:
2176         if (is_valid_policy_hnd(&handle))
2177                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
2178
2179         return werror;
2180 }
2181
2182 /****************************************************************************
2183 ****************************************************************************/
2184
2185 static const char *get_form_flag(int form_flag)
2186 {
2187         switch (form_flag) {
2188         case SPOOLSS_FORM_USER:
2189                 return "FORM_USER";
2190         case SPOOLSS_FORM_BUILTIN:
2191                 return "FORM_BUILTIN";
2192         case SPOOLSS_FORM_PRINTER:
2193                 return "FORM_PRINTER";
2194         default:
2195                 return "unknown";
2196         }
2197 }
2198
2199 /****************************************************************************
2200 ****************************************************************************/
2201
2202 static void display_form_info1(struct spoolss_FormInfo1 *r)
2203 {
2204         printf("%s\n" \
2205                 "\tflag: %s (%d)\n" \
2206                 "\twidth: %d, length: %d\n" \
2207                 "\tleft: %d, right: %d, top: %d, bottom: %d\n\n",
2208                 r->form_name, get_form_flag(r->flags), r->flags,
2209                 r->size.width, r->size.height,
2210                 r->area.left, r->area.right,
2211                 r->area.top, r->area.bottom);
2212 }
2213
2214 /****************************************************************************
2215 ****************************************************************************/
2216
2217 static void display_form_info2(struct spoolss_FormInfo2 *r)
2218 {
2219         printf("%s\n" \
2220                 "\tflag: %s (%d)\n" \
2221                 "\twidth: %d, length: %d\n" \
2222                 "\tleft: %d, right: %d, top: %d, bottom: %d\n",
2223                 r->form_name, get_form_flag(r->flags), r->flags,
2224                 r->size.width, r->size.height,
2225                 r->area.left, r->area.right,
2226                 r->area.top, r->area.bottom);
2227         printf("\tkeyword: %s\n", r->keyword);
2228         printf("\tstring_type: 0x%08x\n", r->string_type);
2229         printf("\tmui_dll: %s\n", r->mui_dll);
2230         printf("\tressource_id: 0x%08x\n", r->ressource_id);
2231         printf("\tdisplay_name: %s\n", r->display_name);
2232         printf("\tlang_id: %d\n", r->lang_id);
2233         printf("\n");
2234 }
2235
2236 /****************************************************************************
2237 ****************************************************************************/
2238
2239 static WERROR cmd_spoolss_getform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
2240                                     int argc, const char **argv)
2241 {
2242         struct policy_handle handle;
2243         WERROR werror;
2244         NTSTATUS status;
2245         const char *printername;
2246         DATA_BLOB buffer;
2247         uint32_t offered = 0;
2248         union spoolss_FormInfo info;
2249         uint32_t needed;
2250         uint32_t level = 1;
2251
2252         /* Parse the command arguments */
2253
2254         if (argc < 3 || argc > 5) {
2255                 printf ("Usage: %s <printer> <formname> [level]\n", argv[0]);
2256                 return WERR_OK;
2257         }
2258
2259         /* Get a printer handle */
2260
2261         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2262
2263         werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2264                                                printername,
2265                                                SEC_FLAG_MAXIMUM_ALLOWED,
2266                                                &handle);
2267         if (!W_ERROR_IS_OK(werror))
2268                 goto done;
2269
2270         if (argc == 4) {
2271                 level = atoi(argv[3]);
2272         }
2273
2274         /* Get the form */
2275
2276         status = rpccli_spoolss_GetForm(cli, mem_ctx,
2277                                         &handle,
2278                                         argv[2],
2279                                         level,
2280                                         NULL,
2281                                         offered,
2282                                         &info,
2283                                         &needed,
2284                                         &werror);
2285         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
2286                 buffer = data_blob_talloc_zero(mem_ctx, needed);
2287                 offered = needed;
2288                 status = rpccli_spoolss_GetForm(cli, mem_ctx,
2289                                                 &handle,
2290                                                 argv[2],
2291                                                 level,
2292                                                 &buffer,
2293                                                 offered,
2294                                                 &info,
2295                                                 &needed,
2296                                                 &werror);
2297         }
2298
2299         if (!NT_STATUS_IS_OK(status)) {
2300                 return werror;
2301         }
2302
2303         switch (level) {
2304         case 1:
2305                 display_form_info1(&info.info1);
2306                 break;
2307         case 2:
2308                 display_form_info2(&info.info2);
2309                 break;
2310         }
2311
2312  done:
2313         if (is_valid_policy_hnd(&handle))
2314                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
2315
2316         return werror;
2317 }
2318
2319 /****************************************************************************
2320 ****************************************************************************/
2321
2322 static WERROR cmd_spoolss_deleteform(struct rpc_pipe_client *cli,
2323                                        TALLOC_CTX *mem_ctx, int argc,
2324                                        const char **argv)
2325 {
2326         struct policy_handle handle;
2327         WERROR werror;
2328         NTSTATUS status;
2329         const char *printername;
2330
2331         /* Parse the command arguments */
2332
2333         if (argc != 3) {
2334                 printf ("Usage: %s <printer> <formname>\n", argv[0]);
2335                 return WERR_OK;
2336         }
2337
2338         /* Get a printer handle */
2339
2340         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2341
2342         werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2343                                                printername,
2344                                                SEC_FLAG_MAXIMUM_ALLOWED,
2345                                                &handle);
2346         if (!W_ERROR_IS_OK(werror))
2347                 goto done;
2348
2349         /* Delete the form */
2350
2351         status = rpccli_spoolss_DeleteForm(cli, mem_ctx,
2352                                            &handle,
2353                                            argv[2],
2354                                            &werror);
2355         if (!NT_STATUS_IS_OK(status)) {
2356                 return ntstatus_to_werror(status);
2357         }
2358
2359  done:
2360         if (is_valid_policy_hnd(&handle))
2361                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
2362
2363         return werror;
2364 }
2365
2366 /****************************************************************************
2367 ****************************************************************************/
2368
2369 static WERROR cmd_spoolss_enum_forms(struct rpc_pipe_client *cli,
2370                                        TALLOC_CTX *mem_ctx, int argc,
2371                                        const char **argv)
2372 {
2373         struct policy_handle handle;
2374         WERROR werror;
2375         const char *printername;
2376         uint32_t num_forms, level = 1, i;
2377         union spoolss_FormInfo *forms;
2378
2379         /* Parse the command arguments */
2380
2381         if (argc < 2 || argc > 4) {
2382                 printf ("Usage: %s <printer> [level]\n", argv[0]);
2383                 return WERR_OK;
2384         }
2385
2386         /* Get a printer handle */
2387
2388         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2389
2390         werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2391                                                printername,
2392                                                SEC_FLAG_MAXIMUM_ALLOWED,
2393                                                &handle);
2394         if (!W_ERROR_IS_OK(werror))
2395                 goto done;
2396
2397         if (argc == 3) {
2398                 level = atoi(argv[2]);
2399         }
2400
2401         /* Enumerate forms */
2402
2403         werror = rpccli_spoolss_enumforms(cli, mem_ctx,
2404                                           &handle,
2405                                           level,
2406                                           0,
2407                                           &num_forms,
2408                                           &forms);
2409
2410         if (!W_ERROR_IS_OK(werror))
2411                 goto done;
2412
2413         /* Display output */
2414
2415         for (i = 0; i < num_forms; i++) {
2416                 switch (level) {
2417                 case 1:
2418                         display_form_info1(&forms[i].info1);
2419                         break;
2420                 case 2:
2421                         display_form_info2(&forms[i].info2);
2422                         break;
2423                 }
2424         }
2425
2426  done:
2427         if (is_valid_policy_hnd(&handle))
2428                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
2429
2430         return werror;
2431 }
2432
2433 /****************************************************************************
2434 ****************************************************************************/
2435
2436 static WERROR cmd_spoolss_setprinterdata(struct rpc_pipe_client *cli,
2437                                             TALLOC_CTX *mem_ctx,
2438                                             int argc, const char **argv)
2439 {
2440         WERROR result;
2441         NTSTATUS status;
2442         const char *printername;
2443         struct policy_handle pol;
2444         union spoolss_PrinterInfo info;
2445         enum winreg_Type type;
2446         union spoolss_PrinterData data;
2447         DATA_BLOB blob;
2448
2449         /* parse the command arguments */
2450         if (argc < 5) {
2451                 printf ("Usage: %s <printer> <string|binary|dword|multistring>"
2452                         " <value> <data>\n",
2453                         argv[0]);
2454                 return WERR_OK;
2455         }
2456
2457         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2458
2459         type = REG_NONE;
2460
2461         if (strequal(argv[2], "string")) {
2462                 type = REG_SZ;
2463         }
2464
2465         if (strequal(argv[2], "binary")) {
2466                 type = REG_BINARY;
2467         }
2468
2469         if (strequal(argv[2], "dword")) {
2470                 type = REG_DWORD;
2471         }
2472
2473         if (strequal(argv[2], "multistring")) {
2474                 type = REG_MULTI_SZ;
2475         }
2476
2477         if (type == REG_NONE) {
2478                 printf("Unknown data type: %s\n", argv[2]);
2479                 result =  WERR_INVALID_PARAM;
2480                 goto done;
2481         }
2482
2483         /* get a printer handle */
2484
2485         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2486                                                printername,
2487                                                SEC_FLAG_MAXIMUM_ALLOWED,
2488                                                &pol);
2489         if (!W_ERROR_IS_OK(result)) {
2490                 goto done;
2491         }
2492
2493         result = rpccli_spoolss_getprinter(cli, mem_ctx,
2494                                            &pol,
2495                                            0,
2496                                            0,
2497                                            &info);
2498         if (!W_ERROR_IS_OK(result)) {
2499                 goto done;
2500         }
2501
2502         printf("%s\n", current_timestring(mem_ctx, true));
2503         printf("\tchange_id (before set)\t:[0x%x]\n", info.info0.change_id);
2504
2505         /* Set the printer data */
2506
2507         switch (type) {
2508         case REG_SZ:
2509                 data.string = talloc_strdup(mem_ctx, argv[4]);
2510                 W_ERROR_HAVE_NO_MEMORY(data.string);
2511                 break;
2512         case REG_DWORD:
2513                 data.value = strtoul(argv[4], NULL, 10);
2514                 break;
2515         case REG_BINARY:
2516                 data.binary = strhex_to_data_blob(mem_ctx, argv[4]);
2517                 break;
2518         case REG_MULTI_SZ: {
2519                 int i, num_strings;
2520                 const char **strings = NULL;
2521
2522                 for (i=4; i<argc; i++) {
2523                         if (strcmp(argv[i], "NULL") == 0) {
2524                                 argv[i] = "";
2525                         }
2526                         if (!add_string_to_array(mem_ctx, argv[i],
2527                                                  &strings,
2528                                                  &num_strings)) {
2529                                 result = WERR_NOMEM;
2530                                 goto done;
2531                         }
2532                 }
2533                 data.string_array = talloc_zero_array(mem_ctx, const char *, num_strings + 1);
2534                 if (!data.string_array) {
2535                         result = WERR_NOMEM;
2536                         goto done;
2537                 }
2538                 for (i=0; i < num_strings; i++) {
2539                         data.string_array[i] = strings[i];
2540                 }
2541                 break;
2542                 }
2543         default:
2544                 printf("Unknown data type: %s\n", argv[2]);
2545                 result = WERR_INVALID_PARAM;
2546                 goto done;
2547         }
2548
2549         result = push_spoolss_PrinterData(mem_ctx, &blob, type, &data);
2550         if (!W_ERROR_IS_OK(result)) {
2551                 goto done;
2552         }
2553
2554         status = rpccli_spoolss_SetPrinterData(cli, mem_ctx,
2555                                                &pol,
2556                                                argv[3], /* value_name */
2557                                                type,
2558                                                blob.data,
2559                                                blob.length,
2560                                                &result);
2561         if (!W_ERROR_IS_OK(result)) {
2562                 printf ("Unable to set [%s=%s]!\n", argv[3], argv[4]);
2563                 goto done;
2564         }
2565         printf("\tSetPrinterData succeeded [%s: %s]\n", argv[3], argv[4]);
2566
2567         result = rpccli_spoolss_getprinter(cli, mem_ctx,
2568                                            &pol,
2569                                            0,
2570                                            0,
2571                                            &info);
2572         if (!W_ERROR_IS_OK(result)) {
2573                 goto done;
2574         }
2575
2576         printf("%s\n", current_timestring(mem_ctx, true));
2577         printf("\tchange_id (after set)\t:[0x%x]\n", info.info0.change_id);
2578
2579 done:
2580         /* cleanup */
2581         if (is_valid_policy_hnd(&pol)) {
2582                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
2583         }
2584
2585         return result;
2586 }
2587
2588 /****************************************************************************
2589 ****************************************************************************/
2590
2591 static void display_job_info1(struct spoolss_JobInfo1 *r)
2592 {
2593         printf("%d: jobid[%d]: %s %s %s %d/%d pages\n", r->position, r->job_id,
2594                r->user_name, r->document_name, r->text_status, r->pages_printed,
2595                r->total_pages);
2596 }
2597
2598 /****************************************************************************
2599 ****************************************************************************/
2600
2601 static void display_job_info2(struct spoolss_JobInfo2 *r)
2602 {
2603         printf("%d: jobid[%d]: %s %s %s %d/%d pages, %d bytes\n",
2604                r->position, r->job_id,
2605                r->user_name, r->document_name, r->text_status, r->pages_printed,
2606                r->total_pages, r->size);
2607 }
2608
2609 /****************************************************************************
2610 ****************************************************************************/
2611
2612 static void display_job_info3(struct spoolss_JobInfo3 *r)
2613 {
2614         printf("jobid[%d], next_jobid[%d]\n",
2615                 r->job_id, r->next_job_id);
2616 }
2617
2618 /****************************************************************************
2619 ****************************************************************************/
2620
2621 static void display_job_info4(struct spoolss_JobInfo4 *r)
2622 {
2623         printf("%d: jobid[%d]: %s %s %s %d/%d pages, %d/%d bytes\n",
2624                r->position, r->job_id,
2625                r->user_name, r->document_name, r->text_status, r->pages_printed,
2626                r->total_pages, r->size, r->size_high);
2627 }
2628
2629 /****************************************************************************
2630 ****************************************************************************/
2631
2632 static WERROR cmd_spoolss_enum_jobs(struct rpc_pipe_client *cli,
2633                                       TALLOC_CTX *mem_ctx, int argc,
2634                                       const char **argv)
2635 {
2636         WERROR result;
2637         uint32_t level = 1, count, i;
2638         const char *printername;
2639         struct policy_handle hnd;
2640         union spoolss_JobInfo *info;
2641
2642         if (argc < 2 || argc > 3) {
2643                 printf("Usage: %s printername [level]\n", argv[0]);
2644                 return WERR_OK;
2645         }
2646
2647         if (argc == 3) {
2648                 level = atoi(argv[2]);
2649         }
2650
2651         /* Open printer handle */
2652
2653         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2654
2655         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2656                                                printername,
2657                                                SEC_FLAG_MAXIMUM_ALLOWED,
2658                                                &hnd);
2659         if (!W_ERROR_IS_OK(result))
2660                 goto done;
2661
2662         /* Enumerate ports */
2663
2664         result = rpccli_spoolss_enumjobs(cli, mem_ctx,
2665                                          &hnd,
2666                                          0, /* firstjob */
2667                                          1000, /* numjobs */
2668                                          level,
2669                                          0,
2670                                          &count,
2671                                          &info);
2672         if (!W_ERROR_IS_OK(result)) {
2673                 goto done;
2674         }
2675
2676         for (i = 0; i < count; i++) {
2677                 switch (level) {
2678                 case 1:
2679                         display_job_info1(&info[i].info1);
2680                         break;
2681                 case 2:
2682                         display_job_info2(&info[i].info2);
2683                         break;
2684                 default:
2685                         d_printf("unknown info level %d\n", level);
2686                         break;
2687                 }
2688         }
2689
2690 done:
2691         if (is_valid_policy_hnd(&hnd)) {
2692                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2693         }
2694
2695         return result;
2696 }
2697
2698 /****************************************************************************
2699 ****************************************************************************/
2700
2701 static WERROR cmd_spoolss_get_job(struct rpc_pipe_client *cli,
2702                                   TALLOC_CTX *mem_ctx, int argc,
2703                                   const char **argv)
2704 {
2705         WERROR result;
2706         const char *printername;
2707         struct policy_handle hnd;
2708         uint32_t job_id;
2709         uint32_t level = 1;
2710         union spoolss_JobInfo info;
2711
2712         if (argc < 3 || argc > 4) {
2713                 printf("Usage: %s printername job_id [level]\n", argv[0]);
2714                 return WERR_OK;
2715         }
2716
2717         job_id = atoi(argv[2]);
2718
2719         if (argc == 4) {
2720                 level = atoi(argv[3]);
2721         }
2722
2723         /* Open printer handle */
2724
2725         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2726
2727         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2728                                                printername,
2729                                                SEC_FLAG_MAXIMUM_ALLOWED,
2730                                                &hnd);
2731         if (!W_ERROR_IS_OK(result)) {
2732                 goto done;
2733         }
2734
2735         /* Enumerate ports */
2736
2737         result = rpccli_spoolss_getjob(cli, mem_ctx,
2738                                        &hnd,
2739                                        job_id,
2740                                        level,
2741                                        0,
2742                                        &info);
2743
2744         if (!W_ERROR_IS_OK(result)) {
2745                 goto done;
2746         }
2747
2748         switch (level) {
2749         case 1:
2750                 display_job_info1(&info.info1);
2751                 break;
2752         case 2:
2753                 display_job_info2(&info.info2);
2754                 break;
2755         case 3:
2756                 display_job_info3(&info.info3);
2757                 break;
2758         case 4:
2759                 display_job_info4(&info.info4);
2760                 break;
2761         default:
2762                 d_printf("unknown info level %d\n", level);
2763                 break;
2764         }
2765
2766 done:
2767         if (is_valid_policy_hnd(&hnd)) {
2768                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2769         }
2770
2771         return result;
2772 }
2773
2774 /****************************************************************************
2775 ****************************************************************************/
2776
2777 static struct {
2778         const char *name;
2779         enum spoolss_JobControl val;
2780 } cmdvals[] = {
2781         {"PAUSE", SPOOLSS_JOB_CONTROL_PAUSE},
2782         {"RESUME", SPOOLSS_JOB_CONTROL_RESUME},
2783         {"CANCEL", SPOOLSS_JOB_CONTROL_CANCEL},
2784         {"RESTART", SPOOLSS_JOB_CONTROL_RESTART},
2785         {"DELETE", SPOOLSS_JOB_CONTROL_DELETE},
2786         {"SEND_TO_PRINTER", SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER},
2787         {"EJECTED", SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED},
2788         {"RETAIN", SPOOLSS_JOB_CONTROL_RETAIN},
2789         {"RELEASE", SPOOLSS_JOB_CONTROL_RELEASE}
2790 };
2791
2792 static enum spoolss_JobControl parse_setjob_command(const char *cmd)
2793 {
2794         int i;
2795
2796         for (i = 0; i < sizeof(cmdvals)/sizeof(cmdvals[0]); i++) {
2797                 if (strequal(cmdvals[i].name, cmd)) {
2798                         return cmdvals[i].val;
2799                 }
2800         }
2801         return (enum spoolss_JobControl)atoi(cmd);
2802 }
2803
2804 static WERROR cmd_spoolss_set_job(struct rpc_pipe_client *cli,
2805                                   TALLOC_CTX *mem_ctx, int argc,
2806                                   const char **argv)
2807 {
2808         WERROR result;
2809         NTSTATUS status;
2810         const char *printername;
2811         struct policy_handle hnd;
2812         uint32_t job_id;
2813         enum spoolss_JobControl command;
2814
2815         if (argc != 4) {
2816                 printf("Usage: %s printername job_id command\n", argv[0]);
2817                 printf("command = [PAUSE|RESUME|CANCEL|RESTART|DELETE|"
2818                         "SEND_TO_PRINTER|EJECTED|RETAIN|RELEASE]\n");
2819                 return WERR_OK;
2820         }
2821
2822         job_id = atoi(argv[2]);
2823         command = parse_setjob_command(argv[3]);
2824
2825         /* Open printer handle */
2826
2827         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2828
2829         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2830                                                printername,
2831                                                SEC_FLAG_MAXIMUM_ALLOWED,
2832                                                &hnd);
2833         if (!W_ERROR_IS_OK(result)) {
2834                 goto done;
2835         }
2836
2837         /* Set Job */
2838
2839         status = rpccli_spoolss_SetJob(cli, mem_ctx,
2840                                        &hnd,
2841                                        job_id,
2842                                        NULL,
2843                                        command,
2844                                        &result);
2845
2846         if (!W_ERROR_IS_OK(result)) {
2847                 goto done;
2848         }
2849
2850 done:
2851         if (is_valid_policy_hnd(&hnd)) {
2852                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2853         }
2854
2855         return result;
2856 }
2857
2858 /****************************************************************************
2859 ****************************************************************************/
2860
2861 static WERROR cmd_spoolss_enum_data(struct rpc_pipe_client *cli,
2862                                     TALLOC_CTX *mem_ctx, int argc,
2863                                     const char **argv)
2864 {
2865         WERROR result;
2866         NTSTATUS status;
2867         uint32_t i = 0;
2868         const char *printername;
2869         struct policy_handle hnd;
2870         uint32_t value_offered = 0;
2871         const char *value_name = NULL;
2872         uint32_t value_needed;
2873         enum winreg_Type type;
2874         uint8_t *data = NULL;
2875         uint32_t data_offered = 0;
2876         uint32_t data_needed;
2877
2878         if (argc != 2) {
2879                 printf("Usage: %s printername\n", argv[0]);
2880                 return WERR_OK;
2881         }
2882
2883         /* Open printer handle */
2884
2885         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2886
2887         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2888                                                printername,
2889                                                SEC_FLAG_MAXIMUM_ALLOWED,
2890                                                &hnd);
2891         if (!W_ERROR_IS_OK(result)) {
2892                 goto done;
2893         }
2894
2895         /* Enumerate data */
2896
2897         status = rpccli_spoolss_EnumPrinterData(cli, mem_ctx,
2898                                                 &hnd,
2899                                                 i,
2900                                                 value_name,
2901                                                 value_offered,
2902                                                 &value_needed,
2903                                                 &type,
2904                                                 data,
2905                                                 data_offered,
2906                                                 &data_needed,
2907                                                 &result);
2908
2909         if (!NT_STATUS_IS_OK(status)) {
2910                 result = ntstatus_to_werror(status);
2911                 goto done;
2912         }
2913
2914         if (!W_ERROR_IS_OK(result)) {
2915                 goto done;
2916         }
2917
2918         data_offered    = data_needed;
2919         value_offered   = value_needed;
2920         data            = talloc_zero_array(mem_ctx, uint8_t, data_needed);
2921         value_name      = talloc_zero_array(mem_ctx, char, value_needed);
2922
2923         while (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(result)) {
2924
2925                 status = rpccli_spoolss_EnumPrinterData(cli, mem_ctx,
2926                                                         &hnd,
2927                                                         i++,
2928                                                         value_name,
2929                                                         value_offered,
2930                                                         &value_needed,
2931                                                         &type,
2932                                                         data,
2933                                                         data_offered,
2934                                                         &data_needed,
2935                                                         &result);
2936                 if (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(result)) {
2937                         struct regval_blob *v;
2938
2939                         v = regval_compose(talloc_tos(),
2940                                            value_name,
2941                                            type,
2942                                            data,
2943                                            data_offered);
2944                         if (v == NULL) {
2945                                 result = WERR_NOMEM;
2946                                 goto done;
2947                         }
2948
2949                         display_reg_value(v);
2950                         talloc_free(v);
2951                 }
2952         }
2953
2954         if (W_ERROR_V(result) == ERRnomoreitems) {
2955                 result = W_ERROR(ERRsuccess);
2956         }
2957
2958 done:
2959         if (is_valid_policy_hnd(&hnd)) {
2960                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
2961         }
2962
2963         return result;
2964 }
2965
2966 /****************************************************************************
2967 ****************************************************************************/
2968
2969 static WERROR cmd_spoolss_enum_data_ex( struct rpc_pipe_client *cli,
2970                                           TALLOC_CTX *mem_ctx, int argc,
2971                                           const char **argv)
2972 {
2973         WERROR result;
2974         uint32_t i;
2975         const char *printername;
2976         struct policy_handle hnd;
2977         uint32_t count;
2978         struct spoolss_PrinterEnumValues *info;
2979
2980         if (argc != 3) {
2981                 printf("Usage: %s printername <keyname>\n", argv[0]);
2982                 return WERR_OK;
2983         }
2984
2985         /* Open printer handle */
2986
2987         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
2988
2989         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
2990                                                printername,
2991                                                SEC_FLAG_MAXIMUM_ALLOWED,
2992                                                &hnd);
2993         if (!W_ERROR_IS_OK(result)) {
2994                 goto done;
2995         }
2996
2997         /* Enumerate subkeys */
2998
2999         result = rpccli_spoolss_enumprinterdataex(cli, mem_ctx,
3000                                                   &hnd,
3001                                                   argv[2],
3002                                                   0,
3003                                                   &count,
3004                                                   &info);
3005         if (!W_ERROR_IS_OK(result)) {
3006                 goto done;
3007         }
3008
3009         for (i=0; i < count; i++) {
3010                 display_printer_data(info[i].value_name,
3011                                      info[i].type,
3012                                      info[i].data->data,
3013                                      info[i].data->length);
3014         }
3015
3016  done:
3017         if (is_valid_policy_hnd(&hnd)) {
3018                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
3019         }
3020
3021         return result;
3022 }
3023
3024 /****************************************************************************
3025 ****************************************************************************/
3026
3027 static WERROR cmd_spoolss_enum_printerkey(struct rpc_pipe_client *cli,
3028                                           TALLOC_CTX *mem_ctx, int argc,
3029                                           const char **argv)
3030 {
3031         WERROR result;
3032         const char *printername;
3033         const char *keyname = NULL;
3034         struct policy_handle hnd;
3035         const char **key_buffer = NULL;
3036         int i;
3037         uint32_t offered = 0;
3038
3039         if (argc < 2 || argc > 4) {
3040                 printf("Usage: %s printername [keyname] [offered]\n", argv[0]);
3041                 return WERR_OK;
3042         }
3043
3044         if (argc >= 3) {
3045                 keyname = argv[2];
3046         } else {
3047                 keyname = "";
3048         }
3049
3050         if (argc == 4) {
3051                 offered = atoi(argv[3]);
3052         }
3053
3054         /* Open printer handle */
3055
3056         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
3057
3058         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
3059                                                printername,
3060                                                SEC_FLAG_MAXIMUM_ALLOWED,
3061                                                &hnd);
3062         if (!W_ERROR_IS_OK(result)) {
3063                 goto done;
3064         }
3065
3066         /* Enumerate subkeys */
3067
3068         result = rpccli_spoolss_enumprinterkey(cli, mem_ctx,
3069                                                &hnd,
3070                                                keyname,
3071                                                &key_buffer,
3072                                                offered);
3073
3074         if (!W_ERROR_IS_OK(result)) {
3075                 goto done;
3076         }
3077
3078         for (i=0; key_buffer && key_buffer[i]; i++) {
3079                 printf("%s\n", key_buffer[i]);
3080         }
3081
3082  done:
3083
3084         if (is_valid_policy_hnd(&hnd)) {
3085                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
3086         }
3087
3088         return result;
3089 }
3090
3091 /****************************************************************************
3092 ****************************************************************************/
3093
3094 static WERROR cmd_spoolss_rffpcnex(struct rpc_pipe_client *cli,
3095                                      TALLOC_CTX *mem_ctx, int argc,
3096                                      const char **argv)
3097 {
3098         const char *printername;
3099         const char *clientname;
3100         struct policy_handle hnd;
3101         WERROR result;
3102         NTSTATUS status;
3103         struct spoolss_NotifyOption option;
3104
3105         if (argc != 2) {
3106                 printf("Usage: %s printername\n", argv[0]);
3107                 result = WERR_OK;
3108                 goto done;
3109         }
3110
3111         /* Open printer */
3112
3113         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
3114
3115         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
3116                                                printername,
3117                                                SEC_FLAG_MAXIMUM_ALLOWED,
3118                                                &hnd);
3119         if (!W_ERROR_IS_OK(result)) {
3120                 printf("Error opening %s\n", argv[1]);
3121                 goto done;
3122         }
3123
3124         /* Create spool options */
3125
3126         option.version = 2;
3127         option.count = 2;
3128
3129         option.types = talloc_array(mem_ctx, struct spoolss_NotifyOptionType, 2);
3130         if (option.types == NULL) {
3131                 result = WERR_NOMEM;
3132                 goto done;
3133         }
3134
3135         option.types[0].type = PRINTER_NOTIFY_TYPE;
3136         option.types[0].count = 1;
3137         option.types[0].fields = talloc_array(mem_ctx, union spoolss_Field, 1);
3138         if (option.types[0].fields == NULL) {
3139                 result = WERR_NOMEM;
3140                 goto done;
3141         }
3142         option.types[0].fields[0].field = PRINTER_NOTIFY_FIELD_SERVER_NAME;
3143
3144         option.types[1].type = JOB_NOTIFY_TYPE;
3145         option.types[1].count = 1;
3146         option.types[1].fields = talloc_array(mem_ctx, union spoolss_Field, 1);
3147         if (option.types[1].fields == NULL) {
3148                 result = WERR_NOMEM;
3149                 goto done;
3150         }
3151         option.types[1].fields[0].field = JOB_NOTIFY_FIELD_PRINTER_NAME;
3152
3153         clientname = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
3154         if (!clientname) {
3155                 result = WERR_NOMEM;
3156                 goto done;
3157         }
3158
3159         /* Send rffpcnex */
3160
3161         status = rpccli_spoolss_RemoteFindFirstPrinterChangeNotifyEx(cli, mem_ctx,
3162                                                                      &hnd,
3163                                                                      0,
3164                                                                      0,
3165                                                                      clientname,
3166                                                                      123,
3167                                                                      &option,
3168                                                                      &result);
3169         if (!W_ERROR_IS_OK(result)) {
3170                 printf("Error rffpcnex %s\n", argv[1]);
3171                 goto done;
3172         }
3173
3174 done:
3175         if (is_valid_policy_hnd(&hnd))
3176                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &hnd, NULL);
3177
3178         return result;
3179 }
3180
3181 /****************************************************************************
3182 ****************************************************************************/
3183
3184 static bool compare_printer( struct rpc_pipe_client *cli1, struct policy_handle *hnd1,
3185                              struct rpc_pipe_client *cli2, struct policy_handle *hnd2 )
3186 {
3187         union spoolss_PrinterInfo info1, info2;
3188         WERROR werror;
3189         TALLOC_CTX *mem_ctx = talloc_init("compare_printer");
3190
3191         printf("Retrieving printer propertiesfor %s...", cli1->desthost);
3192         werror = rpccli_spoolss_getprinter(cli1, mem_ctx,
3193                                            hnd1,
3194                                            2,
3195                                            0,
3196                                            &info1);
3197         if ( !W_ERROR_IS_OK(werror) ) {
3198                 printf("failed (%s)\n", win_errstr(werror));
3199                 talloc_destroy(mem_ctx);
3200                 return false;
3201         }
3202         printf("ok\n");
3203
3204         printf("Retrieving printer properties for %s...", cli2->desthost);
3205         werror = rpccli_spoolss_getprinter(cli2, mem_ctx,
3206                                            hnd2,
3207                                            2,
3208                                            0,
3209                                            &info2);
3210         if ( !W_ERROR_IS_OK(werror) ) {
3211                 printf("failed (%s)\n", win_errstr(werror));
3212                 talloc_destroy(mem_ctx);
3213                 return false;
3214         }
3215         printf("ok\n");
3216
3217         talloc_destroy(mem_ctx);
3218
3219         return true;
3220 }
3221
3222 /****************************************************************************
3223 ****************************************************************************/
3224
3225 static bool compare_printer_secdesc( struct rpc_pipe_client *cli1, struct policy_handle *hnd1,
3226                                      struct rpc_pipe_client *cli2, struct policy_handle *hnd2 )
3227 {
3228         union spoolss_PrinterInfo info1, info2;
3229         WERROR werror;
3230         TALLOC_CTX *mem_ctx = talloc_init("compare_printer_secdesc");
3231         struct security_descriptor *sd1, *sd2;
3232         bool result = true;
3233
3234
3235         printf("Retrieving printer security for %s...", cli1->desthost);
3236         werror = rpccli_spoolss_getprinter(cli1, mem_ctx,
3237                                            hnd1,
3238                                            3,
3239                                            0,
3240                                            &info1);
3241         if ( !W_ERROR_IS_OK(werror) ) {
3242                 printf("failed (%s)\n", win_errstr(werror));
3243                 result = false;
3244                 goto done;
3245         }
3246         printf("ok\n");
3247
3248         printf("Retrieving printer security for %s...", cli2->desthost);
3249         werror = rpccli_spoolss_getprinter(cli2, mem_ctx,
3250                                            hnd2,
3251                                            3,
3252                                            0,
3253                                            &info2);
3254         if ( !W_ERROR_IS_OK(werror) ) {
3255                 printf("failed (%s)\n", win_errstr(werror));
3256                 result = false;
3257                 goto done;
3258         }
3259         printf("ok\n");
3260
3261
3262         printf("++ ");
3263
3264         sd1 = info1.info3.secdesc;
3265         sd2 = info2.info3.secdesc;
3266
3267         if ( (sd1 != sd2) && ( !sd1 || !sd2 ) ) {
3268                 printf("NULL secdesc!\n");
3269                 result = false;
3270                 goto done;
3271         }
3272
3273         if (!security_descriptor_equal( sd1, sd2 ) ) {
3274                 printf("Security Descriptors *not* equal!\n");
3275                 result = false;
3276                 goto done;
3277         }
3278
3279         printf("Security descriptors match\n");
3280
3281 done:
3282         talloc_destroy(mem_ctx);
3283         return result;
3284 }
3285
3286
3287 /****************************************************************************
3288 ****************************************************************************/
3289
3290 extern struct user_auth_info *rpcclient_auth_info;
3291
3292 static WERROR cmd_spoolss_printercmp(struct rpc_pipe_client *cli,
3293                                      TALLOC_CTX *mem_ctx, int argc,
3294                                      const char **argv)
3295 {
3296         const char *printername;
3297         char *printername_path = NULL;
3298         struct cli_state *cli_server2 = NULL;
3299         struct rpc_pipe_client *cli2 = NULL;
3300         struct policy_handle hPrinter1, hPrinter2;
3301         NTSTATUS nt_status;
3302         WERROR werror;
3303
3304         if ( argc != 3 )  {
3305                 printf("Usage: %s <printer> <server>\n", argv[0]);
3306                 return WERR_OK;
3307         }
3308
3309         printername = argv[1];
3310
3311         /* first get the connection to the remote server */
3312
3313         nt_status = cli_full_connection(&cli_server2, global_myname(), argv[2],
3314                                         NULL, 0,
3315                                         "IPC$", "IPC",
3316                                         get_cmdline_auth_info_username(rpcclient_auth_info),
3317                                         lp_workgroup(),
3318                                         get_cmdline_auth_info_password(rpcclient_auth_info),
3319                                         get_cmdline_auth_info_use_kerberos(rpcclient_auth_info) ? CLI_FULL_CONNECTION_USE_KERBEROS : 0,
3320                                         get_cmdline_auth_info_signing_state(rpcclient_auth_info));
3321
3322         if ( !NT_STATUS_IS_OK(nt_status) )
3323                 return WERR_GENERAL_FAILURE;
3324
3325         nt_status = cli_rpc_pipe_open_noauth(cli_server2, &ndr_table_spoolss.syntax_id,
3326                                              &cli2);
3327         if (!NT_STATUS_IS_OK(nt_status)) {
3328                 printf("failed to open spoolss pipe on server %s (%s)\n",
3329                         argv[2], nt_errstr(nt_status));
3330                 return WERR_GENERAL_FAILURE;
3331         }
3332
3333         /* now open up both printers */
3334
3335         RPCCLIENT_PRINTERNAME(printername_path, cli, printername);
3336
3337         printf("Opening %s...", printername_path);
3338
3339         werror = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
3340                                                printername_path,
3341                                                PRINTER_ALL_ACCESS,
3342                                                &hPrinter1);
3343         if ( !W_ERROR_IS_OK(werror) ) {
3344                 printf("failed (%s)\n", win_errstr(werror));
3345                 goto done;
3346         }
3347         printf("ok\n");
3348
3349         RPCCLIENT_PRINTERNAME(printername_path, cli2, printername);
3350
3351         printf("Opening %s...", printername_path);
3352         werror = rpccli_spoolss_openprinter_ex(cli2, mem_ctx,
3353                                                printername_path,
3354                                                PRINTER_ALL_ACCESS,
3355                                                &hPrinter2);
3356         if ( !W_ERROR_IS_OK(werror) ) {
3357                  printf("failed (%s)\n", win_errstr(werror));
3358                 goto done;
3359         }
3360         printf("ok\n");
3361
3362         compare_printer( cli, &hPrinter1, cli2, &hPrinter2 );
3363         compare_printer_secdesc( cli, &hPrinter1, cli2, &hPrinter2 );
3364 #if 0
3365         compare_printerdata( cli_server1, &hPrinter1, cli_server2, &hPrinter2 );
3366 #endif
3367
3368
3369 done:
3370         /* cleanup */
3371
3372         printf("Closing printers...");
3373         rpccli_spoolss_ClosePrinter( cli, mem_ctx, &hPrinter1, NULL );
3374         rpccli_spoolss_ClosePrinter( cli2, mem_ctx, &hPrinter2, NULL );
3375         printf("ok\n");
3376
3377         /* close the second remote connection */
3378
3379         cli_shutdown( cli_server2 );
3380         return WERR_OK;
3381 }
3382
3383 static void display_proc_info1(struct spoolss_PrintProcessorInfo1 *r)
3384 {
3385         printf("print_processor_name: %s\n", r->print_processor_name);
3386 }
3387
3388 static WERROR cmd_spoolss_enum_procs(struct rpc_pipe_client *cli,
3389                                      TALLOC_CTX *mem_ctx, int argc,
3390                                      const char **argv)
3391 {
3392         WERROR werror;
3393         const char *environment = SPOOLSS_ARCHITECTURE_NT_X86;
3394         uint32_t num_procs, level = 1, i;
3395         union spoolss_PrintProcessorInfo *procs;
3396
3397         /* Parse the command arguments */
3398
3399         if (argc < 1 || argc > 4) {
3400                 printf ("Usage: %s [environment] [level]\n", argv[0]);
3401                 return WERR_OK;
3402         }
3403
3404         if (argc >= 2) {
3405                 environment = argv[1];
3406         }
3407
3408         if (argc == 3) {
3409                 level = atoi(argv[2]);
3410         }
3411
3412         /* Enumerate Print Processors */
3413
3414         werror = rpccli_spoolss_enumprintprocessors(cli, mem_ctx,
3415                                                     cli->srv_name_slash,
3416                                                     environment,
3417                                                     level,
3418                                                     0,
3419                                                     &num_procs,
3420                                                     &procs);
3421         if (!W_ERROR_IS_OK(werror))
3422                 goto done;
3423
3424         /* Display output */
3425
3426         for (i = 0; i < num_procs; i++) {
3427                 switch (level) {
3428                 case 1:
3429                         display_proc_info1(&procs[i].info1);
3430                         break;
3431                 }
3432         }
3433
3434  done:
3435         return werror;
3436 }
3437
3438 static void display_proc_data_types_info1(struct spoolss_PrintProcDataTypesInfo1 *r)
3439 {
3440         printf("name_array: %s\n", r->name_array);
3441 }
3442
3443 static WERROR cmd_spoolss_enum_proc_data_types(struct rpc_pipe_client *cli,
3444                                                TALLOC_CTX *mem_ctx, int argc,
3445                                                const char **argv)
3446 {
3447         WERROR werror;
3448         const char *print_processor_name = "winprint";
3449         uint32_t num_procs, level = 1, i;
3450         union spoolss_PrintProcDataTypesInfo *procs;
3451
3452         /* Parse the command arguments */
3453
3454         if (argc < 1 || argc > 4) {
3455                 printf ("Usage: %s [environment] [level]\n", argv[0]);
3456                 return WERR_OK;
3457         }
3458
3459         if (argc >= 2) {
3460                 print_processor_name = argv[1];
3461         }
3462
3463         if (argc == 3) {
3464                 level = atoi(argv[2]);
3465         }
3466
3467         /* Enumerate Print Processor Data Types */
3468
3469         werror = rpccli_spoolss_enumprintprocessordatatypes(cli, mem_ctx,
3470                                                             cli->srv_name_slash,
3471                                                             print_processor_name,
3472                                                             level,
3473                                                             0,
3474                                                             &num_procs,
3475                                                             &procs);
3476         if (!W_ERROR_IS_OK(werror))
3477                 goto done;
3478
3479         /* Display output */
3480
3481         for (i = 0; i < num_procs; i++) {
3482                 switch (level) {
3483                 case 1:
3484                         display_proc_data_types_info1(&procs[i].info1);
3485                         break;
3486                 }
3487         }
3488
3489  done:
3490         return werror;
3491 }
3492
3493 static void display_monitor1(const struct spoolss_MonitorInfo1 *r)
3494 {
3495         printf("monitor_name: %s\n", r->monitor_name);
3496 }
3497
3498 static void display_monitor2(const struct spoolss_MonitorInfo2 *r)
3499 {
3500         printf("monitor_name: %s\n", r->monitor_name);
3501         printf("environment: %s\n", r->environment);
3502         printf("dll_name: %s\n", r->dll_name);
3503 }
3504
3505 static WERROR cmd_spoolss_enum_monitors(struct rpc_pipe_client *cli,
3506                                         TALLOC_CTX *mem_ctx, int argc,
3507                                         const char **argv)
3508 {
3509         WERROR werror;
3510         uint32_t count, level = 1, i;
3511         union spoolss_MonitorInfo *info;
3512
3513         /* Parse the command arguments */
3514
3515         if (argc > 2) {
3516                 printf("Usage: %s [level]\n", argv[0]);
3517                 return WERR_OK;
3518         }
3519
3520         if (argc == 2) {
3521                 level = atoi(argv[1]);
3522         }
3523
3524         /* Enumerate Print Monitors */
3525
3526         werror = rpccli_spoolss_enummonitors(cli, mem_ctx,
3527                                              cli->srv_name_slash,
3528                                              level,
3529                                              0,
3530                                              &count,
3531                                              &info);
3532         if (!W_ERROR_IS_OK(werror)) {
3533                 goto done;
3534         }
3535
3536         /* Display output */
3537
3538         for (i = 0; i < count; i++) {
3539                 switch (level) {
3540                 case 1:
3541                         display_monitor1(&info[i].info1);
3542                         break;
3543                 case 2:
3544                         display_monitor2(&info[i].info2);
3545                         break;
3546                 }
3547         }
3548
3549  done:
3550         return werror;
3551 }
3552
3553 static WERROR cmd_spoolss_create_printer_ic(struct rpc_pipe_client *cli,
3554                                             TALLOC_CTX *mem_ctx, int argc,
3555                                             const char **argv)
3556 {
3557         WERROR result;
3558         NTSTATUS status;
3559         struct policy_handle handle, gdi_handle;
3560         const char *printername;
3561         struct spoolss_DevmodeContainer devmode_ctr;
3562
3563         RPCCLIENT_PRINTERNAME(printername, cli, argv[1]);
3564
3565         result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
3566                                                printername,
3567                                                SEC_FLAG_MAXIMUM_ALLOWED,
3568                                                &handle);
3569         if (!W_ERROR_IS_OK(result)) {
3570                 return result;
3571         }
3572
3573         ZERO_STRUCT(devmode_ctr);
3574
3575         status = rpccli_spoolss_CreatePrinterIC(cli, mem_ctx,
3576                                                 &handle,
3577                                                 &gdi_handle,
3578                                                 &devmode_ctr,
3579                                                 &result);
3580         if (!W_ERROR_IS_OK(result)) {
3581                 goto done;
3582         }
3583
3584  done:
3585         if (is_valid_policy_hnd(&gdi_handle)) {
3586                 rpccli_spoolss_DeletePrinterIC(cli, mem_ctx, &gdi_handle, NULL);
3587         }
3588         if (is_valid_policy_hnd(&handle)) {
3589                 rpccli_spoolss_ClosePrinter(cli, mem_ctx, &handle, NULL);
3590         }
3591
3592         return result;
3593 }
3594
3595 /* List of commands exported by this module */
3596 struct cmd_set spoolss_commands[] = {
3597
3598         { "SPOOLSS"  },
3599
3600         { "adddriver",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterdriver,   &ndr_table_spoolss.syntax_id, NULL, "Add a print driver",                  "" },
3601         { "addprinter",         RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterex,       &ndr_table_spoolss.syntax_id, NULL, "Add a printer",                       "" },
3602         { "deldriver",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_deletedriver,       &ndr_table_spoolss.syntax_id, NULL, "Delete a printer driver",             "" },
3603         { "deldriverex",        RPC_RTYPE_WERROR, NULL, cmd_spoolss_deletedriverex,     &ndr_table_spoolss.syntax_id, NULL, "Delete a printer driver with files",  "" },
3604         { "enumdata",           RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data,          &ndr_table_spoolss.syntax_id, NULL, "Enumerate printer data",              "" },
3605         { "enumdataex",         RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data_ex,       &ndr_table_spoolss.syntax_id, NULL, "Enumerate printer data for a key",    "" },
3606         { "enumkey",            RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printerkey,    &ndr_table_spoolss.syntax_id, NULL, "Enumerate printer keys",              "" },
3607         { "enumjobs",           RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_jobs,          &ndr_table_spoolss.syntax_id, NULL, "Enumerate print jobs",                "" },
3608         { "getjob",             RPC_RTYPE_WERROR, NULL, cmd_spoolss_get_job,            &ndr_table_spoolss.syntax_id, NULL, "Get print job",                       "" },
3609         { "setjob",             RPC_RTYPE_WERROR, NULL, cmd_spoolss_set_job,            &ndr_table_spoolss.syntax_id, NULL, "Set print job",                       "" },
3610         { "enumports",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_ports,         &ndr_table_spoolss.syntax_id, NULL, "Enumerate printer ports",             "" },
3611         { "enumdrivers",        RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_drivers,       &ndr_table_spoolss.syntax_id, NULL, "Enumerate installed printer drivers", "" },
3612         { "enumprinters",       RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printers,      &ndr_table_spoolss.syntax_id, NULL, "Enumerate printers",                  "" },
3613         { "getdata",            RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdata,     &ndr_table_spoolss.syntax_id, NULL, "Get print driver data",               "" },
3614         { "getdataex",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdataex,   &ndr_table_spoolss.syntax_id, NULL, "Get printer driver data with keyname", ""},
3615         { "getdriver",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriver,          &ndr_table_spoolss.syntax_id, NULL, "Get print driver information",        "" },
3616         { "getdriverdir",       RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriverdir,       &ndr_table_spoolss.syntax_id, NULL, "Get print driver upload directory",   "" },
3617         { "getprinter",         RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinter,         &ndr_table_spoolss.syntax_id, NULL, "Get printer info",                    "" },
3618         { "openprinter",        RPC_RTYPE_WERROR, NULL, cmd_spoolss_open_printer,       &ndr_table_spoolss.syntax_id, NULL, "Open printer handle",                 "" },
3619         { "openprinter_ex",     RPC_RTYPE_WERROR, NULL, cmd_spoolss_open_printer_ex,    &ndr_table_spoolss.syntax_id, NULL, "Open printer handle",                 "" },
3620         { "setdriver",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_setdriver,          &ndr_table_spoolss.syntax_id, NULL, "Set printer driver",                  "" },
3621         { "getprintprocdir",    RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprintprocdir,    &ndr_table_spoolss.syntax_id, NULL, "Get print processor directory",       "" },
3622         { "addform",            RPC_RTYPE_WERROR, NULL, cmd_spoolss_addform,            &ndr_table_spoolss.syntax_id, NULL, "Add form",                            "" },
3623         { "setform",            RPC_RTYPE_WERROR, NULL, cmd_spoolss_setform,            &ndr_table_spoolss.syntax_id, NULL, "Set form",                            "" },
3624         { "getform",            RPC_RTYPE_WERROR, NULL, cmd_spoolss_getform,            &ndr_table_spoolss.syntax_id, NULL, "Get form",                            "" },
3625         { "deleteform",         RPC_RTYPE_WERROR, NULL, cmd_spoolss_deleteform,         &ndr_table_spoolss.syntax_id, NULL, "Delete form",                         "" },
3626         { "enumforms",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_forms,         &ndr_table_spoolss.syntax_id, NULL, "Enumerate forms",                     "" },
3627         { "setprinter",         RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinter,         &ndr_table_spoolss.syntax_id, NULL, "Set printer comment",                 "" },
3628         { "setprintername",     RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprintername,     &ndr_table_spoolss.syntax_id, NULL, "Set printername",                 "" },
3629         { "setprinterdata",     RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinterdata,     &ndr_table_spoolss.syntax_id, NULL, "Set REG_SZ printer data",             "" },
3630         { "rffpcnex",           RPC_RTYPE_WERROR, NULL, cmd_spoolss_rffpcnex,           &ndr_table_spoolss.syntax_id, NULL, "Rffpcnex test", "" },
3631         { "printercmp",         RPC_RTYPE_WERROR, NULL, cmd_spoolss_printercmp,         &ndr_table_spoolss.syntax_id, NULL, "Printer comparison test", "" },
3632         { "enumprocs",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_procs,         &ndr_table_spoolss.syntax_id, NULL, "Enumerate Print Processors",          "" },
3633         { "enumprocdatatypes",  RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_proc_data_types, &ndr_table_spoolss.syntax_id, NULL, "Enumerate Print Processor Data Types", "" },
3634         { "enummonitors",       RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_monitors,      &ndr_table_spoolss.syntax_id, NULL, "Enumerate Print Monitors", "" },
3635         { "createprinteric",    RPC_RTYPE_WERROR, NULL, cmd_spoolss_create_printer_ic,  &ndr_table_spoolss.syntax_id, NULL, "Create Printer IC", "" },
3636
3637         { NULL }
3638 };