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_getprinterdata(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1370                                   POLICY_HND *hnd, const char *valuename,
1371                                   REGISTRY_VALUE *value)
1372 {
1373         prs_struct qbuf, rbuf;
1374         SPOOL_Q_GETPRINTERDATA in;
1375         SPOOL_R_GETPRINTERDATA out;
1376         uint32 offered;
1377
1378         ZERO_STRUCT(in);
1379         ZERO_STRUCT(out);
1380
1381         offered = 0;
1382         make_spoolss_q_getprinterdata( &in, hnd, valuename, offered );
1383
1384         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDATA,
1385                     in, out,
1386                     qbuf, rbuf,
1387                     spoolss_io_q_getprinterdata,
1388                     spoolss_io_r_getprinterdata,
1389                     WERR_GENERAL_FAILURE );
1390
1391         if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1392                 offered = out.needed;
1393
1394                 ZERO_STRUCT(in);
1395                 ZERO_STRUCT(out);
1396
1397                 make_spoolss_q_getprinterdata( &in, hnd, valuename, offered );
1398
1399                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDATA,
1400                             in, out,
1401                             qbuf, rbuf,
1402                             spoolss_io_q_getprinterdata,
1403                             spoolss_io_r_getprinterdata,
1404                             WERR_GENERAL_FAILURE );
1405         }
1406
1407         if (!W_ERROR_IS_OK(out.status))
1408                 return out.status;
1409
1410         /* Return output parameters */
1411
1412         if (out.needed) {
1413                 value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data, out.needed);
1414         } else {
1415                 value->data_p = NULL;
1416         }
1417         value->type = out.type;
1418         value->size = out.size;
1419
1420         return out.status;
1421 }
1422
1423 /**********************************************************************
1424 **********************************************************************/
1425
1426 WERROR rpccli_spoolss_getprinterdataex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1427                                     POLICY_HND *hnd, const char *keyname,
1428                                     const char *valuename,
1429                                     REGISTRY_VALUE *value)
1430 {
1431         prs_struct qbuf, rbuf;
1432         SPOOL_Q_GETPRINTERDATAEX in;
1433         SPOOL_R_GETPRINTERDATAEX out;
1434         uint32 offered = 0;
1435
1436         ZERO_STRUCT(in);
1437         ZERO_STRUCT(out);
1438
1439         make_spoolss_q_getprinterdataex( &in, hnd, keyname, valuename, offered );
1440
1441         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDATAEX,
1442                     in, out,
1443                     qbuf, rbuf,
1444                     spoolss_io_q_getprinterdataex,
1445                     spoolss_io_r_getprinterdataex,
1446                     WERR_GENERAL_FAILURE );
1447
1448         if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1449                 offered = out.needed;
1450
1451                 ZERO_STRUCT(in);
1452                 ZERO_STRUCT(out);
1453
1454                 make_spoolss_q_getprinterdataex( &in, hnd, keyname, valuename, offered );
1455
1456                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDATAEX,
1457                             in, out,
1458                             qbuf, rbuf,
1459                             spoolss_io_q_getprinterdataex,
1460                             spoolss_io_r_getprinterdataex,
1461                             WERR_GENERAL_FAILURE );
1462         }
1463
1464         if (!W_ERROR_IS_OK(out.status))
1465                 return out.status;
1466
1467         /* Return output parameters */
1468
1469         if (out.needed) {
1470                 value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data, out.needed);
1471         } else {
1472                 value->data_p = NULL;
1473         }
1474         value->type = out.type;
1475         value->size = out.needed;
1476
1477         return out.status;
1478 }
1479
1480 /**********************************************************************
1481 **********************************************************************/
1482
1483 WERROR rpccli_spoolss_setprinterdata(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1484                                   POLICY_HND *hnd, REGISTRY_VALUE *value)
1485 {
1486         prs_struct qbuf, rbuf;
1487         SPOOL_Q_SETPRINTERDATA in;
1488         SPOOL_R_SETPRINTERDATA out;
1489
1490         ZERO_STRUCT(in);
1491         ZERO_STRUCT(out);
1492
1493         make_spoolss_q_setprinterdata( &in, hnd, value->valuename,
1494                 value->type, (char *)value->data_p, value->size);
1495
1496         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_SETPRINTERDATA,
1497                     in, out,
1498                     qbuf, rbuf,
1499                     spoolss_io_q_setprinterdata,
1500                     spoolss_io_r_setprinterdata,
1501                     WERR_GENERAL_FAILURE );
1502
1503         return out.status;
1504 }
1505
1506 /**********************************************************************
1507 **********************************************************************/
1508
1509 WERROR rpccli_spoolss_setprinterdataex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1510                                     POLICY_HND *hnd, char *keyname,
1511                                     REGISTRY_VALUE *value)
1512 {
1513         prs_struct qbuf, rbuf;
1514         SPOOL_Q_SETPRINTERDATAEX in;
1515         SPOOL_R_SETPRINTERDATAEX out;
1516
1517         ZERO_STRUCT(in);
1518         ZERO_STRUCT(out);
1519
1520         make_spoolss_q_setprinterdataex( &in, hnd, keyname, value->valuename,
1521                 value->type, (char *)value->data_p, value->size);
1522
1523         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_SETPRINTERDATAEX,
1524                     in, out,
1525                     qbuf, rbuf,
1526                     spoolss_io_q_setprinterdataex,
1527                     spoolss_io_r_setprinterdataex,
1528                     WERR_GENERAL_FAILURE );
1529
1530         return out.status;
1531 }
1532
1533 /**********************************************************************
1534 **********************************************************************/
1535
1536 WERROR rpccli_spoolss_enumprinterdata(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1537                                    POLICY_HND *hnd, uint32 ndx,
1538                                    uint32 value_offered, uint32 data_offered,
1539                                    uint32 *value_needed, uint32 *data_needed,
1540                                    REGISTRY_VALUE *value)
1541 {
1542         prs_struct qbuf, rbuf;
1543         SPOOL_Q_ENUMPRINTERDATA in;
1544         SPOOL_R_ENUMPRINTERDATA out;
1545
1546         ZERO_STRUCT(in);
1547         ZERO_STRUCT(out);
1548
1549         make_spoolss_q_enumprinterdata( &in, hnd, ndx, value_offered, data_offered );
1550
1551         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERDATA,
1552                     in, out,
1553                     qbuf, rbuf,
1554                     spoolss_io_q_enumprinterdata,
1555                     spoolss_io_r_enumprinterdata,
1556                     WERR_GENERAL_FAILURE );
1557
1558         if ( value_needed )
1559                 *value_needed = out.realvaluesize;
1560         if ( data_needed )
1561                 *data_needed = out.realdatasize;
1562
1563         if (!W_ERROR_IS_OK(out.status))
1564                 return out.status;
1565
1566         if (value) {
1567                 rpcstr_pull(value->valuename, out.value, sizeof(value->valuename), -1,
1568                             STR_TERMINATE);
1569                 if (out.realdatasize) {
1570                         value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data,
1571                                                        out.realdatasize);
1572                 } else {
1573                         value->data_p = NULL;
1574                 }
1575                 value->type = out.type;
1576                 value->size = out.realdatasize;
1577         }
1578
1579         return out.status;
1580 }
1581
1582 /**********************************************************************
1583 **********************************************************************/
1584
1585 WERROR rpccli_spoolss_enumprinterdataex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1586                                      POLICY_HND *hnd, const char *keyname,
1587                                      REGVAL_CTR *ctr)
1588 {
1589         prs_struct qbuf, rbuf;
1590         SPOOL_Q_ENUMPRINTERDATAEX in;
1591         SPOOL_R_ENUMPRINTERDATAEX out;
1592         int i;
1593         uint32 offered;
1594
1595         ZERO_STRUCT(in);
1596         ZERO_STRUCT(out);
1597
1598         offered = 0;
1599         make_spoolss_q_enumprinterdataex( &in, hnd, keyname, offered );
1600
1601         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERDATAEX,
1602                     in, out,
1603                     qbuf, rbuf,
1604                     spoolss_io_q_enumprinterdataex,
1605                     spoolss_io_r_enumprinterdataex,
1606                     WERR_GENERAL_FAILURE );
1607
1608         if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1609                 offered = out.needed;
1610
1611                 ZERO_STRUCT(in);
1612                 ZERO_STRUCT(out);
1613
1614                 make_spoolss_q_enumprinterdataex( &in, hnd, keyname, offered );
1615
1616                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERDATAEX,
1617                             in, out,
1618                             qbuf, rbuf,
1619                             spoolss_io_q_enumprinterdataex,
1620                             spoolss_io_r_enumprinterdataex,
1621                             WERR_GENERAL_FAILURE );
1622         }
1623
1624         if (!W_ERROR_IS_OK(out.status))
1625                 return out.status;
1626
1627         for (i = 0; i < out.returned; i++) {
1628                 PRINTER_ENUM_VALUES *v = &out.ctr.values[i];
1629                 fstring name;
1630
1631                 rpcstr_pull(name, v->valuename.buffer, sizeof(name), -1,
1632                             STR_TERMINATE);
1633                 regval_ctr_addvalue(ctr, name, v->type, (const char *)v->data, v->data_len);
1634         }
1635
1636         return out.status;
1637 }
1638
1639 /**********************************************************************
1640 **********************************************************************/
1641
1642 WERROR rpccli_spoolss_enumprinterkey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1643                                   POLICY_HND *hnd, const char *keyname,
1644                                   uint16 **keylist, uint32 *len)
1645 {
1646         prs_struct qbuf, rbuf;
1647         SPOOL_Q_ENUMPRINTERKEY in;
1648         SPOOL_R_ENUMPRINTERKEY out;
1649         uint32 offered = 0;
1650
1651         ZERO_STRUCT(in);
1652         ZERO_STRUCT(out);
1653
1654         make_spoolss_q_enumprinterkey( &in, hnd, keyname, offered );
1655
1656         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERKEY,
1657                     in, out,
1658                     qbuf, rbuf,
1659                     spoolss_io_q_enumprinterkey,
1660                     spoolss_io_r_enumprinterkey,
1661                     WERR_GENERAL_FAILURE );
1662
1663         if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1664                 offered = out.needed;
1665
1666                 ZERO_STRUCT(in);
1667                 ZERO_STRUCT(out);
1668
1669                 make_spoolss_q_enumprinterkey( &in, hnd, keyname, offered );
1670
1671                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERKEY,
1672                             in, out,
1673                             qbuf, rbuf,
1674                             spoolss_io_q_enumprinterkey,
1675                             spoolss_io_r_enumprinterkey,
1676                             WERR_GENERAL_FAILURE );
1677         }
1678
1679         if ( !W_ERROR_IS_OK(out.status) )
1680                 return out.status;
1681
1682         if (keylist) {
1683                 *keylist = SMB_MALLOC_ARRAY(uint16, out.keys.buf_len);
1684                 if (!*keylist) {
1685                         return WERR_NOMEM;
1686                 }
1687                 memcpy(*keylist, out.keys.buffer, out.keys.buf_len * 2);
1688                 if (len)
1689                         *len = out.keys.buf_len * 2;
1690         }
1691
1692         return out.status;
1693 }
1694
1695 /** @} **/