source3/rpc_server/ntsvcs/srv_ntsvcs_nt.c

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