source4/rpc_server/spoolss/dcesrv_spoolss.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    endpoint server for the spoolss pipe
   5
   6    Copyright (C) Tim Potter 2004
   7    Copyright (C) Stefan Metzmacher 2005
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 #include "includes.h"
  25 #include "rpc_server/dcerpc_server.h"
  26 #include "librpc/gen_ndr/ndr_spoolss.h"
  27 #include "rpc_server/common/common.h"
  28 #include "ntptr/ntptr.h"
  29 #include "lib/socket/socket.h"
  30 #include "smbd/service_stream.h"
  31
  32 #define SPOOLSS_BUFFER_UNION(fn,info,level) \
  33         ((info)?ndr_size_##fn(info, level, 0):0)
  34
  35 #define SPOOLSS_BUFFER_UNION_ARRAY(fn,info,level,count) \
  36         ((info)?ndr_size_##fn##_info(dce_call, level, count, info):0)
  37
  38 #define SPOOLSS_BUFFER_OK(val_true,val_false) ((r->in.offered >= r->out.needed)?val_true:val_false)
  39
  40 static WERROR spoolss_parse_printer_name(TALLOC_CTX *mem_ctx, const char *name,
  41                                          const char **_server_name,
  42                                          const char **_object_name,
  43                                          enum ntptr_HandleType *_object_type)
  44 {
  45         char *p;
  46         char *server = NULL;
  47         char *server_unc = NULL;
  48         const char *object = name;
  49
  50         /* no printername is there it's like open server */
  51         if (!name) {
  52                 *_server_name = NULL;
  53                 *_object_name = NULL;
  54                 *_object_type = NTPTR_HANDLE_SERVER;
  55                 return WERR_OK;
  56         }
  57
  58         /* just "\\" is invalid */
  59         if (strequal("\\\\", name)) {
  60                 return WERR_INVALID_PRINTER_NAME;
  61         }
  62
  63         if (strncmp("\\\\", name, 2) == 0) {
  64                 server_unc = talloc_strdup(mem_ctx, name);
  65                 W_ERROR_HAVE_NO_MEMORY(server_unc);
  66                 server = server_unc + 2;
  67
  68                 /* here we know we have "\\" in front not followed
  69                  * by '\0', now see if we have another "\" in the string
  70                  */
  71                 p = strchr_m(server, '\\');
  72                 if (!p) {
  73                         /* there's no other "\", so it's ("\\%s",server)
  74                          */
  75                         *_server_name = server_unc;
  76                         *_object_name = NULL;
  77                         *_object_type = NTPTR_HANDLE_SERVER;
  78                         return WERR_OK;
  79                 }
  80                 /* here we know that we have ("\\%s\",server),
  81                  * if we have '\0' as next then it's an invalid name
  82                  * otherwise the printer_name
  83                  */
  84                 p[0] = '\0';
  85                 /* everything that follows is the printer name */
  86                 p++;
  87                 object = p;
  88
  89                 /* just "" as server is invalid */
  90                 if (strequal(server, "")) {
  91                         return WERR_INVALID_PRINTER_NAME;
  92                 }
  93         }
  94
  95         /* just "" is invalid */
  96         if (strequal(object, "")) {
  97                 return WERR_INVALID_PRINTER_NAME;
  98         }
  99
 100 #define XCV_PORT ",XcvPort "
 101 #define XCV_MONITOR ",XcvMonitor "
 102         if (strncmp(object, XCV_PORT, strlen(XCV_PORT)) == 0) {
 103                 object += strlen(XCV_PORT);
 104
 105                 /* just "" is invalid */
 106                 if (strequal(object, "")) {
 107                         return WERR_INVALID_PRINTER_NAME;
 108                 }
 109
 110                 *_server_name = server_unc;
 111                 *_object_name = object;
 112                 *_object_type = NTPTR_HANDLE_PORT;
 113                 return WERR_OK;
 114         } else if (strncmp(object, XCV_MONITOR, strlen(XCV_MONITOR)) == 0) {
 115                 object += strlen(XCV_MONITOR);
 116
 117                 /* just "" is invalid */
 118                 if (strequal(object, "")) {
 119                         return WERR_INVALID_PRINTER_NAME;
 120                 }
 121
 122                 *_server_name = server_unc;
 123                 *_object_name = object;
 124                 *_object_type = NTPTR_HANDLE_MONITOR;
 125                 return WERR_OK;
 126         }
 127
 128         *_server_name = server_unc;
 129         *_object_name = object;
 130         *_object_type = NTPTR_HANDLE_PRINTER;
 131         return WERR_OK;
 132 }
 133
 134 /*
 135  * Check server_name is:
 136  * -  "" , functions that don't allow "",
 137  *         should check that on their own, before calling this function
 138  * -  our name (only netbios yet, TODO: need to test dns name!)
 139  * -  our ip address of the current use socket
 140  * otherwise return WERR_INVALID_PRINTER_NAME
 141  */
 142 static WERROR spoolss_check_server_name(struct dcesrv_call_state *dce_call,
 143                                         TALLOC_CTX *mem_ctx,
 144                                         const char *server_name)
 145 {
 146         BOOL ret;
 147         const char *ip_str;
 148
 149         if (!server_name) return WERR_OK;
 150
 151         ret = strequal("",server_name);
 152         if (ret) return WERR_OK;
 153
 154         if (strncmp("\\\\", server_name, 2) != 0) {
 155                 return WERR_INVALID_PRINTER_NAME;
 156         }
 157
 158         server_name += 2;
 159
 160         ret = strequal(lp_netbios_name(), server_name);
 161         if (ret) return WERR_OK;
 162
 163         /* TODO: check dns name here ? */
 164
 165         ip_str = socket_get_my_addr(dce_call->conn->srv_conn->socket, mem_ctx);
 166         W_ERROR_HAVE_NO_MEMORY(ip_str);
 167
 168         ret = strequal(ip_str, server_name);
 169         if (ret) return WERR_OK;
 170
 171         return WERR_INVALID_PRINTER_NAME;
 172 }
 173
 174 static NTSTATUS dcerpc_spoolss_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface)
 175 {
 176         NTSTATUS status;
 177         struct ntptr_context *ntptr;
 178
 179         status = ntptr_init_context(dce_call->context, lp_ntptr_providor(), &ntptr);
 180         NT_STATUS_NOT_OK_RETURN(status);
 181
 182         dce_call->context->private = ntptr;
 183
 184         return NT_STATUS_OK;
 185 }
 186
 187 #define DCESRV_INTERFACE_SPOOLSS_BIND dcerpc_spoolss_bind
 188
 189 /*
 190   spoolss_EnumPrinters
 191 */
 192 static WERROR spoolss_EnumPrinters(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 193                        struct spoolss_EnumPrinters *r)
 194 {
 195         struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private, struct ntptr_context);
 196         WERROR status;
 197
 198         status = spoolss_check_server_name(dce_call, mem_ctx, r->in.server);
 199         W_ERROR_NOT_OK_RETURN(status);
 200
 201         status = ntptr_EnumPrinters(ntptr, mem_ctx, r);
 202         W_ERROR_NOT_OK_RETURN(status);
 203
 204         r->out.needed   = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumPrinters, r->out.info, r->in.level, r->out.count);
 205         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
 206         r->out.count    = SPOOLSS_BUFFER_OK(r->out.count, 0);
 207         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 208 }
 209
 210 static WERROR spoolss_OpenPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 211                        struct spoolss_OpenPrinterEx *r);
 212 /*
 213   spoolss_OpenPrinter
 214 */
 215 static WERROR spoolss_OpenPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 216                        struct spoolss_OpenPrinter *r)
 217 {
 218         WERROR status;
 219         struct spoolss_OpenPrinterEx *r2;
 220
 221         r2 = talloc(mem_ctx, struct spoolss_OpenPrinterEx);
 222         W_ERROR_HAVE_NO_MEMORY(r2);
 223
 224         r2->in.printername      = r->in.printername;
 225         r2->in.datatype         = r->in.datatype;
 226         r2->in.devmode_ctr      = r->in.devmode_ctr;
 227         r2->in.access_mask      = r->in.access_mask;
 228         r2->in.level            = 1;
 229         r2->in.userlevel.level1 = NULL;
 230
 231         r2->out.handle          = r->out.handle;
 232
 233         /* TODO: we should take care about async replies here,
 234                  if spoolss_OpenPrinterEx() would be async!
 235          */
 236         status = spoolss_OpenPrinterEx(dce_call, mem_ctx, r2);
 237
 238         r->out.handle           = r2->out.handle;
 239
 240         return status;
 241 }
 242
 243
 244 /*
 245   spoolss_SetJob
 246 */
 247 static WERROR spoolss_SetJob(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 248                        struct spoolss_SetJob *r)
 249 {
 250         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 251 }
 252
 253
 254 /*
 255   spoolss_GetJob
 256 */
 257 static WERROR spoolss_GetJob(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 258                        struct spoolss_GetJob *r)
 259 {
 260         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 261 }
 262
 263
 264 /*
 265   spoolss_EnumJobs
 266 */
 267 static WERROR spoolss_EnumJobs(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 268                        struct spoolss_EnumJobs *r)
 269 {
 270         return WERR_OK;
 271 }
 272
 273
 274 /*
 275   spoolss_AddPrinter
 276 */
 277 static WERROR spoolss_AddPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 278                        struct spoolss_AddPrinter *r)
 279 {
 280         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 281 }
 282
 283
 284 /*
 285   spoolss_DeletePrinter
 286 */
 287 static WERROR spoolss_DeletePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 288                        struct spoolss_DeletePrinter *r)
 289 {
 290         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 291 }
 292
 293
 294 /*
 295   spoolss_SetPrinter
 296 */
 297 static WERROR spoolss_SetPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 298                        struct spoolss_SetPrinter *r)
 299 {
 300         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 301 }
 302
 303
 304 /*
 305   spoolss_GetPrinter
 306 */
 307 static WERROR spoolss_GetPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 308                        struct spoolss_GetPrinter *r)
 309 {
 310         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 311 }
 312
 313
 314 /*
 315   spoolss_AddPrinterDriver
 316 */
 317 static WERROR spoolss_AddPrinterDriver(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 318                        struct spoolss_AddPrinterDriver *r)
 319 {
 320         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 321 }
 322
 323
 324 /*
 325   spoolss_EnumPrinterDrivers
 326 */
 327 static WERROR spoolss_EnumPrinterDrivers(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 328                        struct spoolss_EnumPrinterDrivers *r)
 329 {
 330         struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private, struct ntptr_context);
 331         WERROR status;
 332
 333         status = spoolss_check_server_name(dce_call, mem_ctx, r->in.server);
 334         W_ERROR_NOT_OK_RETURN(status);
 335
 336         status = ntptr_EnumPrinterDrivers(ntptr, mem_ctx, r);
 337         W_ERROR_NOT_OK_RETURN(status);
 338
 339         r->out.needed   = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumPrinterDrivers, r->out.info, r->in.level, r->out.count);
 340         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
 341         r->out.count    = SPOOLSS_BUFFER_OK(r->out.count, 0);
 342         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 343 }
 344
 345
 346 /*
 347   spoolss_GetPrinterDriver
 348 */
 349 static WERROR spoolss_GetPrinterDriver(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 350                        struct spoolss_GetPrinterDriver *r)
 351 {
 352         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 353 }
 354
 355
 356 /*
 357   spoolss_GetPrinterDriverDirectory
 358 */
 359 static WERROR spoolss_GetPrinterDriverDirectory(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 360                        struct spoolss_GetPrinterDriverDirectory *r)
 361 {
 362         struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private, struct ntptr_context);
 363         WERROR status;
 364
 365         status = spoolss_check_server_name(dce_call, mem_ctx, r->in.server);
 366         W_ERROR_NOT_OK_RETURN(status);
 367
 368         status = ntptr_GetPrinterDriverDirectory(ntptr, mem_ctx, r);
 369         W_ERROR_NOT_OK_RETURN(status);
 370
 371         r->out.needed   = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo, r->out.info, r->in.level);
 372         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
 373         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 374 }
 375
 376
 377 /*
 378   spoolss_DeletePrinterDriver
 379 */
 380 static WERROR spoolss_DeletePrinterDriver(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 381                        struct spoolss_DeletePrinterDriver *r)
 382 {
 383         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 384 }
 385
 386
 387 /*
 388   spoolss_AddPrintProcessor
 389 */
 390 static WERROR spoolss_AddPrintProcessor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 391                        struct spoolss_AddPrintProcessor *r)
 392 {
 393         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 394 }
 395
 396
 397 /*
 398   spoolss_EnumPrintProcessors
 399 */
 400 static WERROR spoolss_EnumPrintProcessors(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 401                        struct spoolss_EnumPrintProcessors *r)
 402 {
 403         return WERR_OK;
 404 }
 405
 406
 407 /*
 408   spoolss_GetPrintProcessorDirectory
 409 */
 410 static WERROR spoolss_GetPrintProcessorDirectory(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 411                        struct spoolss_GetPrintProcessorDirectory *r)
 412 {
 413         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 414 }
 415
 416
 417 /*
 418   spoolss_StartDocPrinter
 419 */
 420 static WERROR spoolss_StartDocPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 421                        struct spoolss_StartDocPrinter *r)
 422 {
 423         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 424 }
 425
 426
 427 /*
 428   spoolss_StartPagePrinter
 429 */
 430 static WERROR spoolss_StartPagePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 431                        struct spoolss_StartPagePrinter *r)
 432 {
 433         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 434 }
 435
 436
 437 /*
 438   spoolss_WritePrinter
 439 */
 440 static WERROR spoolss_WritePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 441                        struct spoolss_WritePrinter *r)
 442 {
 443         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 444 }
 445
 446
 447 /*
 448   spoolss_EndPagePrinter
 449 */
 450 static WERROR spoolss_EndPagePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 451                        struct spoolss_EndPagePrinter *r)
 452 {
 453         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 454 }
 455
 456
 457 /*
 458   spoolss_AbortPrinter
 459 */
 460 static WERROR spoolss_AbortPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 461                        struct spoolss_AbortPrinter *r)
 462 {
 463         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 464 }
 465
 466
 467 /*
 468   spoolss_ReadPrinter
 469 */
 470 static WERROR spoolss_ReadPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 471                        struct spoolss_ReadPrinter *r)
 472 {
 473         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 474 }
 475
 476
 477 /*
 478   spoolss_EndDocPrinter
 479 */
 480 static WERROR spoolss_EndDocPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 481                        struct spoolss_EndDocPrinter *r)
 482 {
 483         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 484 }
 485
 486
 487 /*
 488   spoolss_AddJob
 489 */
 490 static WERROR spoolss_AddJob(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 491                        struct spoolss_AddJob *r)
 492 {
 493         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 494 }
 495
 496
 497 /*
 498   spoolss_ScheduleJob
 499 */
 500 static WERROR spoolss_ScheduleJob(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 501                        struct spoolss_ScheduleJob *r)
 502 {
 503         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 504 }
 505
 506
 507 /*
 508   spoolss_GetPrinterData
 509 */
 510 static WERROR spoolss_GetPrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 511                        struct spoolss_GetPrinterData *r)
 512 {
 513         struct ntptr_GenericHandle *handle;
 514         struct dcesrv_handle *h;
 515         WERROR status;
 516
 517         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 518         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
 519
 520         switch (handle->type) {
 521                 case NTPTR_HANDLE_SERVER:
 522                         status = ntptr_GetPrintServerData(handle, mem_ctx, r);
 523                         break;
 524                 default:
 525                         status = WERR_FOOBAR;
 526                         break;
 527         }
 528
 529         W_ERROR_NOT_OK_RETURN(status);
 530
 531         r->out.needed   = ndr_size_spoolss_PrinterData(&r->out.data, r->out.type, 0);
 532         r->out.type     = SPOOLSS_BUFFER_OK(r->out.type, SPOOLSS_PRINTER_DATA_TYPE_NULL);
 533         r->out.data     = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
 534         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
 535 }
 536
 537
 538 /*
 539   spoolss_SetPrinterData
 540 */
 541 static WERROR spoolss_SetPrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 542                        struct spoolss_SetPrinterData *r)
 543 {
 544         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 545 }
 546
 547
 548 /*
 549   spoolss_WaitForPrinterChange
 550 */
 551 static WERROR spoolss_WaitForPrinterChange(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 552                        struct spoolss_WaitForPrinterChange *r)
 553 {
 554         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 555 }
 556
 557
 558 /*
 559   spoolss_ClosePrinter
 560 */
 561 static WERROR spoolss_ClosePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 562                        struct spoolss_ClosePrinter *r)
 563 {
 564         struct dcesrv_handle *h;
 565
 566         *r->out.handle = *r->in.handle;
 567
 568         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 569
 570         talloc_free(h);
 571
 572         ZERO_STRUCTP(r->out.handle);
 573
 574         return WERR_OK;
 575 }
 576
 577
 578 /*
 579   spoolss_AddForm
 580 */
 581 static WERROR spoolss_AddForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 582                        struct spoolss_AddForm *r)
 583 {
 584         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 585 }
 586
 587
 588 /*
 589   spoolss_DeleteForm
 590 */
 591 static WERROR spoolss_DeleteForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 592                        struct spoolss_DeleteForm *r)
 593 {
 594         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 595 }
 596
 597
 598 /*
 599   spoolss_GetForm
 600 */
 601 static WERROR spoolss_GetForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 602                        struct spoolss_GetForm *r)
 603 {
 604         struct ntptr_GenericHandle *handle;
 605         struct dcesrv_handle *h;
 606         WERROR status;
 607
 608         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 609         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
 610
 611         switch (handle->type) {
 612                 case NTPTR_HANDLE_SERVER:
 613                         status = ntptr_GetPrintServerForm(handle, mem_ctx, r);
 614                         W_ERROR_NOT_OK_RETURN(status);
 615                         break;
 616                 case NTPTR_HANDLE_PRINTER:
 617                         status = ntptr_GetPrinterForm(handle, mem_ctx, r);
 618                         W_ERROR_NOT_OK_RETURN(status);
 619                         break;
 620                 default:
 621                         return WERR_FOOBAR;
 622         }
 623
 624         r->out.needed   = SPOOLSS_BUFFER_UNION(spoolss_FormInfo, r->out.info, r->in.level);
 625         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
 626         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 627 }
 628
 629
 630 /*
 631   spoolss_SetForm
 632 */
 633 static WERROR spoolss_SetForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 634                        struct spoolss_SetForm *r)
 635 {
 636         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 637 }
 638
 639
 640 /*
 641   spoolss_EnumForms
 642 */
 643 static WERROR spoolss_EnumForms(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 644                        struct spoolss_EnumForms *r)
 645 {
 646         struct ntptr_GenericHandle *handle;
 647         struct dcesrv_handle *h;
 648         WERROR status;
 649
 650         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 651         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
 652
 653         switch (handle->type) {
 654                 case NTPTR_HANDLE_SERVER:
 655                         status = ntptr_EnumPrintServerForms(handle, mem_ctx, r);
 656                         W_ERROR_NOT_OK_RETURN(status);
 657                         break;
 658                 case NTPTR_HANDLE_PRINTER:
 659                         status = ntptr_EnumPrinterForms(handle, mem_ctx, r);
 660                         W_ERROR_NOT_OK_RETURN(status);
 661                         break;
 662                 default:
 663                         return WERR_FOOBAR;
 664         }
 665
 666         r->out.needed   = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumForms, r->out.info, r->in.level, r->out.count);
 667         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
 668         r->out.count    = SPOOLSS_BUFFER_OK(r->out.count, 0);
 669         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 670 }
 671
 672
 673 /*
 674   spoolss_EnumPorts
 675 */
 676 static WERROR spoolss_EnumPorts(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 677                        struct spoolss_EnumPorts *r)
 678 {
 679         struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private, struct ntptr_context);
 680         WERROR status;
 681
 682         status = spoolss_check_server_name(dce_call, mem_ctx, r->in.servername);
 683         W_ERROR_NOT_OK_RETURN(status);
 684
 685         status = ntptr_EnumPorts(ntptr, mem_ctx, r);
 686         W_ERROR_NOT_OK_RETURN(status);
 687
 688         r->out.needed   = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumPorts, r->out.info, r->in.level, r->out.count);
 689         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
 690         r->out.count    = SPOOLSS_BUFFER_OK(r->out.count, 0);
 691         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 692 }
 693
 694
 695 /*
 696   spoolss_EnumMonitors
 697 */
 698 static WERROR spoolss_EnumMonitors(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 699                        struct spoolss_EnumMonitors *r)
 700 {
 701         struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private, struct ntptr_context);
 702         WERROR status;
 703
 704         status = spoolss_check_server_name(dce_call, mem_ctx, r->in.servername);
 705         W_ERROR_NOT_OK_RETURN(status);
 706
 707         status = ntptr_EnumMonitors(ntptr, mem_ctx, r);
 708         W_ERROR_NOT_OK_RETURN(status);
 709
 710         r->out.needed   = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumMonitors, r->out.info, r->in.level, r->out.count);
 711         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
 712         r->out.count    = SPOOLSS_BUFFER_OK(r->out.count, 0);
 713         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 714 }
 715
 716
 717 /*
 718   spoolss_AddPort
 719 */
 720 static WERROR spoolss_AddPort(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 721                        struct spoolss_AddPort *r)
 722 {
 723         return WERR_NOT_SUPPORTED;
 724 }
 725
 726
 727 /*
 728   spoolss_ConfigurePort
 729 */
 730 static WERROR spoolss_ConfigurePort(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 731                        struct spoolss_ConfigurePort *r)
 732 {
 733         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 734 }
 735
 736
 737 /*
 738   spoolss_DeletePort
 739 */
 740 static WERROR spoolss_DeletePort(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 741                        struct spoolss_DeletePort *r)
 742 {
 743         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 744 }
 745
 746
 747 /*
 748   spoolss_CreatePrinterIC
 749 */
 750 static WERROR spoolss_CreatePrinterIC(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 751                        struct spoolss_CreatePrinterIC *r)
 752 {
 753         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 754 }
 755
 756
 757 /*
 758   spoolss_PlayGDIScriptOnPrinterIC
 759 */
 760 static WERROR spoolss_PlayGDIScriptOnPrinterIC(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 761                        struct spoolss_PlayGDIScriptOnPrinterIC *r)
 762 {
 763         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 764 }
 765
 766
 767 /*
 768   spoolss_DeletePrinterIC
 769 */
 770 static WERROR spoolss_DeletePrinterIC(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 771                        struct spoolss_DeletePrinterIC *r)
 772 {
 773         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 774 }
 775
 776
 777 /*
 778   spoolss_AddPrinterConnection
 779 */
 780 static WERROR spoolss_AddPrinterConnection(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 781                        struct spoolss_AddPrinterConnection *r)
 782 {
 783         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 784 }
 785
 786
 787 /*
 788   spoolss_DeletePrinterConnection
 789 */
 790 static WERROR spoolss_DeletePrinterConnection(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 791                        struct spoolss_DeletePrinterConnection *r)
 792 {
 793         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 794 }
 795
 796
 797 /*
 798   spoolss_PrinterMessageBox
 799 */
 800 static WERROR spoolss_PrinterMessageBox(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 801                        struct spoolss_PrinterMessageBox *r)
 802 {
 803         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 804 }
 805
 806
 807 /*
 808   spoolss_AddMonitor
 809 */
 810 static WERROR spoolss_AddMonitor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 811                        struct spoolss_AddMonitor *r)
 812 {
 813         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 814 }
 815
 816
 817 /*
 818   spoolss_DeleteMonitor
 819 */
 820 static WERROR spoolss_DeleteMonitor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 821                        struct spoolss_DeleteMonitor *r)
 822 {
 823         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 824 }
 825
 826
 827 /*
 828   spoolss_DeletePrintProcessor
 829 */
 830 static WERROR spoolss_DeletePrintProcessor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 831                        struct spoolss_DeletePrintProcessor *r)
 832 {
 833         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 834 }
 835
 836
 837 /*
 838   spoolss_AddPrintProvidor
 839 */
 840 static WERROR spoolss_AddPrintProvidor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 841                        struct spoolss_AddPrintProvidor *r)
 842 {
 843         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 844 }
 845
 846
 847 /*
 848   spoolss_DeletePrintProvidor
 849 */
 850 static WERROR spoolss_DeletePrintProvidor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 851                        struct spoolss_DeletePrintProvidor *r)
 852 {
 853         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 854 }
 855
 856
 857 /*
 858   spoolss_EnumPrintProcDataTypes
 859 */
 860 static WERROR spoolss_EnumPrintProcDataTypes(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 861                        struct spoolss_EnumPrintProcDataTypes *r)
 862 {
 863         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 864 }
 865
 866
 867 /*
 868   spoolss_ResetPrinter
 869 */
 870 static WERROR spoolss_ResetPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 871                        struct spoolss_ResetPrinter *r)
 872 {
 873         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 874 }
 875
 876
 877 /*
 878   spoolss_GetPrinterDriver2
 879 */
 880 static WERROR spoolss_GetPrinterDriver2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 881                        struct spoolss_GetPrinterDriver2 *r)
 882 {
 883         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 884 }
 885
 886
 887 /*
 888   spoolss_FindFirstPrinterChangeNotification
 889 */
 890 static WERROR spoolss_FindFirstPrinterChangeNotification(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 891                        struct spoolss_FindFirstPrinterChangeNotification *r)
 892 {
 893         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 894 }
 895
 896
 897 /*
 898   spoolss_FindNextPrinterChangeNotification
 899 */
 900 static WERROR spoolss_FindNextPrinterChangeNotification(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 901                        struct spoolss_FindNextPrinterChangeNotification *r)
 902 {
 903         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 904 }
 905
 906
 907 /*
 908   spoolss_FindClosePrinterNotify
 909 */
 910 static WERROR spoolss_FindClosePrinterNotify(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 911                        struct spoolss_FindClosePrinterNotify *r)
 912 {
 913         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 914 }
 915
 916
 917 /*
 918   spoolss_RouterFindFirstPrinterChangeNotificationOld
 919 */
 920 static WERROR spoolss_RouterFindFirstPrinterChangeNotificationOld(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 921                        struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
 922 {
 923         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 924 }
 925
 926
 927 /*
 928   spoolss_ReplyOpenPrinter
 929 */
 930 static WERROR spoolss_ReplyOpenPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 931                        struct spoolss_ReplyOpenPrinter *r)
 932 {
 933         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 934 }
 935
 936
 937 /*
 938   spoolss_RouterReplyPrinter
 939 */
 940 static WERROR spoolss_RouterReplyPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 941                        struct spoolss_RouterReplyPrinter *r)
 942 {
 943         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 944 }
 945
 946
 947 /*
 948   spoolss_ReplyClosePrinter
 949 */
 950 static WERROR spoolss_ReplyClosePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 951                        struct spoolss_ReplyClosePrinter *r)
 952 {
 953         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 954 }
 955
 956
 957 /*
 958   spoolss_AddPortEx
 959 */
 960 static WERROR spoolss_AddPortEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 961                        struct spoolss_AddPortEx *r)
 962 {
 963         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 964 }
 965
 966
 967 /*
 968   spoolss_RouterFindFirstPrinterChangeNotification
 969 */
 970 static WERROR spoolss_RouterFindFirstPrinterChangeNotification(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 971                        struct spoolss_RouterFindFirstPrinterChangeNotification *r)
 972 {
 973         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 974 }
 975
 976
 977 /*
 978   spoolss_SpoolerInit
 979 */
 980 static WERROR spoolss_SpoolerInit(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 981                        struct spoolss_SpoolerInit *r)
 982 {
 983         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 984 }
 985
 986
 987 /*
 988   spoolss_ResetPrinterEx
 989 */
 990 static WERROR spoolss_ResetPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 991                        struct spoolss_ResetPrinterEx *r)
 992 {
 993         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 994 }
 995
 996
 997 /*
 998   spoolss_RemoteFindFirstPrinterChangeNotifyEx
 999 */
