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_array(mem_ctx, uint8_t, r->in.needed);
 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.type    = SPOOLSS_BUFFER_OK(*r->out.type, REG_NONE);
 602         r->out.data     = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
 603         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
 604 }
 605
 606
 607 /*
 608   spoolss_SetPrinterData
 609 */
 610 static WERROR dcesrv_spoolss_SetPrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 611                        struct spoolss_SetPrinterData *r)
 612 {
 613         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 614 }
 615
 616
 617 /*
 618   spoolss_WaitForPrinterChange
 619 */
 620 static WERROR dcesrv_spoolss_WaitForPrinterChange(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 621                        struct spoolss_WaitForPrinterChange *r)
 622 {
 623         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 624 }
 625
 626
 627 /*
 628   spoolss_ClosePrinter
 629 */
 630 static WERROR dcesrv_spoolss_ClosePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 631                        struct spoolss_ClosePrinter *r)
 632 {
 633         struct dcesrv_handle *h;
 634
 635         *r->out.handle = *r->in.handle;
 636
 637         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 638
 639         talloc_free(h);
 640
 641         ZERO_STRUCTP(r->out.handle);
 642
 643         return WERR_OK;
 644 }
 645
 646
 647 /*
 648   spoolss_AddForm
 649 */
 650 static WERROR dcesrv_spoolss_AddForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 651                        struct spoolss_AddForm *r)
 652 {
 653         struct ntptr_GenericHandle *handle;
 654         struct dcesrv_handle *h;
 655         WERROR status;
 656
 657         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 658         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
 659         if (!handle)
 660                 return WERR_BADFID;
 661
 662         switch (handle->type) {
 663                 case NTPTR_HANDLE_SERVER:
 664                         status = ntptr_AddPrintServerForm(handle, mem_ctx, r);
 665                         W_ERROR_NOT_OK_RETURN(status);
 666                         break;
 667                 case NTPTR_HANDLE_PRINTER:
 668                         status = ntptr_AddPrinterForm(handle, mem_ctx, r);
 669                         W_ERROR_NOT_OK_RETURN(status);
 670                         break;
 671                 default:
 672                         return WERR_FOOBAR;
 673         }
 674
 675         return WERR_OK;
 676 }
 677
 678
 679 /*
 680   spoolss_DeleteForm
 681 */
 682 static WERROR dcesrv_spoolss_DeleteForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 683                        struct spoolss_DeleteForm *r)
 684 {
 685         struct ntptr_GenericHandle *handle;
 686         struct dcesrv_handle *h;
 687         WERROR status;
 688
 689         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 690         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
 691         if (!handle)
 692                 return WERR_BADFID;
 693
 694         switch (handle->type) {
 695                 case NTPTR_HANDLE_SERVER:
 696                         status = ntptr_DeletePrintServerForm(handle, mem_ctx, r);
 697                         W_ERROR_NOT_OK_RETURN(status);
 698                         break;
 699                 case NTPTR_HANDLE_PRINTER:
 700                         status = ntptr_DeletePrinterForm(handle, mem_ctx, r);
 701                         W_ERROR_NOT_OK_RETURN(status);
 702                         break;
 703                 default:
 704                         return WERR_FOOBAR;
 705         }
 706
 707         return WERR_OK;
 708 }
 709
 710
 711 /*
 712   spoolss_GetForm
 713 */
 714 static WERROR dcesrv_spoolss_GetForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 715                        struct spoolss_GetForm *r)
 716 {
 717         struct ntptr_GenericHandle *handle;
 718         struct dcesrv_handle *h;
 719         WERROR status;
 720         struct smb_iconv_convenience *ic = lp_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx);
 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                         /*
 730                          * stupid, but w2k3 returns WERR_BADFID here?
 731                          */
 732                         return WERR_BADFID;
 733                 case NTPTR_HANDLE_PRINTER:
 734                         status = ntptr_GetPrinterForm(handle, mem_ctx, r);
 735                         W_ERROR_NOT_OK_RETURN(status);
 736                         break;
 737                 default:
 738                         return WERR_FOOBAR;
 739         }
 740
 741         *r->out.needed  = SPOOLSS_BUFFER_UNION(spoolss_FormInfo, ic, r->out.info, r->in.level);
 742         r->out.info     = SPOOLSS_BUFFER_OK(r->out.info, NULL);
 743         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 744 }
 745
 746
 747 /*
 748   spoolss_SetForm
 749 */
 750 static WERROR dcesrv_spoolss_SetForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 751                        struct spoolss_SetForm *r)
 752 {
 753         struct ntptr_GenericHandle *handle;
 754         struct dcesrv_handle *h;
 755         WERROR status;
 756
 757         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 758         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
 759         if (!handle)
 760                 return WERR_BADFID;
 761
 762         switch (handle->type) {
 763                 case NTPTR_HANDLE_SERVER:
 764                         status = ntptr_SetPrintServerForm(handle, mem_ctx, r);
 765                         W_ERROR_NOT_OK_RETURN(status);
 766                         break;
 767                 case NTPTR_HANDLE_PRINTER:
 768                         status = ntptr_SetPrinterForm(handle, mem_ctx, r);
 769                         W_ERROR_NOT_OK_RETURN(status);
 770                         break;
 771                 default:
 772                         return WERR_FOOBAR;
 773         }
 774
 775         return WERR_OK;
 776 }
 777
 778
 779 /*
 780   spoolss_EnumForms
 781 */
 782 static WERROR dcesrv_spoolss_EnumForms(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 783                        struct spoolss_EnumForms *r)
 784 {
 785         struct ntptr_GenericHandle *handle;
 786         struct dcesrv_handle *h;
 787         WERROR status;
 788         struct smb_iconv_convenience *ic = lp_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx);
 789
 790         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 791         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
 792         if (!handle)
 793                 return WERR_BADFID;
 794
 795         switch (handle->type) {
 796                 case NTPTR_HANDLE_SERVER:
 797                         status = ntptr_EnumPrintServerForms(handle, mem_ctx, r);
 798                         W_ERROR_NOT_OK_RETURN(status);
 799                         break;
 800                 case NTPTR_HANDLE_PRINTER:
 801                         status = ntptr_EnumPrinterForms(handle, mem_ctx, r);
 802                         W_ERROR_NOT_OK_RETURN(status);
 803                         break;
 804                 default:
 805                         return WERR_FOOBAR;
 806         }
 807
 808         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumForms, ic, *r->out.info, r->in.level, *r->out.count);
 809         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
 810         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
 811         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 812 }
 813
 814
 815 /*
 816   spoolss_EnumPorts
 817 */
 818 static WERROR dcesrv_spoolss_EnumPorts(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 819                        struct spoolss_EnumPorts *r)
 820 {
 821         struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private_data, struct ntptr_context);
 822         WERROR status;
 823         struct smb_iconv_convenience *ic = lp_iconv_convenience(ntptr->lp_ctx);
 824
 825         status = dcesrv_spoolss_check_server_name(dce_call, mem_ctx, r->in.servername);
 826         W_ERROR_NOT_OK_RETURN(status);
 827
 828         status = ntptr_EnumPorts(ntptr, mem_ctx, r);
 829         W_ERROR_NOT_OK_RETURN(status);
 830
 831         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumPorts, ic, *r->out.info, r->in.level, *r->out.count);
 832         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
 833         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
 834         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 835 }
 836
 837
 838 /*
 839   spoolss_EnumMonitors
 840 */
 841 static WERROR dcesrv_spoolss_EnumMonitors(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 842                        struct spoolss_EnumMonitors *r)
 843 {
 844         struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private_data, struct ntptr_context);
 845         WERROR status;
 846         struct smb_iconv_convenience *ic = lp_iconv_convenience(ntptr->lp_ctx);
 847
 848         status = dcesrv_spoolss_check_server_name(dce_call, mem_ctx, r->in.servername);
 849         W_ERROR_NOT_OK_RETURN(status);
 850
 851         status = ntptr_EnumMonitors(ntptr, mem_ctx, r);
 852         W_ERROR_NOT_OK_RETURN(status);
 853
 854         *r->out.needed  = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumMonitors, ic, *r->out.info, r->in.level, *r->out.count);
 855         *r->out.info    = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
 856         *r->out.count   = SPOOLSS_BUFFER_OK(*r->out.count, 0);
 857         return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
 858 }
 859
 860
 861 /*
 862   spoolss_AddPort
 863 */
 864 static WERROR dcesrv_spoolss_AddPort(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 865                        struct spoolss_AddPort *r)
 866 {
 867         return WERR_NOT_SUPPORTED;
 868 }
 869
 870
 871 /*
 872   spoolss_ConfigurePort
 873 */
 874 static WERROR dcesrv_spoolss_ConfigurePort(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 875                        struct spoolss_ConfigurePort *r)
 876 {
 877         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 878 }
 879
 880
 881 /*
 882   spoolss_DeletePort
 883 */
 884 static WERROR dcesrv_spoolss_DeletePort(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 885                        struct spoolss_DeletePort *r)
 886 {
 887         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 888 }
 889
 890
 891 /*
 892   spoolss_CreatePrinterIC
 893 */
 894 static WERROR dcesrv_spoolss_CreatePrinterIC(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 895                        struct spoolss_CreatePrinterIC *r)
 896 {
 897         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 898 }
 899
 900
 901 /*
 902   spoolss_PlayGDIScriptOnPrinterIC
 903 */
 904 static WERROR dcesrv_spoolss_PlayGDIScriptOnPrinterIC(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 905                        struct spoolss_PlayGDIScriptOnPrinterIC *r)
 906 {
 907         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 908 }
 909
 910
 911 /*
 912   spoolss_DeletePrinterIC
 913 */
 914 static WERROR dcesrv_spoolss_DeletePrinterIC(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 915                        struct spoolss_DeletePrinterIC *r)
 916 {
 917         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 918 }
 919
 920
 921 /*
 922   spoolss_AddPrinterConnection
 923 */
 924 static WERROR dcesrv_spoolss_AddPrinterConnection(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 925                        struct spoolss_AddPrinterConnection *r)
 926 {
 927         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 928 }
 929
 930
 931 /*
 932   spoolss_DeletePrinterConnection
 933 */
 934 static WERROR dcesrv_spoolss_DeletePrinterConnection(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 935                        struct spoolss_DeletePrinterConnection *r)
 936 {
 937         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 938 }
 939
 940
 941 /*
 942   spoolss_PrinterMessageBox
 943 */
 944 static WERROR dcesrv_spoolss_PrinterMessageBox(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 945                        struct spoolss_PrinterMessageBox *r)
 946 {
 947         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 948 }
 949
 950
 951 /*
 952   spoolss_AddMonitor
 953 */
 954 static WERROR dcesrv_spoolss_AddMonitor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 955                        struct spoolss_AddMonitor *r)
 956 {
 957         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 958 }
 959
 960
 961 /*
 962   spoolss_DeleteMonitor
 963 */
 964 static WERROR dcesrv_spoolss_DeleteMonitor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 965                        struct spoolss_DeleteMonitor *r)
 966 {
 967         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 968 }
 969
 970
 971 /*
 972   spoolss_DeletePrintProcessor
 973 */
 974 static WERROR dcesrv_spoolss_DeletePrintProcessor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 975                        struct spoolss_DeletePrintProcessor *r)
 976 {
 977         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 978 }
 979
 980
 981 /*
 982   spoolss_AddPrintProvidor
 983 */
 984 static WERROR dcesrv_spoolss_AddPrintProvidor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 985                        struct spoolss_AddPrintProvidor *r)
 986 {
 987         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 988 }
 989
 990
 991 /*
 992   spoolss_DeletePrintProvidor
 993 */
 994 static WERROR dcesrv_spoolss_DeletePrintProvidor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 995                        struct spoolss_DeletePrintProvidor *r)
 996 {
 997         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 998 }
 999
