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
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 #include "includes.h"
  25 #include "rpcclient.h"
  26
  27 struct table_node {
  28         const char      *long_archi;
  29         const char      *short_archi;
  30         int     version;
  31 };
  32
  33 /* The version int is used by getdrivers.  Note that
  34    all architecture strings that support mutliple
  35    versions must be grouped together since enumdrivers
  36    uses this property to prevent issuing multiple
  37    enumdriver calls for the same arch */
  38
  39
  40 static const struct table_node archi_table[]= {
  41
  42         {"Windows 4.0",          "WIN40",       0 },
  43         {"Windows NT x86",       "W32X86",      2 },
  44         {"Windows NT x86",       "W32X86",      3 },
  45         {"Windows NT R4000",     "W32MIPS",     2 },
  46         {"Windows NT Alpha_AXP", "W32ALPHA",    2 },
  47         {"Windows NT PowerPC",   "W32PPC",      2 },
  48         {"Windows IA64",         "IA64",        3 },
  49         {"Windows x64",          "x64",         3 },
  50         {NULL,                   "",            -1 }
  51 };
  52
  53 /**
  54  * @file
  55  *
  56  * rpcclient module for SPOOLSS rpc pipe.
  57  *
  58  * This generally just parses and checks command lines, and then calls
  59  * a cli_spoolss function.
  60  **/
  61
  62 /****************************************************************************
  63  function to do the mapping between the long architecture name and
  64  the short one.
  65 ****************************************************************************/
  66
  67 static const char *cmd_spoolss_get_short_archi(const char *long_archi)
  68 {
  69         int i=-1;
  70
  71         DEBUG(107,("Getting architecture dependant directory\n"));
  72         do {
  73                 i++;
  74         } while ( (archi_table[i].long_archi!=NULL ) &&
  75                   StrCaseCmp(long_archi, archi_table[i].long_archi) );
  76
  77         if (archi_table[i].long_archi==NULL) {
  78                 DEBUGADD(10,("Unknown architecture [%s] !\n", long_archi));
  79                 return NULL;
  80         }
  81
  82         /* this might be client code - but shouldn't this be an fstrcpy etc? */
  83
  84
  85         DEBUGADD(108,("index: [%d]\n", i));
  86         DEBUGADD(108,("long architecture: [%s]\n", archi_table[i].long_archi));
  87         DEBUGADD(108,("short architecture: [%s]\n", archi_table[i].short_archi));
  88
  89         return archi_table[i].short_archi;
  90 }
  91
  92 /****************************************************************************
  93 ****************************************************************************/
  94
  95 static WERROR cmd_spoolss_open_printer_ex(struct rpc_pipe_client *cli,
  96                                             TALLOC_CTX *mem_ctx,
  97                                             int argc, const char **argv)
  98 {
  99         WERROR          werror;
 100         fstring         printername;
 101         fstring         servername, user;
 102         POLICY_HND      hnd;
 103
 104         if (argc != 2) {
 105                 printf("Usage: %s <printername>\n", argv[0]);
 106                 return WERR_OK;
 107         }
 108
 109         if (!cli)
 110             return WERR_GENERAL_FAILURE;
 111
 112         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
 113         strupper_m(servername);
 114         fstrcpy(user, cli->auth->user_name);
 115         fstrcpy(printername, argv[1]);
 116
 117         /* Open the printer handle */
 118
 119         werror = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
 120                                              "", PRINTER_ALL_ACCESS,
 121                                              servername, user, &hnd);
 122
 123         if (W_ERROR_IS_OK(werror)) {
 124                 printf("Printer %s opened successfully\n", printername);
 125                 werror = rpccli_spoolss_close_printer(cli, mem_ctx, &hnd);
 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_info_0(PRINTER_INFO_0 *i0)
 141 {
 142         fstring name = "";
 143         fstring servername = "";
 144
 145         if (!i0)
 146                 return;
 147
 148         rpcstr_pull(name, i0->printername.buffer, sizeof(name), -1, STR_TERMINATE);
 149
 150         rpcstr_pull(servername, i0->servername.buffer, sizeof(servername), -1,STR_TERMINATE);
 151
 152         printf("\tprintername:[%s]\n", name);
 153         printf("\tservername:[%s]\n", servername);
 154         printf("\tcjobs:[0x%x]\n", i0->cjobs);
 155         printf("\ttotal_jobs:[0x%x]\n", i0->total_jobs);
 156
 157         printf("\t:date: [%d]-[%d]-[%d] (%d)\n", i0->year, i0->month,
 158                i0->day, i0->dayofweek);
 159         printf("\t:time: [%d]-[%d]-[%d]-[%d]\n", i0->hour, i0->minute,
 160                i0->second, i0->milliseconds);
 161
 162         printf("\tglobal_counter:[0x%x]\n", i0->global_counter);
 163         printf("\ttotal_pages:[0x%x]\n", i0->total_pages);
 164
 165         printf("\tmajorversion:[0x%x]\n", i0->major_version);
 166         printf("\tbuildversion:[0x%x]\n", i0->build_version);
 167
 168         printf("\tunknown7:[0x%x]\n", i0->unknown7);
 169         printf("\tunknown8:[0x%x]\n", i0->unknown8);
 170         printf("\tunknown9:[0x%x]\n", i0->unknown9);
 171         printf("\tsession_counter:[0x%x]\n", i0->session_counter);
 172         printf("\tunknown11:[0x%x]\n", i0->unknown11);
 173         printf("\tprinter_errors:[0x%x]\n", i0->printer_errors);
 174         printf("\tunknown13:[0x%x]\n", i0->unknown13);
 175         printf("\tunknown14:[0x%x]\n", i0->unknown14);
 176         printf("\tunknown15:[0x%x]\n", i0->unknown15);
 177         printf("\tunknown16:[0x%x]\n", i0->unknown16);
 178         printf("\tchange_id:[0x%x]\n", i0->change_id);
 179         printf("\tunknown18:[0x%x]\n", i0->unknown18);
 180         printf("\tstatus:[0x%x]\n", i0->status);
 181         printf("\tunknown20:[0x%x]\n", i0->unknown20);
 182         printf("\tc_setprinter:[0x%x]\n", i0->c_setprinter);
 183         printf("\tunknown22:[0x%x]\n", i0->unknown22);
 184         printf("\tunknown23:[0x%x]\n", i0->unknown23);
 185         printf("\tunknown24:[0x%x]\n", i0->unknown24);
 186         printf("\tunknown25:[0x%x]\n", i0->unknown25);
 187         printf("\tunknown26:[0x%x]\n", i0->unknown26);
 188         printf("\tunknown27:[0x%x]\n", i0->unknown27);
 189         printf("\tunknown28:[0x%x]\n", i0->unknown28);
 190         printf("\tunknown29:[0x%x]\n", i0->unknown29);
 191
 192         printf("\n");
 193 }
 194
 195 /****************************************************************************
 196 ****************************************************************************/
 197
 198 static void display_print_info_1(PRINTER_INFO_1 *i1)
 199 {
 200         fstring desc = "";
 201         fstring name = "";
 202         fstring comm = "";
 203
 204         rpcstr_pull(desc, i1->description.buffer, sizeof(desc), -1,
 205                     STR_TERMINATE);
 206
 207         rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
 208         rpcstr_pull(comm, i1->comment.buffer, sizeof(comm), -1, STR_TERMINATE);
 209
 210         printf("\tflags:[0x%x]\n", i1->flags);
 211         printf("\tname:[%s]\n", name);
 212         printf("\tdescription:[%s]\n", desc);
 213         printf("\tcomment:[%s]\n", comm);
 214
 215         printf("\n");
 216 }
 217
 218 /****************************************************************************
 219 ****************************************************************************/
 220
 221 static void display_print_info_2(PRINTER_INFO_2 *i2)
 222 {
 223         fstring servername = "";
 224         fstring printername = "";
 225         fstring sharename = "";
 226         fstring portname = "";
 227         fstring drivername = "";
 228         fstring comment = "";
 229         fstring location = "";
 230         fstring sepfile = "";
 231         fstring printprocessor = "";
 232         fstring datatype = "";
 233         fstring parameters = "";
 234
 235         rpcstr_pull(servername, i2->servername.buffer,sizeof(servername), -1, STR_TERMINATE);
 236         rpcstr_pull(printername, i2->printername.buffer,sizeof(printername), -1, STR_TERMINATE);
 237         rpcstr_pull(sharename, i2->sharename.buffer,sizeof(sharename), -1, STR_TERMINATE);
 238         rpcstr_pull(portname, i2->portname.buffer,sizeof(portname), -1, STR_TERMINATE);
 239         rpcstr_pull(drivername, i2->drivername.buffer,sizeof(drivername), -1, STR_TERMINATE);
 240         rpcstr_pull(comment, i2->comment.buffer,sizeof(comment), -1, STR_TERMINATE);
 241         rpcstr_pull(location, i2->location.buffer,sizeof(location), -1, STR_TERMINATE);
 242         rpcstr_pull(sepfile, i2->sepfile.buffer,sizeof(sepfile), -1, STR_TERMINATE);
 243         rpcstr_pull(printprocessor, i2->printprocessor.buffer,sizeof(printprocessor), -1, STR_TERMINATE);
 244         rpcstr_pull(datatype, i2->datatype.buffer,sizeof(datatype), -1, STR_TERMINATE);
 245         rpcstr_pull(parameters, i2->parameters.buffer,sizeof(parameters), -1, STR_TERMINATE);
 246
 247         printf("\tservername:[%s]\n", servername);
 248         printf("\tprintername:[%s]\n", printername);
 249         printf("\tsharename:[%s]\n", sharename);
 250         printf("\tportname:[%s]\n", portname);
 251         printf("\tdrivername:[%s]\n", drivername);
 252         printf("\tcomment:[%s]\n", comment);
 253         printf("\tlocation:[%s]\n", location);
 254         printf("\tsepfile:[%s]\n", sepfile);
 255         printf("\tprintprocessor:[%s]\n", printprocessor);
 256         printf("\tdatatype:[%s]\n", datatype);
 257         printf("\tparameters:[%s]\n", parameters);
 258         printf("\tattributes:[0x%x]\n", i2->attributes);
 259         printf("\tpriority:[0x%x]\n", i2->priority);
 260         printf("\tdefaultpriority:[0x%x]\n", i2->defaultpriority);
 261         printf("\tstarttime:[0x%x]\n", i2->starttime);
 262         printf("\tuntiltime:[0x%x]\n", i2->untiltime);
 263         printf("\tstatus:[0x%x]\n", i2->status);
 264         printf("\tcjobs:[0x%x]\n", i2->cjobs);
 265         printf("\taverageppm:[0x%x]\n", i2->averageppm);
 266
 267         if (i2->secdesc)
 268                 display_sec_desc(i2->secdesc);
 269
 270         printf("\n");
 271 }
 272
 273 /****************************************************************************
 274 ****************************************************************************/
 275
 276 static void display_print_info_3(PRINTER_INFO_3 *i3)
 277 {
 278         display_sec_desc(i3->secdesc);
 279
 280         printf("\n");
 281 }
 282
 283 /****************************************************************************
 284 ****************************************************************************/
 285
 286 static void display_print_info_7(PRINTER_INFO_7 *i7)
 287 {
 288         fstring guid = "";
 289         rpcstr_pull(guid, i7->guid.buffer,sizeof(guid), -1, STR_TERMINATE);
 290         printf("\tguid:[%s]\n", guid);
 291         printf("\taction:[0x%x]\n", i7->action);
 292 }
 293
 294
 295 /****************************************************************************
 296 ****************************************************************************/
 297
 298 static WERROR cmd_spoolss_enum_printers(struct rpc_pipe_client *cli,
 299                                           TALLOC_CTX *mem_ctx,
 300                                           int argc, const char **argv)
 301 {
 302         WERROR                  result;
 303         uint32                  info_level = 1;
 304         PRINTER_INFO_CTR        ctr;
 305         uint32                  i = 0, num_printers;
 306         fstring name;
 307
 308         if (argc > 3)
 309         {
 310                 printf("Usage: %s [level] [name]\n", argv[0]);
 311                 return WERR_OK;
 312         }
 313
 314         if (argc >= 2)
 315                 info_level = atoi(argv[1]);
 316
 317         if (argc == 3)
 318                 fstrcpy(name, argv[2]);
 319         else {
 320                 slprintf(name, sizeof(name)-1, "\\\\%s", cli->desthost);
 321                 strupper_m(name);
 322         }
 323
 324         ZERO_STRUCT(ctr);
 325
 326         result = rpccli_spoolss_enum_printers(cli, mem_ctx, name, PRINTER_ENUM_LOCAL,
 327                 info_level, &num_printers, &ctr);
 328
 329         if (W_ERROR_IS_OK(result)) {
 330
 331                 if (!num_printers) {
 332                         printf ("No printers returned.\n");
 333                         goto done;
 334                 }
 335
 336                 for (i = 0; i < num_printers; i++) {
 337                         switch(info_level) {
 338                         case 0:
 339                                 display_print_info_0(&ctr.printers_0[i]);
 340                                 break;
 341                         case 1:
 342                                 display_print_info_1(&ctr.printers_1[i]);
 343                                 break;
 344                         case 2:
 345                                 display_print_info_2(&ctr.printers_2[i]);
 346                                 break;
 347                         case 3:
 348                                 display_print_info_3(&ctr.printers_3[i]);
 349                                 break;
 350                         default:
 351                                 printf("unknown info level %d\n", info_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(PORT_INFO_1 *i1)
 365 {
 366         fstring buffer;
 367
 368         rpcstr_pull(buffer, i1->port_name.buffer, sizeof(buffer), -1, STR_TERMINATE);
 369         printf("\tPort Name:\t[%s]\n", buffer);
 370 }
 371
 372 /****************************************************************************
 373 ****************************************************************************/
 374
 375 static void display_port_info_2(PORT_INFO_2 *i2)
 376 {
 377         fstring buffer;
 378
 379         rpcstr_pull(buffer, i2->port_name.buffer, sizeof(buffer), -1, STR_TERMINATE);
 380         printf("\tPort Name:\t[%s]\n", buffer);
 381         rpcstr_pull(buffer, i2->monitor_name.buffer, sizeof(buffer), -1, STR_TERMINATE);
 382
 383         printf("\tMonitor Name:\t[%s]\n", buffer);
 384         rpcstr_pull(buffer, i2->description.buffer, sizeof(buffer), -1, STR_TERMINATE);
 385
 386         printf("\tDescription:\t[%s]\n", buffer);
 387         printf("\tPort Type:\t" );
 388         if ( i2->port_type ) {
 389                 int comma = 0; /* hack */
 390                 printf( "[" );
 391                 if ( i2->port_type & PORT_TYPE_READ ) {
 392                         printf( "Read" );
 393                         comma = 1;
 394                 }
 395                 if ( i2->port_type & PORT_TYPE_WRITE ) {
 396                         printf( "%sWrite", comma ? ", " : "" );
 397                         comma = 1;
 398                 }
 399                 /* These two have slightly different interpretations
 400                  on 95/98/ME but I'm disregarding that for now */
 401                 if ( i2->port_type & PORT_TYPE_REDIRECTED ) {
 402                         printf( "%sRedirected", comma ? ", " : "" );
 403                         comma = 1;
 404                 }
 405                 if ( i2->port_type & PORT_TYPE_NET_ATTACHED ) {
 406                         printf( "%sNet-Attached", comma ? ", " : "" );
 407                 }
 408                 printf( "]\n" );
 409         } else {
 410                 printf( "[Unset]\n" );
 411         }
 412         printf("\tReserved:\t[%d]\n", i2->reserved);
 413         printf("\n");
 414 }
 415
 416 /****************************************************************************
 417 ****************************************************************************/
 418
 419 static WERROR cmd_spoolss_enum_ports(struct rpc_pipe_client *cli,
 420                                        TALLOC_CTX *mem_ctx, int argc,
 421                                        const char **argv)
 422 {
 423         WERROR                  result;
 424         uint32                  info_level = 1;
 425         PORT_INFO_CTR           ctr;
 426         uint32                  returned;
 427
 428         if (argc > 2) {
 429                 printf("Usage: %s [level]\n", argv[0]);
 430                 return WERR_OK;
 431         }
 432
 433         if (argc == 2)
 434                 info_level = atoi(argv[1]);
 435
 436         /* Enumerate ports */
 437
 438         ZERO_STRUCT(ctr);
 439
 440         result = rpccli_spoolss_enum_ports(cli, mem_ctx, info_level, &returned, &ctr);
 441
 442         if (W_ERROR_IS_OK(result)) {
 443                 int i;
 444
 445                 for (i = 0; i < returned; i++) {
 446                         switch (info_level) {
 447                         case 1:
 448                                 display_port_info_1(&ctr.port.info_1[i]);
 449                                 break;
 450                         case 2:
 451                                 display_port_info_2(&ctr.port.info_2[i]);
 452                                 break;
 453                         default:
 454                                 printf("unknown info level %d\n", info_level);
 455                                 break;
 456                         }
 457                 }
 458         }
 459
 460         return result;
 461 }
 462
 463 /****************************************************************************
 464 ****************************************************************************/
 465
 466 static WERROR cmd_spoolss_setprinter(struct rpc_pipe_client *cli,
 467                                        TALLOC_CTX *mem_ctx,
 468                                        int argc, const char **argv)
 469 {
 470         POLICY_HND      pol;
 471         WERROR          result;
 472         uint32          info_level = 2;
 473         bool            opened_hnd = False;
 474         PRINTER_INFO_CTR ctr;
 475         fstring         printername,
 476                         servername,
 477                         user,
 478                         comment;
 479
 480         if (argc == 1 || argc > 3) {
 481                 printf("Usage: %s printername comment\n", argv[0]);
 482
 483                 return WERR_OK;
 484         }
 485
 486         /* Open a printer handle */
 487         if (argc == 3) {
 488                 fstrcpy(comment, argv[2]);
 489         }
 490
 491         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
 492         strupper_m(servername);
 493         slprintf(printername, sizeof(servername)-1, "%s\\%s", servername, argv[1]);
 494         fstrcpy(user, cli->auth->user_name);
 495
 496         /* get a printer handle */
 497         result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
 498                                 PRINTER_ALL_ACCESS, servername,
 499                                 user, &pol);
 500
 501         if (!W_ERROR_IS_OK(result))
 502                 goto done;
 503
 504         opened_hnd = True;
 505
 506         /* Get printer info */
 507         result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, info_level, &ctr);
 508
 509         if (!W_ERROR_IS_OK(result))
 510                 goto done;
 511
 512
 513         /* Modify the comment. */
 514         init_unistr(&ctr.printers_2->comment, comment);
 515         ctr.printers_2->devmode = NULL;
 516         ctr.printers_2->secdesc = NULL;
 517
 518         result = rpccli_spoolss_setprinter(cli, mem_ctx, &pol, info_level, &ctr, 0);
 519         if (W_ERROR_IS_OK(result))
 520                 printf("Success in setting comment.\n");
 521
 522  done:
 523         if (opened_hnd)
 524                 rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
 525
 526         return result;
 527 }
 528
 529 /****************************************************************************
 530 ****************************************************************************/
 531
 532 static WERROR cmd_spoolss_setprintername(struct rpc_pipe_client *cli,
 533                                        TALLOC_CTX *mem_ctx,
 534                                        int argc, const char **argv)
 535 {
 536         POLICY_HND      pol;
 537         WERROR          result;
 538         uint32          info_level = 2;
 539         bool            opened_hnd = False;
 540         PRINTER_INFO_CTR ctr;
 541         fstring         printername,
 542                         servername,
 543                         user,
 544                         new_printername;
 545
 546         if (argc == 1 || argc > 3) {
 547                 printf("Usage: %s printername new_printername\n", argv[0]);
 548
 549                 return WERR_OK;
 550         }
 551
 552         /* Open a printer handle */
 553         if (argc == 3) {
 554                 fstrcpy(new_printername, argv[2]);
 555         }
 556
 557         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
 558         strupper_m(servername);
 559         slprintf(printername, sizeof(printername)-1, "%s\\%s", servername, argv[1]);
 560         fstrcpy(user, cli->auth->user_name);
 561
 562         /* get a printer handle */
 563         result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
 564                                 PRINTER_ALL_ACCESS, servername,
 565                                 user, &pol);
 566
 567         if (!W_ERROR_IS_OK(result))
 568                 goto done;
 569
 570         opened_hnd = True;
 571
 572         /* Get printer info */
 573         result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, info_level, &ctr);
 574
 575         if (!W_ERROR_IS_OK(result))
 576                 goto done;
 577
 578         /* Modify the printername. */
 579         init_unistr(&ctr.printers_2->printername, new_printername);
 580         ctr.printers_2->devmode = NULL;
 581         ctr.printers_2->secdesc = NULL;
 582
 583         result = rpccli_spoolss_setprinter(cli, mem_ctx, &pol, info_level, &ctr, 0);
 584         if (W_ERROR_IS_OK(result))
 585                 printf("Success in setting printername.\n");
 586
 587  done:
 588         if (opened_hnd)
 589                 rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
 590
 591         return result;
 592 }
 593
 594 /****************************************************************************
 595 ****************************************************************************/
 596
 597 static WERROR cmd_spoolss_getprinter(struct rpc_pipe_client *cli,
 598                                        TALLOC_CTX *mem_ctx,
 599                                        int argc, const char **argv)
 600 {
 601         POLICY_HND      pol;
 602         WERROR          result;
 603         uint32          info_level = 1;
 604         bool            opened_hnd = False;
 605         PRINTER_INFO_CTR ctr;
 606         fstring         printername,
 607                         servername,
 608                         user;
 609
 610         if (argc == 1 || argc > 3) {
 611                 printf("Usage: %s <printername> [level]\n", argv[0]);
 612                 return WERR_OK;
 613         }
 614
 615         /* Open a printer handle */
 616         if (argc == 3) {
 617                 info_level = atoi(argv[2]);
 618         }
 619
 620         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
 621         strupper_m(servername);
 622         slprintf(printername, sizeof(printername)-1, "%s\\%s", servername, argv[1]);
 623         fstrcpy(user, cli->auth->user_name);
 624
 625         /* get a printer handle */
 626
 627         result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
 628                                              "", MAXIMUM_ALLOWED_ACCESS,
 629                                              servername, user, &pol);
 630
 631         if (!W_ERROR_IS_OK(result))
 632                 goto done;
 633
 634         opened_hnd = True;
 635
 636         /* Get printer info */
 637
 638         result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, info_level, &ctr);
 639
 640         if (!W_ERROR_IS_OK(result))
 641                 goto done;
 642
 643         /* Display printer info */
 644
 645         switch (info_level) {
 646         case 0:
 647                 display_print_info_0(ctr.printers_0);
 648                 break;
 649         case 1:
 650                 display_print_info_1(ctr.printers_1);
 651                 break;
 652         case 2:
 653                 display_print_info_2(ctr.printers_2);
 654                 break;
 655         case 3:
 656                 display_print_info_3(ctr.printers_3);
 657                 break;
 658         case 7:
 659                 display_print_info_7(ctr.printers_7);
 660                 break;
 661         default:
 662                 printf("unknown info level %d\n", info_level);
 663                 break;
 664         }
 665
 666  done:
 667         if (opened_hnd)
 668                 rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
 669
 670         return result;
 671 }
 672
 673 /****************************************************************************
 674 ****************************************************************************/
 675
 676 static void display_reg_value(REGISTRY_VALUE value)
 677 {
 678         char *text = NULL;
 679
 680         switch(value.type) {
 681         case REG_DWORD:
 682                 printf("%s: REG_DWORD: 0x%08x\n", value.valuename,
 683                        *((uint32 *) value.data_p));
 684                 break;
 685         case REG_SZ:
 686                 rpcstr_pull_talloc(talloc_tos(),
 687                                 &text,
 688                                 value.data_p,
 689                                 value.size,
 690                                 STR_TERMINATE);
 691                 printf("%s: REG_SZ: %s\n", value.valuename, text ? text : "");
 692                 break;
 693         case REG_BINARY: {
 694                 char *hex = hex_encode_talloc(NULL, value.data_p, value.size);
 695                 size_t i, len;
 696                 printf("%s: REG_BINARY:", value.valuename);
 697                 len = strlen(hex);
 698                 for (i=0; i<len; i++) {
 699                         if (hex[i] == '\0') {
 700                                 break;
 701                         }
 702                         if (i%40 == 0) {
 703                                 putchar('\n');
 704                         }
 705                         putchar(hex[i]);
 706                 }
 707                 TALLOC_FREE(hex);
 708                 putchar('\n');
 709                 break;
 710         }
 711         case REG_MULTI_SZ: {
 712                 uint32 i, num_values;
 713                 char **values;
 714
 715                 if (!W_ERROR_IS_OK(reg_pull_multi_sz(NULL, value.data_p,
 716                                                      value.size, &num_values,
 717                                                      &values))) {
 718                         d_printf("reg_pull_multi_sz failed\n");
 719                         break;
 720                 }
 721
 722                 for (i=0; i<num_values; i++) {
 723                         d_printf("%s\n", values[i]);
 724                 }
 725                 TALLOC_FREE(values);
 726                 break;
 727         }
 728         default:
 729                 printf("%s: unknown type %d\n", value.valuename, value.type);
 730         }
 731
 732 }
 733
 734 /****************************************************************************
 735 ****************************************************************************/
 736
 737 static WERROR cmd_spoolss_getprinterdata(struct rpc_pipe_client *cli,
 738                                            TALLOC_CTX *mem_ctx,
 739                                            int argc, const char **argv)
 740 {
 741         POLICY_HND      pol;
 742         WERROR          result;
 743         bool            opened_hnd = False;
 744         fstring         printername,
 745                         servername,
 746                         user;
 747         const char *valuename;
 748         REGISTRY_VALUE value;
 749
 750         if (argc != 3) {
 751                 printf("Usage: %s <printername> <valuename>\n", argv[0]);
 752                 printf("<printername> of . queries print server\n");
 753                 return WERR_OK;
 754         }
 755         valuename = argv[2];
 756
 757         /* Open a printer handle */
 758
 759         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
 760         strupper_m(servername);
 761         if (strncmp(argv[1], ".", sizeof(".")) == 0)
 762                 fstrcpy(printername, servername);
 763         else
 764                 slprintf(printername, sizeof(servername)-1, "%s\\%s",
 765                           servername, argv[1]);
 766         fstrcpy(user, cli->auth->user_name);
 767
 768         /* get a printer handle */
 769
 770         result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
 771                                              "", MAXIMUM_ALLOWED_ACCESS,
 772                                              servername, user, &pol);
 773
 774         if (!W_ERROR_IS_OK(result))
 775                 goto done;
 776
 777         opened_hnd = True;
 778
 779         /* Get printer info */
 780
 781         result = rpccli_spoolss_getprinterdata(cli, mem_ctx, &pol, valuename, &value);
 782
 783         if (!W_ERROR_IS_OK(result))
 784                 goto done;
 785
 786         /* Display printer data */
 787
 788         fstrcpy(value.valuename, valuename);
 789         display_reg_value(value);
 790
 791
 792  done:
 793         if (opened_hnd)
 794                 rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
 795
 796         return result;
 797 }
 798
 799 /****************************************************************************
 800 ****************************************************************************/
 801
 802 static WERROR cmd_spoolss_getprinterdataex(struct rpc_pipe_client *cli,
 803                                              TALLOC_CTX *mem_ctx,
 804                                              int argc, const char **argv)
 805 {
 806         POLICY_HND      pol;
 807         WERROR          result;
 808         bool            opened_hnd = False;
 809         fstring         printername,
 810                         servername,
 811                         user;
 812         const char *valuename, *keyname;
 813         REGISTRY_VALUE value;
 814
 815         if (argc != 4) {
 816                 printf("Usage: %s <printername> <keyname> <valuename>\n",
 817                        argv[0]);
 818                 printf("<printername> of . queries print server\n");
 819                 return WERR_OK;
 820         }
 821         valuename = argv[3];
 822         keyname = argv[2];
 823
 824         /* Open a printer handle */
 825
 826         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
 827         strupper_m(servername);
 828         if (strncmp(argv[1], ".", sizeof(".")) == 0)
 829                 fstrcpy(printername, servername);
 830         else
 831                 slprintf(printername, sizeof(printername)-1, "%s\\%s",
 832                           servername, argv[1]);
 833         fstrcpy(user, cli->auth->user_name);
 834
 835         /* get a printer handle */
 836
 837         result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
 838                                              "", MAXIMUM_ALLOWED_ACCESS,
 839                                              servername, user, &pol);
 840
 841         if (!W_ERROR_IS_OK(result))
 842                 goto done;
 843
 844         opened_hnd = True;
 845
 846         /* Get printer info */
 847
 848         result = rpccli_spoolss_getprinterdataex(cli, mem_ctx, &pol, keyname,
 849                 valuename, &value);
 850
 851         if (!W_ERROR_IS_OK(result))
 852                 goto done;
 853
 854         /* Display printer data */
 855
 856         fstrcpy(value.valuename, valuename);
 857         display_reg_value(value);
 858
 859
 860  done:
 861         if (opened_hnd)
 862                 rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
 863
 864         return result;
 865 }
 866
 867 /****************************************************************************
 868 ****************************************************************************/
 869
 870 static void display_print_driver_1(DRIVER_INFO_1 *i1)
 871 {
 872         fstring name;
 873         if (i1 == NULL)
 874                 return;
 875
 876         rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
 877
 878         printf ("Printer Driver Info 1:\n");
 879         printf ("\tDriver Name: [%s]\n\n", name);
 880
 881         return;
 882 }
 883
 884 /****************************************************************************
 885 ****************************************************************************/
 886
 887 static void display_print_driver_2(DRIVER_INFO_2 *i1)
 888 {
 889         fstring name;
 890         fstring architecture;
 891         fstring driverpath;
 892         fstring datafile;
 893         fstring configfile;
 894         if (i1 == NULL)
 895                 return;
 896
 897         rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
 898         rpcstr_pull(architecture, i1->architecture.buffer, sizeof(architecture), -1, STR_TERMINATE);
 899         rpcstr_pull(driverpath, i1->driverpath.buffer, sizeof(driverpath), -1, STR_TERMINATE);
 900         rpcstr_pull(datafile, i1->datafile.buffer, sizeof(datafile), -1, STR_TERMINATE);
 901         rpcstr_pull(configfile, i1->configfile.buffer, sizeof(configfile), -1, STR_TERMINATE);
 902
 903         printf ("Printer Driver Info 2:\n");
 904         printf ("\tVersion: [%x]\n", i1->version);
 905         printf ("\tDriver Name: [%s]\n", name);
 906         printf ("\tArchitecture: [%s]\n", architecture);
 907         printf ("\tDriver Path: [%s]\n", driverpath);
 908         printf ("\tDatafile: [%s]\n", datafile);
 909         printf ("\tConfigfile: [%s]\n\n", configfile);
 910
 911         return;
 912 }
 913
 914 /****************************************************************************
 915 ****************************************************************************/
 916
 917 static void display_print_driver_3(DRIVER_INFO_3 *i1)
 918 {
 919         fstring name = "";
 920         fstring architecture = "";
 921         fstring driverpath = "";
 922         fstring datafile = "";
 923         fstring configfile = "";
 924         fstring helpfile = "";
 925         fstring dependentfiles = "";
 926         fstring monitorname = "";
 927         fstring defaultdatatype = "";
 928
 929         int length=0;
 930         bool valid = True;
 931
 932         if (i1 == NULL)
 933                 return;
 934
 935         rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
 936         rpcstr_pull(architecture, i1->architecture.buffer, sizeof(architecture), -1, STR_TERMINATE);
 937         rpcstr_pull(driverpath, i1->driverpath.buffer, sizeof(driverpath), -1, STR_TERMINATE);
 938         rpcstr_pull(datafile, i1->datafile.buffer, sizeof(datafile), -1, STR_TERMINATE);
 939         rpcstr_pull(configfile, i1->configfile.buffer, sizeof(configfile), -1, STR_TERMINATE);
 940         rpcstr_pull(helpfile, i1->helpfile.buffer, sizeof(helpfile), -1, STR_TERMINATE);
 941         rpcstr_pull(monitorname, i1->monitorname.buffer, sizeof(monitorname), -1, STR_TERMINATE);
 942         rpcstr_pull(defaultdatatype, i1->defaultdatatype.buffer, sizeof(defaultdatatype), -1, STR_TERMINATE);
 943
 944         printf ("Printer Driver Info 3:\n");
 945         printf ("\tVersion: [%x]\n", i1->version);
 946         printf ("\tDriver Name: [%s]\n",name);
 947         printf ("\tArchitecture: [%s]\n", architecture);
 948         printf ("\tDriver Path: [%s]\n", driverpath);
 949         printf ("\tDatafile: [%s]\n", datafile);
 950         printf ("\tConfigfile: [%s]\n", configfile);
 951         printf ("\tHelpfile: [%s]\n\n", helpfile);
 952
 953         while (valid)
 954         {
 955                 rpcstr_pull(dependentfiles, i1->dependentfiles+length, sizeof(dependentfiles), -1, STR_TERMINATE);
 956
 957                 length+=strlen(dependentfiles)+1;
 958
 959                 if (strlen(dependentfiles) > 0)
 960                 {
 961                         printf ("\tDependentfiles: [%s]\n", dependentfiles);
 962                 }
 963                 else
 964                 {
 965                         valid = False;
 966                 }
 967         }
 968
 969         printf ("\n");
 970
 971         printf ("\tMonitorname: [%s]\n", monitorname);
 972         printf ("\tDefaultdatatype: [%s]\n\n", defaultdatatype);
 973
 974         return;
 975 }
 976
 977 /****************************************************************************
 978 ****************************************************************************/
 979
 980 static WERROR cmd_spoolss_getdriver(struct rpc_pipe_client *cli,
 981                                       TALLOC_CTX *mem_ctx,
 982                                       int argc, const char **argv)
 983 {
 984         POLICY_HND      pol;
 985         WERROR          werror;
 986         uint32          info_level = 3;
 987         bool            opened_hnd = False;
 988         PRINTER_DRIVER_CTR      ctr;
 989         fstring         printername,
 990                         servername,
 991                         user;
 992         uint32          i;
 993         bool            success = False;
 994
 995         if ((argc == 1) || (argc > 3))
 996         {
 997                 printf("Usage: %s <printername> [level]\n", argv[0]);
 998                 return WERR_OK;
 999         }
1000
1001         /* get the arguments need to open the printer handle */
1002         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
1003         strupper_m(servername);
1004         fstrcpy(user, cli->auth->user_name);
1005         slprintf(printername, sizeof(servername)-1, "%s\\%s", servername, argv[1]);
1006         if (argc == 3)
1007                 info_level = atoi(argv[2]);
1008
1009         /* Open a printer handle */
1010
1011         werror = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
1012                                              PRINTER_ACCESS_USE,
1013                                              servername, user, &pol);
1014
1015         if (!W_ERROR_IS_OK(werror)) {
1016                 printf("Error opening printer handle for %s!\n", printername);
1017                 return werror;
1018         }
1019
1020         opened_hnd = True;
1021
1022         /* loop through and print driver info level for each architecture */
1023
1024         for (i=0; archi_table[i].long_archi!=NULL; i++) {
1025
1026                 werror = rpccli_spoolss_getprinterdriver( cli, mem_ctx, &pol, info_level,
1027                         archi_table[i].long_archi, archi_table[i].version,
1028                         &ctr);
1029
1030                 if (!W_ERROR_IS_OK(werror))
1031                         continue;
1032
1033                 /* need at least one success */
1034
1035                 success = True;
1036
1037                 printf ("\n[%s]\n", archi_table[i].long_archi);
1038
1039                 switch (info_level) {
1040                 case 1:
1041                         display_print_driver_1 (ctr.info1);
1042                         break;
1043                 case 2:
1044                         display_print_driver_2 (ctr.info2);
1045                         break;
1046                 case 3:
1047                         display_print_driver_3 (ctr.info3);
1048                         break;
1049                 default:
1050                         printf("unknown info level %d\n", info_level);
1051                         break;
1052                 }
1053         }
1054
1055         /* Cleanup */
1056
1057         if (opened_hnd)
1058                 rpccli_spoolss_close_printer (cli, mem_ctx, &pol);
1059
1060         if ( success )
1061                 werror = WERR_OK;
1062
1063         return werror;
1064 }
1065
1066 /****************************************************************************
1067 ****************************************************************************/
1068
1069 static WERROR cmd_spoolss_enum_drivers(struct rpc_pipe_client *cli,
1070                                          TALLOC_CTX *mem_ctx,
1071                                          int argc, const char **argv)
1072 {
1073         WERROR werror = WERR_OK;
1074         uint32          info_level = 1;
1075         PRINTER_DRIVER_CTR      ctr;
1076         uint32          i, j,
1077                         returned;
1078
1079         if (argc > 2) {
1080                 printf("Usage: enumdrivers [level]\n");
1081                 return WERR_OK;
1082         }
1083
1084         if (argc == 2)
1085                 info_level = atoi(argv[1]);
1086
1087
1088         /* loop through and print driver info level for each architecture */
1089         for (i=0; archi_table[i].long_archi!=NULL; i++) {
1090                 /* check to see if we already asked for this architecture string */
1091
1092                 if ( i>0 && strequal(archi_table[i].long_archi, archi_table[i-1].long_archi) )
1093                         continue;
1094
1095                 werror = rpccli_spoolss_enumprinterdrivers(
1096                         cli, mem_ctx, info_level,
1097                         archi_table[i].long_archi, &returned, &ctr);
1098
1099                 if (W_ERROR_V(werror) == W_ERROR_V(WERR_INVALID_ENVIRONMENT)) {
1100                         printf ("Server does not support environment [%s]\n",
1101                                 archi_table[i].long_archi);
1102                         werror = WERR_OK;
1103                         continue;
1104                 }
1105
1106                 if (returned == 0)
1107                         continue;
1108
1109                 if (!W_ERROR_IS_OK(werror)) {
1110                         printf ("Error getting driver for environment [%s] - %d\n",
1111                                 archi_table[i].long_archi, W_ERROR_V(werror));
1112                         continue;
1113                 }
1114
1115                 printf ("\n[%s]\n", archi_table[i].long_archi);
1116                 switch (info_level)
1117                 {
1118
1119                 case 1:
1120                         for (j=0; j < returned; j++) {
1121                                 display_print_driver_1 (&ctr.info1[j]);
1122                         }
1123                         break;
1124                 case 2:
1125                         for (j=0; j < returned; j++) {
1126                                 display_print_driver_2 (&ctr.info2[j]);
1127                         }
1128                         break;
1129                 case 3:
1130                         for (j=0; j < returned; j++) {
1131                                 display_print_driver_3 (&ctr.info3[j]);
1132                         }
1133                         break;
1134                 default:
1135                         printf("unknown info level %d\n", info_level);
1136                         return WERR_UNKNOWN_LEVEL;
1137                 }
1138         }
1139
1140         return werror;
1141 }
1142
1143 /****************************************************************************
1144 ****************************************************************************/
1145
1146 static void display_printdriverdir_1(DRIVER_DIRECTORY_1 *i1)
1147 {
1148         fstring name;
1149         if (i1 == NULL)
1150                 return;
1151
1152         rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
1153
1154         printf ("\tDirectory Name:[%s]\n", name);
1155 }
1156
1157 /****************************************************************************
1158 ****************************************************************************/
1159
1160 static WERROR cmd_spoolss_getdriverdir(struct rpc_pipe_client *cli,
1161                                          TALLOC_CTX *mem_ctx,
1162                                          int argc, const char **argv)
1163 {
1164         WERROR result;
1165         fstring                 env;
1166         DRIVER_DIRECTORY_CTR    ctr;
1167
1168         if (argc > 2) {
1169                 printf("Usage: %s [environment]\n", argv[0]);
1170                 return WERR_OK;
1171         }
1172
1173         /* Get the arguments need to open the printer handle */
1174
1175         if (argc == 2)
1176                 fstrcpy (env, argv[1]);
1177         else
1178                 fstrcpy (env, "Windows NT x86");
1179
1180         /* Get the directory.  Only use Info level 1 */
1181
1182         result = rpccli_spoolss_getprinterdriverdir(cli, mem_ctx, 1, env, &ctr);
1183
1184         if (W_ERROR_IS_OK(result))
1185                 display_printdriverdir_1(ctr.info1);
1186
1187         return result;
1188 }
1189
1190 /****************************************************************************
1191 ****************************************************************************/
1192
1193 void set_drv_info_3_env (DRIVER_INFO_3 *info, const char *arch)
1194 {
1195
1196         int i;
1197
1198         for (i=0; archi_table[i].long_archi != NULL; i++)
1199         {
1200                 if (strcmp(arch, archi_table[i].short_archi) == 0)
1201                 {
1202                         info->version = archi_table[i].version;
1203                         init_unistr (&info->architecture, archi_table[i].long_archi);
1204                         break;
1205                 }
1206         }
1207
1208         if (archi_table[i].long_archi == NULL)
1209         {
1210                 DEBUG(0, ("set_drv_info_3_env: Unknown arch [%s]\n", arch));
1211         }
1212
1213         return;
1214 }
1215
1216
1217 /**************************************************************************
1218  wrapper for strtok to get the next parameter from a delimited list.
1219  Needed to handle the empty parameter string denoted by "NULL"
1220  *************************************************************************/
1221
1222 static char* get_driver_3_param (char* str, const char* delim, UNISTR* dest,
1223                                  char **saveptr)
1224 {
1225         char    *ptr;
1226
1227         /* get the next token */
1228         ptr = strtok_r(str, delim, saveptr);
1229
1230         /* a string of 'NULL' is used to represent an empty
1231            parameter because two consecutive delimiters
1232            will not return an empty string.  See man strtok(3)
1233            for details */
1234         if (ptr && (StrCaseCmp(ptr, "NULL") == 0))
1235                 ptr = NULL;
1236
1237         if (dest != NULL)
1238                 init_unistr(dest, ptr);
1239
1240         return ptr;
1241 }
1242
1243 /********************************************************************************
1244  fill in the members of a DRIVER_INFO_3 struct using a character
1245  string in the form of
1246          <Long Printer Name>:<Driver File Name>:<Data File Name>:\
1247              <Config File Name>:<Help File Name>:<Language Monitor Name>:\
1248              <Default Data Type>:<Comma Separated list of Files>
1249  *******************************************************************************/
1250 static bool init_drv_info_3_members ( TALLOC_CTX *mem_ctx, DRIVER_INFO_3 *info,
1251                                       char *args )
1252 {
1253         char    *str, *str2;
1254         uint32  len, i;
1255         char *saveptr = NULL;
1256
1257         /* fill in the UNISTR fields */
1258         str = get_driver_3_param (args, ":", &info->name, &saveptr);
1259         str = get_driver_3_param (NULL, ":", &info->driverpath, &saveptr);
1260         str = get_driver_3_param (NULL, ":", &info->datafile, &saveptr);
1261         str = get_driver_3_param (NULL, ":", &info->configfile, &saveptr);
1262         str = get_driver_3_param (NULL, ":", &info->helpfile, &saveptr);
1263         str = get_driver_3_param (NULL, ":", &info->monitorname, &saveptr);
1264         str = get_driver_3_param (NULL, ":", &info->defaultdatatype, &saveptr);
1265
1266         /* <Comma Separated List of Dependent Files> */
1267         /* save the beginning of the string */
1268         str2 = get_driver_3_param (NULL, ":", NULL, &saveptr);
1269         str = str2;
1270
1271         /* begin to strip out each filename */
1272         str = strtok_r(str, ",", &saveptr);
1273         len = 0;
1274         while (str != NULL)
1275         {
1276                 /* keep a cumlative count of the str lengths */
1277                 len += strlen(str)+1;
1278                 str = strtok_r(NULL, ",", &saveptr);
1279         }
1280
1281         /* allocate the space; add one extra slot for a terminating NULL.
1282            Each filename is NULL terminated and the end contains a double
1283            NULL */
1284         if ((info->dependentfiles=TALLOC_ARRAY(mem_ctx, uint16, len+1)) == NULL)
1285         {
1286                 DEBUG(0,("init_drv_info_3_members: Unable to malloc memory for dependenfiles\n"));
1287                 return False;
1288         }
1289         for (i=0; i<len; i++)
1290         {
1291                 SSVAL(&info->dependentfiles[i], 0, str2[i]);
1292         }
1293         info->dependentfiles[len] = '\0';
1294
1295         return True;
1296 }
1297
1298
1299 /****************************************************************************
1300 ****************************************************************************/
1301
1302 static WERROR cmd_spoolss_addprinterdriver(struct rpc_pipe_client *cli,
1303                                              TALLOC_CTX *mem_ctx,
1304                                              int argc, const char **argv)
1305 {
1306         WERROR result;
1307         uint32                  level = 3;
1308         PRINTER_DRIVER_CTR      ctr;
1309         DRIVER_INFO_3           info3;
1310         const char              *arch;
1311         fstring                 driver_name;
1312         char                    *driver_args;
1313
1314         /* parse the command arguments */
1315         if (argc != 3 && argc != 4)
1316         {
1317                 printf ("Usage: %s <Environment> \\\n", argv[0]);
1318                 printf ("\t<Long Printer Name>:<Driver File Name>:<Data File Name>:\\\n");
1319                 printf ("\t<Config File Name>:<Help File Name>:<Language Monitor Name>:\\\n");
1320                 printf ("\t<Default Data Type>:<Comma Separated list of Files> \\\n");
1321                 printf ("\t[version]\n");
1322
1323             return WERR_OK;
1324         }
1325
1326         /* Fill in the DRIVER_INFO_3 struct */
1327         ZERO_STRUCT(info3);
1328         if (!(arch = cmd_spoolss_get_short_archi(argv[1])))
1329         {
1330                 printf ("Error Unknown architechture [%s]\n", argv[1]);
1331                 return WERR_INVALID_PARAM;
1332         }
1333         else
1334                 set_drv_info_3_env(&info3, arch);
1335
1336         driver_args = talloc_strdup( mem_ctx, argv[2] );
1337         if (!init_drv_info_3_members(mem_ctx, &info3, driver_args ))
1338         {
1339                 printf ("Error Invalid parameter list - %s.\n", argv[2]);
1340                 return WERR_INVALID_PARAM;
1341         }
1342
1343         /* if printer driver version specified, override the default version
1344          * used by the architecture.  This allows installation of Windows
1345          * 2000 (version 3) printer drivers. */
1346         if (argc == 4)
1347         {
1348                 info3.version = atoi(argv[3]);
1349         }
1350
1351
1352         ctr.info3 = &info3;
1353         result = rpccli_spoolss_addprinterdriver (cli, mem_ctx, level, &ctr);
1354
1355         if (W_ERROR_IS_OK(result)) {
1356                 rpcstr_pull(driver_name, info3.name.buffer,
1357                             sizeof(driver_name), -1, STR_TERMINATE);
1358                 printf ("Printer Driver %s successfully installed.\n",
1359                         driver_name);
1360         }
1361
1362         return result;
1363 }
1364
1365
1366 /****************************************************************************
1367 ****************************************************************************/
1368
1369 static WERROR cmd_spoolss_addprinterex(struct rpc_pipe_client *cli,
1370                                          TALLOC_CTX *mem_ctx,
1371                                          int argc, const char **argv)
1372 {
1373         WERROR result;
1374         uint32                  level = 2;
1375         PRINTER_INFO_CTR        ctr;
1376         PRINTER_INFO_2          info2;
1377         fstring                 servername;
1378
1379         /* parse the command arguments */
1380         if (argc != 5)
1381         {
1382                 printf ("Usage: %s <name> <shared name> <driver> <port>\n", argv[0]);
1383                 return WERR_OK;
1384         }
1385
1386         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
1387         strupper_m(servername);
1388
1389         /* Fill in the DRIVER_INFO_2 struct */
1390         ZERO_STRUCT(info2);
1391
1392         init_unistr( &info2.printername,        argv[1]);
1393         init_unistr( &info2.sharename,          argv[2]);
1394         init_unistr( &info2.drivername,         argv[3]);
1395         init_unistr( &info2.portname,           argv[4]);
1396         init_unistr( &info2.comment,            "Created by rpcclient");
1397         init_unistr( &info2.printprocessor,     "winprint");
1398         init_unistr( &info2.datatype,           "RAW");
1399         info2.devmode =         NULL;
1400         info2.secdesc =         NULL;
1401         info2.attributes        = PRINTER_ATTRIBUTE_SHARED;
1402         info2.priority          = 0;
1403         info2.defaultpriority   = 0;
1404         info2.starttime         = 0;
1405         info2.untiltime         = 0;
1406
1407         /* These three fields must not be used by AddPrinter()
1408            as defined in the MS Platform SDK documentation..
1409            --jerry
1410         info2.status            = 0;
1411         info2.cjobs             = 0;
1412         info2.averageppm        = 0;
1413         */
1414
1415         ctr.printers_2 = &info2;
1416         result = rpccli_spoolss_addprinterex (cli, mem_ctx, level, &ctr);
1417
1418         if (W_ERROR_IS_OK(result))
1419                 printf ("Printer %s successfully installed.\n", argv[1]);
1420
1421         return result;
1422 }
1423
1424 /****************************************************************************
1425 ****************************************************************************/
1426
1427 static WERROR cmd_spoolss_setdriver(struct rpc_pipe_client *cli,
1428                                       TALLOC_CTX *mem_ctx,
1429                                       int argc, const char **argv)
1430 {
1431         POLICY_HND              pol;
1432         WERROR                  result;
1433         uint32                  level = 2;
1434         bool                    opened_hnd = False;
1435         PRINTER_INFO_CTR        ctr;
1436         PRINTER_INFO_2          info2;
1437         fstring                 servername,
1438                                 printername,
1439                                 user;
1440
1441         /* parse the command arguments */
1442         if (argc != 3)
1443         {
1444                 printf ("Usage: %s <printer> <driver>\n", argv[0]);
1445                 return WERR_OK;
1446         }
1447
1448         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
1449         strupper_m(servername);
1450         slprintf(printername, sizeof(printername)-1, "%s\\%s", servername, argv[1]);
1451         fstrcpy(user, cli->auth->user_name);
1452
1453         /* Get a printer handle */
1454
1455         result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
1456                                              PRINTER_ALL_ACCESS,
1457                                              servername, user, &pol);
1458
1459         if (!W_ERROR_IS_OK(result))
1460                 goto done;
1461
1462         opened_hnd = True;
1463
1464         /* Get printer info */
1465
1466         ZERO_STRUCT (info2);
1467         ctr.printers_2 = &info2;
1468
1469         result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, level, &ctr);
1470
1471         if (!W_ERROR_IS_OK(result)) {
1472                 printf ("Unable to retrieve printer information!\n");
1473                 goto done;
1474         }
1475
1476         /* Set the printer driver */
1477
1478         init_unistr(&ctr.printers_2->drivername, argv[2]);
1479
1480         result = rpccli_spoolss_setprinter(cli, mem_ctx, &pol, level, &ctr, 0);
1481
1482         if (!W_ERROR_IS_OK(result)) {
1483                 printf("SetPrinter call failed!\n");
1484                 goto done;;
1485         }
1486
1487         printf("Successfully set %s to driver %s.\n", argv[1], argv[2]);
1488
1489 done:
1490         /* Cleanup */
1491
1492         if (opened_hnd)
1493                 rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
1494
1495         return result;
1496 }
1497
1498
1499 /****************************************************************************
1500 ****************************************************************************/
1501
1502 static WERROR cmd_spoolss_deletedriverex(struct rpc_pipe_client *cli,
1503                                          TALLOC_CTX *mem_ctx,
1504                                          int argc, const char **argv)
1505 {
1506         WERROR result, ret = WERR_UNKNOWN_PRINTER_DRIVER;
1507
1508         int   i;
1509         int vers = -1;
1510
1511         const char *arch = NULL;
1512
1513         /* parse the command arguments */
1514         if (argc < 2 || argc > 4) {
1515                 printf ("Usage: %s <driver> [arch] [version]\n", argv[0]);
1516                 return WERR_OK;
1517         }
1518
1519         if (argc >= 3)
1520                 arch = argv[2];
1521         if (argc == 4)
1522                 vers = atoi (argv[3]);
1523
1524
1525         /* delete the driver for all architectures */
1526         for (i=0; archi_table[i].long_archi; i++) {
1527
1528                 if (arch &&  !strequal( archi_table[i].long_archi, arch))
1529                         continue;
1530
1531                 if (vers >= 0 && archi_table[i].version != vers)
1532                         continue;
1533
1534                 /* make the call to remove the driver */
1535                 result = rpccli_spoolss_deleteprinterdriverex(
1536                         cli, mem_ctx, archi_table[i].long_archi, argv[1], archi_table[i].version);
1537
1538                 if ( !W_ERROR_IS_OK(result) )
1539                 {
1540                         if ( !W_ERROR_EQUAL(result, WERR_UNKNOWN_PRINTER_DRIVER) ) {
1541                                 printf ("Failed to remove driver %s for arch [%s] (version: %d): %s\n",
1542                                         argv[1], archi_table[i].long_archi, archi_table[i].version, win_errstr(result));
1543                         }
1544                 }
1545                 else
1546                 {
1547                         printf ("Driver %s and files removed for arch [%s] (version: %d).\n", argv[1],
1548                         archi_table[i].long_archi, archi_table[i].version);
1549                         ret = WERR_OK;
1550                 }
1551         }
1552
1553         return ret;
1554 }
1555
1556
1557 /****************************************************************************
1558 ****************************************************************************/
1559
1560 static WERROR cmd_spoolss_deletedriver(struct rpc_pipe_client *cli,
1561                                          TALLOC_CTX *mem_ctx,
1562                                          int argc, const char **argv)
1563 {
1564         WERROR result = WERR_OK;
1565         fstring                 servername;
1566         int                     i;
1567
1568         /* parse the command arguments */
1569         if (argc != 2) {
1570                 printf ("Usage: %s <driver>\n", argv[0]);
1571                 return WERR_OK;
1572         }
1573
1574         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
1575         strupper_m(servername);
1576
1577         /* delete the driver for all architectures */
1578         for (i=0; archi_table[i].long_archi; i++) {
1579                 /* make the call to remove the driver */
1580                 result = rpccli_spoolss_deleteprinterdriver(
1581                         cli, mem_ctx, archi_table[i].long_archi, argv[1]);
1582
1583                 if ( !W_ERROR_IS_OK(result) ) {
1584                         if ( !W_ERROR_EQUAL(result, WERR_UNKNOWN_PRINTER_DRIVER) ) {
1585                                 printf ("Failed to remove driver %s for arch [%s] - error 0x%x!\n",
1586                                         argv[1], archi_table[i].long_archi,
1587                                         W_ERROR_V(result));
1588                         }
1589                 } else {
1590                         printf ("Driver %s removed for arch [%s].\n", argv[1],
1591                                 archi_table[i].long_archi);
1592                 }
1593         }
1594
1595         return result;
1596 }
1597
1598 /****************************************************************************
1599 ****************************************************************************/
1600
1601 static WERROR cmd_spoolss_getprintprocdir(struct rpc_pipe_client *cli,
1602                                             TALLOC_CTX *mem_ctx,
1603                                             int argc, const char **argv)
1604 {
1605         WERROR result;
1606         char *servername = NULL, *environment = NULL;
1607         fstring procdir;
1608
1609         /* parse the command arguments */
1610         if (argc > 2) {
1611                 printf ("Usage: %s [environment]\n", argv[0]);
1612                 return WERR_OK;
1613         }
1614
1615         if (asprintf(&servername, "\\\\%s", cli->desthost) < 0)
1616                 return WERR_NOMEM;
1617         strupper_m(servername);
1618
1619         if (asprintf(&environment, "%s", (argc == 2) ? argv[1] :
1620                      PRINTER_DRIVER_ARCHITECTURE) < 0) {
1621                 SAFE_FREE(servername);
1622                 return WERR_NOMEM;
1623         }
1624
1625         result = rpccli_spoolss_getprintprocessordirectory(
1626                 cli, mem_ctx, servername, environment, procdir);
1627
1628         if (W_ERROR_IS_OK(result))
1629                 printf("%s\n", procdir);
1630
1631         SAFE_FREE(servername);
1632         SAFE_FREE(environment);
1633
1634         return result;
1635 }
1636
1637 /****************************************************************************
1638 ****************************************************************************/
1639
1640 static WERROR cmd_spoolss_addform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1641                                     int argc, const char **argv)
1642 {
1643         POLICY_HND handle;
1644         WERROR werror;
1645         char *servername = NULL, *printername = NULL;
1646         FORM form;
1647         bool got_handle = False;
1648
1649         /* Parse the command arguments */
1650
1651         if (argc != 3) {
1652                 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1653                 return WERR_OK;
1654         }
1655
1656         /* Get a printer handle */
1657
1658         if (asprintf(&servername, "\\\\%s", cli->desthost) == -1) {
1659                 return WERR_NOMEM;
1660         }
1661         strupper_m(servername);
1662         if (asprintf(&printername, "%s\\%s", servername, argv[1]) == -1) {
1663                 SAFE_FREE(servername);
1664                 return WERR_NOMEM;
1665         }
1666
1667         werror = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
1668                                              PRINTER_ALL_ACCESS,
1669                                              servername, cli->auth->user_name,
1670                                              &handle);
1671
1672         if (!W_ERROR_IS_OK(werror))
1673                 goto done;
1674
1675         got_handle = True;
1676
1677         /* Dummy up some values for the form data */
1678
1679         form.flags = FORM_USER;
1680         form.size_x = form.size_y = 100;
1681         form.left = 0;
1682         form.top = 10;
1683         form.right = 20;
1684         form.bottom = 30;
1685
1686         init_unistr2(&form.name, argv[2], UNI_STR_TERMINATE);
1687
1688         /* Add the form */
1689
1690
1691         werror = rpccli_spoolss_addform(cli, mem_ctx, &handle, 1, &form);
1692
1693  done:
1694         if (got_handle)
1695                 rpccli_spoolss_close_printer(cli, mem_ctx, &handle);
1696
1697         SAFE_FREE(servername);
1698         SAFE_FREE(printername);
1699
1700         return werror;
1701 }
1702
1703 /****************************************************************************
1704 ****************************************************************************/
1705
1706 static WERROR cmd_spoolss_setform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1707                                     int argc, const char **argv)
1708 {
1709         POLICY_HND handle;
1710         WERROR werror;
1711         char *servername = NULL, *printername = NULL;
1712         FORM form;
1713         bool got_handle = False;
1714
1715         /* Parse the command arguments */
1716
1717         if (argc != 3) {
1718                 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1719                 return WERR_OK;
1720         }
1721
1722         /* Get a printer handle */
1723
1724         if (asprintf(&servername, "\\\\%s", cli->desthost)) {
1725                 return WERR_NOMEM;
1726         }
1727         strupper_m(servername);
1728         if (asprintf(&printername, "%s\\%s", servername, argv[1]) == -1) {
1729                 SAFE_FREE(servername);
1730                 return WERR_NOMEM;
1731         }
1732
1733         werror = rpccli_spoolss_open_printer_ex(
1734                 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1735                 servername, cli->auth->user_name, &handle);
1736
1737         if (!W_ERROR_IS_OK(werror))
1738                 goto done;
1739
1740         got_handle = True;
1741
1742         /* Dummy up some values for the form data */
1743
1744         form.flags = FORM_PRINTER;
1745         form.size_x = form.size_y = 100;
1746         form.left = 0;
1747         form.top = 1000;
1748         form.right = 2000;
1749         form.bottom = 3000;
1750
1751         init_unistr2(&form.name, argv[2], UNI_STR_TERMINATE);
1752
1753         /* Set the form */
1754
1755         werror = rpccli_spoolss_setform(cli, mem_ctx, &handle, 1, argv[2], &form);
1756
1757  done:
1758         if (got_handle)
1759                 rpccli_spoolss_close_printer(cli, mem_ctx, &handle);
1760
1761         SAFE_FREE(servername);
1762         SAFE_FREE(printername);
1763
1764         return werror;
1765 }
1766
1767 /****************************************************************************
1768 ****************************************************************************/
1769
1770 static const char *get_form_flag(int form_flag)
1771 {
1772         switch (form_flag) {
1773         case FORM_USER:
1774                 return "FORM_USER";
1775         case FORM_BUILTIN:
1776                 return "FORM_BUILTIN";
1777         case FORM_PRINTER:
1778                 return "FORM_PRINTER";
1779         default:
1780                 return "unknown";
1781         }
1782 }
1783
1784 /****************************************************************************
1785 ****************************************************************************/
1786
1787 static void display_form(FORM_1 *form)
1788 {
1789         fstring form_name = "";
1790
1791         if (form->name.buffer)
1792                 rpcstr_pull(form_name, form->name.buffer,
1793                             sizeof(form_name), -1, STR_TERMINATE);
1794
1795         printf("%s\n" \
1796                 "\tflag: %s (%d)\n" \
1797                 "\twidth: %d, length: %d\n" \
1798                 "\tleft: %d, right: %d, top: %d, bottom: %d\n\n",
1799                 form_name, get_form_flag(form->flag), form->flag,
1800                 form->width, form->length,
1801                 form->left, form->right,
1802                 form->top, form->bottom);
1803 }
1804
1805 /****************************************************************************
1806 ****************************************************************************/
1807
1808 static WERROR cmd_spoolss_getform(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1809                                     int argc, const char **argv)
1810 {
1811         POLICY_HND handle;
1812         WERROR werror;
1813         char *servername = NULL, *printername = NULL;
1814         FORM_1 form;
1815         bool got_handle = False;
1816
1817         /* Parse the command arguments */
1818
1819         if (argc != 3) {
1820                 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1821                 return WERR_OK;
1822         }
1823
1824         /* Get a printer handle */
1825
1826         if (asprintf(&servername, "\\\\%s", cli->desthost) == -1) {
1827                 return WERR_NOMEM;
1828         }
1829         strupper_m(servername);
1830         if (asprintf(&printername, "%s\\%s", servername, argv[1])) {
1831                 SAFE_FREE(servername);
1832                 return WERR_NOMEM;
1833         }
1834
1835         werror = rpccli_spoolss_open_printer_ex(
1836                 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1837                 servername, cli->auth->user_name, &handle);
1838
1839         if (!W_ERROR_IS_OK(werror))
1840                 goto done;
1841
1842         got_handle = True;
1843
1844         /* Get the form */
1845
1846         werror = rpccli_spoolss_getform(cli, mem_ctx, &handle, argv[2], 1, &form);
1847
1848         if (!W_ERROR_IS_OK(werror))
1849                 goto done;
1850
1851         display_form(&form);
1852
1853  done:
1854         if (got_handle)
1855                 rpccli_spoolss_close_printer(cli, mem_ctx, &handle);
1856
1857         SAFE_FREE(servername);
1858         SAFE_FREE(printername);
1859
1860         return werror;
1861 }
1862
1863 /****************************************************************************
1864 ****************************************************************************/
1865
1866 static WERROR cmd_spoolss_deleteform(struct rpc_pipe_client *cli,
1867                                        TALLOC_CTX *mem_ctx, int argc,
1868                                        const char **argv)
1869 {
1870         POLICY_HND handle;
1871         WERROR werror;
1872         char *servername = NULL, *printername = NULL;
1873         bool got_handle = False;
1874
1875         /* Parse the command arguments */
1876
1877         if (argc != 3) {
1878                 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1879                 return WERR_OK;
1880         }
1881
1882         /* Get a printer handle */
1883
1884         if (asprintf(&servername, "\\\\%s", cli->desthost) == -1) {
1885                 return WERR_NOMEM;
1886         }
1887         strupper_m(servername);
1888         if (asprintf(&printername, "%s\\%s", servername, argv[1]) == -1) {
1889                 SAFE_FREE(servername);
1890                 return WERR_NOMEM;
1891         }
1892
1893         werror = rpccli_spoolss_open_printer_ex(
1894                 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1895                 servername, cli->auth->user_name, &handle);
1896
1897         if (!W_ERROR_IS_OK(werror))
1898                 goto done;
1899
1900         got_handle = True;
1901
1902         /* Delete the form */
1903
1904         werror = rpccli_spoolss_deleteform(cli, mem_ctx, &handle, argv[2]);
1905
1906  done:
1907         if (got_handle)
1908                 rpccli_spoolss_close_printer(cli, mem_ctx, &handle);
1909
1910         SAFE_FREE(servername);
1911         SAFE_FREE(printername);
1912
1913         return werror;
1914 }
1915
1916 /****************************************************************************
1917 ****************************************************************************/
1918
1919 static WERROR cmd_spoolss_enum_forms(struct rpc_pipe_client *cli,
1920                                        TALLOC_CTX *mem_ctx, int argc,
1921                                        const char **argv)
1922 {
1923         POLICY_HND handle;
1924         WERROR werror;
1925         char *servername = NULL, *printername = NULL;
1926         bool got_handle = False;
1927         uint32 num_forms, level = 1, i;
1928         FORM_1 *forms;
1929
1930         /* Parse the command arguments */
1931
1932         if (argc != 2) {
1933                 printf ("Usage: %s <printer>\n", argv[0]);
1934                 return WERR_OK;
1935         }
1936
1937         /* Get a printer handle */
1938
1939         if (asprintf(&servername, "\\\\%s", cli->desthost) == -1) {
1940                 return WERR_NOMEM;
1941         }
1942         strupper_m(servername);
1943         if (asprintf(&printername, "%s\\%s", servername, argv[1]) == -1) {
1944                 SAFE_FREE(servername);
1945                 return WERR_NOMEM;
1946         }
1947
1948         werror = rpccli_spoolss_open_printer_ex(
1949                 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1950                 servername, cli->auth->user_name, &handle);
1951
1952         if (!W_ERROR_IS_OK(werror))
1953                 goto done;
1954
1955         got_handle = True;
1956
1957         /* Enumerate forms */
1958
1959         werror = rpccli_spoolss_enumforms(cli, mem_ctx, &handle, level, &num_forms, &forms);
1960
1961         if (!W_ERROR_IS_OK(werror))
1962                 goto done;
1963
1964         /* Display output */
1965
1966         for (i = 0; i < num_forms; i++) {
1967
1968                 display_form(&forms[i]);
1969
1970         }
1971
1972  done:
1973         if (got_handle)
1974                 rpccli_spoolss_close_printer(cli, mem_ctx, &handle);
1975
1976         SAFE_FREE(servername);
1977         SAFE_FREE(printername);
1978
1979         return werror;
1980 }
1981
1982 /****************************************************************************
1983 ****************************************************************************/
1984
1985 static WERROR cmd_spoolss_setprinterdata(struct rpc_pipe_client *cli,
1986                                             TALLOC_CTX *mem_ctx,
1987                                             int argc, const char **argv)
1988 {
1989         WERROR result;
1990         fstring servername, printername, user;
1991         POLICY_HND pol;
1992         bool opened_hnd = False;
1993         PRINTER_INFO_CTR ctr;
1994         PRINTER_INFO_0 info;
1995         REGISTRY_VALUE value;
1996         TALLOC_CTX *tmp_ctx = talloc_stackframe();
1997
1998         /* parse the command arguments */
1999         if (argc < 5) {
2000                 printf ("Usage: %s <printer> <string|binary|dword|multistring>"
2001                         " <value> <data>\n",
2002                         argv[0]);
2003                 result = WERR_INVALID_PARAM;
2004                 goto done;
2005         }
2006
2007         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
2008         strupper_m(servername);
2009         slprintf(printername, sizeof(servername)-1, "%s\\%s", servername, argv[1]);
2010         fstrcpy(user, cli->auth->user_name);
2011
2012         value.type = REG_NONE;
2013
2014         if (strequal(argv[2], "string")) {
2015                 value.type = REG_SZ;
2016         }
2017
2018         if (strequal(argv[2], "binary")) {
2019                 value.type = REG_BINARY;
2020         }
2021
2022         if (strequal(argv[2], "dword")) {
2023                 value.type = REG_DWORD;
2024         }
2025
2026         if (strequal(argv[2], "multistring")) {
2027                 value.type = REG_MULTI_SZ;
2028         }
2029
2030         if (value.type == REG_NONE) {
2031                 printf("Unknown data type: %s\n", argv[2]);
2032                 result =  WERR_INVALID_PARAM;
2033                 goto done;
2034         }
2035
2036         /* get a printer handle */
2037         result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
2038                                              MAXIMUM_ALLOWED_ACCESS, servername,
2039                                              user, &pol);
2040         if (!W_ERROR_IS_OK(result))
2041                 goto done;
2042
2043         opened_hnd = True;
2044
2045         ctr.printers_0 = &info;
2046
2047         result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, 0, &ctr);
2048
2049         if (!W_ERROR_IS_OK(result))
2050                 goto done;
2051
2052         printf("%s\n", current_timestring(tmp_ctx, True));
2053         printf("\tchange_id (before set)\t:[0x%x]\n", info.change_id);
2054
2055         /* Set the printer data */
2056
2057         fstrcpy(value.valuename, argv[3]);
2058
2059         switch (value.type) {
2060         case REG_SZ: {
2061                 UNISTR2 data;
2062                 init_unistr2(&data, argv[4], UNI_STR_TERMINATE);
2063                 value.size = data.uni_str_len * 2;
2064                 if (value.size) {
2065                         value.data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, data.buffer,
2066                                                       value.size);
2067                 } else {
2068                         value.data_p = NULL;
2069                 }
2070                 break;
2071         }
2072         case REG_DWORD: {
2073                 uint32 data = strtoul(argv[4], NULL, 10);
2074                 value.size = sizeof(data);
2075                 if (sizeof(data)) {
2076                         value.data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, &data,
2077                                                       sizeof(data));
2078                 } else {
2079                         value.data_p = NULL;
2080                 }
2081                 break;
2082         }
2083         case REG_BINARY: {
2084                 DATA_BLOB data = strhex_to_data_blob(mem_ctx, argv[4]);
2085                 value.data_p = data.data;
2086                 value.size = data.length;
2087                 break;
2088         }
2089         case REG_MULTI_SZ: {
2090                 int i;
2091                 size_t len = 0;
2092                 char *p;
2093
2094                 for (i=4; i<argc; i++) {
2095                         if (strcmp(argv[i], "NULL") == 0) {
2096                                 argv[i] = "";
2097                         }
2098                         len += strlen(argv[i])+1;
2099                 }
2100
2101                 value.size = len*2;
2102                 value.data_p = TALLOC_ARRAY(mem_ctx, unsigned char, value.size);
2103                 if (value.data_p == NULL) {
2104                         result = WERR_NOMEM;
2105                         goto done;
2106                 }
2107
2108                 p = (char *)value.data_p;
2109                 len = value.size;
2110                 for (i=4; i<argc; i++) {
2111                         size_t l = (strlen(argv[i])+1)*2;
2112                         rpcstr_push(p, argv[i], len, STR_TERMINATE);
2113                         p += l;
2114                         len -= l;
2115                 }
2116                 SMB_ASSERT(len == 0);
2117                 break;
2118         }
2119         default:
2120                 printf("Unknown data type: %s\n", argv[2]);
2121                 result = WERR_INVALID_PARAM;
2122                 goto done;
2123         }
2124
2125         result = rpccli_spoolss_setprinterdata(cli, mem_ctx, &pol, &value);
2126
2127         if (!W_ERROR_IS_OK(result)) {
2128                 printf ("Unable to set [%s=%s]!\n", argv[3], argv[4]);
2129                 goto done;
2130         }
2131         printf("\tSetPrinterData succeeded [%s: %s]\n", argv[3], argv[4]);
2132
2133         result = rpccli_spoolss_getprinter(cli, mem_ctx, &pol, 0, &ctr);
2134
2135         if (!W_ERROR_IS_OK(result))
2136                 goto done;
2137
2138         printf("%s\n", current_timestring(tmp_ctx, True));
2139         printf("\tchange_id (after set)\t:[0x%x]\n", info.change_id);
2140
2141 done:
2142         /* cleanup */
2143         TALLOC_FREE(tmp_ctx);
2144         if (opened_hnd)
2145                 rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
2146
2147         return result;
2148 }
2149
2150 /****************************************************************************
2151 ****************************************************************************/
2152
2153 static void display_job_info_1(JOB_INFO_1 *job)
2154 {
2155         fstring username = "", document = "", text_status = "";
2156
2157         rpcstr_pull(username, job->username.buffer,
2158                     sizeof(username), -1, STR_TERMINATE);
2159
2160         rpcstr_pull(document, job->document.buffer,
2161                     sizeof(document), -1, STR_TERMINATE);
2162
2163         rpcstr_pull(text_status, job->text_status.buffer,
2164                     sizeof(text_status), -1, STR_TERMINATE);
2165
2166         printf("%d: jobid[%d]: %s %s %s %d/%d pages\n", job->position, job->jobid,
2167                username, document, text_status, job->pagesprinted,
2168                job->totalpages);
2169 }
2170
2171 /****************************************************************************
2172 ****************************************************************************/
2173
2174 static void display_job_info_2(JOB_INFO_2 *job)
2175 {
2176         fstring username = "", document = "", text_status = "";
2177
2178         rpcstr_pull(username, job->username.buffer,
2179                     sizeof(username), -1, STR_TERMINATE);
2180
2181         rpcstr_pull(document, job->document.buffer,
2182                     sizeof(document), -1, STR_TERMINATE);
2183
2184         rpcstr_pull(text_status, job->text_status.buffer,
2185                     sizeof(text_status), -1, STR_TERMINATE);
2186
2187         printf("%d: jobid[%d]: %s %s %s %d/%d pages, %d bytes\n", job->position, job->jobid,
2188                username, document, text_status, job->pagesprinted,
2189                job->totalpages, job->size);
2190 }
2191
2192 /****************************************************************************
2193 ****************************************************************************/
2194
2195 static WERROR cmd_spoolss_enum_jobs(struct rpc_pipe_client *cli,
2196                                       TALLOC_CTX *mem_ctx, int argc,
2197                                       const char **argv)
2198 {
2199         WERROR result;
2200         uint32 level = 1, num_jobs, i;
2201         bool got_hnd = False;
2202         char *printername = NULL;
2203         fstring servername, user;
2204         POLICY_HND hnd;
2205         JOB_INFO_CTR ctr;
2206
2207         if (argc < 2 || argc > 3) {
2208                 printf("Usage: %s printername [level]\n", argv[0]);
2209                 return WERR_OK;
2210         }
2211
2212         if (argc == 3)
2213                 level = atoi(argv[2]);
2214
2215         /* Open printer handle */
2216
2217         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
2218         strupper_m(servername);
2219         fstrcpy(user, cli->auth->user_name);
2220         printername = talloc_asprintf(mem_ctx, "\\\\%s\\", cli->desthost);
2221         if (!printername) {
2222                 return WERR_NOMEM;
2223         }
2224         strupper_m(printername);
2225         printername = talloc_asprintf_append(printername, "%s", argv[1]);
2226         if (!printername) {
2227                 return WERR_NOMEM;
2228         }
2229
2230         result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
2231                                              "", MAXIMUM_ALLOWED_ACCESS,
2232                                              servername, user, &hnd);
2233
2234         if (!W_ERROR_IS_OK(result))
2235                 goto done;
2236
2237         got_hnd = True;
2238
2239         /* Enumerate ports */
2240
2241         result = rpccli_spoolss_enumjobs(cli, mem_ctx, &hnd, level, 0, 1000,
2242                 &num_jobs, &ctr);
2243
2244         if (!W_ERROR_IS_OK(result))
2245                 goto done;
2246
2247         for (i = 0; i < num_jobs; i++) {
2248                 switch(level) {
2249                 case 1:
2250                         display_job_info_1(&ctr.job.job_info_1[i]);
2251                         break;
2252                 case 2:
2253                         display_job_info_2(&ctr.job.job_info_2[i]);
2254                         break;
2255                 default:
2256                         d_printf("unknown info level %d\n", level);
2257                         break;
2258                 }
2259         }
2260
2261 done:
2262         if (got_hnd)
2263                 rpccli_spoolss_close_printer(cli, mem_ctx, &hnd);
2264
2265         return result;
2266 }
2267
2268 /****************************************************************************
2269 ****************************************************************************/
2270
2271 static WERROR cmd_spoolss_enum_data( struct rpc_pipe_client *cli,
2272                                        TALLOC_CTX *mem_ctx, int argc,
2273                                        const char **argv)
2274 {
2275         WERROR result;
2276         uint32 i=0, val_needed, data_needed;
2277         bool got_hnd = False;
2278         char *printername = NULL;
2279         fstring servername, user;
2280         POLICY_HND hnd;
2281
2282         if (argc != 2) {
2283                 printf("Usage: %s printername\n", argv[0]);
2284                 return WERR_OK;
2285         }
2286
2287         /* Open printer handle */
2288
2289         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
2290         strupper_m(servername);
2291         fstrcpy(user, cli->auth->user_name);
2292         printername = talloc_asprintf(mem_ctx, "\\\\%s\\", cli->desthost);
2293         if (!printername) {
2294                 return WERR_NOMEM;
2295         }
2296         strupper_m(printername);
2297         printername = talloc_asprintf_append(printername, "%s", argv[1]);
2298         if (!printername) {
2299                 return WERR_NOMEM;
2300         }
2301
2302         result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
2303                                              "", MAXIMUM_ALLOWED_ACCESS,
2304                                              servername, user, &hnd);
2305
2306         if (!W_ERROR_IS_OK(result))
2307                 goto done;
2308
2309         got_hnd = True;
2310
2311         /* Enumerate data */
2312
2313         result = rpccli_spoolss_enumprinterdata(cli, mem_ctx, &hnd, i, 0, 0,
2314                                              &val_needed, &data_needed,
2315                                              NULL);
2316         while (W_ERROR_IS_OK(result)) {
2317                 REGISTRY_VALUE value;
2318                 result = rpccli_spoolss_enumprinterdata(
2319                         cli, mem_ctx, &hnd, i++, val_needed,
2320                         data_needed, 0, 0, &value);
2321                 if (W_ERROR_IS_OK(result))
2322                         display_reg_value(value);
2323         }
2324         if (W_ERROR_V(result) == ERRnomoreitems)
2325                 result = W_ERROR(ERRsuccess);
2326
2327 done:
2328         if (got_hnd)
2329                 rpccli_spoolss_close_printer(cli, mem_ctx, &hnd);
2330
2331         return result;
2332 }
2333
2334 /****************************************************************************
2335 ****************************************************************************/
2336
2337 static WERROR cmd_spoolss_enum_data_ex( struct rpc_pipe_client *cli,
2338                                           TALLOC_CTX *mem_ctx, int argc,
2339                                           const char **argv)
2340 {
2341         WERROR result;
2342         uint32 i;
2343         bool got_hnd = False;
2344         char *printername = NULL;
2345         fstring servername, user;
2346         const char *keyname = NULL;
2347         POLICY_HND hnd;
2348         REGVAL_CTR *ctr = NULL;
2349
2350         if (argc != 3) {
2351                 printf("Usage: %s printername <keyname>\n", argv[0]);
2352                 return WERR_OK;
2353         }
2354
2355         keyname = argv[2];
2356
2357         /* Open printer handle */
2358
2359         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
2360         strupper_m(servername);
2361         fstrcpy(user, cli->auth->user_name);
2362
2363         printername = talloc_asprintf(mem_ctx, "\\\\%s\\", cli->desthost);
2364         if (!printername) {
2365                 return WERR_NOMEM;
2366         }
2367         strupper_m(printername);
2368         printername = talloc_asprintf_append(printername, "%s", argv[1]);
2369         if (!printername) {
2370                 return WERR_NOMEM;
2371         }
2372
2373         result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
2374                                              "", MAXIMUM_ALLOWED_ACCESS,
2375                                              servername, user, &hnd);
2376
2377         if (!W_ERROR_IS_OK(result))
2378                 goto done;
2379
2380         got_hnd = True;
2381
2382         /* Enumerate subkeys */
2383
2384         if ( !(ctr = TALLOC_ZERO_P( mem_ctx, REGVAL_CTR )) )
2385                 return WERR_NOMEM;
2386
2387         result = rpccli_spoolss_enumprinterdataex(cli, mem_ctx, &hnd, keyname, ctr);
2388
2389         if (!W_ERROR_IS_OK(result))
2390                 goto done;
2391
2392         for (i=0; i < ctr->num_values; i++) {
2393                 display_reg_value(*(ctr->values[i]));
2394         }
2395
2396         TALLOC_FREE( ctr );
2397
2398 done:
2399         if (got_hnd)
2400                 rpccli_spoolss_close_printer(cli, mem_ctx, &hnd);
2401
2402         return result;
2403 }
2404
2405 /****************************************************************************
2406 ****************************************************************************/
2407
2408 static WERROR cmd_spoolss_enum_printerkey( struct rpc_pipe_client *cli,
2409                                              TALLOC_CTX *mem_ctx, int argc,
2410                                              const char **argv)
2411 {
2412         WERROR result;
2413         bool got_hnd = False;
2414         char *printername = NULL;
2415         fstring servername, user;
2416         const char *keyname = NULL;
2417         POLICY_HND hnd;
2418         uint16 *keylist = NULL, *curkey;
2419
2420         if (argc < 2 || argc > 3) {
2421                 printf("Usage: %s printername [keyname]\n", argv[0]);
2422                 return WERR_OK;
2423         }
2424
2425         if (argc == 3)
2426                 keyname = argv[2];
2427         else
2428                 keyname = "";
2429
2430         /* Open printer handle */
2431
2432         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
2433         strupper_m(servername);
2434         fstrcpy(user, cli->auth->user_name);
2435
2436         printername = talloc_asprintf(mem_ctx, "\\\\%s\\", cli->desthost);
2437         if (!printername) {
2438                 return WERR_NOMEM;
2439         }
2440         strupper_m(printername);
2441         printername = talloc_asprintf_append(printername, "%s", argv[1]);
2442         if (!printername) {
2443                 return WERR_NOMEM;
2444         }
2445
2446
2447         result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
2448                                              "", MAXIMUM_ALLOWED_ACCESS,
2449                                              servername, user, &hnd);
2450
2451         if (!W_ERROR_IS_OK(result))
2452                 goto done;
2453
2454         got_hnd = True;
2455
2456         /* Enumerate subkeys */
2457
2458         result = rpccli_spoolss_enumprinterkey(cli, mem_ctx, &hnd, keyname, &keylist, NULL);
2459
2460         if (!W_ERROR_IS_OK(result))
2461                 goto done;
2462
2463         curkey = keylist;
2464         while (*curkey != 0) {
2465                 char *subkey = NULL;
2466                 rpcstr_pull_talloc(mem_ctx, &subkey, curkey, -1,
2467                             STR_TERMINATE);
2468                 if (!subkey) {
2469                         break;
2470                 }
2471                 printf("%s\n", subkey);
2472                 curkey += strlen(subkey) + 1;
2473         }
2474
2475 done:
2476
2477         SAFE_FREE(keylist);
2478
2479         if (got_hnd)
2480                 rpccli_spoolss_close_printer(cli, mem_ctx, &hnd);
2481
2482         return result;
2483 }
2484
2485 /****************************************************************************
2486 ****************************************************************************/
2487
2488 static WERROR cmd_spoolss_rffpcnex(struct rpc_pipe_client *cli,
2489                                      TALLOC_CTX *mem_ctx, int argc,
2490                                      const char **argv)
2491 {
2492         fstring servername, printername;
2493         POLICY_HND hnd;
2494         bool got_hnd = False;
2495         WERROR result;
2496         SPOOL_NOTIFY_OPTION option;
2497
2498         if (argc != 2) {
2499                 printf("Usage: %s printername\n", argv[0]);
2500                 result = WERR_OK;
2501                 goto done;
2502         }
2503
2504         /* Open printer */
2505
2506         slprintf(servername, sizeof(servername) - 1, "\\\\%s", cli->desthost);
2507         strupper_m(servername);
2508
2509         slprintf(printername, sizeof(printername) - 1, "\\\\%s\\%s",
2510                  cli->desthost, argv[1]);
2511         strupper_m(printername);
2512
2513         result = rpccli_spoolss_open_printer_ex(
2514                 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
2515                 servername, cli->auth->user_name, &hnd);
2516
2517         if (!W_ERROR_IS_OK(result)) {
2518                 printf("Error opening %s\n", argv[1]);
2519                 goto done;
2520         }
2521
2522         got_hnd = True;
2523
2524         /* Create spool options */
2525
2526         ZERO_STRUCT(option);
2527
2528         option.version = 2;
2529         option.option_type_ptr = 1;
2530         option.count = option.ctr.count = 2;
2531
2532         option.ctr.type = TALLOC_ARRAY(mem_ctx, SPOOL_NOTIFY_OPTION_TYPE, 2);
2533         if (option.ctr.type == NULL) {
2534                 result = WERR_NOMEM;
2535                 goto done;
2536         }
2537
2538         ZERO_STRUCT(option.ctr.type[0]);
2539         option.ctr.type[0].type = PRINTER_NOTIFY_TYPE;
2540         option.ctr.type[0].count = option.ctr.type[0].count2 = 1;
2541         option.ctr.type[0].fields_ptr = 1;
2542         option.ctr.type[0].fields[0] = PRINTER_NOTIFY_SERVER_NAME;
2543
2544         ZERO_STRUCT(option.ctr.type[1]);
2545         option.ctr.type[1].type = JOB_NOTIFY_TYPE;
2546         option.ctr.type[1].count = option.ctr.type[1].count2 = 1;
2547         option.ctr.type[1].fields_ptr = 1;
2548         option.ctr.type[1].fields[0] = JOB_NOTIFY_PRINTER_NAME;
2549
2550         /* Send rffpcnex */
2551
2552         slprintf(servername, sizeof(servername) - 1, "\\\\%s", myhostname());
2553         strupper_m(servername);
2554
2555         result = rpccli_spoolss_rffpcnex(
2556                 cli, mem_ctx, &hnd, 0, 0, servername, 123, &option);
2557
2558         if (!W_ERROR_IS_OK(result)) {
2559                 printf("Error rffpcnex %s\n", argv[1]);
2560                 goto done;
2561         }
2562
2563 done:
2564         if (got_hnd)
2565                 rpccli_spoolss_close_printer(cli, mem_ctx, &hnd);
2566
2567         return result;
2568 }
2569
2570 /****************************************************************************
2571 ****************************************************************************/
2572
2573 static bool compare_printer( struct rpc_pipe_client *cli1, POLICY_HND *hnd1,
2574                              struct rpc_pipe_client *cli2, POLICY_HND *hnd2 )
2575 {
2576         PRINTER_INFO_CTR ctr1, ctr2;
2577         WERROR werror;
2578         TALLOC_CTX *mem_ctx = talloc_init("compare_printer");
2579
2580         printf("Retrieving printer propertiesfor %s...", cli1->desthost);
2581         werror = rpccli_spoolss_getprinter( cli1, mem_ctx, hnd1, 2, &ctr1);
2582         if ( !W_ERROR_IS_OK(werror) ) {
2583                 printf("failed (%s)\n", win_errstr(werror));
2584                 talloc_destroy(mem_ctx);
2585                 return False;
2586         }
2587         printf("ok\n");
2588
2589         printf("Retrieving printer properties for %s...", cli2->desthost);
2590         werror = rpccli_spoolss_getprinter( cli2, mem_ctx, hnd2, 2, &ctr2);
2591         if ( !W_ERROR_IS_OK(werror) ) {
2592                 printf("failed (%s)\n", win_errstr(werror));
2593                 talloc_destroy(mem_ctx);
2594                 return False;
2595         }
2596         printf("ok\n");
2597
2598         talloc_destroy(mem_ctx);
2599
2600         return True;
2601 }
2602
2603 /****************************************************************************
2604 ****************************************************************************/
2605
2606 static bool compare_printer_secdesc( struct rpc_pipe_client *cli1, POLICY_HND *hnd1,
2607                                      struct rpc_pipe_client *cli2, POLICY_HND *hnd2 )
2608 {
2609         PRINTER_INFO_CTR ctr1, ctr2;
2610         WERROR werror;
2611         TALLOC_CTX *mem_ctx = talloc_init("compare_printer_secdesc");
2612         SEC_DESC *sd1, *sd2;
2613         bool result = True;
2614
2615
2616         printf("Retrieving printer security for %s...", cli1->desthost);
2617         werror = rpccli_spoolss_getprinter( cli1, mem_ctx, hnd1, 3, &ctr1);
2618         if ( !W_ERROR_IS_OK(werror) ) {
2619                 printf("failed (%s)\n", win_errstr(werror));
2620                 result = False;
2621                 goto done;
2622         }
2623         printf("ok\n");
2624
2625         printf("Retrieving printer security for %s...", cli2->desthost);
2626         werror = rpccli_spoolss_getprinter( cli2, mem_ctx, hnd2, 3, &ctr2);
2627         if ( !W_ERROR_IS_OK(werror) ) {
2628                 printf("failed (%s)\n", win_errstr(werror));
2629                 result = False;
2630                 goto done;
2631         }
2632         printf("ok\n");
2633
2634
2635         printf("++ ");
2636
2637         if ( (ctr1.printers_3 != ctr2.printers_3) && (!ctr1.printers_3 || !ctr2.printers_3) ) {
2638                 printf("NULL PRINTER_INFO_3!\n");
2639                 result = False;
2640                 goto done;
2641         }
2642
2643         sd1 = ctr1.printers_3->secdesc;
2644         sd2 = ctr2.printers_3->secdesc;
2645
2646         if ( (sd1 != sd2) && ( !sd1 || !sd2 ) ) {
2647                 printf("NULL secdesc!\n");
2648                 result = False;
2649                 goto done;
2650         }
2651
2652         if (!sec_desc_equal( sd1, sd2 ) ) {
2653                 printf("Security Descriptors *not* equal!\n");
2654                 result = False;
2655                 goto done;
2656         }
2657
2658         printf("Security descriptors match\n");
2659
2660 done:
2661         talloc_destroy(mem_ctx);
2662         return result;
2663 }
2664
2665
2666 /****************************************************************************
2667 ****************************************************************************/
2668
2669 extern struct user_auth_info *rpcclient_auth_info;
2670
2671 static WERROR cmd_spoolss_printercmp(struct rpc_pipe_client *cli,
2672                                      TALLOC_CTX *mem_ctx, int argc,
2673                                      const char **argv)
2674 {
2675         fstring printername, servername1, servername2;
2676         char *printername_path = NULL;
2677         struct cli_state *cli_server1 = rpc_pipe_np_smb_conn(cli);
2678         struct cli_state *cli_server2 = NULL;
2679         struct rpc_pipe_client *cli2 = NULL;
2680         POLICY_HND hPrinter1, hPrinter2;
2681         NTSTATUS nt_status;
2682         WERROR werror;
2683
2684         if ( argc != 3 )  {
2685                 printf("Usage: %s <printer> <server>\n", argv[0]);
2686                 return WERR_OK;
2687         }
2688
2689         fstrcpy( printername, argv[1] );
2690
2691         fstrcpy( servername1, cli->desthost );
2692         fstrcpy( servername2, argv[2] );
2693         strupper_m( servername1 );
2694         strupper_m( servername2 );
2695
2696         /* first get the connection to the remote server */
2697
2698         nt_status = cli_full_connection(&cli_server2, global_myname(), servername2,
2699                                         NULL, 0,
2700                                         "IPC$", "IPC",
2701                                         get_cmdline_auth_info_username(rpcclient_auth_info),
2702                                         lp_workgroup(),
2703                                         get_cmdline_auth_info_password(rpcclient_auth_info),
2704                                         get_cmdline_auth_info_use_kerberos(rpcclient_auth_info) ? CLI_FULL_CONNECTION_USE_KERBEROS : 0,
2705                                         get_cmdline_auth_info_signing_state(rpcclient_auth_info), NULL);
2706
2707         if ( !NT_STATUS_IS_OK(nt_status) )
2708                 return WERR_GENERAL_FAILURE;
2709
2710         nt_status = cli_rpc_pipe_open_noauth(cli_server2, &syntax_spoolss,
2711                                              &cli2);
2712         if (!NT_STATUS_IS_OK(nt_status)) {
2713                 printf("failed to open spoolss pipe on server %s (%s)\n",
2714                         servername2, nt_errstr(nt_status));
2715                 return WERR_GENERAL_FAILURE;
2716         }
2717
2718         /* now open up both printers */
2719
2720         printername_path = talloc_asprintf(mem_ctx,
2721                                 "\\\\%s\\%s",
2722                                 servername1,
2723                                 printername);
2724         if (!printername_path) {
2725                 return WERR_NOMEM;
2726         }
2727         printf("Opening %s...", printername_path);
2728         werror = rpccli_spoolss_open_printer_ex( cli, mem_ctx, printername_path,
2729                 "", PRINTER_ALL_ACCESS, servername1, cli_server1->user_name, &hPrinter1);
2730         if ( !W_ERROR_IS_OK(werror) ) {
2731                 printf("failed (%s)\n", win_errstr(werror));
2732                 goto done;
2733         }
2734         printf("ok\n");
2735
2736         printername_path = talloc_asprintf(mem_ctx,
2737                                         "\\\\%s\\%s",
2738                                         servername2,
2739                                         printername);
2740         if (!printername_path) {
2741                 return WERR_NOMEM;
2742         }
2743         printf("Opening %s...", printername_path);
2744         werror = rpccli_spoolss_open_printer_ex( cli2, mem_ctx, printername_path,
2745                 "", PRINTER_ALL_ACCESS, servername2, cli_server2->user_name, &hPrinter2 );
2746         if ( !W_ERROR_IS_OK(werror) ) {
2747                  printf("failed (%s)\n", win_errstr(werror));
2748                 goto done;
2749         }
2750         printf("ok\n");
2751
2752         compare_printer( cli, &hPrinter1, cli2, &hPrinter2 );
2753         compare_printer_secdesc( cli, &hPrinter1, cli2, &hPrinter2 );
2754 #if 0
2755         compare_printerdata( cli_server1, &hPrinter1, cli_server2, &hPrinter2 );
2756 #endif
2757
2758
2759 done:
2760         /* cleanup */
2761
2762         printf("Closing printers...");
2763         rpccli_spoolss_close_printer( cli, mem_ctx, &hPrinter1 );
2764         rpccli_spoolss_close_printer( cli2, mem_ctx, &hPrinter2 );
2765         printf("ok\n");
2766
2767         /* close the second remote connection */
2768
2769         cli_shutdown( cli_server2 );
2770         return WERR_OK;
2771 }
2772
2773 /* List of commands exported by this module */
2774 struct cmd_set spoolss_commands[] = {
2775
2776         { "SPOOLSS"  },
2777
2778         { "adddriver",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterdriver,   &syntax_spoolss, NULL, "Add a print driver",                  "" },
2779         { "addprinter",         RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterex,       &syntax_spoolss, NULL, "Add a printer",                       "" },
2780         { "deldriver",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_deletedriver,       &syntax_spoolss, NULL, "Delete a printer driver",             "" },
2781         { "deldriverex",        RPC_RTYPE_WERROR, NULL, cmd_spoolss_deletedriverex,     &syntax_spoolss, NULL, "Delete a printer driver with files",  "" },
2782         { "enumdata",           RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data,          &syntax_spoolss, NULL, "Enumerate printer data",              "" },
2783         { "enumdataex",         RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data_ex,       &syntax_spoolss, NULL, "Enumerate printer data for a key",    "" },
2784         { "enumkey",            RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printerkey,    &syntax_spoolss, NULL, "Enumerate printer keys",              "" },
2785         { "enumjobs",           RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_jobs,          &syntax_spoolss, NULL, "Enumerate print jobs",                "" },
2786         { "enumports",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_ports,         &syntax_spoolss, NULL, "Enumerate printer ports",             "" },
2787         { "enumdrivers",        RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_drivers,       &syntax_spoolss, NULL, "Enumerate installed printer drivers", "" },
2788         { "enumprinters",       RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printers,      &syntax_spoolss, NULL, "Enumerate printers",                  "" },
2789         { "getdata",            RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdata,     &syntax_spoolss, NULL, "Get print driver data",               "" },
2790         { "getdataex",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdataex,   &syntax_spoolss, NULL, "Get printer driver data with keyname", ""},
2791         { "getdriver",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriver,          &syntax_spoolss, NULL, "Get print driver information",        "" },
2792         { "getdriverdir",       RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriverdir,       &syntax_spoolss, NULL, "Get print driver upload directory",   "" },
2793         { "getprinter",         RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinter,         &syntax_spoolss, NULL, "Get printer info",                    "" },
2794         { "openprinter",        RPC_RTYPE_WERROR, NULL, cmd_spoolss_open_printer_ex,    &syntax_spoolss, NULL, "Open printer handle",                 "" },
2795         { "setdriver",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_setdriver,          &syntax_spoolss, NULL, "Set printer driver",                  "" },
2796         { "getprintprocdir",    RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprintprocdir,    &syntax_spoolss, NULL, "Get print processor directory",       "" },
2797         { "addform",            RPC_RTYPE_WERROR, NULL, cmd_spoolss_addform,            &syntax_spoolss, NULL, "Add form",                            "" },
2798         { "setform",            RPC_RTYPE_WERROR, NULL, cmd_spoolss_setform,            &syntax_spoolss, NULL, "Set form",                            "" },
2799         { "getform",            RPC_RTYPE_WERROR, NULL, cmd_spoolss_getform,            &syntax_spoolss, NULL, "Get form",                            "" },
2800         { "deleteform",         RPC_RTYPE_WERROR, NULL, cmd_spoolss_deleteform,         &syntax_spoolss, NULL, "Delete form",                         "" },
2801         { "enumforms",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_forms,         &syntax_spoolss, NULL, "Enumerate forms",                     "" },
2802         { "setprinter",         RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinter,         &syntax_spoolss, NULL, "Set printer comment",                 "" },
2803         { "setprintername",     RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprintername,     &syntax_spoolss, NULL, "Set printername",                 "" },
2804         { "setprinterdata",     RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinterdata,     &syntax_spoolss, NULL, "Set REG_SZ printer data",             "" },
2805         { "rffpcnex",           RPC_RTYPE_WERROR, NULL, cmd_spoolss_rffpcnex,           &syntax_spoolss, NULL, "Rffpcnex test", "" },
2806         { "printercmp",         RPC_RTYPE_WERROR, NULL, cmd_spoolss_printercmp,         &syntax_spoolss, NULL, "Printer comparison test", "" },
2807
2808         { NULL }
2809 };