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