1000
1001 /*
1002   spoolss_EnumPrintProcDataTypes
1003 */
1004 static WERROR dcesrv_spoolss_EnumPrintProcDataTypes(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1005                        struct spoolss_EnumPrintProcDataTypes *r)
1006 {
1007         return WERR_OK;
1008 }
1009
1010
1011 /*
1012   spoolss_ResetPrinter
1013 */
1014 static WERROR dcesrv_spoolss_ResetPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1015                        struct spoolss_ResetPrinter *r)
1016 {
1017         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1018 }
1019
1020
1021 /*
1022   spoolss_GetPrinterDriver2
1023 */
1024 static WERROR dcesrv_spoolss_GetPrinterDriver2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1025                        struct spoolss_GetPrinterDriver2 *r)
1026 {
1027         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1028 }
1029
1030
1031 /*
1032   spoolss_FindFirstPrinterChangeNotification
1033 */
1034 static WERROR dcesrv_spoolss_FindFirstPrinterChangeNotification(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1035                        struct spoolss_FindFirstPrinterChangeNotification *r)
1036 {
1037         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1038 }
1039
1040
1041 /*
1042   spoolss_FindNextPrinterChangeNotification
1043 */
1044 static WERROR dcesrv_spoolss_FindNextPrinterChangeNotification(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1045                        struct spoolss_FindNextPrinterChangeNotification *r)
1046 {
1047         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1048 }
1049
1050
1051 /*
1052   spoolss_FindClosePrinterNotify
1053 */
1054 static WERROR dcesrv_spoolss_FindClosePrinterNotify(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1055                        struct spoolss_FindClosePrinterNotify *r)
1056 {
1057         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1058 }
1059
1060
1061 /*
1062   spoolss_RouterFindFirstPrinterChangeNotificationOld
1063 */
1064 static WERROR dcesrv_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1065                        struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
1066 {
1067         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1068 }
1069
1070
1071 /*
1072   spoolss_ReplyOpenPrinter
1073 */
1074 static WERROR dcesrv_spoolss_ReplyOpenPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1075                        struct spoolss_ReplyOpenPrinter *r)
1076 {
1077         struct dcesrv_handle *handle;
1078
1079         handle = dcesrv_handle_new(dce_call->context, SPOOLSS_NOTIFY);
1080         W_ERROR_HAVE_NO_MEMORY(handle);
1081
1082         /* For now, just return a handle */
1083
1084         *r->out.handle = handle->wire_handle;
1085
1086         return WERR_OK;
1087 }
1088
1089
1090 /*
1091   spoolss_RouterReplyPrinter
1092 */
1093 static WERROR dcesrv_spoolss_RouterReplyPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1094                        struct spoolss_RouterReplyPrinter *r)
1095 {
1096         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1097 }
1098
1099
1100 /*
1101   spoolss_ReplyClosePrinter
1102 */
1103 static WERROR dcesrv_spoolss_ReplyClosePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1104                        struct spoolss_ReplyClosePrinter *r)
1105 {
1106         struct dcesrv_handle *handle;
1107
1108         DCESRV_PULL_HANDLE_WERR(handle, r->in.handle, SPOOLSS_NOTIFY);
1109
1110         talloc_free(handle);
1111
1112         ZERO_STRUCTP(r->out.handle);
1113
1114         return WERR_OK;
1115 }
1116
1117 /*
1118   spoolss_AddPortEx
1119 */
1120 static WERROR dcesrv_spoolss_AddPortEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1121                        struct spoolss_AddPortEx *r)
1122 {
1123         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1124 }
1125
1126
1127 /*
1128   spoolss_RouterFindFirstPrinterChangeNotification
1129 */
1130 static WERROR dcesrv_spoolss_RouterFindFirstPrinterChangeNotification(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1131                        struct spoolss_RouterFindFirstPrinterChangeNotification *r)
1132 {
1133         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1134 }
1135
1136
1137 /*
1138   spoolss_SpoolerInit
1139 */
1140 static WERROR dcesrv_spoolss_SpoolerInit(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1141                        struct spoolss_SpoolerInit *r)
1142 {
1143         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1144 }
1145
1146
1147 /*
1148   spoolss_ResetPrinterEx
1149 */
1150 static WERROR dcesrv_spoolss_ResetPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1151                        struct spoolss_ResetPrinterEx *r)
1152 {
1153         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1154 }
1155
1156
1157 /*
1158   spoolss_RemoteFindFirstPrinterChangeNotifyEx
1159 */
1160 static WERROR dcesrv_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1161                        struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
1162 {
1163         struct dcerpc_pipe *p;
1164         struct dcerpc_binding *binding;
1165         NTSTATUS status;
1166         struct spoolss_ReplyOpenPrinter rop;
1167         struct cli_credentials *creds;
1168         struct policy_handle notify_handle;
1169
1170         DEBUG(2, ("Received RFFPCNex from %s\n", r->in.local_machine));
1171
1172         /*
1173          * TODO: for now just open a connection to the client and drop it again
1174          *       to keep the w2k3 PrintServer
1175          *       happy to allow to open the Add Printer GUI
1176          *       and the torture suite passing
1177          */
1178
1179         binding = talloc_zero(mem_ctx, struct dcerpc_binding);
1180
1181         binding->transport = NCACN_NP;
1182         if (strncmp(r->in.local_machine, "\\\\", 2))
1183                 return WERR_INVALID_COMPUTERNAME;
1184         binding->host = r->in.local_machine+2;
1185
1186         creds = cli_credentials_init_anon(mem_ctx); /* FIXME: Use machine credentials instead ? */
1187
1188         status = dcerpc_pipe_connect_b(mem_ctx, &p, binding, &ndr_table_spoolss,
1189                                        creds, dce_call->event_ctx,
1190                                        dce_call->conn->dce_ctx->lp_ctx);
1191
1192         if (NT_STATUS_IS_ERR(status)) {
1193                 DEBUG(0, ("unable to call back to %s\n", r->in.local_machine));
1194                 return WERR_SERVER_UNAVAILABLE;
1195         }
1196
1197         ZERO_STRUCT(rop);
1198         rop.in.server_name = lp_netbios_name(dce_call->conn->dce_ctx->lp_ctx);
1199         W_ERROR_HAVE_NO_MEMORY(rop.in.server_name);
1200         rop.in.printer_local = 0;
1201         rop.in.type = REG_NONE;
1202         rop.in.bufsize = 0;
1203         rop.in.buffer = NULL;
1204         rop.out.handle = &notify_handle;
1205
1206         status = dcerpc_spoolss_ReplyOpenPrinter(p, mem_ctx, &rop);
1207         if (NT_STATUS_IS_ERR(status)) {
1208                 DEBUG(0, ("unable to open remote printer %s\n",
1209                         r->in.local_machine));
1210                 return WERR_SERVER_UNAVAILABLE;
1211         }
1212
1213         talloc_free(p);
1214
1215         return WERR_OK;
1216 }
1217
1218
1219 /*
1220   spoolss_RouterReplyPrinterEx
1221 */
1222 static WERROR dcesrv_spoolss_RouterReplyPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1223                        struct spoolss_RouterReplyPrinterEx *r)
1224 {
1225         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1226 }
1227
1228
1229 /*
1230   spoolss_RouterRefreshPrinterChangeNotify
1231 */
1232 static WERROR dcesrv_spoolss_RouterRefreshPrinterChangeNotify(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1233                        struct spoolss_RouterRefreshPrinterChangeNotify *r)
1234 {
1235         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1236 }
1237
1238
1239 /*
1240   spoolss_44
1241 */
1242 static WERROR dcesrv_spoolss_44(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1243                        struct spoolss_44 *r)
1244 {
1245         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1246 }
1247
1248 /*
1249   spoolss_OpenPrinterEx
1250 */
1251 static WERROR dcesrv_spoolss_OpenPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1252                        struct spoolss_OpenPrinterEx *r)
1253 {
1254         struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private_data, struct ntptr_context);
1255         struct ntptr_GenericHandle *handle;
1256         struct dcesrv_handle *h;
1257         const char *server;
1258         const char *object;
1259         enum ntptr_HandleType type;
1260         WERROR status;
1261
1262         ZERO_STRUCTP(r->out.handle);
1263
1264         status = dcesrv_spoolss_parse_printer_name(mem_ctx, r->in.printername, &server, &object, &type);
1265         W_ERROR_NOT_OK_RETURN(status);
1266
1267         status = dcesrv_spoolss_check_server_name(dce_call, mem_ctx, server);
1268         W_ERROR_NOT_OK_RETURN(status);
1269
1270         switch (type) {
1271                 case NTPTR_HANDLE_SERVER:
1272                         status = ntptr_OpenPrintServer(ntptr, mem_ctx, r, server, &handle);
1273                         W_ERROR_NOT_OK_RETURN(status);
1274                         break;
1275                 case NTPTR_HANDLE_PORT:
1276                         status = ntptr_OpenPort(ntptr, mem_ctx, r, object, &handle);
1277                         W_ERROR_NOT_OK_RETURN(status);
1278                         break;
1279                 case NTPTR_HANDLE_MONITOR:
1280                         status = ntptr_OpenMonitor(ntptr, mem_ctx, r, object, &handle);
1281                         W_ERROR_NOT_OK_RETURN(status);
1282                         break;
1283                 case NTPTR_HANDLE_PRINTER:
1284                         status = ntptr_OpenPrinter(ntptr, mem_ctx, r, object, &handle);
1285                         W_ERROR_NOT_OK_RETURN(status);
1286                         break;
1287                 default:
1288                         return WERR_FOOBAR;
1289         }
1290
1291         h = dcesrv_handle_new(dce_call->context, handle->type);
1292         W_ERROR_HAVE_NO_MEMORY(h);
1293
1294         h->data = talloc_steal(h, handle);
1295
1296         *r->out.handle  = h->wire_handle;
1297
1298         return WERR_OK;
1299 }
1300
1301 /*
1302   spoolss_AddPrinterEx
1303 */
1304 static WERROR dcesrv_spoolss_AddPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1305                        struct spoolss_AddPrinterEx *r)
1306 {
1307         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1308 }
1309
1310
1311 /*
1312   spoolss_47
1313 */
1314 static WERROR dcesrv_spoolss_47(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1315                        struct spoolss_47 *r)
1316 {
1317         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1318 }
1319
1320
1321 /*
1322   spoolss_EnumPrinterData
1323 */
1324 static WERROR dcesrv_spoolss_EnumPrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1325                        struct spoolss_EnumPrinterData *r)
1326 {
1327         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1328 }
1329
1330
1331 /*
1332   spoolss_DeletePrinterData
1333 */
1334 static WERROR dcesrv_spoolss_DeletePrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1335                        struct spoolss_DeletePrinterData *r)
1336 {
1337         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1338 }
1339
1340
1341 /*
1342   spoolss_4a
1343 */
1344 static WERROR dcesrv_spoolss_4a(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1345                        struct spoolss_4a *r)
1346 {
1347         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1348 }
1349
1350
1351 /*
1352   spoolss_4b
1353 */
1354 static WERROR dcesrv_spoolss_4b(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1355                        struct spoolss_4b *r)
1356 {
1357         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1358 }
1359
1360
1361 /*
1362   spoolss_4c
1363 */
1364 static WERROR dcesrv_spoolss_4c(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1365                        struct spoolss_4c *r)
1366 {
1367         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1368 }
1369
1370
1371 /*
1372   spoolss_SetPrinterDataEx
1373 */
1374 static WERROR dcesrv_spoolss_SetPrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1375                        struct spoolss_SetPrinterDataEx *r)
1376 {
1377         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1378 }
1379
1380
1381 /*
1382   spoolss_GetPrinterDataEx
1383 */
1384 static WERROR dcesrv_spoolss_GetPrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1385                        struct spoolss_GetPrinterDataEx *r)
1386 {
1387         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1388 }
1389
1390
1391 /*
1392   spoolss_EnumPrinterDataEx
1393 */
1394 static WERROR dcesrv_spoolss_EnumPrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1395                        struct spoolss_EnumPrinterDataEx *r)
1396 {
1397         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1398 }
1399
1400
1401 /*
1402   spoolss_EnumPrinterKey
1403 */
1404 static WERROR dcesrv_spoolss_EnumPrinterKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1405                        struct spoolss_EnumPrinterKey *r)
1406 {
1407         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1408 }
1409
1410
1411 /*
1412   spoolss_DeletePrinterDataEx
1413 */
1414 static WERROR dcesrv_spoolss_DeletePrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1415                        struct spoolss_DeletePrinterDataEx *r)
1416 {
1417         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1418 }
1419
1420
1421 /*
1422   spoolss_DeletePrinterKey
1423 */
1424 static WERROR dcesrv_spoolss_DeletePrinterKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1425                        struct spoolss_DeletePrinterKey *r)
1426 {
1427         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1428 }
1429
1430
1431 /*
1432   spoolss_53
1433 */
1434 static WERROR dcesrv_spoolss_53(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1435                        struct spoolss_53 *r)
1436 {
1437         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1438 }
1439
1440
1441 /*
1442   spoolss_DeletePrinterDriverEx
1443 */
1444 static WERROR dcesrv_spoolss_DeletePrinterDriverEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1445                        struct spoolss_DeletePrinterDriverEx *r)
1446 {
1447         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1448 }
1449
1450
1451 /*
1452   spoolss_55
1453 */
1454 static WERROR dcesrv_spoolss_55(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1455                        struct spoolss_55 *r)
1456 {
1457         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1458 }
1459
1460
1461 /*
1462   spoolss_56
1463 */
1464 static WERROR dcesrv_spoolss_56(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1465                        struct spoolss_56 *r)
1466 {
1467         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1468 }
1469
1470
1471 /*
1472   spoolss_57
1473 */
1474 static WERROR dcesrv_spoolss_57(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1475                        struct spoolss_57 *r)
1476 {
1477         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1478 }
1479
1480
1481 /*
1482   spoolss_XcvData
1483 */
1484 static WERROR dcesrv_spoolss_XcvData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1485                        struct spoolss_XcvData *r)
1486 {
1487         struct ntptr_GenericHandle *handle;
1488         struct dcesrv_handle *h;
1489         WERROR status;
1490
1491         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
1492         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
1493
1494         switch (handle->type) {
1495                 case NTPTR_HANDLE_SERVER:
1496                         status = ntptr_XcvDataPrintServer(handle, mem_ctx, r);
1497                         W_ERROR_NOT_OK_RETURN(status);
1498                         break;
1499                 case NTPTR_HANDLE_PRINTER:
1500                         status = ntptr_XcvDataPrinter(handle, mem_ctx, r);
1501                         W_ERROR_NOT_OK_RETURN(status);
1502                         break;
1503                 case NTPTR_HANDLE_PORT:
1504                         status = ntptr_XcvDataPort(handle, mem_ctx, r);
1505                         W_ERROR_NOT_OK_RETURN(status);
1506                         break;
1507                 case NTPTR_HANDLE_MONITOR:
1508                         status = ntptr_XcvDataMonitor(handle, mem_ctx, r);
1509                         W_ERROR_NOT_OK_RETURN(status);
1510                         break;
1511                 default:
1512                         return WERR_FOOBAR;
1513         }
1514
1515         /* TODO: handle the buffer sizes here! */
1516         return WERR_OK;
1517 }
1518
1519
1520 /*
1521   spoolss_AddPrinterDriverEx
1522 */
1523 static WERROR dcesrv_spoolss_AddPrinterDriverEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1524                        struct spoolss_AddPrinterDriverEx *r)
1525 {
1526         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1527 }
1528
1529
1530 /*
1531   spoolss_5a
1532 */
1533 static WERROR dcesrv_spoolss_5a(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1534                        struct spoolss_5a *r)
1535 {
1536         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1537 }
1538
1539
1540 /*
1541   spoolss_5b
1542 */
1543 static WERROR dcesrv_spoolss_5b(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1544                        struct spoolss_5b *r)
1545 {
1546         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1547 }
1548
1549
1550 /*
1551   spoolss_5c
1552 */
1553 static WERROR dcesrv_spoolss_5c(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1554                        struct spoolss_5c *r)
1555 {
1556         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1557 }
1558
1559
1560 /*
1561   spoolss_5d
1562 */
1563 static WERROR dcesrv_spoolss_5d(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1564                        struct spoolss_5d *r)
1565 {
1566         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1567 }
1568
1569
1570 /*
1571   spoolss_5e
1572 */
1573 static WERROR dcesrv_spoolss_5e(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1574                        struct spoolss_5e *r)
1575 {
1576         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1577 }
1578
1579
1580 /*
1581   spoolss_5f
1582 */
1583 static WERROR dcesrv_spoolss_5f(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1584                        struct spoolss_5f *r)
1585 {
1586         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1587 }
1588
1589 /*
1590   spoolss_60
1591 */
1592 static WERROR dcesrv_spoolss_60(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1593                        struct spoolss_60 *r)
1594 {
1595         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1596 }
1597
1598
1599 /*
1600   spoolss_61
1601 */
1602 static WERROR dcesrv_spoolss_61(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1603                        struct spoolss_61 *r)
1604 {
1605         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1606 }
1607
1608
1609 /*
1610   spoolss_62
1611 */
1612 static WERROR dcesrv_spoolss_62(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1613                        struct spoolss_62 *r)
1614 {
1615         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1616 }
1617
1618
1619 /*
1620   spoolss_63
1621 */
1622 static WERROR dcesrv_spoolss_63(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1623                        struct spoolss_63 *r)
1624 {
1625         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1626 }
1627
1628
1629 /*
1630   spoolss_64
1631 */
1632 static WERROR dcesrv_spoolss_64(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1633                        struct spoolss_64 *r)
1634 {
1635         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1636 }
1637
1638
1639 /*
1640   spoolss_65
1641 */
1642 static WERROR dcesrv_spoolss_65(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1643                        struct spoolss_65 *r)
1644 {
1645         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1646 }
1647
1648
1649 /*
1650   spoolss_GetCorePrinterDrivers
1651 */
1652 static WERROR dcesrv_spoolss_GetCorePrinterDrivers(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1653                        struct spoolss_GetCorePrinterDrivers *r)
1654 {
1655         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1656 }
1657
1658
1659 /*
1660   spoolss_67
1661 */
1662 static WERROR dcesrv_spoolss_67(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1663                        struct spoolss_67 *r)
1664 {
1665         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1666 }
1667
1668
1669 /*
1670   spoolss_GetPrinterDriverPackagePath
1671 */
1672 static WERROR dcesrv_spoolss_GetPrinterDriverPackagePath(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1673                        struct spoolss_GetPrinterDriverPackagePath *r)
1674 {
1675         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1676 }
1677
1678
1679 /*
1680   spoolss_69
1681 */
1682 static WERROR dcesrv_spoolss_69(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1683                        struct spoolss_69 *r)
1684 {
1685         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1686 }
1687
1688
1689 /*
1690   spoolss_6a
1691 */
1692 static WERROR dcesrv_spoolss_6a(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1693                        struct spoolss_6a *r)
1694 {
1695         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1696 }
1697
1698
1699 /*
1700   spoolss_6b
1701 */
1702 static WERROR dcesrv_spoolss_6b(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1703                        struct spoolss_6b *r)
1704 {
1705         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1706 }
1707
1708
1709 /*
1710   spoolss_6c
1711 */
1712 static WERROR dcesrv_spoolss_6c(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1713                        struct spoolss_6c *r)
1714 {
1715         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1716 }
1717
1718
1719 /*
1720   spoolss_6d
1721 */
1722 static WERROR dcesrv_spoolss_6d(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1723                        struct spoolss_6d *r)
1724 {
1725         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1726 }
1727
1728
1729
1730 /* include the generated boilerplate */
1731 #include "librpc/gen_ndr/ndr_spoolss_s.c"