source/rpcclient/cmd_spoolss.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    RPC pipe client
   4
   5    Copyright (C) Gerald Carter                     2001
   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 2 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, write to the Free Software
  22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23 */
  24
  25 #include "includes.h"
  26 #include "rpcclient.h"
  27
  28 struct table_node {
  29         const char      *long_archi;
  30         const char      *short_archi;
  31         int     version;
  32 };
  33
  34 static const struct table_node archi_table[]= {
  35
  36         {"Windows 4.0",          "WIN40",       0 },
  37         {"Windows NT x86",       "W32X86",      2 },
  38         {"Windows NT x86",       "W32X86",      3 },
  39         {"Windows NT R4000",     "W32MIPS",     2 },
  40         {"Windows NT Alpha_AXP", "W32ALPHA",    2 },
  41         {"Windows NT PowerPC",   "W32PPC",      2 },
  42         {NULL,                   "",            -1 }
  43 };
  44
  45 /**
  46  * @file
  47  *
  48  * rpcclient module for SPOOLSS rpc pipe.
  49  *
  50  * This generally just parses and checks command lines, and then calls
  51  * a cli_spoolss function.
  52  **/
  53
  54 /****************************************************************************
  55 function to do the mapping between the long architecture name and
  56 the short one.
  57 ****************************************************************************/
  58 static const char *cmd_spoolss_get_short_archi(const char *long_archi)
  59 {
  60         int i=-1;
  61
  62         DEBUG(107,("Getting architecture dependant directory\n"));
  63         do {
  64                 i++;
  65         } while ( (archi_table[i].long_archi!=NULL ) &&
  66                   StrCaseCmp(long_archi, archi_table[i].long_archi) );
  67
  68         if (archi_table[i].long_archi==NULL) {
  69                 DEBUGADD(10,("Unknown architecture [%s] !\n", long_archi));
  70                 return NULL;
  71         }
  72
  73         /* this might be client code - but shouldn't this be an fstrcpy etc? */
  74
  75
  76         DEBUGADD(108,("index: [%d]\n", i));
  77         DEBUGADD(108,("long architecture: [%s]\n", archi_table[i].long_archi));
  78         DEBUGADD(108,("short architecture: [%s]\n", archi_table[i].short_archi));
  79
  80         return archi_table[i].short_archi;
  81 }
  82
  83 #if 0
  84 /**********************************************************************
  85  * dummy function  -- placeholder
  86   */
  87 static WERROR cmd_spoolss_not_implemented(struct cli_state *cli,
  88                                             TALLOC_CTX *mem_ctx,
  89                                             int argc, const char **argv)
  90 {
  91         printf ("(*) This command is not currently implemented.\n");
  92         return WERR_OK;
  93 }
  94 #endif
  95
  96 /***********************************************************************
  97  * Get printer information
  98  */
  99 static WERROR cmd_spoolss_open_printer_ex(struct cli_state *cli,
 100                                             TALLOC_CTX *mem_ctx,
 101                                             int argc, const char **argv)
 102 {
 103         WERROR          werror;
 104         fstring         printername;
 105         fstring         servername, user;
 106         POLICY_HND      hnd;
 107
 108         if (argc != 2) {
 109                 printf("Usage: %s <printername>\n", argv[0]);
 110                 return WERR_OK;
 111         }
 112
 113         if (!cli)
 114             return WERR_GENERAL_FAILURE;
 115
 116         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
 117         strupper_m(servername);
 118         fstrcpy(user, cli->user_name);
 119         fstrcpy(printername, argv[1]);
 120
 121         /* Open the printer handle */
 122
 123         werror = cli_spoolss_open_printer_ex(cli, mem_ctx, printername,
 124                                              "", PRINTER_ALL_ACCESS,
 125                                              servername, user, &hnd);
 126
 127         if (W_ERROR_IS_OK(werror)) {
 128                 printf("Printer %s opened successfully\n", printername);
 129                 werror = cli_spoolss_close_printer(cli, mem_ctx, &hnd);
 130
 131                 if (!W_ERROR_IS_OK(werror)) {
 132                         printf("Error closing printer handle! (%s)\n",
 133                                 get_dos_error_msg(werror));
 134                 }
 135         }
 136
 137         return werror;
 138 }
 139
 140
 141 /****************************************************************************
 142 printer info level 0 display function
 143 ****************************************************************************/
 144 static void display_print_info_0(PRINTER_INFO_0 *i0)
 145 {
 146         fstring name = "";
 147         fstring servername = "";
 148
 149         if (!i0)
 150                 return;
 151
 152         rpcstr_pull(name, i0->printername.buffer, sizeof(name), -1, STR_TERMINATE);
 153
 154         rpcstr_pull(servername, i0->servername.buffer, sizeof(servername), -1,STR_TERMINATE);
 155
 156         printf("\tprintername:[%s]\n", name);
 157         printf("\tservername:[%s]\n", servername);
 158         printf("\tcjobs:[0x%x]\n", i0->cjobs);
 159         printf("\ttotal_jobs:[0x%x]\n", i0->total_jobs);
 160
 161         printf("\t:date: [%d]-[%d]-[%d] (%d)\n", i0->year, i0->month,
 162                i0->day, i0->dayofweek);
 163         printf("\t:time: [%d]-[%d]-[%d]-[%d]\n", i0->hour, i0->minute,
 164                i0->second, i0->milliseconds);
 165
 166         printf("\tglobal_counter:[0x%x]\n", i0->global_counter);
 167         printf("\ttotal_pages:[0x%x]\n", i0->total_pages);
 168
 169         printf("\tmajorversion:[0x%x]\n", i0->major_version);
 170         printf("\tbuildversion:[0x%x]\n", i0->build_version);
 171
 172         printf("\tunknown7:[0x%x]\n", i0->unknown7);
 173         printf("\tunknown8:[0x%x]\n", i0->unknown8);
 174         printf("\tunknown9:[0x%x]\n", i0->unknown9);
 175         printf("\tsession_counter:[0x%x]\n", i0->session_counter);
 176         printf("\tunknown11:[0x%x]\n", i0->unknown11);
 177         printf("\tprinter_errors:[0x%x]\n", i0->printer_errors);
 178         printf("\tunknown13:[0x%x]\n", i0->unknown13);
 179         printf("\tunknown14:[0x%x]\n", i0->unknown14);
 180         printf("\tunknown15:[0x%x]\n", i0->unknown15);
 181         printf("\tunknown16:[0x%x]\n", i0->unknown16);
 182         printf("\tchange_id:[0x%x]\n", i0->change_id);
 183         printf("\tunknown18:[0x%x]\n", i0->unknown18);
 184         printf("\tstatus:[0x%x]\n", i0->status);
 185         printf("\tunknown20:[0x%x]\n", i0->unknown20);
 186         printf("\tc_setprinter:[0x%x]\n", i0->c_setprinter);
 187         printf("\tunknown22:[0x%x]\n", i0->unknown22);
 188         printf("\tunknown23:[0x%x]\n", i0->unknown23);
 189         printf("\tunknown24:[0x%x]\n", i0->unknown24);
 190         printf("\tunknown25:[0x%x]\n", i0->unknown25);
 191         printf("\tunknown26:[0x%x]\n", i0->unknown26);
 192         printf("\tunknown27:[0x%x]\n", i0->unknown27);
 193         printf("\tunknown28:[0x%x]\n", i0->unknown28);
 194         printf("\tunknown29:[0x%x]\n", i0->unknown29);
 195
 196         printf("\n");
 197 }
 198
 199 /****************************************************************************
 200 printer info level 1 display function
 201 ****************************************************************************/
 202 static void display_print_info_1(PRINTER_INFO_1 *i1)
 203 {
 204         fstring desc = "";
 205         fstring name = "";
 206         fstring comm = "";
 207
 208         rpcstr_pull(desc, i1->description.buffer, sizeof(desc), -1,
 209                     STR_TERMINATE);
 210
 211         rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
 212         rpcstr_pull(comm, i1->comment.buffer, sizeof(comm), -1, STR_TERMINATE);
 213
 214         printf("\tflags:[0x%x]\n", i1->flags);
 215         printf("\tname:[%s]\n", name);
 216         printf("\tdescription:[%s]\n", desc);
 217         printf("\tcomment:[%s]\n", comm);
 218
 219         printf("\n");
 220 }
 221
 222 /****************************************************************************
 223 printer info level 2 display function
 224 ****************************************************************************/
 225 static void display_print_info_2(PRINTER_INFO_2 *i2)
 226 {
 227         fstring servername = "";
 228         fstring printername = "";
 229         fstring sharename = "";
 230         fstring portname = "";
 231         fstring drivername = "";
 232         fstring comment = "";
 233         fstring location = "";
 234         fstring sepfile = "";
 235         fstring printprocessor = "";
 236         fstring datatype = "";
 237         fstring parameters = "";
 238
 239         rpcstr_pull(servername, i2->servername.buffer,sizeof(servername), -1, STR_TERMINATE);
 240
 241         rpcstr_pull(printername, i2->printername.buffer,sizeof(printername), -1, STR_TERMINATE);
 242
 243         rpcstr_pull(sharename, i2->sharename.buffer,sizeof(sharename), -1, STR_TERMINATE);
 244
 245         rpcstr_pull(portname, i2->portname.buffer,sizeof(portname), -1, STR_TERMINATE);
 246
 247         rpcstr_pull(drivername, i2->drivername.buffer,sizeof(drivername), -1, STR_TERMINATE);
 248
 249         rpcstr_pull(comment, i2->comment.buffer,sizeof(comment), -1, STR_TERMINATE);
 250
 251         rpcstr_pull(location, i2->location.buffer,sizeof(location), -1, STR_TERMINATE);
 252
 253         rpcstr_pull(sepfile, i2->sepfile.buffer,sizeof(sepfile), -1, STR_TERMINATE);
 254
 255         rpcstr_pull(printprocessor, i2->printprocessor.buffer,sizeof(printprocessor), -1, STR_TERMINATE);
 256
 257         rpcstr_pull(datatype, i2->datatype.buffer,sizeof(datatype), -1, STR_TERMINATE);
 258
 259         rpcstr_pull(parameters, i2->parameters.buffer,sizeof(parameters), -1, STR_TERMINATE);
 260
 261         printf("\tservername:[%s]\n", servername);
 262         printf("\tprintername:[%s]\n", printername);
 263         printf("\tsharename:[%s]\n", sharename);
 264         printf("\tportname:[%s]\n", portname);
 265         printf("\tdrivername:[%s]\n", drivername);
 266         printf("\tcomment:[%s]\n", comment);
 267         printf("\tlocation:[%s]\n", location);
 268         printf("\tsepfile:[%s]\n", sepfile);
 269         printf("\tprintprocessor:[%s]\n", printprocessor);
 270         printf("\tdatatype:[%s]\n", datatype);
 271         printf("\tparameters:[%s]\n", parameters);
 272         printf("\tattributes:[0x%x]\n", i2->attributes);
 273         printf("\tpriority:[0x%x]\n", i2->priority);
 274         printf("\tdefaultpriority:[0x%x]\n", i2->defaultpriority);
 275         printf("\tstarttime:[0x%x]\n", i2->starttime);
 276         printf("\tuntiltime:[0x%x]\n", i2->untiltime);
 277         printf("\tstatus:[0x%x]\n", i2->status);
 278         printf("\tcjobs:[0x%x]\n", i2->cjobs);
 279         printf("\taverageppm:[0x%x]\n", i2->averageppm);
 280
 281         if (i2->secdesc)
 282                 display_sec_desc(i2->secdesc);
 283
 284         printf("\n");
 285 }
 286
 287 /****************************************************************************
 288 printer info level 3 display function
 289 ****************************************************************************/
 290 static void display_print_info_3(PRINTER_INFO_3 *i3)
 291 {
 292         printf("\tflags:[0x%x]\n", i3->flags);
 293
 294         display_sec_desc(i3->secdesc);
 295
 296         printf("\n");
 297 }
 298
 299 /* Enumerate printers */
 300
 301 static WERROR cmd_spoolss_enum_printers(struct cli_state *cli,
 302                                           TALLOC_CTX *mem_ctx,
 303                                           int argc, const char **argv)
 304 {
 305         WERROR                  result;
 306         uint32                  info_level = 1;
 307         PRINTER_INFO_CTR        ctr;
 308         uint32                  i = 0, num_printers, needed;
 309         fstring name;
 310
 311         if (argc > 3)
 312         {
 313                 printf("Usage: %s [level] [name]\n", argv[0]);
 314                 return WERR_OK;
 315         }
 316
 317         if (argc == 2)
 318                 info_level = atoi(argv[1]);
 319
 320         if (argc == 3)
 321                 fstrcpy(name, argv[2]);
 322         else {
 323                 slprintf(name, sizeof(name)-1, "\\\\%s", cli->desthost);
 324                 strupper_m(name);
 325         }
 326
 327         /* Enumerate printers  -- Should we enumerate types other
 328            than PRINTER_ENUM_LOCAL?  Maybe accept as a parameter?  --jerry */
 329
 330         ZERO_STRUCT(ctr);
 331
 332         result = cli_spoolss_enum_printers(
 333                 cli, mem_ctx, 0, &needed, name, PRINTER_ENUM_LOCAL,
 334                 info_level, &num_printers, &ctr);
 335
 336         if (W_ERROR_V(result) == ERRinsufficientbuffer)
 337                 result = cli_spoolss_enum_printers(
 338                         cli, mem_ctx, needed, NULL, name, PRINTER_ENUM_LOCAL,
 339                         info_level, &num_printers, &ctr);
 340
 341         if (W_ERROR_IS_OK(result)) {
 342
 343                 if (!num_printers) {
 344                         printf ("No printers returned.\n");
 345                         goto done;
 346                 }
 347
 348                 for (i = 0; i < num_printers; i++) {
 349                         switch(info_level) {
 350                         case 0:
 351                                 display_print_info_0(&ctr.printers_0[i]);
 352                                 break;
 353                         case 1:
 354                                 display_print_info_1(&ctr.printers_1[i]);
 355                                 break;
 356                         case 2:
 357                                 display_print_info_2(&ctr.printers_2[i]);
 358                                 break;
 359                         case 3:
 360                                 display_print_info_3(&ctr.printers_3[i]);
 361                                 break;
 362                         default:
 363                                 printf("unknown info level %d\n", info_level);
 364                                 goto done;
 365                         }
 366                 }
 367         }
 368         done:
 369
 370         return result;
 371 }
 372
 373 /****************************************************************************
 374 port info level 1 display function
 375 ****************************************************************************/
 376 static void display_port_info_1(PORT_INFO_1 *i1)
 377 {
 378         fstring buffer;
 379
 380         rpcstr_pull(buffer, i1->port_name.buffer, sizeof(buffer), -1, STR_TERMINATE);
 381         printf("\tPort Name:\t[%s]\n", buffer);
 382 }
 383
 384 /****************************************************************************
 385 port info level 2 display function
 386 ****************************************************************************/
 387 static void display_port_info_2(PORT_INFO_2 *i2)
 388 {
 389         fstring buffer;
 390
 391         rpcstr_pull(buffer, i2->port_name.buffer, sizeof(buffer), -1, STR_TERMINATE);
 392         printf("\tPort Name:\t[%s]\n", buffer);
 393         rpcstr_pull(buffer, i2->monitor_name.buffer, sizeof(buffer), -1, STR_TERMINATE);
 394
 395         printf("\tMonitor Name:\t[%s]\n", buffer);
 396         rpcstr_pull(buffer, i2->description.buffer, sizeof(buffer), -1, STR_TERMINATE);
 397
 398         printf("\tDescription:\t[%s]\n", buffer);
 399         printf("\tPort Type:\t" );
 400         if ( i2->port_type ) {
 401                 int comma = 0; /* hack */
 402                 printf( "[" );
 403                 if ( i2->port_type & PORT_TYPE_READ ) {
 404                         printf( "Read" );
 405                         comma = 1;
 406                 }
 407                 if ( i2->port_type & PORT_TYPE_WRITE ) {
 408                         printf( "%sWrite", comma ? ", " : "" );
 409                         comma = 1;
 410                 }
 411                 /* These two have slightly different interpretations
 412                  on 95/98/ME but I'm disregarding that for now */
 413                 if ( i2->port_type & PORT_TYPE_REDIRECTED ) {
 414                         printf( "%sRedirected", comma ? ", " : "" );
 415                         comma = 1;
 416                 }
 417                 if ( i2->port_type & PORT_TYPE_NET_ATTACHED ) {
 418                         printf( "%sNet-Attached", comma ? ", " : "" );
 419                 }
 420                 printf( "]\n" );
 421         } else {
 422                 printf( "[Unset]\n" );
 423         }
 424         printf("\tReserved:\t[%d]\n", i2->reserved);
 425         printf("\n");
 426 }
 427
 428 /* Enumerate ports */
 429
 430 static WERROR cmd_spoolss_enum_ports(struct cli_state *cli,
 431                                        TALLOC_CTX *mem_ctx, int argc,
 432                                        const char **argv)
 433 {
 434         WERROR                  result;
 435         uint32                  needed, info_level = 1;
 436         PORT_INFO_CTR           ctr;
 437         int                     returned;
 438
 439         if (argc > 2) {
 440                 printf("Usage: %s [level]\n", argv[0]);
 441                 return WERR_OK;
 442         }
 443
 444         if (argc == 2)
 445                 info_level = atoi(argv[1]);
 446
 447         /* Enumerate ports */
 448
 449         ZERO_STRUCT(ctr);
 450
 451         result = cli_spoolss_enum_ports(cli, mem_ctx, 0, &needed, info_level,
 452                                         &returned, &ctr);
 453
 454         if (W_ERROR_V(result) == ERRinsufficientbuffer)
 455                 result = cli_spoolss_enum_ports(cli, mem_ctx, needed, NULL,
 456                                                 info_level, &returned, &ctr);
 457
 458         if (W_ERROR_IS_OK(result)) {
 459                 int i;
 460
 461                 for (i = 0; i < returned; i++) {
 462                         switch (info_level) {
 463                         case 1:
 464                                 display_port_info_1(&ctr.port.info_1[i]);
 465                                 break;
 466                         case 2:
 467                                 display_port_info_2(&ctr.port.info_2[i]);
 468                                 break;
 469                         default:
 470                                 printf("unknown info level %d\n", info_level);
 471                                 break;
 472                         }
 473                 }
 474         }
 475
 476         return result;
 477 }
 478
 479 /***********************************************************************
 480  * Set printer comment - use a level2 set.
 481  */
 482 static WERROR cmd_spoolss_setprinter(struct cli_state *cli,
 483                                        TALLOC_CTX *mem_ctx,
 484                                        int argc, const char **argv)
 485 {
 486         POLICY_HND      pol;
 487         WERROR          result;
 488         uint32          needed;
 489         uint32          info_level = 2;
 490         BOOL            opened_hnd = False;
 491         PRINTER_INFO_CTR ctr;
 492         fstring         printername,
 493                         servername,
 494                         user,
 495                         comment;
 496
 497         if (argc == 1 || argc > 3) {
 498                 printf("Usage: %s printername comment\n", argv[0]);
 499
 500                 return WERR_OK;
 501         }
 502
 503         /* Open a printer handle */
 504         if (argc == 3) {
 505                 fstrcpy(comment, argv[2]);
 506         }
 507
 508         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
 509         strupper_m(servername);
 510         fstrcpy(printername, argv[1]);
 511         fstrcpy(user, cli->user_name);
 512
 513         /* get a printer handle */
 514         result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
 515                                 PRINTER_ALL_ACCESS, servername,
 516                                 user, &pol);
 517
 518         if (!W_ERROR_IS_OK(result))
 519                 goto done;
 520
 521         opened_hnd = True;
 522
 523         /* Get printer info */
 524         result = cli_spoolss_getprinter(cli, mem_ctx, 0, &needed, &pol, info_level, &ctr);
 525
 526         if (W_ERROR_V(result) == ERRinsufficientbuffer)
 527                 result = cli_spoolss_getprinter(cli, mem_ctx, needed, NULL, &pol, info_level, &ctr);
 528
 529         if (!W_ERROR_IS_OK(result))
 530                 goto done;
 531
 532
 533         /* Modify the comment. */
 534         init_unistr(&ctr.printers_2->comment, comment);
 535         ctr.printers_2->devmode = NULL;
 536         ctr.printers_2->secdesc = NULL;
 537
 538         result = cli_spoolss_setprinter(cli, mem_ctx, &pol, info_level, &ctr, 0);
 539         if (W_ERROR_IS_OK(result))
 540                 printf("Success in setting comment.\n");
 541
 542  done:
 543         if (opened_hnd)
 544                 cli_spoolss_close_printer(cli, mem_ctx, &pol);
 545
 546         return result;
 547 }
 548
 549 /***********************************************************************
 550  * Get printer information
 551  */
 552 static WERROR cmd_spoolss_getprinter(struct cli_state *cli,
 553                                        TALLOC_CTX *mem_ctx,
 554                                        int argc, const char **argv)
 555 {
 556         POLICY_HND      pol;
 557         WERROR          result;
 558         uint32          info_level = 1;
 559         BOOL            opened_hnd = False;
 560         PRINTER_INFO_CTR ctr;
 561         fstring         printername,
 562                         servername,
 563                         user;
 564         uint32 needed;
 565
 566         if (argc == 1 || argc > 3) {
 567                 printf("Usage: %s <printername> [level]\n", argv[0]);
 568                 return WERR_OK;
 569         }
 570
 571         /* Open a printer handle */
 572         if (argc == 3) {
 573                 info_level = atoi(argv[2]);
 574         }
 575
 576         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
 577         strupper_m(servername);
 578         slprintf(printername, sizeof(printername)-1, "%s\\%s", servername, argv[1]);
 579         fstrcpy(user, cli->user_name);
 580
 581         /* get a printer handle */
 582
 583         result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername,
 584                                              "", MAXIMUM_ALLOWED_ACCESS,
 585                                              servername, user, &pol);
 586
 587         if (!W_ERROR_IS_OK(result))
 588                 goto done;
 589
 590         opened_hnd = True;
 591
 592         /* Get printer info */
 593
 594         result = cli_spoolss_getprinter(cli, mem_ctx, 0, &needed,
 595                                         &pol, info_level, &ctr);
 596
 597         if (W_ERROR_V(result) == ERRinsufficientbuffer)
 598                 result = cli_spoolss_getprinter(
 599                         cli, mem_ctx, needed, NULL, &pol, info_level, &ctr);
 600
 601         if (!W_ERROR_IS_OK(result))
 602                 goto done;
 603
 604         /* Display printer info */
 605
 606         switch (info_level) {
 607         case 0:
 608                 display_print_info_0(ctr.printers_0);
 609                 break;
 610         case 1:
 611                 display_print_info_1(ctr.printers_1);
 612                 break;
 613         case 2:
 614                 display_print_info_2(ctr.printers_2);
 615                 break;
 616         case 3:
 617                 display_print_info_3(ctr.printers_3);
 618                 break;
 619         default:
 620                 printf("unknown info level %d\n", info_level);
 621                 break;
 622         }
 623
 624  done:
 625         if (opened_hnd)
 626                 cli_spoolss_close_printer(cli, mem_ctx, &pol);
 627
 628         return result;
 629 }
 630
 631 static void display_reg_value(REGISTRY_VALUE value)
 632 {
 633         pstring text;
 634
 635         switch(value.type) {
 636         case REG_DWORD:
 637                 printf("%s: REG_DWORD: 0x%08x\n", value.valuename,
 638                        *((uint32 *) value.data_p));
 639                 break;
 640         case REG_SZ:
 641                 rpcstr_pull(text, value.data_p, sizeof(text), value.size,
 642                             STR_TERMINATE);
 643                 printf("%s: REG_SZ: %s\n", value.valuename, text);
 644                 break;
 645         case REG_BINARY:
 646                 printf("%s: REG_BINARY: unknown length value not displayed\n",
 647                        value.valuename);
 648                 break;
 649         case REG_MULTI_SZ: {
 650                 uint16 *curstr = (uint16 *) value.data_p;
 651                 uint8 *start = value.data_p;
 652                 printf("%s: REG_MULTI_SZ:\n", value.valuename);
 653                 while ((*curstr != 0) &&
 654                        ((uint8 *) curstr < start + value.size)) {
 655                         rpcstr_pull(text, curstr, sizeof(text), -1,
 656                                     STR_TERMINATE);
 657                         printf("  %s\n", text);
 658                         curstr += strlen(text) + 1;
 659                 }
 660         }
 661         break;
 662         default:
 663                 printf("%s: unknown type %d\n", value.valuename, value.type);
 664         }
 665
 666 }
 667
 668 /***********************************************************************
 669  * Get printer data
 670  */
 671 static WERROR cmd_spoolss_getprinterdata(struct cli_state *cli,
 672                                            TALLOC_CTX *mem_ctx,
 673                                            int argc, const char **argv)
 674 {
 675         POLICY_HND      pol;
 676         WERROR          result;
 677         BOOL            opened_hnd = False;
 678         fstring         printername,
 679                         servername,
 680                         user;
 681         uint32 needed;
 682         const char *valuename;
 683         REGISTRY_VALUE value;
 684
 685         if (argc != 3) {
 686                 printf("Usage: %s <printername> <valuename>\n", argv[0]);
 687                 printf("<printername> of . queries print server\n");
 688                 return WERR_OK;
 689         }
 690         valuename = argv[2];
 691
 692         /* Open a printer handle */
 693
 694         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
 695         strupper_m(servername);
 696         if (strncmp(argv[1], ".", sizeof(".")) == 0)
 697                 fstrcpy(printername, servername);
 698         else
 699                 slprintf(printername, sizeof(servername)-1, "%s\\%s",
 700                           servername, argv[1]);
 701         fstrcpy(user, cli->user_name);
 702
 703         /* get a printer handle */
 704
 705         result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername,
 706                                              "", MAXIMUM_ALLOWED_ACCESS,
 707                                              servername, user, &pol);
 708
 709         if (!W_ERROR_IS_OK(result))
 710                 goto done;
 711
 712         opened_hnd = True;
 713
 714         /* Get printer info */
 715
 716         result = cli_spoolss_getprinterdata(cli, mem_ctx, 0, &needed,
 717                                             &pol, valuename, &value);
 718
 719         if (W_ERROR_V(result) == ERRmoredata)
 720                 result = cli_spoolss_getprinterdata(
 721                         cli, mem_ctx, needed, NULL, &pol, valuename, &value);
 722
 723         if (!W_ERROR_IS_OK(result))
 724                 goto done;
 725
 726         /* Display printer data */
 727
 728         fstrcpy(value.valuename, valuename);
 729         display_reg_value(value);
 730
 731
 732  done:
 733         if (opened_hnd)
 734                 cli_spoolss_close_printer(cli, mem_ctx, &pol);
 735
 736         return result;
 737 }
 738
 739 /***********************************************************************
 740  * Get printer data
 741  */
 742 static WERROR cmd_spoolss_getprinterdataex(struct cli_state *cli,
 743                                              TALLOC_CTX *mem_ctx,
 744                                              int argc, const char **argv)
 745 {
 746         POLICY_HND      pol;
 747         WERROR          result;
 748         BOOL            opened_hnd = False;
 749         fstring         printername,
 750                         servername,
 751                         user;
 752         uint32 needed;
 753         const char *valuename, *keyname;
 754         REGISTRY_VALUE value;
 755
 756         if (argc != 4) {
 757                 printf("Usage: %s <printername> <keyname> <valuename>\n",
 758                        argv[0]);
 759                 printf("<printername> of . queries print server\n");
 760                 return WERR_OK;
 761         }
 762         valuename = argv[3];
 763         keyname = argv[2];
 764
 765         /* Open a printer handle */
 766
 767         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
 768         strupper_m(servername);
 769         if (strncmp(argv[1], ".", sizeof(".")) == 0)
 770                 fstrcpy(printername, servername);
 771         else
 772                 slprintf(printername, sizeof(printername)-1, "%s\\%s",
 773                           servername, argv[1]);
 774         fstrcpy(user, cli->user_name);
 775
 776         /* get a printer handle */
 777
 778         result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername,
 779                                              "", MAXIMUM_ALLOWED_ACCESS,
 780                                              servername, user, &pol);
 781
 782         if (!W_ERROR_IS_OK(result))
 783                 goto done;
 784
 785         opened_hnd = True;
 786
 787         /* Get printer info */
 788
 789         result = cli_spoolss_getprinterdataex(cli, mem_ctx, 0, &needed,
 790                                               &pol, keyname, valuename,
 791                                               &value);
 792
 793         if (W_ERROR_V(result) == ERRmoredata)
 794                 result = cli_spoolss_getprinterdataex(cli, mem_ctx, needed,
 795                                                       NULL, &pol, keyname,
 796                                                       valuename, &value);
 797
 798         if (!W_ERROR_IS_OK(result))
 799                 goto done;
 800
 801         /* Display printer data */
 802
 803         fstrcpy(value.valuename, valuename);
 804         display_reg_value(value);
 805
 806
 807  done:
 808         if (opened_hnd)
 809                 cli_spoolss_close_printer(cli, mem_ctx, &pol);
 810
 811         return result;
 812 }
 813
 814 /****************************************************************************
 815 printer info level 0 display function
 816 ****************************************************************************/
 817 static void display_print_driver_1(DRIVER_INFO_1 *i1)
 818 {
 819         fstring name;
 820         if (i1 == NULL)
 821                 return;
 822
 823         rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
 824
 825         printf ("Printer Driver Info 1:\n");
 826         printf ("\tDriver Name: [%s]\n\n", name);
 827
 828         return;
 829 }
 830
 831 /****************************************************************************
 832 printer info level 1 display function
 833 ****************************************************************************/
 834 static void display_print_driver_2(DRIVER_INFO_2 *i1)
 835 {
 836         fstring name;
 837         fstring architecture;
 838         fstring driverpath;
 839         fstring datafile;
 840         fstring configfile;
 841         if (i1 == NULL)
 842                 return;
 843
 844         rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
 845         rpcstr_pull(architecture, i1->architecture.buffer, sizeof(architecture), -1, STR_TERMINATE);
 846         rpcstr_pull(driverpath, i1->driverpath.buffer, sizeof(driverpath), -1, STR_TERMINATE);
 847         rpcstr_pull(datafile, i1->datafile.buffer, sizeof(datafile), -1, STR_TERMINATE);
 848         rpcstr_pull(configfile, i1->configfile.buffer, sizeof(configfile), -1, STR_TERMINATE);
 849
 850         printf ("Printer Driver Info 2:\n");
 851         printf ("\tVersion: [%x]\n", i1->version);
 852         printf ("\tDriver Name: [%s]\n", name);
 853         printf ("\tArchitecture: [%s]\n", architecture);
 854         printf ("\tDriver Path: [%s]\n", driverpath);
 855         printf ("\tDatafile: [%s]\n", datafile);
 856         printf ("\tConfigfile: [%s]\n\n", configfile);
 857
 858         return;
 859 }
 860
 861 /****************************************************************************
 862 printer info level 2 display function
 863 ****************************************************************************/
 864 static void display_print_driver_3(DRIVER_INFO_3 *i1)
 865 {
 866         fstring name = "";
 867         fstring architecture = "";
 868         fstring driverpath = "";
 869         fstring datafile = "";
 870         fstring configfile = "";
 871         fstring helpfile = "";
 872         fstring dependentfiles = "";
 873         fstring monitorname = "";
 874         fstring defaultdatatype = "";
 875
 876         int length=0;
 877         BOOL valid = True;
 878
 879         if (i1 == NULL)
 880                 return;
 881
 882         rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
 883         rpcstr_pull(architecture, i1->architecture.buffer, sizeof(architecture), -1, STR_TERMINATE);
 884         rpcstr_pull(driverpath, i1->driverpath.buffer, sizeof(driverpath), -1, STR_TERMINATE);
 885         rpcstr_pull(datafile, i1->datafile.buffer, sizeof(datafile), -1, STR_TERMINATE);
 886         rpcstr_pull(configfile, i1->configfile.buffer, sizeof(configfile), -1, STR_TERMINATE);
 887         rpcstr_pull(helpfile, i1->helpfile.buffer, sizeof(helpfile), -1, STR_TERMINATE);
 888         rpcstr_pull(monitorname, i1->monitorname.buffer, sizeof(monitorname), -1, STR_TERMINATE);
 889         rpcstr_pull(defaultdatatype, i1->defaultdatatype.buffer, sizeof(defaultdatatype), -1, STR_TERMINATE);
 890
 891         printf ("Printer Driver Info 3:\n");
 892         printf ("\tVersion: [%x]\n", i1->version);
 893         printf ("\tDriver Name: [%s]\n",name);
 894         printf ("\tArchitecture: [%s]\n", architecture);
 895         printf ("\tDriver Path: [%s]\n", driverpath);
 896         printf ("\tDatafile: [%s]\n", datafile);
 897         printf ("\tConfigfile: [%s]\n", configfile);
 898         printf ("\tHelpfile: [%s]\n\n", helpfile);
 899
 900         while (valid)
 901         {
 902                 rpcstr_pull(dependentfiles, i1->dependentfiles+length, sizeof(dependentfiles), -1, STR_TERMINATE);
 903
 904                 length+=strlen(dependentfiles)+1;
 905
 906                 if (strlen(dependentfiles) > 0)
 907                 {
 908                         printf ("\tDependentfiles: [%s]\n", dependentfiles);
 909                 }
 910                 else
 911                 {
 912                         valid = False;
 913                 }
 914         }
 915
 916         printf ("\n");
 917
 918         printf ("\tMonitorname: [%s]\n", monitorname);
 919         printf ("\tDefaultdatatype: [%s]\n\n", defaultdatatype);
 920
 921         return;
 922 }
 923
 924 /***********************************************************************
 925  * Get printer information
 926  */
 927 static WERROR cmd_spoolss_getdriver(struct cli_state *cli,
 928                                       TALLOC_CTX *mem_ctx,
 929                                       int argc, const char **argv)
 930 {
 931         POLICY_HND      pol;
 932         WERROR          werror;
 933         uint32          info_level = 3;
 934         BOOL            opened_hnd = False;
 935         PRINTER_DRIVER_CTR      ctr;
 936         fstring         printername,
 937                         servername,
 938                         user;
 939         uint32          i;
 940         BOOL            success = False;
 941
 942         if ((argc == 1) || (argc > 3))
 943         {
 944                 printf("Usage: %s <printername> [level]\n", argv[0]);
 945                 return WERR_OK;
 946         }
 947
 948         /* get the arguments need to open the printer handle */
 949         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
 950         strupper_m(servername);
 951         fstrcpy(user, cli->user_name);
 952         fstrcpy(printername, argv[1]);
 953         if (argc == 3)
 954                 info_level = atoi(argv[2]);
 955
 956         /* Open a printer handle */
 957
 958         werror = cli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
 959                                              PRINTER_ACCESS_USE,
 960                                              servername, user, &pol);
 961
 962         if (!W_ERROR_IS_OK(werror)) {
 963                 printf("Error opening printer handle for %s!\n", printername);
 964                 return werror;
 965         }
 966
 967         opened_hnd = True;
 968
 969         /* loop through and print driver info level for each architecture */
 970
 971         for (i=0; archi_table[i].long_archi!=NULL; i++) {
 972                 uint32 needed;
 973
 974                 werror = cli_spoolss_getprinterdriver(
 975                         cli, mem_ctx, 0, &needed, &pol, info_level,
 976                         archi_table[i].long_archi, archi_table[i].version,
 977                         &ctr);
 978
 979                 if (W_ERROR_V(werror) == ERRinsufficientbuffer) {
 980                         werror = cli_spoolss_getprinterdriver(
 981                                 cli, mem_ctx, needed, NULL, &pol, info_level,
 982                                 archi_table[i].long_archi, archi_table[i].version,
 983                                 &ctr);
 984                 }
 985
 986                 if (!W_ERROR_IS_OK(werror))
 987                         continue;
 988
 989                 /* need at least one success */
 990
 991                 success = True;
 992
 993                 printf ("\n[%s]\n", archi_table[i].long_archi);
 994
 995                 switch (info_level) {
 996                 case 1:
 997                         display_print_driver_1 (ctr.info1);
 998                         break;
 999                 case 2:
1000                         display_print_driver_2 (ctr.info2);
1001                         break;
1002                 case 3:
1003                         display_print_driver_3 (ctr.info3);
1004                         break;
1005                 default:
1006                         printf("unknown info level %d\n", info_level);
1007                         break;
1008                 }
1009         }
1010
1011         /* Cleanup */
1012
1013         if (opened_hnd)
1014                 cli_spoolss_close_printer (cli, mem_ctx, &pol);
1015
1016         if ( success )
1017                 werror = WERR_OK;
1018
1019         return werror;
1020 }
1021
1022 /***********************************************************************
1023  * Get printer information
1024  */
1025 static WERROR cmd_spoolss_enum_drivers(struct cli_state *cli,
1026                                          TALLOC_CTX *mem_ctx,
1027                                          int argc, const char **argv)
1028 {
1029         WERROR werror;
1030         uint32          info_level = 1;
1031         PRINTER_DRIVER_CTR      ctr;
1032         uint32          i, j,
1033                         returned;
1034
1035         if (argc > 2)
1036         {
1037                 printf("Usage: enumdrivers [level]\n");
1038                 return WERR_OK;
1039         }
1040
1041         if (argc == 2)
1042                 info_level = atoi(argv[1]);
1043
1044
1045         /* loop through and print driver info level for each architecture */
1046         for (i=0; archi_table[i].long_archi!=NULL; i++)
1047         {
1048                 uint32 needed;
1049
1050                 werror = cli_spoolss_enumprinterdrivers(
1051                         cli, mem_ctx, 0, &needed, info_level,
1052                         archi_table[i].long_archi, &returned, &ctr);
1053
1054                 if (W_ERROR_V(werror) == ERRinsufficientbuffer)
1055                         werror = cli_spoolss_enumprinterdrivers(
1056                                 cli, mem_ctx, needed, NULL, info_level,
1057                                 archi_table[i].long_archi, &returned, &ctr);
1058
1059                 if (returned == 0)
1060                         continue;
1061
1062                 if (!W_ERROR_IS_OK(werror)) {
1063                         printf ("Error getting driver for environment [%s] - %d\n",
1064                                 archi_table[i].long_archi, W_ERROR_V(werror));
1065                         continue;
1066                 }
1067
1068                 printf ("\n[%s]\n", archi_table[i].long_archi);
1069                 switch (info_level)
1070                 {
1071
1072                 case 1:
1073                         for (j=0; j < returned; j++) {
1074                                 display_print_driver_1 (&(ctr.info1[j]));
1075                         }
1076                         break;
1077                 case 2:
1078                         for (j=0; j < returned; j++) {
1079                                 display_print_driver_2 (&(ctr.info2[j]));
1080                         }
1081                         break;
1082                 case 3:
1083                         for (j=0; j < returned; j++) {
1084                                 display_print_driver_3 (&(ctr.info3[j]));
1085                         }
1086                         break;
1087                 default:
1088                         printf("unknown info level %d\n", info_level);
1089                         break;
1090                 }
1091         }
1092
1093         return werror;
1094 }
1095
1096 /****************************************************************************
1097 printer info level 1 display function
1098 ****************************************************************************/
1099 static void display_printdriverdir_1(DRIVER_DIRECTORY_1 *i1)
1100 {
1101         fstring name;
1102         if (i1 == NULL)
1103                 return;
1104
1105         rpcstr_pull(name, i1->name.buffer, sizeof(name), -1, STR_TERMINATE);
1106
1107         printf ("\tDirectory Name:[%s]\n", name);
1108 }
1109
1110 /***********************************************************************
1111  * Get printer driver directory information
1112  */
1113 static WERROR cmd_spoolss_getdriverdir(struct cli_state *cli,
1114                                          TALLOC_CTX *mem_ctx,
1115                                          int argc, const char **argv)
1116 {
1117         WERROR result;
1118         fstring                 env;
1119         DRIVER_DIRECTORY_CTR    ctr;
1120         uint32 needed;
1121
1122         if (argc > 2) {
1123                 printf("Usage: %s [environment]\n", argv[0]);
1124                 return WERR_OK;
1125         }
1126
1127         /* Get the arguments need to open the printer handle */
1128
1129         if (argc == 2)
1130                 fstrcpy (env, argv[1]);
1131         else
1132                 fstrcpy (env, "Windows NT x86");
1133
1134         /* Get the directory.  Only use Info level 1 */
1135
1136         result = cli_spoolss_getprinterdriverdir(
1137                 cli, mem_ctx, 0, &needed, 1, env, &ctr);
1138
1139         if (W_ERROR_V(result) == ERRinsufficientbuffer)
1140                 result = cli_spoolss_getprinterdriverdir(
1141                         cli, mem_ctx, needed, NULL, 1, env, &ctr);
1142
1143         if (W_ERROR_IS_OK(result))
1144                 display_printdriverdir_1(ctr.info1);
1145
1146         return result;
1147 }
1148
1149 /*******************************************************************************
1150  set the version and environment fields of a DRIVER_INFO_3 struct
1151  ******************************************************************************/
1152 void set_drv_info_3_env (DRIVER_INFO_3 *info, const char *arch)
1153 {
1154
1155         int i;
1156
1157         for (i=0; archi_table[i].long_archi != NULL; i++)
1158         {
1159                 if (strcmp(arch, archi_table[i].short_archi) == 0)
1160                 {
1161                         info->version = archi_table[i].version;
1162                         init_unistr (&info->architecture, archi_table[i].long_archi);
1163                         break;
1164                 }
1165         }
1166
1167         if (archi_table[i].long_archi == NULL)
1168         {
1169                 DEBUG(0, ("set_drv_info_3_env: Unknown arch [%s]\n", arch));
1170         }
1171
1172         return;
1173 }
1174
1175
1176 /**************************************************************************
1177  wrapper for strtok to get the next parameter from a delimited list.
1178  Needed to handle the empty parameter string denoted by "NULL"
1179  *************************************************************************/
1180 static char* get_driver_3_param (const char* str, const char* delim, UNISTR* dest)
1181 {
1182         char    *ptr;
1183
1184         /* get the next token */
1185         ptr = strtok(str, delim);
1186
1187         /* a string of 'NULL' is used to represent an empty
1188            parameter because two consecutive delimiters
1189            will not return an empty string.  See man strtok(3)
1190            for details */
1191         if (ptr && (StrCaseCmp(ptr, "NULL") == 0))
1192                 ptr = NULL;
1193
1194         if (dest != NULL)
1195                 init_unistr(dest, ptr);
1196
1197         return ptr;
1198 }
1199
1200 /********************************************************************************
1201  fill in the members of a DRIVER_INFO_3 struct using a character
1202  string in the form of
1203          <Long Printer Name>:<Driver File Name>:<Data File Name>:\
1204              <Config File Name>:<Help File Name>:<Language Monitor Name>:\
1205              <Default Data Type>:<Comma Separated list of Files>
1206  *******************************************************************************/
1207 static BOOL init_drv_info_3_members (
1208         TALLOC_CTX *mem_ctx,
1209         DRIVER_INFO_3 *info,
1210         const char *args
1211 )
1212 {
1213         char    *str, *str2;
1214         uint32  len, i;
1215
1216         /* fill in the UNISTR fields */
1217         str = get_driver_3_param (args, ":", &info->name);
1218         str = get_driver_3_param (NULL, ":", &info->driverpath);
1219         str = get_driver_3_param (NULL, ":", &info->datafile);
1220         str = get_driver_3_param (NULL, ":", &info->configfile);
1221         str = get_driver_3_param (NULL, ":", &info->helpfile);
1222         str = get_driver_3_param (NULL, ":", &info->monitorname);
1223         str = get_driver_3_param (NULL, ":", &info->defaultdatatype);
1224
1225         /* <Comma Separated List of Dependent Files> */
1226         str2 = get_driver_3_param (NULL, ":", NULL); /* save the beginning of the string */
1227         str = str2;
1228
1229         /* begin to strip out each filename */
1230         str = strtok(str, ",");
1231         len = 0;
1232         while (str != NULL)
1233         {
1234                 /* keep a cumlative count of the str lengths */
1235                 len += strlen(str)+1;
1236                 str = strtok(NULL, ",");
1237         }
1238
1239         /* allocate the space; add one extra slot for a terminating NULL.
1240            Each filename is NULL terminated and the end contains a double
1241            NULL */
1242         if ((info->dependentfiles=(uint16*)talloc(mem_ctx, (len+1)*sizeof(uint16))) == NULL)
1243         {
1244                 DEBUG(0,("init_drv_info_3_members: Unable to malloc memory for dependenfiles\n"));
1245                 return False;
1246         }
1247         for (i=0; i<len; i++)
1248         {
1249                 SSVAL(&info->dependentfiles[i], 0, str2[i]);
1250         }
1251         info->dependentfiles[len] = '\0';
1252
1253         return True;
1254 }
1255
1256
1257 static WERROR cmd_spoolss_addprinterdriver(struct cli_state *cli,
1258                                              TALLOC_CTX *mem_ctx,
1259                                              int argc, const char **argv)
1260 {
1261         WERROR result;
1262         uint32                  level = 3;
1263         PRINTER_DRIVER_CTR      ctr;
1264         DRIVER_INFO_3           info3;
1265         const char              *arch;
1266         fstring                 driver_name;
1267
1268         /* parse the command arguements */
1269         if (argc != 3)
1270         {
1271                 printf ("Usage: %s <Environment>\\\n", argv[0]);
1272                 printf ("\t<Long Printer Name>:<Driver File Name>:<Data File Name>:\\\n");
1273                 printf ("\t<Config File Name>:<Help File Name>:<Language Monitor Name>:\\\n");
1274                 printf ("\t<Default Data Type>:<Comma Separated list of Files>\n");
1275
1276             return WERR_OK;
1277         }
1278
1279         /* Fill in the DRIVER_INFO_3 struct */
1280         ZERO_STRUCT(info3);
1281         if (!(arch = cmd_spoolss_get_short_archi(argv[1])))
1282         {
1283                 printf ("Error Unknown architechture [%s]\n", argv[1]);
1284                 return WERR_INVALID_PARAM;
1285         }
1286         else
1287                 set_drv_info_3_env(&info3, arch);
1288
1289         if (!init_drv_info_3_members(mem_ctx, &info3, argv[2]))
1290         {
1291                 printf ("Error Invalid parameter list - %s.\n", argv[2]);
1292                 return WERR_INVALID_PARAM;
1293         }
1294
1295
1296         ctr.info3 = &info3;
1297         result = cli_spoolss_addprinterdriver (cli, mem_ctx, level, &ctr);
1298
1299         if (W_ERROR_IS_OK(result)) {
1300                 rpcstr_pull(driver_name, info3.name.buffer,
1301                             sizeof(driver_name), -1, STR_TERMINATE);
1302                 printf ("Printer Driver %s successfully installed.\n",
1303                         driver_name);
1304         }
1305
1306         return result;
1307 }
1308
1309
1310 static WERROR cmd_spoolss_addprinterex(struct cli_state *cli,
1311                                          TALLOC_CTX *mem_ctx,
1312                                          int argc, const char **argv)
1313 {
1314         WERROR result;
1315         uint32                  level = 2;
1316         PRINTER_INFO_CTR        ctr;
1317         PRINTER_INFO_2          info2;
1318         fstring                 servername;
1319
1320         /* parse the command arguements */
1321         if (argc != 5)
1322         {
1323                 printf ("Usage: %s <name> <shared name> <driver> <port>\n", argv[0]);
1324                 return WERR_OK;
1325         }
1326
1327         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
1328         strupper_m(servername);
1329
1330         /* Fill in the DRIVER_INFO_3 struct */
1331         ZERO_STRUCT(info2);
1332 #if 0   /* JERRY */
1333         init_unistr( &info2.servername,         servername);
1334 #endif
1335         init_unistr( &info2.printername,        argv[1]);
1336         init_unistr( &info2.sharename,          argv[2]);
1337         init_unistr( &info2.drivername,         argv[3]);
1338         init_unistr( &info2.portname,           argv[4]);
1339         init_unistr( &info2.comment,            "Created by rpcclient");
1340         init_unistr( &info2.printprocessor,     "winprint");
1341         init_unistr( &info2.datatype,           "RAW");
1342         info2.devmode =         NULL;
1343         info2.secdesc =         NULL;
1344         info2.attributes        = PRINTER_ATTRIBUTE_SHARED;
1345         info2.priority          = 0;
1346         info2.defaultpriority   = 0;
1347         info2.starttime         = 0;
1348         info2.untiltime         = 0;
1349
1350         /* These three fields must not be used by AddPrinter()
1351            as defined in the MS Platform SDK documentation..
1352            --jerry
1353         info2.status            = 0;
1354         info2.cjobs             = 0;
1355         info2.averageppm        = 0;
1356         */
1357
1358         ctr.printers_2 = &info2;
1359         result = cli_spoolss_addprinterex (cli, mem_ctx, level, &ctr);
1360
1361         if (W_ERROR_IS_OK(result))
1362                 printf ("Printer %s successfully installed.\n", argv[1]);
1363
1364         return result;
1365 }
1366
1367 static WERROR cmd_spoolss_setdriver(struct cli_state *cli,
1368                                       TALLOC_CTX *mem_ctx,
1369                                       int argc, const char **argv)
1370 {
1371         POLICY_HND              pol;
1372         WERROR                  result;
1373         uint32                  level = 2;
1374         BOOL                    opened_hnd = False;
1375         PRINTER_INFO_CTR        ctr;
1376         PRINTER_INFO_2          info2;
1377         fstring                 servername,
1378                                 printername,
1379                                 user;
1380         uint32 needed;
1381
1382         /* parse the command arguements */
1383         if (argc != 3)
1384         {
1385                 printf ("Usage: %s <printer> <driver>\n", argv[0]);
1386                 return WERR_OK;
1387         }
1388
1389         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
1390         strupper_m(servername);
1391         slprintf(printername, sizeof(printername)-1, "%s\\%s", servername, argv[1]);
1392         fstrcpy(user, cli->user_name);
1393
1394         /* Get a printer handle */
1395
1396         result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
1397                                              PRINTER_ALL_ACCESS,
1398                                              servername, user, &pol);
1399
1400         if (!W_ERROR_IS_OK(result))
1401                 goto done;
1402
1403         opened_hnd = True;
1404
1405         /* Get printer info */
1406
1407         ZERO_STRUCT (info2);
1408         ctr.printers_2 = &info2;
1409
1410         result = cli_spoolss_getprinter(cli, mem_ctx, 0, &needed,
1411                                         &pol, level, &ctr);
1412
1413         if (W_ERROR_V(result) == ERRinsufficientbuffer)
1414                 result = cli_spoolss_getprinter(
1415                         cli, mem_ctx, needed, NULL, &pol, level, &ctr);
1416
1417         if (!W_ERROR_IS_OK(result)) {
1418                 printf ("Unable to retrieve printer information!\n");
1419                 goto done;
1420         }
1421
1422         /* Set the printer driver */
1423
1424         init_unistr(&ctr.printers_2->drivername, argv[2]);
1425
1426         result = cli_spoolss_setprinter(cli, mem_ctx, &pol, level, &ctr, 0);
1427
1428         if (!W_ERROR_IS_OK(result)) {
1429                 printf("SetPrinter call failed!\n");
1430                 goto done;;
1431         }
1432
1433         printf("Succesfully set %s to driver %s.\n", argv[1], argv[2]);
1434
1435 done:
1436         /* Cleanup */
1437
1438         if (opened_hnd)
1439                 cli_spoolss_close_printer(cli, mem_ctx, &pol);
1440
1441         return result;
1442 }
1443
1444
1445 static WERROR cmd_spoolss_deletedriver(struct cli_state *cli,
1446                                          TALLOC_CTX *mem_ctx,
1447                                          int argc, const char **argv)
1448 {
1449         WERROR result;
1450         fstring                 servername;
1451         int                     i;
1452
1453         /* parse the command arguements */
1454         if (argc != 2)
1455         {
1456                 printf ("Usage: %s <driver>\n", argv[0]);
1457                 return WERR_OK;
1458         }
1459
1460         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
1461         strupper_m(servername);
1462
1463         /* delete the driver for all architectures */
1464         for (i=0; archi_table[i].long_archi; i++)
1465         {
1466                 /* make the call to remove the driver */
1467                 result = cli_spoolss_deleteprinterdriver(
1468                         cli, mem_ctx, archi_table[i].long_archi, argv[1]);
1469
1470                 if ( !W_ERROR_IS_OK(result) ) {
1471                         if ( !W_ERROR_EQUAL(result, WERR_UNKNOWN_PRINTER_DRIVER) ) {
1472                                 printf ("Failed to remove driver %s for arch [%s] - error 0x%x!\n",
1473                                         argv[1], archi_table[i].long_archi,
1474                                         W_ERROR_V(result));
1475                         }
1476                 }
1477                 else
1478                 {
1479                         printf ("Driver %s removed for arch [%s].\n", argv[1],
1480                                 archi_table[i].long_archi);
1481                 }
1482         }
1483
1484         return result;
1485 }
1486
1487 static WERROR cmd_spoolss_getprintprocdir(struct cli_state *cli,
1488                                             TALLOC_CTX *mem_ctx,
1489                                             int argc, const char **argv)
1490 {
1491         WERROR result;
1492         char *servername = NULL, *environment = NULL;
1493         fstring procdir;
1494         uint32 needed;
1495
1496         /* parse the command arguements */
1497         if (argc > 2) {
1498                 printf ("Usage: %s [environment]\n", argv[0]);
1499                 return WERR_OK;
1500         }
1501
1502         if (asprintf(&servername, "\\\\%s", cli->desthost) < 0)
1503                 return WERR_NOMEM;
1504         strupper_m(servername);
1505
1506         if (asprintf(&environment, "%s", (argc == 2) ? argv[1] :
1507                      PRINTER_DRIVER_ARCHITECTURE) < 0) {
1508                 SAFE_FREE(servername);
1509                 return WERR_NOMEM;
1510         }
1511
1512         result = cli_spoolss_getprintprocessordirectory(
1513                 cli, mem_ctx, 0, &needed, servername, environment, procdir);
1514
1515         if (W_ERROR_V(result) == ERRinsufficientbuffer)
1516                 result = cli_spoolss_getprintprocessordirectory(
1517                         cli, mem_ctx, needed, NULL, servername, environment,
1518                         procdir);
1519
1520         if (W_ERROR_IS_OK(result))
1521                 printf("%s\n", procdir);
1522
1523         SAFE_FREE(servername);
1524         SAFE_FREE(environment);
1525
1526         return result;
1527 }
1528
1529 /* Add a form */
1530
1531 static WERROR cmd_spoolss_addform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1532                                     int argc, const char **argv)
1533 {
1534         POLICY_HND handle;
1535         WERROR werror;
1536         char *servername = NULL, *printername = NULL;
1537         FORM form;
1538         BOOL got_handle = False;
1539
1540         /* Parse the command arguements */
1541
1542         if (argc != 3) {
1543                 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1544                 return WERR_OK;
1545         }
1546
1547         /* Get a printer handle */
1548
1549         asprintf(&servername, "\\\\%s", cli->desthost);
1550         strupper_m(servername);
1551         asprintf(&printername, "%s\\%s", servername, argv[1]);
1552
1553         werror = cli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
1554                                              MAXIMUM_ALLOWED_ACCESS,
1555                                              servername, cli->user_name, &handle);
1556
1557         if (!W_ERROR_IS_OK(werror))
1558                 goto done;
1559
1560         got_handle = True;
1561
1562         /* Dummy up some values for the form data */
1563
1564         form.flags = FORM_USER;
1565         form.size_x = form.size_y = 100;
1566         form.left = 0;
1567         form.top = 10;
1568         form.right = 20;
1569         form.bottom = 30;
1570
1571         init_unistr2(&form.name, argv[2], UNI_STR_TERMINATE);
1572
1573         /* Add the form */
1574
1575
1576         werror = cli_spoolss_addform(cli, mem_ctx, &handle, 1, &form);
1577
1578  done:
1579         if (got_handle)
1580                 cli_spoolss_close_printer(cli, mem_ctx, &handle);
1581
1582         SAFE_FREE(servername);
1583         SAFE_FREE(printername);
1584
1585         return werror;
1586 }
1587
1588 /* Set a form */
1589
1590 static WERROR cmd_spoolss_setform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1591                                     int argc, const char **argv)
1592 {
1593         POLICY_HND handle;
1594         WERROR werror;
1595         char *servername = NULL, *printername = NULL;
1596         FORM form;
1597         BOOL got_handle = False;
1598
1599         /* Parse the command arguements */
1600
1601         if (argc != 3) {
1602                 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1603                 return WERR_OK;
1604         }
1605
1606         /* Get a printer handle */
1607
1608         asprintf(&servername, "\\\\%s", cli->desthost);
1609         strupper_m(servername);
1610         asprintf(&printername, "%s\\%s", servername, argv[1]);
1611
1612         werror = cli_spoolss_open_printer_ex(
1613                 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1614                 servername, cli->user_name, &handle);
1615
1616         if (!W_ERROR_IS_OK(werror))
1617                 goto done;
1618
1619         got_handle = True;
1620
1621         /* Dummy up some values for the form data */
1622
1623         form.flags = FORM_PRINTER;
1624         form.size_x = form.size_y = 100;
1625         form.left = 0;
1626         form.top = 1000;
1627         form.right = 2000;
1628         form.bottom = 3000;
1629
1630         init_unistr2(&form.name, argv[2], UNI_STR_TERMINATE);
1631
1632         /* Set the form */
1633
1634         werror = cli_spoolss_setform(cli, mem_ctx, &handle, 1, argv[2], &form);
1635
1636  done:
1637         if (got_handle)
1638                 cli_spoolss_close_printer(cli, mem_ctx, &handle);
1639
1640         SAFE_FREE(servername);
1641         SAFE_FREE(printername);
1642
1643         return werror;
1644 }
1645
1646 /* Get a form */
1647
1648 static WERROR cmd_spoolss_getform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1649                                     int argc, const char **argv)
1650 {
1651         POLICY_HND handle;
1652         WERROR werror;
1653         char *servername = NULL, *printername = NULL;
1654         FORM_1 form;
1655         BOOL got_handle = False;
1656         uint32 needed;
1657
1658         /* Parse the command arguements */
1659
1660         if (argc != 3) {
1661                 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1662                 return WERR_OK;
1663         }
1664
1665         /* Get a printer handle */
1666
1667         asprintf(&servername, "\\\\%s", cli->desthost);
1668         strupper_m(servername);
1669         asprintf(&printername, "%s\\%s", servername, argv[1]);
1670
1671         werror = cli_spoolss_open_printer_ex(
1672                 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1673                 servername, cli->user_name, &handle);
1674
1675         if (!W_ERROR_IS_OK(werror))
1676                 goto done;
1677
1678         got_handle = True;
1679
1680         /* Set the form */
1681
1682         werror = cli_spoolss_getform(cli, mem_ctx, 0, &needed,
1683                                      &handle, argv[2], 1, &form);
1684
1685         if (W_ERROR_V(werror) == ERRinsufficientbuffer)
1686                 werror = cli_spoolss_getform(cli, mem_ctx, needed, NULL,
1687                                              &handle, argv[2], 1, &form);
1688
1689         if (!W_ERROR_IS_OK(werror))
1690                 goto done;
1691
1692         printf("width: %d\n", form.width);
1693         printf("length: %d\n", form.length);
1694         printf("left: %d\n", form.left);
1695         printf("top: %d\n", form.top);
1696         printf("right: %d\n", form.right);
1697         printf("bottom: %d\n", form.bottom);
1698
1699  done:
1700         if (got_handle)
1701                 cli_spoolss_close_printer(cli, mem_ctx, &handle);
1702
1703         SAFE_FREE(servername);
1704         SAFE_FREE(printername);
1705
1706         return werror;
1707 }
1708
1709 /* Delete a form */
1710
1711 static WERROR cmd_spoolss_deleteform(struct cli_state *cli,
1712                                        TALLOC_CTX *mem_ctx, int argc,
1713                                        const char **argv)
1714 {
1715         POLICY_HND handle;
1716         WERROR werror;
1717         char *servername = NULL, *printername = NULL;
1718         BOOL got_handle = False;
1719
1720         /* Parse the command arguements */
1721
1722         if (argc != 3) {
1723                 printf ("Usage: %s <printer> <formname>\n", argv[0]);
1724                 return WERR_OK;
1725         }
1726
1727         /* Get a printer handle */
1728
1729         asprintf(&servername, "\\\\%s", cli->desthost);
1730         strupper_m(servername);
1731         asprintf(&printername, "%s\\%s", servername, argv[1]);
1732
1733         werror = cli_spoolss_open_printer_ex(
1734                 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1735                 servername, cli->user_name, &handle);
1736
1737         if (!W_ERROR_IS_OK(werror))
1738                 goto done;
1739
1740         got_handle = True;
1741
1742         /* Delete the form */
1743
1744         werror = cli_spoolss_deleteform(cli, mem_ctx, &handle, argv[2]);
1745
1746  done:
1747         if (got_handle)
1748                 cli_spoolss_close_printer(cli, mem_ctx, &handle);
1749
1750         SAFE_FREE(servername);
1751         SAFE_FREE(printername);
1752
1753         return werror;
1754 }
1755
1756 /* Enumerate forms */
1757
1758 static WERROR cmd_spoolss_enum_forms(struct cli_state *cli,
1759                                        TALLOC_CTX *mem_ctx, int argc,
1760                                        const char **argv)
1761 {
1762         POLICY_HND handle;
1763         WERROR werror;
1764         char *servername = NULL, *printername = NULL;
1765         BOOL got_handle = False;
1766         uint32 needed, num_forms, level = 1, i;
1767         FORM_1 *forms;
1768
1769         /* Parse the command arguements */
1770
1771         if (argc != 2) {
1772                 printf ("Usage: %s <printer>\n", argv[0]);
1773                 return WERR_OK;
1774         }
1775
1776         /* Get a printer handle */
1777
1778         asprintf(&servername, "\\\\%s", cli->desthost);
1779         strupper_m(servername);
1780         asprintf(&printername, "%s\\%s", servername, argv[1]);
1781
1782         werror = cli_spoolss_open_printer_ex(
1783                 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
1784                 servername, cli->user_name, &handle);
1785
1786         if (!W_ERROR_IS_OK(werror))
1787                 goto done;
1788
1789         got_handle = True;
1790
1791         /* Enumerate forms */
1792
1793         werror = cli_spoolss_enumforms(
1794                 cli, mem_ctx, 0, &needed, &handle, level, &num_forms, &forms);
1795
1796         if (W_ERROR_V(werror) == ERRinsufficientbuffer)
1797                 werror = cli_spoolss_enumforms(
1798                         cli, mem_ctx, needed, NULL, &handle, level,
1799                         &num_forms, &forms);
1800
1801         if (!W_ERROR_IS_OK(werror))
1802                 goto done;
1803
1804         /* Display output */
1805
1806         for (i = 0; i < num_forms; i++) {
1807                 fstring form_name;
1808
1809                 if (forms[i].name.buffer)
1810                         rpcstr_pull(form_name, forms[i].name.buffer,
1811                                     sizeof(form_name), -1, STR_TERMINATE);
1812
1813                 printf("%s\n", form_name);
1814         }
1815
1816  done:
1817         if (got_handle)
1818                 cli_spoolss_close_printer(cli, mem_ctx, &handle);
1819
1820         SAFE_FREE(servername);
1821         SAFE_FREE(printername);
1822
1823         return werror;
1824 }
1825
1826 static WERROR cmd_spoolss_setprinterdata(struct cli_state *cli,
1827                                             TALLOC_CTX *mem_ctx,
1828                                             int argc, const char **argv)
1829 {
1830         WERROR result;
1831         uint32 needed;
1832         fstring servername, printername, user;
1833         POLICY_HND pol;
1834         BOOL opened_hnd = False;
1835         PRINTER_INFO_CTR ctr;
1836         PRINTER_INFO_0 info;
1837         REGISTRY_VALUE value;
1838
1839         /* parse the command arguements */
1840         if (argc != 4) {
1841                 printf ("Usage: %s <printer> <value> <data>\n", argv[0]);
1842                 return WERR_OK;
1843         }
1844
1845         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
1846         strupper_m(servername);
1847         slprintf(printername, sizeof(servername)-1, "%s\\%s", servername, argv[1]);
1848         fstrcpy(user, cli->user_name);
1849
1850         /* get a printer handle */
1851         result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername, "",
1852                                              MAXIMUM_ALLOWED_ACCESS, servername,
1853                                              user, &pol);
1854         if (!W_ERROR_IS_OK(result))
1855                 goto done;
1856
1857         opened_hnd = True;
1858
1859         ctr.printers_0 = &info;
1860
1861         result = cli_spoolss_getprinter(cli, mem_ctx, 0, &needed,
1862                                         &pol, 0, &ctr);
1863
1864         if (W_ERROR_V(result) == ERRinsufficientbuffer)
1865                 result = cli_spoolss_getprinter(cli, mem_ctx, needed, NULL, &pol, 0, &ctr);
1866
1867         if (!W_ERROR_IS_OK(result))
1868                 goto done;
1869
1870         printf("%s\n", timestring(True));
1871         printf("\tchange_id (before set)\t:[0x%x]\n", info.change_id);
1872
1873         /* Set the printer data */
1874
1875         fstrcpy(value.valuename, argv[2]);
1876         value.type = REG_SZ;
1877         value.size = strlen(argv[3]) + 1;
1878         value.data_p = talloc_memdup(mem_ctx, argv[3], value.size);
1879
1880         result = cli_spoolss_setprinterdata(cli, mem_ctx, &pol, &value);
1881
1882         if (!W_ERROR_IS_OK(result)) {
1883                 printf ("Unable to set [%s=%s]!\n", argv[2], argv[3]);
1884                 goto done;
1885         }
1886         printf("\tSetPrinterData succeeded [%s: %s]\n", argv[2], argv[3]);
1887
1888         result = cli_spoolss_getprinter(cli, mem_ctx, 0, &needed, &pol, 0, &ctr);
1889
1890         if (W_ERROR_V(result) == ERRinsufficientbuffer)
1891                 result = cli_spoolss_getprinter(cli, mem_ctx, needed, NULL, &pol, 0, &ctr);
1892
1893         if (!W_ERROR_IS_OK(result))
1894                 goto done;
1895
1896         printf("%s\n", timestring(True));
1897         printf("\tchange_id (after set)\t:[0x%x]\n", info.change_id);
1898
1899 done:
1900         /* cleanup */
1901         if (opened_hnd)
1902                 cli_spoolss_close_printer(cli, mem_ctx, &pol);
1903
1904         return result;
1905 }
1906
1907 static void display_job_info_1(JOB_INFO_1 *job)
1908 {
1909         fstring username = "", document = "", text_status = "";
1910
1911         rpcstr_pull(username, job->username.buffer,
1912                     sizeof(username), -1, STR_TERMINATE);
1913
1914         rpcstr_pull(document, job->document.buffer,
1915                     sizeof(document), -1, STR_TERMINATE);
1916
1917         rpcstr_pull(text_status, job->text_status.buffer,
1918                     sizeof(text_status), -1, STR_TERMINATE);
1919
1920         printf("%d: jobid[%d]: %s %s %s %d/%d pages\n", job->position, job->jobid,
1921                username, document, text_status, job->pagesprinted,
1922                job->totalpages);
1923 }
1924
1925 static void display_job_info_2(JOB_INFO_2 *job)
1926 {
1927         fstring username = "", document = "", text_status = "";
1928
1929         rpcstr_pull(username, job->username.buffer,
1930                     sizeof(username), -1, STR_TERMINATE);
1931
1932         rpcstr_pull(document, job->document.buffer,
1933                     sizeof(document), -1, STR_TERMINATE);
1934
1935         rpcstr_pull(text_status, job->text_status.buffer,
1936                     sizeof(text_status), -1, STR_TERMINATE);
1937
1938         printf("%d: jobid[%d]: %s %s %s %d/%d pages, %d bytes\n", job->position, job->jobid,
1939                username, document, text_status, job->pagesprinted,
1940                job->totalpages, job->size);
1941 }
1942
1943 /* Enumerate jobs */
1944
1945 static WERROR cmd_spoolss_enum_jobs(struct cli_state *cli,
1946                                       TALLOC_CTX *mem_ctx, int argc,
1947                                       const char **argv)
1948 {
1949         WERROR result;
1950         uint32 needed, level = 1, num_jobs, i;
1951         BOOL got_hnd = False;
1952         pstring printername;
1953         fstring servername, user;
1954         POLICY_HND hnd;
1955         JOB_INFO_CTR ctr;
1956
1957         if (argc < 2 || argc > 3) {
1958                 printf("Usage: %s printername [level]\n", argv[0]);
1959                 return WERR_OK;
1960         }
1961
1962         if (argc == 3)
1963                 level = atoi(argv[2]);
1964
1965         /* Open printer handle */
1966
1967         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
1968         strupper_m(servername);
1969         fstrcpy(user, cli->user_name);
1970         slprintf(printername, sizeof(servername)-1, "\\\\%s\\", cli->desthost);
1971         strupper_m(printername);
1972         pstrcat(printername, argv[1]);
1973
1974         result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername,
1975                                              "", MAXIMUM_ALLOWED_ACCESS,
1976                                              servername, user, &hnd);
1977
1978         if (!W_ERROR_IS_OK(result))
1979                 goto done;
1980
1981         got_hnd = True;
1982
1983         /* Enumerate ports */
1984
1985         result = cli_spoolss_enumjobs(
1986                 cli, mem_ctx, 0, &needed, &hnd, level, 0, 1000,
1987                 &num_jobs, &ctr);
1988
1989         if (W_ERROR_V(result) == ERRinsufficientbuffer)
1990                 result = cli_spoolss_enumjobs(
1991                         cli, mem_ctx, needed, NULL, &hnd, level, 0,
1992                         1000, &num_jobs, &ctr);
1993
1994         if (!W_ERROR_IS_OK(result))
1995                 goto done;
1996
1997         for (i = 0; i < num_jobs; i++) {
1998                 switch(level) {
1999                 case 1:
2000                         display_job_info_1(&ctr.job.job_info_1[i]);
2001                         break;
2002                 case 2:
2003                         display_job_info_2(&ctr.job.job_info_2[i]);
2004                         break;
2005                 default:
2006                         d_printf("unknown info level %d\n", level);
2007                         break;
2008                 }
2009         }
2010
2011 done:
2012         if (got_hnd)
2013                 cli_spoolss_close_printer(cli, mem_ctx, &hnd);
2014
2015         return result;
2016 }
2017
2018 /* enumerate data */
2019
2020 static WERROR cmd_spoolss_enum_data( struct cli_state *cli,
2021                                        TALLOC_CTX *mem_ctx, int argc,
2022                                        const char **argv)
2023 {
2024         WERROR result;
2025         uint32 i=0, val_needed, data_needed;
2026         BOOL got_hnd = False;
2027         pstring printername;
2028         fstring servername, user;
2029         POLICY_HND hnd;
2030
2031         if (argc != 2) {
2032                 printf("Usage: %s printername\n", argv[0]);
2033                 return WERR_OK;
2034         }
2035
2036         /* Open printer handle */
2037
2038         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
2039         strupper_m(servername);
2040         fstrcpy(user, cli->user_name);
2041         slprintf(printername, sizeof(printername)-1, "\\\\%s\\", cli->desthost);
2042         strupper_m(printername);
2043         pstrcat(printername, argv[1]);
2044
2045         result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername,
2046                                              "", MAXIMUM_ALLOWED_ACCESS,
2047                                              servername, user, &hnd);
2048
2049         if (!W_ERROR_IS_OK(result))
2050                 goto done;
2051
2052         got_hnd = True;
2053
2054         /* Enumerate data */
2055
2056         result = cli_spoolss_enumprinterdata(cli, mem_ctx, &hnd, i, 0, 0,
2057                                              &val_needed, &data_needed,
2058                                              NULL);
2059         while (W_ERROR_IS_OK(result)) {
2060                 REGISTRY_VALUE value;
2061                 result = cli_spoolss_enumprinterdata(
2062                         cli, mem_ctx, &hnd, i++, val_needed,
2063                         data_needed, 0, 0, &value);
2064                 if (W_ERROR_IS_OK(result))
2065                         display_reg_value(value);
2066         }
2067         if (W_ERROR_V(result) == ERRnomoreitems)
2068                 result = W_ERROR(ERRsuccess);
2069
2070 done:
2071         if (got_hnd)
2072                 cli_spoolss_close_printer(cli, mem_ctx, &hnd);
2073
2074         return result;
2075 }
2076
2077 /* enumerate data for a given key */
2078
2079 static WERROR cmd_spoolss_enum_data_ex( struct cli_state *cli,
2080                                           TALLOC_CTX *mem_ctx, int argc,
2081                                           const char **argv)
2082 {
2083         WERROR result;
2084         uint32 needed, i;
2085         BOOL got_hnd = False;
2086         pstring printername;
2087         fstring servername, user;
2088         const char *keyname = NULL;
2089         POLICY_HND hnd;
2090         REGVAL_CTR ctr;
2091
2092         if (argc != 3) {
2093                 printf("Usage: %s printername <keyname>\n", argv[0]);
2094                 return WERR_OK;
2095         }
2096
2097         keyname = argv[2];
2098
2099         /* Open printer handle */
2100
2101         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
2102         strupper_m(servername);
2103         fstrcpy(user, cli->user_name);
2104         slprintf(printername, sizeof(printername)-1, "\\\\%s\\", cli->desthost);
2105         strupper_m(printername);
2106         pstrcat(printername, argv[1]);
2107
2108         result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername,
2109                                              "", MAXIMUM_ALLOWED_ACCESS,
2110                                              servername, user, &hnd);
2111
2112         if (!W_ERROR_IS_OK(result))
2113                 goto done;
2114
2115         got_hnd = True;
2116
2117         /* Enumerate subkeys */
2118
2119         result = cli_spoolss_enumprinterdataex(
2120                 cli, mem_ctx, 0, &needed, &hnd, keyname, NULL);
2121
2122         if (W_ERROR_V(result) == ERRmoredata)
2123                 result = cli_spoolss_enumprinterdataex(
2124                         cli, mem_ctx, needed, NULL, &hnd, keyname, &ctr);
2125
2126         if (!W_ERROR_IS_OK(result))
2127                 goto done;
2128
2129         for (i=0; i < ctr.num_values; i++) {
2130                 display_reg_value(*(ctr.values[i]));
2131         }
2132
2133         regval_ctr_destroy(&ctr);
2134
2135 done:
2136         if (got_hnd)
2137                 cli_spoolss_close_printer(cli, mem_ctx, &hnd);
2138
2139         return result;
2140 }
2141
2142 /* enumerate subkeys */
2143
2144 static WERROR cmd_spoolss_enum_printerkey( struct cli_state *cli,
2145                                              TALLOC_CTX *mem_ctx, int argc,
2146                                              const char **argv)
2147 {
2148         WERROR result;
2149         uint32 needed, returned;
2150         BOOL got_hnd = False;
2151         pstring printername;
2152         fstring servername, user;
2153         const char *keyname = NULL;
2154         POLICY_HND hnd;
2155         uint16 *keylist = NULL, *curkey;
2156
2157         if (argc < 2 || argc > 3) {
2158                 printf("Usage: %s printername [keyname]\n", argv[0]);
2159                 return WERR_OK;
2160         }
2161
2162         if (argc == 3)
2163                 keyname = argv[2];
2164         else
2165                 keyname = "";
2166
2167         /* Open printer handle */
2168
2169         slprintf(servername, sizeof(servername)-1, "\\\\%s", cli->desthost);
2170         strupper_m(servername);
2171         fstrcpy(user, cli->user_name);
2172         slprintf(printername, sizeof(printername)-1, "\\\\%s\\", cli->desthost);
2173         strupper_m(printername);
2174         pstrcat(printername, argv[1]);
2175
2176         result = cli_spoolss_open_printer_ex(cli, mem_ctx, printername,
2177                                              "", MAXIMUM_ALLOWED_ACCESS,
2178                                              servername, user, &hnd);
2179
2180         if (!W_ERROR_IS_OK(result))
2181                 goto done;
2182
2183         got_hnd = True;
2184
2185         /* Enumerate subkeys */
2186
2187         result = cli_spoolss_enumprinterkey(
2188                 cli, mem_ctx, 0, &needed, &hnd, keyname, NULL, NULL);
2189
2190         if (W_ERROR_V(result) == ERRmoredata)
2191                 result = cli_spoolss_enumprinterkey(
2192                         cli, mem_ctx, needed, NULL, &hnd, keyname, &keylist,
2193                         &returned);
2194
2195         if (!W_ERROR_IS_OK(result))
2196                 goto done;
2197
2198         curkey = keylist;
2199         while (*curkey != 0) {
2200                 pstring subkey;
2201                 rpcstr_pull(subkey, curkey, sizeof(subkey), -1,
2202                             STR_TERMINATE);
2203                 printf("%s\n", subkey);
2204                 curkey += strlen(subkey) + 1;
2205         }
2206
2207         safe_free(keylist);
2208
2209 done:
2210         if (got_hnd)
2211                 cli_spoolss_close_printer(cli, mem_ctx, &hnd);
2212
2213         return result;
2214 }
2215
2216 static WERROR cmd_spoolss_rffpcnex(struct cli_state *cli,
2217                                      TALLOC_CTX *mem_ctx, int argc,
2218                                      const char **argv)
2219 {
2220         fstring servername, printername;
2221         POLICY_HND hnd;
2222         BOOL got_hnd = False;
2223         WERROR result;
2224         SPOOL_NOTIFY_OPTION option;
2225
2226         if (argc != 2) {
2227                 printf("Usage: %s printername\n", argv[0]);
2228                 result = WERR_OK;
2229                 goto done;
2230         }
2231
2232         /* Open printer */
2233
2234         slprintf(servername, sizeof(servername) - 1, "\\\\%s", cli->desthost);
2235         strupper_m(servername);
2236
2237         slprintf(printername, sizeof(printername) - 1, "\\\\%s\\%s", cli->desthost,
2238                  argv[1]);
2239         strupper_m(printername);
2240
2241         result = cli_spoolss_open_printer_ex(
2242                 cli, mem_ctx, printername, "", MAXIMUM_ALLOWED_ACCESS,
2243                 servername, cli->user_name, &hnd);
2244
2245         if (!W_ERROR_IS_OK(result)) {
2246                 printf("Error opening %s\n", argv[1]);
2247                 goto done;
2248         }
2249
2250         got_hnd = True;
2251
2252         /* Create spool options */
2253
2254         ZERO_STRUCT(option);
2255
2256         option.version = 2;
2257         option.option_type_ptr = 1;
2258         option.count = option.ctr.count = 2;
2259
2260         option.ctr.type = (SPOOL_NOTIFY_OPTION_TYPE *)talloc(
2261                 mem_ctx, sizeof(SPOOL_NOTIFY_OPTION_TYPE) * 2);
2262
2263         ZERO_STRUCT(option.ctr.type[0]);
2264         option.ctr.type[0].type = PRINTER_NOTIFY_TYPE;
2265         option.ctr.type[0].count = option.ctr.type[0].count2 = 1;
2266         option.ctr.type[0].fields_ptr = 1;
2267         option.ctr.type[0].fields[0] = PRINTER_NOTIFY_SERVER_NAME;
2268
2269         ZERO_STRUCT(option.ctr.type[1]);
2270         option.ctr.type[1].type = JOB_NOTIFY_TYPE;
2271         option.ctr.type[1].count = option.ctr.type[1].count2 = 1;
2272         option.ctr.type[1].fields_ptr = 1;
2273         option.ctr.type[1].fields[0] = JOB_NOTIFY_PRINTER_NAME;
2274
2275         /* Send rffpcnex */
2276
2277         slprintf(servername, sizeof(servername) - 1, "\\\\%s", myhostname());
2278         strupper_m(servername);
2279
2280         result = cli_spoolss_rffpcnex(
2281                 cli, mem_ctx, &hnd, 0, 0, servername, 123, &option);
2282
2283         if (!W_ERROR_IS_OK(result)) {
2284                 printf("Error rffpcnex %s\n", argv[1]);
2285                 goto done;
2286         }
2287
2288 done:
2289         if (got_hnd)
2290                 cli_spoolss_close_printer(cli, mem_ctx, &hnd);
2291
2292         return result;
2293 }
2294
2295 /* List of commands exported by this module */
2296 struct cmd_set spoolss_commands[] = {
2297
2298         { "SPOOLSS"  },
2299
2300         { "adddriver",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterdriver,   PI_SPOOLSS, "Add a print driver",                  "" },
2301         { "addprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_addprinterex,       PI_SPOOLSS, "Add a printer",                       "" },
2302         { "deldriver",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_deletedriver,       PI_SPOOLSS, "Delete a printer driver",             "" },
2303         { "enumdata",           RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data,          PI_SPOOLSS, "Enumerate printer data",              "" },
2304         { "enumdataex", RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_data_ex,       PI_SPOOLSS, "Enumerate printer data for a key",    "" },
2305         { "enumkey",            RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printerkey,    PI_SPOOLSS, "Enumerate printer keys",              "" },
2306         { "enumjobs",           RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_jobs,          PI_SPOOLSS, "Enumerate print jobs",                "" },
2307         { "enumports",  RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_ports,         PI_SPOOLSS, "Enumerate printer ports",             "" },
2308         { "enumdrivers",        RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_drivers,       PI_SPOOLSS, "Enumerate installed printer drivers", "" },
2309         { "enumprinters",       RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_printers,      PI_SPOOLSS, "Enumerate printers",                  "" },
2310         { "getdata",            RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdata,     PI_SPOOLSS, "Get print driver data",               "" },
2311         { "getdataex",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinterdataex,   PI_SPOOLSS, "Get printer driver data with keyname", ""},
2312         { "getdriver",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriver,          PI_SPOOLSS, "Get print driver information",        "" },
2313         { "getdriverdir",       RPC_RTYPE_WERROR, NULL, cmd_spoolss_getdriverdir,       PI_SPOOLSS, "Get print driver upload directory",   "" },
2314         { "getprinter",         RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprinter,         PI_SPOOLSS, "Get printer info",                    "" },
2315         { "getprintprocdir",RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprintprocdir,    PI_SPOOLSS, "Get print processor directory",       "" },
2316         { "openprinter",        RPC_RTYPE_WERROR, NULL, cmd_spoolss_open_printer_ex,    PI_SPOOLSS, "Open printer handle",                 "" },
2317         { "setdriver",  RPC_RTYPE_WERROR, NULL, cmd_spoolss_setdriver,          PI_SPOOLSS, "Set printer driver",                  "" },
2318         { "getprintprocdir",    RPC_RTYPE_WERROR, NULL, cmd_spoolss_getprintprocdir,    PI_SPOOLSS, "Get print processor directory",       "" },
2319         { "addform",            RPC_RTYPE_WERROR, NULL, cmd_spoolss_addform,            PI_SPOOLSS, "Add form",                            "" },
2320         { "setform",            RPC_RTYPE_WERROR, NULL, cmd_spoolss_setform,            PI_SPOOLSS, "Set form",                            "" },
2321         { "getform",            RPC_RTYPE_WERROR, NULL, cmd_spoolss_getform,            PI_SPOOLSS, "Get form",                            "" },
2322         { "deleteform", RPC_RTYPE_WERROR, NULL, cmd_spoolss_deleteform,         PI_SPOOLSS, "Delete form",                         "" },
2323         { "enumforms",          RPC_RTYPE_WERROR, NULL, cmd_spoolss_enum_forms,         PI_SPOOLSS, "Enumerate forms",                     "" },
2324         { "setprinter", RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinter,         PI_SPOOLSS, "Set printer comment",                 "" },
2325         { "setprinterdata",     RPC_RTYPE_WERROR, NULL, cmd_spoolss_setprinterdata,     PI_SPOOLSS, "Set REG_SZ printer data",             "" },
2326         { "rffpcnex",           RPC_RTYPE_WERROR, NULL, cmd_spoolss_rffpcnex,           PI_SPOOLSS, "Rffpcnex test", "" },
2327
2328         { NULL }
2329 };