source/libsmb/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 /** Opens a SMB connection and connects to the SPOOLSS pipe.
  35  *
  36  * @param cli Uninitialised client handle.
  37  * @param system_name NETBIOS name of the machine to connect to.
  38  * @param creds User credentials to connect as.
  39  * @returns Initialised client handle.
  40  */
  41 struct cli_state *cli_spoolss_initialise(struct cli_state *cli,
  42                                          char *system_name,
  43                                          struct ntuser_creds *creds)
  44 {
  45         return cli_pipe_initialise(cli, system_name, PIPE_SPOOLSS, creds);
  46 }
  47
  48
  49 /**********************************************************************
  50  Initialize a new spoolss buff for use by a client rpc
  51 **********************************************************************/
  52 static void init_buffer(NEW_BUFFER *buffer, uint32 size, TALLOC_CTX *ctx)
  53 {
  54         buffer->ptr = (size != 0);
  55         buffer->size = size;
  56         buffer->string_at_end = size;
  57         prs_init(&buffer->prs, size, ctx, MARSHALL);
  58         buffer->struct_start = prs_offset(&buffer->prs);
  59 }
  60
  61 /*********************************************************************
  62  Decode various spoolss rpc's and info levels
  63  ********************************************************************/
  64
  65 /**********************************************************************
  66 **********************************************************************/
  67 static void decode_printer_info_0(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
  68                                 uint32 returned, PRINTER_INFO_0 **info)
  69 {
  70         uint32 i;
  71         PRINTER_INFO_0  *inf;
  72
  73         inf=(PRINTER_INFO_0 *)talloc(mem_ctx, returned*sizeof(PRINTER_INFO_0));
  74
  75         buffer->prs.data_offset=0;
  76
  77         for (i=0; i<returned; i++) {
  78                 smb_io_printer_info_0("", buffer, &inf[i], 0);
  79         }
  80
  81         *info=inf;
  82 }
  83
  84 /**********************************************************************
  85 **********************************************************************/
  86 static void decode_printer_info_1(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
  87                                 uint32 returned, PRINTER_INFO_1 **info)
  88 {
  89         uint32 i;
  90         PRINTER_INFO_1  *inf;
  91
  92         inf=(PRINTER_INFO_1 *)talloc(mem_ctx, returned*sizeof(PRINTER_INFO_1));
  93
  94         buffer->prs.data_offset=0;
  95
  96         for (i=0; i<returned; i++) {
  97                 smb_io_printer_info_1("", buffer, &inf[i], 0);
  98         }
  99
 100         *info=inf;
 101 }
 102
 103 /**********************************************************************
 104 **********************************************************************/
 105 static void decode_printer_info_2(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
 106                                 uint32 returned, PRINTER_INFO_2 **info)
 107 {
 108         uint32 i;
 109         PRINTER_INFO_2  *inf;
 110
 111         inf=(PRINTER_INFO_2 *)talloc(mem_ctx, returned*sizeof(PRINTER_INFO_2));
 112
 113         buffer->prs.data_offset=0;
 114
 115         for (i=0; i<returned; i++) {
 116                 /* a little initialization as we go */
 117                 inf[i].secdesc = NULL;
 118                 smb_io_printer_info_2("", buffer, &inf[i], 0);
 119         }
 120
 121         *info=inf;
 122 }
 123
 124 /**********************************************************************
 125 **********************************************************************/
 126 static void decode_printer_info_3(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
 127                                 uint32 returned, PRINTER_INFO_3 **info)
 128 {
 129         uint32 i;
 130         PRINTER_INFO_3  *inf;
 131
 132         inf=(PRINTER_INFO_3 *)talloc(mem_ctx, returned*sizeof(PRINTER_INFO_3));
 133
 134         buffer->prs.data_offset=0;
 135
 136         for (i=0; i<returned; i++) {
 137                 inf[i].secdesc = NULL;
 138                 smb_io_printer_info_3("", buffer, &inf[i], 0);
 139         }
 140
 141         *info=inf;
 142 }
 143
 144 /**********************************************************************
 145 **********************************************************************/
 146 static void decode_port_info_1(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
 147                         uint32 returned, PORT_INFO_1 **info)
 148 {
 149         uint32 i;
 150         PORT_INFO_1 *inf;
 151
 152         inf=(PORT_INFO_1*)talloc(mem_ctx, returned*sizeof(PORT_INFO_1));
 153
 154         prs_set_offset(&buffer->prs, 0);
 155
 156         for (i=0; i<returned; i++) {
 157                 smb_io_port_info_1("", buffer, &(inf[i]), 0);
 158         }
 159
 160         *info=inf;
 161 }
 162
 163 /**********************************************************************
 164 **********************************************************************/
 165 static void decode_port_info_2(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
 166                         uint32 returned, PORT_INFO_2 **info)
 167 {
 168         uint32 i;
 169         PORT_INFO_2 *inf;
 170
 171         inf=(PORT_INFO_2*)talloc(mem_ctx, returned*sizeof(PORT_INFO_2));
 172
 173         prs_set_offset(&buffer->prs, 0);
 174
 175         for (i=0; i<returned; i++) {
 176                 smb_io_port_info_2("", buffer, &(inf[i]), 0);
 177         }
 178
 179         *info=inf;
 180 }
 181
 182 /**********************************************************************
 183 **********************************************************************/
 184 static void decode_printer_driver_1(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
 185                         uint32 returned, DRIVER_INFO_1 **info)
 186 {
 187         uint32 i;
 188         DRIVER_INFO_1 *inf;
 189
 190         inf=(DRIVER_INFO_1 *)talloc(mem_ctx, returned*sizeof(DRIVER_INFO_1));
 191
 192         buffer->prs.data_offset=0;
 193
 194         for (i=0; i<returned; i++) {
 195                 smb_io_printer_driver_info_1("", buffer, &(inf[i]), 0);
 196         }
 197
 198         *info=inf;
 199 }
 200
 201 /**********************************************************************
 202 **********************************************************************/
 203 static void decode_printer_driver_2(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
 204                         uint32 returned, DRIVER_INFO_2 **info)
 205 {
 206         uint32 i;
 207         DRIVER_INFO_2 *inf;
 208
 209         inf=(DRIVER_INFO_2 *)talloc(mem_ctx, returned*sizeof(DRIVER_INFO_2));
 210
 211         buffer->prs.data_offset=0;
 212
 213         for (i=0; i<returned; i++) {
 214                 smb_io_printer_driver_info_2("", buffer, &(inf[i]), 0);
 215         }
 216
 217         *info=inf;
 218 }
 219
 220 /**********************************************************************
 221 **********************************************************************/
 222 static void decode_printer_driver_3(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
 223                         uint32 returned, DRIVER_INFO_3 **info)
 224 {
 225         uint32 i;
 226         DRIVER_INFO_3 *inf;
 227
 228         inf=(DRIVER_INFO_3 *)talloc(mem_ctx, returned*sizeof(DRIVER_INFO_3));
 229
 230         buffer->prs.data_offset=0;
 231
 232         for (i=0; i<returned; i++) {
 233                 smb_io_printer_driver_info_3("", buffer, &(inf[i]), 0);
 234         }
 235
 236         *info=inf;
 237 }
 238
 239 /**********************************************************************
 240 **********************************************************************/
 241 static void decode_printerdriverdir_1 (TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
 242                         uint32 returned, DRIVER_DIRECTORY_1 **info
 243 )
 244 {
 245         DRIVER_DIRECTORY_1 *inf;
 246
 247         inf=(DRIVER_DIRECTORY_1 *)talloc(mem_ctx, sizeof(DRIVER_DIRECTORY_1));
 248
 249         prs_set_offset(&buffer->prs, 0);
 250
 251         smb_io_driverdir_1("", buffer, inf, 0);
 252
 253         *info=inf;
 254 }
 255
 256 /** Return a handle to the specified printer or print server.
 257  *
 258  * @param cli              Pointer to client state structure which is open
 259  * on the SPOOLSS pipe.
 260  *
 261  * @param mem_ctx          Pointer to an initialised talloc context.
 262  *
 263  * @param printername      The name of the printer or print server to be
 264  * opened in UNC format.
 265  *
 266  * @param datatype         Specifies the default data type for the printer.
 267  *
 268  * @param access_required  The access rights requested on the printer or
 269  * print server.
 270  *
 271  * @param station          The UNC name of the requesting workstation.
 272  *
 273  * @param username         The name of the user requesting the open.
 274  *
 275  * @param pol              Returned policy handle.
 276  */
 277
 278 /*********************************************************************************
 279  Win32 API - OpenPrinter()
 280  ********************************************************************************/
 281
 282 WERROR cli_spoolss_open_printer_ex(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 283                                 char *printername, char *datatype, uint32 access_required,
 284                                 char *station, char *username, POLICY_HND *pol)
 285 {
 286         prs_struct qbuf, rbuf;
 287         SPOOL_Q_OPEN_PRINTER_EX q;
 288         SPOOL_R_OPEN_PRINTER_EX r;
 289         WERROR result = W_ERROR(ERRgeneral);
 290
 291         ZERO_STRUCT(q);
 292         ZERO_STRUCT(r);
 293
 294         /* Initialise parse structures */
 295
 296         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 297         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 298
 299         /* Initialise input parameters */
 300
 301         make_spoolss_q_open_printer_ex(&q, printername, datatype,
 302                                        access_required, station, username);
 303
 304         /* Marshall data and send request */
 305
 306         if (!spoolss_io_q_open_printer_ex("", &q, &qbuf, 0) ||
 307             !rpc_api_pipe_req(cli, SPOOLSS_OPENPRINTEREX, &qbuf, &rbuf))
 308                 goto done;
 309
 310         /* Unmarshall response */
 311
 312         if (!spoolss_io_r_open_printer_ex("", &r, &rbuf, 0))
 313                 goto done;
 314
 315         /* Return output parameters */
 316
 317         result = r.status;
 318
 319         if (W_ERROR_IS_OK(result))
 320                 *pol = r.handle;
 321
 322  done:
 323         prs_mem_free(&qbuf);
 324         prs_mem_free(&rbuf);
 325
 326         return result;
 327 }
 328
 329 /** Close a printer handle
 330  *
 331  * @param cli              Pointer to client state structure which is open
 332  * on the SPOOLSS pipe.
 333  *
 334  * @param mem_ctx          Pointer to an initialised talloc context.
 335  *
 336  * @param pol              Policy handle of printer or print server to close.
 337  */
 338 /*********************************************************************************
 339  Win32 API - ClosePrinter()
 340  ********************************************************************************/
 341
 342 WERROR cli_spoolss_close_printer(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 343                                 POLICY_HND *pol)
 344 {
 345         prs_struct qbuf, rbuf;
 346         SPOOL_Q_CLOSEPRINTER q;
 347         SPOOL_R_CLOSEPRINTER r;
 348         WERROR result = W_ERROR(ERRgeneral);
 349
 350         ZERO_STRUCT(q);
 351         ZERO_STRUCT(r);
 352
 353         /* Initialise parse structures */
 354
 355         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 356         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 357
 358         /* Initialise input parameters */
 359
 360         make_spoolss_q_closeprinter(&q, pol);
 361
 362         /* Marshall data and send request */
 363
 364         if (!spoolss_io_q_closeprinter("", &q, &qbuf, 0) ||
 365             !rpc_api_pipe_req(cli, SPOOLSS_CLOSEPRINTER, &qbuf, &rbuf))
 366                 goto done;
 367
 368         /* Unmarshall response */
 369
 370         if (!spoolss_io_r_closeprinter("", &r, &rbuf, 0))
 371                 goto done;
 372
 373         /* Return output parameters */
 374
 375         result = r.status;
 376
 377         if (W_ERROR_IS_OK(result))
 378                 *pol = r.handle;
 379
 380  done:
 381         prs_mem_free(&qbuf);
 382         prs_mem_free(&rbuf);
 383
 384         return result;
 385 }
 386
 387 /** Enumerate printers on a print server.
 388  *
 389  * @param cli              Pointer to client state structure which is open
 390  *                         on the SPOOLSS pipe.
 391  * @param mem_ctx          Pointer to an initialised talloc context.
 392  *
 393  * @param offered          Buffer size offered in the request.
 394  * @param needed           Number of bytes needed to complete the request.
 395  *                         may be NULL.
 396  *
 397  * @param flags            Selected from PRINTER_ENUM_* flags.
 398  * @param level            Request information level.
 399  *
 400  * @param num_printers     Pointer to number of printers returned.  May be
 401  *                         NULL.
 402  * @param ctr              Return structure for printer information.  May
 403  *                         be NULL.
 404  */
 405 /*********************************************************************************
 406  Win32 API - EnumPrinters()
 407  ********************************************************************************/
 408
 409 WERROR cli_spoolss_enum_printers(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 410                                  uint32 offered, uint32 *needed,
 411                                  uint32 flags, uint32 level,
 412                                  uint32 *num_printers, PRINTER_INFO_CTR *ctr)
 413 {
 414         prs_struct qbuf, rbuf;
 415         SPOOL_Q_ENUMPRINTERS q;
 416         SPOOL_R_ENUMPRINTERS r;
 417         NEW_BUFFER buffer;
 418         WERROR result = W_ERROR(ERRgeneral);
 419         fstring server;
 420
 421         ZERO_STRUCT(q);
 422         ZERO_STRUCT(r);
 423
 424         fstrcpy (server, cli->desthost);
 425         strupper (server);
 426
 427                 /* Initialise input parameters */
 428
 429         init_buffer(&buffer, offered, mem_ctx);
 430
 431                 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 432                 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 433
 434                 make_spoolss_q_enumprinters(&q, flags, server, level, &buffer,
 435                                     offered);
 436
 437                 /* Marshall data and send request */
 438
 439                 if (!spoolss_io_q_enumprinters("", &q, &qbuf, 0) ||
 440             !rpc_api_pipe_req(cli, SPOOLSS_ENUMPRINTERS, &qbuf, &rbuf))
 441                         goto done;
 442
 443                 /* Unmarshall response */
 444
 445                 if (spoolss_io_r_enumprinters("", &r, &rbuf, 0)) {
 446                 if (needed)
 447                         *needed = r.needed;
 448                 }
 449
 450         result = r.status;
 451
 452         /* Return output parameters */
 453
 454         if (!W_ERROR_IS_OK(r.status))
 455                         goto done;
 456
 457         if (num_printers)
 458                 *num_printers = r.returned;
 459
 460         if (!ctr)
 461                 goto done;
 462
 463                         switch (level) {
 464                         case 0:
 465                                 decode_printer_info_0(mem_ctx, r.buffer, r.returned,
 466                                                       &ctr->printers_0);
 467                                 break;
 468                         case 1:
 469                                 decode_printer_info_1(mem_ctx, r.buffer, r.returned,
 470                                                       &ctr->printers_1);
 471                                 break;
 472                         case 2:
 473                                 decode_printer_info_2(mem_ctx, r.buffer, r.returned,
 474                                                       &ctr->printers_2);
 475                                 break;
 476                         case 3:
 477                                 decode_printer_info_3(mem_ctx, r.buffer, r.returned,
 478                                                       &ctr->printers_3);
 479                                 break;
 480                         }
 481
 482         done:
 483                 prs_mem_free(&qbuf);
 484                 prs_mem_free(&rbuf);
 485
 486         return result;
 487 }
 488
 489 /*********************************************************************************
 490  Win32 API - EnumPorts()
 491  ********************************************************************************/
 492 /** Enumerate printer ports on a print server.
 493  *
 494  * @param cli              Pointer to client state structure which is open
 495  *                         on the SPOOLSS pipe.
 496  * @param mem_ctx          Pointer to an initialised talloc context.
 497  *
 498  * @param offered          Buffer size offered in the request.
 499  * @param needed           Number of bytes needed to complete the request.
 500  *                         May be NULL.
 501  *
 502  * @param level            Requested information level.
 503  *
 504  * @param num_ports        Pointer to number of ports returned.  May be NULL.
 505  * @param ctr              Pointer to structure holding port information.
 506  *                         May be NULL.
 507  */
 508
 509 WERROR cli_spoolss_enum_ports(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 510                               uint32 offered, uint32 *needed,
 511                               uint32 level, int *num_ports, PORT_INFO_CTR *ctr)
 512 {
 513         prs_struct qbuf, rbuf;
 514         SPOOL_Q_ENUMPORTS q;
 515         SPOOL_R_ENUMPORTS r;
 516         NEW_BUFFER buffer;
 517         WERROR result = W_ERROR(ERRgeneral);
 518         fstring server;
 519
 520         ZERO_STRUCT(q);
 521         ZERO_STRUCT(r);
 522
 523         slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 524         strupper (server);
 525
 526                 /* Initialise input parameters */
 527
 528         init_buffer(&buffer, offered, mem_ctx);
 529
 530                 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 531                 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 532
 533         make_spoolss_q_enumports(&q, server, level, &buffer, offered);
 534
 535                 /* Marshall data and send request */
 536
 537                 if (!spoolss_io_q_enumports("", &q, &qbuf, 0) ||
 538             !rpc_api_pipe_req(cli, SPOOLSS_ENUMPORTS, &qbuf, &rbuf))
 539                         goto done;
 540
 541                 /* Unmarshall response */
 542
 543                 if (spoolss_io_r_enumports("", &r, &rbuf, 0)) {
 544                 if (needed)
 545                         *needed = r.needed;
 546                 }
 547
 548         result = r.status;
 549
 550                 /* Return output parameters */
 551
 552         if (!W_ERROR_IS_OK(result))
 553                 goto done;
 554
 555         if (num_ports)
 556                 *num_ports = r.returned;
 557
 558         if (!ctr)
 559                 goto done;
 560
 561                         switch (level) {
 562                         case 1:
 563                                 decode_port_info_1(mem_ctx, r.buffer, r.returned,
 564                                                    &ctr->port.info_1);
 565                                 break;
 566                         case 2:
 567                                 decode_port_info_2(mem_ctx, r.buffer, r.returned,
 568                                                    &ctr->port.info_2);
 569                                 break;
 570                         }
 571
 572         done:
 573                 prs_mem_free(&qbuf);
 574                 prs_mem_free(&rbuf);
 575
 576         return result;
 577 }
 578
 579 /*********************************************************************************
 580  Win32 API - GetPrinter()
 581  ********************************************************************************/
 582
 583 WERROR cli_spoolss_getprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 584                               uint32 offered, uint32 *needed,
 585                               POLICY_HND *pol, uint32 level,
 586                               PRINTER_INFO_CTR *ctr)
 587 {
 588         prs_struct qbuf, rbuf;
 589         SPOOL_Q_GETPRINTER q;
 590         SPOOL_R_GETPRINTER r;
 591         NEW_BUFFER buffer;
 592         WERROR result = W_ERROR(ERRgeneral);
 593
 594         ZERO_STRUCT(q);
 595         ZERO_STRUCT(r);
 596
 597                 /* Initialise input parameters */
 598
 599         init_buffer(&buffer, offered, mem_ctx);
 600
 601                 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 602                 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 603
 604         make_spoolss_q_getprinter(mem_ctx, &q, pol, level, &buffer, offered);
 605
 606                 /* Marshall data and send request */
 607
 608                 if (!spoolss_io_q_getprinter("", &q, &qbuf, 0) ||
 609                     !rpc_api_pipe_req(cli, SPOOLSS_GETPRINTER, &qbuf, &rbuf))
 610                         goto done;
 611
 612                 /* Unmarshall response */
 613
 614         if (!spoolss_io_r_getprinter("", &r, &rbuf, 0))
 615                 goto done;
 616
 617         if (needed)
 618                 *needed = r.needed;
 619
 620                 /* Return output parameters */
 621
 622         result = r.status;
 623
 624                 if (NT_STATUS_IS_OK(result)) {
 625                         switch (level) {
 626                         case 0:
 627                                 decode_printer_info_0(mem_ctx, r.buffer, 1, &ctr->printers_0);
 628                                 break;
 629                         case 1:
 630                                 decode_printer_info_1(mem_ctx, r.buffer, 1, &ctr->printers_1);
 631                                 break;
 632                         case 2:
 633                                 decode_printer_info_2(mem_ctx, r.buffer, 1, &ctr->printers_2);
 634                                 break;
 635                         case 3:
 636                                 decode_printer_info_3(mem_ctx, r.buffer, 1, &ctr->printers_3);
 637                                 break;
 638                         }
 639                 }
 640
 641         done:
 642                 prs_mem_free(&qbuf);
 643                 prs_mem_free(&rbuf);
 644
 645         return result;
 646 }
 647
 648 /*********************************************************************************
 649  Win32 API - SetPrinter()
 650  ********************************************************************************/
 651 /** Set printer info
 652  *
 653  * @param cli              Pointer to client state structure which is open
 654  *                         on the SPOOLSS pipe.
 655  * @param mem_ctx          Pointer to an initialised talloc context.
 656  *
 657  * @param pol              Policy handle on printer to set info.
 658  * @param level            Information level to set.
 659  * @param ctr              Pointer to structure holding printer information.
 660  * @param command          Specifies the action performed.  See
 661  * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/gdi/prntspol_13ua.asp
 662  * for details.
 663  *
 664  */
 665
 666 WERROR cli_spoolss_setprinter(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 667                               POLICY_HND *pol, uint32 level,
 668                               PRINTER_INFO_CTR *ctr, uint32 command)
 669 {
 670         prs_struct qbuf, rbuf;
 671         SPOOL_Q_SETPRINTER q;
 672         SPOOL_R_SETPRINTER r;
 673         WERROR result = W_ERROR(ERRgeneral);
 674
 675         ZERO_STRUCT(q);
 676         ZERO_STRUCT(r);
 677
 678         /* Initialise input parameters */
 679         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 680         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 681
 682         make_spoolss_q_setprinter(mem_ctx, &q, pol, level, ctr, command);
 683
 684         /* Marshall data and send request */
 685
 686         if (!spoolss_io_q_setprinter("", &q, &qbuf, 0) ||
 687             !rpc_api_pipe_req(cli, SPOOLSS_SETPRINTER, &qbuf, &rbuf))
 688                 goto done;
 689
 690         /* Unmarshall response */
 691
 692         if (!spoolss_io_r_setprinter("", &r, &rbuf, 0))
 693                 goto done;
 694
 695         result = r.status;
 696
 697 done:
 698         prs_mem_free(&qbuf);
 699         prs_mem_free(&rbuf);
 700
 701
 702         return result;
 703 }
 704
 705 /*********************************************************************************
 706  Win32 API - GetPrinterDriver()
 707  ********************************************************************************/
 708 /** Get installed printer drivers for a given printer
 709  *
 710  * @param cli              Pointer to client state structure which is open
 711  * on the SPOOLSS pipe.
 712  *
 713  * @param mem_ctx          Pointer to an initialised talloc context.
 714  *
 715  * @param offered          Buffer size offered in the request.
 716  * @param needed           Number of bytes needed to complete the request.
 717  *                         may be NULL.
 718  *
 719  * @param pol              Pointer to an open policy handle for the printer
 720  *                         opened with cli_spoolss_open_printer_ex().
 721  * @param level            Requested information level.
 722  * @param env              The print environment or archictecture.  This is
 723  *                         "Windows NT x86" for NT4.
 724  * @param ctr              Returned printer driver information.
 725  */
 726
 727 WERROR cli_spoolss_getprinterdriver(struct cli_state *cli,
 728                                     TALLOC_CTX *mem_ctx,
 729                                     uint32 offered, uint32 *needed,
 730                                     POLICY_HND *pol, uint32 level,
 731                                     char *env, PRINTER_DRIVER_CTR *ctr)
 732 {
 733         prs_struct qbuf, rbuf;
 734         SPOOL_Q_GETPRINTERDRIVER2 q;
 735         SPOOL_R_GETPRINTERDRIVER2 r;
 736         NEW_BUFFER buffer;
 737         WERROR result = W_ERROR(ERRgeneral);
 738         fstring server;
 739
 740         ZERO_STRUCT(q);
 741         ZERO_STRUCT(r);
 742
 743         fstrcpy (server, cli->desthost);
 744         strupper (server);
 745
 746                 /* Initialise input parameters */
 747
 748         init_buffer(&buffer, offered, mem_ctx);
 749
 750                 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 751                 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 752
 753         make_spoolss_q_getprinterdriver2(&q, pol, env, level, 2, 2,
 754                                          &buffer, offered);
 755
 756         /* Marshall data and send request */
 757
 758                 if (!spoolss_io_q_getprinterdriver2 ("", &q, &qbuf, 0) ||
 759                     !rpc_api_pipe_req (cli, SPOOLSS_GETPRINTERDRIVER2, &qbuf, &rbuf))
 760                         goto done;
 761
 762                 /* Unmarshall response */
 763
 764         if (spoolss_io_r_getprinterdriver2 ("", &r, &rbuf, 0)) {
 765                 if (needed)
 766                         *needed = r.needed;
 767                 }
 768
 769         result = r.status;
 770
 771                 /* Return output parameters */
 772
 773         if (!W_ERROR_IS_OK(result))
 774                 goto done;
 775
 776         if (!ctr)
 777                 goto done;
 778
 779         switch (level) {
 780                         case 1:
 781                                 decode_printer_driver_1(mem_ctx, r.buffer, 1, &ctr->info1);
 782                                 break;
 783                         case 2:
 784                                 decode_printer_driver_2(mem_ctx, r.buffer, 1, &ctr->info2);
 785                                 break;
 786                         case 3:
 787                                 decode_printer_driver_3(mem_ctx, r.buffer, 1, &ctr->info3);
 788                                 break;
 789                         }
 790
 791         done:
 792                 prs_mem_free(&qbuf);
 793                 prs_mem_free(&rbuf);
 794
 795         return result;
 796 }
 797
 798 /*********************************************************************************
 799  Win32 API - EnumPrinterDrivers()
 800  ********************************************************************************/
 801 /**********************************************************************
 802  * Get installed printer drivers for a given printer
 803  */
 804 WERROR cli_spoolss_enumprinterdrivers (struct cli_state *cli,
 805                                        TALLOC_CTX *mem_ctx,
 806                                        uint32 offered, uint32 *needed,
 807                                        uint32 level, char *env,
 808                                        uint32 *num_drivers,
 809                                 PRINTER_DRIVER_CTR *ctr)
 810 {
 811         prs_struct                      qbuf, rbuf;
 812         SPOOL_Q_ENUMPRINTERDRIVERS      q;
 813         SPOOL_R_ENUMPRINTERDRIVERS      r;
 814         NEW_BUFFER                      buffer;
 815         WERROR result = W_ERROR(ERRgeneral);
 816         fstring                         server;
 817
 818         ZERO_STRUCT(q);
 819         ZERO_STRUCT(r);
 820
 821         slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 822         strupper (server);
 823
 824                 /* Initialise input parameters */
 825
 826         init_buffer(&buffer, offered, mem_ctx);
 827
 828                 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 829                 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 830
 831         /* Write the request */
 832
 833         make_spoolss_q_enumprinterdrivers(&q, server, env, level, &buffer,
 834                                           offered);
 835
 836                 /* Marshall data and send request */
 837
 838                 if (!spoolss_io_q_enumprinterdrivers ("", &q, &qbuf, 0) ||
 839                     !rpc_api_pipe_req (cli, SPOOLSS_ENUMPRINTERDRIVERS, &qbuf, &rbuf))
 840                         goto done;
 841
 842                 /* Unmarshall response */
 843
 844         if (!spoolss_io_r_enumprinterdrivers ("", &r, &rbuf, 0))
 845                 goto done;
 846
 847         if (needed)
 848                 *needed = r.needed;
 849
 850         if (num_drivers)
 851                 *num_drivers = r.returned;
 852
 853         result = r.status;
 854
 855                 /* Return output parameters */
 856
 857         if (W_ERROR_IS_OK(result) && (r.returned != 0)) {
 858                 *num_drivers = r.returned;
 859
 860                 switch (level) {
 861                         case 1:
 862                                 decode_printer_driver_1(mem_ctx, r.buffer, r.returned, &ctr->info1);
 863                                 break;
 864                         case 2:
 865                                 decode_printer_driver_2(mem_ctx, r.buffer, r.returned, &ctr->info2);
 866                                 break;
 867                         case 3:
 868                                 decode_printer_driver_3(mem_ctx, r.buffer, r.returned, &ctr->info3);
 869                                 break;
 870                         }
 871                 }
 872
 873         done:
 874                 prs_mem_free(&qbuf);
 875                 prs_mem_free(&rbuf);
 876
 877         return result;
 878 }
 879
 880
 881 /*********************************************************************************
 882  Win32 API - GetPrinterDriverDirectory()
 883  ********************************************************************************/
 884 /**********************************************************************
 885  * Get installed printer drivers for a given printer
 886  */
 887 WERROR cli_spoolss_getprinterdriverdir (struct cli_state *cli,
 888                                         TALLOC_CTX *mem_ctx,
 889                                         uint32 offered, uint32 *needed,
 890                                         uint32 level, char *env,
 891                                         DRIVER_DIRECTORY_CTR *ctr)
 892 {
 893         prs_struct                      qbuf, rbuf;
 894         SPOOL_Q_GETPRINTERDRIVERDIR     q;
 895         SPOOL_R_GETPRINTERDRIVERDIR     r;
 896         NEW_BUFFER                      buffer;
 897         WERROR result = W_ERROR(ERRgeneral);
 898         fstring                         server;
 899
 900         ZERO_STRUCT(q);
 901         ZERO_STRUCT(r);
 902
 903         slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 904         strupper (server);
 905
 906                 /* Initialise input parameters */
 907
 908         init_buffer(&buffer, offered, mem_ctx);
 909
 910                 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 911                 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 912
 913         /* Write the request */
 914
 915         make_spoolss_q_getprinterdriverdir(&q, server, env, level, &buffer,
 916                                            offered);
 917
 918                 /* Marshall data and send request */
 919
 920                 if (!spoolss_io_q_getprinterdriverdir ("", &q, &qbuf, 0) ||
 921             !rpc_api_pipe_req (cli, SPOOLSS_GETPRINTERDRIVERDIRECTORY,
 922                                &qbuf, &rbuf))
 923                         goto done;
 924
 925                 /* Unmarshall response */
 926
 927         if (spoolss_io_r_getprinterdriverdir ("", &r, &rbuf, 0)) {
 928                 if (needed)
 929                         *needed = r.needed;
 930                 }
 931
 932                 /* Return output parameters */
 933
 934         result = r.status;
 935
 936         if (W_ERROR_IS_OK(result)) {
 937                 switch (level) {
 938                         case 1:
 939                         decode_printerdriverdir_1(mem_ctx, r.buffer, 1,
 940                                                   &ctr->info1);
 941                                 break;
 942                         }
 943                 }
 944
 945         done:
 946                 prs_mem_free(&qbuf);
 947                 prs_mem_free(&rbuf);
 948
 949         return result;
 950 }
 951
 952 /*********************************************************************************
 953  Win32 API - AddPrinterDriver()
 954  ********************************************************************************/
 955 /**********************************************************************
 956  * Install a printer driver
 957  */
 958 WERROR cli_spoolss_addprinterdriver (struct cli_state *cli,
 959                                      TALLOC_CTX *mem_ctx, uint32 level,
 960                                      PRINTER_DRIVER_CTR *ctr)
 961 {
 962         prs_struct                      qbuf, rbuf;
 963         SPOOL_Q_ADDPRINTERDRIVER        q;
 964         SPOOL_R_ADDPRINTERDRIVER        r;
 965         WERROR result = W_ERROR(ERRgeneral);
 966         fstring                         server;
 967
 968         ZERO_STRUCT(q);
 969         ZERO_STRUCT(r);
 970
 971         slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
 972         strupper (server);
 973
 974         /* Initialise input parameters */
 975         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 976         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 977
 978         /* Write the request */
 979
 980         make_spoolss_q_addprinterdriver (mem_ctx, &q, server, level, ctr);
 981
 982         /* Marshall data and send request */
 983
 984         if (!spoolss_io_q_addprinterdriver ("", &q, &qbuf, 0) ||
 985             !rpc_api_pipe_req (cli, SPOOLSS_ADDPRINTERDRIVER, &qbuf, &rbuf))
 986                 goto done;
 987
 988         /* Unmarshall response */
 989
 990         if (!spoolss_io_r_addprinterdriver ("", &r, &rbuf, 0))
 991                 goto done;
 992
 993         /* Return output parameters */
 994
 995         result = r.status;
 996
 997 done:
 998         prs_mem_free(&qbuf);
 999         prs_mem_free(&rbuf);
1000
1001         return result;
1002 }
1003
1004 /*********************************************************************************
1005  Win32 API - AddPrinter()
1006  ********************************************************************************/
1007 /**********************************************************************
1008  * Install a printer
1009  */
1010 WERROR cli_spoolss_addprinterex (struct cli_state *cli, TALLOC_CTX *mem_ctx,
1011                                  uint32 level, PRINTER_INFO_CTR*ctr)
1012 {
1013         prs_struct                      qbuf, rbuf;
1014         SPOOL_Q_ADDPRINTEREX            q;
1015         SPOOL_R_ADDPRINTEREX            r;
1016         WERROR result = W_ERROR(ERRgeneral);
1017         fstring                         server,
1018                                         client,
1019                                         user;
1020
1021         ZERO_STRUCT(q);
1022         ZERO_STRUCT(r);
1023
1024         slprintf (client, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1025         strupper (client);
1026         slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1027         strupper (server);
1028         fstrcpy  (user, cli->user_name);
1029
1030         /* Initialise input parameters */
1031
1032         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1033         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1034
1035         /* Write the request */
1036
1037         make_spoolss_q_addprinterex (mem_ctx, &q, server, client, user,
1038                                      level, ctr);
1039
1040         /* Marshall data and send request */
1041
1042         if (!spoolss_io_q_addprinterex ("", &q, &qbuf, 0) ||
1043             !rpc_api_pipe_req (cli, SPOOLSS_ADDPRINTEREX, &qbuf, &rbuf))
1044                 goto done;
1045
1046         /* Unmarshall response */
1047
1048         if (!spoolss_io_r_addprinterex ("", &r, &rbuf, 0))
1049                 goto done;
1050
1051         /* Return output parameters */
1052
1053         result = r.status;
1054
1055  done:
1056         prs_mem_free(&qbuf);
1057         prs_mem_free(&rbuf);
1058
1059         return result;
1060 }
1061
1062 /*********************************************************************************
1063  Win32 API - DeltePrinterDriver()
1064  ********************************************************************************/
1065 /**********************************************************************
1066  * Delete a Printer Driver from the server (does not remove
1067  * the driver files
1068  */
1069 WERROR cli_spoolss_deleteprinterdriver (struct cli_state *cli,
1070                                         TALLOC_CTX *mem_ctx, char *arch,
1071                                         char *driver)
1072 {
1073         prs_struct                      qbuf, rbuf;
1074         SPOOL_Q_DELETEPRINTERDRIVER     q;
1075         SPOOL_R_DELETEPRINTERDRIVER     r;
1076         WERROR result = W_ERROR(ERRgeneral);
1077         fstring                         server;
1078
1079         ZERO_STRUCT(q);
1080         ZERO_STRUCT(r);
1081
1082
1083         /* Initialise input parameters */
1084         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1085         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1086
1087         slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1088         strupper (server);
1089
1090         /* Write the request */
1091
1092         make_spoolss_q_deleteprinterdriver(mem_ctx, &q, server, arch, driver);
1093
1094         /* Marshall data and send request */
1095
1096         if (!spoolss_io_q_deleteprinterdriver ("", &q, &qbuf, 0) ||
1097             !rpc_api_pipe_req (cli,SPOOLSS_DELETEPRINTERDRIVER , &qbuf, &rbuf))
1098                 goto done;
1099
1100         /* Unmarshall response */
1101
1102         if (!spoolss_io_r_deleteprinterdriver ("", &r, &rbuf, 0))
1103                 goto done;
1104
1105         /* Return output parameters */
1106
1107         result = r.status;
1108
1109  done:
1110         prs_mem_free(&qbuf);
1111         prs_mem_free(&rbuf);
1112
1113         return result;
1114 }
1115
1116 /*********************************************************************************
1117  Win32 API - GetPrinterProcessorDirectory()
1118  ********************************************************************************/
1119
1120 WERROR cli_spoolss_getprintprocessordirectory(struct cli_state *cli,
1121                                               TALLOC_CTX *mem_ctx,
1122                                               uint32 offered, uint32 *needed,
1123                                               char *name, char *environment,
1124                                               fstring procdir)
1125 {
1126         prs_struct qbuf, rbuf;
1127         SPOOL_Q_GETPRINTPROCESSORDIRECTORY q;
1128         SPOOL_R_GETPRINTPROCESSORDIRECTORY r;
1129         int level = 1;
1130         WERROR result = W_ERROR(ERRgeneral);
1131         NEW_BUFFER buffer;
1132
1133         ZERO_STRUCT(q);
1134         ZERO_STRUCT(r);
1135
1136         /* Initialise parse structures */
1137
1138         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1139         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1140
1141         /* Initialise input parameters */
1142
1143         init_buffer(&buffer, offered, mem_ctx);
1144
1145         make_spoolss_q_getprintprocessordirectory(
1146                 &q, name, environment, level, &buffer, offered);
1147
1148         /* Marshall data and send request */
1149
1150         if (!spoolss_io_q_getprintprocessordirectory("", &q, &qbuf, 0) ||
1151             !rpc_api_pipe_req(cli, SPOOLSS_GETPRINTPROCESSORDIRECTORY,
1152                               &qbuf, &rbuf))
1153                 goto done;
1154
1155         /* Unmarshall response */
1156
1157         if (!spoolss_io_r_getprintprocessordirectory("", &r, &rbuf, 0))
1158                 goto done;
1159
1160         /* Return output parameters */
1161
1162         result = r.status;
1163
1164         if (needed)
1165                 *needed = r.needed;
1166
1167         if (W_ERROR_IS_OK(result))
1168                 fstrcpy(procdir, "Not implemented!");
1169
1170  done:
1171         prs_mem_free(&qbuf);
1172         prs_mem_free(&rbuf);
1173
1174         return result;
1175 }
1176
1177 /** Add a form to a printer.
1178  *
1179  * @param cli              Pointer to client state structure which is open
1180  *                         on the SPOOLSS pipe.
1181  * @param mem_ctx          Pointer to an initialised talloc context.
1182  *
1183  * @param handle           Policy handle opened with cli_spoolss_open_printer_ex
1184  *                         or cli_spoolss_addprinterex.
1185  * @param level            Form info level to add - should always be 1.
1186  * @param form             A pointer to the form to be added.
1187  *
1188  */
1189
1190 WERROR cli_spoolss_addform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1191                            POLICY_HND *handle, uint32 level, FORM *form)
1192 {
1193         prs_struct qbuf, rbuf;
1194         SPOOL_Q_ADDFORM q;
1195         SPOOL_R_ADDFORM r;
1196         WERROR result = W_ERROR(ERRgeneral);
1197
1198         ZERO_STRUCT(q);
1199         ZERO_STRUCT(r);
1200
1201         /* Initialise parse structures */
1202
1203                 prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1204                 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1205
1206         /* Initialise input parameters */
1207
1208         make_spoolss_q_addform(&q, handle, level, form);
1209
1210                 /* Marshall data and send request */
1211
1212         if (!spoolss_io_q_addform("", &q, &qbuf, 0) ||
1213             !rpc_api_pipe_req(cli, SPOOLSS_ADDFORM, &qbuf, &rbuf))
1214                 goto done;
1215
1216         /* Unmarshall response */
1217
1218         if (!spoolss_io_r_addform("", &r, &rbuf, 0))
1219                         goto done;
1220
1221         /* Return output parameters */
1222
1223         result = r.status;
1224
1225  done:
1226         prs_mem_free(&qbuf);
1227         prs_mem_free(&rbuf);
1228
1229         return result;
1230 }
1231
1232 /** Set a form on a printer.
1233  *
1234  * @param cli              Pointer to client state structure which is open
1235  *                         on the SPOOLSS pipe.
1236  * @param mem_ctx          Pointer to an initialised talloc context.
1237  *
1238  * @param handle           Policy handle opened with cli_spoolss_open_printer_ex
1239  *                         or cli_spoolss_addprinterex.
1240  * @param level            Form info level to set - should always be 1.
1241  * @param form             A pointer to the form to be set.
1242  *
1243  */
1244
1245 WERROR cli_spoolss_setform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1246                            POLICY_HND *handle, uint32 level, char *form_name,
1247                            FORM *form)
1248 {
1249         prs_struct qbuf, rbuf;
1250         SPOOL_Q_SETFORM q;
1251         SPOOL_R_SETFORM r;
1252         WERROR result = W_ERROR(ERRgeneral);
1253
1254         ZERO_STRUCT(q);
1255         ZERO_STRUCT(r);
1256
1257         /* Initialise parse structures */
1258
1259         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1260         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1261
1262         /* Initialise input parameters */
1263
1264         make_spoolss_q_setform(&q, handle, level, form_name, form);
1265
1266         /* Marshall data and send request */
1267
1268         if (!spoolss_io_q_setform("", &q, &qbuf, 0) ||
1269             !rpc_api_pipe_req(cli, SPOOLSS_SETFORM, &qbuf, &rbuf))
1270                 goto done;
1271
1272                 /* Unmarshall response */
1273
1274         if (!spoolss_io_r_setform("", &r, &rbuf, 0))
1275                         goto done;
1276
1277         /* Return output parameters */
1278
1279         result = r.status;
1280
1281         if (!W_ERROR_IS_OK(result))
1282                 goto done;
1283
1284
1285
1286  done:
1287         prs_mem_free(&qbuf);
1288         prs_mem_free(&rbuf);
1289
1290         return result;
1291 }
1292
1293 /** Get a form on a printer.
1294  *
1295  * @param cli              Pointer to client state structure which is open
1296  *                         on the SPOOLSS pipe.
1297  * @param mem_ctx          Pointer to an initialised talloc context.
1298  *
1299  * @param handle           Policy handle opened with cli_spoolss_open_printer_ex
1300  *                         or cli_spoolss_addprinterex.
1301  * @param formname         Name of the form to get
1302  * @param level            Form info level to get - should always be 1.
1303  *
1304  */
1305
1306 WERROR cli_spoolss_getform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1307                            uint32 offered, uint32 *needed,
1308                            POLICY_HND *handle, char *formname, uint32 level,
1309                            FORM_1 *form)
1310 {
1311         prs_struct qbuf, rbuf;
1312         SPOOL_Q_GETFORM q;
1313         SPOOL_R_GETFORM r;
1314         WERROR result = W_ERROR(ERRgeneral);
1315         NEW_BUFFER buffer;
1316
1317         ZERO_STRUCT(q);
1318         ZERO_STRUCT(r);
1319
1320         /* Initialise parse structures */
1321
1322         init_buffer(&buffer, offered, mem_ctx);
1323
1324         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1325         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1326
1327         /* Initialise input parameters */
1328
1329         make_spoolss_q_getform(&q, handle, formname, level, &buffer, offered);
1330
1331         /* Marshall data and send request */
1332
1333         if (!spoolss_io_q_getform("", &q, &qbuf, 0) ||
1334             !rpc_api_pipe_req(cli, SPOOLSS_GETFORM, &qbuf, &rbuf))
1335                 goto done;
1336
1337         /* Unmarshall response */
1338
1339         if (!spoolss_io_r_getform("", &r, &rbuf, 0))
1340                 goto done;
1341
1342                 /* Return output parameters */
1343
1344         result = r.status;
1345
1346         if (needed)
1347                 *needed = r.needed;
1348
1349         if (W_ERROR_IS_OK(result))
1350                 smb_io_form_1("", r.buffer, form, 0);
1351
1352  done:
1353         prs_mem_free(&qbuf);
1354         prs_mem_free(&rbuf);
1355
1356         return result;
1357 }
1358
1359 /** Delete a form on a printer.
1360  *
1361  * @param cli              Pointer to client state structure which is open
1362  *                         on the SPOOLSS pipe.
1363  * @param mem_ctx          Pointer to an initialised talloc context.
1364  *
1365  * @param handle           Policy handle opened with cli_spoolss_open_printer_ex
1366  *                         or cli_spoolss_addprinterex.
1367  * @param form             The name of the form to delete.
1368  *
1369  */
1370
1371 WERROR cli_spoolss_deleteform(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1372                               POLICY_HND *handle, char *form_name)
1373 {
1374         prs_struct qbuf, rbuf;
1375         SPOOL_Q_DELETEFORM q;
1376         SPOOL_R_DELETEFORM r;
1377         WERROR result = W_ERROR(ERRgeneral);
1378
1379         ZERO_STRUCT(q);
1380         ZERO_STRUCT(r);
1381
1382         /* Initialise parse structures */
1383
1384         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1385         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1386
1387         /* Initialise input parameters */
1388
1389         make_spoolss_q_deleteform(&q, handle, form_name);
1390
1391         /* Marshall data and send request */
1392
1393         if (!spoolss_io_q_deleteform("", &q, &qbuf, 0) ||
1394             !rpc_api_pipe_req(cli, SPOOLSS_DELETEFORM, &qbuf, &rbuf))
1395                 goto done;
1396
1397         /* Unmarshall response */
1398
1399         if (!spoolss_io_r_deleteform("", &r, &rbuf, 0))
1400                 goto done;
1401
1402         /* Return output parameters */
1403
1404         result = r.status;
1405
1406  done:
1407         prs_mem_free(&qbuf);
1408         prs_mem_free(&rbuf);
1409
1410         return result;
1411 }
1412
1413 static void decode_forms_1(TALLOC_CTX *mem_ctx, NEW_BUFFER *buffer,
1414                            uint32 num_forms, FORM_1 **forms)
1415 {
1416         int i;
1417
1418         *forms = (FORM_1 *)talloc(mem_ctx, num_forms * sizeof(FORM_1));
1419         buffer->prs.data_offset = 0;
1420
1421         for (i = 0; i < num_forms; i++)
1422                 smb_io_form_1("", buffer, &((*forms)[i]), 0);
1423 }
1424
1425 /** Enumerate forms
1426  *
1427  * @param cli              Pointer to client state structure which is open
1428  *                         on the SPOOLSS pipe.
1429  * @param mem_ctx          Pointer to an initialised talloc context.
1430  *
1431  * @param offered          Buffer size offered in the request.
1432  * @param needed           Number of bytes needed to complete the request.
1433  *                         may be NULL.
1434  *                         or cli_spoolss_addprinterex.
1435  * @param level            Form info level to get - should always be 1.
1436  * @param handle           Open policy handle
1437  *
1438  */
1439
1440 WERROR cli_spoolss_enumforms(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1441                              uint32 offered, uint32 *needed,
1442                              POLICY_HND *handle, int level, uint32 *num_forms,
1443                              FORM_1 **forms)
1444 {
1445         prs_struct qbuf, rbuf;
1446         SPOOL_Q_ENUMFORMS q;
1447         SPOOL_R_ENUMFORMS r;
1448         WERROR result = W_ERROR(ERRgeneral);
1449         NEW_BUFFER buffer;
1450
1451         ZERO_STRUCT(q);
1452         ZERO_STRUCT(r);
1453
1454         /* Initialise parse structures */
1455
1456         init_buffer(&buffer, offered, mem_ctx);
1457
1458         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1459         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1460
1461         /* Initialise input parameters */
1462
1463         make_spoolss_q_enumforms(&q, handle, level, &buffer, offered);
1464
1465         /* Marshall data and send request */
1466
1467         if (!spoolss_io_q_enumforms("", &q, &qbuf, 0) ||
1468             !rpc_api_pipe_req(cli, SPOOLSS_ENUMFORMS, &qbuf, &rbuf))
1469                 goto done;
1470
1471         /* Unmarshall response */
1472
1473         if (!spoolss_io_r_enumforms("", &r, &rbuf, 0))
1474                 goto done;
1475
1476         /* Return output parameters */
1477
1478         result = r.status;
1479
1480         if (needed)
1481                 *needed = r.needed;
1482
1483         if (num_forms)
1484                 *num_forms = r.numofforms;
1485
1486         decode_forms_1(mem_ctx, r.buffer, *num_forms, forms);
1487
1488  done:
1489         prs_mem_free(&qbuf);
1490         prs_mem_free(&rbuf);
1491
1492         return result;
1493 }
1494
1495 /*********************************************************************************
1496  Win32 API - SetPrinterData()
1497  ********************************************************************************/
1498
1499 WERROR cli_spoolss_setprinterdata (struct cli_state *cli, TALLOC_CTX *mem_ctx,
1500                                         POLICY_HND *pol, char* valname, char* value)
1501 {
1502         prs_struct qbuf, rbuf;
1503         SPOOL_Q_SETPRINTERDATA q;
1504         SPOOL_R_SETPRINTERDATA r;
1505         WERROR result = W_ERROR(ERRgeneral);
1506
1507         ZERO_STRUCT(q);
1508         ZERO_STRUCT(r);
1509
1510         /* Initialise input parameters */
1511
1512         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1513         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1514
1515
1516         /* write the request */
1517         make_spoolss_q_setprinterdata(&q, mem_ctx, pol, valname, value);
1518
1519         /* Marshall data and send request */
1520         if (!spoolss_io_q_setprinterdata ("", &q, &qbuf, 0) ||
1521             !rpc_api_pipe_req (cli, SPOOLSS_SETPRINTERDATA, &qbuf, &rbuf))
1522                 goto done;
1523
1524         /* Unmarshall response */
1525         if (spoolss_io_r_setprinterdata ("", &r, &rbuf, 0))
1526                 goto done;
1527
1528         result = r.status;
1529
1530 done:
1531         prs_mem_free(&qbuf);
1532         prs_mem_free(&rbuf);
1533
1534         return result;
1535 }
1536
1537
1538 /** @} **/