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