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