source3/rpc_server/srv_spoolss.c

   1 #define OLD_NTDOMAIN 1
   2 /*
   3  *  Unix SMB/Netbios implementation.
   4  *  Version 1.9.
   5  *  RPC Pipe client / server routines
   6  *  Copyright (C) Andrew Tridgell              1992-2000,
   7  *  Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
   8  *  Copyright (C) Jean François Micouleau      1998-2000.
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 #include "includes.h"
  26
  27 extern int DEBUGLEVEL;
  28
  29 /********************************************************************
  30  * api_spoolss_open_printer_ex
  31  ********************************************************************/
  32 static BOOL api_spoolss_open_printer_ex(pipes_struct *p)
  33 {
  34         SPOOL_Q_OPEN_PRINTER_EX q_u;
  35         SPOOL_R_OPEN_PRINTER_EX r_u;
  36         UNISTR2 *printername = NULL;
  37         prs_struct *data = &p->in_data.data;
  38         prs_struct *rdata = &p->out_data.rdata;
  39
  40         ZERO_STRUCT(q_u);
  41         ZERO_STRUCT(r_u);
  42
  43         if (!spoolss_io_q_open_printer_ex("", &q_u, data, 0)) {
  44                 DEBUG(0,("spoolss_io_q_open_printer_ex: unable to unmarshall SPOOL_Q_OPEN_PRINTER_EX.\n"));
  45                 return False;
  46         }
  47
  48         if (q_u.printername_ptr != 0)
  49                 printername = &q_u.printername;
  50
  51         r_u.status = _spoolss_open_printer_ex( printername, p,
  52                                                &q_u.printer_default,
  53                                                q_u.user_switch, q_u.user_ctr,
  54                                                &r_u.handle);
  55
  56         /* we _really_ need to switch to talloc() */
  57         free_spoolss_q_open_printer_ex(&q_u);
  58
  59         if (!spoolss_io_r_open_printer_ex("",&r_u,rdata,0)){
  60                 DEBUG(0,("spoolss_io_r_open_printer_ex: unable to marshall SPOOL_R_OPEN_PRINTER_EX.\n"));
  61                 return False;
  62         }
  63
  64         return True;
  65 }
  66
  67 /********************************************************************
  68  * api_spoolss_getprinterdata
  69  *
  70  * called from the spoolss dispatcher
  71  ********************************************************************/
  72 static BOOL api_spoolss_getprinterdata(pipes_struct *p)
  73 {
  74         SPOOL_Q_GETPRINTERDATA q_u;
  75         SPOOL_R_GETPRINTERDATA r_u;
  76         prs_struct *data = &p->in_data.data;
  77         prs_struct *rdata = &p->out_data.rdata;
  78
  79         ZERO_STRUCT(q_u);
  80         ZERO_STRUCT(r_u);
  81
  82         /* read the stream and fill the struct */
  83         if (!spoolss_io_q_getprinterdata("", &q_u, data, 0)) {
  84                 DEBUG(0,("spoolss_io_q_getprinterdata: unable to unmarshall SPOOL_Q_GETPRINTERDATA.\n"));
  85                 return False;
  86         }
  87
  88         r_u.status = _spoolss_getprinterdata( &q_u.handle, &q_u.valuename,
  89                                               q_u.size, &r_u.type, &r_u.size,
  90                                               &r_u.data, &r_u.needed);
  91
  92         if (!spoolss_io_r_getprinterdata("", &r_u, rdata, 0)) {
  93                 DEBUG(0,("spoolss_io_r_getprinterdata: unable to marshall SPOOL_R_GETPRINTERDATA.\n"));
  94                 return False;
  95         }
  96
  97         safe_free(r_u.data);
  98
  99         return True;
 100 }
 101
 102 /********************************************************************
 103  * api_spoolss_deleteprinterdata
 104  *
 105  * called from the spoolss dispatcher
 106  ********************************************************************/
 107 static BOOL api_spoolss_deleteprinterdata(pipes_struct *p)
 108 {
 109         SPOOL_Q_DELETEPRINTERDATA q_u;
 110         SPOOL_R_DELETEPRINTERDATA r_u;
 111         prs_struct *data = &p->in_data.data;
 112         prs_struct *rdata = &p->out_data.rdata;
 113
 114         ZERO_STRUCT(q_u);
 115         ZERO_STRUCT(r_u);
 116
 117         /* read the stream and fill the struct */
 118         if (!spoolss_io_q_deleteprinterdata("", &q_u, data, 0)) {
 119                 DEBUG(0,("spoolss_io_q_deleteprinterdata: unable to unmarshall SPOOL_Q_DELETEPRINTERDATA.\n"));
 120                 return False;
 121         }
 122
 123         r_u.status = _spoolss_deleteprinterdata( &q_u.handle, &q_u.valuename);
 124
 125         if (!spoolss_io_r_deleteprinterdata("", &r_u, rdata, 0)) {
 126                 DEBUG(0,("spoolss_io_r_deleteprinterdata: unable to marshall SPOOL_R_DELETEPRINTERDATA.\n"));
 127                 return False;
 128         }
 129
 130         return True;
 131 }
 132
 133 /********************************************************************
 134  * api_spoolss_closeprinter
 135  *
 136  * called from the spoolss dispatcher
 137  ********************************************************************/
 138 static BOOL api_spoolss_closeprinter(pipes_struct *p)
 139 {
 140         SPOOL_Q_CLOSEPRINTER q_u;
 141         SPOOL_R_CLOSEPRINTER r_u;
 142         prs_struct *data = &p->in_data.data;
 143         prs_struct *rdata = &p->out_data.rdata;
 144
 145         ZERO_STRUCT(q_u);
 146         ZERO_STRUCT(r_u);
 147
 148         if (!spoolss_io_q_closeprinter("", &q_u, data, 0)) {
 149                 DEBUG(0,("spoolss_io_q_closeprinter: unable to unmarshall SPOOL_Q_CLOSEPRINTER.\n"));
 150                 return False;
 151         }
 152
 153         r_u.status = _spoolss_closeprinter(&q_u.handle);
 154         memcpy(&r_u.handle, &q_u.handle, sizeof(r_u.handle));
 155
 156         if (!spoolss_io_r_closeprinter("",&r_u,rdata,0)) {
 157                 DEBUG(0,("spoolss_io_r_closeprinter: unable to marshall SPOOL_R_CLOSEPRINTER.\n"));
 158                 return False;
 159         }
 160
 161         return True;
 162 }
 163
 164 /********************************************************************
 165  * api_spoolss_abortprinter
 166  *
 167  * called from the spoolss dispatcher
 168  ********************************************************************/
 169 static BOOL api_spoolss_abortprinter(pipes_struct *p)
 170 {
 171         SPOOL_Q_ABORTPRINTER q_u;
 172         SPOOL_R_ABORTPRINTER r_u;
 173         prs_struct *data = &p->in_data.data;
 174         prs_struct *rdata = &p->out_data.rdata;
 175
 176         ZERO_STRUCT(q_u);
 177         ZERO_STRUCT(r_u);
 178
 179         if (!spoolss_io_q_abortprinter("", &q_u, data, 0)) {
 180                 DEBUG(0,("spoolss_io_q_abortprinter: unable to unmarshall SPOOL_Q_ABORTPRINTER.\n"));
 181                 return False;
 182         }
 183
 184         r_u.status = _spoolss_abortprinter(&q_u.handle, p);
 185
 186         if (!spoolss_io_r_abortprinter("",&r_u,rdata,0)) {
 187                 DEBUG(0,("spoolss_io_r_abortprinter: unable to marshall SPOOL_R_ABORTPRINTER.\n"));
 188                 return False;
 189         }
 190
 191         return True;
 192 }
 193
 194 /********************************************************************
 195  * api_spoolss_deleteprinter
 196  *
 197  * called from the spoolss dispatcher
 198  ********************************************************************/
 199 static BOOL api_spoolss_deleteprinter(pipes_struct *p)
 200 {
 201         SPOOL_Q_DELETEPRINTER q_u;
 202         SPOOL_R_DELETEPRINTER r_u;
 203         prs_struct *data = &p->in_data.data;
 204         prs_struct *rdata = &p->out_data.rdata;
 205
 206         ZERO_STRUCT(q_u);
 207         ZERO_STRUCT(r_u);
 208
 209         if (!spoolss_io_q_deleteprinter("", &q_u, data, 0)) {
 210                 DEBUG(0,("spoolss_io_q_deleteprinter: unable to unmarshall SPOOL_Q_DELETEPRINTER.\n"));
 211                 return False;
 212         }
 213
 214         r_u.status = _spoolss_deleteprinter(&q_u.handle);
 215         memcpy(&r_u.handle, &q_u.handle, sizeof(r_u.handle));
 216
 217         if (!spoolss_io_r_deleteprinter("",&r_u,rdata,0)) {
 218                 DEBUG(0,("spoolss_io_r_deleteprinter: unable to marshall SPOOL_R_DELETEPRINTER.\n"));
 219                 return False;
 220         }
 221
 222         return True;
 223 }
 224
 225
 226 /********************************************************************
 227  * api_spoolss_rffpcnex
 228  * ReplyFindFirstPrinterChangeNotifyEx
 229  ********************************************************************/
 230 static BOOL api_spoolss_rffpcnex(pipes_struct *p)
 231 {
 232         SPOOL_Q_RFFPCNEX q_u;
 233         SPOOL_R_RFFPCNEX r_u;
 234         prs_struct *data = &p->in_data.data;
 235         prs_struct *rdata = &p->out_data.rdata;
 236
 237         ZERO_STRUCT(q_u);
 238         ZERO_STRUCT(r_u);
 239
 240         if (!spoolss_io_q_rffpcnex("", &q_u, data, 0)) {
 241                 DEBUG(0,("spoolss_io_q_rffpcnex: unable to unmarshall SPOOL_Q_RFFPCNEX.\n"));
 242                 return False;
 243         }
 244
 245         r_u.status = _spoolss_rffpcnex(&q_u.handle, q_u.flags,
 246                                        q_u.options, &q_u.localmachine,
 247                                        q_u.printerlocal, q_u.option);
 248
 249         if (!spoolss_io_r_rffpcnex("", &r_u, rdata, 0)) {
 250                 DEBUG(0,("spoolss_io_r_rffpcnex: unable to marshall SPOOL_R_RFFPCNEX.\n"));
 251                 return False;
 252         }
 253
 254         return True;
 255 }
 256
 257
 258 /********************************************************************
 259  * api_spoolss_rfnpcnex
 260  * ReplyFindNextPrinterChangeNotifyEx
 261  * called from the spoolss dispatcher
 262  *
 263  ********************************************************************/
 264 static BOOL api_spoolss_rfnpcnex(pipes_struct *p)
 265 {
 266         SPOOL_Q_RFNPCNEX q_u;
 267         SPOOL_R_RFNPCNEX r_u;
 268         prs_struct *data = &p->in_data.data;
 269         prs_struct *rdata = &p->out_data.rdata;
 270
 271         ZERO_STRUCT(q_u);
 272         ZERO_STRUCT(r_u);
 273
 274         if (!spoolss_io_q_rfnpcnex("", &q_u, data, 0)) {
 275                 DEBUG(0,("spoolss_io_q_rfnpcnex: unable to unmarshall SPOOL_Q_RFNPCNEX.\n"));
 276                 return False;
 277         }
 278
 279         r_u.status = _spoolss_rfnpcnex(&q_u.handle, q_u.change,
 280                                        q_u.option, data->mem_ctx, &r_u.info);
 281
 282         safe_free(q_u.option);
 283
 284         /* we always have a NOTIFY_INFO struct */
 285         r_u.info_ptr=0x1;
 286
 287         if (!spoolss_io_r_rfnpcnex("", &r_u, rdata, 0)) {
 288                 DEBUG(0,("spoolss_io_r_rfnpcnex: unable to marshall SPOOL_R_RFNPCNEX.\n"));
 289                 return False;
 290         }
 291
 292         safe_free(r_u.info.data);
 293
 294         return True;
 295 }
 296
 297
 298 /********************************************************************
 299  * api_spoolss_enumprinters
 300  * called from the spoolss dispatcher
 301  *
 302  ********************************************************************/
 303 static BOOL api_spoolss_enumprinters(pipes_struct *p)
 304 {
 305         SPOOL_Q_ENUMPRINTERS q_u;
 306         SPOOL_R_ENUMPRINTERS r_u;
 307         prs_struct *data = &p->in_data.data;
 308         prs_struct *rdata = &p->out_data.rdata;
 309
 310         ZERO_STRUCT(q_u);
 311         ZERO_STRUCT(r_u);
 312
 313         if(!new_spoolss_allocate_buffer(&q_u.buffer))
 314                 return False;
 315
 316         if (!spoolss_io_q_enumprinters("", &q_u, data, 0)) {
 317                 DEBUG(0,("spoolss_io_q_enumprinters: unable to unmarshall SPOOL_Q_ENUMPRINTERS.\n"));
 318                 return False;
 319         }
 320
 321         /* that's an [in out] buffer */
 322         new_spoolss_move_buffer(q_u.buffer, &r_u.buffer);
 323
 324         r_u.status = _spoolss_enumprinters( q_u.flags, &q_u.servername, q_u.level,
 325                                             r_u.buffer, q_u.offered,
 326                                             &r_u.needed, &r_u.returned);
 327
 328         if (!new_spoolss_io_r_enumprinters("", &r_u, rdata, 0)) {
 329                 DEBUG(0,("new_spoolss_io_r_enumprinters: unable to marshall SPOOL_R_ENUMPRINTERS.\n"));
 330                 new_spoolss_free_buffer(q_u.buffer);
 331                 return False;
 332         }
 333
 334         new_spoolss_free_buffer(q_u.buffer);
 335
 336         return True;
 337 }
 338
 339 /********************************************************************
 340  * api_spoolss_getprinter
 341  * called from the spoolss dispatcher
 342  *
 343  ********************************************************************/
 344 static BOOL api_spoolss_getprinter(pipes_struct *p)
 345 {
 346         SPOOL_Q_GETPRINTER q_u;
 347         SPOOL_R_GETPRINTER r_u;
 348         prs_struct *data = &p->in_data.data;
 349         prs_struct *rdata = &p->out_data.rdata;
 350
 351         ZERO_STRUCT(q_u);
 352         ZERO_STRUCT(r_u);
 353
 354         if(!new_spoolss_allocate_buffer(&q_u.buffer))
 355                 return False;
 356
 357         if(!spoolss_io_q_getprinter("", &q_u, data, 0)) {
 358                 DEBUG(0,("spoolss_io_q_getprinter: unable to unmarshall SPOOL_Q_GETPRINTER.\n"));
 359                 return False;
 360         }
 361
 362         /* that's an [in out] buffer */
 363         new_spoolss_move_buffer(q_u.buffer, &r_u.buffer);
 364
 365         r_u.status = _spoolss_getprinter(&q_u.handle, q_u.level,
 366                                          r_u.buffer, q_u.offered,
 367                                          &r_u.needed);
 368
 369         if(!spoolss_io_r_getprinter("",&r_u,rdata,0)) {
 370                 DEBUG(0,("spoolss_io_r_getprinter: unable to marshall SPOOL_R_GETPRINTER.\n"));
 371                 new_spoolss_free_buffer(q_u.buffer);
 372                 return False;
 373         }
 374
 375         new_spoolss_free_buffer(q_u.buffer);
 376         return True;
 377 }
 378
 379
 380 /********************************************************************
 381  * api_spoolss_getprinter
 382  * called from the spoolss dispatcher
 383  *
 384  ********************************************************************/
 385 static BOOL api_spoolss_getprinterdriver2(pipes_struct *p)
 386 {
 387         SPOOL_Q_GETPRINTERDRIVER2 q_u;
 388         SPOOL_R_GETPRINTERDRIVER2 r_u;
 389         prs_struct *data = &p->in_data.data;
 390         prs_struct *rdata = &p->out_data.rdata;
 391
 392         ZERO_STRUCT(q_u);
 393         ZERO_STRUCT(r_u);
 394
 395         if(!new_spoolss_allocate_buffer(&q_u.buffer))
 396                 return False;
 397
 398         if(!spoolss_io_q_getprinterdriver2("", &q_u, data, 0)) {
 399                 DEBUG(0,("spoolss_io_q_getprinterdriver2: unable to unmarshall SPOOL_Q_GETPRINTERDRIVER2.\n"));
 400                 return False;
 401         }
 402
 403         /* that's an [in out] buffer */
 404         new_spoolss_move_buffer(q_u.buffer, &r_u.buffer);
 405
 406         r_u.status = _spoolss_getprinterdriver2(&q_u.handle, &q_u.architecture, q_u.level,
 407                                                 q_u.clientmajorversion, q_u.clientminorversion,
 408                                                 r_u.buffer, q_u.offered,
 409                                                 &r_u.needed, &r_u.servermajorversion, &r_u.serverminorversion);
 410
 411         if(!spoolss_io_r_getprinterdriver2("",&r_u,rdata,0)) {
 412                 DEBUG(0,("spoolss_io_r_getprinterdriver2: unable to marshall SPOOL_R_GETPRINTERDRIVER2.\n"));
 413                 new_spoolss_free_buffer(q_u.buffer);
 414                 return False;
 415         }
 416
 417         new_spoolss_free_buffer(q_u.buffer);
 418         return True;
 419 }
 420
 421 /********************************************************************
 422  * api_spoolss_getprinter
 423  * called from the spoolss dispatcher
 424  *
 425  ********************************************************************/
 426 static BOOL api_spoolss_startpageprinter(pipes_struct *p)
 427 {
 428         SPOOL_Q_STARTPAGEPRINTER q_u;
 429         SPOOL_R_STARTPAGEPRINTER r_u;
 430         prs_struct *data = &p->in_data.data;
 431         prs_struct *rdata = &p->out_data.rdata;
 432
 433         ZERO_STRUCT(q_u);
 434         ZERO_STRUCT(r_u);
 435
 436         if(!spoolss_io_q_startpageprinter("", &q_u, data, 0)) {
 437                 DEBUG(0,("spoolss_io_q_startpageprinter: unable to unmarshall SPOOL_Q_STARTPAGEPRINTER.\n"));
 438                 return False;
 439         }
 440
 441         r_u.status = _spoolss_startpageprinter(&q_u.handle);
 442
 443         if(!spoolss_io_r_startpageprinter("",&r_u,rdata,0)) {
 444                 DEBUG(0,("spoolss_io_r_startpageprinter: unable to marshall SPOOL_R_STARTPAGEPRINTER.\n"));
 445                 return False;
 446         }
 447
 448         return True;
 449 }
 450
 451
 452 /********************************************************************
 453  * api_spoolss_getprinter
 454  * called from the spoolss dispatcher
 455  *
 456  ********************************************************************/
 457 static BOOL api_spoolss_endpageprinter(pipes_struct *p)
 458 {
 459         SPOOL_Q_ENDPAGEPRINTER q_u;
 460         SPOOL_R_ENDPAGEPRINTER r_u;
 461         prs_struct *data = &p->in_data.data;
 462         prs_struct *rdata = &p->out_data.rdata;
 463
 464         ZERO_STRUCT(q_u);
 465         ZERO_STRUCT(r_u);
 466
 467         if(!spoolss_io_q_endpageprinter("", &q_u, data, 0)) {
 468                 DEBUG(0,("spoolss_io_q_endpageprinter: unable to unmarshall SPOOL_Q_ENDPAGEPRINTER.\n"));
 469                 return False;
 470         }
 471
 472         r_u.status = _spoolss_endpageprinter(&q_u.handle);
 473
 474         if(!spoolss_io_r_endpageprinter("",&r_u,rdata,0)) {
 475                 DEBUG(0,("spoolss_io_r_endpageprinter: unable to marshall SPOOL_R_ENDPAGEPRINTER.\n"));
 476                 return False;
 477         }
 478
 479         return True;
 480 }
 481
 482 /********************************************************************
 483 ********************************************************************/
 484 static BOOL api_spoolss_startdocprinter(pipes_struct *p)
 485 {
 486         SPOOL_Q_STARTDOCPRINTER q_u;
 487         SPOOL_R_STARTDOCPRINTER r_u;
 488         prs_struct *data = &p->in_data.data;
 489         prs_struct *rdata = &p->out_data.rdata;
 490
 491         ZERO_STRUCT(q_u);
 492         ZERO_STRUCT(r_u);
 493
 494         if(!spoolss_io_q_startdocprinter("", &q_u, data, 0)) {
 495                 DEBUG(0,("spoolss_io_q_startdocprinter: unable to unmarshall SPOOL_Q_STARTDOCPRINTER.\n"));
 496                 return False;
 497         }
 498
 499         r_u.status = _spoolss_startdocprinter(&q_u.handle,
 500                                   q_u.doc_info_container.level, p,
 501                                   &q_u.doc_info_container.docinfo,
 502                                   &r_u.jobid);
 503
 504         if(!spoolss_io_r_startdocprinter("",&r_u,rdata,0)) {
 505                 DEBUG(0,("spoolss_io_r_startdocprinter: unable to marshall SPOOL_R_STARTDOCPRINTER.\n"));
 506                 return False;
 507         }
 508
 509         return True;
 510 }
 511
 512
 513 /********************************************************************
 514 ********************************************************************/
 515 static BOOL api_spoolss_enddocprinter(pipes_struct *p)
 516 {
 517         SPOOL_Q_ENDDOCPRINTER q_u;
 518         SPOOL_R_ENDDOCPRINTER r_u;
 519         prs_struct *data = &p->in_data.data;
 520         prs_struct *rdata = &p->out_data.rdata;
 521
 522         ZERO_STRUCT(q_u);
 523         ZERO_STRUCT(r_u);
 524
 525         if(!spoolss_io_q_enddocprinter("", &q_u, data, 0)) {
 526                 DEBUG(0,("spoolss_io_q_enddocprinter: unable to unmarshall SPOOL_Q_ENDDOCPRINTER.\n"));
 527                 return False;
 528         }
 529
 530         r_u.status = _spoolss_enddocprinter(&q_u.handle);
 531
 532         if(!spoolss_io_r_enddocprinter("",&r_u,rdata,0)) {
 533                 DEBUG(0,("spoolss_io_r_enddocprinter: unable to marshall SPOOL_R_ENDDOCPRINTER.\n"));
 534                 return False;
 535         }
 536
 537         return True;
 538 }
 539
 540
 541 /********************************************************************
 542 ********************************************************************/
 543 static BOOL api_spoolss_writeprinter(pipes_struct *p)
 544 {
 545         SPOOL_Q_WRITEPRINTER q_u;
 546         SPOOL_R_WRITEPRINTER r_u;
 547         prs_struct *data = &p->in_data.data;
 548         prs_struct *rdata = &p->out_data.rdata;
 549
 550         ZERO_STRUCT(q_u);
 551         ZERO_STRUCT(r_u);
 552
 553         if(!spoolss_io_q_writeprinter("", &q_u, data, 0)) {
 554                 DEBUG(0,("spoolss_io_q_writeprinter: unable to unmarshall SPOOL_Q_WRITEPRINTER.\n"));
 555                 return False;
 556         }
 557
 558         r_u.status = _spoolss_writeprinter(&q_u.handle,
 559                                            q_u.buffer_size,
 560                                            q_u.buffer,
 561                                            &q_u.buffer_size2);
 562         r_u.buffer_written = q_u.buffer_size2;
 563         safe_free(q_u.buffer);
 564
 565         if(!spoolss_io_r_writeprinter("",&r_u,rdata,0)) {
 566                 DEBUG(0,("spoolss_io_r_writeprinter: unable to marshall SPOOL_R_WRITEPRINTER.\n"));
 567                 return False;
 568         }
 569
 570         return True;
 571 }
 572
 573 /****************************************************************************
 574
 575 ****************************************************************************/
 576 static BOOL api_spoolss_setprinter(pipes_struct *p)
 577 {
 578         SPOOL_Q_SETPRINTER q_u;
 579         SPOOL_R_SETPRINTER r_u;
 580         prs_struct *data = &p->in_data.data;
 581         prs_struct *rdata = &p->out_data.rdata;
 582
 583         ZERO_STRUCT(q_u);
 584         ZERO_STRUCT(r_u);
 585
 586         if(!spoolss_io_q_setprinter("", &q_u, data, 0)) {
 587                 DEBUG(0,("spoolss_io_q_setprinter: unable to unmarshall SPOOL_Q_SETPRINTER.\n"));
 588                 return False;
 589         }
 590
 591         r_u.status = _spoolss_setprinter(&q_u.handle, q_u.level, &q_u.info,
 592                                          q_u.devmode_ctr, q_u.secdesc_ctr,
 593                                          q_u.command, p);
 594
 595         if(!spoolss_io_r_setprinter("",&r_u,rdata,0)) {
 596                 DEBUG(0,("spoolss_io_r_setprinter: unable to marshall SPOOL_R_SETPRINTER.\n"));
 597                 free_spoolss_q_setprinter(&q_u);
 598                 return False;
 599         }
 600
 601         /* Free anything allocated in the unparse. */
 602         free_spoolss_q_setprinter(&q_u);
 603
 604         return True;
 605 }
 606
 607 /****************************************************************************
 608 ****************************************************************************/
 609 static BOOL api_spoolss_fcpn(pipes_struct *p)
 610 {
 611         SPOOL_Q_FCPN q_u;
 612         SPOOL_R_FCPN r_u;
 613         prs_struct *data = &p->in_data.data;
 614         prs_struct *rdata = &p->out_data.rdata;
 615
 616         ZERO_STRUCT(q_u);
 617         ZERO_STRUCT(r_u);
 618
 619         if(!spoolss_io_q_fcpn("", &q_u, data, 0)) {
 620                 DEBUG(0,("spoolss_io_q_fcpn: unable to unmarshall SPOOL_Q_FCPN.\n"));
 621                 return False;
 622         }
 623
 624         r_u.status = _spoolss_fcpn(&q_u.handle);
 625
 626         if(!spoolss_io_r_fcpn("",&r_u,rdata,0)) {
 627                 DEBUG(0,("spoolss_io_r_fcpn: unable to marshall SPOOL_R_FCPN.\n"));
 628                 return False;
 629         }
 630
 631         return True;
 632 }
 633
 634
 635 /****************************************************************************
 636 ****************************************************************************/
 637 static BOOL api_spoolss_addjob(pipes_struct *p)
 638 {
 639         SPOOL_Q_ADDJOB q_u;
 640         SPOOL_R_ADDJOB r_u;
 641         prs_struct *data = &p->in_data.data;
 642         prs_struct *rdata = &p->out_data.rdata;
 643
 644         ZERO_STRUCT(q_u);
 645         ZERO_STRUCT(r_u);
 646
 647         if(!new_spoolss_allocate_buffer(&q_u.buffer))
 648                 return False;
 649
 650         if(!spoolss_io_q_addjob("", &q_u, data, 0)) {
 651                 DEBUG(0,("spoolss_io_q_addjob: unable to unmarshall SPOOL_Q_ADDJOB.\n"));
 652                 return False;
 653         }
 654
 655         /* that's an [in out] buffer (despite appearences to the contrary) */
 656         new_spoolss_move_buffer(q_u.buffer, &r_u.buffer);
 657
 658         r_u.status = _spoolss_addjob(&q_u.handle, q_u.level,
 659                                      r_u.buffer, q_u.offered, &r_u.needed);
 660
 661         if(!spoolss_io_r_addjob("",&r_u,rdata,0)) {
 662                 DEBUG(0,("spoolss_io_r_addjob: unable to marshall SPOOL_R_ADDJOB.\n"));
 663                 new_spoolss_free_buffer(q_u.buffer);
 664                 return False;
 665         }
 666
 667         new_spoolss_free_buffer(q_u.buffer);
 668
 669         return True;
 670 }
 671
 672
 673 /****************************************************************************
 674 ****************************************************************************/
 675 static BOOL api_spoolss_enumjobs(pipes_struct *p)
 676 {
 677         SPOOL_Q_ENUMJOBS q_u;
 678         SPOOL_R_ENUMJOBS r_u;
 679         prs_struct *data = &p->in_data.data;
 680         prs_struct *rdata = &p->out_data.rdata;
 681
 682         ZERO_STRUCT(q_u);
 683         ZERO_STRUCT(r_u);
 684
 685         if(!new_spoolss_allocate_buffer(&q_u.buffer))
 686                 return False;
 687
 688         if (!spoolss_io_q_enumjobs("", &q_u, data, 0)) {
 689                 DEBUG(0,("spoolss_io_q_enumjobs: unable to unmarshall SPOOL_Q_ENUMJOBS.\n"));
 690                 return False;
 691         }
 692
 693         /* that's an [in out] buffer */
 694         new_spoolss_move_buffer(q_u.buffer, &r_u.buffer);
 695
 696         r_u.status = _spoolss_enumjobs(&q_u.handle, q_u.firstjob, q_u.numofjobs, q_u.level,
 697                                         r_u.buffer, q_u.offered,
 698                                         &r_u.needed, &r_u.returned);
 699
 700         if (!spoolss_io_r_enumjobs("",&r_u,rdata,0)) {
 701                 DEBUG(0,("spoolss_io_r_enumjobs: unable to marshall SPOOL_R_ENUMJOBS.\n"));
 702                 new_spoolss_free_buffer(q_u.buffer);
 703                 return False;
 704         }
 705
 706         new_spoolss_free_buffer(q_u.buffer);
 707
 708         return True;
 709 }
 710
 711
 712 /****************************************************************************
 713 ****************************************************************************/
 714 static BOOL api_spoolss_schedulejob(pipes_struct *p)
 715 {
 716         SPOOL_Q_SCHEDULEJOB q_u;
 717         SPOOL_R_SCHEDULEJOB r_u;
 718         prs_struct *data = &p->in_data.data;
 719         prs_struct *rdata = &p->out_data.rdata;
 720
 721         ZERO_STRUCT(q_u);
 722         ZERO_STRUCT(r_u);
 723
 724         if(!spoolss_io_q_schedulejob("", &q_u, data, 0)) {
 725                 DEBUG(0,("spoolss_io_q_schedulejob: unable to unmarshall SPOOL_Q_SCHEDULEJOB.\n"));
 726                 return False;
 727         }
 728
 729         r_u.status = _spoolss_schedulejob(&q_u.handle, q_u.jobid);
 730
 731         if(!spoolss_io_r_schedulejob("",&r_u,rdata,0)) {
 732                 DEBUG(0,("spoolss_io_r_schedulejob: unable to marshall SPOOL_R_SCHEDULEJOB.\n"));
 733                 return False;
 734         }
 735
 736         return True;
 737 }
 738
 739 /****************************************************************************
 740 ****************************************************************************/
 741 static BOOL api_spoolss_setjob(pipes_struct *p)
 742 {
 743         SPOOL_Q_SETJOB q_u;
 744         SPOOL_R_SETJOB r_u;
 745         prs_struct *data = &p->in_data.data;
 746         prs_struct *rdata = &p->out_data.rdata;
 747
 748         ZERO_STRUCT(q_u);
 749         ZERO_STRUCT(r_u);
 750
 751         if(!spoolss_io_q_setjob("", &q_u, data, 0)) {
 752                 DEBUG(0,("spoolss_io_q_setjob: unable to unmarshall SPOOL_Q_SETJOB.\n"));
 753                 return False;
 754         }
 755
 756         r_u.status = _spoolss_setjob(&q_u.handle, q_u.jobid,
 757                                 q_u.level, p, &q_u.ctr, q_u.command);
 758
 759         if(!spoolss_io_r_setjob("",&r_u,rdata,0)) {
 760                 DEBUG(0,("spoolss_io_r_setjob: unable to marshall SPOOL_R_SETJOB.\n"));
 761                 return False;
 762         }
 763
 764         return True;
 765 }
 766
 767 /****************************************************************************
 768 ****************************************************************************/
 769
 770 static BOOL api_spoolss_enumprinterdrivers(pipes_struct *p)
 771 {
 772         SPOOL_Q_ENUMPRINTERDRIVERS q_u;
 773         SPOOL_R_ENUMPRINTERDRIVERS r_u;
 774         prs_struct *data = &p->in_data.data;
 775         prs_struct *rdata = &p->out_data.rdata;
 776
 777         ZERO_STRUCT(q_u);
 778         ZERO_STRUCT(r_u);
 779
 780         if(!new_spoolss_allocate_buffer(&q_u.buffer))
 781                 return False;
 782
 783         if (!spoolss_io_q_enumprinterdrivers("", &q_u, data, 0)) {
 784                 DEBUG(0,("spoolss_io_q_enumprinterdrivers: unable to unmarshall SPOOL_Q_ENUMPRINTERDRIVERS.\n"));
 785                 return False;
 786         }
 787
 788         /* that's an [in out] buffer */
 789         new_spoolss_move_buffer(q_u.buffer, &r_u.buffer);
 790
 791         r_u.status = _spoolss_enumprinterdrivers(&q_u.name, &q_u.environment, q_u.level,
 792                                                  r_u.buffer, q_u.offered,
 793                                                  &r_u.needed, &r_u.returned);
 794
 795         if (!new_spoolss_io_r_enumprinterdrivers("",&r_u,rdata,0)) {
 796                 DEBUG(0,("new_spoolss_io_r_enumprinterdrivers: unable to marshall SPOOL_R_ENUMPRINTERDRIVERS.\n"));
 797                 new_spoolss_free_buffer(q_u.buffer);
 798                 return False;
 799         }
 800
 801         new_spoolss_free_buffer(q_u.buffer);
 802
 803         return True;
 804 }
 805
 806
 807 /****************************************************************************
 808 ****************************************************************************/
 809 static BOOL api_spoolss_getform(pipes_struct *p)
 810 {
 811         SPOOL_Q_GETFORM q_u;
 812         SPOOL_R_GETFORM r_u;
 813         prs_struct *data = &p->in_data.data;
 814         prs_struct *rdata = &p->out_data.rdata;
 815
 816         ZERO_STRUCT(q_u);
 817         ZERO_STRUCT(r_u);
 818
 819         if(!new_spoolss_allocate_buffer(&q_u.buffer))
 820                 return False;
 821
 822         if (!spoolss_io_q_getform("", &q_u, data, 0)) {
 823                 DEBUG(0,("spoolss_io_q_getform: unable to unmarshall SPOOL_Q_GETFORM.\n"));
 824                 return False;
 825         }
 826
 827         /* that's an [in out] buffer */
 828         new_spoolss_move_buffer(q_u.buffer, &r_u.buffer);
 829
 830         r_u.status = _spoolss_getform(&q_u.handle, q_u.level,
 831                                 &q_u.formname, r_u.buffer, q_u.offered, &r_u.needed);
 832
 833         if (!new_spoolss_io_r_getform("",&r_u,rdata,0)) {
 834                 DEBUG(0,("new_spoolss_io_r_getform: unable to marshall SPOOL_R_GETFORM.\n"));
 835                 new_spoolss_free_buffer(q_u.buffer);
 836                 return False;
 837         }
 838
 839         new_spoolss_free_buffer(q_u.buffer);
 840
 841         return True;
 842 }
 843
 844 /****************************************************************************
 845 ****************************************************************************/
 846 static BOOL api_spoolss_enumforms(pipes_struct *p)
 847 {
 848         SPOOL_Q_ENUMFORMS q_u;
 849         SPOOL_R_ENUMFORMS r_u;
 850         prs_struct *data = &p->in_data.data;
 851         prs_struct *rdata = &p->out_data.rdata;
 852
 853         ZERO_STRUCT(q_u);
 854         ZERO_STRUCT(r_u);
 855
 856         if(!new_spoolss_allocate_buffer(&q_u.buffer))
 857                 return False;
 858
 859         if (!spoolss_io_q_enumforms("", &q_u, data, 0)) {
 860                 DEBUG(0,("spoolss_io_q_enumforms: unable to unmarshall SPOOL_Q_ENUMFORMS.\n"));
 861                 return False;
 862         }
 863
 864         /* that's an [in out] buffer */
 865         new_spoolss_move_buffer(q_u.buffer, &r_u.buffer);
 866
 867         r_u.status = _new_spoolss_enumforms(&q_u.handle, q_u.level,
 868                                 r_u.buffer, q_u.offered,
 869                                 &r_u.needed, &r_u.numofforms);
 870
 871         if (!new_spoolss_io_r_enumforms("",&r_u,rdata,0)) {
 872                 DEBUG(0,("new_spoolss_io_r_enumforms: unable to marshall SPOOL_R_ENUMFORMS.\n"));
 873                 new_spoolss_free_buffer(q_u.buffer);
 874                 return False;
 875         }
 876
 877         new_spoolss_free_buffer(q_u.buffer);
 878
 879         return True;
 880 }
 881
 882
 883 /****************************************************************************
 884 ****************************************************************************/
 885 static BOOL api_spoolss_enumports(pipes_struct *p)
 886 {
 887         SPOOL_Q_ENUMPORTS q_u;
 888         SPOOL_R_ENUMPORTS r_u;
 889         prs_struct *data = &p->in_data.data;
 890         prs_struct *rdata = &p->out_data.rdata;
 891
 892         ZERO_STRUCT(q_u);
 893         ZERO_STRUCT(r_u);
 894
 895         if(!new_spoolss_allocate_buffer(&q_u.buffer))
 896                 return False;
 897
 898         if(!spoolss_io_q_enumports("", &q_u, data, 0)) {
 899                 DEBUG(0,("spoolss_io_q_enumports: unable to unmarshall SPOOL_Q_ENUMPORTS.\n"));
 900                 return False;
 901         }
 902
 903         /* that's an [in out] buffer */
 904         new_spoolss_move_buffer(q_u.buffer, &r_u.buffer);
 905
 906         r_u.status = _spoolss_enumports(&q_u.name, q_u.level,
 907                                         r_u.buffer, q_u.offered,
 908                                         &r_u.needed, &r_u.returned);
 909
 910         if (!new_spoolss_io_r_enumports("",&r_u,rdata,0)) {
 911                 DEBUG(0,("new_spoolss_io_r_enumports: unable to marshall SPOOL_R_ENUMPORTS.\n"));
 912                 new_spoolss_free_buffer(q_u.buffer);
 913                 return False;
 914         }
 915
 916         new_spoolss_free_buffer(q_u.buffer);
 917
 918         return True;
 919 }
 920
 921
 922 /****************************************************************************
 923 ****************************************************************************/
 924 static BOOL api_spoolss_addprinterex(pipes_struct *p)
 925 {
 926         SPOOL_Q_ADDPRINTEREX q_u;
 927         SPOOL_R_ADDPRINTEREX r_u;
 928         prs_struct *data = &p->in_data.data;
 929         prs_struct *rdata = &p->out_data.rdata;
 930
 931         ZERO_STRUCT(q_u);
 932         ZERO_STRUCT(r_u);
 933
 934         if(!spoolss_io_q_addprinterex("", &q_u, data, 0)) {
 935                 DEBUG(0,("spoolss_io_q_addprinterex: unable to unmarshall SPOOL_Q_ADDPRINTEREX.\n"));
 936                 return False;
 937         }
 938
 939         r_u.status = _spoolss_addprinterex(&q_u.server_name,
 940                                 q_u.level, &q_u.info,
 941                                 q_u.unk0, q_u.unk1, q_u.unk2, q_u.unk3,
 942                                 q_u.user_switch, &q_u.user_ctr,
 943                                 &r_u.handle);
 944
 945         if(!spoolss_io_r_addprinterex("", &r_u, rdata, 0)) {
 946                 DEBUG(0,("spoolss_io_r_addprinterex: unable to marshall SPOOL_R_ADDPRINTEREX.\n"));
 947                 return False;
 948         }
 949
 950         if (q_u.info.info_ptr!=0) {
 951                 switch (q_u.info.level) {
 952                         case 1:
 953                                 safe_free(q_u.info.info_1);
 954                                 break;
 955                         case 2:
 956                                 safe_free(q_u.info.info_2);
 957                                 break;
 958                 }
 959         }
 960
 961         return True;
 962 }
 963
 964 /****************************************************************************
 965 ****************************************************************************/
 966 static BOOL api_spoolss_addprinterdriver(pipes_struct *p)
 967 {
 968         SPOOL_Q_ADDPRINTERDRIVER q_u;
 969         SPOOL_R_ADDPRINTERDRIVER r_u;
 970         prs_struct *data = &p->in_data.data;
 971         prs_struct *rdata = &p->out_data.rdata;
 972
 973         ZERO_STRUCT(q_u);
 974         ZERO_STRUCT(r_u);
 975
 976         if(!spoolss_io_q_addprinterdriver("", &q_u, data, 0)) {
 977                 DEBUG(0,("spoolss_io_q_addprinterdriver: unable to unmarshall SPOOL_Q_ADDPRINTERDRIVER.\n"));
 978                 free_spoolss_q_addprinterdriver(&q_u);
 979                 return False;
 980         }
 981
 982         r_u.status = _spoolss_addprinterdriver(p, &q_u.server_name, q_u.level, &q_u.info);
 983
 984         if(!spoolss_io_r_addprinterdriver("", &r_u, rdata, 0)) {
 985                 DEBUG(0,("spoolss_io_r_addprinterdriver: unable to marshall SPOOL_R_ADDPRINTERDRIVER.\n"));
 986                 free_spoolss_q_addprinterdriver(&q_u);
 987                 return False;
 988         }
 989
 990         free_spoolss_q_addprinterdriver(&q_u);
 991
 992         return True;
 993 }
 994
 995 /****************************************************************************
 996 ****************************************************************************/
 997 static BOOL api_spoolss_getprinterdriverdirectory(pipes_struct *p)
 998 {
 999         SPOOL_Q_GETPRINTERDRIVERDIR q_u;
1000         SPOOL_R_GETPRINTERDRIVERDIR r_u;
1001         prs_struct *data = &p->in_data.data;
1002         prs_struct *rdata = &p->out_data.rdata;
1003
1004         ZERO_STRUCT(q_u);
1005         ZERO_STRUCT(r_u);
1006
1007         if(!new_spoolss_allocate_buffer(&q_u.buffer))
1008                 return False;
1009
1010         if(!spoolss_io_q_getprinterdriverdir("", &q_u, data, 0)) {
1011                 DEBUG(0,("spoolss_io_q_getprinterdriverdir: unable to unmarshall SPOOL_Q_GETPRINTERDRIVERDIR.\n"));
1012                 return False;
1013         }
1014
1015         /* that's an [in out] buffer */
1016         new_spoolss_move_buffer(q_u.buffer, &r_u.buffer);
1017
1018         r_u.status = _spoolss_getprinterdriverdirectory(&q_u.name, &q_u.environment, q_u.level,
1019                                                         r_u.buffer, q_u.offered,
1020                                                         &r_u.needed);
1021
1022         if(!spoolss_io_r_getprinterdriverdir("", &r_u, rdata, 0)) {
1023                 DEBUG(0,("spoolss_io_r_getprinterdriverdir: unable to marshall SPOOL_R_GETPRINTERDRIVERDIR.\n"));
1024                 new_spoolss_free_buffer(q_u.buffer);
1025                 return False;
1026         }
1027
1028         new_spoolss_free_buffer(q_u.buffer);
1029
1030         return True;
1031 }
1032
1033 /****************************************************************************
1034 ****************************************************************************/
1035 static BOOL api_spoolss_enumprinterdata(pipes_struct *p)
1036 {
1037         SPOOL_Q_ENUMPRINTERDATA q_u;
1038         SPOOL_R_ENUMPRINTERDATA r_u;
1039         prs_struct *data = &p->in_data.data;
1040         prs_struct *rdata = &p->out_data.rdata;
1041
1042         ZERO_STRUCT(q_u);
1043         ZERO_STRUCT(r_u);
1044
1045         if(!spoolss_io_q_enumprinterdata("", &q_u, data, 0)) {
1046                 DEBUG(0,("spoolss_io_q_enumprinterdata: unable to unmarshall SPOOL_Q_ENUMPRINTERDATA.\n"));
1047                 return False;
1048         }
1049
1050         r_u.status = _spoolss_enumprinterdata(&q_u.handle, q_u.index, q_u.valuesize, q_u.datasize,
1051                                                 &r_u.valuesize, &r_u.value, &r_u.realvaluesize,
1052                                                 &r_u.type,
1053                                                 &r_u.datasize, &r_u.data, &r_u.realdatasize);
1054
1055         if(!spoolss_io_r_enumprinterdata("", &r_u, rdata, 0)) {
1056                 DEBUG(0,("spoolss_io_r_enumprinterdata: unable to marshall SPOOL_R_ENUMPRINTERDATA.\n"));
1057                 safe_free(r_u.value);
1058                 safe_free(r_u.data);
1059                 return False;
1060         }
1061
1062         safe_free(r_u.value);
1063         safe_free(r_u.data);
1064
1065         return True;
1066 }
1067
1068 /****************************************************************************
1069 ****************************************************************************/
1070 static BOOL api_spoolss_setprinterdata(pipes_struct *p)
1071 {
1072         SPOOL_Q_SETPRINTERDATA q_u;
1073         SPOOL_R_SETPRINTERDATA r_u;
1074         prs_struct *data = &p->in_data.data;
1075         prs_struct *rdata = &p->out_data.rdata;
1076
1077         ZERO_STRUCT(q_u);
1078         ZERO_STRUCT(r_u);
1079
1080         if(!spoolss_io_q_setprinterdata("", &q_u, data, 0)) {
1081                 DEBUG(0,("spoolss_io_q_setprinterdata: unable to unmarshall SPOOL_Q_SETPRINTERDATA.\n"));
1082                 return False;
1083         }
1084
1085         r_u.status = _spoolss_setprinterdata(&q_u.handle,
1086                                 &q_u.value, q_u.type, q_u.max_len,
1087                                 q_u.data, q_u.real_len, q_u.numeric_data);
1088
1089         free_spoolss_q_setprinterdata(&q_u);
1090
1091         if(!spoolss_io_r_setprinterdata("", &r_u, rdata, 0)) {
1092                 DEBUG(0,("spoolss_io_r_setprinterdata: unable to marshall SPOOL_R_SETPRINTERDATA.\n"));
1093                 return False;
1094         }
1095
1096         return True;
1097 }
1098
1099 /****************************************************************************
1100 ****************************************************************************/
1101 static BOOL api_spoolss_addform(pipes_struct *p)
1102 {
1103         SPOOL_Q_ADDFORM q_u;
1104         SPOOL_R_ADDFORM r_u;
1105         prs_struct *data = &p->in_data.data;
1106         prs_struct *rdata = &p->out_data.rdata;
1107
1108         ZERO_STRUCT(q_u);
1109         ZERO_STRUCT(r_u);
1110
1111         if(!spoolss_io_q_addform("", &q_u, data, 0)) {
1112                 DEBUG(0,("spoolss_io_q_addform: unable to unmarshall SPOOL_Q_ADDFORM.\n"));
1113                 return False;
1114         }
1115
1116         r_u.status = _spoolss_addform(&q_u.handle, q_u.level, &q_u.form);
1117
1118         if(!spoolss_io_r_addform("", &r_u, rdata, 0)) {
1119                 DEBUG(0,("spoolss_io_r_addform: unable to marshall SPOOL_R_ADDFORM.\n"));
1120                 return False;
1121         }
1122
1123         return True;
1124 }
1125
1126 /****************************************************************************
1127 ****************************************************************************/
1128 static BOOL api_spoolss_deleteform(pipes_struct *p)
1129 {
1130         SPOOL_Q_DELETEFORM q_u;
1131         SPOOL_R_DELETEFORM r_u;
1132         prs_struct *data = &p->in_data.data;
1133         prs_struct *rdata = &p->out_data.rdata;
1134
1135         ZERO_STRUCT(q_u);
1136         ZERO_STRUCT(r_u);
1137
1138         if(!spoolss_io_q_deleteform("", &q_u, data, 0)) {
1139                 DEBUG(0,("spoolss_io_q_deleteform: unable to unmarshall SPOOL_Q_DELETEFORM.\n"));
1140                 return False;
1141         }
1142
1143         r_u.status = _spoolss_deleteform(&q_u.handle, &q_u.name);
1144
1145         if(!spoolss_io_r_deleteform("", &r_u, rdata, 0)) {
1146                 DEBUG(0,("spoolss_io_r_deleteform: unable to marshall SPOOL_R_DELETEFORM.\n"));
1147                 return False;
1148         }
1149
1150         return True;
1151 }
1152
1153 /****************************************************************************
1154 ****************************************************************************/
1155 static BOOL api_spoolss_setform(pipes_struct *p)
1156 {
1157         SPOOL_Q_SETFORM q_u;
1158         SPOOL_R_SETFORM r_u;
1159         prs_struct *data = &p->in_data.data;
1160         prs_struct *rdata = &p->out_data.rdata;
1161
1162         ZERO_STRUCT(q_u);
1163         ZERO_STRUCT(r_u);
1164
1165         if(!spoolss_io_q_setform("", &q_u, data, 0)) {
1166                 DEBUG(0,("spoolss_io_q_setform: unable to unmarshall SPOOL_Q_SETFORM.\n"));
1167                 return False;
1168         }
1169
1170         r_u.status = _spoolss_setform(&q_u.handle, &q_u.name, q_u.level, &q_u.form);
1171
1172         if(!spoolss_io_r_setform("", &r_u, rdata, 0)) {
1173                 DEBUG(0,("spoolss_io_r_setform: unable to marshall SPOOL_R_SETFORM.\n"));
1174                 return False;
1175         }
1176
1177         return True;
1178 }
1179
1180 /****************************************************************************
1181 ****************************************************************************/
1182 static BOOL api_spoolss_enumprintprocessors(pipes_struct *p)
1183 {
1184         SPOOL_Q_ENUMPRINTPROCESSORS q_u;
1185         SPOOL_R_ENUMPRINTPROCESSORS r_u;
1186         prs_struct *data = &p->in_data.data;
1187         prs_struct *rdata = &p->out_data.rdata;
1188
1189         ZERO_STRUCT(q_u);
1190         ZERO_STRUCT(r_u);
1191
1192         if(!new_spoolss_allocate_buffer(&q_u.buffer))
1193                 return False;
1194
1195         if(!spoolss_io_q_enumprintprocessors("", &q_u, data, 0)) {
1196                 DEBUG(0,("spoolss_io_q_enumprintprocessors: unable to unmarshall SPOOL_Q_ENUMPRINTPROCESSORS.\n"));
1197                 return False;
1198         }
1199
1200         /* that's an [in out] buffer */
1201         new_spoolss_move_buffer(q_u.buffer, &r_u.buffer);
1202
1203         r_u.status = _spoolss_enumprintprocessors(&q_u.name, &q_u.environment, q_u.level,
1204                                                   r_u.buffer, q_u.offered,
1205                                                   &r_u.needed, &r_u.returned);
1206
1207         if(!spoolss_io_r_enumprintprocessors("", &r_u, rdata, 0)) {
1208                 DEBUG(0,("spoolss_io_r_enumprintprocessors: unable to marshall SPOOL_R_ENUMPRINTPROCESSORS.\n"));
1209                 new_spoolss_free_buffer(q_u.buffer);
1210                 return False;
1211         }
1212
1213         new_spoolss_free_buffer(q_u.buffer);
1214
1215         return True;
1216 }
1217
1218 /****************************************************************************
1219 ****************************************************************************/
1220 static BOOL api_spoolss_enumprintprocdatatypes(pipes_struct *p)
1221 {
1222         SPOOL_Q_ENUMPRINTPROCDATATYPES q_u;
1223         SPOOL_R_ENUMPRINTPROCDATATYPES r_u;
1224         prs_struct *data = &p->in_data.data;
1225         prs_struct *rdata = &p->out_data.rdata;
1226
1227         ZERO_STRUCT(q_u);
1228         ZERO_STRUCT(r_u);
1229
1230         if(!new_spoolss_allocate_buffer(&q_u.buffer))
1231                 return False;
1232
1233         if(!spoolss_io_q_enumprintprocdatatypes("", &q_u, data, 0)) {
1234                 DEBUG(0,("spoolss_io_q_enumprintprocdatatypes: unable to unmarshall SPOOL_Q_ENUMPRINTPROCDATATYPES.\n"));
1235                 return False;
1236         }
1237
1238         /* that's an [in out] buffer */
1239         new_spoolss_move_buffer(q_u.buffer, &r_u.buffer);
1240
1241         r_u.status = _spoolss_enumprintprocdatatypes(&q_u.name, &q_u.processor, q_u.level,
1242                                                      r_u.buffer, q_u.offered,
1243                                                      &r_u.needed, &r_u.returned);
1244
1245         if(!spoolss_io_r_enumprintprocdatatypes("", &r_u, rdata, 0)) {
1246                 DEBUG(0,("spoolss_io_r_enumprintprocdatatypes: unable to marshall SPOOL_R_ENUMPRINTPROCDATATYPES.\n"));
1247                 new_spoolss_free_buffer(q_u.buffer);
1248                 return False;
1249         }
1250
1251         new_spoolss_free_buffer(q_u.buffer);
1252
1253         return True;
1254 }
1255
1256 /****************************************************************************
1257 ****************************************************************************/
1258 static BOOL api_spoolss_enumprintmonitors(pipes_struct *p)
1259 {
1260         SPOOL_Q_ENUMPRINTMONITORS q_u;
1261         SPOOL_R_ENUMPRINTMONITORS r_u;
1262         prs_struct *data = &p->in_data.data;
1263         prs_struct *rdata = &p->out_data.rdata;
1264
1265         ZERO_STRUCT(q_u);
1266         ZERO_STRUCT(r_u);
1267
1268         if(!new_spoolss_allocate_buffer(&q_u.buffer))
1269                 return False;
1270
1271         if (!spoolss_io_q_enumprintmonitors("", &q_u, data, 0)) {
1272                 DEBUG(0,("spoolss_io_q_enumprintmonitors: unable to unmarshall SPOOL_Q_ENUMPRINTMONITORS.\n"));
1273                 return False;
1274         }
1275
1276         /* that's an [in out] buffer */
1277         new_spoolss_move_buffer(q_u.buffer, &r_u.buffer);
1278
1279         r_u.status = _spoolss_enumprintmonitors(&q_u.name, q_u.level,
1280                                                 r_u.buffer, q_u.offered,
1281                                                 &r_u.needed, &r_u.returned);
1282
1283         if (!spoolss_io_r_enumprintmonitors("", &r_u, rdata, 0)) {
1284                 DEBUG(0,("spoolss_io_r_enumprintmonitors: unable to marshall SPOOL_R_ENUMPRINTMONITORS.\n"));
1285                 new_spoolss_free_buffer(q_u.buffer);
1286                 return False;
1287         }
1288
1289         new_spoolss_free_buffer(q_u.buffer);
1290
1291         return True;
1292 }
1293
1294 /****************************************************************************
1295 ****************************************************************************/
1296 static BOOL api_spoolss_getjob(pipes_struct *p)
1297 {
1298         SPOOL_Q_GETJOB q_u;
1299         SPOOL_R_GETJOB r_u;
1300         prs_struct *data = &p->in_data.data;
1301         prs_struct *rdata = &p->out_data.rdata;
1302
1303         if(!new_spoolss_allocate_buffer(&q_u.buffer))
1304                 return False;
1305
1306         if(!spoolss_io_q_getjob("", &q_u, data, 0)) {
1307                 DEBUG(0,("spoolss_io_q_getjob: unable to unmarshall SPOOL_Q_GETJOB.\n"));
1308                 return False;
1309         }
1310
1311         /* that's an [in out] buffer */
1312         new_spoolss_move_buffer(q_u.buffer, &r_u.buffer);
1313
1314         r_u.status = _spoolss_getjob(&q_u.handle, q_u.jobid, q_u.level,
1315                                         r_u.buffer, q_u.offered,
1316                                         &r_u.needed);
1317
1318         if(!spoolss_io_r_getjob("",&r_u,rdata,0)) {
1319                 DEBUG(0,("spoolss_io_r_getjob: unable to marshall SPOOL_R_GETJOB.\n"));
1320                 new_spoolss_free_buffer(q_u.buffer);
1321                 return False;
1322         }
1323
1324         new_spoolss_free_buffer(q_u.buffer);
1325         return True;
1326 }
1327
1328 /*******************************************************************
1329 \pipe\spoolss commands
1330 ********************************************************************/
1331 struct api_struct api_spoolss_cmds[] =
1332 {
1333  {"SPOOLSS_OPENPRINTEREX",             SPOOLSS_OPENPRINTEREX,             api_spoolss_open_printer_ex           },
1334  {"SPOOLSS_GETPRINTERDATA",            SPOOLSS_GETPRINTERDATA,            api_spoolss_getprinterdata            },
1335  {"SPOOLSS_CLOSEPRINTER",              SPOOLSS_CLOSEPRINTER,              api_spoolss_closeprinter              },
1336  {"SPOOLSS_DELETEPRINTER",             SPOOLSS_DELETEPRINTER,             api_spoolss_deleteprinter             },
1337  {"SPOOLSS_ABORTPRINTER",              SPOOLSS_ABORTPRINTER,              api_spoolss_abortprinter              },
1338  {"SPOOLSS_RFFPCNEX",                  SPOOLSS_RFFPCNEX,                  api_spoolss_rffpcnex                  },
1339  {"SPOOLSS_RFNPCNEX",                  SPOOLSS_RFNPCNEX,                  api_spoolss_rfnpcnex                  },
1340  {"SPOOLSS_ENUMPRINTERS",              SPOOLSS_ENUMPRINTERS,              api_spoolss_enumprinters              },
1341  {"SPOOLSS_GETPRINTER",                SPOOLSS_GETPRINTER,                api_spoolss_getprinter                },
1342  {"SPOOLSS_GETPRINTERDRIVER2",         SPOOLSS_GETPRINTERDRIVER2,         api_spoolss_getprinterdriver2         },
1343  {"SPOOLSS_STARTPAGEPRINTER",          SPOOLSS_STARTPAGEPRINTER,          api_spoolss_startpageprinter          },
1344  {"SPOOLSS_ENDPAGEPRINTER",            SPOOLSS_ENDPAGEPRINTER,            api_spoolss_endpageprinter            },
1345  {"SPOOLSS_STARTDOCPRINTER",           SPOOLSS_STARTDOCPRINTER,           api_spoolss_startdocprinter           },
1346  {"SPOOLSS_ENDDOCPRINTER",             SPOOLSS_ENDDOCPRINTER,             api_spoolss_enddocprinter             },
1347  {"SPOOLSS_WRITEPRINTER",              SPOOLSS_WRITEPRINTER,              api_spoolss_writeprinter              },
1348  {"SPOOLSS_SETPRINTER",                SPOOLSS_SETPRINTER,                api_spoolss_setprinter                },
1349  {"SPOOLSS_FCPN",                      SPOOLSS_FCPN,                      api_spoolss_fcpn                      },
1350  {"SPOOLSS_ADDJOB",                    SPOOLSS_ADDJOB,                    api_spoolss_addjob                    },
1351  {"SPOOLSS_ENUMJOBS",                  SPOOLSS_ENUMJOBS,                  api_spoolss_enumjobs                  },
1352  {"SPOOLSS_SCHEDULEJOB",               SPOOLSS_SCHEDULEJOB,               api_spoolss_schedulejob               },
1353  {"SPOOLSS_SETJOB",                    SPOOLSS_SETJOB,                    api_spoolss_setjob                    },
1354  {"SPOOLSS_ENUMFORMS",                 SPOOLSS_ENUMFORMS,                 api_spoolss_enumforms                 },
1355  {"SPOOLSS_ENUMPORTS",                 SPOOLSS_ENUMPORTS,                 api_spoolss_enumports                 },
1356  {"SPOOLSS_ENUMPRINTERDRIVERS",        SPOOLSS_ENUMPRINTERDRIVERS,        api_spoolss_enumprinterdrivers        },
1357  {"SPOOLSS_ADDPRINTEREX",              SPOOLSS_ADDPRINTEREX,              api_spoolss_addprinterex              },
1358  {"SPOOLSS_ADDPRINTERDRIVER",          SPOOLSS_ADDPRINTERDRIVER,          api_spoolss_addprinterdriver          },
1359  {"SPOOLSS_GETPRINTERDRIVERDIRECTORY", SPOOLSS_GETPRINTERDRIVERDIRECTORY, api_spoolss_getprinterdriverdirectory },
1360  {"SPOOLSS_ENUMPRINTERDATA",           SPOOLSS_ENUMPRINTERDATA,           api_spoolss_enumprinterdata           },
1361  {"SPOOLSS_SETPRINTERDATA",            SPOOLSS_SETPRINTERDATA,            api_spoolss_setprinterdata            },
1362  {"SPOOLSS_DELETEPRINTERDATA",         SPOOLSS_DELETEPRINTERDATA,         api_spoolss_deleteprinterdata         },
1363  {"SPOOLSS_ADDFORM",                   SPOOLSS_ADDFORM,                   api_spoolss_addform                   },
1364  {"SPOOLSS_DELETEFORM",                SPOOLSS_DELETEFORM,                api_spoolss_deleteform                },
1365  {"SPOOLSS_GETFORM",                   SPOOLSS_GETFORM,                   api_spoolss_getform                   },
1366  {"SPOOLSS_SETFORM",                   SPOOLSS_SETFORM,                   api_spoolss_setform                   },
1367  {"SPOOLSS_ENUMPRINTPROCESSORS",       SPOOLSS_ENUMPRINTPROCESSORS,       api_spoolss_enumprintprocessors       },
1368  {"SPOOLSS_ENUMMONITORS",              SPOOLSS_ENUMMONITORS,              api_spoolss_enumprintmonitors         },
1369  {"SPOOLSS_GETJOB",                    SPOOLSS_GETJOB,                    api_spoolss_getjob                    },
1370  {"SPOOLSS_ENUMPRINTPROCDATATYPES",    SPOOLSS_ENUMPRINTPROCDATATYPES,    api_spoolss_enumprintprocdatatypes    },
1371  { NULL,                               0,                                 NULL                                  }
1372 };
1373
1374 /*******************************************************************
1375 receives a spoolss pipe and responds.
1376 ********************************************************************/
1377 BOOL api_spoolss_rpc(pipes_struct *p)
1378 {
1379         return api_rpcTNP(p, "api_spoolss_rpc", api_spoolss_cmds);
1380 }
1381
1382 #undef OLD_NTDOMAIN