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