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         char *str;
 148
 149         /* NULL is ok */
 150         if (!server_name) return WERR_OK;
 151
 152         /* "" is ok */
 153         ret = strequal("",server_name);
 154         if (ret) return WERR_OK;
 155
 156         /* just "\\" is invalid */
 157         if (strequal("\\\\", server_name)) {
 158                 return WERR_INVALID_PRINTER_NAME;
 159         }
 160
 161         /* then we need "\\" */
 162         if (strncmp("\\\\", server_name, 2) != 0) {
 163                 return WERR_INVALID_PRINTER_NAME;
 164         }
 165
 166         server_name += 2;
 167
 168         /* NETBIOS NAME is ok */
 169         ret = strequal(lp_netbios_name(), server_name);
 170         if (ret) return WERR_OK;
 171
 172         /* DNS NAME is ok
 173          * TODO: we need to check if aliases are also ok
 174          */
 175         if (lp_realm() != NULL) {
 176                 str = talloc_asprintf(mem_ctx, "%s.%s",
 177                                                 lp_netbios_name(),
 178                                                 lp_realm());
 179                 W_ERROR_HAVE_NO_MEMORY(str);
 180
 181                 ret = strequal(str, server_name);
 182                 talloc_free(str);
 183                 if (ret) return WERR_OK;
 184         }
 185
 186         str = socket_get_my_addr(dce_call->conn->srv_conn->socket, mem_ctx);
 187         W_ERROR_HAVE_NO_MEMORY(str);
 188
 189         ret = strequal(str, server_name);
 190         talloc_free(str);
 191         if (ret) return WERR_OK;
 192
 193         return WERR_INVALID_PRINTER_NAME;
 194 }
 195
 196 static NTSTATUS dcerpc_spoolss_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface)
 197 {
 198         NTSTATUS status;
 199         struct ntptr_context *ntptr;
 200
 201         status = ntptr_init_context(dce_call->context, lp_ntptr_providor(), &ntptr);
 202         NT_STATUS_NOT_OK_RETURN(status);
 203
 204         dce_call->context->private = ntptr;
 205
 206         return NT_STATUS_OK;
 207 }
 208
 209 #define DCESRV_INTERFACE_SPOOLSS_BIND dcerpc_spoolss_bind
 210
 211 /*
 212   spoolss_EnumPrinters
 213 */
 214 static WERROR spoolss_EnumPrinters(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 215                        struct spoolss_EnumPrinters *r)
 216 {
 217         struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private, struct ntptr_context);
 218         WERROR status;
 219
 220         status = spoolss_check_server_name(dce_call, mem_ctx, r->in.server);
 221         W_ERROR_NOT_OK_RETURN(status);
 222
 223         status = ntptr_EnumPrinters(ntptr, mem_ctx, r);
 224         W_ERROR_NOT_OK_RETURN(status);
 225
 226         r->out.needed   = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumPrinters, r->out.info, r->in.level, r->out.count);
 227         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
 228         r->out.count    = SPOOLSS_BUFFER_OK(r->out.count, 0);
 229         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 230 }
 231
 232 static WERROR spoolss_OpenPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 233                        struct spoolss_OpenPrinterEx *r);
 234 /*
 235   spoolss_OpenPrinter
 236 */
 237 static WERROR spoolss_OpenPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 238                        struct spoolss_OpenPrinter *r)
 239 {
 240         WERROR status;
 241         struct spoolss_OpenPrinterEx *r2;
 242
 243         r2 = talloc(mem_ctx, struct spoolss_OpenPrinterEx);
 244         W_ERROR_HAVE_NO_MEMORY(r2);
 245
 246         r2->in.printername      = r->in.printername;
 247         r2->in.datatype         = r->in.datatype;
 248         r2->in.devmode_ctr      = r->in.devmode_ctr;
 249         r2->in.access_mask      = r->in.access_mask;
 250         r2->in.level            = 1;
 251         r2->in.userlevel.level1 = NULL;
 252
 253         r2->out.handle          = r->out.handle;
 254
 255         /* TODO: we should take care about async replies here,
 256                  if spoolss_OpenPrinterEx() would be async!
 257          */
 258         status = spoolss_OpenPrinterEx(dce_call, mem_ctx, r2);
 259
 260         r->out.handle           = r2->out.handle;
 261
 262         return status;
 263 }
 264
 265
 266 /*
 267   spoolss_SetJob
 268 */
 269 static WERROR spoolss_SetJob(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 270                        struct spoolss_SetJob *r)
 271 {
 272         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 273 }
 274
 275
 276 /*
 277   spoolss_GetJob
 278 */
 279 static WERROR spoolss_GetJob(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 280                        struct spoolss_GetJob *r)
 281 {
 282         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 283 }
 284
 285
 286 /*
 287   spoolss_EnumJobs
 288 */
 289 static WERROR spoolss_EnumJobs(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 290                        struct spoolss_EnumJobs *r)
 291 {
 292         return WERR_OK;
 293 }
 294
 295
 296 /*
 297   spoolss_AddPrinter
 298 */
 299 static WERROR spoolss_AddPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 300                        struct spoolss_AddPrinter *r)
 301 {
 302         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 303 }
 304
 305
 306 /*
 307   spoolss_DeletePrinter
 308 */
 309 static WERROR spoolss_DeletePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 310                        struct spoolss_DeletePrinter *r)
 311 {
 312         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 313 }
 314
 315
 316 /*
 317   spoolss_SetPrinter
 318 */
 319 static WERROR spoolss_SetPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 320                        struct spoolss_SetPrinter *r)
 321 {
 322         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 323 }
 324
 325
 326 /*
 327   spoolss_GetPrinter
 328 */
 329 static WERROR spoolss_GetPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 330                        struct spoolss_GetPrinter *r)
 331 {
 332         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 333 }
 334
 335
 336 /*
 337   spoolss_AddPrinterDriver
 338 */
 339 static WERROR spoolss_AddPrinterDriver(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 340                        struct spoolss_AddPrinterDriver *r)
 341 {
 342         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 343 }
 344
 345
 346 /*
 347   spoolss_EnumPrinterDrivers
 348 */
 349 static WERROR spoolss_EnumPrinterDrivers(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 350                        struct spoolss_EnumPrinterDrivers *r)
 351 {
 352         struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private, struct ntptr_context);
 353         WERROR status;
 354
 355         status = spoolss_check_server_name(dce_call, mem_ctx, r->in.server);
 356         W_ERROR_NOT_OK_RETURN(status);
 357
 358         status = ntptr_EnumPrinterDrivers(ntptr, mem_ctx, r);
 359         W_ERROR_NOT_OK_RETURN(status);
 360
 361         r->out.needed   = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumPrinterDrivers, r->out.info, r->in.level, r->out.count);
 362         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
 363         r->out.count    = SPOOLSS_BUFFER_OK(r->out.count, 0);
 364         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 365 }
 366
 367
 368 /*
 369   spoolss_GetPrinterDriver
 370 */
 371 static WERROR spoolss_GetPrinterDriver(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 372                        struct spoolss_GetPrinterDriver *r)
 373 {
 374         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 375 }
 376
 377
 378 /*
 379   spoolss_GetPrinterDriverDirectory
 380 */
 381 static WERROR spoolss_GetPrinterDriverDirectory(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 382                        struct spoolss_GetPrinterDriverDirectory *r)
 383 {
 384         struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private, struct ntptr_context);
 385         WERROR status;
 386
 387         status = spoolss_check_server_name(dce_call, mem_ctx, r->in.server);
 388         W_ERROR_NOT_OK_RETURN(status);
 389
 390         status = ntptr_GetPrinterDriverDirectory(ntptr, mem_ctx, r);
 391         W_ERROR_NOT_OK_RETURN(status);
 392
 393         r->out.needed   = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo, r->out.info, r->in.level);
 394         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
 395         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 396 }
 397
 398
 399 /*
 400   spoolss_DeletePrinterDriver
 401 */
 402 static WERROR spoolss_DeletePrinterDriver(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 403                        struct spoolss_DeletePrinterDriver *r)
 404 {
 405         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 406 }
 407
 408
 409 /*
 410   spoolss_AddPrintProcessor
 411 */
 412 static WERROR spoolss_AddPrintProcessor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 413                        struct spoolss_AddPrintProcessor *r)
 414 {
 415         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 416 }
 417
 418
 419 /*
 420   spoolss_EnumPrintProcessors
 421 */
 422 static WERROR spoolss_EnumPrintProcessors(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 423                        struct spoolss_EnumPrintProcessors *r)
 424 {
 425         return WERR_OK;
 426 }
 427
 428
 429 /*
 430   spoolss_GetPrintProcessorDirectory
 431 */
 432 static WERROR spoolss_GetPrintProcessorDirectory(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 433                        struct spoolss_GetPrintProcessorDirectory *r)
 434 {
 435         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 436 }
 437
 438
 439 /*
 440   spoolss_StartDocPrinter
 441 */
 442 static WERROR spoolss_StartDocPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 443                        struct spoolss_StartDocPrinter *r)
 444 {
 445         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 446 }
 447
 448
 449 /*
 450   spoolss_StartPagePrinter
 451 */
 452 static WERROR spoolss_StartPagePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 453                        struct spoolss_StartPagePrinter *r)
 454 {
 455         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 456 }
 457
 458
 459 /*
 460   spoolss_WritePrinter
 461 */
 462 static WERROR spoolss_WritePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 463                        struct spoolss_WritePrinter *r)
 464 {
 465         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 466 }
 467
 468
 469 /*
 470   spoolss_EndPagePrinter
 471 */
 472 static WERROR spoolss_EndPagePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 473                        struct spoolss_EndPagePrinter *r)
 474 {
 475         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 476 }
 477
 478
 479 /*
 480   spoolss_AbortPrinter
 481 */
 482 static WERROR spoolss_AbortPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 483                        struct spoolss_AbortPrinter *r)
 484 {
 485         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 486 }
 487
 488
 489 /*
 490   spoolss_ReadPrinter
 491 */
 492 static WERROR spoolss_ReadPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 493                        struct spoolss_ReadPrinter *r)
 494 {
 495         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 496 }
 497
 498
 499 /*
 500   spoolss_EndDocPrinter
 501 */
 502 static WERROR spoolss_EndDocPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 503                        struct spoolss_EndDocPrinter *r)
 504 {
 505         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 506 }
 507
 508
 509 /*
 510   spoolss_AddJob
 511 */
 512 static WERROR spoolss_AddJob(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 513                        struct spoolss_AddJob *r)
 514 {
 515         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 516 }
 517
 518
 519 /*
 520   spoolss_ScheduleJob
 521 */
 522 static WERROR spoolss_ScheduleJob(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 523                        struct spoolss_ScheduleJob *r)
 524 {
 525         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 526 }
 527
 528
 529 /*
 530   spoolss_GetPrinterData
 531 */
 532 static WERROR spoolss_GetPrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 533                        struct spoolss_GetPrinterData *r)
 534 {
 535         struct ntptr_GenericHandle *handle;
 536         struct dcesrv_handle *h;
 537         WERROR status;
 538
 539         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 540         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
 541
 542         switch (handle->type) {
 543                 case NTPTR_HANDLE_SERVER:
 544                         status = ntptr_GetPrintServerData(handle, mem_ctx, r);
 545                         break;
 546                 default:
 547                         status = WERR_FOOBAR;
 548                         break;
 549         }
 550
 551         W_ERROR_NOT_OK_RETURN(status);
 552
 553         r->out.needed   = ndr_size_spoolss_PrinterData(&r->out.data, r->out.type, 0);
 554         r->out.type     = SPOOLSS_BUFFER_OK(r->out.type, SPOOLSS_PRINTER_DATA_TYPE_NULL);
 555         r->out.data     = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
 556         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
 557 }
 558
 559
 560 /*
 561   spoolss_SetPrinterData
 562 */
 563 static WERROR spoolss_SetPrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 564                        struct spoolss_SetPrinterData *r)
 565 {
 566         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 567 }
 568
 569
 570 /*
 571   spoolss_WaitForPrinterChange
 572 */
 573 static WERROR spoolss_WaitForPrinterChange(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 574                        struct spoolss_WaitForPrinterChange *r)
 575 {
 576         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 577 }
 578
 579
 580 /*
 581   spoolss_ClosePrinter
 582 */
 583 static WERROR spoolss_ClosePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 584                        struct spoolss_ClosePrinter *r)
 585 {
 586         struct dcesrv_handle *h;
 587
 588         *r->out.handle = *r->in.handle;
 589
 590         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 591
 592         talloc_free(h);
 593
 594         ZERO_STRUCTP(r->out.handle);
 595
 596         return WERR_OK;
 597 }
 598
 599
 600 /*
 601   spoolss_AddForm
 602 */
 603 static WERROR spoolss_AddForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 604                        struct spoolss_AddForm *r)
 605 {
 606         struct ntptr_GenericHandle *handle;
 607         struct dcesrv_handle *h;
 608         WERROR status;
 609
 610         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 611         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
 612
 613         switch (handle->type) {
 614                 case NTPTR_HANDLE_SERVER:
 615                         status = ntptr_AddPrintServerForm(handle, mem_ctx, r);
 616                         W_ERROR_NOT_OK_RETURN(status);
 617                         break;
 618                 case NTPTR_HANDLE_PRINTER:
 619                         status = ntptr_AddPrinterForm(handle, mem_ctx, r);
 620                         W_ERROR_NOT_OK_RETURN(status);
 621                         break;
 622                 default:
 623                         return WERR_FOOBAR;
 624         }
 625
 626         return WERR_OK;
 627 }
 628
 629
 630 /*
 631   spoolss_DeleteForm
 632 */
 633 static WERROR spoolss_DeleteForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 634                        struct spoolss_DeleteForm *r)
 635 {
 636         struct ntptr_GenericHandle *handle;
 637         struct dcesrv_handle *h;
 638         WERROR status;
 639
 640         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 641         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
 642
 643         switch (handle->type) {
 644                 case NTPTR_HANDLE_SERVER:
 645                         status = ntptr_DeletePrintServerForm(handle, mem_ctx, r);
 646                         W_ERROR_NOT_OK_RETURN(status);
 647                         break;
 648                 case NTPTR_HANDLE_PRINTER:
 649                         status = ntptr_DeletePrinterForm(handle, mem_ctx, r);
 650                         W_ERROR_NOT_OK_RETURN(status);
 651                         break;
 652                 default:
 653                         return WERR_FOOBAR;
 654         }
 655
 656         return WERR_OK;
 657 }
 658
 659
 660 /*
 661   spoolss_GetForm
 662 */
 663 static WERROR spoolss_GetForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 664                        struct spoolss_GetForm *r)
 665 {
 666         struct ntptr_GenericHandle *handle;
 667         struct dcesrv_handle *h;
 668         WERROR status;
 669
 670         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 671         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
 672
 673         switch (handle->type) {
 674                 case NTPTR_HANDLE_SERVER:
 675                         /*
 676                          * stupid, but w2k3 returns WERR_BADFID here?
 677                          */
 678                         return WERR_BADFID;
 679                 case NTPTR_HANDLE_PRINTER:
 680                         status = ntptr_GetPrinterForm(handle, mem_ctx, r);
 681                         W_ERROR_NOT_OK_RETURN(status);
 682                         break;
 683                 default:
 684                         return WERR_FOOBAR;
 685         }
 686
 687         r->out.needed   = SPOOLSS_BUFFER_UNION(spoolss_FormInfo, r->out.info, r->in.level);
 688         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
 689         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 690 }
 691
 692
 693 /*
 694   spoolss_SetForm
 695 */
 696 static WERROR spoolss_SetForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 697                        struct spoolss_SetForm *r)
 698 {
 699         struct ntptr_GenericHandle *handle;
 700         struct dcesrv_handle *h;
 701         WERROR status;
 702
 703         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 704         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
 705
 706         switch (handle->type) {
 707                 case NTPTR_HANDLE_SERVER:
 708                         status = ntptr_SetPrintServerForm(handle, mem_ctx, r);
 709                         W_ERROR_NOT_OK_RETURN(status);
 710                         break;
 711                 case NTPTR_HANDLE_PRINTER:
 712                         status = ntptr_SetPrinterForm(handle, mem_ctx, r);
 713                         W_ERROR_NOT_OK_RETURN(status);
 714                         break;
 715                 default:
 716                         return WERR_FOOBAR;
 717         }
 718
 719         return WERR_OK;
 720 }
 721
 722
 723 /*
 724   spoolss_EnumForms
 725 */
 726 static WERROR spoolss_EnumForms(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 727                        struct spoolss_EnumForms *r)
 728 {
 729         struct ntptr_GenericHandle *handle;
 730         struct dcesrv_handle *h;
 731         WERROR status;
 732
 733         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 734         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
 735
 736         switch (handle->type) {
 737                 case NTPTR_HANDLE_SERVER:
 738                         status = ntptr_EnumPrintServerForms(handle, mem_ctx, r);
 739                         W_ERROR_NOT_OK_RETURN(status);
 740                         break;
 741                 case NTPTR_HANDLE_PRINTER:
 742                         status = ntptr_EnumPrinterForms(handle, mem_ctx, r);
 743                         W_ERROR_NOT_OK_RETURN(status);
 744                         break;
 745                 default:
 746                         return WERR_FOOBAR;
 747         }
 748
 749         r->out.needed   = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumForms, r->out.info, r->in.level, r->out.count);
 750         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
 751         r->out.count    = SPOOLSS_BUFFER_OK(r->out.count, 0);
 752         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 753 }
 754
 755
 756 /*
 757   spoolss_EnumPorts
 758 */
 759 static WERROR spoolss_EnumPorts(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 760                        struct spoolss_EnumPorts *r)
 761 {
 762         struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private, struct ntptr_context);
 763         WERROR status;
 764
 765         status = spoolss_check_server_name(dce_call, mem_ctx, r->in.servername);
 766         W_ERROR_NOT_OK_RETURN(status);
 767
 768         status = ntptr_EnumPorts(ntptr, mem_ctx, r);
 769         W_ERROR_NOT_OK_RETURN(status);
 770
 771         r->out.needed   = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumPorts, r->out.info, r->in.level, r->out.count);
 772         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
 773         r->out.count    = SPOOLSS_BUFFER_OK(r->out.count, 0);
 774         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 775 }
 776
 777
 778 /*
 779   spoolss_EnumMonitors
 780 */
 781 static WERROR spoolss_EnumMonitors(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 782                        struct spoolss_EnumMonitors *r)
 783 {
 784         struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private, struct ntptr_context);
 785         WERROR status;
 786
 787         status = spoolss_check_server_name(dce_call, mem_ctx, r->in.servername);
 788         W_ERROR_NOT_OK_RETURN(status);
 789
 790         status = ntptr_EnumMonitors(ntptr, mem_ctx, r);
 791         W_ERROR_NOT_OK_RETURN(status);
 792
 793         r->out.needed   = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumMonitors, r->out.info, r->in.level, r->out.count);
 794         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
 795         r->out.count    = SPOOLSS_BUFFER_OK(r->out.count, 0);
 796         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 797 }
 798
 799
 800 /*
 801   spoolss_AddPort
 802 */
 803 static WERROR spoolss_AddPort(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 804                        struct spoolss_AddPort *r)
 805 {
 806         return WERR_NOT_SUPPORTED;
 807 }
 808
 809
 810 /*
 811   spoolss_ConfigurePort
 812 */
 813 static WERROR spoolss_ConfigurePort(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 814                        struct spoolss_ConfigurePort *r)
 815 {
 816         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 817 }
 818
 819
 820 /*
 821   spoolss_DeletePort
 822 */
 823 static WERROR spoolss_DeletePort(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 824                        struct spoolss_DeletePort *r)
 825 {
 826         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 827 }
 828
 829
 830 /*
 831   spoolss_CreatePrinterIC
 832 */
 833 static WERROR spoolss_CreatePrinterIC(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 834                        struct spoolss_CreatePrinterIC *r)
 835 {
 836         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 837 }
 838
 839
 840 /*
 841   spoolss_PlayGDIScriptOnPrinterIC
 842 */
 843 static WERROR spoolss_PlayGDIScriptOnPrinterIC(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 844                        struct spoolss_PlayGDIScriptOnPrinterIC *r)
 845 {
 846         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 847 }
 848
 849
 850 /*
 851   spoolss_DeletePrinterIC
 852 */
 853 static WERROR spoolss_DeletePrinterIC(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 854                        struct spoolss_DeletePrinterIC *r)
 855 {
 856         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 857 }
 858
 859
 860 /*
 861   spoolss_AddPrinterConnection
 862 */
 863 static WERROR spoolss_AddPrinterConnection(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 864                        struct spoolss_AddPrinterConnection *r)
 865 {
 866         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 867 }
 868
 869
 870 /*
 871   spoolss_DeletePrinterConnection
 872 */
 873 static WERROR spoolss_DeletePrinterConnection(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 874                        struct spoolss_DeletePrinterConnection *r)
 875 {
 876         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 877 }
 878
 879
 880 /*
 881   spoolss_PrinterMessageBox
 882 */
 883 static WERROR spoolss_PrinterMessageBox(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 884                        struct spoolss_PrinterMessageBox *r)
 885 {
 886         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 887 }
 888
 889
 890 /*
 891   spoolss_AddMonitor
 892 */
 893 static WERROR spoolss_AddMonitor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 894                        struct spoolss_AddMonitor *r)
 895 {
 896         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 897 }
 898
 899
 900 /*
 901   spoolss_DeleteMonitor
 902 */
 903 static WERROR spoolss_DeleteMonitor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 904                        struct spoolss_DeleteMonitor *r)
 905 {
 906         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 907 }
 908
 909
 910 /*
 911   spoolss_DeletePrintProcessor
 912 */
 913 static WERROR spoolss_DeletePrintProcessor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 914                        struct spoolss_DeletePrintProcessor *r)
 915 {
 916         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 917 }
 918
 919
 920 /*
 921   spoolss_AddPrintProvidor
 922 */
 923 static WERROR spoolss_AddPrintProvidor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 924                        struct spoolss_AddPrintProvidor *r)
 925 {
 926         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 927 }
 928
 929
 930 /*
 931   spoolss_DeletePrintProvidor
 932 */
 933 static WERROR spoolss_DeletePrintProvidor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 934                        struct spoolss_DeletePrintProvidor *r)
 935 {
 936         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 937 }
 938
 939
 940 /*
 941   spoolss_EnumPrintProcDataTypes
 942 */
 943 static WERROR spoolss_EnumPrintProcDataTypes(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 944                        struct spoolss_EnumPrintProcDataTypes *r)
 945 {
 946         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 947 }
 948
 949
 950 /*
 951   spoolss_ResetPrinter
 952 */
 953 static WERROR spoolss_ResetPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 954                        struct spoolss_ResetPrinter *r)
 955 {
 956         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 957 }
 958
 959
 960 /*
 961   spoolss_GetPrinterDriver2
 962 */
 963 static WERROR spoolss_GetPrinterDriver2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 964                        struct spoolss_GetPrinterDriver2 *r)
 965 {
 966         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 967 }
 968
 969
 970 /*
 971   spoolss_FindFirstPrinterChangeNotification
 972 */
 973 static WERROR spoolss_FindFirstPrinterChangeNotification(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 974                        struct spoolss_FindFirstPrinterChangeNotification *r)
 975 {
 976         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 977 }
 978
 979
 980 /*
 981   spoolss_FindNextPrinterChangeNotification
 982 */
 983 static WERROR spoolss_FindNextPrinterChangeNotification(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 984                        struct spoolss_FindNextPrinterChangeNotification *r)
 985 {
 986         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 987 }
 988
 989
 990 /*
 991   spoolss_FindClosePrinterNotify
 992 */
 993 static WERROR spoolss_FindClosePrinterNotify(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 994                        struct spoolss_FindClosePrinterNotify *r)
 995 {
 996         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 997 }
 998
 999