1000 static WERROR spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1001                        struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
1002 {
1003         /*
1004          * TODO: for now just return ok,
1005          *       to keep the w2k3 PrintServer
1006          *       happy to allow to open the Add Printer GUI
1007          */
1008         return WERR_OK;
1009 }
1010
1011
1012 /*
1013   spoolss_RouterRefreshPrinterChangeNotification
1014 */
1015 static WERROR spoolss_RouterRefreshPrinterChangeNotification(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1016                        struct spoolss_RouterRefreshPrinterChangeNotification *r)
1017 {
1018         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1019 }
1020
1021
1022 /*
1023   spoolss_RemoteFindNextPrinterChangeNotifyEx
1024 */
1025 static WERROR spoolss_RemoteFindNextPrinterChangeNotifyEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1026                        struct spoolss_RemoteFindNextPrinterChangeNotifyEx *r)
1027 {
1028         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1029 }
1030
1031
1032 /*
1033   spoolss_44
1034 */
1035 static WERROR spoolss_44(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1036                        struct spoolss_44 *r)
1037 {
1038         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1039 }
1040
1041 /*
1042   spoolss_OpenPrinterEx
1043 */
1044 static WERROR spoolss_OpenPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1045                        struct spoolss_OpenPrinterEx *r)
1046 {
1047         struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private, struct ntptr_context);
1048         struct ntptr_GenericHandle *handle;
1049         struct dcesrv_handle *h;
1050         const char *server;
1051         const char *object;
1052         enum ntptr_HandleType type;
1053         WERROR status;
1054
1055         ZERO_STRUCTP(r->out.handle);
1056
1057         status = spoolss_parse_printer_name(mem_ctx, r->in.printername, &server, &object, &type);
1058         W_ERROR_NOT_OK_RETURN(status);
1059
1060         status = spoolss_check_server_name(dce_call, mem_ctx, server);
1061         W_ERROR_NOT_OK_RETURN(status);
1062
1063         switch (type) {
1064                 case NTPTR_HANDLE_SERVER:
1065                         status = ntptr_OpenPrintServer(ntptr, mem_ctx, r, server, &handle);
1066                         W_ERROR_NOT_OK_RETURN(status);
1067                         break;
1068                 case NTPTR_HANDLE_PORT:
1069                         status = ntptr_OpenPort(ntptr, mem_ctx, r, object, &handle);
1070                         W_ERROR_NOT_OK_RETURN(status);
1071                         break;
1072                 case NTPTR_HANDLE_MONITOR:
1073                         status = ntptr_OpenMonitor(ntptr, mem_ctx, r, object, &handle);
1074                         W_ERROR_NOT_OK_RETURN(status);
1075                         break;
1076                 case NTPTR_HANDLE_PRINTER:
1077                         status = ntptr_OpenPrinter(ntptr, mem_ctx, r, object, &handle);
1078                         W_ERROR_NOT_OK_RETURN(status);
1079                         break;
1080                 default:
1081                         return WERR_FOOBAR;
1082         }
1083
1084         h = dcesrv_handle_new(dce_call->context, handle->type);
1085         W_ERROR_HAVE_NO_MEMORY(h);
1086
1087         h->data = talloc_steal(h, handle);
1088
1089         *r->out.handle  = h->wire_handle;
1090
1091         return WERR_OK;
1092 }
1093
1094 /*
1095   spoolss_AddPrinterEx
1096 */
1097 static WERROR spoolss_AddPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1098                        struct spoolss_AddPrinterEx *r)
1099 {
1100         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1101 }
1102
1103
1104 /*
1105   spoolss_47
1106 */
1107 static WERROR spoolss_47(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1108                        struct spoolss_47 *r)
1109 {
1110         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1111 }
1112
1113
1114 /*
1115   spoolss_EnumPrinterData
1116 */
1117 static WERROR spoolss_EnumPrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1118                        struct spoolss_EnumPrinterData *r)
1119 {
1120         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1121 }
1122
1123
1124 /*
1125   spoolss_DeletePrinterData
1126 */
1127 static WERROR spoolss_DeletePrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1128                        struct spoolss_DeletePrinterData *r)
1129 {
1130         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1131 }
1132
1133
1134 /*
1135   spoolss_4a
1136 */
1137 static WERROR spoolss_4a(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1138                        struct spoolss_4a *r)
1139 {
1140         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1141 }
1142
1143
1144 /*
1145   spoolss_4b
1146 */
1147 static WERROR spoolss_4b(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1148                        struct spoolss_4b *r)
1149 {
1150         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1151 }
1152
1153
1154 /*
1155   spoolss_4c
1156 */
1157 static WERROR spoolss_4c(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1158                        struct spoolss_4c *r)
1159 {
1160         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1161 }
1162
1163
1164 /*
1165   spoolss_SetPrinterDataEx
1166 */
1167 static WERROR spoolss_SetPrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1168                        struct spoolss_SetPrinterDataEx *r)
1169 {
1170         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1171 }
1172
1173
1174 /*
1175   spoolss_GetPrinterDataEx
1176 */
1177 static WERROR spoolss_GetPrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1178                        struct spoolss_GetPrinterDataEx *r)
1179 {
1180         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1181 }
1182
1183
1184 /*
1185   spoolss_EnumPrinterDataEx
1186 */
1187 static WERROR spoolss_EnumPrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1188                        struct spoolss_EnumPrinterDataEx *r)
1189 {
1190         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1191 }
1192
1193
1194 /*
1195   spoolss_EnumPrinterKey
1196 */
1197 static WERROR spoolss_EnumPrinterKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1198                        struct spoolss_EnumPrinterKey *r)
1199 {
1200         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1201 }
1202
1203
1204 /*
1205   spoolss_DeletePrinterDataEx
1206 */
1207 static WERROR spoolss_DeletePrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1208                        struct spoolss_DeletePrinterDataEx *r)
1209 {
1210         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1211 }
1212
1213
1214 /*
1215   spoolss_DeletePrinterKey
1216 */
1217 static WERROR spoolss_DeletePrinterKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1218                        struct spoolss_DeletePrinterKey *r)
1219 {
1220         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1221 }
1222
1223
1224 /*
1225   spoolss_53
1226 */
1227 static WERROR spoolss_53(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1228                        struct spoolss_53 *r)
1229 {
1230         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1231 }
1232
1233
1234 /*
1235   spoolss_DeletePrinterDriverEx
1236 */
1237 static WERROR spoolss_DeletePrinterDriverEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1238                        struct spoolss_DeletePrinterDriverEx *r)
1239 {
1240         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1241 }
1242
1243
1244 /*
1245   spoolss_55
1246 */
1247 static WERROR spoolss_55(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1248                        struct spoolss_55 *r)
1249 {
1250         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1251 }
1252
1253
1254 /*
1255   spoolss_56
1256 */
1257 static WERROR spoolss_56(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1258                        struct spoolss_56 *r)
1259 {
1260         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1261 }
1262
1263
1264 /*
1265   spoolss_57
1266 */
1267 static WERROR spoolss_57(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1268                        struct spoolss_57 *r)
1269 {
1270         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1271 }
1272
1273
1274 /*
1275   spoolss_58
1276 */
1277 static WERROR spoolss_58(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1278                        struct spoolss_58 *r)
1279 {
1280         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1281 }
1282
1283
1284 /*
1285   spoolss_AddPrinterDriverEx
1286 */
1287 static WERROR spoolss_AddPrinterDriverEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1288                        struct spoolss_AddPrinterDriverEx *r)
1289 {
1290         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1291 }
1292
1293
1294 /*
1295   spoolss_5a
1296 */
1297 static WERROR spoolss_5a(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1298                        struct spoolss_5a *r)
1299 {
1300         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1301 }
1302
1303
1304 /*
1305   spoolss_5b
1306 */
1307 static WERROR spoolss_5b(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1308                        struct spoolss_5b *r)
1309 {
1310         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1311 }
1312
1313
1314 /*
1315   spoolss_5c
1316 */
1317 static WERROR spoolss_5c(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1318                        struct spoolss_5c *r)
1319 {
1320         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1321 }
1322
1323
1324 /*
1325   spoolss_5d
1326 */
1327 static WERROR spoolss_5d(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1328                        struct spoolss_5d *r)
1329 {
1330         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1331 }
1332
1333
1334 /*
1335   spoolss_5e
1336 */
1337 static WERROR spoolss_5e(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1338                        struct spoolss_5e *r)
1339 {
1340         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1341 }
1342
1343
1344 /*
1345   spoolss_5f
1346 */
1347 static WERROR spoolss_5f(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1348                        struct spoolss_5f *r)
1349 {
1350         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1351 }
1352
1353
1354 /* include the generated boilerplate */
1355 #include "librpc/gen_ndr/ndr_spoolss_s.c"