source3/rpc_client/cli_spoolss.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    RPC pipe client
   4
   5    Copyright (C) Gerald Carter                2001-2005,
   6    Copyright (C) Tim Potter                   2000-2002,
   7    Copyright (C) Andrew Tridgell              1994-2000,
   8    Copyright (C) Jean-Francois Micouleau      1999-2000.
   9    Copyright (C) Jeremy Allison                         2005.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23 */
  24
  25 #include "includes.h"
  26 #include "rpc_client.h"
  27
  28 /*********************************************************************
  29  Decode various spoolss rpc's and info levels
  30  ********************************************************************/
  31
  32 /**********************************************************************
  33 **********************************************************************/
  34
  35 static bool decode_printer_info_0(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
  36                                 uint32 returned, PRINTER_INFO_0 **info)
  37 {
  38         uint32 i;
  39         PRINTER_INFO_0  *inf;
  40
  41         if (returned) {
  42                 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_0, returned);
  43                 if (!inf) {
  44                         return False;
  45                 }
  46                 memset(inf, 0, returned*sizeof(PRINTER_INFO_0));
  47         } else {
  48                 inf = NULL;
  49         }
  50
  51         prs_set_offset(&buffer->prs,0);
  52
  53         for (i=0; i<returned; i++) {
  54                 if (!smb_io_printer_info_0("", buffer, &inf[i], 0)) {
  55                         return False;
  56                 }
  57         }
  58
  59         *info=inf;
  60         return True;
  61 }
  62
  63 /**********************************************************************
  64 **********************************************************************/
  65
  66 static bool decode_printer_info_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
  67                                 uint32 returned, PRINTER_INFO_1 **info)
  68 {
  69         uint32 i;
  70         PRINTER_INFO_1  *inf;
  71
  72         if (returned) {
  73                 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_1, returned);
  74                 if (!inf) {
  75                         return False;
  76                 }
  77                 memset(inf, 0, returned*sizeof(PRINTER_INFO_1));
  78         } else {
  79                 inf = NULL;
  80         }
  81
  82         prs_set_offset(&buffer->prs,0);
  83
  84         for (i=0; i<returned; i++) {
  85                 if (!smb_io_printer_info_1("", buffer, &inf[i], 0)) {
  86                         return False;
  87                 }
  88         }
  89
  90         *info=inf;
  91         return True;
  92 }
  93
  94 /**********************************************************************
  95 **********************************************************************/
  96
  97 static bool decode_printer_info_2(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
  98                                 uint32 returned, PRINTER_INFO_2 **info)
  99 {
 100         uint32 i;
 101         PRINTER_INFO_2  *inf;
 102
 103         if (returned) {
 104                 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_2, returned);
 105                 if (!inf) {
 106                         return False;
 107                 }
 108                 memset(inf, 0, returned*sizeof(PRINTER_INFO_2));
 109         } else {
 110                 inf = NULL;
 111         }
 112
 113         prs_set_offset(&buffer->prs,0);
 114
 115         for (i=0; i<returned; i++) {
 116                 /* a little initialization as we go */
 117                 inf[i].secdesc = NULL;
 118                 if (!smb_io_printer_info_2("", buffer, &inf[i], 0)) {
 119                         return False;
 120                 }
 121         }
 122
 123         *info=inf;
 124         return True;
 125 }
 126
 127 /**********************************************************************
 128 **********************************************************************/
 129
 130 static bool decode_printer_info_3(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 131                                 uint32 returned, PRINTER_INFO_3 **info)
 132 {
 133         uint32 i;
 134         PRINTER_INFO_3  *inf;
 135
 136         if (returned) {
 137                 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_3, returned);
 138                 if (!inf) {
 139                         return False;
 140                 }
 141                 memset(inf, 0, returned*sizeof(PRINTER_INFO_3));
 142         } else {
 143                 inf = NULL;
 144         }
 145
 146         prs_set_offset(&buffer->prs,0);
 147
 148         for (i=0; i<returned; i++) {
 149                 inf[i].secdesc = NULL;
 150                 if (!smb_io_printer_info_3("", buffer, &inf[i], 0)) {
 151                         return False;
 152                 }
 153         }
 154
 155         *info=inf;
 156         return True;
 157 }
 158
 159 /**********************************************************************
 160 **********************************************************************/
 161
 162 static bool decode_printer_info_7(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 163                                 uint32 returned, PRINTER_INFO_7 **info)
 164 {
 165         uint32 i;
 166         PRINTER_INFO_7  *inf;
 167
 168         if (returned) {
 169                 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_7, returned);
 170                 if (!inf) {
 171                         return False;
 172                 }
 173                 memset(inf, 0, returned*sizeof(PRINTER_INFO_7));
 174         } else {
 175                 inf = NULL;
 176         }
 177
 178         prs_set_offset(&buffer->prs,0);
 179
 180         for (i=0; i<returned; i++) {
 181                 if (!smb_io_printer_info_7("", buffer, &inf[i], 0)) {
 182                         return False;
 183                 }
 184         }
 185
 186         *info=inf;
 187         return True;
 188 }
 189
 190
 191 /**********************************************************************
 192 **********************************************************************/
 193
 194 static bool decode_port_info_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 195                         uint32 returned, PORT_INFO_1 **info)
 196 {
 197         uint32 i;
 198         PORT_INFO_1 *inf;
 199
 200         if (returned) {
 201                 inf=TALLOC_ARRAY(mem_ctx, PORT_INFO_1, returned);
 202                 if (!inf) {
 203                         return False;
 204                 }
 205                 memset(inf, 0, returned*sizeof(PORT_INFO_1));
 206         } else {
 207                 inf = NULL;
 208         }
 209
 210         prs_set_offset(&buffer->prs, 0);
 211
 212         for (i=0; i<returned; i++) {
 213                 if (!smb_io_port_info_1("", buffer, &(inf[i]), 0)) {
 214                         return False;
 215                 }
 216         }
 217
 218         *info=inf;
 219         return True;
 220 }
 221
 222 /**********************************************************************
 223 **********************************************************************/
 224
 225 static bool decode_port_info_2(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 226                         uint32 returned, PORT_INFO_2 **info)
 227 {
 228         uint32 i;
 229         PORT_INFO_2 *inf;
 230
 231         if (returned) {
 232                 inf=TALLOC_ARRAY(mem_ctx, PORT_INFO_2, returned);
 233                 if (!inf) {
 234                         return False;
 235                 }
 236                 memset(inf, 0, returned*sizeof(PORT_INFO_2));
 237         } else {
 238                 inf = NULL;
 239         }
 240
 241         prs_set_offset(&buffer->prs, 0);
 242
 243         for (i=0; i<returned; i++) {
 244                 if (!smb_io_port_info_2("", buffer, &(inf[i]), 0)) {
 245                         return False;
 246                 }
 247         }
 248
 249         *info=inf;
 250         return True;
 251 }
 252
 253 /**********************************************************************
 254 **********************************************************************/
 255
 256 static bool decode_printer_driver_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 257                         uint32 returned, DRIVER_INFO_1 **info)
 258 {
 259         uint32 i;
 260         DRIVER_INFO_1 *inf;
 261
 262         if (returned) {
 263                 inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_1, returned);
 264                 if (!inf) {
 265                         return False;
 266                 }
 267                 memset(inf, 0, returned*sizeof(DRIVER_INFO_1));
 268         } else {
 269                 inf = NULL;
 270         }
 271
 272         prs_set_offset(&buffer->prs,0);
 273
 274         for (i=0; i<returned; i++) {
 275                 if (!smb_io_printer_driver_info_1("", buffer, &(inf[i]), 0)) {
 276                         return False;
 277                 }
 278         }
 279
 280         *info=inf;
 281         return True;
 282 }
 283
 284 /**********************************************************************
 285 **********************************************************************/
 286
 287 static bool decode_printer_driver_2(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 288                         uint32 returned, DRIVER_INFO_2 **info)
 289 {
 290         uint32 i;
 291         DRIVER_INFO_2 *inf;
 292
 293         if (returned) {
 294                 inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_2, returned);
 295                 if (!inf) {
 296                         return False;
 297                 }
 298                 memset(inf, 0, returned*sizeof(DRIVER_INFO_2));
 299         } else {
 300                 inf = NULL;
 301         }
 302
 303         prs_set_offset(&buffer->prs,0);
 304
 305         for (i=0; i<returned; i++) {
 306                 if (!smb_io_printer_driver_info_2("", buffer, &(inf[i]), 0)) {
 307                         return False;
 308                 }
 309         }
 310
 311         *info=inf;
 312         return True;
 313 }
 314
 315 /**********************************************************************
 316 **********************************************************************/
 317
 318 static bool decode_printer_driver_3(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 319                         uint32 returned, DRIVER_INFO_3 **info)
 320 {
 321         uint32 i;
 322         DRIVER_INFO_3 *inf;
 323
 324         if (returned) {
 325                 inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_3, returned);
 326                 if (!inf) {
 327                         return False;
 328                 }
 329                 memset(inf, 0, returned*sizeof(DRIVER_INFO_3));
 330         } else {
 331                 inf = NULL;
 332         }
 333
 334         prs_set_offset(&buffer->prs,0);
 335
 336         for (i=0; i<returned; i++) {
 337                 if (!smb_io_printer_driver_info_3("", buffer, &(inf[i]), 0)) {
 338                         return False;
 339                 }
 340         }
 341
 342         *info=inf;
 343         return True;
 344 }
 345
 346 /**********************************************************************
 347 **********************************************************************/
 348
 349 static bool decode_printerdriverdir_1 (TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 350                         uint32 returned, DRIVER_DIRECTORY_1 **info
 351 )
 352 {
 353         DRIVER_DIRECTORY_1 *inf;
 354
 355         inf=TALLOC_P(mem_ctx, DRIVER_DIRECTORY_1);
 356         if (!inf) {
 357                 return False;
 358         }
 359         memset(inf, 0, sizeof(DRIVER_DIRECTORY_1));
 360
 361         prs_set_offset(&buffer->prs, 0);
 362
 363         if (!smb_io_driverdir_1("", buffer, inf, 0)) {
 364                 return False;
 365         }
 366
 367         *info=inf;
 368         return True;
 369 }
 370
 371 /**********************************************************************
 372 **********************************************************************/
 373
 374 static bool decode_jobs_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 375                           uint32 num_jobs, JOB_INFO_1 **jobs)
 376 {
 377         uint32 i;
 378
 379         if (num_jobs) {
 380                 *jobs = TALLOC_ARRAY(mem_ctx, JOB_INFO_1, num_jobs);
 381                 if (*jobs == NULL) {
 382                         return False;
 383                 }
 384         } else {
 385                 *jobs = NULL;
 386         }
 387         prs_set_offset(&buffer->prs,0);
 388
 389         for (i = 0; i < num_jobs; i++) {
 390                 if (!smb_io_job_info_1("", buffer, &((*jobs)[i]), 0)) {
 391                         return False;
 392                 }
 393         }
 394
 395         return True;
 396 }
 397
 398 /**********************************************************************
 399 **********************************************************************/
 400
 401 static bool decode_jobs_2(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 402                           uint32 num_jobs, JOB_INFO_2 **jobs)
 403 {
 404         uint32 i;
 405
 406         if (num_jobs) {
 407                 *jobs = TALLOC_ARRAY(mem_ctx, JOB_INFO_2, num_jobs);
 408                 if (*jobs == NULL) {
 409                         return False;
 410                 }
 411         } else {
 412                 *jobs = NULL;
 413         }
 414         prs_set_offset(&buffer->prs,0);
 415
 416         for (i = 0; i < num_jobs; i++) {
 417                 if (!smb_io_job_info_2("", buffer, &((*jobs)[i]), 0)) {
 418                         return False;
 419                 }
 420         }
 421
 422         return True;
 423 }
 424
 425 /**********************************************************************
 426 **********************************************************************/
 427
 428 static bool decode_forms_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 429                            uint32 num_forms, FORM_1 **forms)
 430 {
 431         int i;
 432
 433         if (num_forms) {
 434                 *forms = TALLOC_ARRAY(mem_ctx, FORM_1, num_forms);
 435                 if (*forms == NULL) {
 436                         return False;
 437                 }
 438         } else {
 439                 *forms = NULL;
 440         }
 441
 442         prs_set_offset(&buffer->prs,0);
 443
 444         for (i = 0; i < num_forms; i++) {
 445                 if (!smb_io_form_1("", buffer, &((*forms)[i]), 0)) {
 446                         return False;
 447                 }
 448         }
 449
 450         return True;
 451 }
 452
 453 /**********************************************************************
 454 **********************************************************************/
 455
 456 WERROR rpccli_spoolss_open_printer_ex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 457                                 const char *printername, const char *datatype, uint32 access_required,
 458                                 const char *station, const char *username, POLICY_HND *pol)
 459 {
 460         prs_struct qbuf, rbuf;
 461         SPOOL_Q_OPEN_PRINTER_EX in;
 462         SPOOL_R_OPEN_PRINTER_EX out;
 463
 464         ZERO_STRUCT(in);
 465         ZERO_STRUCT(out);
 466
 467         make_spoolss_q_open_printer_ex( &in, printername, datatype,
 468                 access_required, station, username );
 469
 470         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_OPENPRINTEREX,
 471                     in, out,
 472                     qbuf, rbuf,
 473                     spoolss_io_q_open_printer_ex,
 474                     spoolss_io_r_open_printer_ex,
 475                     WERR_GENERAL_FAILURE );
 476
 477         memcpy( pol, &out.handle, sizeof(POLICY_HND) );
 478
 479         return out.status;
 480 }
 481
 482 /**********************************************************************
 483 **********************************************************************/
 484
 485 WERROR rpccli_spoolss_enum_printers(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 486                                  char *name, uint32 flags, uint32 level,
 487                                  uint32 *num_printers, PRINTER_INFO_CTR *ctr)
 488 {
 489         prs_struct qbuf, rbuf;
 490         SPOOL_Q_ENUMPRINTERS in;
 491         SPOOL_R_ENUMPRINTERS out;
 492         RPC_BUFFER buffer;
 493         uint32 offered;
 494
 495         ZERO_STRUCT(in);
 496         ZERO_STRUCT(out);
 497
 498         offered = 0;
 499         if (!rpcbuf_init(&buffer, offered, mem_ctx))
 500                 return WERR_NOMEM;
 501         make_spoolss_q_enumprinters( &in, flags, name, level, &buffer, offered );
 502
 503         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERS,
 504                     in, out,
 505                     qbuf, rbuf,
 506                     spoolss_io_q_enumprinters,
 507                     spoolss_io_r_enumprinters,
 508                     WERR_GENERAL_FAILURE );
 509
 510         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
 511                 offered = out.needed;
 512
 513                 ZERO_STRUCT(in);
 514                 ZERO_STRUCT(out);
 515
 516                 if (!rpcbuf_init(&buffer, offered, mem_ctx))
 517                         return WERR_NOMEM;
 518                 make_spoolss_q_enumprinters( &in, flags, name, level, &buffer, offered );
 519
 520                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERS,
 521                             in, out,
 522                             qbuf, rbuf,
 523                             spoolss_io_q_enumprinters,
 524                             spoolss_io_r_enumprinters,
 525                             WERR_GENERAL_FAILURE );
 526         }
 527
 528         if ( !W_ERROR_IS_OK(out.status) )
 529                 return out.status;
 530
 531         switch (level) {
 532         case 0:
 533                 if (!decode_printer_info_0(mem_ctx, out.buffer, out.returned, &ctr->printers_0)) {
 534                         return WERR_GENERAL_FAILURE;
 535                 }
 536                 break;
 537         case 1:
 538                 if (!decode_printer_info_1(mem_ctx, out.buffer, out.returned, &ctr->printers_1)) {
 539                         return WERR_GENERAL_FAILURE;
 540                 }
 541                 break;
 542         case 2:
 543                 if (!decode_printer_info_2(mem_ctx, out.buffer, out.returned, &ctr->printers_2)) {
 544                         return WERR_GENERAL_FAILURE;
 545                 }
 546                 break;
 547         case 3:
 548                 if (!decode_printer_info_3(mem_ctx, out.buffer, out.returned, &ctr->printers_3)) {
 549                         return WERR_GENERAL_FAILURE;
 550                 }
 551                 break;
 552         default:
 553                 return WERR_UNKNOWN_LEVEL;
 554         }
 555
 556         *num_printers = out.returned;
 557
 558         return out.status;
 559 }
 560
 561 /**********************************************************************
 562 **********************************************************************/
 563
 564 WERROR rpccli_spoolss_enum_ports(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 565                               uint32 level, uint32 *num_ports, PORT_INFO_CTR *ctr)
 566 {
 567         prs_struct qbuf, rbuf;
 568         SPOOL_Q_ENUMPORTS in;
 569         SPOOL_R_ENUMPORTS out;
 570         RPC_BUFFER buffer;
 571         fstring server;
 572         uint32 offered;
 573
 574         ZERO_STRUCT(in);
 575         ZERO_STRUCT(out);
 576
 577         slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 578         strupper_m(server);
 579
 580         offered = 0;
 581         if (!rpcbuf_init(&buffer, offered, mem_ctx))
 582                 return WERR_NOMEM;
 583         make_spoolss_q_enumports( &in, server, level, &buffer, offered );
 584
 585         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPORTS,
 586                     in, out,
 587                     qbuf, rbuf,
 588                     spoolss_io_q_enumports,
 589                     spoolss_io_r_enumports,
 590                     WERR_GENERAL_FAILURE );
 591
 592         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
 593                 offered = out.needed;
 594
 595                 ZERO_STRUCT(in);
 596                 ZERO_STRUCT(out);
 597
 598                 if (!rpcbuf_init(&buffer, offered, mem_ctx))
 599                         return WERR_NOMEM;
 600                 make_spoolss_q_enumports( &in, server, level, &buffer, offered );
 601
 602                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPORTS,
 603                             in, out,
 604                             qbuf, rbuf,
 605                             spoolss_io_q_enumports,
 606                             spoolss_io_r_enumports,
 607                             WERR_GENERAL_FAILURE );
 608         }
 609
 610         if ( !W_ERROR_IS_OK(out.status) )
 611                 return out.status;
 612
 613         switch (level) {
 614         case 1:
 615                 if (!decode_port_info_1(mem_ctx, out.buffer, out.returned, &ctr->port.info_1)) {
 616                         return WERR_GENERAL_FAILURE;
 617                 }
 618                 break;
 619         case 2:
 620                 if (!decode_port_info_2(mem_ctx, out.buffer, out.returned, &ctr->port.info_2)) {
 621                         return WERR_GENERAL_FAILURE;
 622                 }
 623                 break;
 624         default:
 625                 return WERR_UNKNOWN_LEVEL;
 626         }
 627
 628         *num_ports = out.returned;
 629
 630         return out.status;
 631 }
 632
 633 /**********************************************************************
 634 **********************************************************************/
 635
 636 WERROR rpccli_spoolss_getprinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 637                               POLICY_HND *pol, uint32 level,
 638                               PRINTER_INFO_CTR *ctr)
 639 {
 640         prs_struct qbuf, rbuf;
 641         SPOOL_Q_GETPRINTER in;
 642         SPOOL_R_GETPRINTER out;
 643         RPC_BUFFER buffer;
 644         uint32 offered;
 645
 646         ZERO_STRUCT(in);
 647         ZERO_STRUCT(out);
 648
 649         /* Initialise input parameters */
 650
 651         offered = 0;
 652         if (!rpcbuf_init(&buffer, offered, mem_ctx))
 653                 return WERR_NOMEM;
 654         make_spoolss_q_getprinter( mem_ctx, &in, pol, level, &buffer, offered );
 655
 656         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTER,
 657                     in, out,
 658                     qbuf, rbuf,
 659                     spoolss_io_q_getprinter,
 660                     spoolss_io_r_getprinter,
 661                     WERR_GENERAL_FAILURE );
 662
 663         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
 664                 offered = out.needed;
 665
 666                 ZERO_STRUCT(in);
 667                 ZERO_STRUCT(out);
 668
 669                 if (!rpcbuf_init(&buffer, offered, mem_ctx))
 670                         return WERR_NOMEM;
 671                 make_spoolss_q_getprinter( mem_ctx, &in, pol, level, &buffer, offered );
 672
 673                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTER,
 674                             in, out,
 675                             qbuf, rbuf,
 676                             spoolss_io_q_getprinter,
 677                             spoolss_io_r_getprinter,
 678                             WERR_GENERAL_FAILURE );
 679         }
 680
 681         if ( !W_ERROR_IS_OK(out.status) )
 682                 return out.status;
 683
 684         switch (level) {
 685         case 0:
 686                 if (!decode_printer_info_0(mem_ctx, out.buffer, 1, &ctr->printers_0)) {
 687                         return WERR_GENERAL_FAILURE;
 688                 }
 689                 break;
 690         case 1:
 691                 if (!decode_printer_info_1(mem_ctx, out.buffer, 1, &ctr->printers_1)) {
 692                         return WERR_GENERAL_FAILURE;
 693                 }
 694                 break;
 695         case 2:
 696                 if (!decode_printer_info_2(mem_ctx, out.buffer, 1, &ctr->printers_2)) {
 697                         return WERR_GENERAL_FAILURE;
 698                 }
 699                 break;
 700         case 3:
 701                 if (!decode_printer_info_3(mem_ctx, out.buffer, 1, &ctr->printers_3)) {
 702                         return WERR_GENERAL_FAILURE;
 703                 }
 704                 break;
 705         case 7:
 706                 if (!decode_printer_info_7(mem_ctx, out.buffer, 1, &ctr->printers_7)) {
 707                         return WERR_GENERAL_FAILURE;
 708                 }
 709                 break;
 710         default:
 711                 return WERR_UNKNOWN_LEVEL;
 712         }
 713
 714         return out.status;
 715 }
 716
 717 /**********************************************************************
 718 **********************************************************************/
 719
 720 WERROR rpccli_spoolss_setprinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 721                               POLICY_HND *pol, uint32 level,
 722                               PRINTER_INFO_CTR *ctr, uint32 command)
 723 {
 724         prs_struct qbuf, rbuf;
 725         SPOOL_Q_SETPRINTER in;
 726         SPOOL_R_SETPRINTER out;
 727
 728         ZERO_STRUCT(in);
 729         ZERO_STRUCT(out);
 730
 731         make_spoolss_q_setprinter( mem_ctx, &in, pol, level, ctr, command );
 732
 733         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_SETPRINTER,
 734                     in, out,
 735                     qbuf, rbuf,
 736                     spoolss_io_q_setprinter,
 737                     spoolss_io_r_setprinter,
 738                     WERR_GENERAL_FAILURE );
 739
 740         return out.status;
 741 }
 742
 743 /**********************************************************************
 744 **********************************************************************/
 745
 746 WERROR rpccli_spoolss_getprinterdriver(struct rpc_pipe_client *cli,
 747                                     TALLOC_CTX *mem_ctx,
 748                                     POLICY_HND *pol, uint32 level,
 749                                     const char *env, int version, PRINTER_DRIVER_CTR *ctr)
 750 {
 751         prs_struct qbuf, rbuf;
 752         SPOOL_Q_GETPRINTERDRIVER2 in;
 753         SPOOL_R_GETPRINTERDRIVER2 out;
 754         RPC_BUFFER buffer;
 755         fstring server;
 756         uint32 offered;
 757
 758         ZERO_STRUCT(in);
 759         ZERO_STRUCT(out);
 760
 761         fstrcpy(server, cli->desthost);
 762         strupper_m(server);
 763
 764         offered = 0;
 765         if (!rpcbuf_init(&buffer, offered, mem_ctx))
 766                 return WERR_NOMEM;
 767         make_spoolss_q_getprinterdriver2( &in, pol, env, level,
 768                 version, 2, &buffer, offered);
 769
 770         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDRIVER2,
 771                     in, out,
 772                     qbuf, rbuf,
 773                     spoolss_io_q_getprinterdriver2,
 774                     spoolss_io_r_getprinterdriver2,
 775                     WERR_GENERAL_FAILURE );
 776
 777         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
 778                 offered = out.needed;
 779
 780                 ZERO_STRUCT(in);
 781                 ZERO_STRUCT(out);
 782
 783                 if (!rpcbuf_init(&buffer, offered, mem_ctx))
 784                         return WERR_NOMEM;
 785                 make_spoolss_q_getprinterdriver2( &in, pol, env, level,
 786                         version, 2, &buffer, offered);
 787
 788                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDRIVER2,
 789                             in, out,
 790                             qbuf, rbuf,
 791                             spoolss_io_q_getprinterdriver2,
 792                             spoolss_io_r_getprinterdriver2,
 793                             WERR_GENERAL_FAILURE );
 794         }
 795
 796         if ( !W_ERROR_IS_OK(out.status) )
 797                 return out.status;
 798
 799         switch (level) {
 800         case 1:
 801                 if (!decode_printer_driver_1(mem_ctx, out.buffer, 1, &ctr->info1)) {
 802                         return WERR_GENERAL_FAILURE;
 803                 }
 804                 break;
 805         case 2:
 806                 if (!decode_printer_driver_2(mem_ctx, out.buffer, 1, &ctr->info2)) {
 807                         return WERR_GENERAL_FAILURE;
 808                 }
 809                 break;
 810         case 3:
 811                 if (!decode_printer_driver_3(mem_ctx, out.buffer, 1, &ctr->info3)) {
 812                         return WERR_GENERAL_FAILURE;
 813                 }
 814                 break;
 815         default:
 816                 return WERR_UNKNOWN_LEVEL;
 817         }
 818
 819         return out.status;
 820 }
 821
 822 /**********************************************************************
 823 **********************************************************************/
 824
 825 WERROR rpccli_spoolss_enumprinterdrivers (struct rpc_pipe_client *cli,
 826                                        TALLOC_CTX *mem_ctx,
 827                                        uint32 level, const char *env,
 828                                        uint32 *num_drivers,
 829                                        PRINTER_DRIVER_CTR *ctr)
 830 {
 831         prs_struct qbuf, rbuf;
 832         SPOOL_Q_ENUMPRINTERDRIVERS in;
 833         SPOOL_R_ENUMPRINTERDRIVERS out;
 834         RPC_BUFFER buffer;
 835         fstring server;
 836         uint32 offered;
 837
 838         ZERO_STRUCT(in);
 839         ZERO_STRUCT(out);
 840
 841         slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 842         strupper_m(server);
 843
 844         offered = 0;
 845         if (!rpcbuf_init(&buffer, offered, mem_ctx))
 846                 return WERR_NOMEM;
 847         make_spoolss_q_enumprinterdrivers( &in, server, env, level,
 848                 &buffer, offered);
 849
 850         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERDRIVERS,
 851                     in, out,
 852                     qbuf, rbuf,
 853                     spoolss_io_q_enumprinterdrivers,
 854                     spoolss_io_r_enumprinterdrivers,
 855                     WERR_GENERAL_FAILURE );
 856
 857         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
 858                 offered = out.needed;
 859
 860                 ZERO_STRUCT(in);
 861                 ZERO_STRUCT(out);
 862
 863                 if (!rpcbuf_init(&buffer, offered, mem_ctx))
 864                         return WERR_NOMEM;
 865                 make_spoolss_q_enumprinterdrivers( &in, server, env, level,
 866                         &buffer, offered);
 867
 868                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERDRIVERS,
 869                             in, out,
 870                             qbuf, rbuf,
 871                             spoolss_io_q_enumprinterdrivers,
 872                             spoolss_io_r_enumprinterdrivers,
 873                             WERR_GENERAL_FAILURE );
 874         }
 875
 876         *num_drivers = out.returned;
 877
 878         if ( !W_ERROR_IS_OK(out.status) )
 879                 return out.status;
 880
 881         if ( out.returned ) {
 882
 883                 switch (level) {
 884                 case 1:
 885                         if (!decode_printer_driver_1(mem_ctx, out.buffer, out.returned, &ctr->info1)) {
 886                                 return WERR_GENERAL_FAILURE;
 887                         }
 888                         break;
 889                 case 2:
 890                         if (!decode_printer_driver_2(mem_ctx, out.buffer, out.returned, &ctr->info2)) {
 891                                 return WERR_GENERAL_FAILURE;
 892                         }
 893                         break;
 894                 case 3:
 895                         if (!decode_printer_driver_3(mem_ctx, out.buffer, out.returned, &ctr->info3)) {
 896                                 return WERR_GENERAL_FAILURE;
 897                         }
 898                         break;
 899                 default:
 900                         return WERR_UNKNOWN_LEVEL;
 901                 }
 902         }
 903
 904         return out.status;
 905 }
 906
 907
 908 /**********************************************************************
 909 **********************************************************************/
 910
 911 WERROR rpccli_spoolss_getprinterdriverdir (struct rpc_pipe_client *cli,
 912                                         TALLOC_CTX *mem_ctx,
 913                                         uint32 level, char *env,
 914                                         DRIVER_DIRECTORY_CTR *ctr)
 915 {
 916         prs_struct qbuf, rbuf;
 917         SPOOL_Q_GETPRINTERDRIVERDIR in;
 918         SPOOL_R_GETPRINTERDRIVERDIR out;
 919         RPC_BUFFER buffer;
 920         fstring server;
 921         uint32 offered;
 922
 923         ZERO_STRUCT(in);
 924         ZERO_STRUCT(out);
 925
 926         slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 927         strupper_m(server);
 928
 929         offered = 0;
 930         if (!rpcbuf_init(&buffer, offered, mem_ctx))
 931                 return WERR_NOMEM;
 932         make_spoolss_q_getprinterdriverdir( &in, server, env, level,
 933                 &buffer, offered );
 934
 935         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDRIVERDIRECTORY,
 936                     in, out,
 937                     qbuf, rbuf,
 938                     spoolss_io_q_getprinterdriverdir,
 939                     spoolss_io_r_getprinterdriverdir,
 940                     WERR_GENERAL_FAILURE );
 941
 942         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
 943                 offered = out.needed;
 944
 945                 ZERO_STRUCT(in);
 946                 ZERO_STRUCT(out);
 947
 948                 if (!rpcbuf_init(&buffer, offered, mem_ctx))
 949                         return WERR_NOMEM;
 950                 make_spoolss_q_getprinterdriverdir( &in, server, env, level,
 951                         &buffer, offered );
 952
 953                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDRIVERDIRECTORY,
 954                             in, out,
 955                             qbuf, rbuf,
 956                             spoolss_io_q_getprinterdriverdir,
 957                             spoolss_io_r_getprinterdriverdir,
 958                             WERR_GENERAL_FAILURE );
 959         }
 960
 961         if (!W_ERROR_IS_OK(out.status))
 962                 return out.status;
 963
 964         if (!decode_printerdriverdir_1(mem_ctx, out.buffer, 1, &ctr->info1)) {
 965                 return WERR_GENERAL_FAILURE;
 966         }
 967
 968         return out.status;
 969 }
 970
 971 /**********************************************************************
 972 **********************************************************************/
 973
 974 WERROR rpccli_spoolss_addprinterdriver (struct rpc_pipe_client *cli,
 975                                      TALLOC_CTX *mem_ctx, uint32 level,
 976                                      PRINTER_DRIVER_CTR *ctr)
 977 {
 978         prs_struct qbuf, rbuf;
 979         SPOOL_Q_ADDPRINTERDRIVER in;
 980         SPOOL_R_ADDPRINTERDRIVER out;
 981         fstring server;
 982
 983         ZERO_STRUCT(in);
 984         ZERO_STRUCT(out);
 985
 986         slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 987         strupper_m(server);
 988
 989         make_spoolss_q_addprinterdriver( mem_ctx, &in, server, level, ctr );
 990
 991         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ADDPRINTERDRIVER,
 992                     in, out,
 993                     qbuf, rbuf,
 994                     spoolss_io_q_addprinterdriver,
 995                     spoolss_io_r_addprinterdriver,
 996                     WERR_GENERAL_FAILURE );
 997
 998         return out.status;
 999 }
