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()) {
 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         if (!handle)
 542                 return WERR_BADFID;
 543
 544         switch (handle->type) {
 545                 case NTPTR_HANDLE_SERVER:
 546                         status = ntptr_GetPrintServerData(handle, mem_ctx, r);
 547                         break;
 548                 default:
 549                         status = WERR_FOOBAR;
 550                         break;
 551         }
 552
 553         W_ERROR_NOT_OK_RETURN(status);
 554
 555         r->out.needed   = ndr_size_spoolss_PrinterData(&r->out.data, r->out.type, 0);
 556         r->out.type     = SPOOLSS_BUFFER_OK(r->out.type, SPOOLSS_PRINTER_DATA_TYPE_NULL);
 557         r->out.data     = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
 558         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
 559 }
 560
 561
 562 /*
 563   spoolss_SetPrinterData
 564 */
 565 static WERROR spoolss_SetPrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 566                        struct spoolss_SetPrinterData *r)
 567 {
 568         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 569 }
 570
 571
 572 /*
 573   spoolss_WaitForPrinterChange
 574 */
 575 static WERROR spoolss_WaitForPrinterChange(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 576                        struct spoolss_WaitForPrinterChange *r)
 577 {
 578         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 579 }
 580
 581
 582 /*
 583   spoolss_ClosePrinter
 584 */
 585 static WERROR spoolss_ClosePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 586                        struct spoolss_ClosePrinter *r)
 587 {
 588         struct dcesrv_handle *h;
 589
 590         *r->out.handle = *r->in.handle;
 591
 592         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 593
 594         talloc_free(h);
 595
 596         ZERO_STRUCTP(r->out.handle);
 597
 598         return WERR_OK;
 599 }
 600
 601
 602 /*
 603   spoolss_AddForm
 604 */
 605 static WERROR spoolss_AddForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 606                        struct spoolss_AddForm *r)
 607 {
 608         struct ntptr_GenericHandle *handle;
 609         struct dcesrv_handle *h;
 610         WERROR status;
 611
 612         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 613         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
 614         if (!handle)
 615                 return WERR_BADFID;
 616
 617         switch (handle->type) {
 618                 case NTPTR_HANDLE_SERVER:
 619                         status = ntptr_AddPrintServerForm(handle, mem_ctx, r);
 620                         W_ERROR_NOT_OK_RETURN(status);
 621                         break;
 622                 case NTPTR_HANDLE_PRINTER:
 623                         status = ntptr_AddPrinterForm(handle, mem_ctx, r);
 624                         W_ERROR_NOT_OK_RETURN(status);
 625                         break;
 626                 default:
 627                         return WERR_FOOBAR;
 628         }
 629
 630         return WERR_OK;
 631 }
 632
 633
 634 /*
 635   spoolss_DeleteForm
 636 */
 637 static WERROR spoolss_DeleteForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 638                        struct spoolss_DeleteForm *r)
 639 {
 640         struct ntptr_GenericHandle *handle;
 641         struct dcesrv_handle *h;
 642         WERROR status;
 643
 644         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 645         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
 646         if (!handle)
 647                 return WERR_BADFID;
 648
 649         switch (handle->type) {
 650                 case NTPTR_HANDLE_SERVER:
 651                         status = ntptr_DeletePrintServerForm(handle, mem_ctx, r);
 652                         W_ERROR_NOT_OK_RETURN(status);
 653                         break;
 654                 case NTPTR_HANDLE_PRINTER:
 655                         status = ntptr_DeletePrinterForm(handle, mem_ctx, r);
 656                         W_ERROR_NOT_OK_RETURN(status);
 657                         break;
 658                 default:
 659                         return WERR_FOOBAR;
 660         }
 661
 662         return WERR_OK;
 663 }
 664
 665
 666 /*
 667   spoolss_GetForm
 668 */
 669 static WERROR spoolss_GetForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 670                        struct spoolss_GetForm *r)
 671 {
 672         struct ntptr_GenericHandle *handle;
 673         struct dcesrv_handle *h;
 674         WERROR status;
 675
 676         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 677         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
 678         if (!handle)
 679                 return WERR_BADFID;
 680
 681         switch (handle->type) {
 682                 case NTPTR_HANDLE_SERVER:
 683                         /*
 684                          * stupid, but w2k3 returns WERR_BADFID here?
 685                          */
 686                         return WERR_BADFID;
 687                 case NTPTR_HANDLE_PRINTER:
 688                         status = ntptr_GetPrinterForm(handle, mem_ctx, r);
 689                         W_ERROR_NOT_OK_RETURN(status);
 690                         break;
 691                 default:
 692                         return WERR_FOOBAR;
 693         }
 694
 695         r->out.needed   = SPOOLSS_BUFFER_UNION(spoolss_FormInfo, r->out.info, r->in.level);
 696         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
 697         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 698 }
 699
 700
 701 /*
 702   spoolss_SetForm
 703 */
 704 static WERROR spoolss_SetForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 705                        struct spoolss_SetForm *r)
 706 {
 707         struct ntptr_GenericHandle *handle;
 708         struct dcesrv_handle *h;
 709         WERROR status;
 710
 711         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 712         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
 713         if (!handle)
 714                 return WERR_BADFID;
 715
 716         switch (handle->type) {
 717                 case NTPTR_HANDLE_SERVER:
 718                         status = ntptr_SetPrintServerForm(handle, mem_ctx, r);
 719                         W_ERROR_NOT_OK_RETURN(status);
 720                         break;
 721                 case NTPTR_HANDLE_PRINTER:
 722                         status = ntptr_SetPrinterForm(handle, mem_ctx, r);
 723                         W_ERROR_NOT_OK_RETURN(status);
 724                         break;
 725                 default:
 726                         return WERR_FOOBAR;
 727         }
 728
 729         return WERR_OK;
 730 }
 731
 732
 733 /*
 734   spoolss_EnumForms
 735 */
 736 static WERROR spoolss_EnumForms(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 737                        struct spoolss_EnumForms *r)
 738 {
 739         struct ntptr_GenericHandle *handle;
 740         struct dcesrv_handle *h;
 741         WERROR status;
 742
 743         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 744         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
 745         if (!handle)
 746                 return WERR_BADFID;
 747
 748         switch (handle->type) {
 749                 case NTPTR_HANDLE_SERVER:
 750                         status = ntptr_EnumPrintServerForms(handle, mem_ctx, r);
 751                         W_ERROR_NOT_OK_RETURN(status);
 752                         break;
 753                 case NTPTR_HANDLE_PRINTER:
 754                         status = ntptr_EnumPrinterForms(handle, mem_ctx, r);
 755                         W_ERROR_NOT_OK_RETURN(status);
 756                         break;
 757                 default:
 758                         return WERR_FOOBAR;
 759         }
 760
 761         r->out.needed   = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumForms, r->out.info, r->in.level, r->out.count);
 762         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
 763         r->out.count    = SPOOLSS_BUFFER_OK(r->out.count, 0);
 764         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 765 }
 766
 767
 768 /*
 769   spoolss_EnumPorts
 770 */
 771 static WERROR spoolss_EnumPorts(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 772                        struct spoolss_EnumPorts *r)
 773 {
 774         struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private, struct ntptr_context);
 775         WERROR status;
 776
 777         status = spoolss_check_server_name(dce_call, mem_ctx, r->in.servername);
 778         W_ERROR_NOT_OK_RETURN(status);
 779
 780         status = ntptr_EnumPorts(ntptr, mem_ctx, r);
 781         W_ERROR_NOT_OK_RETURN(status);
 782
 783         r->out.needed   = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumPorts, r->out.info, r->in.level, r->out.count);
 784         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
 785         r->out.count    = SPOOLSS_BUFFER_OK(r->out.count, 0);
 786         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 787 }
 788
 789
 790 /*
 791   spoolss_EnumMonitors
 792 */
 793 static WERROR spoolss_EnumMonitors(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 794                        struct spoolss_EnumMonitors *r)
 795 {
 796         struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private, struct ntptr_context);
 797         WERROR status;
 798
 799         status = spoolss_check_server_name(dce_call, mem_ctx, r->in.servername);
 800         W_ERROR_NOT_OK_RETURN(status);
 801
 802         status = ntptr_EnumMonitors(ntptr, mem_ctx, r);
 803         W_ERROR_NOT_OK_RETURN(status);
 804
 805         r->out.needed   = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumMonitors, r->out.info, r->in.level, r->out.count);
 806         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
 807         r->out.count    = SPOOLSS_BUFFER_OK(r->out.count, 0);
 808         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 809 }
 810
 811
 812 /*
 813   spoolss_AddPort
 814 */
 815 static WERROR spoolss_AddPort(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 816                        struct spoolss_AddPort *r)
 817 {
 818         return WERR_NOT_SUPPORTED;
 819 }
 820
 821
 822 /*
 823   spoolss_ConfigurePort
 824 */
 825 static WERROR spoolss_ConfigurePort(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 826                        struct spoolss_ConfigurePort *r)
 827 {
 828         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 829 }
 830
 831
 832 /*
 833   spoolss_DeletePort
 834 */
 835 static WERROR spoolss_DeletePort(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 836                        struct spoolss_DeletePort *r)
 837 {
 838         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 839 }
 840
 841
 842 /*
 843   spoolss_CreatePrinterIC
 844 */
 845 static WERROR spoolss_CreatePrinterIC(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 846                        struct spoolss_CreatePrinterIC *r)
 847 {
 848         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 849 }
 850
 851
 852 /*
 853   spoolss_PlayGDIScriptOnPrinterIC
 854 */
 855 static WERROR spoolss_PlayGDIScriptOnPrinterIC(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 856                        struct spoolss_PlayGDIScriptOnPrinterIC *r)
 857 {
 858         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 859 }
 860
 861
 862 /*
 863   spoolss_DeletePrinterIC
 864 */
 865 static WERROR spoolss_DeletePrinterIC(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 866                        struct spoolss_DeletePrinterIC *r)
 867 {
 868         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 869 }
 870
 871
 872 /*
 873   spoolss_AddPrinterConnection
 874 */
 875 static WERROR spoolss_AddPrinterConnection(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 876                        struct spoolss_AddPrinterConnection *r)
 877 {
 878         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 879 }
 880
 881
 882 /*
 883   spoolss_DeletePrinterConnection
 884 */
 885 static WERROR spoolss_DeletePrinterConnection(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 886                        struct spoolss_DeletePrinterConnection *r)
 887 {
 888         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 889 }
 890
 891
 892 /*
 893   spoolss_PrinterMessageBox
 894 */
 895 static WERROR spoolss_PrinterMessageBox(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 896                        struct spoolss_PrinterMessageBox *r)
 897 {
 898         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 899 }
 900
 901
 902 /*
 903   spoolss_AddMonitor
 904 */
 905 static WERROR spoolss_AddMonitor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 906                        struct spoolss_AddMonitor *r)
 907 {
 908         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 909 }
 910
 911
 912 /*
 913   spoolss_DeleteMonitor
 914 */
 915 static WERROR spoolss_DeleteMonitor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 916                        struct spoolss_DeleteMonitor *r)
 917 {
 918         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 919 }
 920
 921
 922 /*
 923   spoolss_DeletePrintProcessor
 924 */
 925 static WERROR spoolss_DeletePrintProcessor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 926                        struct spoolss_DeletePrintProcessor *r)
 927 {
 928         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 929 }
 930
 931
 932 /*
 933   spoolss_AddPrintProvidor
 934 */
 935 static WERROR spoolss_AddPrintProvidor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 936                        struct spoolss_AddPrintProvidor *r)
 937 {
 938         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 939 }
 940
 941
 942 /*
 943   spoolss_DeletePrintProvidor
 944 */
 945 static WERROR spoolss_DeletePrintProvidor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 946                        struct spoolss_DeletePrintProvidor *r)
 947 {
 948         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 949 }
 950
 951
 952 /*
 953   spoolss_EnumPrintProcDataTypes
 954 */
 955 static WERROR spoolss_EnumPrintProcDataTypes(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 956                        struct spoolss_EnumPrintProcDataTypes *r)
 957 {
 958         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 959 }
 960
 961
 962 /*
 963   spoolss_ResetPrinter
 964 */
 965 static WERROR spoolss_ResetPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 966                        struct spoolss_ResetPrinter *r)
 967 {
 968         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 969 }
 970
 971
 972 /*
 973   spoolss_GetPrinterDriver2
 974 */
 975 static WERROR spoolss_GetPrinterDriver2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 976                        struct spoolss_GetPrinterDriver2 *r)
 977 {
 978         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 979 }
 980
 981
 982 /*
 983   spoolss_FindFirstPrinterChangeNotification
 984 */
 985 static WERROR spoolss_FindFirstPrinterChangeNotification(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 986                        struct spoolss_FindFirstPrinterChangeNotification *r)
 987 {
 988         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 989 }
 990
 991
 992 /*
 993   spoolss_FindNextPrinterChangeNotification
 994 */
 995 static WERROR spoolss_FindNextPrinterChangeNotification(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 996                        struct spoolss_FindNextPrinterChangeNotification *r)
 997 {
 998         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 999 }
