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
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "rpc_server/dcerpc_server.h"
  25 #include "librpc/gen_ndr/ndr_spoolss.h"
  26 #include "rpc_server/common/common.h"
  27 #include "rpc_server/spoolss/dcesrv_spoolss.h"
  28
  29 static WERROR spoolss_EnumPrinters1(TALLOC_CTX *mem_ctx,
  30                                     struct ldb_message **msgs, int num_msgs,
  31                                     struct ndr_push *ndr)
  32 {
  33         struct spoolss_PrinterInfo1 *info;
  34         int i;
  35
  36         info = talloc_array(mem_ctx, struct spoolss_PrinterInfo1, num_msgs);
  37
  38         if (!info)
  39                 return WERR_NOMEM;
  40
  41         for (i = 0; i < num_msgs; i++) {
  42                 info[i].flags = samdb_result_uint(msgs[i], "flags", 0);
  43                 info[i].name = samdb_result_string(msgs[i], "name", "");
  44                 info[i].description = samdb_result_string(msgs[i], "description", "");
  45                 info[i].comment = samdb_result_string(msgs[i], "comment", "");
  46         }
  47
  48         ndr_push_array(ndr, NDR_SCALARS|NDR_BUFFERS, info,
  49                        sizeof(struct spoolss_PrinterInfo1), num_msgs,
  50                        (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1);
  51
  52         return WERR_OK;
  53 }
  54
  55 static WERROR spoolss_EnumPrinters2(TALLOC_CTX *mem_ctx,
  56                                     struct ldb_message **msgs, int num_msgs,
  57                                     struct ndr_push *ndr)
  58 {
  59         struct spoolss_PrinterInfo2 *info;
  60         int i;
  61
  62         info = talloc_array(mem_ctx, struct spoolss_PrinterInfo2, num_msgs);
  63
  64         if (!info)
  65                 return WERR_NOMEM;
  66
  67         for (i = 0; i < num_msgs; i++) {
  68                 info[i].servername = samdb_result_string(msgs[i], "servername", "");
  69                 info[i].printername = samdb_result_string(msgs[i], "printername", "");
  70                 info[i].sharename = samdb_result_string(msgs[i], "sharename", "");
  71                 info[i].portname = samdb_result_string(msgs[i], "portname", "");
  72                 info[i].drivername = samdb_result_string(msgs[i], "drivername", "");
  73                 info[i].comment = samdb_result_string(msgs[i], "comment", "");
  74                 info[i].location = samdb_result_string(msgs[i], "location", "");
  75                 /* DEVICEMODE - eek! */
  76                 info[i].sepfile = samdb_result_string(msgs[i], "sepfile", "");
  77                 info[i].printprocessor = samdb_result_string(msgs[i], "printprocessor", "");
  78                 info[i].datatype = samdb_result_string(msgs[i], "datatype", "");
  79                 info[i].parameters = samdb_result_string(msgs[i], "parameters", "");
  80                 /* SECURITY_DESCRIPTOR */
  81                 info[i].attributes = samdb_result_uint(msgs[i], "attributes", 0);
  82                 info[i].priority = samdb_result_uint(msgs[i], "priority", 0);
  83                 info[i].defaultpriority = samdb_result_uint(msgs[i], "defaultpriority", 0);
  84                 info[i].starttime = samdb_result_uint(msgs[i], "starttime", 0);
  85                 info[i].untiltime = samdb_result_uint(msgs[i], "untiltime", 0);
  86                 info[i].status = samdb_result_uint(msgs[i], "status", 0);
  87                 info[i].cjobs = samdb_result_uint(msgs[i], "cjobs", 0);
  88                 info[i].averageppm = samdb_result_uint(msgs[i], "averageppm", 0);
  89         }
  90
  91         ndr_push_array(ndr, NDR_SCALARS|NDR_BUFFERS, info,
  92                        sizeof(struct spoolss_PrinterInfo2), num_msgs,
  93                        (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2);
  94
  95         return WERR_OK;
  96 }
  97
  98 static WERROR spoolss_EnumPrinters5(TALLOC_CTX *mem_ctx,
  99                                     struct ldb_message **msgs, int num_msgs,
 100                                     struct ndr_push *ndr)
 101 {
 102         struct spoolss_PrinterInfo5 *info;
 103         int i;
 104
 105         info = talloc_array(mem_ctx, struct spoolss_PrinterInfo5, num_msgs);
 106
 107         if (!info)
 108                 return WERR_NOMEM;
 109
 110         for (i = 0; i < num_msgs; i++) {
 111                 info[i].printername = samdb_result_string(msgs[i], "name", "");
 112                 info[i].portname = samdb_result_string(msgs[i], "port", "");
 113                 info[i].attributes = samdb_result_uint(msgs[i], "attributes", 0);
 114                 info[i].device_not_selected_timeout = samdb_result_uint(msgs[i], "device_not_selected_timeout", 0);
 115                 info[i].transmission_retry_timeout = samdb_result_uint(msgs[i], "transmission_retry_timeout", 0);
 116         }
 117
 118         ndr_push_array(ndr, NDR_SCALARS|NDR_BUFFERS, info,
 119                        sizeof(struct spoolss_PrinterInfo5), num_msgs,
 120                        (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5);
 121
 122         return WERR_OK;
 123 }
 124
 125 /*
 126   spoolss_EnumPrinters
 127 */
 128 static WERROR spoolss_EnumPrinters(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 129                        struct spoolss_EnumPrinters *r)
 130 {
 131         struct ndr_push *ndr;
 132         void *spoolss_ctx;
 133         WERROR result;
 134         struct ldb_message **msgs;
 135         int ret;
 136
 137         spoolss_ctx = spoolssdb_connect();
 138         if (spoolss_ctx == NULL)
 139                 return WERR_NOMEM;
 140
 141         ret = spoolssdb_search(spoolss_ctx, mem_ctx, NULL, &msgs, NULL,
 142                                "(&(objectclass=printer))");
 143
 144         ndr = ndr_push_init();
 145
 146         r->out.count = 0;
 147         *r->out.buf_size = 0;
 148
 149         switch(r->in.level) {
 150         case 1:
 151                 result = spoolss_EnumPrinters1(mem_ctx, msgs, ret, ndr);
 152                 break;
 153         case 2:
 154                 result = spoolss_EnumPrinters2(mem_ctx, msgs, ret, ndr);
 155                 break;
 156         case 5:
 157                 result = spoolss_EnumPrinters5(mem_ctx, msgs, ret, ndr);
 158                 break;
 159         default:
 160                 r->out.buffer = NULL;
 161                 result = WERR_UNKNOWN_LEVEL;
 162                 goto done;
 163         }
 164
 165         if (*r->in.buf_size < ndr->offset) {
 166                 *r->out.buf_size = ndr->offset;
 167                 result = WERR_INSUFFICIENT_BUFFER;
 168                 goto done;
 169         }
 170
 171         r->out.buffer = talloc(mem_ctx, DATA_BLOB);
 172
 173         if (!r->out.buffer) {
 174                 result = WERR_NOMEM;
 175                 goto done;
 176         }
 177
 178         *r->out.buffer = data_blob_talloc(mem_ctx, ndr->data, ndr->offset);
 179         *r->out.buf_size = ndr->offset;
 180
 181  done:
 182         ndr_push_free(ndr);
 183         spoolssdb_close(spoolss_ctx);
 184
 185         return result;
 186 }
 187
 188
 189 /*
 190   spoolss_OpenPrinter
 191 */
 192 static WERROR spoolss_OpenPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 193                        struct spoolss_OpenPrinter *r)
 194 {
 195         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 196 }
 197
 198
 199 /*
 200   spoolss_SetJob
 201 */
 202 static WERROR spoolss_SetJob(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 203                        struct spoolss_SetJob *r)
 204 {
 205         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 206 }
 207
 208
 209 /*
 210   spoolss_GetJob
 211 */
 212 static WERROR spoolss_GetJob(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 213                        struct spoolss_GetJob *r)
 214 {
 215         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 216 }
 217
 218
 219 /*
 220   spoolss_EnumJobs
 221 */
 222 static WERROR spoolss_EnumJobs(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 223                        struct spoolss_EnumJobs *r)
 224 {
 225         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 226 }
 227
 228
 229 /*
 230   spoolss_AddPrinter
 231 */
 232 static WERROR spoolss_AddPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 233                        struct spoolss_AddPrinter *r)
 234 {
 235         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 236 }
 237
 238
 239 /*
 240   spoolss_DeletePrinter
 241 */
 242 static WERROR spoolss_DeletePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 243                        struct spoolss_DeletePrinter *r)
 244 {
 245         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 246 }
 247
 248
 249 /*
 250   spoolss_SetPrinter
 251 */
 252 static WERROR spoolss_SetPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 253                        struct spoolss_SetPrinter *r)
 254 {
 255         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 256 }
 257
 258
 259 /*
 260   spoolss_GetPrinter
 261 */
 262 static WERROR spoolss_GetPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 263                        struct spoolss_GetPrinter *r)
 264 {
 265         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 266 }
 267
 268
 269 /*
 270   spoolss_AddPrinterDriver
 271 */
 272 static WERROR spoolss_AddPrinterDriver(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 273                        struct spoolss_AddPrinterDriver *r)
 274 {
 275         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 276 }
 277
 278
 279 /*
 280   spoolss_EnumPrinterDrivers
 281 */
 282 static WERROR spoolss_EnumPrinterDrivers(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 283                        struct spoolss_EnumPrinterDrivers *r)
 284 {
 285         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 286 }
 287
 288
 289 /*
 290   spoolss_GetPrinterDriver
 291 */
 292 static WERROR spoolss_GetPrinterDriver(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 293                        struct spoolss_GetPrinterDriver *r)
 294 {
 295         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 296 }
 297
 298
 299 /*
 300   spoolss_GetPrinterDriverDirectory
 301 */
 302 static WERROR spoolss_GetPrinterDriverDirectory(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 303                        struct spoolss_GetPrinterDriverDirectory *r)
 304 {
 305         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 306 }
 307
 308
 309 /*
 310   spoolss_DeletePrinterDriver
 311 */
 312 static WERROR spoolss_DeletePrinterDriver(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 313                        struct spoolss_DeletePrinterDriver *r)
 314 {
 315         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 316 }
 317
 318
 319 /*
 320   spoolss_AddPrintProcessor
 321 */
 322 static WERROR spoolss_AddPrintProcessor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 323                        struct spoolss_AddPrintProcessor *r)
 324 {
 325         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 326 }
 327
 328
 329 /*
 330   spoolss_EnumPrintProcessors
 331 */
 332 static WERROR spoolss_EnumPrintProcessors(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 333                        struct spoolss_EnumPrintProcessors *r)
 334 {
 335         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 336 }
 337
 338
 339 /*
 340   spoolss_GetPrintProcessorDirectory
 341 */
 342 static WERROR spoolss_GetPrintProcessorDirectory(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 343                        struct spoolss_GetPrintProcessorDirectory *r)
 344 {
 345         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 346 }
 347
 348
 349 /*
 350   spoolss_StartDocPrinter
 351 */
 352 static WERROR spoolss_StartDocPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 353                        struct spoolss_StartDocPrinter *r)
 354 {
 355         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 356 }
 357
 358
 359 /*
 360   spoolss_StartPagePrinter
 361 */
 362 static WERROR spoolss_StartPagePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 363                        struct spoolss_StartPagePrinter *r)
 364 {
 365         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 366 }
 367
 368
 369 /*
 370   spoolss_WritePrinter
 371 */
 372 static WERROR spoolss_WritePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 373                        struct spoolss_WritePrinter *r)
 374 {
 375         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 376 }
 377
 378
 379 /*
 380   spoolss_EndPagePrinter
 381 */
 382 static WERROR spoolss_EndPagePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 383                        struct spoolss_EndPagePrinter *r)
 384 {
 385         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 386 }
 387
 388
 389 /*
 390   spoolss_AbortPrinter
 391 */
 392 static WERROR spoolss_AbortPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 393                        struct spoolss_AbortPrinter *r)
 394 {
 395         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 396 }
 397
 398
 399 /*
 400   spoolss_ReadPrinter
 401 */
 402 static WERROR spoolss_ReadPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 403                        struct spoolss_ReadPrinter *r)
 404 {
 405         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 406 }
 407
 408
 409 /*
 410   spoolss_EndDocPrinter
 411 */
 412 static WERROR spoolss_EndDocPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 413                        struct spoolss_EndDocPrinter *r)
 414 {
 415         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 416 }
 417
 418
 419 /*
 420   spoolss_AddJob
 421 */
 422 static WERROR spoolss_AddJob(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 423                        struct spoolss_AddJob *r)
 424 {
 425         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 426 }
 427
 428
 429 /*
 430   spoolss_ScheduleJob
 431 */
 432 static WERROR spoolss_ScheduleJob(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 433                        struct spoolss_ScheduleJob *r)
 434 {
 435         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 436 }
 437
 438
 439 /*
 440   spoolss_GetPrinterData
 441 */
 442 static WERROR spoolss_GetPrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 443                        struct spoolss_GetPrinterData *r)
 444 {
 445         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 446 }
 447
 448
 449 /*
 450   spoolss_SetPrinterData
 451 */
 452 static WERROR spoolss_SetPrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 453                        struct spoolss_SetPrinterData *r)
 454 {
 455         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 456 }
 457
 458
 459 /*
 460   spoolss_WaitForPrinterChange
 461 */
 462 static WERROR spoolss_WaitForPrinterChange(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 463                        struct spoolss_WaitForPrinterChange *r)
 464 {
 465         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 466 }
 467
 468
 469 /*
 470   spoolss_ClosePrinter
 471 */
 472 static WERROR spoolss_ClosePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 473                        struct spoolss_ClosePrinter *r)
 474 {
 475         struct dcesrv_handle *h;
 476
 477         *r->out.handle = *r->in.handle;
 478
 479         DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
 480
 481         talloc_free(h);
 482
 483         ZERO_STRUCTP(r->out.handle);
 484
 485         return WERR_OK;
 486 }
 487
 488
 489 /*
 490   spoolss_AddForm
 491 */
 492 static WERROR spoolss_AddForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 493                        struct spoolss_AddForm *r)
 494 {
 495         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 496 }
 497
 498
 499 /*
 500   spoolss_DeleteForm
 501 */
 502 static WERROR spoolss_DeleteForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 503                        struct spoolss_DeleteForm *r)
 504 {
 505         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 506 }
 507
 508
 509 /*
 510   spoolss_GetForm
 511 */
 512 static WERROR spoolss_GetForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 513                        struct spoolss_GetForm *r)
 514 {
 515         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 516 }
 517
 518
 519 /*
 520   spoolss_SetForm
 521 */
 522 static WERROR spoolss_SetForm(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 523                        struct spoolss_SetForm *r)
 524 {
 525         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 526 }
 527
 528
 529 /*
 530   spoolss_EnumForms
 531 */
 532 static WERROR spoolss_EnumForms(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 533                        struct spoolss_EnumForms *r)
 534 {
 535         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 536 }
 537
 538
 539 /*
 540   spoolss_EnumPorts
 541 */
 542 static WERROR spoolss_EnumPorts(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 543                        struct spoolss_EnumPorts *r)
 544 {
 545         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 546 }
 547
 548
 549 /*
 550   spoolss_EnumMonitors
 551 */
 552 static WERROR spoolss_EnumMonitors(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 553                        struct spoolss_EnumMonitors *r)
 554 {
 555         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 556 }
 557
 558
 559 /*
 560   spoolss_AddPort
 561 */
 562 static WERROR spoolss_AddPort(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 563                        struct spoolss_AddPort *r)
 564 {
 565         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 566 }
 567
 568
 569 /*
 570   spoolss_ConfigurePort
 571 */
 572 static WERROR spoolss_ConfigurePort(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 573                        struct spoolss_ConfigurePort *r)
 574 {
 575         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 576 }
 577
 578
 579 /*
 580   spoolss_DeletePort
 581 */
 582 static WERROR spoolss_DeletePort(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 583                        struct spoolss_DeletePort *r)
 584 {
 585         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 586 }
 587
 588
 589 /*
 590   spoolss_CreatePrinterIC
 591 */
 592 static WERROR spoolss_CreatePrinterIC(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 593                        struct spoolss_CreatePrinterIC *r)
 594 {
 595         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 596 }
 597
 598
 599 /*
 600   spoolss_PlayGDIScriptOnPrinterIC
 601 */
 602 static WERROR spoolss_PlayGDIScriptOnPrinterIC(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 603                        struct spoolss_PlayGDIScriptOnPrinterIC *r)
 604 {
 605         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 606 }
 607
 608
 609 /*
 610   spoolss_DeletePrinterIC
 611 */
 612 static WERROR spoolss_DeletePrinterIC(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 613                        struct spoolss_DeletePrinterIC *r)
 614 {
 615         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 616 }
 617
 618
 619 /*
 620   spoolss_AddPrinterConnection
 621 */
 622 static WERROR spoolss_AddPrinterConnection(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 623                        struct spoolss_AddPrinterConnection *r)
 624 {
 625         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 626 }
 627
 628
 629 /*
 630   spoolss_DeletePrinterConnection
 631 */
 632 static WERROR spoolss_DeletePrinterConnection(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 633                        struct spoolss_DeletePrinterConnection *r)
 634 {
 635         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 636 }
 637
 638
 639 /*
 640   spoolss_PrinterMessageBox
 641 */
 642 static WERROR spoolss_PrinterMessageBox(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 643                        struct spoolss_PrinterMessageBox *r)
 644 {
 645         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 646 }
 647
 648
 649 /*
 650   spoolss_AddMonitor
 651 */
 652 static WERROR spoolss_AddMonitor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 653                        struct spoolss_AddMonitor *r)
 654 {
 655         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 656 }
 657
 658
 659 /*
 660   spoolss_DeleteMonitor
 661 */
 662 static WERROR spoolss_DeleteMonitor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 663                        struct spoolss_DeleteMonitor *r)
 664 {
 665         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 666 }
 667
 668
 669 /*
 670   spoolss_DeletePrintProcessor
 671 */
 672 static WERROR spoolss_DeletePrintProcessor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 673                        struct spoolss_DeletePrintProcessor *r)
 674 {
 675         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 676 }
 677
 678
 679 /*
 680   spoolss_AddPrintProvidor
 681 */
 682 static WERROR spoolss_AddPrintProvidor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 683                        struct spoolss_AddPrintProvidor *r)
 684 {
 685         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 686 }
 687
 688
 689 /*
 690   spoolss_DeletePrintProvidor
 691 */
 692 static WERROR spoolss_DeletePrintProvidor(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 693                        struct spoolss_DeletePrintProvidor *r)
 694 {
 695         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 696 }
 697
 698
 699 /*
 700   spoolss_EnumPrintProcDataTypes
 701 */
 702 static WERROR spoolss_EnumPrintProcDataTypes(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 703                        struct spoolss_EnumPrintProcDataTypes *r)
 704 {
 705         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 706 }
 707
 708
 709 /*
 710   spoolss_ResetPrinter
 711 */
 712 static WERROR spoolss_ResetPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 713                        struct spoolss_ResetPrinter *r)
 714 {
 715         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 716 }
 717
 718
 719 /*
 720   spoolss_GetPrinterDriver2
 721 */
 722 static WERROR spoolss_GetPrinterDriver2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 723                        struct spoolss_GetPrinterDriver2 *r)
 724 {
 725         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 726 }
 727
 728
 729 /*
 730   spoolss_FindFirstPrinterChangeNotification
 731 */
 732 static WERROR spoolss_FindFirstPrinterChangeNotification(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 733                        struct spoolss_FindFirstPrinterChangeNotification *r)
 734 {
 735         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 736 }
 737
 738
 739 /*
 740   spoolss_FindNextPrinterChangeNotification
 741 */
 742 static WERROR spoolss_FindNextPrinterChangeNotification(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 743                        struct spoolss_FindNextPrinterChangeNotification *r)
 744 {
 745         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 746 }
 747
 748
 749 /*
 750   spoolss_FindClosePrinterNotify
 751 */
 752 static WERROR spoolss_FindClosePrinterNotify(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 753                        struct spoolss_FindClosePrinterNotify *r)
 754 {
 755         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 756 }
 757
 758
 759 /*
 760   spoolss_RouterFindFirstPrinterChangeNotificationOld
 761 */
 762 static WERROR spoolss_RouterFindFirstPrinterChangeNotificationOld(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 763                        struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
 764 {
 765         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 766 }
 767
 768
 769 /*
 770   spoolss_ReplyOpenPrinter
 771 */
 772 static WERROR spoolss_ReplyOpenPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 773                        struct spoolss_ReplyOpenPrinter *r)
 774 {
 775         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 776 }
 777
 778
 779 /*
 780   spoolss_RouterReplyPrinter
 781 */
 782 static WERROR spoolss_RouterReplyPrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 783                        struct spoolss_RouterReplyPrinter *r)
 784 {
 785         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 786 }
 787
 788
 789 /*
 790   spoolss_ReplyClosePrinter
 791 */
 792 static WERROR spoolss_ReplyClosePrinter(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 793                        struct spoolss_ReplyClosePrinter *r)
 794 {
 795         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 796 }
 797
 798
 799 /*
 800   spoolss_AddPortEx
 801 */
 802 static WERROR spoolss_AddPortEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 803                        struct spoolss_AddPortEx *r)
 804 {
 805         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 806 }
 807
 808
 809 /*
 810   spoolss_RouterFindFirstPrinterChangeNotification
 811 */
 812 static WERROR spoolss_RouterFindFirstPrinterChangeNotification(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 813                        struct spoolss_RouterFindFirstPrinterChangeNotification *r)
 814 {
 815         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 816 }
 817
 818
 819 /*
 820   spoolss_SpoolerInit
 821 */
 822 static WERROR spoolss_SpoolerInit(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 823                        struct spoolss_SpoolerInit *r)
 824 {
 825         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 826 }
 827
 828
 829 /*
 830   spoolss_ResetPrinterEx
 831 */
 832 static WERROR spoolss_ResetPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 833                        struct spoolss_ResetPrinterEx *r)
 834 {
 835         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 836 }
 837
 838
 839 /*
 840   spoolss_RemoteFindFirstPrinterChangeNotifyEx
 841 */
 842 static WERROR spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 843                        struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
 844 {
 845         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 846 }
 847
 848
 849 /*
 850   spoolss_RouterRefreshPrinterChangeNotification
 851 */
 852 static WERROR spoolss_RouterRefreshPrinterChangeNotification(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 853                        struct spoolss_RouterRefreshPrinterChangeNotification *r)
 854 {
 855         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 856 }
 857
 858
 859 /*
 860   spoolss_RemoteFindNextPrinterChangeNotifyEx
 861 */
 862 static WERROR spoolss_RemoteFindNextPrinterChangeNotifyEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 863                        struct spoolss_RemoteFindNextPrinterChangeNotifyEx *r)
 864 {
 865         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 866 }
 867
 868
 869 /*
 870   spoolss_44
 871 */
 872 static WERROR spoolss_44(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 873                        struct spoolss_44 *r)
 874 {
 875         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 876 }
 877
 878
 879 static WERROR spoolss_OpenPrinterEx_server(struct dcesrv_call_state *dce_call,
 880                                            TALLOC_CTX *mem_ctx,
 881                                            struct spoolss_OpenPrinterEx *r)
 882 {
 883         struct spoolss_openprinter_state *state;
 884         struct dcesrv_handle *handle;
 885
 886         /* Check printername is our name */
 887
 888         if (!strequal(r->in.printername + 2, lp_netbios_name()))
 889                 return WERR_INVALID_PRINTER_NAME;
 890
 891         handle = dcesrv_handle_new(dce_call->context, SPOOLSS_HANDLE_SERVER);
 892         if (!handle) {
 893                 return WERR_NOMEM;
 894         }
 895
 896         state = talloc(handle, struct spoolss_openprinter_state);
 897         if (!state) {
 898                 return WERR_OK;
 899         }
 900
 901         handle->data = state;
 902
 903         state->access_mask = r->in.access_mask;
 904         *r->out.handle = handle->wire_handle;
 905
 906         return WERR_OK;
 907 }
 908
 909 static WERROR spoolss_OpenPrinterEx_printer(struct dcesrv_call_state *dce_call,
 910                                             TALLOC_CTX *mem_ctx,
 911                                             struct spoolss_OpenPrinterEx *r)
 912 {
 913         char *server = talloc_strdup(mem_ctx, r->in.printername + 2);
 914         char *pos, *printer;
 915
 916         pos = strchr(server, '\\');
 917         *pos = 0;
 918         printer = talloc_strdup(mem_ctx, pos + 1);
 919
 920         if (!strequal(server, lp_netbios_name()))
 921                 return WERR_INVALID_PRINTER_NAME;
 922
 923         DEBUG(0, ("looking for server %s, printer %s\n", server, printer));
 924
 925         return WERR_INVALID_PRINTER_NAME;
 926 }
 927
 928 /*
 929   spoolss_OpenPrinterEx
 930 */
 931 static WERROR spoolss_OpenPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 932                        struct spoolss_OpenPrinterEx *r)
 933 {
 934         ZERO_STRUCTP(r->out.handle);
 935
 936         /* Printername must start with \\ */
 937
 938         if (strncmp(r->in.printername, "\\\\", 2) == 0)
 939                 return WERR_INVALID_PARAM;
 940
 941         if (strchr_m(r->in.printername + 2, '\\'))
 942                 return spoolss_OpenPrinterEx_server(dce_call, mem_ctx, r);
 943
 944         return spoolss_OpenPrinterEx_printer(dce_call, mem_ctx, r);
 945 }
 946
 947
 948 /*
 949   spoolss_AddPrinterEx
 950 */
 951 static WERROR spoolss_AddPrinterEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 952                        struct spoolss_AddPrinterEx *r)
 953 {
 954         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 955 }
 956
 957
 958 /*
 959   spoolss_47
 960 */
 961 static WERROR spoolss_47(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 962                        struct spoolss_47 *r)
 963 {
 964         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 965 }
 966
 967
 968 /*
 969   spoolss_EnumPrinterData
 970 */
 971 static WERROR spoolss_EnumPrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 972                        struct spoolss_EnumPrinterData *r)
 973 {
 974         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 975 }
 976
 977
 978 /*
 979   spoolss_DeletePrinterData
 980 */
 981 static WERROR spoolss_DeletePrinterData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 982                        struct spoolss_DeletePrinterData *r)
 983 {
 984         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 985 }
 986
 987
 988 /*
 989   spoolss_4a
 990 */
 991 static WERROR spoolss_4a(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 992                        struct spoolss_4a *r)
 993 {
 994         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 995 }
 996
 997
 998 /*
 999   spoolss_4b
1000 */
1001 static WERROR spoolss_4b(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1002                        struct spoolss_4b *r)
1003 {
1004         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1005 }
1006
1007
1008 /*
1009   spoolss_4c
1010 */
1011 static WERROR spoolss_4c(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1012                        struct spoolss_4c *r)
1013 {
1014         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1015 }
1016
1017
1018 /*
1019   spoolss_SetPrinterDataEx
1020 */
1021 static WERROR spoolss_SetPrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1022                        struct spoolss_SetPrinterDataEx *r)
1023 {
1024         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1025 }
1026
1027
1028 /*
1029   spoolss_GetPrinterDataEx
1030 */
1031 static WERROR spoolss_GetPrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1032                        struct spoolss_GetPrinterDataEx *r)
1033 {
1034         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1035 }
1036
1037
1038 /*
1039   spoolss_EnumPrinterDataEx
1040 */
1041 static WERROR spoolss_EnumPrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1042                        struct spoolss_EnumPrinterDataEx *r)
1043 {
1044         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1045 }
1046
1047
1048 /*
1049   spoolss_EnumPrinterKey
1050 */
1051 static WERROR spoolss_EnumPrinterKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1052                        struct spoolss_EnumPrinterKey *r)
1053 {
1054         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1055 }
1056
1057
1058 /*
1059   spoolss_DeletePrinterDataEx
1060 */
1061 static WERROR spoolss_DeletePrinterDataEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1062                        struct spoolss_DeletePrinterDataEx *r)
1063 {
1064         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1065 }
1066
1067
1068 /*
1069   spoolss_DeletePrinterKey
1070 */
1071 static WERROR spoolss_DeletePrinterKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1072                        struct spoolss_DeletePrinterKey *r)
1073 {
1074         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1075 }
1076
1077
1078 /*
1079   spoolss_53
1080 */
1081 static WERROR spoolss_53(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1082                        struct spoolss_53 *r)
1083 {
1084         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1085 }
1086
1087
1088 /*
1089   spoolss_DeletePrinterDriverEx
1090 */
1091 static WERROR spoolss_DeletePrinterDriverEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1092                        struct spoolss_DeletePrinterDriverEx *r)
1093 {
1094         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1095 }
1096
1097
1098 /*
1099   spoolss_55
1100 */
1101 static WERROR spoolss_55(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1102                        struct spoolss_55 *r)
1103 {
1104         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1105 }
1106
1107
1108 /*
1109   spoolss_56
1110 */
1111 static WERROR spoolss_56(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1112                        struct spoolss_56 *r)
1113 {
1114         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1115 }
1116
1117
1118 /*
1119   spoolss_57
1120 */
1121 static WERROR spoolss_57(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1122                        struct spoolss_57 *r)
1123 {
1124         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1125 }
1126
1127
1128 /*
1129   spoolss_58
1130 */
1131 static WERROR spoolss_58(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1132                        struct spoolss_58 *r)
1133 {
1134         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1135 }
1136
1137
1138 /*
1139   spoolss_AddPrinterDriverEx
1140 */
1141 static WERROR spoolss_AddPrinterDriverEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1142                        struct spoolss_AddPrinterDriverEx *r)
1143 {
1144         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1145 }
1146
1147
1148 /*
1149   spoolss_5a
1150 */
1151 static WERROR spoolss_5a(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1152                        struct spoolss_5a *r)
1153 {
1154         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1155 }
1156
1157
1158 /*
1159   spoolss_5b
1160 */
1161 static WERROR spoolss_5b(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1162                        struct spoolss_5b *r)
1163 {
1164         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1165 }
1166
1167
1168 /*
1169   spoolss_5c
1170 */
1171 static WERROR spoolss_5c(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1172                        struct spoolss_5c *r)
1173 {
1174         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1175 }
1176
1177
1178 /*
1179   spoolss_5d
1180 */
1181 static WERROR spoolss_5d(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1182                        struct spoolss_5d *r)
1183 {
1184         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1185 }
1186
1187
1188 /*
1189   spoolss_5e
1190 */
1191 static WERROR spoolss_5e(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1192                        struct spoolss_5e *r)
1193 {
1194         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1195 }
1196
1197
1198 /*
1199   spoolss_5f
1200 */
1201 static WERROR spoolss_5f(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1202                        struct spoolss_5f *r)
1203 {
1204         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1205 }
1206
1207
1208 /* include the generated boilerplate */
1209 #include "librpc/gen_ndr/ndr_spoolss_s.c"