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         struct dcerpc_binding *binding;
1160         NTSTATUS status;
1161         struct spoolss_ReplyOpenPrinter rop;
1162         struct cli_credentials *creds;
1163         struct policy_handle notify_handle;
1164
1165         DEBUG(2, ("Received RFFPCNex from %s\n", r->in.local_machine));
1166
1167         /*
1168          * TODO: for now just open a connection to the client and drop it again
1169          *       to keep the w2k3 PrintServer
1170          *       happy to allow to open the Add Printer GUI
1171          *       and the torture suite passing
1172          */
1173
1174         binding = talloc_zero(mem_ctx, struct dcerpc_binding);
1175
1176         binding->transport = NCACN_NP;
1177         if (strncmp(r->in.local_machine, "\\\\", 2))
1178                 return WERR_INVALID_COMPUTERNAME;
1179         binding->host = r->in.local_machine+2;
1180
1181         creds = cli_credentials_init_anon(mem_ctx); /* FIXME: Use machine credentials instead ? */
1182
1183         status = dcerpc_pipe_connect_b(mem_ctx, &p, binding, &ndr_table_spoolss,
1184                                        creds, dce_call->event_ctx,
1185                                        dce_call->conn->dce_ctx->lp_ctx);
1186
1187         if (NT_STATUS_IS_ERR(status)) {
1188                 DEBUG(0, ("unable to call back to %s\n", r->in.local_machine));
1189                 return WERR_SERVER_UNAVAILABLE;
1190         }
1191
1192         ZERO_STRUCT(rop);
1193         rop.in.server_name = lpcfg_netbios_name(dce_call->conn->dce_ctx->lp_ctx);
1194         W_ERROR_HAVE_NO_MEMORY(rop.in.server_name);
1195         rop.in.printer_local = 0;
1196         rop.in.type = REG_NONE;
1197         rop.in.bufsize = 0;
1198         rop.in.buffer = NULL;
1199         rop.out.handle = &notify_handle;
1200
1201         status = dcerpc_spoolss_ReplyOpenPrinter_r(p->binding_handle, mem_ctx, &rop);
1202         if (NT_STATUS_IS_ERR(status)) {
1203                 DEBUG(0, ("unable to open remote printer %s\n",
1204                         r->in.local_machine));
1205                 return WERR_SERVER_UNAVAILABLE;
1206         }
1207
1208         talloc_free(p);
1209
1210         return WERR_OK;
1211 }
1212
1213
1214 /*
1215   spoolss_RouterReplyPrinterEx
1216 */
1217 static WERROR dcesrv_spoolss_RouterReplyPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1218                        struct spoolss_RouterReplyPrinterEx *r)
1219 {
1220         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1221 }
1222
1223
1224 /*
1225   spoolss_RouterRefreshPrinterChangeNotify
1226 */
1227 static WERROR dcesrv_spoolss_RouterRefreshPrinterChangeNotify(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1228                        struct spoolss_RouterRefreshPrinterChangeNotify *r)
1229 {
1230         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1231 }
1232
1233
1234 /*
1235   spoolss_44
1236 */
1237 static WERROR dcesrv_spoolss_44(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1238                        struct spoolss_44 *r)
1239 {
1240         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1241 }
1242
1243 /*
1244   spoolss_OpenPrinterEx
1245 */
1246 static WERROR dcesrv_spoolss_OpenPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1247                        struct spoolss_OpenPrinterEx *r)
1248 {
1249         struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private_data, struct ntptr_context);
1250         struct ntptr_GenericHandle *handle;
1251         struct dcesrv_handle *h;
1252         const char *server;
1253         const char *object;
1254         enum ntptr_HandleType type;
1255         WERROR status;
1256
1257         ZERO_STRUCTP(r->out.handle);
1258
1259         status = dcesrv_spoolss_parse_printer_name(mem_ctx, r->in.printername, &server, &object, &type);
1260         W_ERROR_NOT_OK_RETURN(status);
1261
1262         status = dcesrv_spoolss_check_server_name(dce_call, mem_ctx, server);
1263         W_ERROR_NOT_OK_RETURN(status);
1264
1265         switch (type) {
1266                 case NTPTR_HANDLE_SERVER:
1267                         status = ntptr_OpenPrintServer(ntptr, mem_ctx, r, server, &handle);
1268                         W_ERROR_NOT_OK_RETURN(status);
1269                         break;
1270                 case NTPTR_HANDLE_PORT:
1271                         status = ntptr_OpenPort(ntptr, mem_ctx, r, object, &handle);
1272                         W_ERROR_NOT_OK_RETURN(status);
1273                         break;
1274                 case NTPTR_HANDLE_MONITOR:
1275                         status = ntptr_OpenMonitor(ntptr, mem_ctx, r, object, &handle);
1276                         W_ERROR_NOT_OK_RETURN(status);
1277                         break;
1278                 case NTPTR_HANDLE_PRINTER:
1279                         status = ntptr_OpenPrinter(ntptr, mem_ctx, r, object, &handle);
1280                         W_ERROR_NOT_OK_RETURN(status);
1281                         break;
1282                 default:
1283                         return WERR_FOOBAR;
1284         }
1285
1286         h = dcesrv_handle_new(dce_call->context, handle->type);
1287         W_ERROR_HAVE_NO_MEMORY(h);
1288
1289         h->data = talloc_steal(h, handle);
1290
1291         *r->out.handle  = h->wire_handle;
1292
1293         return WERR_OK;
1294 }
1295
1296 /*
1297   spoolss_AddPrinterEx
1298 */
1299 static WERROR dcesrv_spoolss_AddPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1300                        struct spoolss_AddPrinterEx *r)
1301 {
1302         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1303 }
1304
1305
1306 /*
1307   spoolss_SetPort
1308 */
1309 static WERROR dcesrv_spoolss_SetPort(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1310                        struct spoolss_SetPort *r)
1311 {
1312         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1313 }
1314
1315
1316 /*
1317   spoolss_EnumPrinterData
1318 */
1319 static WERROR dcesrv_spoolss_EnumPrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1320                        struct spoolss_EnumPrinterData *r)
1321 {
1322         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1323 }
1324
1325
1326 /*
1327   spoolss_DeletePrinterData
1328 */
1329 static WERROR dcesrv_spoolss_DeletePrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1330                        struct spoolss_DeletePrinterData *r)
1331 {
1332         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1333 }
1334
1335
1336 /*
1337   spoolss_4a
1338 */
1339 static WERROR dcesrv_spoolss_4a(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1340                        struct spoolss_4a *r)
1341 {
1342         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1343 }
1344
1345
1346 /*
1347   spoolss_4b
1348 */
1349 static WERROR dcesrv_spoolss_4b(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1350                        struct spoolss_4b *r)
1351 {
1352         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1353 }
1354
1355
1356 /*
1357   spoolss_4c
1358 */
1359 static WERROR dcesrv_spoolss_4c(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1360                        struct spoolss_4c *r)
1361 {
1362         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1363 }
1364
1365
1366 /*
1367   spoolss_SetPrinterDataEx
1368 */
1369 static WERROR dcesrv_spoolss_SetPrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1370                        struct spoolss_SetPrinterDataEx *r)
1371 {
1372         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1373 }
1374
1375
1376 /*
1377   spoolss_GetPrinterDataEx
1378 */
1379 static WERROR dcesrv_spoolss_GetPrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1380                        struct spoolss_GetPrinterDataEx *r)
1381 {
1382         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1383 }
1384
1385
1386 /*
1387   spoolss_EnumPrinterDataEx
1388 */
1389 static WERROR dcesrv_spoolss_EnumPrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1390                        struct spoolss_EnumPrinterDataEx *r)
1391 {
1392         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1393 }
1394
1395
1396 /*
1397   spoolss_EnumPrinterKey
1398 */
1399 static WERROR dcesrv_spoolss_EnumPrinterKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1400                        struct spoolss_EnumPrinterKey *r)
1401 {
1402         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1403 }
1404
1405
1406 /*
1407   spoolss_DeletePrinterDataEx
1408 */
1409 static WERROR dcesrv_spoolss_DeletePrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1410                        struct spoolss_DeletePrinterDataEx *r)
1411 {
1412         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1413 }
1414
1415
1416 /*
1417   spoolss_DeletePrinterKey
1418 */
1419 static WERROR dcesrv_spoolss_DeletePrinterKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1420                        struct spoolss_DeletePrinterKey *r)
1421 {
1422         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1423 }
1424
1425
1426 /*
1427   spoolss_53
1428 */
1429 static WERROR dcesrv_spoolss_53(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1430                        struct spoolss_53 *r)
1431 {
1432         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1433 }
1434
1435
1436 /*
1437   spoolss_DeletePrinterDriverEx
1438 */
1439 static WERROR dcesrv_spoolss_DeletePrinterDriverEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1440                        struct spoolss_DeletePrinterDriverEx *r)
1441 {
1442         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1443 }
1444
1445
1446 /*
1447   spoolss_AddPerMachineConnection
1448 */
1449 static WERROR dcesrv_spoolss_AddPerMachineConnection(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1450                        struct spoolss_AddPerMachineConnection *r)
1451 {
1452         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1453 }
1454
1455
1456 /*
1457   spoolss_DeletePerMachineConnection
1458 */
1459 static WERROR dcesrv_spoolss_DeletePerMachineConnection(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1460                        struct spoolss_DeletePerMachineConnection *r)
1461 {
1462         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1463 }
1464
1465
1466 /*
1467   spoolss_EnumPerMachineConnections
1468 */
1469 static WERROR dcesrv_spoolss_EnumPerMachineConnections(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1470                        struct spoolss_EnumPerMachineConnections *r)
1471 {
1472         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1473 }
1474
1475
1476 /*
1477   spoolss_XcvData
1478 */
1479 static WERROR dcesrv_spoolss_XcvData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1480                        struct spoolss_XcvData *r)
1481 {
1482         struct ntptr_GenericHandle *handle;
1483         struct dcesrv_handle *h;
1484         WERROR status;
1485
1486         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
1487         handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
1488
1489         switch (handle->type) {
1490                 case NTPTR_HANDLE_SERVER:
1491                         status = ntptr_XcvDataPrintServer(handle, mem_ctx, r);
1492                         W_ERROR_NOT_OK_RETURN(status);
1493                         break;
1494                 case NTPTR_HANDLE_PRINTER:
1495                         status = ntptr_XcvDataPrinter(handle, mem_ctx, r);
1496                         W_ERROR_NOT_OK_RETURN(status);
1497                         break;
1498                 case NTPTR_HANDLE_PORT:
1499                         status = ntptr_XcvDataPort(handle, mem_ctx, r);
1500                         W_ERROR_NOT_OK_RETURN(status);
1501                         break;
1502                 case NTPTR_HANDLE_MONITOR:
1503                         status = ntptr_XcvDataMonitor(handle, mem_ctx, r);
1504                         W_ERROR_NOT_OK_RETURN(status);
1505                         break;
1506                 default:
1507                         return WERR_FOOBAR;
1508         }
1509
1510         /* TODO: handle the buffer sizes here! */
1511         return WERR_OK;
1512 }
1513
1514
1515 /*
1516   spoolss_AddPrinterDriverEx
1517 */
1518 static WERROR dcesrv_spoolss_AddPrinterDriverEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1519                        struct spoolss_AddPrinterDriverEx *r)
1520 {
1521         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1522 }
1523
1524
1525 /*
1526   spoolss_5a
1527 */
1528 static WERROR dcesrv_spoolss_5a(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1529                        struct spoolss_5a *r)
1530 {
1531         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1532 }
1533
1534
1535 /*
1536   spoolss_5b
1537 */
1538 static WERROR dcesrv_spoolss_5b(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1539                        struct spoolss_5b *r)
1540 {
1541         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1542 }
1543
1544
1545 /*
1546   spoolss_5c
1547 */
1548 static WERROR dcesrv_spoolss_5c(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1549                        struct spoolss_5c *r)
1550 {
1551         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1552 }
1553
1554
1555 /*
1556   spoolss_5d
1557 */
1558 static WERROR dcesrv_spoolss_5d(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1559                        struct spoolss_5d *r)
1560 {
1561         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1562 }
1563
1564
1565 /*
1566   spoolss_5e
1567 */
1568 static WERROR dcesrv_spoolss_5e(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1569                        struct spoolss_5e *r)
1570 {
1571         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1572 }
1573
1574
1575 /*
1576   spoolss_5f
1577 */
1578 static WERROR dcesrv_spoolss_5f(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1579                        struct spoolss_5f *r)
1580 {
1581         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1582 }
1583
1584 /*
1585   spoolss_60
1586 */
1587 static WERROR dcesrv_spoolss_60(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1588                        struct spoolss_60 *r)
1589 {
1590         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1591 }
1592
1593
1594 /*
1595   spoolss_61
1596 */
1597 static WERROR dcesrv_spoolss_61(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1598                        struct spoolss_61 *r)
1599 {
1600         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1601 }
1602
1603
1604 /*
1605   spoolss_62
1606 */
1607 static WERROR dcesrv_spoolss_62(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1608                        struct spoolss_62 *r)
1609 {
1610         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1611 }
1612
1613
1614 /*
1615   spoolss_63
1616 */
1617 static WERROR dcesrv_spoolss_63(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1618                        struct spoolss_63 *r)
1619 {
1620         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1621 }
1622
1623
1624 /*
1625   spoolss_64
1626 */
1627 static WERROR dcesrv_spoolss_64(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1628                        struct spoolss_64 *r)
1629 {
1630         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1631 }
1632
1633
1634 /*
1635   spoolss_65
1636 */
1637 static WERROR dcesrv_spoolss_65(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1638                        struct spoolss_65 *r)
1639 {
1640         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1641 }
1642
1643
1644 /*
1645   spoolss_GetCorePrinterDrivers
1646 */
1647 static WERROR dcesrv_spoolss_GetCorePrinterDrivers(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1648                        struct spoolss_GetCorePrinterDrivers *r)
1649 {
1650         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1651 }
1652
1653
1654 /*
1655   spoolss_67
1656 */
1657 static WERROR dcesrv_spoolss_67(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1658                        struct spoolss_67 *r)
1659 {
1660         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1661 }
1662
1663
1664 /*
1665   spoolss_GetPrinterDriverPackagePath
1666 */
1667 static WERROR dcesrv_spoolss_GetPrinterDriverPackagePath(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1668                        struct spoolss_GetPrinterDriverPackagePath *r)
1669 {
1670         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1671 }
1672
1673
1674 /*
1675   spoolss_69
1676 */
1677 static WERROR dcesrv_spoolss_69(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1678                        struct spoolss_69 *r)
1679 {
1680         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1681 }
1682
1683
1684 /*
1685   spoolss_6a
1686 */
1687 static WERROR dcesrv_spoolss_6a(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1688                        struct spoolss_6a *r)
1689 {
1690         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1691 }
1692
1693
1694 /*
1695   spoolss_6b
1696 */
1697 static WERROR dcesrv_spoolss_6b(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1698                        struct spoolss_6b *r)
1699 {
1700         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1701 }
1702
1703
1704 /*
1705   spoolss_6c
1706 */
1707 static WERROR dcesrv_spoolss_6c(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1708                        struct spoolss_6c *r)
1709 {
1710         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1711 }
1712
1713
1714 /*
1715   spoolss_6d
1716 */
1717 static WERROR dcesrv_spoolss_6d(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1718                        struct spoolss_6d *r)
1719 {
1720         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1721 }
1722
1723
1724 /*
1725   spoolss_RpcGetJobNamedPropertyValue
1726 */
1727 static WERROR dcesrv_spoolss_RpcGetJobNamedPropertyValue(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1728                        struct spoolss_RpcGetJobNamedPropertyValue *r)
1729 {
1730         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1731 }
1732
1733
1734 /*
1735   spoolss_RpcSetJobNamedProperty
1736 */
1737 static WERROR dcesrv_spoolss_RpcSetJobNamedProperty(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1738                        struct spoolss_RpcSetJobNamedProperty *r)
1739 {
1740         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1741 }
1742
1743
1744 /*
1745   spoolss_RpcDeleteJobNamedProperty
1746 */
1747 static WERROR dcesrv_spoolss_RpcDeleteJobNamedProperty(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1748                        struct spoolss_RpcDeleteJobNamedProperty *r)
1749 {
1750         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1751 }
1752
1753 /*
1754   spoolss_RpcEnumJobNamedProperties
1755 */
1756 static WERROR dcesrv_spoolss_RpcEnumJobNamedProperties(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1757                        struct spoolss_RpcEnumJobNamedProperties *r)
1758 {
1759         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1760 }
1761
1762 /* include the generated boilerplate */
1763 #include "librpc/gen_ndr/ndr_spoolss_s.c"