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