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   = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
  48         W_ERROR_HAVE_NO_MEMORY(level1.client);
  49         level1.user     = cli->auth->user_name;
  50         level1.build    = 1381;
  51         level1.major    = 2;
  52         level1.minor    = 0;
  53         level1.processor = 0;
  54
  55         userlevel.level1 = &level1;
  56
  57         status = rpccli_spoolss_OpenPrinterEx(cli, mem_ctx,
  58                                               printername,
  59                                               NULL,
  60                                               devmode_ctr,
  61                                               access_desired,
  62                                               1, /* level */
  63                                               userlevel,
  64                                               handle,
  65                                               &werror);
  66
  67         if (!W_ERROR_IS_OK(werror)) {
  68                 return werror;
  69         }
  70
  71         if (!NT_STATUS_IS_OK(status)) {
  72                 return ntstatus_to_werror(status);
  73         }
  74
  75         return WERR_OK;
  76 }
  77
  78 /**********************************************************************
  79  convencience wrapper around rpccli_spoolss_GetPrinterDriver2
  80 **********************************************************************/
  81
  82 WERROR rpccli_spoolss_getprinterdriver2(struct rpc_pipe_client *cli,
  83                                         TALLOC_CTX *mem_ctx,
  84                                         struct policy_handle *handle,
  85                                         const char *architecture,
  86                                         uint32_t level,
  87                                         uint32_t offered,
  88                                         uint32_t client_major_version,
  89                                         uint32_t client_minor_version,
  90                                         union spoolss_DriverInfo *info,
  91                                         uint32_t *server_major_version,
  92                                         uint32_t *server_minor_version)
  93 {
  94         NTSTATUS status;
  95         WERROR werror;
  96         uint32_t needed;
  97         DATA_BLOB buffer;
  98
  99         if (offered > 0) {
 100                 buffer = data_blob_talloc_zero(mem_ctx, offered);
 101                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
 102         }
 103
 104         status = rpccli_spoolss_GetPrinterDriver2(cli, mem_ctx,
 105                                                   handle,
 106                                                   architecture,
 107                                                   level,
 108                                                   (offered > 0) ? &buffer : NULL,
 109                                                   offered,
 110                                                   client_major_version,
 111                                                   client_minor_version,
 112                                                   info,
 113                                                   &needed,
 114                                                   server_major_version,
 115                                                   server_minor_version,
 116                                                   &werror);
 117         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
 118                 offered = needed;
 119                 buffer = data_blob_talloc_zero(mem_ctx, needed);
 120                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
 121
 122                 status = rpccli_spoolss_GetPrinterDriver2(cli, mem_ctx,
 123                                                           handle,
 124                                                           architecture,
 125                                                           level,
 126                                                           &buffer,
 127                                                           offered,
 128                                                           client_major_version,
 129                                                           client_minor_version,
 130                                                           info,
 131                                                           &needed,
 132                                                           server_major_version,
 133                                                           server_minor_version,
 134                                                           &werror);
 135         }
 136
 137         return werror;
 138 }
 139
 140 /*********************************************************************
 141  Decode various spoolss rpc's and info levels
 142  ********************************************************************/
 143
 144 /**********************************************************************
 145 **********************************************************************/
 146
 147 static bool decode_printer_info_0(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 148                                 uint32 returned, PRINTER_INFO_0 **info)
 149 {
 150         uint32 i;
 151         PRINTER_INFO_0  *inf;
 152
 153         if (returned) {
 154                 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_0, returned);
 155                 if (!inf) {
 156                         return False;
 157                 }
 158                 memset(inf, 0, returned*sizeof(PRINTER_INFO_0));
 159         } else {
 160                 inf = NULL;
 161         }
 162
 163         prs_set_offset(&buffer->prs,0);
 164
 165         for (i=0; i<returned; i++) {
 166                 if (!smb_io_printer_info_0("", buffer, &inf[i], 0)) {
 167                         return False;
 168                 }
 169         }
 170
 171         *info=inf;
 172         return True;
 173 }
 174
 175 /**********************************************************************
 176 **********************************************************************/
 177
 178 static bool decode_printer_info_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 179                                 uint32 returned, PRINTER_INFO_1 **info)
 180 {
 181         uint32 i;
 182         PRINTER_INFO_1  *inf;
 183
 184         if (returned) {
 185                 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_1, returned);
 186                 if (!inf) {
 187                         return False;
 188                 }
 189                 memset(inf, 0, returned*sizeof(PRINTER_INFO_1));
 190         } else {
 191                 inf = NULL;
 192         }
 193
 194         prs_set_offset(&buffer->prs,0);
 195
 196         for (i=0; i<returned; i++) {
 197                 if (!smb_io_printer_info_1("", buffer, &inf[i], 0)) {
 198                         return False;
 199                 }
 200         }
 201
 202         *info=inf;
 203         return True;
 204 }
 205
 206 /**********************************************************************
 207 **********************************************************************/
 208
 209 static bool decode_printer_info_2(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 210                                 uint32 returned, PRINTER_INFO_2 **info)
 211 {
 212         uint32 i;
 213         PRINTER_INFO_2  *inf;
 214
 215         if (returned) {
 216                 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_2, returned);
 217                 if (!inf) {
 218                         return False;
 219                 }
 220                 memset(inf, 0, returned*sizeof(PRINTER_INFO_2));
 221         } else {
 222                 inf = NULL;
 223         }
 224
 225         prs_set_offset(&buffer->prs,0);
 226
 227         for (i=0; i<returned; i++) {
 228                 /* a little initialization as we go */
 229                 inf[i].secdesc = NULL;
 230                 if (!smb_io_printer_info_2("", buffer, &inf[i], 0)) {
 231                         return False;
 232                 }
 233         }
 234
 235         *info=inf;
 236         return True;
 237 }
 238
 239 /**********************************************************************
 240 **********************************************************************/
 241
 242 static bool decode_printer_info_3(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 243                                 uint32 returned, PRINTER_INFO_3 **info)
 244 {
 245         uint32 i;
 246         PRINTER_INFO_3  *inf;
 247
 248         if (returned) {
 249                 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_3, returned);
 250                 if (!inf) {
 251                         return False;
 252                 }
 253                 memset(inf, 0, returned*sizeof(PRINTER_INFO_3));
 254         } else {
 255                 inf = NULL;
 256         }
 257
 258         prs_set_offset(&buffer->prs,0);
 259
 260         for (i=0; i<returned; i++) {
 261                 inf[i].secdesc = NULL;
 262                 if (!smb_io_printer_info_3("", 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_printer_info_7(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 275                                 uint32 returned, PRINTER_INFO_7 **info)
 276 {
 277         uint32 i;
 278         PRINTER_INFO_7  *inf;
 279
 280         if (returned) {
 281                 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_7, returned);
 282                 if (!inf) {
 283                         return False;
 284                 }
 285                 memset(inf, 0, returned*sizeof(PRINTER_INFO_7));
 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_printer_info_7("", buffer, &inf[i], 0)) {
 294                         return False;
 295                 }
 296         }
 297
 298         *info=inf;
 299         return True;
 300 }
 301
 302
 303 /**********************************************************************
 304 **********************************************************************/
 305
 306 static bool decode_port_info_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 307                         uint32 returned, PORT_INFO_1 **info)
 308 {
 309         uint32 i;
 310         PORT_INFO_1 *inf;
 311
 312         if (returned) {
 313                 inf=TALLOC_ARRAY(mem_ctx, PORT_INFO_1, returned);
 314                 if (!inf) {
 315                         return False;
 316                 }
 317                 memset(inf, 0, returned*sizeof(PORT_INFO_1));
 318         } else {
 319                 inf = NULL;
 320         }
 321
 322         prs_set_offset(&buffer->prs, 0);
 323
 324         for (i=0; i<returned; i++) {
 325                 if (!smb_io_port_info_1("", buffer, &(inf[i]), 0)) {
 326                         return False;
 327                 }
 328         }
 329
 330         *info=inf;
 331         return True;
 332 }
 333
 334 /**********************************************************************
 335 **********************************************************************/
 336
 337 static bool decode_port_info_2(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 338                         uint32 returned, PORT_INFO_2 **info)
 339 {
 340         uint32 i;
 341         PORT_INFO_2 *inf;
 342
 343         if (returned) {
 344                 inf=TALLOC_ARRAY(mem_ctx, PORT_INFO_2, returned);
 345                 if (!inf) {
 346                         return False;
 347                 }
 348                 memset(inf, 0, returned*sizeof(PORT_INFO_2));
 349         } else {
 350                 inf = NULL;
 351         }
 352
 353         prs_set_offset(&buffer->prs, 0);
 354
 355         for (i=0; i<returned; i++) {
 356                 if (!smb_io_port_info_2("", buffer, &(inf[i]), 0)) {
 357                         return False;
 358                 }
 359         }
 360
 361         *info=inf;
 362         return True;
 363 }
 364
 365 /**********************************************************************
 366 **********************************************************************/
 367
 368 static bool decode_printer_driver_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 369                         uint32 returned, DRIVER_INFO_1 **info)
 370 {
 371         uint32 i;
 372         DRIVER_INFO_1 *inf;
 373
 374         if (returned) {
 375                 inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_1, returned);
 376                 if (!inf) {
 377                         return False;
 378                 }
 379                 memset(inf, 0, returned*sizeof(DRIVER_INFO_1));
 380         } else {
 381                 inf = NULL;
 382         }
 383
 384         prs_set_offset(&buffer->prs,0);
 385
 386         for (i=0; i<returned; i++) {
 387                 if (!smb_io_printer_driver_info_1("", buffer, &(inf[i]), 0)) {
 388                         return False;
 389                 }
 390         }
 391
 392         *info=inf;
 393         return True;
 394 }
 395
 396 /**********************************************************************
 397 **********************************************************************/
 398
 399 static bool decode_printer_driver_2(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 400                         uint32 returned, DRIVER_INFO_2 **info)
 401 {
 402         uint32 i;
 403         DRIVER_INFO_2 *inf;
 404
 405         if (returned) {
 406                 inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_2, returned);
 407                 if (!inf) {
 408                         return False;
 409                 }
 410                 memset(inf, 0, returned*sizeof(DRIVER_INFO_2));
 411         } else {
 412                 inf = NULL;
 413         }
 414
 415         prs_set_offset(&buffer->prs,0);
 416
 417         for (i=0; i<returned; i++) {
 418                 if (!smb_io_printer_driver_info_2("", buffer, &(inf[i]), 0)) {
 419                         return False;
 420                 }
 421         }
 422
 423         *info=inf;
 424         return True;
 425 }
 426
 427 /**********************************************************************
 428 **********************************************************************/
 429
 430 static bool decode_printer_driver_3(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 431                         uint32 returned, DRIVER_INFO_3 **info)
 432 {
 433         uint32 i;
 434         DRIVER_INFO_3 *inf;
 435
 436         if (returned) {
 437                 inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_3, returned);
 438                 if (!inf) {
 439                         return False;
 440                 }
 441                 memset(inf, 0, returned*sizeof(DRIVER_INFO_3));
 442         } else {
 443                 inf = NULL;
 444         }
 445
 446         prs_set_offset(&buffer->prs,0);
 447
 448         for (i=0; i<returned; i++) {
 449                 if (!smb_io_printer_driver_info_3("", buffer, &(inf[i]), 0)) {
 450                         return False;
 451                 }
 452         }
 453
 454         *info=inf;
 455         return True;
 456 }
 457
 458 /**********************************************************************
 459 **********************************************************************/
 460
 461 static bool decode_jobs_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 462                           uint32 num_jobs, JOB_INFO_1 **jobs)
 463 {
 464         uint32 i;
 465
 466         if (num_jobs) {
 467                 *jobs = TALLOC_ARRAY(mem_ctx, JOB_INFO_1, num_jobs);
 468                 if (*jobs == NULL) {
 469                         return False;
 470                 }
 471         } else {
 472                 *jobs = NULL;
 473         }
 474         prs_set_offset(&buffer->prs,0);
 475
 476         for (i = 0; i < num_jobs; i++) {
 477                 if (!smb_io_job_info_1("", buffer, &((*jobs)[i]), 0)) {
 478                         return False;
 479                 }
 480         }
 481
 482         return True;
 483 }
 484
 485 /**********************************************************************
 486 **********************************************************************/
 487
 488 static bool decode_jobs_2(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 489                           uint32 num_jobs, JOB_INFO_2 **jobs)
 490 {
 491         uint32 i;
 492
 493         if (num_jobs) {
 494                 *jobs = TALLOC_ARRAY(mem_ctx, JOB_INFO_2, num_jobs);
 495                 if (*jobs == NULL) {
 496                         return False;
 497                 }
 498         } else {
 499                 *jobs = NULL;
 500         }
 501         prs_set_offset(&buffer->prs,0);
 502
 503         for (i = 0; i < num_jobs; i++) {
 504                 if (!smb_io_job_info_2("", buffer, &((*jobs)[i]), 0)) {
 505                         return False;
 506                 }
 507         }
 508
 509         return True;
 510 }
 511
 512 /**********************************************************************
 513 **********************************************************************/
 514
 515 static bool decode_forms_1(TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer,
 516                            uint32 num_forms, FORM_1 **forms)
 517 {
 518         int i;
 519
 520         if (num_forms) {
 521                 *forms = TALLOC_ARRAY(mem_ctx, FORM_1, num_forms);
 522                 if (*forms == NULL) {
 523                         return False;
 524                 }
 525         } else {
 526                 *forms = NULL;
 527         }
 528
 529         prs_set_offset(&buffer->prs,0);
 530
 531         for (i = 0; i < num_forms; i++) {
 532                 if (!smb_io_form_1("", buffer, &((*forms)[i]), 0)) {
 533                         return False;
 534                 }
 535         }
 536
 537         return True;
 538 }
 539
 540 /**********************************************************************
 541 **********************************************************************/
 542
 543 WERROR rpccli_spoolss_enum_printers(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 544                                  char *name, uint32 flags, uint32 level,
 545                                  uint32 *num_printers, PRINTER_INFO_CTR *ctr)
 546 {
 547         prs_struct qbuf, rbuf;
 548         SPOOL_Q_ENUMPRINTERS in;
 549         SPOOL_R_ENUMPRINTERS out;
 550         RPC_BUFFER buffer;
 551         uint32 offered;
 552
 553         ZERO_STRUCT(in);
 554         ZERO_STRUCT(out);
 555
 556         offered = 0;
 557         if (!rpcbuf_init(&buffer, offered, mem_ctx))
 558                 return WERR_NOMEM;
 559         make_spoolss_q_enumprinters( &in, flags, name, level, &buffer, offered );
 560
 561         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERS,
 562                     in, out,
 563                     qbuf, rbuf,
 564                     spoolss_io_q_enumprinters,
 565                     spoolss_io_r_enumprinters,
 566                     WERR_GENERAL_FAILURE );
 567
 568         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
 569                 offered = out.needed;
 570
 571                 ZERO_STRUCT(in);
 572                 ZERO_STRUCT(out);
 573
 574                 if (!rpcbuf_init(&buffer, offered, mem_ctx))
 575                         return WERR_NOMEM;
 576                 make_spoolss_q_enumprinters( &in, flags, name, level, &buffer, offered );
 577
 578                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERS,
 579                             in, out,
 580                             qbuf, rbuf,
 581                             spoolss_io_q_enumprinters,
 582                             spoolss_io_r_enumprinters,
 583                             WERR_GENERAL_FAILURE );
 584         }
 585
 586         if ( !W_ERROR_IS_OK(out.status) )
 587                 return out.status;
 588
 589         switch (level) {
 590         case 0:
 591                 if (!decode_printer_info_0(mem_ctx, out.buffer, out.returned, &ctr->printers_0)) {
 592                         return WERR_GENERAL_FAILURE;
 593                 }
 594                 break;
 595         case 1:
 596                 if (!decode_printer_info_1(mem_ctx, out.buffer, out.returned, &ctr->printers_1)) {
 597                         return WERR_GENERAL_FAILURE;
 598                 }
 599                 break;
 600         case 2:
 601                 if (!decode_printer_info_2(mem_ctx, out.buffer, out.returned, &ctr->printers_2)) {
 602                         return WERR_GENERAL_FAILURE;
 603                 }
 604                 break;
 605         case 3:
 606                 if (!decode_printer_info_3(mem_ctx, out.buffer, out.returned, &ctr->printers_3)) {
 607                         return WERR_GENERAL_FAILURE;
 608                 }
 609                 break;
 610         default:
 611                 return WERR_UNKNOWN_LEVEL;
 612         }
 613
 614         *num_printers = out.returned;
 615
 616         return out.status;
 617 }
 618
 619 /**********************************************************************
 620 **********************************************************************/
 621
 622 WERROR rpccli_spoolss_enum_ports(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 623                               uint32 level, uint32 *num_ports, PORT_INFO_CTR *ctr)
 624 {
 625         prs_struct qbuf, rbuf;
 626         SPOOL_Q_ENUMPORTS in;
 627         SPOOL_R_ENUMPORTS out;
 628         RPC_BUFFER buffer;
 629         fstring server;
 630         uint32 offered;
 631
 632         ZERO_STRUCT(in);
 633         ZERO_STRUCT(out);
 634
 635         slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 636         strupper_m(server);
 637
 638         offered = 0;
 639         if (!rpcbuf_init(&buffer, offered, mem_ctx))
 640                 return WERR_NOMEM;
 641         make_spoolss_q_enumports( &in, server, level, &buffer, offered );
 642
 643         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPORTS,
 644                     in, out,
 645                     qbuf, rbuf,
 646                     spoolss_io_q_enumports,
 647                     spoolss_io_r_enumports,
 648                     WERR_GENERAL_FAILURE );
 649
 650         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
 651                 offered = out.needed;
 652
 653                 ZERO_STRUCT(in);
 654                 ZERO_STRUCT(out);
 655
 656                 if (!rpcbuf_init(&buffer, offered, mem_ctx))
 657                         return WERR_NOMEM;
 658                 make_spoolss_q_enumports( &in, server, level, &buffer, offered );
 659
 660                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPORTS,
 661                             in, out,
 662                             qbuf, rbuf,
 663                             spoolss_io_q_enumports,
 664                             spoolss_io_r_enumports,
 665                             WERR_GENERAL_FAILURE );
 666         }
 667
 668         if ( !W_ERROR_IS_OK(out.status) )
 669                 return out.status;
 670
 671         switch (level) {
 672         case 1:
 673                 if (!decode_port_info_1(mem_ctx, out.buffer, out.returned, &ctr->port.info_1)) {
 674                         return WERR_GENERAL_FAILURE;
 675                 }
 676                 break;
 677         case 2:
 678                 if (!decode_port_info_2(mem_ctx, out.buffer, out.returned, &ctr->port.info_2)) {
 679                         return WERR_GENERAL_FAILURE;
 680                 }
 681                 break;
 682         default:
 683                 return WERR_UNKNOWN_LEVEL;
 684         }
 685
 686         *num_ports = out.returned;
 687
 688         return out.status;
 689 }
 690
 691 /**********************************************************************
 692 **********************************************************************/
 693
 694 WERROR rpccli_spoolss_getprinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 695                               POLICY_HND *pol, uint32 level,
 696                               PRINTER_INFO_CTR *ctr)
 697 {
 698         prs_struct qbuf, rbuf;
 699         SPOOL_Q_GETPRINTER in;
 700         SPOOL_R_GETPRINTER out;
 701         RPC_BUFFER buffer;
 702         uint32 offered;
 703
 704         ZERO_STRUCT(in);
 705         ZERO_STRUCT(out);
 706
 707         /* Initialise input parameters */
 708
 709         offered = 0;
 710         if (!rpcbuf_init(&buffer, offered, mem_ctx))
 711                 return WERR_NOMEM;
 712         make_spoolss_q_getprinter( mem_ctx, &in, pol, level, &buffer, offered );
 713
 714         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTER,
 715                     in, out,
 716                     qbuf, rbuf,
 717                     spoolss_io_q_getprinter,
 718                     spoolss_io_r_getprinter,
 719                     WERR_GENERAL_FAILURE );
 720
 721         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
 722                 offered = out.needed;
 723
 724                 ZERO_STRUCT(in);
 725                 ZERO_STRUCT(out);
 726
 727                 if (!rpcbuf_init(&buffer, offered, mem_ctx))
 728                         return WERR_NOMEM;
 729                 make_spoolss_q_getprinter( mem_ctx, &in, pol, level, &buffer, offered );
 730
 731                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTER,
 732                             in, out,
 733                             qbuf, rbuf,
 734                             spoolss_io_q_getprinter,
 735                             spoolss_io_r_getprinter,
 736                             WERR_GENERAL_FAILURE );
 737         }
 738
 739         if ( !W_ERROR_IS_OK(out.status) )
 740                 return out.status;
 741
 742         switch (level) {
 743         case 0:
 744                 if (!decode_printer_info_0(mem_ctx, out.buffer, 1, &ctr->printers_0)) {
 745                         return WERR_GENERAL_FAILURE;
 746                 }
 747                 break;
 748         case 1:
 749                 if (!decode_printer_info_1(mem_ctx, out.buffer, 1, &ctr->printers_1)) {
 750                         return WERR_GENERAL_FAILURE;
 751                 }
 752                 break;
 753         case 2:
 754                 if (!decode_printer_info_2(mem_ctx, out.buffer, 1, &ctr->printers_2)) {
 755                         return WERR_GENERAL_FAILURE;
 756                 }
 757                 break;
 758         case 3:
 759                 if (!decode_printer_info_3(mem_ctx, out.buffer, 1, &ctr->printers_3)) {
 760                         return WERR_GENERAL_FAILURE;
 761                 }
 762                 break;
 763         case 7:
 764                 if (!decode_printer_info_7(mem_ctx, out.buffer, 1, &ctr->printers_7)) {
 765                         return WERR_GENERAL_FAILURE;
 766                 }
 767                 break;
 768         default:
 769                 return WERR_UNKNOWN_LEVEL;
 770         }
 771
 772         return out.status;
 773 }
 774
 775 /**********************************************************************
 776 **********************************************************************/
 777
 778 WERROR rpccli_spoolss_setprinter(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 779                               POLICY_HND *pol, uint32 level,
 780                               PRINTER_INFO_CTR *ctr, uint32 command)
 781 {
 782         prs_struct qbuf, rbuf;
 783         SPOOL_Q_SETPRINTER in;
 784         SPOOL_R_SETPRINTER out;
 785
 786         ZERO_STRUCT(in);
 787         ZERO_STRUCT(out);
 788
 789         make_spoolss_q_setprinter( mem_ctx, &in, pol, level, ctr, command );
 790
 791         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_SETPRINTER,
 792                     in, out,
 793                     qbuf, rbuf,
 794                     spoolss_io_q_setprinter,
 795                     spoolss_io_r_setprinter,
 796                     WERR_GENERAL_FAILURE );
 797
 798         return out.status;
 799 }
 800
 801 /**********************************************************************
 802 **********************************************************************/
 803
 804 WERROR rpccli_spoolss_enumprinterdrivers (struct rpc_pipe_client *cli,
 805                                        TALLOC_CTX *mem_ctx,
 806                                        uint32 level, const char *env,
 807                                        uint32 *num_drivers,
 808                                        PRINTER_DRIVER_CTR *ctr)
 809 {
 810         prs_struct qbuf, rbuf;
 811         SPOOL_Q_ENUMPRINTERDRIVERS in;
 812         SPOOL_R_ENUMPRINTERDRIVERS out;
 813         RPC_BUFFER buffer;
 814         fstring server;
 815         uint32 offered;
 816
 817         ZERO_STRUCT(in);
 818         ZERO_STRUCT(out);
 819
 820         slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 821         strupper_m(server);
 822
 823         offered = 0;
 824         if (!rpcbuf_init(&buffer, offered, mem_ctx))
 825                 return WERR_NOMEM;
 826         make_spoolss_q_enumprinterdrivers( &in, server, env, level,
 827                 &buffer, offered);
 828
 829         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERDRIVERS,
 830                     in, out,
 831                     qbuf, rbuf,
 832                     spoolss_io_q_enumprinterdrivers,
 833                     spoolss_io_r_enumprinterdrivers,
 834                     WERR_GENERAL_FAILURE );
 835
 836         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
 837                 offered = out.needed;
 838
 839                 ZERO_STRUCT(in);
 840                 ZERO_STRUCT(out);
 841
 842                 if (!rpcbuf_init(&buffer, offered, mem_ctx))
 843                         return WERR_NOMEM;
 844                 make_spoolss_q_enumprinterdrivers( &in, server, env, level,
 845                         &buffer, offered);
 846
 847                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERDRIVERS,
 848                             in, out,
 849                             qbuf, rbuf,
 850                             spoolss_io_q_enumprinterdrivers,
 851                             spoolss_io_r_enumprinterdrivers,
 852                             WERR_GENERAL_FAILURE );
 853         }
 854
 855         *num_drivers = out.returned;
 856
 857         if ( !W_ERROR_IS_OK(out.status) )
 858                 return out.status;
 859
 860         if ( out.returned ) {
 861
 862                 switch (level) {
 863                 case 1:
 864                         if (!decode_printer_driver_1(mem_ctx, out.buffer, out.returned, &ctr->info1)) {
 865                                 return WERR_GENERAL_FAILURE;
 866                         }
 867                         break;
 868                 case 2:
 869                         if (!decode_printer_driver_2(mem_ctx, out.buffer, out.returned, &ctr->info2)) {
 870                                 return WERR_GENERAL_FAILURE;
 871                         }
 872                         break;
 873                 case 3:
 874                         if (!decode_printer_driver_3(mem_ctx, out.buffer, out.returned, &ctr->info3)) {
 875                                 return WERR_GENERAL_FAILURE;
 876                         }
 877                         break;
 878                 default:
 879                         return WERR_UNKNOWN_LEVEL;
 880                 }
 881         }
 882
 883         return out.status;
 884 }
 885
 886 /**********************************************************************
 887 **********************************************************************/
 888
 889 WERROR rpccli_spoolss_addprinterex (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 890                                  uint32 level, PRINTER_INFO_CTR*ctr)
 891 {
 892         prs_struct qbuf, rbuf;
 893         SPOOL_Q_ADDPRINTEREX in;
 894         SPOOL_R_ADDPRINTEREX out;
 895         fstring server, client, user;
 896
 897         ZERO_STRUCT(in);
 898         ZERO_STRUCT(out);
 899
 900         slprintf(client, sizeof(fstring)-1, "\\\\%s", global_myname());
 901         slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 902
 903         strupper_m(client);
 904         strupper_m(server);
 905
 906         fstrcpy  (user, cli->auth->user_name);
 907
 908         make_spoolss_q_addprinterex( mem_ctx, &in, server, client,
 909                 user, level, ctr);
 910
 911         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ADDPRINTEREX,
 912                     in, out,
 913                     qbuf, rbuf,
 914                     spoolss_io_q_addprinterex,
 915                     spoolss_io_r_addprinterex,
 916                     WERR_GENERAL_FAILURE );
 917
 918         return out.status;
 919 }
 920
 921 /**********************************************************************
 922 **********************************************************************/
 923
 924 WERROR rpccli_spoolss_enumforms(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 925                              POLICY_HND *handle, int level, uint32 *num_forms,
 926                              FORM_1 **forms)
 927 {
 928         prs_struct qbuf, rbuf;
 929         SPOOL_Q_ENUMFORMS in;
 930         SPOOL_R_ENUMFORMS out;
 931         RPC_BUFFER buffer;
 932         uint32 offered;
 933
 934         ZERO_STRUCT(in);
 935         ZERO_STRUCT(out);
 936
 937         offered = 0;
 938         if (!rpcbuf_init(&buffer, offered, mem_ctx))
 939                 return WERR_NOMEM;
 940         make_spoolss_q_enumforms( &in, handle, level, &buffer, offered );
 941
 942         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMFORMS,
 943                     in, out,
 944                     qbuf, rbuf,
 945                     spoolss_io_q_enumforms,
 946                     spoolss_io_r_enumforms,
 947                     WERR_GENERAL_FAILURE );
 948
 949         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
 950                 offered = out.needed;
 951
 952                 ZERO_STRUCT(in);
 953                 ZERO_STRUCT(out);
 954
 955                 if (!rpcbuf_init(&buffer, offered, mem_ctx))
 956                         return WERR_NOMEM;
 957                 make_spoolss_q_enumforms( &in, handle, level, &buffer, offered );
 958
 959                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMFORMS,
 960                             in, out,
 961                             qbuf, rbuf,
 962                             spoolss_io_q_enumforms,
 963                             spoolss_io_r_enumforms,
 964                             WERR_GENERAL_FAILURE );
 965         }
 966
 967         if (!W_ERROR_IS_OK(out.status))
 968                 return out.status;
 969
 970         *num_forms = out.numofforms;
 971
 972         if (!decode_forms_1(mem_ctx, out.buffer, *num_forms, forms)) {
 973                 return WERR_GENERAL_FAILURE;
 974         }
 975
 976         return out.status;
 977 }
 978
 979 /**********************************************************************
 980 **********************************************************************/
 981
 982 WERROR rpccli_spoolss_enumjobs(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 983                             POLICY_HND *hnd, uint32 level, uint32 firstjob,
 984                             uint32 num_jobs, uint32 *returned, JOB_INFO_CTR *ctr)
 985 {
 986         prs_struct qbuf, rbuf;
 987         SPOOL_Q_ENUMJOBS in;
 988         SPOOL_R_ENUMJOBS out;
 989         RPC_BUFFER buffer;
 990         uint32 offered;
 991
 992         ZERO_STRUCT(in);
 993         ZERO_STRUCT(out);
 994
 995         offered = 0;
 996         if (!rpcbuf_init(&buffer, offered, mem_ctx))
 997                 return WERR_NOMEM;
 998         make_spoolss_q_enumjobs( &in, hnd, firstjob, num_jobs, level,
 999                 &buffer, offered );
1000
1001         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMJOBS,
1002                     in, out,
1003                     qbuf, rbuf,
1004                     spoolss_io_q_enumjobs,
1005                     spoolss_io_r_enumjobs,
1006                     WERR_GENERAL_FAILURE );
1007
1008         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
1009                 offered = out.needed;
1010
1011                 ZERO_STRUCT(in);
1012                 ZERO_STRUCT(out);
1013
1014                 if (!rpcbuf_init(&buffer, offered, mem_ctx))
1015                         return WERR_NOMEM;
1016                 make_spoolss_q_enumjobs( &in, hnd, firstjob, num_jobs, level,
1017                         &buffer, offered );
1018
1019                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMJOBS,
1020                             in, out,
1021                             qbuf, rbuf,
1022                             spoolss_io_q_enumjobs,
1023                             spoolss_io_r_enumjobs,
1024                             WERR_GENERAL_FAILURE );
1025         }
1026
1027         if (!W_ERROR_IS_OK(out.status))
1028                 return out.status;
1029
1030         switch(level) {
1031         case 1:
1032                 if (!decode_jobs_1(mem_ctx, out.buffer, out.returned, &ctr->job.job_info_1)) {
1033                         return WERR_GENERAL_FAILURE;
1034                 }
1035                 break;
1036         case 2:
1037                 if (!decode_jobs_2(mem_ctx, out.buffer, out.returned, &ctr->job.job_info_2)) {
1038                         return WERR_GENERAL_FAILURE;
1039                 }
1040                 break;
1041         default:
1042                 DEBUG(3, ("unsupported info level %d", level));
1043                 return WERR_UNKNOWN_LEVEL;
1044         }
1045
1046         *returned = out.returned;
1047
1048         return out.status;
1049 }
1050
1051 /**********************************************************************
1052 **********************************************************************/
1053
1054 WERROR rpccli_spoolss_getjob(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1055                           POLICY_HND *hnd, uint32 jobid, uint32 level,
1056                           JOB_INFO_CTR *ctr)
1057 {
1058         prs_struct qbuf, rbuf;
1059         SPOOL_Q_GETJOB in;
1060         SPOOL_R_GETJOB out;
1061         RPC_BUFFER buffer;
1062         uint32 offered;
1063
1064         ZERO_STRUCT(in);
1065         ZERO_STRUCT(out);
1066
1067         offered = 0;
1068         if (!rpcbuf_init(&buffer, offered, mem_ctx))
1069                 return WERR_NOMEM;
1070         make_spoolss_q_getjob( &in, hnd, jobid, level, &buffer, offered );
1071
1072         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETJOB,
1073                     in, out,
1074                     qbuf, rbuf,
1075                     spoolss_io_q_getjob,
1076                     spoolss_io_r_getjob,
1077                     WERR_GENERAL_FAILURE );
1078
1079         if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1080                 offered = out.needed;
1081
1082                 ZERO_STRUCT(in);
1083                 ZERO_STRUCT(out);
1084
1085                 if (!rpcbuf_init(&buffer, offered, mem_ctx))
1086                         return WERR_NOMEM;
1087                 make_spoolss_q_getjob( &in, hnd, jobid, level, &buffer, offered );
1088
1089                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETJOB,
1090                             in, out,
1091                             qbuf, rbuf,
1092                             spoolss_io_q_getjob,
1093                             spoolss_io_r_getjob,
1094                             WERR_GENERAL_FAILURE );
1095         }
1096
1097         if (!W_ERROR_IS_OK(out.status))
1098                 return out.status;
1099
1100         switch(level) {
1101         case 1:
1102                 if (!decode_jobs_1(mem_ctx, out.buffer, 1, &ctr->job.job_info_1)) {
1103                         return WERR_GENERAL_FAILURE;
1104                 }
1105                 break;
1106         case 2:
1107                 if (!decode_jobs_2(mem_ctx, out.buffer, 1, &ctr->job.job_info_2)) {
1108                         return WERR_GENERAL_FAILURE;
1109                 }
1110                 break;
1111         default:
1112                 return WERR_UNKNOWN_LEVEL;
1113         }
1114
1115         return out.status;
1116 }
1117
1118 /**********************************************************************
1119 **********************************************************************/
1120
1121 WERROR rpccli_spoolss_getprinterdata(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1122                                   POLICY_HND *hnd, const char *valuename,
1123                                   REGISTRY_VALUE *value)
1124 {
1125         prs_struct qbuf, rbuf;
1126         SPOOL_Q_GETPRINTERDATA in;
1127         SPOOL_R_GETPRINTERDATA out;
1128         uint32 offered;
1129
1130         ZERO_STRUCT(in);
1131         ZERO_STRUCT(out);
1132
1133         offered = 0;
1134         make_spoolss_q_getprinterdata( &in, hnd, valuename, offered );
1135
1136         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDATA,
1137                     in, out,
1138                     qbuf, rbuf,
1139                     spoolss_io_q_getprinterdata,
1140                     spoolss_io_r_getprinterdata,
1141                     WERR_GENERAL_FAILURE );
1142
1143         if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1144                 offered = out.needed;
1145
1146                 ZERO_STRUCT(in);
1147                 ZERO_STRUCT(out);
1148
1149                 make_spoolss_q_getprinterdata( &in, hnd, valuename, offered );
1150
1151                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDATA,
1152                             in, out,
1153                             qbuf, rbuf,
1154                             spoolss_io_q_getprinterdata,
1155                             spoolss_io_r_getprinterdata,
1156                             WERR_GENERAL_FAILURE );
1157         }
1158
1159         if (!W_ERROR_IS_OK(out.status))
1160                 return out.status;
1161
1162         /* Return output parameters */
1163
1164         if (out.needed) {
1165                 value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data, out.needed);
1166         } else {
1167                 value->data_p = NULL;
1168         }
1169         value->type = out.type;
1170         value->size = out.size;
1171
1172         return out.status;
1173 }
1174
1175 /**********************************************************************
1176 **********************************************************************/
1177
1178 WERROR rpccli_spoolss_setprinterdata(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1179                                   POLICY_HND *hnd, REGISTRY_VALUE *value)
1180 {
1181         prs_struct qbuf, rbuf;
1182         SPOOL_Q_SETPRINTERDATA in;
1183         SPOOL_R_SETPRINTERDATA out;
1184
1185         ZERO_STRUCT(in);
1186         ZERO_STRUCT(out);
1187
1188         make_spoolss_q_setprinterdata( &in, hnd, value->valuename,
1189                 value->type, (char *)value->data_p, value->size);
1190
1191         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_SETPRINTERDATA,
1192                     in, out,
1193                     qbuf, rbuf,
1194                     spoolss_io_q_setprinterdata,
1195                     spoolss_io_r_setprinterdata,
1196                     WERR_GENERAL_FAILURE );
1197
1198         return out.status;
1199 }
1200
1201 /**********************************************************************
1202 **********************************************************************/
1203
1204 WERROR rpccli_spoolss_enumprinterdata(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1205                                    POLICY_HND *hnd, uint32 ndx,
1206                                    uint32 value_offered, uint32 data_offered,
1207                                    uint32 *value_needed, uint32 *data_needed,
1208                                    REGISTRY_VALUE *value)
1209 {
1210         prs_struct qbuf, rbuf;
1211         SPOOL_Q_ENUMPRINTERDATA in;
1212         SPOOL_R_ENUMPRINTERDATA out;
1213
1214         ZERO_STRUCT(in);
1215         ZERO_STRUCT(out);
1216
1217         make_spoolss_q_enumprinterdata( &in, hnd, ndx, value_offered, data_offered );
1218
1219         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERDATA,
1220                     in, out,
1221                     qbuf, rbuf,
1222                     spoolss_io_q_enumprinterdata,
1223                     spoolss_io_r_enumprinterdata,
1224                     WERR_GENERAL_FAILURE );
1225
1226         if ( value_needed )
1227                 *value_needed = out.realvaluesize;
1228         if ( data_needed )
1229                 *data_needed = out.realdatasize;
1230
1231         if (!W_ERROR_IS_OK(out.status))
1232                 return out.status;
1233
1234         if (value) {
1235                 rpcstr_pull(value->valuename, out.value, sizeof(value->valuename), -1,
1236                             STR_TERMINATE);
1237                 if (out.realdatasize) {
1238                         value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data,
1239                                                        out.realdatasize);
1240                 } else {
1241                         value->data_p = NULL;
1242                 }
1243                 value->type = out.type;
1244                 value->size = out.realdatasize;
1245         }
1246
1247         return out.status;
1248 }
1249
1250 /**********************************************************************
1251 **********************************************************************/
1252
1253 WERROR rpccli_spoolss_enumprinterdataex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1254                                      POLICY_HND *hnd, const char *keyname,
1255                                      REGVAL_CTR *ctr)
1256 {
1257         prs_struct qbuf, rbuf;
1258         SPOOL_Q_ENUMPRINTERDATAEX in;
1259         SPOOL_R_ENUMPRINTERDATAEX out;
1260         int i;
1261         uint32 offered;
1262
1263         ZERO_STRUCT(in);
1264         ZERO_STRUCT(out);
1265
1266         offered = 0;
1267         make_spoolss_q_enumprinterdataex( &in, hnd, keyname, offered );
1268
1269         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERDATAEX,
1270                     in, out,
1271                     qbuf, rbuf,
1272                     spoolss_io_q_enumprinterdataex,
1273                     spoolss_io_r_enumprinterdataex,
1274                     WERR_GENERAL_FAILURE );
1275
1276         if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1277                 offered = out.needed;
1278
1279                 ZERO_STRUCT(in);
1280                 ZERO_STRUCT(out);
1281
1282                 make_spoolss_q_enumprinterdataex( &in, hnd, keyname, offered );
1283
1284                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERDATAEX,
1285                             in, out,
1286                             qbuf, rbuf,
1287                             spoolss_io_q_enumprinterdataex,
1288                             spoolss_io_r_enumprinterdataex,
1289                             WERR_GENERAL_FAILURE );
1290         }
1291
1292         if (!W_ERROR_IS_OK(out.status))
1293                 return out.status;
1294
1295         for (i = 0; i < out.returned; i++) {
1296                 PRINTER_ENUM_VALUES *v = &out.ctr.values[i];
1297                 fstring name;
1298
1299                 rpcstr_pull(name, v->valuename.buffer, sizeof(name), -1,
1300                             STR_TERMINATE);
1301                 regval_ctr_addvalue(ctr, name, v->type, (const char *)v->data, v->data_len);
1302         }
1303
1304         return out.status;
1305 }
1306
1307 /**********************************************************************
1308 **********************************************************************/
1309
1310 WERROR rpccli_spoolss_enumprinterkey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1311                                   POLICY_HND *hnd, const char *keyname,
1312                                   uint16 **keylist, uint32 *len)
1313 {
1314         prs_struct qbuf, rbuf;
1315         SPOOL_Q_ENUMPRINTERKEY in;
1316         SPOOL_R_ENUMPRINTERKEY out;
1317         uint32 offered = 0;
1318
1319         ZERO_STRUCT(in);
1320         ZERO_STRUCT(out);
1321
1322         make_spoolss_q_enumprinterkey( &in, hnd, keyname, offered );
1323
1324         CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERKEY,
1325                     in, out,
1326                     qbuf, rbuf,
1327                     spoolss_io_q_enumprinterkey,
1328                     spoolss_io_r_enumprinterkey,
1329                     WERR_GENERAL_FAILURE );
1330
1331         if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1332                 offered = out.needed;
1333
1334                 ZERO_STRUCT(in);
1335                 ZERO_STRUCT(out);
1336
1337                 make_spoolss_q_enumprinterkey( &in, hnd, keyname, offered );
1338
1339                 CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERKEY,
1340                             in, out,
1341                             qbuf, rbuf,
1342                             spoolss_io_q_enumprinterkey,
1343                             spoolss_io_r_enumprinterkey,
1344                             WERR_GENERAL_FAILURE );
1345         }
1346
1347         if ( !W_ERROR_IS_OK(out.status) )
1348                 return out.status;
1349
1350         if (keylist) {
1351                 *keylist = SMB_MALLOC_ARRAY(uint16, out.keys.buf_len);
1352                 if (!*keylist) {
1353                         return WERR_NOMEM;
1354                 }
1355                 memcpy(*keylist, out.keys.buffer, out.keys.buf_len * 2);
1356                 if (len)
1357                         *len = out.keys.buf_len * 2;
1358         }
1359
1360         return out.status;
1361 }
1362
1363 /** @} **/