source3/rpc_server/ntsvcs/srv_ntsvcs_nt.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *
   5  *  Copyright (C) Gerald (Jerry) Carter             2005.
   6  *  Copyright (C) Guenther Deschner                 2008,2009.
   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 3 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, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include "includes.h"
  23 #include "ntdomain.h"
  24 #include "librpc/rpc/dcesrv_core.h"
  25 #include "librpc/gen_ndr/ndr_ntsvcs.h"
  26 #include "librpc/gen_ndr/ndr_ntsvcs_scompat.h"
  27 #include "services/svc_winreg_glue.h"
  28 #include "../libcli/registry/util_reg.h"
  29
  30 #undef DBGC_CLASS
  31 #define DBGC_CLASS DBGC_RPC_SRV
  32
  33 /********************************************************************
  34 ********************************************************************/
  35
  36 static char* get_device_path(TALLOC_CTX *mem_ctx, const char *device )
  37 {
  38         return talloc_asprintf(mem_ctx, "ROOT\\Legacy_%s\\0000", device);
  39 }
  40
  41 /********************************************************************
  42 ********************************************************************/
  43
  44 WERROR _PNP_GetVersion(struct pipes_struct *p,
  45                        struct PNP_GetVersion *r)
  46 {
  47         *r->out.version = 0x0400;      /* no idea what this means */
  48
  49         return WERR_OK;
  50 }
  51
  52 /********************************************************************
  53 ********************************************************************/
  54
  55 WERROR _PNP_GetDeviceListSize(struct pipes_struct *p,
  56                               struct PNP_GetDeviceListSize *r)
  57 {
  58         char *devicepath;
  59
  60         if ((r->in.flags & CM_GETIDLIST_FILTER_SERVICE) &&
  61             (!r->in.devicename)) {
  62                 return WERR_CM_INVALID_POINTER;
  63         }
  64
  65         if (!(devicepath = get_device_path(p->mem_ctx, r->in.devicename))) {
  66                 return WERR_NOT_ENOUGH_MEMORY;
  67         }
  68
  69         *r->out.size = strlen(devicepath) + 2;
  70
  71         TALLOC_FREE(devicepath);
  72
  73         return WERR_OK;
  74 }
  75
  76 /****************************************************************
  77  _PNP_GetDeviceList
  78 ****************************************************************/
  79
  80 WERROR _PNP_GetDeviceList(struct pipes_struct *p,
  81                           struct PNP_GetDeviceList *r)
  82 {
  83         char *devicepath;
  84         uint32_t size = 0;
  85         const char **multi_sz = NULL;
  86         DATA_BLOB blob;
  87
  88         if ((r->in.flags & CM_GETIDLIST_FILTER_SERVICE) &&
  89             (!r->in.filter)) {
  90                 return WERR_CM_INVALID_POINTER;
  91         }
  92
  93         if (!(devicepath = get_device_path(p->mem_ctx, r->in.filter))) {
  94                 return WERR_NOT_ENOUGH_MEMORY;
  95         }
  96
  97         size = strlen(devicepath) + 2;
  98
  99         if (*r->in.length < size) {
 100                 return WERR_CM_BUFFER_SMALL;
 101         }
 102
 103         multi_sz = talloc_zero_array(p->mem_ctx, const char *, 2);
 104         if (!multi_sz) {
 105                 return WERR_NOT_ENOUGH_MEMORY;
 106         }
 107
 108         multi_sz[0] = devicepath;
 109
 110         if (!push_reg_multi_sz(multi_sz, &blob, multi_sz)) {
 111                 return WERR_NOT_ENOUGH_MEMORY;
 112         }
 113
 114         if (*r->in.length < blob.length/2) {
 115                 return WERR_CM_BUFFER_SMALL;
 116         }
 117
 118         memcpy(r->out.buffer, blob.data, blob.length);
 119
 120         return WERR_OK;
 121 }
 122
 123 /********************************************************************
 124 _PNP_GetDeviceRegProp
 125 ********************************************************************/
 126
 127 WERROR _PNP_GetDeviceRegProp(struct pipes_struct *p,
 128                              struct PNP_GetDeviceRegProp *r)
 129 {
 130         struct dcesrv_call_state *dce_call = p->dce_call;
 131         struct auth_session_info *session_info =
 132                 dcesrv_call_session_info(dce_call);
 133         char *ptr;
 134         const char *result;
 135         DATA_BLOB blob;
 136         TALLOC_CTX *mem_ctx = NULL;
 137
 138         switch( r->in.property ) {
 139         case DEV_REGPROP_DESC:
 140
 141                 /* just parse the service name from the device path and then
 142                    lookup the display name */
 143                 if ( !(ptr = strrchr_m( r->in.devicepath, '\\' )) )
 144                         return WERR_GEN_FAILURE;
 145                 *ptr = '\0';
 146
 147                 if ( !(ptr = strrchr_m( r->in.devicepath, '_' )) )
 148                         return WERR_GEN_FAILURE;
 149                 ptr++;
 150
 151                 mem_ctx = talloc_stackframe();
 152
 153                 result = svcctl_lookup_dispname(mem_ctx,
 154                                                 p->msg_ctx,
 155                                                 session_info,
 156                                                 ptr);
 157                 if (result == NULL) {
 158                         return WERR_GEN_FAILURE;
 159                 }
 160
 161                 if (!push_reg_sz(mem_ctx, &blob, result)) {
 162                         talloc_free(mem_ctx);
 163                         return WERR_GEN_FAILURE;
 164                 }
 165
 166                 if (*r->in.buffer_size < blob.length) {
 167                         *r->out.needed = blob.length;
 168                         *r->out.buffer_size = 0;
 169                         talloc_free(mem_ctx);
 170                         return WERR_CM_BUFFER_SMALL;
 171                 }
 172
 173                 r->out.buffer = (uint8_t *)talloc_memdup(p->mem_ctx, blob.data, blob.length);
 174                 talloc_free(mem_ctx);
 175                 if (!r->out.buffer) {
 176                         return WERR_NOT_ENOUGH_MEMORY;
 177                 }
 178
 179                 *r->out.reg_data_type = REG_SZ; /* always 1...tested using a remove device manager connection */
 180                 *r->out.buffer_size = blob.length;
 181                 *r->out.needed = blob.length;
 182
 183                 break;
 184
 185         default:
 186                 *r->out.reg_data_type = 0x00437c98; /* ??? */
 187                 return WERR_CM_NO_SUCH_VALUE;
 188         }
 189
 190         return WERR_OK;
 191 }
 192
 193 /********************************************************************
 194 ********************************************************************/
 195
 196 WERROR _PNP_ValidateDeviceInstance(struct pipes_struct *p,
 197                                    struct PNP_ValidateDeviceInstance *r)
 198 {
 199         /* whatever dude */
 200         return WERR_OK;
 201 }
 202
 203 /********************************************************************
 204 ********************************************************************/
 205
 206 WERROR _PNP_GetHwProfInfo(struct pipes_struct *p,
 207                           struct PNP_GetHwProfInfo *r)
 208 {
 209         /* steal the incoming buffer */
 210
 211         r->out.info = r->in.info;
 212
 213         /* Take the 5th Ammentment */
 214
 215         return WERR_CM_NO_MORE_HW_PROFILES;
 216 }
 217
 218 /********************************************************************
 219 ********************************************************************/
 220
 221 WERROR _PNP_HwProfFlags(struct pipes_struct *p,
 222                         struct PNP_HwProfFlags *r)
 223 {
 224         /* just nod your head */
 225
 226         return WERR_OK;
 227 }
 228
 229 /****************************************************************
 230 ****************************************************************/
 231
 232 WERROR _PNP_Disconnect(struct pipes_struct *p,
 233                        struct PNP_Disconnect *r)
 234 {
 235         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 236         return WERR_NOT_SUPPORTED;
 237 }
 238
 239 /****************************************************************
 240 ****************************************************************/
 241
 242 WERROR _PNP_Connect(struct pipes_struct *p,
 243                     struct PNP_Connect *r)
 244 {
 245         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 246         return WERR_NOT_SUPPORTED;
 247 }
 248
 249 /****************************************************************
 250 ****************************************************************/
 251
 252 WERROR _PNP_GetGlobalState(struct pipes_struct *p,
 253                            struct PNP_GetGlobalState *r)
 254 {
 255         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 256         return WERR_NOT_SUPPORTED;
 257 }
 258
 259 /****************************************************************
 260 ****************************************************************/
 261
 262 WERROR _PNP_InitDetection(struct pipes_struct *p,
 263                           struct PNP_InitDetection *r)
 264 {
 265         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 266         return WERR_NOT_SUPPORTED;
 267 }
 268
 269 /****************************************************************
 270 ****************************************************************/
 271
 272 WERROR _PNP_ReportLogOn(struct pipes_struct *p,
 273                         struct PNP_ReportLogOn *r)
 274 {
 275         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 276         return WERR_NOT_SUPPORTED;
 277 }
 278
 279 /****************************************************************
 280 ****************************************************************/
 281
 282 WERROR _PNP_GetRootDeviceInstance(struct pipes_struct *p,
 283                                   struct PNP_GetRootDeviceInstance *r)
 284 {
 285         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 286         return WERR_NOT_SUPPORTED;
 287 }
 288
 289 /****************************************************************
 290 ****************************************************************/
 291
 292 WERROR _PNP_GetRelatedDeviceInstance(struct pipes_struct *p,
 293                                      struct PNP_GetRelatedDeviceInstance *r)
 294 {
 295         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 296         return WERR_NOT_SUPPORTED;
 297 }
 298
 299 /****************************************************************
 300 ****************************************************************/
 301
 302 WERROR _PNP_EnumerateSubKeys(struct pipes_struct *p,
 303                              struct PNP_EnumerateSubKeys *r)
 304 {
 305         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 306         return WERR_NOT_SUPPORTED;
 307 }
 308
 309 /****************************************************************
 310 ****************************************************************/
 311
 312 WERROR _PNP_GetDepth(struct pipes_struct *p,
 313                      struct PNP_GetDepth *r)
 314 {
 315         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 316         return WERR_NOT_SUPPORTED;
 317 }
 318
 319 /****************************************************************
 320 ****************************************************************/
 321
 322 WERROR _PNP_SetDeviceRegProp(struct pipes_struct *p,
 323                              struct PNP_SetDeviceRegProp *r)
 324 {
 325         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 326         return WERR_NOT_SUPPORTED;
 327 }
 328
 329 /****************************************************************
 330 ****************************************************************/
 331
 332 WERROR _PNP_GetClassInstance(struct pipes_struct *p,
 333                              struct PNP_GetClassInstance *r)
 334 {
 335         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 336         return WERR_NOT_SUPPORTED;
 337 }
 338
 339 /****************************************************************
 340 ****************************************************************/
 341
 342 WERROR _PNP_CreateKey(struct pipes_struct *p,
 343                       struct PNP_CreateKey *r)
 344 {
 345         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 346         return WERR_NOT_SUPPORTED;
 347 }
 348
 349 /****************************************************************
 350 ****************************************************************/
 351
 352 WERROR _PNP_DeleteRegistryKey(struct pipes_struct *p,
 353                               struct PNP_DeleteRegistryKey *r)
 354 {
 355         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 356         return WERR_NOT_SUPPORTED;
 357 }
 358
 359 /****************************************************************
 360 ****************************************************************/
 361
 362 WERROR _PNP_GetClassCount(struct pipes_struct *p,
 363                           struct PNP_GetClassCount *r)
 364 {
 365         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 366         return WERR_NOT_SUPPORTED;
 367 }
 368
 369 /****************************************************************
 370 ****************************************************************/
 371
 372 WERROR _PNP_GetClassName(struct pipes_struct *p,
 373                          struct PNP_GetClassName *r)
 374 {
 375         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 376         return WERR_NOT_SUPPORTED;
 377 }
 378
 379 /****************************************************************
 380 ****************************************************************/
 381
 382 WERROR _PNP_DeleteClassKey(struct pipes_struct *p,
 383                            struct PNP_DeleteClassKey *r)
 384 {
 385         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 386         return WERR_NOT_SUPPORTED;
 387 }
 388
 389 /****************************************************************
 390 ****************************************************************/
 391
 392 WERROR _PNP_GetInterfaceDeviceAlias(struct pipes_struct *p,
 393                                     struct PNP_GetInterfaceDeviceAlias *r)
 394 {
 395         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 396         return WERR_NOT_SUPPORTED;
 397 }
 398
 399 /****************************************************************
 400 ****************************************************************/
 401
 402 WERROR _PNP_GetInterfaceDeviceList(struct pipes_struct *p,
 403                                    struct PNP_GetInterfaceDeviceList *r)
 404 {
 405         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 406         return WERR_NOT_SUPPORTED;
 407 }
 408
 409 /****************************************************************
 410 ****************************************************************/
 411
 412 WERROR _PNP_GetInterfaceDeviceListSize(struct pipes_struct *p,
 413                                        struct PNP_GetInterfaceDeviceListSize *r)
 414 {
 415         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 416         return WERR_NOT_SUPPORTED;
 417 }
 418
 419 /****************************************************************
 420 ****************************************************************/
 421
 422 WERROR _PNP_RegisterDeviceClassAssociation(struct pipes_struct *p,
 423                                            struct PNP_RegisterDeviceClassAssociation *r)
 424 {
 425         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 426         return WERR_NOT_SUPPORTED;
 427 }
 428
 429 /****************************************************************
 430 ****************************************************************/
 431
 432 WERROR _PNP_UnregisterDeviceClassAssociation(struct pipes_struct *p,
 433                                              struct PNP_UnregisterDeviceClassAssociation *r)
 434 {
 435         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 436         return WERR_NOT_SUPPORTED;
 437 }
 438
 439 /****************************************************************
 440 ****************************************************************/
 441
 442 WERROR _PNP_GetClassRegProp(struct pipes_struct *p,
 443                             struct PNP_GetClassRegProp *r)
 444 {
 445         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 446         return WERR_NOT_SUPPORTED;
 447 }
 448
 449 /****************************************************************
 450 ****************************************************************/
 451
 452 WERROR _PNP_SetClassRegProp(struct pipes_struct *p,
 453                             struct PNP_SetClassRegProp *r)
 454 {
 455         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 456         return WERR_NOT_SUPPORTED;
 457 }
 458
 459 /****************************************************************
 460 ****************************************************************/
 461
 462 WERROR _PNP_CreateDevInst(struct pipes_struct *p,
 463                           struct PNP_CreateDevInst *r)
 464 {
 465         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 466         return WERR_NOT_SUPPORTED;
 467 }
 468
 469 /****************************************************************
 470 ****************************************************************/
 471
 472 WERROR _PNP_DeviceInstanceAction(struct pipes_struct *p,
 473                                  struct PNP_DeviceInstanceAction *r)
 474 {
 475         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 476         return WERR_NOT_SUPPORTED;
 477 }
 478
 479 /****************************************************************
 480 ****************************************************************/
 481
 482 WERROR _PNP_GetDeviceStatus(struct pipes_struct *p,
 483                             struct PNP_GetDeviceStatus *r)
 484 {
 485         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 486         return WERR_NOT_SUPPORTED;
 487 }
 488
 489 /****************************************************************
 490 ****************************************************************/
 491
 492 WERROR _PNP_SetDeviceProblem(struct pipes_struct *p,
 493                              struct PNP_SetDeviceProblem *r)
 494 {
 495         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 496         return WERR_NOT_SUPPORTED;
 497 }
 498
 499 /****************************************************************
 500 ****************************************************************/
 501
 502 WERROR _PNP_DisableDevInst(struct pipes_struct *p,
 503                            struct PNP_DisableDevInst *r)
 504 {
 505         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 506         return WERR_NOT_SUPPORTED;
 507 }
 508
 509 /****************************************************************
 510 ****************************************************************/
 511
 512 WERROR _PNP_UninstallDevInst(struct pipes_struct *p,
 513                              struct PNP_UninstallDevInst *r)
 514 {
 515         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 516         return WERR_NOT_SUPPORTED;
 517 }
 518
 519 /****************************************************************
 520 ****************************************************************/
 521
 522 WERROR _PNP_AddID(struct pipes_struct *p,
 523                   struct PNP_AddID *r)
 524 {
 525         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 526         return WERR_NOT_SUPPORTED;
 527 }
 528
 529 /****************************************************************
 530 ****************************************************************/
 531
 532 WERROR _PNP_RegisterDriver(struct pipes_struct *p,
 533                            struct PNP_RegisterDriver *r)
 534 {
 535         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 536         return WERR_NOT_SUPPORTED;
 537 }
 538
 539 /****************************************************************
 540 ****************************************************************/
 541
 542 WERROR _PNP_QueryRemove(struct pipes_struct *p,
 543                         struct PNP_QueryRemove *r)
 544 {
 545         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 546         return WERR_NOT_SUPPORTED;
 547 }
 548
 549 /****************************************************************
 550 ****************************************************************/
 551
 552 WERROR _PNP_RequestDeviceEject(struct pipes_struct *p,
 553                                struct PNP_RequestDeviceEject *r)
 554 {
 555         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 556         return WERR_NOT_SUPPORTED;
 557 }
 558
 559 /****************************************************************
 560 ****************************************************************/
 561
 562 WERROR _PNP_IsDockStationPresent(struct pipes_struct *p,
 563                                  struct PNP_IsDockStationPresent *r)
 564 {
 565         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 566         return WERR_NOT_SUPPORTED;
 567 }
 568
 569 /****************************************************************
 570 ****************************************************************/
 571
 572 WERROR _PNP_RequestEjectPC(struct pipes_struct *p,
 573                            struct PNP_RequestEjectPC *r)
 574 {
 575         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 576         return WERR_NOT_SUPPORTED;
 577 }
 578
 579 /****************************************************************
 580 ****************************************************************/
 581
 582 WERROR _PNP_AddEmptyLogConf(struct pipes_struct *p,
 583                             struct PNP_AddEmptyLogConf *r)
 584 {
 585         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 586         return WERR_NOT_SUPPORTED;
 587 }
 588
 589 /****************************************************************
 590 ****************************************************************/
 591
 592 WERROR _PNP_FreeLogConf(struct pipes_struct *p,
 593                         struct PNP_FreeLogConf *r)
 594 {
 595         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 596         return WERR_NOT_SUPPORTED;
 597 }
 598
 599 /****************************************************************
 600 ****************************************************************/
 601
 602 WERROR _PNP_GetFirstLogConf(struct pipes_struct *p,
 603                             struct PNP_GetFirstLogConf *r)
 604 {
 605         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 606         return WERR_NOT_SUPPORTED;
 607 }
 608
 609 /****************************************************************
 610 ****************************************************************/
 611
 612 WERROR _PNP_GetNextLogConf(struct pipes_struct *p,
 613                            struct PNP_GetNextLogConf *r)
 614 {
 615         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 616         return WERR_NOT_SUPPORTED;
 617 }
 618
 619 /****************************************************************
 620 ****************************************************************/
 621
 622 WERROR _PNP_GetLogConfPriority(struct pipes_struct *p,
 623                                struct PNP_GetLogConfPriority *r)
 624 {
 625         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 626         return WERR_NOT_SUPPORTED;
 627 }
 628
 629 /****************************************************************
 630 ****************************************************************/
 631
 632 WERROR _PNP_AddResDes(struct pipes_struct *p,
 633                       struct PNP_AddResDes *r)
 634 {
 635         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 636         return WERR_NOT_SUPPORTED;
 637 }
 638
 639 /****************************************************************
 640 ****************************************************************/
 641
 642 WERROR _PNP_FreeResDes(struct pipes_struct *p,
 643                        struct PNP_FreeResDes *r)
 644 {
 645         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 646         return WERR_NOT_SUPPORTED;
 647 }
 648
 649 /****************************************************************
 650 ****************************************************************/
 651
 652 WERROR _PNP_GetNextResDes(struct pipes_struct *p,
 653                           struct PNP_GetNextResDes *r)
 654 {
 655         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 656         return WERR_NOT_SUPPORTED;
 657 }
 658
 659 /****************************************************************
 660 ****************************************************************/
 661
 662 WERROR _PNP_GetResDesData(struct pipes_struct *p,
 663                           struct PNP_GetResDesData *r)
 664 {
 665         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 666         return WERR_NOT_SUPPORTED;
 667 }
 668
 669 /****************************************************************
 670 ****************************************************************/
 671
 672 WERROR _PNP_GetResDesDataSize(struct pipes_struct *p,
 673                               struct PNP_GetResDesDataSize *r)
 674 {
 675         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 676         return WERR_NOT_SUPPORTED;
 677 }
 678
 679 /****************************************************************
 680 ****************************************************************/
 681
 682 WERROR _PNP_ModifyResDes(struct pipes_struct *p,
 683                          struct PNP_ModifyResDes *r)
 684 {
 685         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 686         return WERR_NOT_SUPPORTED;
 687 }
 688
 689 /****************************************************************
 690 ****************************************************************/
 691
 692 WERROR _PNP_DetectResourceLimit(struct pipes_struct *p,
 693                                 struct PNP_DetectResourceLimit *r)
 694 {
 695         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 696         return WERR_NOT_SUPPORTED;
 697 }
 698
 699 /****************************************************************
 700 ****************************************************************/
 701
 702 WERROR _PNP_QueryResConfList(struct pipes_struct *p,
 703                              struct PNP_QueryResConfList *r)
 704 {
 705         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 706         return WERR_NOT_SUPPORTED;
 707 }
 708
 709 /****************************************************************
 710 ****************************************************************/
 711
 712 WERROR _PNP_SetHwProf(struct pipes_struct *p,
 713                       struct PNP_SetHwProf *r)
 714 {
 715         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 716         return WERR_NOT_SUPPORTED;
 717 }
 718
 719 /****************************************************************
 720 ****************************************************************/
 721
 722 WERROR _PNP_QueryArbitratorFreeData(struct pipes_struct *p,
 723                                     struct PNP_QueryArbitratorFreeData *r)
 724 {
 725         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 726         return WERR_NOT_SUPPORTED;
 727 }
 728
 729 /****************************************************************
 730 ****************************************************************/
 731
 732 WERROR _PNP_QueryArbitratorFreeSize(struct pipes_struct *p,
 733                                     struct PNP_QueryArbitratorFreeSize *r)
 734 {
 735         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 736         return WERR_NOT_SUPPORTED;
 737 }
 738
 739 /****************************************************************
 740 ****************************************************************/
 741
 742 WERROR _PNP_RunDetection(struct pipes_struct *p,
 743                          struct PNP_RunDetection *r)
 744 {
 745         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 746         return WERR_NOT_SUPPORTED;
 747 }
 748
 749 /****************************************************************
 750 ****************************************************************/
 751
 752 WERROR _PNP_RegisterNotification(struct pipes_struct *p,
 753                                  struct PNP_RegisterNotification *r)
 754 {
 755         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 756         return WERR_NOT_SUPPORTED;
 757 }
 758
 759 /****************************************************************
 760 ****************************************************************/
 761
 762 WERROR _PNP_UnregisterNotification(struct pipes_struct *p,
 763                                    struct PNP_UnregisterNotification *r)
 764 {
 765         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 766         return WERR_NOT_SUPPORTED;
 767 }
 768
 769 /****************************************************************
 770 ****************************************************************/
 771
 772 WERROR _PNP_GetCustomDevProp(struct pipes_struct *p,
 773                              struct PNP_GetCustomDevProp *r)
 774 {
 775         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 776         return WERR_NOT_SUPPORTED;
 777 }
 778
 779 /****************************************************************
 780 ****************************************************************/
 781
 782 WERROR _PNP_GetVersionInternal(struct pipes_struct *p,
 783                                struct PNP_GetVersionInternal *r)
 784 {
 785         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 786         return WERR_NOT_SUPPORTED;
 787 }
 788
 789 /****************************************************************
 790 ****************************************************************/
 791
 792 WERROR _PNP_GetBlockedDriverInfo(struct pipes_struct *p,
 793                                  struct PNP_GetBlockedDriverInfo *r)
 794 {
 795         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 796         return WERR_NOT_SUPPORTED;
 797 }
 798
 799 /****************************************************************
 800 ****************************************************************/
 801
 802 WERROR _PNP_GetServerSideDeviceInstallFlags(struct pipes_struct *p,
 803                                             struct PNP_GetServerSideDeviceInstallFlags *r)
 804 {
 805         p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
 806         return WERR_NOT_SUPPORTED;
 807 }
 808
 809 /* include the generated boilerplate */
 810 #include "librpc/gen_ndr/ndr_ntsvcs_scompat.c"