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