1000
1001 /**********************************************************************
1002 **********************************************************************/
1003
1004 WERROR rpccli_spoolss_addprinterex (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1005                                  uint32 level, PRINTER_INFO_CTR*ctr)
1006 {
1007         prs_struct qbuf, rbuf;
1008         SPOOL_Q_ADDPRINTEREX in;
1009         SPOOL_R_ADDPRINTEREX out;
1010         fstring server, client, user;
1011
1012         ZERO_STRUCT(in);
1013         ZERO_STRUCT(out);
1014
1015         slprintf(client, sizeof(fstring)-1, "\\\\%s", global_myname());
1016         slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1017
1018         strupper_m(client);
1019         strupper_m(server);
1020
1021         fstrcpy  (user, cli->auth->user_name);
1022
1023         make_spoolss_q_addprinterex( mem_ctx, &in, server, client,
1024                 user, level, ctr);
1025
1026         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ADDPRINTEREX,
1027                     in, out,
1028                     qbuf, rbuf,
1029                     spoolss_io_q_addprinterex,
1030                     spoolss_io_r_addprinterex,
1031                     WERR_GENERAL_FAILURE );
1032
1033         return out.status;
1034 }
1035
1036 /**********************************************************************
1037 **********************************************************************/
1038
1039 WERROR rpccli_spoolss_deleteprinterdriverex(struct rpc_pipe_client *cli,
1040                                          TALLOC_CTX *mem_ctx, const char *arch,
1041                                          const char *driver, int version)
1042 {
1043         prs_struct qbuf, rbuf;
1044         SPOOL_Q_DELETEPRINTERDRIVEREX in;
1045         SPOOL_R_DELETEPRINTERDRIVEREX out;
1046         fstring server;
1047
1048         ZERO_STRUCT(in);
1049         ZERO_STRUCT(out);
1050
1051         slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1052         strupper_m(server);
1053
1054         make_spoolss_q_deleteprinterdriverex( mem_ctx, &in, server, arch, driver, version );
1055
1056         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_DELETEPRINTERDRIVEREX,
1057                     in, out,
1058                     qbuf, rbuf,
1059                     spoolss_io_q_deleteprinterdriverex,
1060                     spoolss_io_r_deleteprinterdriverex,
1061                     WERR_GENERAL_FAILURE );
1062
1063         return out.status;
1064 }
1065
1066 /**********************************************************************
1067 **********************************************************************/
1068
1069 WERROR rpccli_spoolss_deleteprinterdriver (struct rpc_pipe_client *cli,
1070                                         TALLOC_CTX *mem_ctx, const char *arch,
1071                                         const char *driver)
1072 {
1073         prs_struct qbuf, rbuf;
1074         SPOOL_Q_DELETEPRINTERDRIVER in;
1075         SPOOL_R_DELETEPRINTERDRIVER out;
1076         fstring server;
1077
1078         ZERO_STRUCT(in);
1079         ZERO_STRUCT(out);
1080
1081         slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1082         strupper_m(server);
1083
1084         make_spoolss_q_deleteprinterdriver( mem_ctx, &in, server, arch, driver );
1085
1086         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_DELETEPRINTERDRIVER,
1087                     in, out,
1088                     qbuf, rbuf,
1089                     spoolss_io_q_deleteprinterdriver,
1090                     spoolss_io_r_deleteprinterdriver,
1091                     WERR_GENERAL_FAILURE );
1092
1093         return out.status;
1094 }
1095
1096 /**********************************************************************
1097 **********************************************************************/
1098
1099 WERROR rpccli_spoolss_getprintprocessordirectory(struct rpc_pipe_client *cli,
1100                                               TALLOC_CTX *mem_ctx,
1101                                               char *name, char *environment,
1102                                               fstring procdir)
1103 {
1104         prs_struct qbuf, rbuf;
1105         SPOOL_Q_GETPRINTPROCESSORDIRECTORY in;
1106         SPOOL_R_GETPRINTPROCESSORDIRECTORY out;
1107         int level = 1;
1108         RPC_BUFFER buffer;
1109         uint32 offered;
1110
1111         ZERO_STRUCT(in);
1112         ZERO_STRUCT(out);
1113
1114         offered = 0;
1115         if (!rpcbuf_init(&buffer, offered, mem_ctx))
1116                 return WERR_NOMEM;
1117         make_spoolss_q_getprintprocessordirectory( &in, name,
1118                 environment, level, &buffer, offered );
1119
1120         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTPROCESSORDIRECTORY,
1121                     in, out,
1122                     qbuf, rbuf,
1123                     spoolss_io_q_getprintprocessordirectory,
1124                     spoolss_io_r_getprintprocessordirectory,
1125                     WERR_GENERAL_FAILURE );
1126
1127         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
1128                 offered = out.needed;
1129
1130                 ZERO_STRUCT(in);
1131                 ZERO_STRUCT(out);
1132
1133                 if (!rpcbuf_init(&buffer, offered, mem_ctx))
1134                         return WERR_NOMEM;
1135                 make_spoolss_q_getprintprocessordirectory( &in, name,
1136                         environment, level, &buffer, offered );
1137
1138                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTPROCESSORDIRECTORY,
1139                             in, out,
1140                             qbuf, rbuf,
1141                             spoolss_io_q_getprintprocessordirectory,
1142                             spoolss_io_r_getprintprocessordirectory,
1143                             WERR_GENERAL_FAILURE );
1144         }
1145
1146         if ( !W_ERROR_IS_OK(out.status) )
1147                 return out.status;
1148
1149         fstrcpy(procdir, "Not implemented!");
1150
1151         return out.status;
1152 }
1153
1154 /**********************************************************************
1155 **********************************************************************/
1156
1157 WERROR rpccli_spoolss_enumforms(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1158                              POLICY_HND *handle, int level, uint32 *num_forms,
1159                              FORM_1 **forms)
1160 {
1161         prs_struct qbuf, rbuf;
1162         SPOOL_Q_ENUMFORMS in;
1163         SPOOL_R_ENUMFORMS out;
1164         RPC_BUFFER buffer;
1165         uint32 offered;
1166
1167         ZERO_STRUCT(in);
1168         ZERO_STRUCT(out);
1169
1170         offered = 0;
1171         if (!rpcbuf_init(&buffer, offered, mem_ctx))
1172                 return WERR_NOMEM;
1173         make_spoolss_q_enumforms( &in, handle, level, &buffer, offered );
1174
1175         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMFORMS,
1176                     in, out,
1177                     qbuf, rbuf,
1178                     spoolss_io_q_enumforms,
1179                     spoolss_io_r_enumforms,
1180                     WERR_GENERAL_FAILURE );
1181
1182         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
1183                 offered = out.needed;
1184
1185                 ZERO_STRUCT(in);
1186                 ZERO_STRUCT(out);
1187
1188                 if (!rpcbuf_init(&buffer, offered, mem_ctx))
1189                         return WERR_NOMEM;
1190                 make_spoolss_q_enumforms( &in, handle, level, &buffer, offered );
1191
1192                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMFORMS,
1193                             in, out,
1194                             qbuf, rbuf,
1195                             spoolss_io_q_enumforms,
1196                             spoolss_io_r_enumforms,
1197                             WERR_GENERAL_FAILURE );
1198         }
1199
1200         if (!W_ERROR_IS_OK(out.status))
1201                 return out.status;
1202
1203         *num_forms = out.numofforms;
1204
1205         if (!decode_forms_1(mem_ctx, out.buffer, *num_forms, forms)) {
1206                 return WERR_GENERAL_FAILURE;
1207         }
1208
1209         return out.status;
1210 }
1211
1212 /**********************************************************************
1213 **********************************************************************/
1214
1215 WERROR rpccli_spoolss_enumjobs(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1216                             POLICY_HND *hnd, uint32 level, uint32 firstjob,
1217                             uint32 num_jobs, uint32 *returned, JOB_INFO_CTR *ctr)
1218 {
1219         prs_struct qbuf, rbuf;
1220         SPOOL_Q_ENUMJOBS in;
1221         SPOOL_R_ENUMJOBS out;
1222         RPC_BUFFER buffer;
1223         uint32 offered;
1224
1225         ZERO_STRUCT(in);
1226         ZERO_STRUCT(out);
1227
1228         offered = 0;
1229         if (!rpcbuf_init(&buffer, offered, mem_ctx))
1230                 return WERR_NOMEM;
1231         make_spoolss_q_enumjobs( &in, hnd, firstjob, num_jobs, level,
1232                 &buffer, offered );
1233
1234         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMJOBS,
1235                     in, out,
1236                     qbuf, rbuf,
1237                     spoolss_io_q_enumjobs,
1238                     spoolss_io_r_enumjobs,
1239                     WERR_GENERAL_FAILURE );
1240
1241         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
1242                 offered = out.needed;
1243
1244                 ZERO_STRUCT(in);
1245                 ZERO_STRUCT(out);
1246
1247                 if (!rpcbuf_init(&buffer, offered, mem_ctx))
1248                         return WERR_NOMEM;
1249                 make_spoolss_q_enumjobs( &in, hnd, firstjob, num_jobs, level,
1250                         &buffer, offered );
1251
1252                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMJOBS,
1253                             in, out,
1254                             qbuf, rbuf,
1255                             spoolss_io_q_enumjobs,
1256                             spoolss_io_r_enumjobs,
1257                             WERR_GENERAL_FAILURE );
1258         }
1259
1260         if (!W_ERROR_IS_OK(out.status))
1261                 return out.status;
1262
1263         switch(level) {
1264         case 1:
1265                 if (!decode_jobs_1(mem_ctx, out.buffer, out.returned, &ctr->job.job_info_1)) {
1266                         return WERR_GENERAL_FAILURE;
1267                 }
1268                 break;
1269         case 2:
1270                 if (!decode_jobs_2(mem_ctx, out.buffer, out.returned, &ctr->job.job_info_2)) {
1271                         return WERR_GENERAL_FAILURE;
1272                 }
1273                 break;
1274         default:
1275                 DEBUG(3, ("unsupported info level %d", level));
1276                 return WERR_UNKNOWN_LEVEL;
1277         }
1278
1279         *returned = out.returned;
1280
1281         return out.status;
1282 }
1283
1284 /**********************************************************************
1285 **********************************************************************/
1286
1287 WERROR rpccli_spoolss_setjob(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1288                           POLICY_HND *hnd, uint32 jobid, uint32 level,
1289                           uint32 command)
1290 {
1291         prs_struct qbuf, rbuf;
1292         SPOOL_Q_SETJOB in;
1293         SPOOL_R_SETJOB out;
1294
1295         ZERO_STRUCT(in);
1296         ZERO_STRUCT(out);
1297
1298         make_spoolss_q_setjob( &in, hnd, jobid, level, command );
1299
1300         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_SETJOB,
1301                     in, out,
1302                     qbuf, rbuf,
1303                     spoolss_io_q_setjob,
1304                     spoolss_io_r_setjob,
1305                     WERR_GENERAL_FAILURE );
1306
1307         return out.status;
1308 }
1309
1310 /**********************************************************************
1311 **********************************************************************/
1312
1313 WERROR rpccli_spoolss_getjob(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1314                           POLICY_HND *hnd, uint32 jobid, uint32 level,
1315                           JOB_INFO_CTR *ctr)
1316 {
1317         prs_struct qbuf, rbuf;
1318         SPOOL_Q_GETJOB in;
1319         SPOOL_R_GETJOB out;
1320         RPC_BUFFER buffer;
1321         uint32 offered;
1322
1323         ZERO_STRUCT(in);
1324         ZERO_STRUCT(out);
1325
1326         offered = 0;
1327         if (!rpcbuf_init(&buffer, offered, mem_ctx))
1328                 return WERR_NOMEM;
1329         make_spoolss_q_getjob( &in, hnd, jobid, level, &buffer, offered );
1330
1331         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETJOB,
1332                     in, out,
1333                     qbuf, rbuf,
1334                     spoolss_io_q_getjob,
1335                     spoolss_io_r_getjob,
1336                     WERR_GENERAL_FAILURE );
1337
1338         if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1339                 offered = out.needed;
1340
1341                 ZERO_STRUCT(in);
1342                 ZERO_STRUCT(out);
1343
1344                 if (!rpcbuf_init(&buffer, offered, mem_ctx))
1345                         return WERR_NOMEM;
1346                 make_spoolss_q_getjob( &in, hnd, jobid, level, &buffer, offered );
1347
1348                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETJOB,
1349                             in, out,
1350                             qbuf, rbuf,
1351                             spoolss_io_q_getjob,
1352                             spoolss_io_r_getjob,
1353                             WERR_GENERAL_FAILURE );
1354         }
1355
1356         if (!W_ERROR_IS_OK(out.status))
1357                 return out.status;
1358
1359         switch(level) {
1360         case 1:
1361                 if (!decode_jobs_1(mem_ctx, out.buffer, 1, &ctr->job.job_info_1)) {
1362                         return WERR_GENERAL_FAILURE;
1363                 }
1364                 break;
1365         case 2:
1366                 if (!decode_jobs_2(mem_ctx, out.buffer, 1, &ctr->job.job_info_2)) {
1367                         return WERR_GENERAL_FAILURE;
1368                 }
1369                 break;
1370         default:
1371                 return WERR_UNKNOWN_LEVEL;
1372         }
1373
1374         return out.status;
1375 }
1376
1377 /**********************************************************************
1378 **********************************************************************/
1379
1380 WERROR rpccli_spoolss_startdocprinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1381                                    POLICY_HND *hnd, char *docname,
1382                                    char *outputfile, char *datatype,
1383                                    uint32 *jobid)
1384 {
1385         prs_struct qbuf, rbuf;
1386         SPOOL_Q_STARTDOCPRINTER in;
1387         SPOOL_R_STARTDOCPRINTER out;
1388         uint32 level = 1;
1389
1390         ZERO_STRUCT(in);
1391         ZERO_STRUCT(out);
1392
1393         make_spoolss_q_startdocprinter( &in, hnd, level, docname,
1394                 outputfile, datatype );
1395
1396         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_STARTDOCPRINTER,
1397                     in, out,
1398                     qbuf, rbuf,
1399                     spoolss_io_q_startdocprinter,
1400                     spoolss_io_r_startdocprinter,
1401                     WERR_GENERAL_FAILURE );
1402
1403         *jobid = out.jobid;
1404
1405         return out.status;
1406 }
1407
1408 /**********************************************************************
1409 **********************************************************************/
1410
1411 WERROR rpccli_spoolss_getprinterdata(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1412                                   POLICY_HND *hnd, const char *valuename,
1413                                   REGISTRY_VALUE *value)
1414 {
1415         prs_struct qbuf, rbuf;
1416         SPOOL_Q_GETPRINTERDATA in;
1417         SPOOL_R_GETPRINTERDATA out;
1418         uint32 offered;
1419
1420         ZERO_STRUCT(in);
1421         ZERO_STRUCT(out);
1422
1423         offered = 0;
1424         make_spoolss_q_getprinterdata( &in, hnd, valuename, offered );
1425
1426         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDATA,
1427                     in, out,
1428                     qbuf, rbuf,
1429                     spoolss_io_q_getprinterdata,
1430                     spoolss_io_r_getprinterdata,
1431                     WERR_GENERAL_FAILURE );
1432
1433         if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1434                 offered = out.needed;
1435
1436                 ZERO_STRUCT(in);
1437                 ZERO_STRUCT(out);
1438
1439                 make_spoolss_q_getprinterdata( &in, hnd, valuename, offered );
1440
1441                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDATA,
1442                             in, out,
1443                             qbuf, rbuf,
1444                             spoolss_io_q_getprinterdata,
1445                             spoolss_io_r_getprinterdata,
1446                             WERR_GENERAL_FAILURE );
1447         }
1448
1449         if (!W_ERROR_IS_OK(out.status))
1450                 return out.status;
1451
1452         /* Return output parameters */
1453
1454         if (out.needed) {
1455                 value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data, out.needed);
1456         } else {
1457                 value->data_p = NULL;
1458         }
1459         value->type = out.type;
1460         value->size = out.size;
1461
1462         return out.status;
1463 }
1464
1465 /**********************************************************************
1466 **********************************************************************/
1467
1468 WERROR rpccli_spoolss_getprinterdataex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1469                                     POLICY_HND *hnd, const char *keyname,
1470                                     const char *valuename,
1471                                     REGISTRY_VALUE *value)
1472 {
1473         prs_struct qbuf, rbuf;
1474         SPOOL_Q_GETPRINTERDATAEX in;
1475         SPOOL_R_GETPRINTERDATAEX out;
1476         uint32 offered = 0;
1477
1478         ZERO_STRUCT(in);
1479         ZERO_STRUCT(out);
1480
1481         make_spoolss_q_getprinterdataex( &in, hnd, keyname, valuename, offered );
1482
1483         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDATAEX,
1484                     in, out,
1485                     qbuf, rbuf,
1486                     spoolss_io_q_getprinterdataex,
1487                     spoolss_io_r_getprinterdataex,
1488                     WERR_GENERAL_FAILURE );
1489
1490         if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1491                 offered = out.needed;
1492
1493                 ZERO_STRUCT(in);
1494                 ZERO_STRUCT(out);
1495
1496                 make_spoolss_q_getprinterdataex( &in, hnd, keyname, valuename, offered );
1497
1498                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDATAEX,
1499                             in, out,
1500                             qbuf, rbuf,
1501                             spoolss_io_q_getprinterdataex,
1502                             spoolss_io_r_getprinterdataex,
1503                             WERR_GENERAL_FAILURE );
1504         }
1505
1506         if (!W_ERROR_IS_OK(out.status))
1507                 return out.status;
1508
1509         /* Return output parameters */
1510
1511         if (out.needed) {
1512                 value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data, out.needed);
1513         } else {
1514                 value->data_p = NULL;
1515         }
1516         value->type = out.type;
1517         value->size = out.needed;
1518
1519         return out.status;
1520 }
1521
1522 /**********************************************************************
1523 **********************************************************************/
1524
1525 WERROR rpccli_spoolss_setprinterdata(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1526                                   POLICY_HND *hnd, REGISTRY_VALUE *value)
1527 {
1528         prs_struct qbuf, rbuf;
1529         SPOOL_Q_SETPRINTERDATA in;
1530         SPOOL_R_SETPRINTERDATA out;
1531
1532         ZERO_STRUCT(in);
1533         ZERO_STRUCT(out);
1534
1535         make_spoolss_q_setprinterdata( &in, hnd, value->valuename,
1536                 value->type, (char *)value->data_p, value->size);
1537
1538         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_SETPRINTERDATA,
1539                     in, out,
1540                     qbuf, rbuf,
1541                     spoolss_io_q_setprinterdata,
1542                     spoolss_io_r_setprinterdata,
1543                     WERR_GENERAL_FAILURE );
1544
1545         return out.status;
1546 }
1547
1548 /**********************************************************************
1549 **********************************************************************/
1550
1551 WERROR rpccli_spoolss_setprinterdataex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1552                                     POLICY_HND *hnd, char *keyname,
1553                                     REGISTRY_VALUE *value)
1554 {
1555         prs_struct qbuf, rbuf;
1556         SPOOL_Q_SETPRINTERDATAEX in;
1557         SPOOL_R_SETPRINTERDATAEX out;
1558
1559         ZERO_STRUCT(in);
1560         ZERO_STRUCT(out);
1561
1562         make_spoolss_q_setprinterdataex( &in, hnd, keyname, value->valuename,
1563                 value->type, (char *)value->data_p, value->size);
1564
1565         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_SETPRINTERDATAEX,
1566                     in, out,
1567                     qbuf, rbuf,
1568                     spoolss_io_q_setprinterdataex,
1569                     spoolss_io_r_setprinterdataex,
1570                     WERR_GENERAL_FAILURE );
1571
1572         return out.status;
1573 }
1574
1575 /**********************************************************************
1576 **********************************************************************/
1577
1578 WERROR rpccli_spoolss_enumprinterdata(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1579                                    POLICY_HND *hnd, uint32 ndx,
1580                                    uint32 value_offered, uint32 data_offered,
1581                                    uint32 *value_needed, uint32 *data_needed,
1582                                    REGISTRY_VALUE *value)
1583 {
1584         prs_struct qbuf, rbuf;
1585         SPOOL_Q_ENUMPRINTERDATA in;
1586         SPOOL_R_ENUMPRINTERDATA out;
1587
1588         ZERO_STRUCT(in);
1589         ZERO_STRUCT(out);
1590
1591         make_spoolss_q_enumprinterdata( &in, hnd, ndx, value_offered, data_offered );
1592
1593         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERDATA,
1594                     in, out,
1595                     qbuf, rbuf,
1596                     spoolss_io_q_enumprinterdata,
1597                     spoolss_io_r_enumprinterdata,
1598                     WERR_GENERAL_FAILURE );
1599
1600         if ( value_needed )
1601                 *value_needed = out.realvaluesize;
1602         if ( data_needed )
1603                 *data_needed = out.realdatasize;
1604
1605         if (!W_ERROR_IS_OK(out.status))
1606                 return out.status;
1607
1608         if (value) {
1609                 rpcstr_pull(value->valuename, out.value, sizeof(value->valuename), -1,
1610                             STR_TERMINATE);
1611                 if (out.realdatasize) {
1612                         value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data,
1613                                                        out.realdatasize);
1614                 } else {
1615                         value->data_p = NULL;
1616                 }
1617                 value->type = out.type;
1618                 value->size = out.realdatasize;
1619         }
1620
1621         return out.status;
1622 }
1623
1624 /**********************************************************************
1625 **********************************************************************/
1626
1627 WERROR rpccli_spoolss_enumprinterdataex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1628                                      POLICY_HND *hnd, const char *keyname,
1629                                      REGVAL_CTR *ctr)
1630 {
1631         prs_struct qbuf, rbuf;
1632         SPOOL_Q_ENUMPRINTERDATAEX in;
1633         SPOOL_R_ENUMPRINTERDATAEX out;
1634         int i;
1635         uint32 offered;
1636
1637         ZERO_STRUCT(in);
1638         ZERO_STRUCT(out);
1639
1640         offered = 0;
1641         make_spoolss_q_enumprinterdataex( &in, hnd, keyname, offered );
1642
1643         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERDATAEX,
1644                     in, out,
1645                     qbuf, rbuf,
1646                     spoolss_io_q_enumprinterdataex,
1647                     spoolss_io_r_enumprinterdataex,
1648                     WERR_GENERAL_FAILURE );
1649
1650         if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1651                 offered = out.needed;
1652
1653                 ZERO_STRUCT(in);
1654                 ZERO_STRUCT(out);
1655
1656                 make_spoolss_q_enumprinterdataex( &in, hnd, keyname, offered );
1657
1658                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERDATAEX,
1659                             in, out,
1660                             qbuf, rbuf,
1661                             spoolss_io_q_enumprinterdataex,
1662                             spoolss_io_r_enumprinterdataex,
1663                             WERR_GENERAL_FAILURE );
1664         }
1665
1666         if (!W_ERROR_IS_OK(out.status))
1667                 return out.status;
1668
1669         for (i = 0; i < out.returned; i++) {
1670                 PRINTER_ENUM_VALUES *v = &out.ctr.values[i];
1671                 fstring name;
1672
1673                 rpcstr_pull(name, v->valuename.buffer, sizeof(name), -1,
1674                             STR_TERMINATE);
1675                 regval_ctr_addvalue(ctr, name, v->type, (const char *)v->data, v->data_len);
1676         }
1677
1678         return out.status;
1679 }
1680
1681 /**********************************************************************
1682 **********************************************************************/
1683
1684 WERROR rpccli_spoolss_deleteprinterdata(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1685                                      POLICY_HND *hnd, char *valuename)
1686 {
1687         prs_struct qbuf, rbuf;
1688         SPOOL_Q_DELETEPRINTERDATA in;
1689         SPOOL_R_DELETEPRINTERDATA out;
1690
1691         ZERO_STRUCT(in);
1692         ZERO_STRUCT(out);
1693
1694         make_spoolss_q_deleteprinterdata( &in, hnd, valuename );
1695
1696         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_DELETEPRINTERDATA,
1697                     in, out,
1698                     qbuf, rbuf,
1699                     spoolss_io_q_deleteprinterdata,
1700                     spoolss_io_r_deleteprinterdata,
1701                     WERR_GENERAL_FAILURE );
1702
1703         return out.status;
1704 }
1705
1706 /**********************************************************************
1707 **********************************************************************/
1708
1709 WERROR rpccli_spoolss_deleteprinterdataex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1710                                        POLICY_HND *hnd, char *keyname,
1711                                        char *valuename)
1712 {
1713         prs_struct qbuf, rbuf;
1714         SPOOL_Q_DELETEPRINTERDATAEX in;
1715         SPOOL_R_DELETEPRINTERDATAEX out;
1716
1717         ZERO_STRUCT(in);
1718         ZERO_STRUCT(out);
1719
1720         make_spoolss_q_deleteprinterdataex( &in, hnd, keyname, valuename );
1721
1722         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_DELETEPRINTERDATAEX,
1723                     in, out,
1724                     qbuf, rbuf,
1725                     spoolss_io_q_deleteprinterdataex,
1726                     spoolss_io_r_deleteprinterdataex,
1727                     WERR_GENERAL_FAILURE );
1728
1729         return out.status;
1730 }
1731
1732 /**********************************************************************
1733 **********************************************************************/
1734
1735 WERROR rpccli_spoolss_enumprinterkey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1736                                   POLICY_HND *hnd, const char *keyname,
1737                                   uint16 **keylist, uint32 *len)
1738 {
1739         prs_struct qbuf, rbuf;
1740         SPOOL_Q_ENUMPRINTERKEY in;
1741         SPOOL_R_ENUMPRINTERKEY out;
1742         uint32 offered = 0;
1743
1744         ZERO_STRUCT(in);
1745         ZERO_STRUCT(out);
1746
1747         make_spoolss_q_enumprinterkey( &in, hnd, keyname, offered );
1748
1749         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERKEY,
1750                     in, out,
1751                     qbuf, rbuf,
1752                     spoolss_io_q_enumprinterkey,
1753                     spoolss_io_r_enumprinterkey,
1754                     WERR_GENERAL_FAILURE );
1755
1756         if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1757                 offered = out.needed;
1758
1759                 ZERO_STRUCT(in);
1760                 ZERO_STRUCT(out);
1761
1762                 make_spoolss_q_enumprinterkey( &in, hnd, keyname, offered );
1763
1764                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERKEY,
1765                             in, out,
1766                             qbuf, rbuf,
1767                             spoolss_io_q_enumprinterkey,
1768                             spoolss_io_r_enumprinterkey,
1769                             WERR_GENERAL_FAILURE );
1770         }
1771
1772         if ( !W_ERROR_IS_OK(out.status) )
1773                 return out.status;
1774
1775         if (keylist) {
1776                 *keylist = SMB_MALLOC_ARRAY(uint16, out.keys.buf_len);
1777                 if (!*keylist) {
1778                         return WERR_NOMEM;
1779                 }
1780                 memcpy(*keylist, out.keys.buffer, out.keys.buf_len * 2);
1781                 if (len)
1782                         *len = out.keys.buf_len * 2;
1783         }
1784
1785         return out.status;
1786 }
1787
1788 /**********************************************************************
1789 **********************************************************************/
1790
1791 WERROR rpccli_spoolss_deleteprinterkey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1792                                     POLICY_HND *hnd, char *keyname)
1793 {
1794         prs_struct qbuf, rbuf;
1795         SPOOL_Q_DELETEPRINTERKEY in;
1796         SPOOL_R_DELETEPRINTERKEY out;
1797
1798         ZERO_STRUCT(in);
1799         ZERO_STRUCT(out);
1800
1801         make_spoolss_q_deleteprinterkey( &in, hnd, keyname );
1802
1803         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_DELETEPRINTERKEY,
1804                     in, out,
1805                     qbuf, rbuf,
1806                     spoolss_io_q_deleteprinterkey,
1807                     spoolss_io_r_deleteprinterkey,
1808                     WERR_GENERAL_FAILURE );
1809
1810         return out.status;
1811 }
1812
1813 /** @} **/