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