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