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