source3/rpc_client/cli_spoolss.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    RPC pipe client
   4
   5    Copyright (C) Gerald Carter                2001-2002,
   6    Copyright (C) Tim Potter                   2000-2002,
   7    Copyright (C) Andrew Tridgell              1994-2000,
   8    Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
   9    Copyright (C) Jean-Francois Micouleau      1999-2000.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 2 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program; if not, write to the Free Software
  23    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24 */
  25
  26 #include "includes.h"
  27
  28 /** @defgroup spoolss SPOOLSS - NT printing routines
  29  *  @ingroup rpc_client
  30  *
  31  * @{
  32  **/
  33
  34 /**********************************************************************
  35  Initialize a new spoolss buff for use by a client rpc
  36 **********************************************************************/
  37 static void init_buffer(NEW_BUFFER *buffer, uint32 size, TALLOC_CTX *ctx)
  38 {
  39         buffer->ptr = (size != 0);
  40         buffer->size = size;
  41         buffer->string_at_end = size;
  42         prs_init(&buffer->prs, size, ctx, MARSHALL);
  43         buffer->struct_start = prs_offset(&buffer->prs);
  44 }
  45
  46 /*********************************************************************
  47  Decode various spoolss rpc's and info levels
  48  ********************************************************************/
  49
  50 /**********************************************************************
  51 **********************************************************************/
  52 static void decode_printer_info_0(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
  53                                 uint32 returned, PRINTER_INFO_0 **info)
  54 {
  55         uint32 i;
  56         PRINTER_INFO_0  *inf;
  57
  58         inf=(PRINTER_INFO_0 *)talloc(mem_ctx, returned*sizeof(PRINTER_INFO_0));
  59
  60         buffer->prs.data_offset=0;
  61
  62         for (i=0; i<returned; i++) {
  63                 smb_io_printer_info_0("", buffer, &inf[i], 0);
  64         }
  65
  66         *info=inf;
  67 }
  68
  69 /**********************************************************************
  70 **********************************************************************/
  71 static void decode_printer_info_1(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
  72                                 uint32 returned, PRINTER_INFO_1 **info)
  73 {
  74         uint32 i;
  75         PRINTER_INFO_1  *inf;
  76
  77         inf=(PRINTER_INFO_1 *)talloc(mem_ctx, returned*sizeof(PRINTER_INFO_1));
  78
  79         buffer->prs.data_offset=0;
  80
  81         for (i=0; i<returned; i++) {
  82                 smb_io_printer_info_1("", buffer, &inf[i], 0);
  83         }
  84
  85         *info=inf;
  86 }
  87
  88 /**********************************************************************
  89 **********************************************************************/
  90 static void decode_printer_info_2(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
  91                                 uint32 returned, PRINTER_INFO_2 **info)
  92 {
  93         uint32 i;
  94         PRINTER_INFO_2  *inf;
  95
  96         inf=(PRINTER_INFO_2 *)talloc(mem_ctx, returned*sizeof(PRINTER_INFO_2));
  97
  98         buffer->prs.data_offset=0;
  99
 100         for (i=0; i<returned; i++) {
 101                 /* a little initialization as we go */
 102                 inf[i].secdesc = NULL;
 103                 smb_io_printer_info_2("", buffer, &inf[i], 0);
 104         }
 105
 106         *info=inf;
 107 }
 108
 109 /**********************************************************************
 110 **********************************************************************/
 111 static void decode_printer_info_3(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
 112                                 uint32 returned, PRINTER_INFO_3 **info)
 113 {
 114         uint32 i;
 115         PRINTER_INFO_3  *inf;
 116
 117         inf=(PRINTER_INFO_3 *)talloc(mem_ctx, returned*sizeof(PRINTER_INFO_3));
 118
 119         buffer->prs.data_offset=0;
 120
 121         for (i=0; i<returned; i++) {
 122                 inf[i].secdesc = NULL;
 123                 smb_io_printer_info_3("", buffer, &inf[i], 0);
 124         }
 125
 126         *info=inf;
 127 }
 128
 129 /**********************************************************************
 130 **********************************************************************/
 131 static void decode_port_info_1(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
 132                         uint32 returned, PORT_INFO_1 **info)
 133 {
 134         uint32 i;
 135         PORT_INFO_1 *inf;
 136
 137         inf=(PORT_INFO_1*)talloc(mem_ctx, returned*sizeof(PORT_INFO_1));
 138
 139         prs_set_offset(&buffer->prs, 0);
 140
 141         for (i=0; i<returned; i++) {
 142                 smb_io_port_info_1("", buffer, &(inf[i]), 0);
 143         }
 144
 145         *info=inf;
 146 }
 147
 148 /**********************************************************************
 149 **********************************************************************/
 150 static void decode_port_info_2(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
 151                         uint32 returned, PORT_INFO_2 **info)
 152 {
 153         uint32 i;
 154         PORT_INFO_2 *inf;
 155
 156         inf=(PORT_INFO_2*)talloc(mem_ctx, returned*sizeof(PORT_INFO_2));
 157
 158         prs_set_offset(&buffer->prs, 0);
 159
 160         for (i=0; i<returned; i++) {
 161                 smb_io_port_info_2("", buffer, &(inf[i]), 0);
 162         }
 163
 164         *info=inf;
 165 }
 166
 167 /**********************************************************************
 168 **********************************************************************/
 169 static void decode_printer_driver_1(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
 170                         uint32 returned, DRIVER_INFO_1 **info)
 171 {
 172         uint32 i;
 173         DRIVER_INFO_1 *inf;
 174
 175         inf=(DRIVER_INFO_1 *)talloc(mem_ctx, returned*sizeof(DRIVER_INFO_1));
 176
 177         buffer->prs.data_offset=0;
 178
 179         for (i=0; i<returned; i++) {
 180                 smb_io_printer_driver_info_1("", buffer, &(inf[i]), 0);
 181         }
 182
 183         *info=inf;
 184 }
 185
 186 /**********************************************************************
 187 **********************************************************************/
 188 static void decode_printer_driver_2(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
 189                         uint32 returned, DRIVER_INFO_2 **info)
 190 {
 191         uint32 i;
 192         DRIVER_INFO_2 *inf;
 193
 194         inf=(DRIVER_INFO_2 *)talloc(mem_ctx, returned*sizeof(DRIVER_INFO_2));
 195
 196         buffer->prs.data_offset=0;
 197
 198         for (i=0; i<returned; i++) {
 199                 smb_io_printer_driver_info_2("", buffer, &(inf[i]), 0);
 200         }
 201
 202         *info=inf;
 203 }
 204
 205 /**********************************************************************
 206 **********************************************************************/
 207 static void decode_printer_driver_3(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
 208                         uint32 returned, DRIVER_INFO_3 **info)
 209 {
 210         uint32 i;
 211         DRIVER_INFO_3 *inf;
 212
 213         inf=(DRIVER_INFO_3 *)talloc(mem_ctx, returned*sizeof(DRIVER_INFO_3));
 214
 215         buffer->prs.data_offset=0;
 216
 217         for (i=0; i<returned; i++) {
 218                 smb_io_printer_driver_info_3("", buffer, &(inf[i]), 0);
 219         }
 220
 221         *info=inf;
 222 }
 223
 224 /**********************************************************************
 225 **********************************************************************/
 226 static void decode_printerdriverdir_1 (TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
 227                         uint32 returned, DRIVER_DIRECTORY_1 **info
 228 )
 229 {
 230         DRIVER_DIRECTORY_1 *inf;
 231
 232         inf=(DRIVER_DIRECTORY_1 *)talloc(mem_ctx, sizeof(DRIVER_DIRECTORY_1));
 233
 234         prs_set_offset(&buffer->prs, 0);
 235
 236         smb_io_driverdir_1("", buffer, inf, 0);
 237
 238         *info=inf;
 239 }
 240
 241 /** Return a handle to the specified printer or print server.
 242  *
 243  * @param cli              Pointer to client state structure which is open
 244  * on the SPOOLSS pipe.
 245  *
 246  * @param mem_ctx          Pointer to an initialised talloc context.
 247  *
 248  * @param printername      The name of the printer or print server to be
 249  * opened in UNC format.
 250  *
 251  * @param datatype         Specifies the default data type for the printer.
 252  *
 253  * @param access_required  The access rights requested on the printer or
 254  * print server.
 255  *
 256  * @param station          The UNC name of the requesting workstation.
 257  *
 258  * @param username         The name of the user requesting the open.
 259  *
 260  * @param pol              Returned policy handle.
 261  */
 262
 263 /*********************************************************************************
 264  Win32 API - OpenPrinter()
 265  ********************************************************************************/
 266
 267 WERROR cli_spoolss_open_printer_ex(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 268                                 char *printername, char *datatype, uint32 access_required,
 269                                 char *station, char *username, POLICY_HND *pol)
 270 {
 271         prs_struct qbuf, rbuf;
 272         SPOOL_Q_OPEN_PRINTER_EX q;
 273         SPOOL_R_OPEN_PRINTER_EX r;
 274         WERROR result = W_ERROR(ERRgeneral);
 275
 276         ZERO_STRUCT(q);
 277         ZERO_STRUCT(r);
 278
 279         /* Initialise parse structures */
 280
 281         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 282         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 283
 284         /* Initialise input parameters */
 285
 286         make_spoolss_q_open_printer_ex(&q, printername, datatype,
 287                                        access_required, station, username);
 288
 289         /* Marshall data and send request */
 290
 291         if (!spoolss_io_q_open_printer_ex("", &q, &qbuf, 0) ||
 292             !rpc_api_pipe_req(cli, SPOOLSS_OPENPRINTEREX, &qbuf, &rbuf))
 293                 goto done;
 294
 295         /* Unmarshall response */
 296
 297         if (!spoolss_io_r_open_printer_ex("", &r, &rbuf, 0))
 298                 goto done;
 299
 300         /* Return output parameters */
 301
 302         result = r.status;
 303
 304         if (W_ERROR_IS_OK(result))
 305                 *pol = r.handle;
 306
 307  done:
 308         prs_mem_free(&qbuf);
 309         prs_mem_free(&rbuf);
 310
 311         return result;
 312 }
 313
 314 /** Close a printer handle
 315  *
 316  * @param cli              Pointer to client state structure which is open
 317  * on the SPOOLSS pipe.
 318  *
 319  * @param mem_ctx          Pointer to an initialised talloc context.
 320  *
 321  * @param pol              Policy handle of printer or print server to close.
 322  */
 323 /*********************************************************************************
 324  Win32 API - ClosePrinter()
 325  ********************************************************************************/
 326
 327 WERROR cli_spoolss_close_printer(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 328                                  POLICY_HND *pol)
 329 {
 330         prs_struct qbuf, rbuf;
 331         SPOOL_Q_CLOSEPRINTER q;
 332         SPOOL_R_CLOSEPRINTER r;
 333         WERROR result = W_ERROR(ERRgeneral);
 334
 335         ZERO_STRUCT(q);
 336         ZERO_STRUCT(r);
 337
 338         /* Initialise parse structures */
 339
 340         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 341         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 342
 343         /* Initialise input parameters */
 344
 345         make_spoolss_q_closeprinter(&q, pol);
 346
 347         /* Marshall data and send request */
 348
 349         if (!spoolss_io_q_closeprinter("", &q, &qbuf, 0) ||
 350             !rpc_api_pipe_req(cli, SPOOLSS_CLOSEPRINTER, &qbuf, &rbuf))
 351                 goto done;
 352
 353         /* Unmarshall response */
 354
 355         if (!spoolss_io_r_closeprinter("", &r, &rbuf, 0))
 356                 goto done;
 357
 358         /* Return output parameters */
 359
 360         result = r.status;
 361
 362         if (W_ERROR_IS_OK(result))
 363                 *pol = r.handle;
 364
 365  done:
 366         prs_mem_free(&qbuf);
 367         prs_mem_free(&rbuf);
 368
 369         return result;
 370 }
 371
 372 /** Enumerate printers on a print server.
 373  *
 374  * @param cli              Pointer to client state structure which is open
 375  *                         on the SPOOLSS pipe.
 376  * @param mem_ctx          Pointer to an initialised talloc context.
 377  *
 378  * @param offered          Buffer size offered in the request.
 379  * @param needed           Number of bytes needed to complete the request.
 380  *                         may be NULL.
 381  *
 382  * @param flags            Selected from PRINTER_ENUM_* flags.
 383  * @param level            Request information level.
 384  *
 385  * @param num_printers     Pointer to number of printers returned.  May be
 386  *                         NULL.
 387  * @param ctr              Return structure for printer information.  May
 388  *                         be NULL.
 389  */
 390 /*********************************************************************************
 391  Win32 API - EnumPrinters()
 392  ********************************************************************************/
 393
 394 WERROR cli_spoolss_enum_printers(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 395                                  uint32 offered, uint32 *needed,
 396                                  uint32 flags, uint32 level,
 397                                  uint32 *num_printers, PRINTER_INFO_CTR *ctr)
 398 {
 399         prs_struct qbuf, rbuf;
 400         SPOOL_Q_ENUMPRINTERS q;
 401         SPOOL_R_ENUMPRINTERS r;
 402         NEW_BUFFER buffer;
 403         WERROR result = W_ERROR(ERRgeneral);
 404         fstring server;
 405
 406         ZERO_STRUCT(q);
 407         ZERO_STRUCT(r);
 408
 409         slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 410         strupper (server);
 411
 412         /* Initialise input parameters */
 413
 414         init_buffer(&buffer, offered, mem_ctx);
 415
 416         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 417         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 418
 419         make_spoolss_q_enumprinters(&q, flags, server, level, &buffer,
 420                                     offered);
 421
 422         /* Marshall data and send request */
 423
 424         if (!spoolss_io_q_enumprinters("", &q, &qbuf, 0) ||
 425             !rpc_api_pipe_req(cli, SPOOLSS_ENUMPRINTERS, &qbuf, &rbuf))
 426                 goto done;
 427
 428         /* Unmarshall response */
 429
 430         if (spoolss_io_r_enumprinters("", &r, &rbuf, 0)) {
 431                 if (needed)
 432                         *needed = r.needed;
 433         }
 434
 435         result = r.status;
 436
 437         /* Return output parameters */
 438
 439         if (!W_ERROR_IS_OK(r.status))
 440                 goto done;
 441
 442         if (num_printers)
 443                 *num_printers = r.returned;
 444
 445         if (!ctr)
 446                 goto done;
 447
 448         switch (level) {
 449         case 0:
 450                 decode_printer_info_0(mem_ctx, r.buffer, r.returned,
 451                                       &ctr->printers_0);
 452                 break;
 453         case 1:
 454                 decode_printer_info_1(mem_ctx, r.buffer, r.returned,
 455                                       &ctr->printers_1);
 456                 break;
 457         case 2:
 458                 decode_printer_info_2(mem_ctx, r.buffer, r.returned,
 459                                       &ctr->printers_2);
 460                 break;
 461         case 3:
 462                 decode_printer_info_3(mem_ctx, r.buffer, r.returned,
 463                                       &ctr->printers_3);
 464                 break;
 465         }
 466
 467  done:
 468         prs_mem_free(&qbuf);
 469         prs_mem_free(&rbuf);
 470
 471         return result;
 472 }
 473
 474 /*********************************************************************************
 475  Win32 API - EnumPorts()
 476  ********************************************************************************/
 477 /** Enumerate printer ports on a print server.
 478  *
 479  * @param cli              Pointer to client state structure which is open
 480  *                         on the SPOOLSS pipe.
 481  * @param mem_ctx          Pointer to an initialised talloc context.
 482  *
 483  * @param offered          Buffer size offered in the request.
 484  * @param needed           Number of bytes needed to complete the request.
 485  *                         May be NULL.
 486  *
 487  * @param level            Requested information level.
 488  *
 489  * @param num_ports        Pointer to number of ports returned.  May be NULL.
 490  * @param ctr              Pointer to structure holding port information.
 491  *                         May be NULL.
 492  */
 493
 494 WERROR cli_spoolss_enum_ports(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 495                               uint32 offered, uint32 *needed,
 496                               uint32 level, int *num_ports, PORT_INFO_CTR *ctr)
 497 {
 498         prs_struct qbuf, rbuf;
 499         SPOOL_Q_ENUMPORTS q;
 500         SPOOL_R_ENUMPORTS r;
 501         NEW_BUFFER buffer;
 502         WERROR result = W_ERROR(ERRgeneral);
 503         fstring server;
 504
 505         ZERO_STRUCT(q);
 506         ZERO_STRUCT(r);
 507
 508         slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 509         strupper (server);
 510
 511         /* Initialise input parameters */
 512
 513         init_buffer(&buffer, offered, mem_ctx);
 514
 515         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 516         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 517
 518         make_spoolss_q_enumports(&q, server, level, &buffer, offered);
 519
 520         /* Marshall data and send request */
 521
 522         if (!spoolss_io_q_enumports("", &q, &qbuf, 0) ||
 523             !rpc_api_pipe_req(cli, SPOOLSS_ENUMPORTS, &qbuf, &rbuf))
 524                 goto done;
 525
 526         /* Unmarshall response */
 527
 528         if (spoolss_io_r_enumports("", &r, &rbuf, 0)) {
 529                 if (needed)
 530                         *needed = r.needed;
 531         }
 532
 533         result = r.status;
 534
 535         /* Return output parameters */
 536
 537         if (!W_ERROR_IS_OK(result))
 538                 goto done;
 539
 540         if (num_ports)
 541                 *num_ports = r.returned;
 542
 543         if (!ctr)
 544                 goto done;
 545
 546         switch (level) {
 547         case 1:
 548                 decode_port_info_1(mem_ctx, r.buffer, r.returned,
 549                                    &ctr->port.info_1);
 550                 break;
 551         case 2:
 552                 decode_port_info_2(mem_ctx, r.buffer, r.returned,
 553                                    &ctr->port.info_2);
 554                 break;
 555         }
 556
 557  done:
 558         prs_mem_free(&qbuf);
 559         prs_mem_free(&rbuf);
 560
 561         return result;
 562 }
 563
 564 /*********************************************************************************
 565  Win32 API - GetPrinter()
 566  ********************************************************************************/
 567
 568 WERROR cli_spoolss_getprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 569                               uint32 offered, uint32 *needed,
 570                               POLICY_HND *pol, uint32 level,
 571                               PRINTER_INFO_CTR *ctr)
 572 {
 573         prs_struct qbuf, rbuf;
 574         SPOOL_Q_GETPRINTER q;
 575         SPOOL_R_GETPRINTER r;
 576         NEW_BUFFER buffer;
 577         WERROR result = W_ERROR(ERRgeneral);
 578
 579         ZERO_STRUCT(q);
 580         ZERO_STRUCT(r);
 581
 582         /* Initialise input parameters */
 583
 584         init_buffer(&buffer, offered, mem_ctx);
 585
 586         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 587         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 588
 589         make_spoolss_q_getprinter(mem_ctx, &q, pol, level, &buffer, offered);
 590
 591         /* Marshall data and send request */
 592
 593         if (!spoolss_io_q_getprinter("", &q, &qbuf, 0) ||
 594             !rpc_api_pipe_req(cli, SPOOLSS_GETPRINTER, &qbuf, &rbuf))
 595                 goto done;
 596
 597         /* Unmarshall response */
 598
 599         if (!spoolss_io_r_getprinter("", &r, &rbuf, 0))
 600                 goto done;
 601
 602         if (needed)
 603                 *needed = r.needed;
 604
 605         /* Return output parameters */
 606
 607         result = r.status;
 608
 609         if (W_ERROR_IS_OK(result)) {
 610                 switch (level) {
 611                 case 0:
 612                         decode_printer_info_0(mem_ctx, r.buffer, 1, &ctr->printers_0);
 613                         break;
 614                 case 1:
 615                         decode_printer_info_1(mem_ctx, r.buffer, 1, &ctr->printers_1);
 616                         break;
 617                 case 2:
 618                         decode_printer_info_2(mem_ctx, r.buffer, 1, &ctr->printers_2);
 619                         break;
 620                 case 3:
 621                         decode_printer_info_3(mem_ctx, r.buffer, 1, &ctr->printers_3);
 622                         break;
 623                 }
 624         }
 625
 626  done:
 627         prs_mem_free(&qbuf);
 628         prs_mem_free(&rbuf);
 629
 630         return result;
 631 }
 632
 633 /*********************************************************************************
 634  Win32 API - SetPrinter()
 635  ********************************************************************************/
 636 /** Set printer info
 637  *
 638  * @param cli              Pointer to client state structure which is open
 639  *                         on the SPOOLSS pipe.
 640  * @param mem_ctx          Pointer to an initialised talloc context.
 641  *
 642  * @param pol              Policy handle on printer to set info.
 643  * @param level            Information level to set.
 644  * @param ctr              Pointer to structure holding printer information.
 645  * @param command          Specifies the action performed.  See
 646  * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/gdi/prntspol_13ua.asp
 647  * for details.
 648  *
 649  */
 650
 651 WERROR cli_spoolss_setprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 652                               POLICY_HND *pol, uint32 level,
 653                               PRINTER_INFO_CTR *ctr, uint32 command)
 654 {
 655         prs_struct qbuf, rbuf;
 656         SPOOL_Q_SETPRINTER q;
 657         SPOOL_R_SETPRINTER r;
 658         WERROR result = W_ERROR(ERRgeneral);
 659
 660         ZERO_STRUCT(q);
 661         ZERO_STRUCT(r);
 662
 663         /* Initialise input parameters */
 664
 665         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 666         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 667
 668         make_spoolss_q_setprinter(mem_ctx, &q, pol, level, ctr, command);
 669
 670         /* Marshall data and send request */
 671
 672         if (!spoolss_io_q_setprinter("", &q, &qbuf, 0) ||
 673             !rpc_api_pipe_req(cli, SPOOLSS_SETPRINTER, &qbuf, &rbuf))
 674                 goto done;
 675
 676         /* Unmarshall response */
 677
 678         if (!spoolss_io_r_setprinter("", &r, &rbuf, 0))
 679                 goto done;
 680
 681         result = r.status;
 682
 683 done:
 684         prs_mem_free(&qbuf);
 685         prs_mem_free(&rbuf);
 686
 687         return result;
 688 }
 689
 690 /*********************************************************************************
 691  Win32 API - GetPrinterDriver()
 692  ********************************************************************************/
 693 /** Get installed printer drivers for a given printer
 694  *
 695  * @param cli              Pointer to client state structure which is open
 696  * on the SPOOLSS pipe.
 697  *
 698  * @param mem_ctx          Pointer to an initialised talloc context.
 699  *
 700  * @param offered          Buffer size offered in the request.
 701  * @param needed           Number of bytes needed to complete the request.
 702  *                         may be NULL.
 703  *
 704  * @param pol              Pointer to an open policy handle for the printer
 705  *                         opened with cli_spoolss_open_printer_ex().
 706  * @param level            Requested information level.
 707  * @param env              The print environment or archictecture.  This is
 708  *                         "Windows NT x86" for NT4.
 709  * @param ctr              Returned printer driver information.
 710  */
 711
 712 WERROR cli_spoolss_getprinterdriver(struct cli_state *cli,
 713                                     TALLOC_CTX *mem_ctx,
 714                                     uint32 offered, uint32 *needed,
 715                                     POLICY_HND *pol, uint32 level,
 716                                     char *env, PRINTER_DRIVER_CTR *ctr)
 717 {
 718         prs_struct qbuf, rbuf;
 719         SPOOL_Q_GETPRINTERDRIVER2 q;
 720         SPOOL_R_GETPRINTERDRIVER2 r;
 721         NEW_BUFFER buffer;
 722         WERROR result = W_ERROR(ERRgeneral);
 723         fstring server;
 724
 725         ZERO_STRUCT(q);
 726         ZERO_STRUCT(r);
 727
 728         fstrcpy (server, cli->desthost);
 729         strupper (server);
 730
 731         /* Initialise input parameters */
 732
 733         init_buffer(&buffer, offered, mem_ctx);
 734
 735         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 736         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 737
 738         make_spoolss_q_getprinterdriver2(&q, pol, env, level, 2, 2,
 739                                          &buffer, offered);
 740
 741         /* Marshall data and send request */
 742
 743         if (!spoolss_io_q_getprinterdriver2 ("", &q, &qbuf, 0) ||
 744             !rpc_api_pipe_req (cli, SPOOLSS_GETPRINTERDRIVER2, &qbuf, &rbuf))
 745                 goto done;
 746
 747         /* Unmarshall response */
 748
 749         if (spoolss_io_r_getprinterdriver2 ("", &r, &rbuf, 0)) {
 750                 if (needed)
 751                         *needed = r.needed;
 752         }
 753
 754         result = r.status;
 755
 756         /* Return output parameters */
 757
 758         if (!W_ERROR_IS_OK(result))
 759                 goto done;
 760
 761         if (!ctr)
 762                 goto done;
 763
 764         switch (level) {
 765         case 1:
 766                 decode_printer_driver_1(mem_ctx, r.buffer, 1, &ctr->info1);
 767                 break;
 768         case 2:
 769                 decode_printer_driver_2(mem_ctx, r.buffer, 1, &ctr->info2);
 770                 break;
 771         case 3:
 772                 decode_printer_driver_3(mem_ctx, r.buffer, 1, &ctr->info3);
 773                 break;
 774         }
 775
 776  done:
 777         prs_mem_free(&qbuf);
 778         prs_mem_free(&rbuf);
 779
 780         return result;
 781 }
 782
 783 /*********************************************************************************
 784  Win32 API - EnumPrinterDrivers()
 785  ********************************************************************************/
 786 /**********************************************************************
 787  * Get installed printer drivers for a given printer
 788  */
 789 WERROR cli_spoolss_enumprinterdrivers (struct cli_state *cli,
 790                                        TALLOC_CTX *mem_ctx,
 791                                        uint32 offered, uint32 *needed,
 792                                        uint32 level, char *env,
 793                                        uint32 *num_drivers,
 794                                        PRINTER_DRIVER_CTR *ctr)
 795 {
 796         prs_struct qbuf, rbuf;
 797         SPOOL_Q_ENUMPRINTERDRIVERS q;
 798         SPOOL_R_ENUMPRINTERDRIVERS r;
 799         NEW_BUFFER buffer;
 800         WERROR result = W_ERROR(ERRgeneral);
 801         fstring server;
 802
 803         ZERO_STRUCT(q);
 804         ZERO_STRUCT(r);
 805
 806         slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 807         strupper (server);
 808
 809         /* Initialise input parameters */
 810
 811         init_buffer(&buffer, offered, mem_ctx);
 812
 813         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 814         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 815
 816         /* Write the request */
 817
 818         make_spoolss_q_enumprinterdrivers(&q, server, env, level, &buffer,
 819                                           offered);
 820
 821         /* Marshall data and send request */
 822
 823         if (!spoolss_io_q_enumprinterdrivers ("", &q, &qbuf, 0) ||
 824             !rpc_api_pipe_req (cli, SPOOLSS_ENUMPRINTERDRIVERS, &qbuf, &rbuf))
 825                 goto done;
 826
 827         /* Unmarshall response */
 828
 829         if (!spoolss_io_r_enumprinterdrivers ("", &r, &rbuf, 0))
 830                 goto done;
 831
 832         if (needed)
 833                 *needed = r.needed;
 834
 835         if (num_drivers)
 836                 *num_drivers = r.returned;
 837
 838         result = r.status;
 839
 840         /* Return output parameters */
 841
 842         if (W_ERROR_IS_OK(result) && (r.returned != 0)) {
 843                 *num_drivers = r.returned;
 844
 845                 switch (level) {
 846                 case 1:
 847                         decode_printer_driver_1(mem_ctx, r.buffer, r.returned, &ctr->info1);
 848                         break;
 849                 case 2:
 850                         decode_printer_driver_2(mem_ctx, r.buffer, r.returned, &ctr->info2);
 851                         break;
 852                 case 3:
 853                         decode_printer_driver_3(mem_ctx, r.buffer, r.returned, &ctr->info3);
 854                         break;
 855                 }
 856         }
 857
 858  done:
 859         prs_mem_free(&qbuf);
 860         prs_mem_free(&rbuf);
 861
 862         return result;
 863 }
 864
 865
 866 /*********************************************************************************
 867  Win32 API - GetPrinterDriverDirectory()
 868  ********************************************************************************/
 869 /**********************************************************************
 870  * Get installed printer drivers for a given printer
 871  */
 872 WERROR cli_spoolss_getprinterdriverdir (struct cli_state *cli,
 873                                         TALLOC_CTX *mem_ctx,
 874                                         uint32 offered, uint32 *needed,
 875                                         uint32 level, char *env,
 876                                         DRIVER_DIRECTORY_CTR *ctr)
 877 {
 878         prs_struct                      qbuf, rbuf;
 879         SPOOL_Q_GETPRINTERDRIVERDIR     q;
 880         SPOOL_R_GETPRINTERDRIVERDIR     r;
 881         NEW_BUFFER                      buffer;
 882         WERROR result = W_ERROR(ERRgeneral);
 883         fstring                         server;
 884
 885         ZERO_STRUCT(q);
 886         ZERO_STRUCT(r);
 887
 888         slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 889         strupper (server);
 890
 891         /* Initialise input parameters */
 892
 893         init_buffer(&buffer, offered, mem_ctx);
 894
 895         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 896         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 897
 898         /* Write the request */
 899
 900         make_spoolss_q_getprinterdriverdir(&q, server, env, level, &buffer,
 901                                            offered);
 902
 903         /* Marshall data and send request */
 904
 905         if (!spoolss_io_q_getprinterdriverdir ("", &q, &qbuf, 0) ||
 906             !rpc_api_pipe_req (cli, SPOOLSS_GETPRINTERDRIVERDIRECTORY,
 907                                &qbuf, &rbuf))
 908                 goto done;
 909
 910         /* Unmarshall response */
 911
 912         if (spoolss_io_r_getprinterdriverdir ("", &r, &rbuf, 0)) {
 913                 if (needed)
 914                         *needed = r.needed;
 915         }
 916
 917         /* Return output parameters */
 918
 919         result = r.status;
 920
 921         if (W_ERROR_IS_OK(result)) {
 922                 switch (level) {
 923                 case 1:
 924                         decode_printerdriverdir_1(mem_ctx, r.buffer, 1,
 925                                                   &ctr->info1);
 926                         break;
 927                 }
 928         }
 929
 930         done:
 931                 prs_mem_free(&qbuf);
 932                 prs_mem_free(&rbuf);
 933
 934         return result;
 935 }
 936
 937 /*********************************************************************************
 938  Win32 API - AddPrinterDriver()
 939  ********************************************************************************/
 940 /**********************************************************************
 941  * Install a printer driver
 942  */
 943 WERROR cli_spoolss_addprinterdriver (struct cli_state *cli,
 944                                      TALLOC_CTX *mem_ctx, uint32 level,
 945                                      PRINTER_DRIVER_CTR *ctr)
 946 {
 947         prs_struct                      qbuf, rbuf;
 948         SPOOL_Q_ADDPRINTERDRIVER        q;
 949         SPOOL_R_ADDPRINTERDRIVER        r;
 950         WERROR result = W_ERROR(ERRgeneral);
 951         fstring                         server;
 952
 953         ZERO_STRUCT(q);
 954         ZERO_STRUCT(r);
 955
 956         slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 957         strupper (server);
 958
 959         /* Initialise input parameters */
 960
 961         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 962         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 963
 964         /* Write the request */
 965
 966         make_spoolss_q_addprinterdriver (mem_ctx, &q, server, level, ctr);
 967
 968         /* Marshall data and send request */
 969
 970         if (!spoolss_io_q_addprinterdriver ("", &q, &qbuf, 0) ||
 971             !rpc_api_pipe_req (cli, SPOOLSS_ADDPRINTERDRIVER, &qbuf, &rbuf))
 972                 goto done;
 973
 974         /* Unmarshall response */
 975
 976         if (!spoolss_io_r_addprinterdriver ("", &r, &rbuf, 0))
 977                 goto done;
 978
 979         /* Return output parameters */
 980
 981         result = r.status;
 982
 983 done:
 984         prs_mem_free(&qbuf);
 985         prs_mem_free(&rbuf);
 986
 987         return result;
 988 }
 989
 990 /*********************************************************************************
 991  Win32 API - AddPrinter()
 992  ********************************************************************************/
 993 /**********************************************************************
 994  * Install a printer
 995  */
 996 WERROR cli_spoolss_addprinterex (struct cli_state *cli, TALLOC_CTX *mem_ctx,
 997                                  uint32 level, PRINTER_INFO_CTR*ctr)
 998 {
 999         prs_struct                      qbuf, rbuf;
1000         SPOOL_Q_ADDPRINTEREX            q;
1001         SPOOL_R_ADDPRINTEREX            r;
1002         WERROR result = W_ERROR(ERRgeneral);
1003         fstring                         server,
1004                                         client,
1005                                         user;
1006
1007         ZERO_STRUCT(q);
1008         ZERO_STRUCT(r);
1009
1010         slprintf (client, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1011         strupper (client);
1012         slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1013         strupper (server);
1014         fstrcpy  (user, cli->user_name);
1015
1016         /* Initialise input parameters */
1017
1018         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1019         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1020
1021         /* Write the request */
1022
1023         make_spoolss_q_addprinterex (mem_ctx, &q, server, client, user,
1024                                      level, ctr);
1025
1026         /* Marshall data and send request */
1027
1028         if (!spoolss_io_q_addprinterex ("", &q, &qbuf, 0) ||
1029             !rpc_api_pipe_req (cli, SPOOLSS_ADDPRINTEREX, &qbuf, &rbuf))
1030                 goto done;
1031
1032         /* Unmarshall response */
1033
1034         if (!spoolss_io_r_addprinterex ("", &r, &rbuf, 0))
1035                 goto done;
1036
1037         /* Return output parameters */
1038
1039         result = r.status;
1040
1041  done:
1042         prs_mem_free(&qbuf);
1043         prs_mem_free(&rbuf);
1044
1045         return result;
1046 }
1047
1048 /*********************************************************************************
1049  Win32 API - DeltePrinterDriver()
1050  ********************************************************************************/
1051 /**********************************************************************
1052  * Delete a Printer Driver from the server (does not remove
1053  * the driver files
1054  */
1055 WERROR cli_spoolss_deleteprinterdriver (struct cli_state *cli,
1056                                         TALLOC_CTX *mem_ctx, char *arch,
1057                                         char *driver)
1058 {
1059         prs_struct                      qbuf, rbuf;
1060         SPOOL_Q_DELETEPRINTERDRIVER     q;
1061         SPOOL_R_DELETEPRINTERDRIVER     r;
1062         WERROR result = W_ERROR(ERRgeneral);
1063         fstring                         server;
1064
1065         ZERO_STRUCT(q);
1066         ZERO_STRUCT(r);
1067
1068
1069         /* Initialise input parameters */
1070         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1071         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1072
1073         slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1074         strupper (server);
1075
1076         /* Write the request */
1077
1078         make_spoolss_q_deleteprinterdriver(mem_ctx, &q, server, arch, driver);
1079
1080         /* Marshall data and send request */
1081
1082         if (!spoolss_io_q_deleteprinterdriver ("", &q, &qbuf, 0) ||
1083             !rpc_api_pipe_req (cli,SPOOLSS_DELETEPRINTERDRIVER , &qbuf, &rbuf))
1084                 goto done;
1085
1086         /* Unmarshall response */
1087
1088         if (!spoolss_io_r_deleteprinterdriver ("", &r, &rbuf, 0))
1089                 goto done;
1090
1091         /* Return output parameters */
1092
1093         result = r.status;
1094
1095  done:
1096         prs_mem_free(&qbuf);
1097         prs_mem_free(&rbuf);
1098
1099         return result;
1100 }
1101
1102 /*********************************************************************************
1103  Win32 API - GetPrinterProcessorDirectory()
1104  ********************************************************************************/
1105
1106 WERROR cli_spoolss_getprintprocessordirectory(struct cli_state *cli,
1107                                               TALLOC_CTX *mem_ctx,
1108                                               uint32 offered, uint32 *needed,
1109                                               char *name, char *environment,
1110                                               fstring procdir)
1111 {
1112         prs_struct qbuf, rbuf;
1113         SPOOL_Q_GETPRINTPROCESSORDIRECTORY q;
1114         SPOOL_R_GETPRINTPROCESSORDIRECTORY r;
1115         int level = 1;
1116         WERROR result = W_ERROR(ERRgeneral);
1117         NEW_BUFFER buffer;
1118
1119         ZERO_STRUCT(q);
1120         ZERO_STRUCT(r);
1121
1122         /* Initialise parse structures */
1123
1124         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1125         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1126
1127         /* Initialise input parameters */
1128
1129         init_buffer(&buffer, offered, mem_ctx);
1130
1131         make_spoolss_q_getprintprocessordirectory(
1132                 &q, name, environment, level, &buffer, offered);
1133
1134         /* Marshall data and send request */
1135
1136         if (!spoolss_io_q_getprintprocessordirectory("", &q, &qbuf, 0) ||
1137             !rpc_api_pipe_req(cli, SPOOLSS_GETPRINTPROCESSORDIRECTORY,
1138                               &qbuf, &rbuf))
1139                 goto done;
1140
1141         /* Unmarshall response */
1142
1143         if (!spoolss_io_r_getprintprocessordirectory("", &r, &rbuf, 0))
1144                 goto done;
1145
1146         /* Return output parameters */
1147
1148         result = r.status;
1149
1150         if (needed)
1151                 *needed = r.needed;
1152
1153         if (W_ERROR_IS_OK(result))
1154                 fstrcpy(procdir, "Not implemented!");
1155
1156  done:
1157         prs_mem_free(&qbuf);
1158         prs_mem_free(&rbuf);
1159
1160         return result;
1161 }
1162
1163 /** Add a form to a printer.
1164  *
1165  * @param cli              Pointer to client state structure which is open
1166  *                         on the SPOOLSS pipe.
1167  * @param mem_ctx          Pointer to an initialised talloc context.
1168  *
1169  * @param handle           Policy handle opened with cli_spoolss_open_printer_ex
1170  *                         or cli_spoolss_addprinterex.
1171  * @param level            Form info level to add - should always be 1.
1172  * @param form             A pointer to the form to be added.
1173  *
1174  */
1175
1176 WERROR cli_spoolss_addform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1177                            POLICY_HND *handle, uint32 level, FORM *form)
1178 {
1179         prs_struct qbuf, rbuf;
1180         SPOOL_Q_ADDFORM q;
1181         SPOOL_R_ADDFORM r;
1182         WERROR result = W_ERROR(ERRgeneral);
1183
1184         ZERO_STRUCT(q);
1185         ZERO_STRUCT(r);
1186
1187         /* Initialise parse structures */
1188
1189         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1190         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1191
1192         /* Initialise input parameters */
1193
1194         make_spoolss_q_addform(&q, handle, level, form);
1195
1196         /* Marshall data and send request */
1197
1198         if (!spoolss_io_q_addform("", &q, &qbuf, 0) ||
1199             !rpc_api_pipe_req(cli, SPOOLSS_ADDFORM, &qbuf, &rbuf))
1200                 goto done;
1201
1202         /* Unmarshall response */
1203
1204         if (!spoolss_io_r_addform("", &r, &rbuf, 0))
1205                 goto done;
1206
1207         /* Return output parameters */
1208
1209         result = r.status;
1210
1211  done:
1212         prs_mem_free(&qbuf);
1213         prs_mem_free(&rbuf);
1214
1215         return result;
1216 }
1217
1218 /** Set a form on a printer.
1219  *
1220  * @param cli              Pointer to client state structure which is open
1221  *                         on the SPOOLSS pipe.
1222  * @param mem_ctx          Pointer to an initialised talloc context.
1223  *
1224  * @param handle           Policy handle opened with cli_spoolss_open_printer_ex
1225  *                         or cli_spoolss_addprinterex.
1226  * @param level            Form info level to set - should always be 1.
1227  * @param form             A pointer to the form to be set.
1228  *
1229  */
1230
1231 WERROR cli_spoolss_setform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1232                            POLICY_HND *handle, uint32 level, char *form_name,
1233                            FORM *form)
1234 {
1235         prs_struct qbuf, rbuf;
1236         SPOOL_Q_SETFORM q;
1237         SPOOL_R_SETFORM r;
1238         WERROR result = W_ERROR(ERRgeneral);
1239
1240         ZERO_STRUCT(q);
1241         ZERO_STRUCT(r);
1242
1243         /* Initialise parse structures */
1244
1245         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1246         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1247
1248         /* Initialise input parameters */
1249
1250         make_spoolss_q_setform(&q, handle, level, form_name, form);
1251
1252         /* Marshall data and send request */
1253
1254         if (!spoolss_io_q_setform("", &q, &qbuf, 0) ||
1255             !rpc_api_pipe_req(cli, SPOOLSS_SETFORM, &qbuf, &rbuf))
1256                 goto done;
1257
1258         /* Unmarshall response */
1259
1260         if (!spoolss_io_r_setform("", &r, &rbuf, 0))
1261                 goto done;
1262
1263         /* Return output parameters */
1264
1265         result = r.status;
1266
1267         if (!W_ERROR_IS_OK(result))
1268                 goto done;
1269
1270
1271
1272  done:
1273         prs_mem_free(&qbuf);
1274         prs_mem_free(&rbuf);
1275
1276         return result;
1277 }
1278
1279 /** Get a form on a printer.
1280  *
1281  * @param cli              Pointer to client state structure which is open
1282  *                         on the SPOOLSS pipe.
1283  * @param mem_ctx          Pointer to an initialised talloc context.
1284  *
1285  * @param handle           Policy handle opened with cli_spoolss_open_printer_ex
1286  *                         or cli_spoolss_addprinterex.
1287  * @param formname         Name of the form to get
1288  * @param level            Form info level to get - should always be 1.
1289  *
1290  */
1291
1292 WERROR cli_spoolss_getform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1293                            uint32 offered, uint32 *needed,
1294                            POLICY_HND *handle, char *formname, uint32 level,
1295                            FORM_1 *form)
1296 {
1297         prs_struct qbuf, rbuf;
1298         SPOOL_Q_GETFORM q;
1299         SPOOL_R_GETFORM r;
1300         WERROR result = W_ERROR(ERRgeneral);
1301         NEW_BUFFER buffer;
1302
1303         ZERO_STRUCT(q);
1304         ZERO_STRUCT(r);
1305
1306         /* Initialise parse structures */
1307
1308         init_buffer(&buffer, offered, mem_ctx);
1309
1310         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1311         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1312
1313         /* Initialise input parameters */
1314
1315         make_spoolss_q_getform(&q, handle, formname, level, &buffer, offered);
1316
1317         /* Marshall data and send request */
1318
1319         if (!spoolss_io_q_getform("", &q, &qbuf, 0) ||
1320             !rpc_api_pipe_req(cli, SPOOLSS_GETFORM, &qbuf, &rbuf))
1321                 goto done;
1322
1323         /* Unmarshall response */
1324
1325         if (!spoolss_io_r_getform("", &r, &rbuf, 0))
1326                 goto done;
1327
1328         /* Return output parameters */
1329
1330         result = r.status;
1331
1332         if (needed)
1333                 *needed = r.needed;
1334
1335         if (W_ERROR_IS_OK(result))
1336                 smb_io_form_1("", r.buffer, form, 0);
1337
1338  done:
1339         prs_mem_free(&qbuf);
1340         prs_mem_free(&rbuf);
1341
1342         return result;
1343 }
1344
1345 /** Delete a form on a printer.
1346  *
1347  * @param cli              Pointer to client state structure which is open
1348  *                         on the SPOOLSS pipe.
1349  * @param mem_ctx          Pointer to an initialised talloc context.
1350  *
1351  * @param handle           Policy handle opened with cli_spoolss_open_printer_ex
1352  *                         or cli_spoolss_addprinterex.
1353  * @param form             The name of the form to delete.
1354  *
1355  */
1356
1357 WERROR cli_spoolss_deleteform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1358                               POLICY_HND *handle, char *form_name)
1359 {
1360         prs_struct qbuf, rbuf;
1361         SPOOL_Q_DELETEFORM q;
1362         SPOOL_R_DELETEFORM r;
1363         WERROR result = W_ERROR(ERRgeneral);
1364
1365         ZERO_STRUCT(q);
1366         ZERO_STRUCT(r);
1367
1368         /* Initialise parse structures */
1369
1370         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1371         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1372
1373         /* Initialise input parameters */
1374
1375         make_spoolss_q_deleteform(&q, handle, form_name);
1376
1377         /* Marshall data and send request */
1378
1379         if (!spoolss_io_q_deleteform("", &q, &qbuf, 0) ||
1380             !rpc_api_pipe_req(cli, SPOOLSS_DELETEFORM, &qbuf, &rbuf))
1381                 goto done;
1382
1383         /* Unmarshall response */
1384
1385         if (!spoolss_io_r_deleteform("", &r, &rbuf, 0))
1386                 goto done;
1387
1388         /* Return output parameters */
1389
1390         result = r.status;
1391
1392  done:
1393         prs_mem_free(&qbuf);
1394         prs_mem_free(&rbuf);
1395
1396         return result;
1397 }
1398
1399 static void decode_forms_1(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
1400                            uint32 num_forms, FORM_1 **forms)
1401 {
1402         int i;
1403
1404         *forms = (FORM_1 *)talloc(mem_ctx, num_forms * sizeof(FORM_1));
1405         buffer->prs.data_offset = 0;
1406
1407         for (i = 0; i < num_forms; i++)
1408                 smb_io_form_1("", buffer, &((*forms)[i]), 0);
1409 }
1410
1411 /** Enumerate forms
1412  *
1413  * @param cli              Pointer to client state structure which is open
1414  *                         on the SPOOLSS pipe.
1415  * @param mem_ctx          Pointer to an initialised talloc context.
1416  *
1417  * @param offered          Buffer size offered in the request.
1418  * @param needed           Number of bytes needed to complete the request.
1419  *                         may be NULL.
1420  *                         or cli_spoolss_addprinterex.
1421  * @param level            Form info level to get - should always be 1.
1422  * @param handle           Open policy handle
1423  *
1424  */
1425
1426 WERROR cli_spoolss_enumforms(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1427                              uint32 offered, uint32 *needed,
1428                              POLICY_HND *handle, int level, uint32 *num_forms,
1429                              FORM_1 **forms)
1430 {
1431         prs_struct qbuf, rbuf;
1432         SPOOL_Q_ENUMFORMS q;
1433         SPOOL_R_ENUMFORMS r;
1434         WERROR result = W_ERROR(ERRgeneral);
1435         NEW_BUFFER buffer;
1436
1437         ZERO_STRUCT(q);
1438         ZERO_STRUCT(r);
1439
1440         /* Initialise parse structures */
1441
1442         init_buffer(&buffer, offered, mem_ctx);
1443
1444         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1445         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1446
1447         /* Initialise input parameters */
1448
1449         make_spoolss_q_enumforms(&q, handle, level, &buffer, offered);
1450
1451         /* Marshall data and send request */
1452
1453         if (!spoolss_io_q_enumforms("", &q, &qbuf, 0) ||
1454             !rpc_api_pipe_req(cli, SPOOLSS_ENUMFORMS, &qbuf, &rbuf))
1455                 goto done;
1456
1457         /* Unmarshall response */
1458
1459         if (!spoolss_io_r_enumforms("", &r, &rbuf, 0))
1460                 goto done;
1461
1462         /* Return output parameters */
1463
1464         result = r.status;
1465
1466         if (needed)
1467                 *needed = r.needed;
1468
1469         if (num_forms)
1470                 *num_forms = r.numofforms;
1471
1472         decode_forms_1(mem_ctx, r.buffer, *num_forms, forms);
1473
1474  done:
1475         prs_mem_free(&qbuf);
1476         prs_mem_free(&rbuf);
1477
1478         return result;
1479 }
1480
1481 static void decode_jobs_1(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
1482                           uint32 num_jobs, JOB_INFO_1 **jobs)
1483 {
1484         uint32 i;
1485
1486         *jobs = (JOB_INFO_1 *)talloc(mem_ctx, num_jobs * sizeof(JOB_INFO_1));
1487         buffer->prs.data_offset = 0;
1488
1489         for (i = 0; i < num_jobs; i++)
1490                 smb_io_job_info_1("", buffer, &((*jobs)[i]), 0);
1491 }
1492
1493 static void decode_jobs_2(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
1494                           uint32 num_jobs, JOB_INFO_2 **jobs)
1495 {
1496         uint32 i;
1497
1498         *jobs = (JOB_INFO_2 *)talloc(mem_ctx, num_jobs * sizeof(JOB_INFO_2));
1499         buffer->prs.data_offset = 0;
1500
1501         for (i = 0; i < num_jobs; i++)
1502                 smb_io_job_info_2("", buffer, &((*jobs)[i]), 0);
1503 }
1504
1505 /* Enumerate jobs */
1506
1507 WERROR cli_spoolss_enumjobs(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1508                             uint32 offered, uint32 *needed,
1509                             POLICY_HND *hnd, uint32 level, uint32 firstjob,
1510                             uint32 num_jobs, uint32 *returned, JOB_INFO_CTR *ctr)
1511 {
1512         prs_struct qbuf, rbuf;
1513         SPOOL_Q_ENUMJOBS q;
1514         SPOOL_R_ENUMJOBS r;
1515         WERROR result = W_ERROR(ERRgeneral);
1516         NEW_BUFFER buffer;
1517
1518         ZERO_STRUCT(q);
1519         ZERO_STRUCT(r);
1520
1521         /* Initialise parse structures */
1522
1523         init_buffer(&buffer, offered, mem_ctx);
1524
1525         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1526         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1527
1528         /* Initialise input parameters */
1529
1530         make_spoolss_q_enumjobs(&q, hnd, firstjob, num_jobs, level, &buffer,
1531                                 offered);
1532
1533         /* Marshall data and send request */
1534
1535         if (!spoolss_io_q_enumjobs("", &q, &qbuf, 0) ||
1536             !rpc_api_pipe_req(cli, SPOOLSS_ENUMJOBS, &qbuf, &rbuf))
1537                 goto done;
1538
1539         /* Unmarshall response */
1540
1541         if (!spoolss_io_r_enumjobs("", &r, &rbuf, 0))
1542                 goto done;
1543
1544         /* Return output parameters */
1545
1546         result = r.status;
1547
1548         if (needed)
1549                 *needed = r.needed;
1550
1551         if (!W_ERROR_IS_OK(r.status))
1552                 goto done;
1553
1554         *returned = r.returned;
1555
1556         switch(level) {
1557         case 1:
1558                 decode_jobs_1(mem_ctx, r.buffer, r.returned,
1559                                 ctr->job.job_info_1);
1560                 break;
1561         case 2:
1562                 decode_jobs_2(mem_ctx, r.buffer, r.returned,
1563                                 ctr->job.job_info_2);
1564                 break;
1565         default:
1566                 DEBUG(3, ("unsupported info level %d", level));
1567                 break;
1568         }
1569
1570  done:
1571         prs_mem_free(&qbuf);
1572         prs_mem_free(&rbuf);
1573
1574         return result;
1575 }
1576
1577 /* Set job */
1578
1579 WERROR cli_spoolss_setjob(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1580                           POLICY_HND *hnd, uint32 jobid, uint32 level,
1581                           uint32 command)
1582 {
1583         prs_struct qbuf, rbuf;
1584         SPOOL_Q_SETJOB q;
1585         SPOOL_R_SETJOB r;
1586         WERROR result = W_ERROR(ERRgeneral);
1587
1588         ZERO_STRUCT(q);
1589         ZERO_STRUCT(r);
1590
1591         /* Initialise parse structures */
1592
1593         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1594         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1595
1596         /* Initialise input parameters */
1597
1598         make_spoolss_q_setjob(&q, hnd, jobid, level, command);
1599
1600         /* Marshall data and send request */
1601
1602         if (!spoolss_io_q_setjob("", &q, &qbuf, 0) ||
1603             !rpc_api_pipe_req(cli, SPOOLSS_SETJOB, &qbuf, &rbuf))
1604                 goto done;
1605
1606         /* Unmarshall response */
1607
1608         if (!spoolss_io_r_setjob("", &r, &rbuf, 0))
1609                 goto done;
1610
1611         /* Return output parameters */
1612
1613         result = r.status;
1614
1615  done:
1616         prs_mem_free(&qbuf);
1617         prs_mem_free(&rbuf);
1618
1619         return result;
1620 }
1621
1622 /* Get job */
1623
1624 WERROR cli_spoolss_getjob(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1625                           uint32 offered, uint32 *needed,
1626                           POLICY_HND *hnd, uint32 jobid, uint32 level,
1627                           JOB_INFO_CTR *ctr)
1628 {
1629         prs_struct qbuf, rbuf;
1630         SPOOL_Q_GETJOB q;
1631         SPOOL_R_GETJOB r;
1632         WERROR result = W_ERROR(ERRgeneral);
1633         NEW_BUFFER buffer;
1634
1635         ZERO_STRUCT(q);
1636         ZERO_STRUCT(r);
1637
1638         /* Initialise parse structures */
1639
1640         init_buffer(&buffer, offered, mem_ctx);
1641
1642         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1643         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1644
1645         /* Initialise input parameters */
1646
1647         make_spoolss_q_getjob(&q, hnd, jobid, level, &buffer, offered);
1648
1649         /* Marshall data and send request */
1650
1651         if (!spoolss_io_q_getjob("", &q, &qbuf, 0) ||
1652             !rpc_api_pipe_req(cli, SPOOLSS_GETJOB, &qbuf, &rbuf))
1653                 goto done;
1654
1655         /* Unmarshall response */
1656
1657         if (!spoolss_io_r_getjob("", &r, &rbuf, 0))
1658                 goto done;
1659
1660         /* Return output parameters */
1661
1662         result = r.status;
1663
1664         if (needed)
1665                 *needed = r.needed;
1666
1667         if (!W_ERROR_IS_OK(r.status))
1668                 goto done;
1669
1670         switch(level) {
1671         case 1:
1672                 decode_jobs_1(mem_ctx, r.buffer, 1, ctr->job.job_info_1);
1673                 break;
1674         case 2:
1675                 decode_jobs_2(mem_ctx, r.buffer, 1, ctr->job.job_info_2);
1676                 break;
1677         default:
1678                 DEBUG(3, ("unsupported info level %d", level));
1679                 break;
1680         }
1681
1682  done:
1683         prs_mem_free(&qbuf);
1684         prs_mem_free(&rbuf);
1685
1686         return result;
1687 }
1688
1689 /* Startpageprinter.  Sent to notify the spooler when a page is about to be
1690    sent to a printer. */
1691
1692 WERROR cli_spoolss_startpageprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1693                                     POLICY_HND *hnd)
1694 {
1695         prs_struct qbuf, rbuf;
1696         SPOOL_Q_STARTPAGEPRINTER q;
1697         SPOOL_R_STARTPAGEPRINTER r;
1698         WERROR result = W_ERROR(ERRgeneral);
1699
1700         ZERO_STRUCT(q);
1701         ZERO_STRUCT(r);
1702
1703         /* Initialise parse structures */
1704
1705         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1706         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1707
1708         /* Initialise input parameters */
1709
1710         make_spoolss_q_startpageprinter(&q, hnd);
1711
1712         /* Marshall data and send request */
1713
1714         if (!spoolss_io_q_startpageprinter("", &q, &qbuf, 0) ||
1715             !rpc_api_pipe_req(cli, SPOOLSS_STARTPAGEPRINTER, &qbuf, &rbuf))
1716                 goto done;
1717
1718         /* Unmarshall response */
1719
1720         if (!spoolss_io_r_startpageprinter("", &r, &rbuf, 0))
1721                 goto done;
1722
1723         /* Return output parameters */
1724
1725         result = r.status;
1726
1727  done:
1728         prs_mem_free(&qbuf);
1729         prs_mem_free(&rbuf);
1730
1731         return result;
1732 }
1733
1734 /* Endpageprinter.  Sent to notify the spooler when a page has finished
1735    being sent to a printer. */
1736
1737 WERROR cli_spoolss_endpageprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1738                                   POLICY_HND *hnd)
1739 {
1740         prs_struct qbuf, rbuf;
1741         SPOOL_Q_ENDPAGEPRINTER q;
1742         SPOOL_R_ENDPAGEPRINTER r;
1743         WERROR result = W_ERROR(ERRgeneral);
1744
1745         ZERO_STRUCT(q);
1746         ZERO_STRUCT(r);
1747
1748         /* Initialise parse structures */
1749
1750         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1751         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1752
1753         /* Initialise input parameters */
1754
1755         make_spoolss_q_endpageprinter(&q, hnd);
1756
1757         /* Marshall data and send request */
1758
1759         if (!spoolss_io_q_endpageprinter("", &q, &qbuf, 0) ||
1760             !rpc_api_pipe_req(cli, SPOOLSS_ENDPAGEPRINTER, &qbuf, &rbuf))
1761                 goto done;
1762
1763         /* Unmarshall response */
1764
1765         if (!spoolss_io_r_endpageprinter("", &r, &rbuf, 0))
1766                 goto done;
1767
1768         /* Return output parameters */
1769
1770         result = r.status;
1771
1772  done:
1773         prs_mem_free(&qbuf);
1774         prs_mem_free(&rbuf);
1775
1776         return result;
1777 }
1778
1779 /* Startdocprinter.  Sent to notify the spooler that a document is about
1780    to be spooled for printing. */
1781
1782 WERROR cli_spoolss_startdocprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1783                                    POLICY_HND *hnd, char *docname,
1784                                    char *outputfile, char *datatype,
1785                                    uint32 *jobid)
1786 {
1787         prs_struct qbuf, rbuf;
1788         SPOOL_Q_STARTDOCPRINTER q;
1789         SPOOL_R_STARTDOCPRINTER r;
1790         WERROR result = W_ERROR(ERRgeneral);
1791         uint32 level = 1;
1792
1793         ZERO_STRUCT(q);
1794         ZERO_STRUCT(r);
1795
1796         /* Initialise parse structures */
1797
1798         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1799         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1800
1801         /* Initialise input parameters */
1802
1803         make_spoolss_q_startdocprinter(&q, hnd, level, docname, outputfile,
1804                                        datatype);
1805
1806         /* Marshall data and send request */
1807
1808         if (!spoolss_io_q_startdocprinter("", &q, &qbuf, 0) ||
1809             !rpc_api_pipe_req(cli, SPOOLSS_STARTDOCPRINTER, &qbuf, &rbuf))
1810                 goto done;
1811
1812         /* Unmarshall response */
1813
1814         if (!spoolss_io_r_startdocprinter("", &r, &rbuf, 0))
1815                 goto done;
1816
1817         /* Return output parameters */
1818
1819         result = r.status;
1820
1821         if (W_ERROR_IS_OK(result))
1822                 *jobid = r.jobid;
1823
1824  done:
1825         prs_mem_free(&qbuf);
1826         prs_mem_free(&rbuf);
1827
1828         return result;
1829 }
1830
1831 /* Enddocprinter.  Sent to notify the spooler that a document has finished
1832    being spooled. */
1833
1834 WERROR cli_spoolss_enddocprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1835                                   POLICY_HND *hnd)
1836 {
1837         prs_struct qbuf, rbuf;
1838         SPOOL_Q_ENDDOCPRINTER q;
1839         SPOOL_R_ENDDOCPRINTER r;
1840         WERROR result = W_ERROR(ERRgeneral);
1841
1842         ZERO_STRUCT(q);
1843         ZERO_STRUCT(r);
1844
1845         /* Initialise parse structures */
1846
1847         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1848         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1849
1850         /* Initialise input parameters */
1851
1852         make_spoolss_q_enddocprinter(&q, hnd);
1853
1854         /* Marshall data and send request */
1855
1856         if (!spoolss_io_q_enddocprinter("", &q, &qbuf, 0) ||
1857             !rpc_api_pipe_req(cli, SPOOLSS_ENDDOCPRINTER, &qbuf, &rbuf))
1858                 goto done;
1859
1860         /* Unmarshall response */
1861
1862         if (!spoolss_io_r_enddocprinter("", &r, &rbuf, 0))
1863                 goto done;
1864
1865         /* Return output parameters */
1866
1867         result = r.status;
1868
1869  done:
1870         prs_mem_free(&qbuf);
1871         prs_mem_free(&rbuf);
1872
1873         return result;
1874 }
1875
1876 /* Get printer data */
1877
1878 WERROR cli_spoolss_getprinterdata(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1879                                   uint32 offered, uint32 *needed,
1880                                   POLICY_HND *hnd, char *valuename,
1881                                   uint32 *data_type, char **data,
1882                                   uint32 *data_size)
1883 {
1884         prs_struct qbuf, rbuf;
1885         SPOOL_Q_GETPRINTERDATA q;
1886         SPOOL_R_GETPRINTERDATA r;
1887         WERROR result = W_ERROR(ERRgeneral);
1888
1889         ZERO_STRUCT(q);
1890         ZERO_STRUCT(r);
1891
1892         /* Initialise parse structures */
1893
1894         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1895         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1896
1897         /* Initialise input parameters */
1898
1899         make_spoolss_q_getprinterdata(&q, hnd, valuename, offered);
1900
1901         /* Marshall data and send request */
1902
1903         if (!spoolss_io_q_getprinterdata("", &q, &qbuf, 0) ||
1904             !rpc_api_pipe_req(cli, SPOOLSS_GETPRINTERDATA, &qbuf, &rbuf))
1905                 goto done;
1906
1907         /* Unmarshall response */
1908
1909         if (!spoolss_io_r_getprinterdata("", &r, &rbuf, 0))
1910                 goto done;
1911
1912         result = r.status;
1913
1914         if (needed)
1915                 *needed = r.needed;
1916
1917         if (!W_ERROR_IS_OK(r.status))
1918                 goto done;
1919
1920         /* Return output parameters */
1921
1922         if (data_type)
1923                 *data_type = r.type;
1924
1925         if (data) {
1926                 *data = (char *)talloc(mem_ctx, r.needed);
1927                 memcpy(*data, r.data, r.needed);
1928         }
1929
1930         if (data_size)
1931                 *data_size = r.needed;
1932
1933  done:
1934         prs_mem_free(&qbuf);
1935         prs_mem_free(&rbuf);
1936
1937         return result;
1938 }
1939
1940 /* Set printer data */
1941
1942 WERROR cli_spoolss_setprinterdata(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1943                                   POLICY_HND *hnd, char *value,
1944                                   uint32 data_type, char *data,
1945                                   uint32 data_size)
1946 {
1947         prs_struct qbuf, rbuf;
1948         SPOOL_Q_SETPRINTERDATA q;
1949         SPOOL_R_SETPRINTERDATA r;
1950         WERROR result = W_ERROR(ERRgeneral);
1951
1952         ZERO_STRUCT(q);
1953         ZERO_STRUCT(r);
1954
1955         /* Initialise parse structures */
1956
1957         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1958         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1959
1960         /* Initialise input parameters */
1961
1962         make_spoolss_q_setprinterdata(&q, hnd, value, data, data_size);
1963
1964         /* Marshall data and send request */
1965
1966         if (!spoolss_io_q_setprinterdata("", &q, &qbuf, 0) ||
1967             !rpc_api_pipe_req(cli, SPOOLSS_SETPRINTERDATA, &qbuf, &rbuf))
1968                 goto done;
1969
1970         /* Unmarshall response */
1971
1972         if (!spoolss_io_r_setprinterdata("", &r, &rbuf, 0))
1973                 goto done;
1974
1975         result = r.status;
1976
1977         if (!W_ERROR_IS_OK(r.status))
1978                 goto done;
1979
1980  done:
1981         prs_mem_free(&qbuf);
1982         prs_mem_free(&rbuf);
1983
1984         return result;
1985 }
1986
1987 /* Enum printer data */
1988
1989 WERROR cli_spoolss_enumprinterdata(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1990                                    POLICY_HND *hnd, uint32 ndx,
1991                                    uint32 value_offered, uint32 data_offered,
1992                                    uint32 *value_needed, uint32 *data_needed,
1993                                    char **value, uint32 *data_type, char **data,
1994                                    uint32 *data_size)
1995 {
1996         prs_struct qbuf, rbuf;
1997         SPOOL_Q_ENUMPRINTERDATA q;
1998         SPOOL_R_ENUMPRINTERDATA r;
1999         WERROR result = W_ERROR(ERRgeneral);
2000
2001         ZERO_STRUCT(q);
2002         ZERO_STRUCT(r);
2003
2004         /* Initialise parse structures */
2005
2006         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2007         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2008
2009         /* Initialise input parameters */
2010
2011         make_spoolss_q_enumprinterdata(&q, hnd, ndx, value_offered, data_offered);
2012
2013         /* Marshall data and send request */
2014
2015         if (!spoolss_io_q_enumprinterdata("", &q, &qbuf, 0) ||
2016             !rpc_api_pipe_req(cli, SPOOLSS_ENUMPRINTERDATA, &qbuf, &rbuf))
2017                 goto done;
2018
2019         /* Unmarshall response */
2020
2021         if (!spoolss_io_r_enumprinterdata("", &r, &rbuf, 0))
2022                 goto done;
2023
2024         result = r.status;
2025
2026         if (!W_ERROR_IS_OK(r.status))
2027                 goto done;
2028
2029         /* Return data */
2030
2031         if (value_needed)
2032                 *value_needed = r.realvaluesize;
2033
2034         if (data_needed)
2035                 *data_needed = r.realdatasize;
2036
2037         if (data_type)
2038                 *data_type = r.type;
2039
2040         if (value) {
2041                 fstring the_value;
2042
2043                 rpcstr_pull(the_value, r.value, sizeof(the_value), -1,
2044                             STR_TERMINATE);
2045
2046                 *value = talloc_strdup(mem_ctx, the_value);
2047         }
2048
2049         if (data)
2050                 *data = talloc_memdup(mem_ctx, r.data, r.realdatasize);
2051
2052         if (data_size)
2053                 *data_size = r.realdatasize;
2054
2055  done:
2056         prs_mem_free(&qbuf);
2057         prs_mem_free(&rbuf);
2058
2059         return result;
2060 }
2061
2062 /* Write data to printer */
2063
2064 WERROR cli_spoolss_writeprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
2065                                 POLICY_HND *hnd, uint32 data_size, char *data,
2066                                 uint32 *num_written)
2067 {
2068         prs_struct qbuf, rbuf;
2069         SPOOL_Q_WRITEPRINTER q;
2070         SPOOL_R_WRITEPRINTER r;
2071         WERROR result = W_ERROR(ERRgeneral);
2072
2073         ZERO_STRUCT(q);
2074         ZERO_STRUCT(r);
2075
2076         /* Initialise parse structures */
2077
2078         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2079         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2080
2081         /* Initialise input parameters */
2082
2083         make_spoolss_q_writeprinter(&q, hnd, data_size, data);
2084
2085         /* Marshall data and send request */
2086
2087         if (!spoolss_io_q_writeprinter("", &q, &qbuf, 0) ||
2088             !rpc_api_pipe_req(cli, SPOOLSS_WRITEPRINTER, &qbuf, &rbuf))
2089                 goto done;
2090
2091         /* Unmarshall response */
2092
2093         if (!spoolss_io_r_writeprinter("", &r, &rbuf, 0))
2094                 goto done;
2095
2096         result = r.status;
2097
2098         if (!W_ERROR_IS_OK(r.status))
2099                 goto done;
2100
2101         if (num_written)
2102                 *num_written = r.buffer_written;
2103
2104  done:
2105         prs_mem_free(&qbuf);
2106         prs_mem_free(&rbuf);
2107
2108         return result;
2109 }
2110
2111 /* Delete printer data */
2112
2113 WERROR cli_spoolss_deleteprinterdata(struct cli_state *cli, TALLOC_CTX *mem_ctx,
2114                                      POLICY_HND *hnd, char *valuename)
2115 {
2116         prs_struct qbuf, rbuf;
2117         SPOOL_Q_DELETEPRINTERDATA q;
2118         SPOOL_R_DELETEPRINTERDATA r;
2119         WERROR result = W_ERROR(ERRgeneral);
2120
2121         ZERO_STRUCT(q);
2122         ZERO_STRUCT(r);
2123
2124         /* Initialise parse structures */
2125
2126         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
2127         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
2128
2129         /* Initialise input parameters */
2130
2131         make_spoolss_q_deleteprinterdata(&q, hnd, valuename);
2132
2133         /* Marshall data and send request */
2134
2135         if (!spoolss_io_q_deleteprinterdata("", &q, &qbuf, 0) ||
2136             !rpc_api_pipe_req(cli, SPOOLSS_DELETEPRINTERDATA, &qbuf, &rbuf))
2137                 goto done;
2138
2139         /* Unmarshall response */
2140
2141         if (!spoolss_io_r_deleteprinterdata("", &r, &rbuf, 0))
2142                 goto done;
2143
2144         result = r.status;
2145
2146         if (!W_ERROR_IS_OK(r.status))
2147                 goto done;
2148
2149  done:
2150         prs_mem_free(&qbuf);
2151         prs_mem_free(&rbuf);
2152
2153         return result;
2154 }
2155
2156 /** @} **/