1000 /*
1001   spoolss_RouterFindFirstPrinterChangeNotificationOld
1002 */
1003 static WERROR spoolss_RouterFindFirstPrinterChangeNotificationOld(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1004                        struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
1005 {
1006         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1007 }
1008
1009
1010 /*
1011   spoolss_ReplyOpenPrinter
1012 */
1013 static WERROR spoolss_ReplyOpenPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1014                        struct spoolss_ReplyOpenPrinter *r)
1015 {
1016         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1017 }
1018
1019
1020 /*
1021   spoolss_RouterReplyPrinter
1022 */
1023 static WERROR spoolss_RouterReplyPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1024                        struct spoolss_RouterReplyPrinter *r)
1025 {
1026         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1027 }
1028
1029
1030 /*
1031   spoolss_ReplyClosePrinter
1032 */
1033 static WERROR spoolss_ReplyClosePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1034                        struct spoolss_ReplyClosePrinter *r)
1035 {
1036         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1037 }
1038
1039
1040 /*
1041   spoolss_AddPortEx
1042 */
1043 static WERROR spoolss_AddPortEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1044                        struct spoolss_AddPortEx *r)
1045 {
1046         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1047 }
1048
1049
1050 /*
1051   spoolss_RouterFindFirstPrinterChangeNotification
1052 */
1053 static WERROR spoolss_RouterFindFirstPrinterChangeNotification(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1054                        struct spoolss_RouterFindFirstPrinterChangeNotification *r)
1055 {
1056         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1057 }
1058
1059
1060 /*
1061   spoolss_SpoolerInit
1062 */
1063 static WERROR spoolss_SpoolerInit(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1064                        struct spoolss_SpoolerInit *r)
1065 {
1066         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1067 }
1068
1069
1070 /*
1071   spoolss_ResetPrinterEx
1072 */
1073 static WERROR spoolss_ResetPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1074                        struct spoolss_ResetPrinterEx *r)
1075 {
1076         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1077 }
1078
1079
1080 /*
1081   spoolss_RemoteFindFirstPrinterChangeNotifyEx
1082 */
1083 static WERROR spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1084                        struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
1085 {
1086         /*
1087          * TODO: for now just return ok,
1088          *       to keep the w2k3 PrintServer
1089          *       happy to allow to open the Add Printer GUI
1090          */
1091         return WERR_OK;
1092 }
1093
1094
1095 /*
1096   spoolss_RouterRefreshPrinterChangeNotification
1097 */
1098 static WERROR spoolss_RouterRefreshPrinterChangeNotification(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1099                        struct spoolss_RouterRefreshPrinterChangeNotification *r)
1100 {
1101         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1102 }
1103
1104
1105 /*
1106   spoolss_RemoteFindNextPrinterChangeNotifyEx
1107 */
1108 static WERROR spoolss_RemoteFindNextPrinterChangeNotifyEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1109                        struct spoolss_RemoteFindNextPrinterChangeNotifyEx *r)
1110 {
1111         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1112 }
1113
1114
1115 /*
1116   spoolss_44
1117 */
1118 static WERROR spoolss_44(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1119                        struct spoolss_44 *r)
1120 {
1121         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1122 }
1123
1124 /*
1125   spoolss_OpenPrinterEx
1126 */
1127 static WERROR spoolss_OpenPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1128                        struct spoolss_OpenPrinterEx *r)
1129 {
1130         struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private, struct ntptr_context);
1131         struct ntptr_GenericHandle *handle;
1132         struct dcesrv_handle *h;
1133         const char *server;
1134         const char *object;
1135         enum ntptr_HandleType type;
1136         WERROR status;
1137
1138         ZERO_STRUCTP(r->out.handle);
1139
1140         status = spoolss_parse_printer_name(mem_ctx, r->in.printername, &server, &object, &type);
1141         W_ERROR_NOT_OK_RETURN(status);
1142
1143         status = spoolss_check_server_name(dce_call, mem_ctx, server);
1144         W_ERROR_NOT_OK_RETURN(status);
1145
1146         switch (type) {
1147                 case NTPTR_HANDLE_SERVER:
1148                         status = ntptr_OpenPrintServer(ntptr, mem_ctx, r, server, &handle);
1149                         W_ERROR_NOT_OK_RETURN(status);
1150                         break;
1151                 case NTPTR_HANDLE_PORT:
1152                         status = ntptr_OpenPort(ntptr, mem_ctx, r, object, &handle);
1153                         W_ERROR_NOT_OK_RETURN(status);
1154                         break;
1155                 case NTPTR_HANDLE_MONITOR:
1156                         status = ntptr_OpenMonitor(ntptr, mem_ctx, r, object, &handle);
1157                         W_ERROR_NOT_OK_RETURN(status);
1158                         break;
1159                 case NTPTR_HANDLE_PRINTER:
1160                         status = ntptr_OpenPrinter(ntptr, mem_ctx, r, object, &handle);
1161                         W_ERROR_NOT_OK_RETURN(status);
1162                         break;
1163                 default:
1164                         return WERR_FOOBAR;
1165         }
1166
1167         h = dcesrv_handle_new(dce_call->context, handle->type);
1168         W_ERROR_HAVE_NO_MEMORY(h);
1169
1170         h->data = talloc_steal(h, handle);
1171
1172         *r->out.handle  = h->wire_handle;
1173
1174         return WERR_OK;
1175 }
1176
1177 /*
1178   spoolss_AddPrinterEx
1179 */
1180 static WERROR spoolss_AddPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1181                        struct spoolss_AddPrinterEx *r)
1182 {
1183         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1184 }
1185
1186
1187 /*
1188   spoolss_47
1189 */
1190 static WERROR spoolss_47(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1191                        struct spoolss_47 *r)
1192 {
1193         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1194 }
1195
1196
1197 /*
1198   spoolss_EnumPrinterData
1199 */
1200 static WERROR spoolss_EnumPrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1201                        struct spoolss_EnumPrinterData *r)
1202 {
1203         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1204 }
1205
1206
1207 /*
1208   spoolss_DeletePrinterData
1209 */
1210 static WERROR spoolss_DeletePrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1211                        struct spoolss_DeletePrinterData *r)
1212 {
1213         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1214 }
1215
1216
1217 /*
1218   spoolss_4a
1219 */
1220 static WERROR spoolss_4a(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1221                        struct spoolss_4a *r)
1222 {
1223         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1224 }
1225
1226
1227 /*
1228   spoolss_4b
1229 */
1230 static WERROR spoolss_4b(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1231                        struct spoolss_4b *r)
1232 {
1233         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1234 }
1235
1236
1237 /*
1238   spoolss_4c
1239 */
1240 static WERROR spoolss_4c(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1241                        struct spoolss_4c *r)
1242 {
1243         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1244 }
1245
1246
1247 /*
1248   spoolss_SetPrinterDataEx
1249 */
1250 static WERROR spoolss_SetPrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1251                        struct spoolss_SetPrinterDataEx *r)
1252 {
1253         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1254 }
1255
1256
1257 /*
1258   spoolss_GetPrinterDataEx
1259 */
1260 static WERROR spoolss_GetPrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1261                        struct spoolss_GetPrinterDataEx *r)
1262 {
1263         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1264 }
1265
1266
1267 /*
1268   spoolss_EnumPrinterDataEx
1269 */
1270 static WERROR spoolss_EnumPrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1271                        struct spoolss_EnumPrinterDataEx *r)
1272 {
1273         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1274 }
1275
1276
1277 /*
1278   spoolss_EnumPrinterKey
1279 */
1280 static WERROR spoolss_EnumPrinterKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1281                        struct spoolss_EnumPrinterKey *r)
1282 {
1283         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1284 }
1285
1286
1287 /*
1288   spoolss_DeletePrinterDataEx
1289 */
1290 static WERROR spoolss_DeletePrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1291                        struct spoolss_DeletePrinterDataEx *r)
1292 {
1293         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1294 }
1295
1296
1297 /*
1298   spoolss_DeletePrinterKey
1299 */
1300 static WERROR spoolss_DeletePrinterKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1301                        struct spoolss_DeletePrinterKey *r)
1302 {
1303         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1304 }
1305
1306
1307 /*
1308   spoolss_53
1309 */
1310 static WERROR spoolss_53(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1311                        struct spoolss_53 *r)
1312 {
1313         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1314 }
1315
1316
1317 /*
1318   spoolss_DeletePrinterDriverEx
1319 */
1320 static WERROR spoolss_DeletePrinterDriverEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1321                        struct spoolss_DeletePrinterDriverEx *r)
1322 {
1323         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1324 }
1325
1326
1327 /*
1328   spoolss_55
1329 */
1330 static WERROR spoolss_55(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1331                        struct spoolss_55 *r)
1332 {
1333         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1334 }
1335
1336
1337 /*
1338   spoolss_56
1339 */
1340 static WERROR spoolss_56(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1341                        struct spoolss_56 *r)
1342 {
1343         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1344 }
1345
1346
1347 /*
1348   spoolss_57
1349 */
1350 static WERROR spoolss_57(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1351                        struct spoolss_57 *r)
1352 {
1353         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1354 }
1355
1356
1357 /*
1358   spoolss_58
1359 */
1360 static WERROR spoolss_58(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1361                        struct spoolss_58 *r)
1362 {
1363         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1364 }
1365
1366
1367 /*
1368   spoolss_AddPrinterDriverEx
1369 */
1370 static WERROR spoolss_AddPrinterDriverEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1371                        struct spoolss_AddPrinterDriverEx *r)
1372 {
1373         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1374 }
1375
1376
1377 /*
1378   spoolss_5a
1379 */
1380 static WERROR spoolss_5a(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1381                        struct spoolss_5a *r)
1382 {
1383         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1384 }
1385
1386
1387 /*
1388   spoolss_5b
1389 */
1390 static WERROR spoolss_5b(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1391                        struct spoolss_5b *r)
1392 {
1393         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1394 }
1395
1396
1397 /*
1398   spoolss_5c
1399 */
1400 static WERROR spoolss_5c(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1401                        struct spoolss_5c *r)
1402 {
1403         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1404 }
1405
1406
1407 /*
1408   spoolss_5d
1409 */
1410 static WERROR spoolss_5d(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1411                        struct spoolss_5d *r)
1412 {
1413         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1414 }
1415
1416
1417 /*
1418   spoolss_5e
1419 */
1420 static WERROR spoolss_5e(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1421                        struct spoolss_5e *r)
1422 {
1423         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1424 }
1425
1426
1427 /*
1428   spoolss_5f
1429 */
1430 static WERROR spoolss_5f(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1431                        struct spoolss_5f *r)
1432 {
1433         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1434 }
1435
1436
1437 /* include the generated boilerplate */
1438 #include "librpc/gen_ndr/ndr_spoolss_s.c"