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