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