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