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