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