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