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