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