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