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