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