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