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