1000
1001
1002 /*
1003   spoolss_FindClosePrinterNotify
1004 */
1005 static WERROR spoolss_FindClosePrinterNotify(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1006                        struct spoolss_FindClosePrinterNotify *r)
1007 {
1008         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1009 }
1010
1011
1012 /*
1013   spoolss_RouterFindFirstPrinterChangeNotificationOld
1014 */
1015 static WERROR spoolss_RouterFindFirstPrinterChangeNotificationOld(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1016                        struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
1017 {
1018         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1019 }
1020
1021
1022 /*
1023   spoolss_ReplyOpenPrinter
1024 */
1025 static WERROR spoolss_ReplyOpenPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1026                        struct spoolss_ReplyOpenPrinter *r)
1027 {
1028         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1029 }
1030
1031
1032 /*
1033   spoolss_RouterReplyPrinter
1034 */
1035 static WERROR spoolss_RouterReplyPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1036                        struct spoolss_RouterReplyPrinter *r)
1037 {
1038         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1039 }
1040
1041
1042 /*
1043   spoolss_ReplyClosePrinter
1044 */
1045 static WERROR spoolss_ReplyClosePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1046                        struct spoolss_ReplyClosePrinter *r)
1047 {
1048         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1049 }
1050
1051
1052 /*
1053   spoolss_AddPortEx
1054 */
1055 static WERROR spoolss_AddPortEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1056                        struct spoolss_AddPortEx *r)
1057 {
1058         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1059 }
1060
1061
1062 /*
1063   spoolss_RouterFindFirstPrinterChangeNotification
1064 */
1065 static WERROR spoolss_RouterFindFirstPrinterChangeNotification(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1066                        struct spoolss_RouterFindFirstPrinterChangeNotification *r)
1067 {
1068         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1069 }
1070
1071
1072 /*
1073   spoolss_SpoolerInit
1074 */
1075 static WERROR spoolss_SpoolerInit(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1076                        struct spoolss_SpoolerInit *r)
1077 {
1078         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1079 }
1080
1081
1082 /*
1083   spoolss_ResetPrinterEx
1084 */
1085 static WERROR spoolss_ResetPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1086                        struct spoolss_ResetPrinterEx *r)
1087 {
1088         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1089 }
1090
1091
1092 /*
1093   spoolss_RemoteFindFirstPrinterChangeNotifyEx
1094 */
1095 static WERROR spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1096                        struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
1097 {
1098         /*
1099          * TODO: for now just return ok,
1100          *       to keep the w2k3 PrintServer
1101          *       happy to allow to open the Add Printer GUI
1102          */
1103         return WERR_OK;
1104 }
1105
1106
1107 /*
1108   spoolss_RouterRefreshPrinterChangeNotification
1109 */
1110 static WERROR spoolss_RouterRefreshPrinterChangeNotification(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1111                        struct spoolss_RouterRefreshPrinterChangeNotification *r)
1112 {
1113         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1114 }
1115
1116
1117 /*
1118   spoolss_RemoteFindNextPrinterChangeNotifyEx
1119 */
1120 static WERROR spoolss_RemoteFindNextPrinterChangeNotifyEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1121                        struct spoolss_RemoteFindNextPrinterChangeNotifyEx *r)
1122 {
1123         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1124 }
1125
1126
1127 /*
1128   spoolss_44
1129 */
1130 static WERROR spoolss_44(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1131                        struct spoolss_44 *r)
1132 {
1133         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1134 }
1135
1136 /*
1137   spoolss_OpenPrinterEx
1138 */
1139 static WERROR spoolss_OpenPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1140                        struct spoolss_OpenPrinterEx *r)
1141 {
1142         struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private, struct ntptr_context);
1143         struct ntptr_GenericHandle *handle;
1144         struct dcesrv_handle *h;
1145         const char *server;
1146         const char *object;
1147         enum ntptr_HandleType type;
1148         WERROR status;
1149
1150         ZERO_STRUCTP(r->out.handle);
1151
1152         status = spoolss_parse_printer_name(mem_ctx, r->in.printername, &server, &object, &type);
1153         W_ERROR_NOT_OK_RETURN(status);
1154
1155         status = spoolss_check_server_name(dce_call, mem_ctx, server);
1156         W_ERROR_NOT_OK_RETURN(status);
1157
1158         switch (type) {
1159                 case NTPTR_HANDLE_SERVER:
1160                         status = ntptr_OpenPrintServer(ntptr, mem_ctx, r, server, &handle);
1161                         W_ERROR_NOT_OK_RETURN(status);
1162                         break;
1163                 case NTPTR_HANDLE_PORT:
1164                         status = ntptr_OpenPort(ntptr, mem_ctx, r, object, &handle);
1165                         W_ERROR_NOT_OK_RETURN(status);
1166                         break;
1167                 case NTPTR_HANDLE_MONITOR:
1168                         status = ntptr_OpenMonitor(ntptr, mem_ctx, r, object, &handle);
1169                         W_ERROR_NOT_OK_RETURN(status);
1170                         break;
1171                 case NTPTR_HANDLE_PRINTER:
1172                         status = ntptr_OpenPrinter(ntptr, mem_ctx, r, object, &handle);
1173                         W_ERROR_NOT_OK_RETURN(status);
1174                         break;
1175                 default:
1176                         return WERR_FOOBAR;
1177         }
1178
1179         h = dcesrv_handle_new(dce_call->context, handle->type);
1180         W_ERROR_HAVE_NO_MEMORY(h);
1181
1182         h->data = talloc_steal(h, handle);
1183
1184         *r->out.handle  = h->wire_handle;
1185
1186         return WERR_OK;
1187 }
1188
1189 /*
1190   spoolss_AddPrinterEx
1191 */
1192 static WERROR spoolss_AddPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1193                        struct spoolss_AddPrinterEx *r)
1194 {
1195         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1196 }
1197
1198
1199 /*
1200   spoolss_47
1201 */
1202 static WERROR spoolss_47(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1203                        struct spoolss_47 *r)
1204 {
1205         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1206 }
1207
1208
1209 /*
1210   spoolss_EnumPrinterData
1211 */
1212 static WERROR spoolss_EnumPrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1213                        struct spoolss_EnumPrinterData *r)
1214 {
1215         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1216 }
1217
1218
1219 /*
1220   spoolss_DeletePrinterData
1221 */
1222 static WERROR spoolss_DeletePrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1223                        struct spoolss_DeletePrinterData *r)
1224 {
1225         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1226 }
1227
1228
1229 /*
1230   spoolss_4a
1231 */
1232 static WERROR spoolss_4a(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1233                        struct spoolss_4a *r)
1234 {
1235         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1236 }
1237
1238
1239 /*
1240   spoolss_4b
1241 */
1242 static WERROR spoolss_4b(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1243                        struct spoolss_4b *r)
1244 {
1245         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1246 }
1247
1248
1249 /*
1250   spoolss_4c
1251 */
1252 static WERROR spoolss_4c(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1253                        struct spoolss_4c *r)
1254 {
1255         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1256 }
1257
1258
1259 /*
1260   spoolss_SetPrinterDataEx
1261 */
1262 static WERROR spoolss_SetPrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1263                        struct spoolss_SetPrinterDataEx *r)
1264 {
1265         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1266 }
1267
1268
1269 /*
1270   spoolss_GetPrinterDataEx
1271 */
1272 static WERROR spoolss_GetPrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1273                        struct spoolss_GetPrinterDataEx *r)
1274 {
1275         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1276 }
1277
1278
1279 /*
1280   spoolss_EnumPrinterDataEx
1281 */
1282 static WERROR spoolss_EnumPrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1283                        struct spoolss_EnumPrinterDataEx *r)
1284 {
1285         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1286 }
1287
1288
1289 /*
1290   spoolss_EnumPrinterKey
1291 */
1292 static WERROR spoolss_EnumPrinterKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1293                        struct spoolss_EnumPrinterKey *r)
1294 {
1295         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1296 }
1297
1298
1299 /*
1300   spoolss_DeletePrinterDataEx
1301 */
1302 static WERROR spoolss_DeletePrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1303                        struct spoolss_DeletePrinterDataEx *r)
1304 {
1305         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1306 }
1307
1308
1309 /*
1310   spoolss_DeletePrinterKey
1311 */
1312 static WERROR spoolss_DeletePrinterKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1313                        struct spoolss_DeletePrinterKey *r)
1314 {
1315         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1316 }
1317
1318
1319 /*
1320   spoolss_53
1321 */
1322 static WERROR spoolss_53(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1323                        struct spoolss_53 *r)
1324 {
1325         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1326 }
1327
1328
1329 /*
1330   spoolss_DeletePrinterDriverEx
1331 */
1332 static WERROR spoolss_DeletePrinterDriverEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1333                        struct spoolss_DeletePrinterDriverEx *r)
1334 {
1335         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1336 }
1337
1338
1339 /*
1340   spoolss_55
1341 */
1342 static WERROR spoolss_55(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1343                        struct spoolss_55 *r)
1344 {
1345         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1346 }
1347
1348
1349 /*
1350   spoolss_56
1351 */
1352 static WERROR spoolss_56(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1353                        struct spoolss_56 *r)
1354 {
1355         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1356 }
1357
1358
1359 /*
1360   spoolss_57
1361 */
1362 static WERROR spoolss_57(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1363                        struct spoolss_57 *r)
1364 {
1365         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1366 }
1367
1368
1369 /*
1370   spoolss_58
1371 */
1372 static WERROR spoolss_58(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1373                        struct spoolss_58 *r)
1374 {
1375         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1376 }
1377
1378
1379 /*
1380   spoolss_AddPrinterDriverEx
1381 */
1382 static WERROR spoolss_AddPrinterDriverEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1383                        struct spoolss_AddPrinterDriverEx *r)
1384 {
1385         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1386 }
1387
1388
1389 /*
1390   spoolss_5a
1391 */
1392 static WERROR spoolss_5a(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1393                        struct spoolss_5a *r)
1394 {
1395         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1396 }
1397
1398
1399 /*
1400   spoolss_5b
1401 */
1402 static WERROR spoolss_5b(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1403                        struct spoolss_5b *r)
1404 {
1405         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1406 }
1407
1408
1409 /*
1410   spoolss_5c
1411 */
1412 static WERROR spoolss_5c(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1413                        struct spoolss_5c *r)
1414 {
1415         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1416 }
1417
1418
1419 /*
1420   spoolss_5d
1421 */
1422 static WERROR spoolss_5d(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1423                        struct spoolss_5d *r)
1424 {
1425         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1426 }
1427
1428
1429 /*
1430   spoolss_5e
1431 */
1432 static WERROR spoolss_5e(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1433                        struct spoolss_5e *r)
1434 {
1435         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1436 }
1437
1438
1439 /*
1440   spoolss_5f
1441 */
1442 static WERROR spoolss_5f(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1443                        struct spoolss_5f *r)
1444 {
1445         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1446 }
1447
1448
1449 /* include the generated boilerplate */
1450 #include "librpc/gen_ndr/ndr_spoolss_s.c"