source3/librpc/gen_ndr/cli_ntsvcs.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * client auto-generated by pidl. DO NOT MODIFY!
   4  */
   5
   6 #include "includes.h"
   7 #include "librpc/gen_ndr/cli_ntsvcs.h"
   8
   9 NTSTATUS rpccli_PNP_Disconnect(struct rpc_pipe_client *cli,
  10                                TALLOC_CTX *mem_ctx,
  11                                WERROR *werror)
  12 {
  13         struct PNP_Disconnect r;
  14         NTSTATUS status;
  15
  16         /* In parameters */
  17
  18         if (DEBUGLEVEL >= 10) {
  19                 NDR_PRINT_IN_DEBUG(PNP_Disconnect, &r);
  20         }
  21
  22         status = cli_do_rpc_ndr(cli,
  23                                 mem_ctx,
  24                                 &ndr_table_ntsvcs,
  25                                 NDR_PNP_DISCONNECT,
  26                                 &r);
  27
  28         if (!NT_STATUS_IS_OK(status)) {
  29                 return status;
  30         }
  31
  32         if (DEBUGLEVEL >= 10) {
  33                 NDR_PRINT_OUT_DEBUG(PNP_Disconnect, &r);
  34         }
  35
  36         if (NT_STATUS_IS_ERR(status)) {
  37                 return status;
  38         }
  39
  40         /* Return variables */
  41
  42         /* Return result */
  43         if (werror) {
  44                 *werror = r.out.result;
  45         }
  46
  47         return werror_to_ntstatus(r.out.result);
  48 }
  49
  50 NTSTATUS rpccli_PNP_Connect(struct rpc_pipe_client *cli,
  51                             TALLOC_CTX *mem_ctx,
  52                             WERROR *werror)
  53 {
  54         struct PNP_Connect r;
  55         NTSTATUS status;
  56
  57         /* In parameters */
  58
  59         if (DEBUGLEVEL >= 10) {
  60                 NDR_PRINT_IN_DEBUG(PNP_Connect, &r);
  61         }
  62
  63         status = cli_do_rpc_ndr(cli,
  64                                 mem_ctx,
  65                                 &ndr_table_ntsvcs,
  66                                 NDR_PNP_CONNECT,
  67                                 &r);
  68
  69         if (!NT_STATUS_IS_OK(status)) {
  70                 return status;
  71         }
  72
  73         if (DEBUGLEVEL >= 10) {
  74                 NDR_PRINT_OUT_DEBUG(PNP_Connect, &r);
  75         }
  76
  77         if (NT_STATUS_IS_ERR(status)) {
  78                 return status;
  79         }
  80
  81         /* Return variables */
  82
  83         /* Return result */
  84         if (werror) {
  85                 *werror = r.out.result;
  86         }
  87
  88         return werror_to_ntstatus(r.out.result);
  89 }
  90
  91 NTSTATUS rpccli_PNP_GetVersion(struct rpc_pipe_client *cli,
  92                                TALLOC_CTX *mem_ctx,
  93                                uint16_t *version /* [out] [ref] */,
  94                                WERROR *werror)
  95 {
  96         struct PNP_GetVersion r;
  97         NTSTATUS status;
  98
  99         /* In parameters */
 100
 101         if (DEBUGLEVEL >= 10) {
 102                 NDR_PRINT_IN_DEBUG(PNP_GetVersion, &r);
 103         }
 104
 105         status = cli_do_rpc_ndr(cli,
 106                                 mem_ctx,
 107                                 &ndr_table_ntsvcs,
 108                                 NDR_PNP_GETVERSION,
 109                                 &r);
 110
 111         if (!NT_STATUS_IS_OK(status)) {
 112                 return status;
 113         }
 114
 115         if (DEBUGLEVEL >= 10) {
 116                 NDR_PRINT_OUT_DEBUG(PNP_GetVersion, &r);
 117         }
 118
 119         if (NT_STATUS_IS_ERR(status)) {
 120                 return status;
 121         }
 122
 123         /* Return variables */
 124         *version = *r.out.version;
 125
 126         /* Return result */
 127         if (werror) {
 128                 *werror = r.out.result;
 129         }
 130
 131         return werror_to_ntstatus(r.out.result);
 132 }
 133
 134 NTSTATUS rpccli_PNP_GetGlobalState(struct rpc_pipe_client *cli,
 135                                    TALLOC_CTX *mem_ctx,
 136                                    WERROR *werror)
 137 {
 138         struct PNP_GetGlobalState r;
 139         NTSTATUS status;
 140
 141         /* In parameters */
 142
 143         if (DEBUGLEVEL >= 10) {
 144                 NDR_PRINT_IN_DEBUG(PNP_GetGlobalState, &r);
 145         }
 146
 147         status = cli_do_rpc_ndr(cli,
 148                                 mem_ctx,
 149                                 &ndr_table_ntsvcs,
 150                                 NDR_PNP_GETGLOBALSTATE,
 151                                 &r);
 152
 153         if (!NT_STATUS_IS_OK(status)) {
 154                 return status;
 155         }
 156
 157         if (DEBUGLEVEL >= 10) {
 158                 NDR_PRINT_OUT_DEBUG(PNP_GetGlobalState, &r);
 159         }
 160
 161         if (NT_STATUS_IS_ERR(status)) {
 162                 return status;
 163         }
 164
 165         /* Return variables */
 166
 167         /* Return result */
 168         if (werror) {
 169                 *werror = r.out.result;
 170         }
 171
 172         return werror_to_ntstatus(r.out.result);
 173 }
 174
 175 NTSTATUS rpccli_PNP_InitDetection(struct rpc_pipe_client *cli,
 176                                   TALLOC_CTX *mem_ctx,
 177                                   WERROR *werror)
 178 {
 179         struct PNP_InitDetection r;
 180         NTSTATUS status;
 181
 182         /* In parameters */
 183
 184         if (DEBUGLEVEL >= 10) {
 185                 NDR_PRINT_IN_DEBUG(PNP_InitDetection, &r);
 186         }
 187
 188         status = cli_do_rpc_ndr(cli,
 189                                 mem_ctx,
 190                                 &ndr_table_ntsvcs,
 191                                 NDR_PNP_INITDETECTION,
 192                                 &r);
 193
 194         if (!NT_STATUS_IS_OK(status)) {
 195                 return status;
 196         }
 197
 198         if (DEBUGLEVEL >= 10) {
 199                 NDR_PRINT_OUT_DEBUG(PNP_InitDetection, &r);
 200         }
 201
 202         if (NT_STATUS_IS_ERR(status)) {
 203                 return status;
 204         }
 205
 206         /* Return variables */
 207
 208         /* Return result */
 209         if (werror) {
 210                 *werror = r.out.result;
 211         }
 212
 213         return werror_to_ntstatus(r.out.result);
 214 }
 215
 216 NTSTATUS rpccli_PNP_ReportLogOn(struct rpc_pipe_client *cli,
 217                                 TALLOC_CTX *mem_ctx,
 218                                 WERROR *werror)
 219 {
 220         struct PNP_ReportLogOn r;
 221         NTSTATUS status;
 222
 223         /* In parameters */
 224
 225         if (DEBUGLEVEL >= 10) {
 226                 NDR_PRINT_IN_DEBUG(PNP_ReportLogOn, &r);
 227         }
 228
 229         status = cli_do_rpc_ndr(cli,
 230                                 mem_ctx,
 231                                 &ndr_table_ntsvcs,
 232                                 NDR_PNP_REPORTLOGON,
 233                                 &r);
 234
 235         if (!NT_STATUS_IS_OK(status)) {
 236                 return status;
 237         }
 238
 239         if (DEBUGLEVEL >= 10) {
 240                 NDR_PRINT_OUT_DEBUG(PNP_ReportLogOn, &r);
 241         }
 242
 243         if (NT_STATUS_IS_ERR(status)) {
 244                 return status;
 245         }
 246
 247         /* Return variables */
 248
 249         /* Return result */
 250         if (werror) {
 251                 *werror = r.out.result;
 252         }
 253
 254         return werror_to_ntstatus(r.out.result);
 255 }
 256
 257 NTSTATUS rpccli_PNP_ValidateDeviceInstance(struct rpc_pipe_client *cli,
 258                                            TALLOC_CTX *mem_ctx,
 259                                            const char *devicepath /* [in] [ref,charset(UTF16)] */,
 260                                            uint32_t flags /* [in]  */,
 261                                            WERROR *werror)
 262 {
 263         struct PNP_ValidateDeviceInstance r;
 264         NTSTATUS status;
 265
 266         /* In parameters */
 267         r.in.devicepath = devicepath;
 268         r.in.flags = flags;
 269
 270         if (DEBUGLEVEL >= 10) {
 271                 NDR_PRINT_IN_DEBUG(PNP_ValidateDeviceInstance, &r);
 272         }
 273
 274         status = cli_do_rpc_ndr(cli,
 275                                 mem_ctx,
 276                                 &ndr_table_ntsvcs,
 277                                 NDR_PNP_VALIDATEDEVICEINSTANCE,
 278                                 &r);
 279
 280         if (!NT_STATUS_IS_OK(status)) {
 281                 return status;
 282         }
 283
 284         if (DEBUGLEVEL >= 10) {
 285                 NDR_PRINT_OUT_DEBUG(PNP_ValidateDeviceInstance, &r);
 286         }
 287
 288         if (NT_STATUS_IS_ERR(status)) {
 289                 return status;
 290         }
 291
 292         /* Return variables */
 293
 294         /* Return result */
 295         if (werror) {
 296                 *werror = r.out.result;
 297         }
 298
 299         return werror_to_ntstatus(r.out.result);
 300 }
 301
 302 NTSTATUS rpccli_PNP_GetRootDeviceInstance(struct rpc_pipe_client *cli,
 303                                           TALLOC_CTX *mem_ctx,
 304                                           WERROR *werror)
 305 {
 306         struct PNP_GetRootDeviceInstance r;
 307         NTSTATUS status;
 308
 309         /* In parameters */
 310
 311         if (DEBUGLEVEL >= 10) {
 312                 NDR_PRINT_IN_DEBUG(PNP_GetRootDeviceInstance, &r);
 313         }
 314
 315         status = cli_do_rpc_ndr(cli,
 316                                 mem_ctx,
 317                                 &ndr_table_ntsvcs,
 318                                 NDR_PNP_GETROOTDEVICEINSTANCE,
 319                                 &r);
 320
 321         if (!NT_STATUS_IS_OK(status)) {
 322                 return status;
 323         }
 324
 325         if (DEBUGLEVEL >= 10) {
 326                 NDR_PRINT_OUT_DEBUG(PNP_GetRootDeviceInstance, &r);
 327         }
 328
 329         if (NT_STATUS_IS_ERR(status)) {
 330                 return status;
 331         }
 332
 333         /* Return variables */
 334
 335         /* Return result */
 336         if (werror) {
 337                 *werror = r.out.result;
 338         }
 339
 340         return werror_to_ntstatus(r.out.result);
 341 }
 342
 343 NTSTATUS rpccli_PNP_GetRelatedDeviceInstance(struct rpc_pipe_client *cli,
 344                                              TALLOC_CTX *mem_ctx,
 345                                              WERROR *werror)
 346 {
 347         struct PNP_GetRelatedDeviceInstance r;
 348         NTSTATUS status;
 349
 350         /* In parameters */
 351
 352         if (DEBUGLEVEL >= 10) {
 353                 NDR_PRINT_IN_DEBUG(PNP_GetRelatedDeviceInstance, &r);
 354         }
 355
 356         status = cli_do_rpc_ndr(cli,
 357                                 mem_ctx,
 358                                 &ndr_table_ntsvcs,
 359                                 NDR_PNP_GETRELATEDDEVICEINSTANCE,
 360                                 &r);
 361
 362         if (!NT_STATUS_IS_OK(status)) {
 363                 return status;
 364         }
 365
 366         if (DEBUGLEVEL >= 10) {
 367                 NDR_PRINT_OUT_DEBUG(PNP_GetRelatedDeviceInstance, &r);
 368         }
 369
 370         if (NT_STATUS_IS_ERR(status)) {
 371                 return status;
 372         }
 373
 374         /* Return variables */
 375
 376         /* Return result */
 377         if (werror) {
 378                 *werror = r.out.result;
 379         }
 380
 381         return werror_to_ntstatus(r.out.result);
 382 }
 383
 384 NTSTATUS rpccli_PNP_EnumerateSubKeys(struct rpc_pipe_client *cli,
 385                                      TALLOC_CTX *mem_ctx,
 386                                      WERROR *werror)
 387 {
 388         struct PNP_EnumerateSubKeys r;
 389         NTSTATUS status;
 390
 391         /* In parameters */
 392
 393         if (DEBUGLEVEL >= 10) {
 394                 NDR_PRINT_IN_DEBUG(PNP_EnumerateSubKeys, &r);
 395         }
 396
 397         status = cli_do_rpc_ndr(cli,
 398                                 mem_ctx,
 399                                 &ndr_table_ntsvcs,
 400                                 NDR_PNP_ENUMERATESUBKEYS,
 401                                 &r);
 402
 403         if (!NT_STATUS_IS_OK(status)) {
 404                 return status;
 405         }
 406
 407         if (DEBUGLEVEL >= 10) {
 408                 NDR_PRINT_OUT_DEBUG(PNP_EnumerateSubKeys, &r);
 409         }
 410
 411         if (NT_STATUS_IS_ERR(status)) {
 412                 return status;
 413         }
 414
 415         /* Return variables */
 416
 417         /* Return result */
 418         if (werror) {
 419                 *werror = r.out.result;
 420         }
 421
 422         return werror_to_ntstatus(r.out.result);
 423 }
 424
 425 NTSTATUS rpccli_PNP_GetDeviceList(struct rpc_pipe_client *cli,
 426                                   TALLOC_CTX *mem_ctx,
 427                                   const char *filter /* [in] [unique,charset(UTF16)] */,
 428                                   uint16_t *buffer /* [out] [ref,length_is(*length),size_is(*length)] */,
 429                                   uint32_t *length /* [in,out] [ref] */,
 430                                   uint32_t flags /* [in]  */,
 431                                   WERROR *werror)
 432 {
 433         struct PNP_GetDeviceList r;
 434         NTSTATUS status;
 435
 436         /* In parameters */
 437         r.in.filter = filter;
 438         r.in.length = length;
 439         r.in.flags = flags;
 440
 441         if (DEBUGLEVEL >= 10) {
 442                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceList, &r);
 443         }
 444
 445         status = cli_do_rpc_ndr(cli,
 446                                 mem_ctx,
 447                                 &ndr_table_ntsvcs,
 448                                 NDR_PNP_GETDEVICELIST,
 449                                 &r);
 450
 451         if (!NT_STATUS_IS_OK(status)) {
 452                 return status;
 453         }
 454
 455         if (DEBUGLEVEL >= 10) {
 456                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceList, &r);
 457         }
 458
 459         if (NT_STATUS_IS_ERR(status)) {
 460                 return status;
 461         }
 462
 463         /* Return variables */
 464         memcpy(buffer, r.out.buffer, *r.in.length * sizeof(*buffer));
 465         *length = *r.out.length;
 466
 467         /* Return result */
 468         if (werror) {
 469                 *werror = r.out.result;
 470         }
 471
 472         return werror_to_ntstatus(r.out.result);
 473 }
 474
 475 NTSTATUS rpccli_PNP_GetDeviceListSize(struct rpc_pipe_client *cli,
 476                                       TALLOC_CTX *mem_ctx,
 477                                       const char *devicename /* [in] [unique,charset(UTF16)] */,
 478                                       uint32_t *size /* [out] [ref] */,
 479                                       uint32_t flags /* [in]  */,
 480                                       WERROR *werror)
 481 {
 482         struct PNP_GetDeviceListSize r;
 483         NTSTATUS status;
 484
 485         /* In parameters */
 486         r.in.devicename = devicename;
 487         r.in.flags = flags;
 488
 489         if (DEBUGLEVEL >= 10) {
 490                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceListSize, &r);
 491         }
 492
 493         status = cli_do_rpc_ndr(cli,
 494                                 mem_ctx,
 495                                 &ndr_table_ntsvcs,
 496                                 NDR_PNP_GETDEVICELISTSIZE,
 497                                 &r);
 498
 499         if (!NT_STATUS_IS_OK(status)) {
 500                 return status;
 501         }
 502
 503         if (DEBUGLEVEL >= 10) {
 504                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceListSize, &r);
 505         }
 506
 507         if (NT_STATUS_IS_ERR(status)) {
 508                 return status;
 509         }
 510
 511         /* Return variables */
 512         *size = *r.out.size;
 513
 514         /* Return result */
 515         if (werror) {
 516                 *werror = r.out.result;
 517         }
 518
 519         return werror_to_ntstatus(r.out.result);
 520 }
 521
 522 NTSTATUS rpccli_PNP_GetDepth(struct rpc_pipe_client *cli,
 523                              TALLOC_CTX *mem_ctx,
 524                              WERROR *werror)
 525 {
 526         struct PNP_GetDepth r;
 527         NTSTATUS status;
 528
 529         /* In parameters */
 530
 531         if (DEBUGLEVEL >= 10) {
 532                 NDR_PRINT_IN_DEBUG(PNP_GetDepth, &r);
 533         }
 534
 535         status = cli_do_rpc_ndr(cli,
 536                                 mem_ctx,
 537                                 &ndr_table_ntsvcs,
 538                                 NDR_PNP_GETDEPTH,
 539                                 &r);
 540
 541         if (!NT_STATUS_IS_OK(status)) {
 542                 return status;
 543         }
 544
 545         if (DEBUGLEVEL >= 10) {
 546                 NDR_PRINT_OUT_DEBUG(PNP_GetDepth, &r);
 547         }
 548
 549         if (NT_STATUS_IS_ERR(status)) {
 550                 return status;
 551         }
 552
 553         /* Return variables */
 554
 555         /* Return result */
 556         if (werror) {
 557                 *werror = r.out.result;
 558         }
 559
 560         return werror_to_ntstatus(r.out.result);
 561 }
 562
 563 NTSTATUS rpccli_PNP_GetDeviceRegProp(struct rpc_pipe_client *cli,
 564                                      TALLOC_CTX *mem_ctx,
 565                                      const char *devicepath /* [in] [ref,charset(UTF16)] */,
 566                                      uint32_t property /* [in]  */,
 567                                      uint32_t *reg_data_type /* [in,out] [ref] */,
 568                                      uint8_t *buffer /* [out] [ref,length_is(*buffer_size),size_is(*buffer_size)] */,
 569                                      uint32_t *buffer_size /* [in,out] [ref] */,
 570                                      uint32_t *needed /* [in,out] [ref] */,
 571                                      uint32_t flags /* [in]  */,
 572                                      WERROR *werror)
 573 {
 574         struct PNP_GetDeviceRegProp r;
 575         NTSTATUS status;
 576
 577         /* In parameters */
 578         r.in.devicepath = devicepath;
 579         r.in.property = property;
 580         r.in.reg_data_type = reg_data_type;
 581         r.in.buffer_size = buffer_size;
 582         r.in.needed = needed;
 583         r.in.flags = flags;
 584
 585         if (DEBUGLEVEL >= 10) {
 586                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceRegProp, &r);
 587         }
 588
 589         status = cli_do_rpc_ndr(cli,
 590                                 mem_ctx,
 591                                 &ndr_table_ntsvcs,
 592                                 NDR_PNP_GETDEVICEREGPROP,
 593                                 &r);
 594
 595         if (!NT_STATUS_IS_OK(status)) {
 596                 return status;
 597         }
 598
 599         if (DEBUGLEVEL >= 10) {
 600                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceRegProp, &r);
 601         }
 602
 603         if (NT_STATUS_IS_ERR(status)) {
 604                 return status;
 605         }
 606
 607         /* Return variables */
 608         *reg_data_type = *r.out.reg_data_type;
 609         memcpy(buffer, r.out.buffer, *r.in.buffer_size * sizeof(*buffer));
 610         *buffer_size = *r.out.buffer_size;
 611         *needed = *r.out.needed;
 612
 613         /* Return result */
 614         if (werror) {
 615                 *werror = r.out.result;
 616         }
 617
 618         return werror_to_ntstatus(r.out.result);
 619 }
 620
 621 NTSTATUS rpccli_PNP_SetDeviceRegProp(struct rpc_pipe_client *cli,
 622                                      TALLOC_CTX *mem_ctx,
 623                                      WERROR *werror)
 624 {
 625         struct PNP_SetDeviceRegProp r;
 626         NTSTATUS status;
 627
 628         /* In parameters */
 629
 630         if (DEBUGLEVEL >= 10) {
 631                 NDR_PRINT_IN_DEBUG(PNP_SetDeviceRegProp, &r);
 632         }
 633
 634         status = cli_do_rpc_ndr(cli,
 635                                 mem_ctx,
 636                                 &ndr_table_ntsvcs,
 637                                 NDR_PNP_SETDEVICEREGPROP,
 638                                 &r);
 639
 640         if (!NT_STATUS_IS_OK(status)) {
 641                 return status;
 642         }
 643
 644         if (DEBUGLEVEL >= 10) {
 645                 NDR_PRINT_OUT_DEBUG(PNP_SetDeviceRegProp, &r);
 646         }
 647
 648         if (NT_STATUS_IS_ERR(status)) {
 649                 return status;
 650         }
 651
 652         /* Return variables */
 653
 654         /* Return result */
 655         if (werror) {
 656                 *werror = r.out.result;
 657         }
 658
 659         return werror_to_ntstatus(r.out.result);
 660 }
 661
 662 NTSTATUS rpccli_PNP_GetClassInstance(struct rpc_pipe_client *cli,
 663                                      TALLOC_CTX *mem_ctx,
 664                                      WERROR *werror)
 665 {
 666         struct PNP_GetClassInstance r;
 667         NTSTATUS status;
 668
 669         /* In parameters */
 670
 671         if (DEBUGLEVEL >= 10) {
 672                 NDR_PRINT_IN_DEBUG(PNP_GetClassInstance, &r);
 673         }
 674
 675         status = cli_do_rpc_ndr(cli,
 676                                 mem_ctx,
 677                                 &ndr_table_ntsvcs,
 678                                 NDR_PNP_GETCLASSINSTANCE,
 679                                 &r);
 680
 681         if (!NT_STATUS_IS_OK(status)) {
 682                 return status;
 683         }
 684
 685         if (DEBUGLEVEL >= 10) {
 686                 NDR_PRINT_OUT_DEBUG(PNP_GetClassInstance, &r);
 687         }
 688
 689         if (NT_STATUS_IS_ERR(status)) {
 690                 return status;
 691         }
 692
 693         /* Return variables */
 694
 695         /* Return result */
 696         if (werror) {
 697                 *werror = r.out.result;
 698         }
 699
 700         return werror_to_ntstatus(r.out.result);
 701 }
 702
 703 NTSTATUS rpccli_PNP_CreateKey(struct rpc_pipe_client *cli,
 704                               TALLOC_CTX *mem_ctx,
 705                               WERROR *werror)
 706 {
 707         struct PNP_CreateKey r;
 708         NTSTATUS status;
 709
 710         /* In parameters */
 711
 712         if (DEBUGLEVEL >= 10) {
 713                 NDR_PRINT_IN_DEBUG(PNP_CreateKey, &r);
 714         }
 715
 716         status = cli_do_rpc_ndr(cli,
 717                                 mem_ctx,
 718                                 &ndr_table_ntsvcs,
 719                                 NDR_PNP_CREATEKEY,
 720                                 &r);
 721
 722         if (!NT_STATUS_IS_OK(status)) {
 723                 return status;
 724         }
 725
 726         if (DEBUGLEVEL >= 10) {
 727                 NDR_PRINT_OUT_DEBUG(PNP_CreateKey, &r);
 728         }
 729
 730         if (NT_STATUS_IS_ERR(status)) {
 731                 return status;
 732         }
 733
 734         /* Return variables */
 735
 736         /* Return result */
 737         if (werror) {
 738                 *werror = r.out.result;
 739         }
 740
 741         return werror_to_ntstatus(r.out.result);
 742 }
 743
 744 NTSTATUS rpccli_PNP_DeleteRegistryKey(struct rpc_pipe_client *cli,
 745                                       TALLOC_CTX *mem_ctx,
 746                                       WERROR *werror)
 747 {
 748         struct PNP_DeleteRegistryKey r;
 749         NTSTATUS status;
 750
 751         /* In parameters */
 752
 753         if (DEBUGLEVEL >= 10) {
 754                 NDR_PRINT_IN_DEBUG(PNP_DeleteRegistryKey, &r);
 755         }
 756
 757         status = cli_do_rpc_ndr(cli,
 758                                 mem_ctx,
 759                                 &ndr_table_ntsvcs,
 760                                 NDR_PNP_DELETEREGISTRYKEY,
 761                                 &r);
 762
 763         if (!NT_STATUS_IS_OK(status)) {
 764                 return status;
 765         }
 766
 767         if (DEBUGLEVEL >= 10) {
 768                 NDR_PRINT_OUT_DEBUG(PNP_DeleteRegistryKey, &r);
 769         }
 770
 771         if (NT_STATUS_IS_ERR(status)) {
 772                 return status;
 773         }
 774
 775         /* Return variables */
 776
 777         /* Return result */
 778         if (werror) {
 779                 *werror = r.out.result;
 780         }
 781
 782         return werror_to_ntstatus(r.out.result);
 783 }
 784
 785 NTSTATUS rpccli_PNP_GetClassCount(struct rpc_pipe_client *cli,
 786                                   TALLOC_CTX *mem_ctx,
 787                                   WERROR *werror)
 788 {
 789         struct PNP_GetClassCount r;
 790         NTSTATUS status;
 791
 792         /* In parameters */
 793
 794         if (DEBUGLEVEL >= 10) {
 795                 NDR_PRINT_IN_DEBUG(PNP_GetClassCount, &r);
 796         }
 797
 798         status = cli_do_rpc_ndr(cli,
 799                                 mem_ctx,
 800                                 &ndr_table_ntsvcs,
 801                                 NDR_PNP_GETCLASSCOUNT,
 802                                 &r);
 803
 804         if (!NT_STATUS_IS_OK(status)) {
 805                 return status;
 806         }
 807
 808         if (DEBUGLEVEL >= 10) {
 809                 NDR_PRINT_OUT_DEBUG(PNP_GetClassCount, &r);
 810         }
 811
 812         if (NT_STATUS_IS_ERR(status)) {
 813                 return status;
 814         }
 815
 816         /* Return variables */
 817
 818         /* Return result */
 819         if (werror) {
 820                 *werror = r.out.result;
 821         }
 822
 823         return werror_to_ntstatus(r.out.result);
 824 }
 825
 826 NTSTATUS rpccli_PNP_GetClassName(struct rpc_pipe_client *cli,
 827                                  TALLOC_CTX *mem_ctx,
 828                                  WERROR *werror)
 829 {
 830         struct PNP_GetClassName r;
 831         NTSTATUS status;
 832
 833         /* In parameters */
 834
 835         if (DEBUGLEVEL >= 10) {
 836                 NDR_PRINT_IN_DEBUG(PNP_GetClassName, &r);
 837         }
 838
 839         status = cli_do_rpc_ndr(cli,
 840                                 mem_ctx,
 841                                 &ndr_table_ntsvcs,
 842                                 NDR_PNP_GETCLASSNAME,
 843                                 &r);
 844
 845         if (!NT_STATUS_IS_OK(status)) {
 846                 return status;
 847         }
 848
 849         if (DEBUGLEVEL >= 10) {
 850                 NDR_PRINT_OUT_DEBUG(PNP_GetClassName, &r);
 851         }
 852
 853         if (NT_STATUS_IS_ERR(status)) {
 854                 return status;
 855         }
 856
 857         /* Return variables */
 858
 859         /* Return result */
 860         if (werror) {
 861                 *werror = r.out.result;
 862         }
 863
 864         return werror_to_ntstatus(r.out.result);
 865 }
 866
 867 NTSTATUS rpccli_PNP_DeleteClassKey(struct rpc_pipe_client *cli,
 868                                    TALLOC_CTX *mem_ctx,
 869                                    WERROR *werror)
 870 {
 871         struct PNP_DeleteClassKey r;
 872         NTSTATUS status;
 873
 874         /* In parameters */
 875
 876         if (DEBUGLEVEL >= 10) {
 877                 NDR_PRINT_IN_DEBUG(PNP_DeleteClassKey, &r);
 878         }
 879
 880         status = cli_do_rpc_ndr(cli,
 881                                 mem_ctx,
 882                                 &ndr_table_ntsvcs,
 883                                 NDR_PNP_DELETECLASSKEY,
 884                                 &r);
 885
 886         if (!NT_STATUS_IS_OK(status)) {
 887                 return status;
 888         }
 889
 890         if (DEBUGLEVEL >= 10) {
 891                 NDR_PRINT_OUT_DEBUG(PNP_DeleteClassKey, &r);
 892         }
 893
 894         if (NT_STATUS_IS_ERR(status)) {
 895                 return status;
 896         }
 897
 898         /* Return variables */
 899
 900         /* Return result */
 901         if (werror) {
 902                 *werror = r.out.result;
 903         }
 904
 905         return werror_to_ntstatus(r.out.result);
 906 }
 907
 908 NTSTATUS rpccli_PNP_GetInterfaceDeviceAlias(struct rpc_pipe_client *cli,
 909                                             TALLOC_CTX *mem_ctx,
 910                                             WERROR *werror)
 911 {
 912         struct PNP_GetInterfaceDeviceAlias r;
 913         NTSTATUS status;
 914
 915         /* In parameters */
 916
 917         if (DEBUGLEVEL >= 10) {
 918                 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceAlias, &r);
 919         }
 920
 921         status = cli_do_rpc_ndr(cli,
 922                                 mem_ctx,
 923                                 &ndr_table_ntsvcs,
 924                                 NDR_PNP_GETINTERFACEDEVICEALIAS,
 925                                 &r);
 926
 927         if (!NT_STATUS_IS_OK(status)) {
 928                 return status;
 929         }
 930
 931         if (DEBUGLEVEL >= 10) {
 932                 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceAlias, &r);
 933         }
 934
 935         if (NT_STATUS_IS_ERR(status)) {
 936                 return status;
 937         }
 938
 939         /* Return variables */
 940
 941         /* Return result */
 942         if (werror) {
 943                 *werror = r.out.result;
 944         }
 945
 946         return werror_to_ntstatus(r.out.result);
 947 }
 948
 949 NTSTATUS rpccli_PNP_GetInterfaceDeviceList(struct rpc_pipe_client *cli,
 950                                            TALLOC_CTX *mem_ctx,
 951                                            WERROR *werror)
 952 {
 953         struct PNP_GetInterfaceDeviceList r;
 954         NTSTATUS status;
 955
 956         /* In parameters */
 957
 958         if (DEBUGLEVEL >= 10) {
 959                 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceList, &r);
 960         }
 961
 962         status = cli_do_rpc_ndr(cli,
 963                                 mem_ctx,
 964                                 &ndr_table_ntsvcs,
 965                                 NDR_PNP_GETINTERFACEDEVICELIST,
 966                                 &r);
 967
 968         if (!NT_STATUS_IS_OK(status)) {
 969                 return status;
 970         }
 971
 972         if (DEBUGLEVEL >= 10) {
 973                 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceList, &r);
 974         }
 975
 976         if (NT_STATUS_IS_ERR(status)) {
 977                 return status;
 978         }
 979
 980         /* Return variables */
 981
 982         /* Return result */
 983         if (werror) {
 984                 *werror = r.out.result;
 985         }
 986
 987         return werror_to_ntstatus(r.out.result);
 988 }
 989
 990 NTSTATUS rpccli_PNP_GetInterfaceDeviceListSize(struct rpc_pipe_client *cli,
 991                                                TALLOC_CTX *mem_ctx,
 992                                                WERROR *werror)
 993 {
 994         struct PNP_GetInterfaceDeviceListSize r;
 995         NTSTATUS status;
 996
 997         /* In parameters */
 998
 999         if (DEBUGLEVEL >= 10) {
1000                 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceListSize, &r);
1001         }
1002
1003         status = cli_do_rpc_ndr(cli,
1004                                 mem_ctx,
1005                                 &ndr_table_ntsvcs,
1006                                 NDR_PNP_GETINTERFACEDEVICELISTSIZE,
1007                                 &r);
1008
1009         if (!NT_STATUS_IS_OK(status)) {
1010                 return status;
1011         }
1012
1013         if (DEBUGLEVEL >= 10) {
1014                 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceListSize, &r);
1015         }
1016
1017         if (NT_STATUS_IS_ERR(status)) {
1018                 return status;
1019         }
1020
1021         /* Return variables */
1022
1023         /* Return result */
1024         if (werror) {
1025                 *werror = r.out.result;
1026         }
1027
1028         return werror_to_ntstatus(r.out.result);
1029 }
1030
1031 NTSTATUS rpccli_PNP_RegisterDeviceClassAssociation(struct rpc_pipe_client *cli,
1032                                                    TALLOC_CTX *mem_ctx,
1033                                                    WERROR *werror)
1034 {
1035         struct PNP_RegisterDeviceClassAssociation r;
1036         NTSTATUS status;
1037
1038         /* In parameters */
1039
1040         if (DEBUGLEVEL >= 10) {
1041                 NDR_PRINT_IN_DEBUG(PNP_RegisterDeviceClassAssociation, &r);
1042         }
1043
1044         status = cli_do_rpc_ndr(cli,
1045                                 mem_ctx,
1046                                 &ndr_table_ntsvcs,
1047                                 NDR_PNP_REGISTERDEVICECLASSASSOCIATION,
1048                                 &r);
1049
1050         if (!NT_STATUS_IS_OK(status)) {
1051                 return status;
1052         }
1053
1054         if (DEBUGLEVEL >= 10) {
1055                 NDR_PRINT_OUT_DEBUG(PNP_RegisterDeviceClassAssociation, &r);
1056         }
1057
1058         if (NT_STATUS_IS_ERR(status)) {
1059                 return status;
1060         }
1061
1062         /* Return variables */
1063
1064         /* Return result */
1065         if (werror) {
1066                 *werror = r.out.result;
1067         }
1068
1069         return werror_to_ntstatus(r.out.result);
1070 }
1071
1072 NTSTATUS rpccli_PNP_UnregisterDeviceClassAssociation(struct rpc_pipe_client *cli,
1073                                                      TALLOC_CTX *mem_ctx,
1074                                                      WERROR *werror)
1075 {
1076         struct PNP_UnregisterDeviceClassAssociation r;
1077         NTSTATUS status;
1078
1079         /* In parameters */
1080
1081         if (DEBUGLEVEL >= 10) {
1082                 NDR_PRINT_IN_DEBUG(PNP_UnregisterDeviceClassAssociation, &r);
1083         }
1084
1085         status = cli_do_rpc_ndr(cli,
1086                                 mem_ctx,
1087                                 &ndr_table_ntsvcs,
1088                                 NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION,
1089                                 &r);
1090
1091         if (!NT_STATUS_IS_OK(status)) {
1092                 return status;
1093         }
1094
1095         if (DEBUGLEVEL >= 10) {
1096                 NDR_PRINT_OUT_DEBUG(PNP_UnregisterDeviceClassAssociation, &r);
1097         }
1098
1099         if (NT_STATUS_IS_ERR(status)) {
1100                 return status;
1101         }
1102
1103         /* Return variables */
1104
1105         /* Return result */
1106         if (werror) {
1107                 *werror = r.out.result;
1108         }
1109
1110         return werror_to_ntstatus(r.out.result);
1111 }
1112
1113 NTSTATUS rpccli_PNP_GetClassRegProp(struct rpc_pipe_client *cli,
1114                                     TALLOC_CTX *mem_ctx,
1115                                     WERROR *werror)
1116 {
1117         struct PNP_GetClassRegProp r;
1118         NTSTATUS status;
1119
1120         /* In parameters */
1121
1122         if (DEBUGLEVEL >= 10) {
1123                 NDR_PRINT_IN_DEBUG(PNP_GetClassRegProp, &r);
1124         }
1125
1126         status = cli_do_rpc_ndr(cli,
1127                                 mem_ctx,
1128                                 &ndr_table_ntsvcs,
1129                                 NDR_PNP_GETCLASSREGPROP,
1130                                 &r);
1131
1132         if (!NT_STATUS_IS_OK(status)) {
1133                 return status;
1134         }
1135
1136         if (DEBUGLEVEL >= 10) {
1137                 NDR_PRINT_OUT_DEBUG(PNP_GetClassRegProp, &r);
1138         }
1139
1140         if (NT_STATUS_IS_ERR(status)) {
1141                 return status;
1142         }
1143
1144         /* Return variables */
1145
1146         /* Return result */
1147         if (werror) {
1148                 *werror = r.out.result;
1149         }
1150
1151         return werror_to_ntstatus(r.out.result);
1152 }
1153
1154 NTSTATUS rpccli_PNP_SetClassRegProp(struct rpc_pipe_client *cli,
1155                                     TALLOC_CTX *mem_ctx,
1156                                     WERROR *werror)
1157 {
1158         struct PNP_SetClassRegProp r;
1159         NTSTATUS status;
1160
1161         /* In parameters */
1162
1163         if (DEBUGLEVEL >= 10) {
1164                 NDR_PRINT_IN_DEBUG(PNP_SetClassRegProp, &r);
1165         }
1166
1167         status = cli_do_rpc_ndr(cli,
1168                                 mem_ctx,
1169                                 &ndr_table_ntsvcs,
1170                                 NDR_PNP_SETCLASSREGPROP,
1171                                 &r);
1172
1173         if (!NT_STATUS_IS_OK(status)) {
1174                 return status;
1175         }
1176
1177         if (DEBUGLEVEL >= 10) {
1178                 NDR_PRINT_OUT_DEBUG(PNP_SetClassRegProp, &r);
1179         }
1180
1181         if (NT_STATUS_IS_ERR(status)) {
1182                 return status;
1183         }
1184
1185         /* Return variables */
1186
1187         /* Return result */
1188         if (werror) {
1189                 *werror = r.out.result;
1190         }
1191
1192         return werror_to_ntstatus(r.out.result);
1193 }
1194
1195 NTSTATUS rpccli_PNP_CreateDevInst(struct rpc_pipe_client *cli,
1196                                   TALLOC_CTX *mem_ctx,
1197                                   WERROR *werror)
1198 {
1199         struct PNP_CreateDevInst r;
1200         NTSTATUS status;
1201
1202         /* In parameters */
1203
1204         if (DEBUGLEVEL >= 10) {
1205                 NDR_PRINT_IN_DEBUG(PNP_CreateDevInst, &r);
1206         }
1207
1208         status = cli_do_rpc_ndr(cli,
1209                                 mem_ctx,
1210                                 &ndr_table_ntsvcs,
1211                                 NDR_PNP_CREATEDEVINST,
1212                                 &r);
1213
1214         if (!NT_STATUS_IS_OK(status)) {
1215                 return status;
1216         }
1217
1218         if (DEBUGLEVEL >= 10) {
1219                 NDR_PRINT_OUT_DEBUG(PNP_CreateDevInst, &r);
1220         }
1221
1222         if (NT_STATUS_IS_ERR(status)) {
1223                 return status;
1224         }
1225
1226         /* Return variables */
1227
1228         /* Return result */
1229         if (werror) {
1230                 *werror = r.out.result;
1231         }
1232
1233         return werror_to_ntstatus(r.out.result);
1234 }
1235
1236 NTSTATUS rpccli_PNP_DeviceInstanceAction(struct rpc_pipe_client *cli,
1237                                          TALLOC_CTX *mem_ctx,
1238                                          WERROR *werror)
1239 {
1240         struct PNP_DeviceInstanceAction r;
1241         NTSTATUS status;
1242
1243         /* In parameters */
1244
1245         if (DEBUGLEVEL >= 10) {
1246                 NDR_PRINT_IN_DEBUG(PNP_DeviceInstanceAction, &r);
1247         }
1248
1249         status = cli_do_rpc_ndr(cli,
1250                                 mem_ctx,
1251                                 &ndr_table_ntsvcs,
1252                                 NDR_PNP_DEVICEINSTANCEACTION,
1253                                 &r);
1254
1255         if (!NT_STATUS_IS_OK(status)) {
1256                 return status;
1257         }
1258
1259         if (DEBUGLEVEL >= 10) {
1260                 NDR_PRINT_OUT_DEBUG(PNP_DeviceInstanceAction, &r);
1261         }
1262
1263         if (NT_STATUS_IS_ERR(status)) {
1264                 return status;
1265         }
1266
1267         /* Return variables */
1268
1269         /* Return result */
1270         if (werror) {
1271                 *werror = r.out.result;
1272         }
1273
1274         return werror_to_ntstatus(r.out.result);
1275 }
1276
1277 NTSTATUS rpccli_PNP_GetDeviceStatus(struct rpc_pipe_client *cli,
1278                                     TALLOC_CTX *mem_ctx,
1279                                     WERROR *werror)
1280 {
1281         struct PNP_GetDeviceStatus r;
1282         NTSTATUS status;
1283
1284         /* In parameters */
1285
1286         if (DEBUGLEVEL >= 10) {
1287                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceStatus, &r);
1288         }
1289
1290         status = cli_do_rpc_ndr(cli,
1291                                 mem_ctx,
1292                                 &ndr_table_ntsvcs,
1293                                 NDR_PNP_GETDEVICESTATUS,
1294                                 &r);
1295
1296         if (!NT_STATUS_IS_OK(status)) {
1297                 return status;
1298         }
1299
1300         if (DEBUGLEVEL >= 10) {
1301                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceStatus, &r);
1302         }
1303
1304         if (NT_STATUS_IS_ERR(status)) {
1305                 return status;
1306         }
1307
1308         /* Return variables */
1309
1310         /* Return result */
1311         if (werror) {
1312                 *werror = r.out.result;
1313         }
1314
1315         return werror_to_ntstatus(r.out.result);
1316 }
1317
1318 NTSTATUS rpccli_PNP_SetDeviceProblem(struct rpc_pipe_client *cli,
1319                                      TALLOC_CTX *mem_ctx,
1320                                      WERROR *werror)
1321 {
1322         struct PNP_SetDeviceProblem r;
1323         NTSTATUS status;
1324
1325         /* In parameters */
1326
1327         if (DEBUGLEVEL >= 10) {
1328                 NDR_PRINT_IN_DEBUG(PNP_SetDeviceProblem, &r);
1329         }
1330
1331         status = cli_do_rpc_ndr(cli,
1332                                 mem_ctx,
1333                                 &ndr_table_ntsvcs,
1334                                 NDR_PNP_SETDEVICEPROBLEM,
1335                                 &r);
1336
1337         if (!NT_STATUS_IS_OK(status)) {
1338                 return status;
1339         }
1340
1341         if (DEBUGLEVEL >= 10) {
1342                 NDR_PRINT_OUT_DEBUG(PNP_SetDeviceProblem, &r);
1343         }
1344
1345         if (NT_STATUS_IS_ERR(status)) {
1346                 return status;
1347         }
1348
1349         /* Return variables */
1350
1351         /* Return result */
1352         if (werror) {
1353                 *werror = r.out.result;
1354         }
1355
1356         return werror_to_ntstatus(r.out.result);
1357 }
1358
1359 NTSTATUS rpccli_PNP_DisableDevInst(struct rpc_pipe_client *cli,
1360                                    TALLOC_CTX *mem_ctx,
1361                                    WERROR *werror)
1362 {
1363         struct PNP_DisableDevInst r;
1364         NTSTATUS status;
1365
1366         /* In parameters */
1367
1368         if (DEBUGLEVEL >= 10) {
1369                 NDR_PRINT_IN_DEBUG(PNP_DisableDevInst, &r);
1370         }
1371
1372         status = cli_do_rpc_ndr(cli,
1373                                 mem_ctx,
1374                                 &ndr_table_ntsvcs,
1375                                 NDR_PNP_DISABLEDEVINST,
1376                                 &r);
1377
1378         if (!NT_STATUS_IS_OK(status)) {
1379                 return status;
1380         }
1381
1382         if (DEBUGLEVEL >= 10) {
1383                 NDR_PRINT_OUT_DEBUG(PNP_DisableDevInst, &r);
1384         }
1385
1386         if (NT_STATUS_IS_ERR(status)) {
1387                 return status;
1388         }
1389
1390         /* Return variables */
1391
1392         /* Return result */
1393         if (werror) {
1394                 *werror = r.out.result;
1395         }
1396
1397         return werror_to_ntstatus(r.out.result);
1398 }
1399
1400 NTSTATUS rpccli_PNP_UninstallDevInst(struct rpc_pipe_client *cli,
1401                                      TALLOC_CTX *mem_ctx,
1402                                      WERROR *werror)
1403 {
1404         struct PNP_UninstallDevInst r;
1405         NTSTATUS status;
1406
1407         /* In parameters */
1408
1409         if (DEBUGLEVEL >= 10) {
1410                 NDR_PRINT_IN_DEBUG(PNP_UninstallDevInst, &r);
1411         }
1412
1413         status = cli_do_rpc_ndr(cli,
1414                                 mem_ctx,
1415                                 &ndr_table_ntsvcs,
1416                                 NDR_PNP_UNINSTALLDEVINST,
1417                                 &r);
1418
1419         if (!NT_STATUS_IS_OK(status)) {
1420                 return status;
1421         }
1422
1423         if (DEBUGLEVEL >= 10) {
1424                 NDR_PRINT_OUT_DEBUG(PNP_UninstallDevInst, &r);
1425         }
1426
1427         if (NT_STATUS_IS_ERR(status)) {
1428                 return status;
1429         }
1430
1431         /* Return variables */
1432
1433         /* Return result */
1434         if (werror) {
1435                 *werror = r.out.result;
1436         }
1437
1438         return werror_to_ntstatus(r.out.result);
1439 }
1440
1441 NTSTATUS rpccli_PNP_AddID(struct rpc_pipe_client *cli,
1442                           TALLOC_CTX *mem_ctx,
1443                           WERROR *werror)
1444 {
1445         struct PNP_AddID r;
1446         NTSTATUS status;
1447
1448         /* In parameters */
1449
1450         if (DEBUGLEVEL >= 10) {
1451                 NDR_PRINT_IN_DEBUG(PNP_AddID, &r);
1452         }
1453
1454         status = cli_do_rpc_ndr(cli,
1455                                 mem_ctx,
1456                                 &ndr_table_ntsvcs,
1457                                 NDR_PNP_ADDID,
1458                                 &r);
1459
1460         if (!NT_STATUS_IS_OK(status)) {
1461                 return status;
1462         }
1463
1464         if (DEBUGLEVEL >= 10) {
1465                 NDR_PRINT_OUT_DEBUG(PNP_AddID, &r);
1466         }
1467
1468         if (NT_STATUS_IS_ERR(status)) {
1469                 return status;
1470         }
1471
1472         /* Return variables */
1473
1474         /* Return result */
1475         if (werror) {
1476                 *werror = r.out.result;
1477         }
1478
1479         return werror_to_ntstatus(r.out.result);
1480 }
1481
1482 NTSTATUS rpccli_PNP_RegisterDriver(struct rpc_pipe_client *cli,
1483                                    TALLOC_CTX *mem_ctx,
1484                                    WERROR *werror)
1485 {
1486         struct PNP_RegisterDriver r;
1487         NTSTATUS status;
1488
1489         /* In parameters */
1490
1491         if (DEBUGLEVEL >= 10) {
1492                 NDR_PRINT_IN_DEBUG(PNP_RegisterDriver, &r);
1493         }
1494
1495         status = cli_do_rpc_ndr(cli,
1496                                 mem_ctx,
1497                                 &ndr_table_ntsvcs,
1498                                 NDR_PNP_REGISTERDRIVER,
1499                                 &r);
1500
1501         if (!NT_STATUS_IS_OK(status)) {
1502                 return status;
1503         }
1504
1505         if (DEBUGLEVEL >= 10) {
1506                 NDR_PRINT_OUT_DEBUG(PNP_RegisterDriver, &r);
1507         }
1508
1509         if (NT_STATUS_IS_ERR(status)) {
1510                 return status;
1511         }
1512
1513         /* Return variables */
1514
1515         /* Return result */
1516         if (werror) {
1517                 *werror = r.out.result;
1518         }
1519
1520         return werror_to_ntstatus(r.out.result);
1521 }
1522
1523 NTSTATUS rpccli_PNP_QueryRemove(struct rpc_pipe_client *cli,
1524                                 TALLOC_CTX *mem_ctx,
1525                                 WERROR *werror)
1526 {
1527         struct PNP_QueryRemove r;
1528         NTSTATUS status;
1529
1530         /* In parameters */
1531
1532         if (DEBUGLEVEL >= 10) {
1533                 NDR_PRINT_IN_DEBUG(PNP_QueryRemove, &r);
1534         }
1535
1536         status = cli_do_rpc_ndr(cli,
1537                                 mem_ctx,
1538                                 &ndr_table_ntsvcs,
1539                                 NDR_PNP_QUERYREMOVE,
1540                                 &r);
1541
1542         if (!NT_STATUS_IS_OK(status)) {
1543                 return status;
1544         }
1545
1546         if (DEBUGLEVEL >= 10) {
1547                 NDR_PRINT_OUT_DEBUG(PNP_QueryRemove, &r);
1548         }
1549
1550         if (NT_STATUS_IS_ERR(status)) {
1551                 return status;
1552         }
1553
1554         /* Return variables */
1555
1556         /* Return result */
1557         if (werror) {
1558                 *werror = r.out.result;
1559         }
1560
1561         return werror_to_ntstatus(r.out.result);
1562 }
1563
1564 NTSTATUS rpccli_PNP_RequestDeviceEject(struct rpc_pipe_client *cli,
1565                                        TALLOC_CTX *mem_ctx,
1566                                        WERROR *werror)
1567 {
1568         struct PNP_RequestDeviceEject r;
1569         NTSTATUS status;
1570
1571         /* In parameters */
1572
1573         if (DEBUGLEVEL >= 10) {
1574                 NDR_PRINT_IN_DEBUG(PNP_RequestDeviceEject, &r);
1575         }
1576
1577         status = cli_do_rpc_ndr(cli,
1578                                 mem_ctx,
1579                                 &ndr_table_ntsvcs,
1580                                 NDR_PNP_REQUESTDEVICEEJECT,
1581                                 &r);
1582
1583         if (!NT_STATUS_IS_OK(status)) {
1584                 return status;
1585         }
1586
1587         if (DEBUGLEVEL >= 10) {
1588                 NDR_PRINT_OUT_DEBUG(PNP_RequestDeviceEject, &r);
1589         }
1590
1591         if (NT_STATUS_IS_ERR(status)) {
1592                 return status;
1593         }
1594
1595         /* Return variables */
1596
1597         /* Return result */
1598         if (werror) {
1599                 *werror = r.out.result;
1600         }
1601
1602         return werror_to_ntstatus(r.out.result);
1603 }
1604
1605 NTSTATUS rpccli_PNP_IsDockStationPresent(struct rpc_pipe_client *cli,
1606                                          TALLOC_CTX *mem_ctx,
1607                                          WERROR *werror)
1608 {
1609         struct PNP_IsDockStationPresent r;
1610         NTSTATUS status;
1611
1612         /* In parameters */
1613
1614         if (DEBUGLEVEL >= 10) {
1615                 NDR_PRINT_IN_DEBUG(PNP_IsDockStationPresent, &r);
1616         }
1617
1618         status = cli_do_rpc_ndr(cli,
1619                                 mem_ctx,
1620                                 &ndr_table_ntsvcs,
1621                                 NDR_PNP_ISDOCKSTATIONPRESENT,
1622                                 &r);
1623
1624         if (!NT_STATUS_IS_OK(status)) {
1625                 return status;
1626         }
1627
1628         if (DEBUGLEVEL >= 10) {
1629                 NDR_PRINT_OUT_DEBUG(PNP_IsDockStationPresent, &r);
1630         }
1631
1632         if (NT_STATUS_IS_ERR(status)) {
1633                 return status;
1634         }
1635
1636         /* Return variables */
1637
1638         /* Return result */
1639         if (werror) {
1640                 *werror = r.out.result;
1641         }
1642
1643         return werror_to_ntstatus(r.out.result);
1644 }
1645
1646 NTSTATUS rpccli_PNP_RequestEjectPC(struct rpc_pipe_client *cli,
1647                                    TALLOC_CTX *mem_ctx,
1648                                    WERROR *werror)
1649 {
1650         struct PNP_RequestEjectPC r;
1651         NTSTATUS status;
1652
1653         /* In parameters */
1654
1655         if (DEBUGLEVEL >= 10) {
1656                 NDR_PRINT_IN_DEBUG(PNP_RequestEjectPC, &r);
1657         }
1658
1659         status = cli_do_rpc_ndr(cli,
1660                                 mem_ctx,
1661                                 &ndr_table_ntsvcs,
1662                                 NDR_PNP_REQUESTEJECTPC,
1663                                 &r);
1664
1665         if (!NT_STATUS_IS_OK(status)) {
1666                 return status;
1667         }
1668
1669         if (DEBUGLEVEL >= 10) {
1670                 NDR_PRINT_OUT_DEBUG(PNP_RequestEjectPC, &r);
1671         }
1672
1673         if (NT_STATUS_IS_ERR(status)) {
1674                 return status;
1675         }
1676
1677         /* Return variables */
1678
1679         /* Return result */
1680         if (werror) {
1681                 *werror = r.out.result;
1682         }
1683
1684         return werror_to_ntstatus(r.out.result);
1685 }
1686
1687 NTSTATUS rpccli_PNP_HwProfFlags(struct rpc_pipe_client *cli,
1688                                 TALLOC_CTX *mem_ctx,
1689                                 uint32_t unknown1 /* [in]  */,
1690                                 const char *devicepath /* [in] [ref,charset(UTF16)] */,
1691                                 uint32_t unknown2 /* [in]  */,
1692                                 uint32_t *unknown3 /* [in,out] [ref] */,
1693                                 uint16_t *unknown4 /* [in,out] [unique] */,
1694                                 const char *unknown5 /* [in] [unique,charset(UTF16)] */,
1695                                 const char **unknown5a /* [out] [unique,charset(UTF16)] */,
1696                                 uint32_t unknown6 /* [in]  */,
1697                                 uint32_t unknown7 /* [in]  */,
1698                                 WERROR *werror)
1699 {
1700         struct PNP_HwProfFlags r;
1701         NTSTATUS status;
1702
1703         /* In parameters */
1704         r.in.unknown1 = unknown1;
1705         r.in.devicepath = devicepath;
1706         r.in.unknown2 = unknown2;
1707         r.in.unknown3 = unknown3;
1708         r.in.unknown4 = unknown4;
1709         r.in.unknown5 = unknown5;
1710         r.in.unknown6 = unknown6;
1711         r.in.unknown7 = unknown7;
1712
1713         if (DEBUGLEVEL >= 10) {
1714                 NDR_PRINT_IN_DEBUG(PNP_HwProfFlags, &r);
1715         }
1716
1717         status = cli_do_rpc_ndr(cli,
1718                                 mem_ctx,
1719                                 &ndr_table_ntsvcs,
1720                                 NDR_PNP_HWPROFFLAGS,
1721                                 &r);
1722
1723         if (!NT_STATUS_IS_OK(status)) {
1724                 return status;
1725         }
1726
1727         if (DEBUGLEVEL >= 10) {
1728                 NDR_PRINT_OUT_DEBUG(PNP_HwProfFlags, &r);
1729         }
1730
1731         if (NT_STATUS_IS_ERR(status)) {
1732                 return status;
1733         }
1734
1735         /* Return variables */
1736         *unknown3 = *r.out.unknown3;
1737         if (unknown4 && r.out.unknown4) {
1738                 *unknown4 = *r.out.unknown4;
1739         }
1740         if (unknown5a && r.out.unknown5a) {
1741                 *unknown5a = *r.out.unknown5a;
1742         }
1743
1744         /* Return result */
1745         if (werror) {
1746                 *werror = r.out.result;
1747         }
1748
1749         return werror_to_ntstatus(r.out.result);
1750 }
1751
1752 NTSTATUS rpccli_PNP_GetHwProfInfo(struct rpc_pipe_client *cli,
1753                                   TALLOC_CTX *mem_ctx,
1754                                   uint32_t idx /* [in]  */,
1755                                   struct PNP_HwProfInfo *info /* [in,out] [ref] */,
1756                                   uint32_t unknown1 /* [in]  */,
1757                                   uint32_t unknown2 /* [in]  */,
1758                                   WERROR *werror)
1759 {
1760         struct PNP_GetHwProfInfo r;
1761         NTSTATUS status;
1762
1763         /* In parameters */
1764         r.in.idx = idx;
1765         r.in.info = info;
1766         r.in.unknown1 = unknown1;
1767         r.in.unknown2 = unknown2;
1768
1769         if (DEBUGLEVEL >= 10) {
1770                 NDR_PRINT_IN_DEBUG(PNP_GetHwProfInfo, &r);
1771         }
1772
1773         status = cli_do_rpc_ndr(cli,
1774                                 mem_ctx,
1775                                 &ndr_table_ntsvcs,
1776                                 NDR_PNP_GETHWPROFINFO,
1777                                 &r);
1778
1779         if (!NT_STATUS_IS_OK(status)) {
1780                 return status;
1781         }
1782
1783         if (DEBUGLEVEL >= 10) {
1784                 NDR_PRINT_OUT_DEBUG(PNP_GetHwProfInfo, &r);
1785         }
1786
1787         if (NT_STATUS_IS_ERR(status)) {
1788                 return status;
1789         }
1790
1791         /* Return variables */
1792         *info = *r.out.info;
1793
1794         /* Return result */
1795         if (werror) {
1796                 *werror = r.out.result;
1797         }
1798
1799         return werror_to_ntstatus(r.out.result);
1800 }
1801
1802 NTSTATUS rpccli_PNP_AddEmptyLogConf(struct rpc_pipe_client *cli,
1803                                     TALLOC_CTX *mem_ctx,
1804                                     WERROR *werror)
1805 {
1806         struct PNP_AddEmptyLogConf r;
1807         NTSTATUS status;
1808
1809         /* In parameters */
1810
1811         if (DEBUGLEVEL >= 10) {
1812                 NDR_PRINT_IN_DEBUG(PNP_AddEmptyLogConf, &r);
1813         }
1814
1815         status = cli_do_rpc_ndr(cli,
1816                                 mem_ctx,
1817                                 &ndr_table_ntsvcs,
1818                                 NDR_PNP_ADDEMPTYLOGCONF,
1819                                 &r);
1820
1821         if (!NT_STATUS_IS_OK(status)) {
1822                 return status;
1823         }
1824
1825         if (DEBUGLEVEL >= 10) {
1826                 NDR_PRINT_OUT_DEBUG(PNP_AddEmptyLogConf, &r);
1827         }
1828
1829         if (NT_STATUS_IS_ERR(status)) {
1830                 return status;
1831         }
1832
1833         /* Return variables */
1834
1835         /* Return result */
1836         if (werror) {
1837                 *werror = r.out.result;
1838         }
1839
1840         return werror_to_ntstatus(r.out.result);
1841 }
1842
1843 NTSTATUS rpccli_PNP_FreeLogConf(struct rpc_pipe_client *cli,
1844                                 TALLOC_CTX *mem_ctx,
1845                                 WERROR *werror)
1846 {
1847         struct PNP_FreeLogConf r;
1848         NTSTATUS status;
1849
1850         /* In parameters */
1851
1852         if (DEBUGLEVEL >= 10) {
1853                 NDR_PRINT_IN_DEBUG(PNP_FreeLogConf, &r);
1854         }
1855
1856         status = cli_do_rpc_ndr(cli,
1857                                 mem_ctx,
1858                                 &ndr_table_ntsvcs,
1859                                 NDR_PNP_FREELOGCONF,
1860                                 &r);
1861
1862         if (!NT_STATUS_IS_OK(status)) {
1863                 return status;
1864         }
1865
1866         if (DEBUGLEVEL >= 10) {
1867                 NDR_PRINT_OUT_DEBUG(PNP_FreeLogConf, &r);
1868         }
1869
1870         if (NT_STATUS_IS_ERR(status)) {
1871                 return status;
1872         }
1873
1874         /* Return variables */
1875
1876         /* Return result */
1877         if (werror) {
1878                 *werror = r.out.result;
1879         }
1880
1881         return werror_to_ntstatus(r.out.result);
1882 }
1883
1884 NTSTATUS rpccli_PNP_GetFirstLogConf(struct rpc_pipe_client *cli,
1885                                     TALLOC_CTX *mem_ctx,
1886                                     WERROR *werror)
1887 {
1888         struct PNP_GetFirstLogConf r;
1889         NTSTATUS status;
1890
1891         /* In parameters */
1892
1893         if (DEBUGLEVEL >= 10) {
1894                 NDR_PRINT_IN_DEBUG(PNP_GetFirstLogConf, &r);
1895         }
1896
1897         status = cli_do_rpc_ndr(cli,
1898                                 mem_ctx,
1899                                 &ndr_table_ntsvcs,
1900                                 NDR_PNP_GETFIRSTLOGCONF,
1901                                 &r);
1902
1903         if (!NT_STATUS_IS_OK(status)) {
1904                 return status;
1905         }
1906
1907         if (DEBUGLEVEL >= 10) {
1908                 NDR_PRINT_OUT_DEBUG(PNP_GetFirstLogConf, &r);
1909         }
1910
1911         if (NT_STATUS_IS_ERR(status)) {
1912                 return status;
1913         }
1914
1915         /* Return variables */
1916
1917         /* Return result */
1918         if (werror) {
1919                 *werror = r.out.result;
1920         }
1921
1922         return werror_to_ntstatus(r.out.result);
1923 }
1924
1925 NTSTATUS rpccli_PNP_GetNextLogConf(struct rpc_pipe_client *cli,
1926                                    TALLOC_CTX *mem_ctx,
1927                                    WERROR *werror)
1928 {
1929         struct PNP_GetNextLogConf r;
1930         NTSTATUS status;
1931
1932         /* In parameters */
1933
1934         if (DEBUGLEVEL >= 10) {
1935                 NDR_PRINT_IN_DEBUG(PNP_GetNextLogConf, &r);
1936         }
1937
1938         status = cli_do_rpc_ndr(cli,
1939                                 mem_ctx,
1940                                 &ndr_table_ntsvcs,
1941                                 NDR_PNP_GETNEXTLOGCONF,
1942                                 &r);
1943
1944         if (!NT_STATUS_IS_OK(status)) {
1945                 return status;
1946         }
1947
1948         if (DEBUGLEVEL >= 10) {
1949                 NDR_PRINT_OUT_DEBUG(PNP_GetNextLogConf, &r);
1950         }
1951
1952         if (NT_STATUS_IS_ERR(status)) {
1953                 return status;
1954         }
1955
1956         /* Return variables */
1957
1958         /* Return result */
1959         if (werror) {
1960                 *werror = r.out.result;
1961         }
1962
1963         return werror_to_ntstatus(r.out.result);
1964 }
1965
1966 NTSTATUS rpccli_PNP_GetLogConfPriority(struct rpc_pipe_client *cli,
1967                                        TALLOC_CTX *mem_ctx,
1968                                        WERROR *werror)
1969 {
1970         struct PNP_GetLogConfPriority r;
1971         NTSTATUS status;
1972
1973         /* In parameters */
1974
1975         if (DEBUGLEVEL >= 10) {
1976                 NDR_PRINT_IN_DEBUG(PNP_GetLogConfPriority, &r);
1977         }
1978
1979         status = cli_do_rpc_ndr(cli,
1980                                 mem_ctx,
1981                                 &ndr_table_ntsvcs,
1982                                 NDR_PNP_GETLOGCONFPRIORITY,
1983                                 &r);
1984
1985         if (!NT_STATUS_IS_OK(status)) {
1986                 return status;
1987         }
1988
1989         if (DEBUGLEVEL >= 10) {
1990                 NDR_PRINT_OUT_DEBUG(PNP_GetLogConfPriority, &r);
1991         }
1992
1993         if (NT_STATUS_IS_ERR(status)) {
1994                 return status;
1995         }
1996
1997         /* Return variables */
1998
1999         /* Return result */
2000         if (werror) {
2001                 *werror = r.out.result;
2002         }
2003
2004         return werror_to_ntstatus(r.out.result);
2005 }
2006
2007 NTSTATUS rpccli_PNP_AddResDes(struct rpc_pipe_client *cli,
2008                               TALLOC_CTX *mem_ctx,
2009                               WERROR *werror)
2010 {
2011         struct PNP_AddResDes r;
2012         NTSTATUS status;
2013
2014         /* In parameters */
2015
2016         if (DEBUGLEVEL >= 10) {
2017                 NDR_PRINT_IN_DEBUG(PNP_AddResDes, &r);
2018         }
2019
2020         status = cli_do_rpc_ndr(cli,
2021                                 mem_ctx,
2022                                 &ndr_table_ntsvcs,
2023                                 NDR_PNP_ADDRESDES,
2024                                 &r);
2025
2026         if (!NT_STATUS_IS_OK(status)) {
2027                 return status;
2028         }
2029
2030         if (DEBUGLEVEL >= 10) {
2031                 NDR_PRINT_OUT_DEBUG(PNP_AddResDes, &r);
2032         }
2033
2034         if (NT_STATUS_IS_ERR(status)) {
2035                 return status;
2036         }
2037
2038         /* Return variables */
2039
2040         /* Return result */
2041         if (werror) {
2042                 *werror = r.out.result;
2043         }
2044
2045         return werror_to_ntstatus(r.out.result);
2046 }
2047
2048 NTSTATUS rpccli_PNP_FreeResDes(struct rpc_pipe_client *cli,
2049                                TALLOC_CTX *mem_ctx,
2050                                WERROR *werror)
2051 {
2052         struct PNP_FreeResDes r;
2053         NTSTATUS status;
2054
2055         /* In parameters */
2056
2057         if (DEBUGLEVEL >= 10) {
2058                 NDR_PRINT_IN_DEBUG(PNP_FreeResDes, &r);
2059         }
2060
2061         status = cli_do_rpc_ndr(cli,
2062                                 mem_ctx,
2063                                 &ndr_table_ntsvcs,
2064                                 NDR_PNP_FREERESDES,
2065                                 &r);
2066
2067         if (!NT_STATUS_IS_OK(status)) {
2068                 return status;
2069         }
2070
2071         if (DEBUGLEVEL >= 10) {
2072                 NDR_PRINT_OUT_DEBUG(PNP_FreeResDes, &r);
2073         }
2074
2075         if (NT_STATUS_IS_ERR(status)) {
2076                 return status;
2077         }
2078
2079         /* Return variables */
2080
2081         /* Return result */
2082         if (werror) {
2083                 *werror = r.out.result;
2084         }
2085
2086         return werror_to_ntstatus(r.out.result);
2087 }
2088
2089 NTSTATUS rpccli_PNP_GetNextResDes(struct rpc_pipe_client *cli,
2090                                   TALLOC_CTX *mem_ctx,
2091                                   WERROR *werror)
2092 {
2093         struct PNP_GetNextResDes r;
2094         NTSTATUS status;
2095
2096         /* In parameters */
2097
2098         if (DEBUGLEVEL >= 10) {
2099                 NDR_PRINT_IN_DEBUG(PNP_GetNextResDes, &r);
2100         }
2101
2102         status = cli_do_rpc_ndr(cli,
2103                                 mem_ctx,
2104                                 &ndr_table_ntsvcs,
2105                                 NDR_PNP_GETNEXTRESDES,
2106                                 &r);
2107
2108         if (!NT_STATUS_IS_OK(status)) {
2109                 return status;
2110         }
2111
2112         if (DEBUGLEVEL >= 10) {
2113                 NDR_PRINT_OUT_DEBUG(PNP_GetNextResDes, &r);
2114         }
2115
2116         if (NT_STATUS_IS_ERR(status)) {
2117                 return status;
2118         }
2119
2120         /* Return variables */
2121
2122         /* Return result */
2123         if (werror) {
2124                 *werror = r.out.result;
2125         }
2126
2127         return werror_to_ntstatus(r.out.result);
2128 }
2129
2130 NTSTATUS rpccli_PNP_GetResDesData(struct rpc_pipe_client *cli,
2131                                   TALLOC_CTX *mem_ctx,
2132                                   WERROR *werror)
2133 {
2134         struct PNP_GetResDesData r;
2135         NTSTATUS status;
2136
2137         /* In parameters */
2138
2139         if (DEBUGLEVEL >= 10) {
2140                 NDR_PRINT_IN_DEBUG(PNP_GetResDesData, &r);
2141         }
2142
2143         status = cli_do_rpc_ndr(cli,
2144                                 mem_ctx,
2145                                 &ndr_table_ntsvcs,
2146                                 NDR_PNP_GETRESDESDATA,
2147                                 &r);
2148
2149         if (!NT_STATUS_IS_OK(status)) {
2150                 return status;
2151         }
2152
2153         if (DEBUGLEVEL >= 10) {
2154                 NDR_PRINT_OUT_DEBUG(PNP_GetResDesData, &r);
2155         }
2156
2157         if (NT_STATUS_IS_ERR(status)) {
2158                 return status;
2159         }
2160
2161         /* Return variables */
2162
2163         /* Return result */
2164         if (werror) {
2165                 *werror = r.out.result;
2166         }
2167
2168         return werror_to_ntstatus(r.out.result);
2169 }
2170
2171 NTSTATUS rpccli_PNP_GetResDesDataSize(struct rpc_pipe_client *cli,
2172                                       TALLOC_CTX *mem_ctx,
2173                                       WERROR *werror)
2174 {
2175         struct PNP_GetResDesDataSize r;
2176         NTSTATUS status;
2177
2178         /* In parameters */
2179
2180         if (DEBUGLEVEL >= 10) {
2181                 NDR_PRINT_IN_DEBUG(PNP_GetResDesDataSize, &r);
2182         }
2183
2184         status = cli_do_rpc_ndr(cli,
2185                                 mem_ctx,
2186                                 &ndr_table_ntsvcs,
2187                                 NDR_PNP_GETRESDESDATASIZE,
2188                                 &r);
2189
2190         if (!NT_STATUS_IS_OK(status)) {
2191                 return status;
2192         }
2193
2194         if (DEBUGLEVEL >= 10) {
2195                 NDR_PRINT_OUT_DEBUG(PNP_GetResDesDataSize, &r);
2196         }
2197
2198         if (NT_STATUS_IS_ERR(status)) {
2199                 return status;
2200         }
2201
2202         /* Return variables */
2203
2204         /* Return result */
2205         if (werror) {
2206                 *werror = r.out.result;
2207         }
2208
2209         return werror_to_ntstatus(r.out.result);
2210 }
2211
2212 NTSTATUS rpccli_PNP_ModifyResDes(struct rpc_pipe_client *cli,
2213                                  TALLOC_CTX *mem_ctx,
2214                                  WERROR *werror)
2215 {
2216         struct PNP_ModifyResDes r;
2217         NTSTATUS status;
2218
2219         /* In parameters */
2220
2221         if (DEBUGLEVEL >= 10) {
2222                 NDR_PRINT_IN_DEBUG(PNP_ModifyResDes, &r);
2223         }
2224
2225         status = cli_do_rpc_ndr(cli,
2226                                 mem_ctx,
2227                                 &ndr_table_ntsvcs,
2228                                 NDR_PNP_MODIFYRESDES,
2229                                 &r);
2230
2231         if (!NT_STATUS_IS_OK(status)) {
2232                 return status;
2233         }
2234
2235         if (DEBUGLEVEL >= 10) {
2236                 NDR_PRINT_OUT_DEBUG(PNP_ModifyResDes, &r);
2237         }
2238
2239         if (NT_STATUS_IS_ERR(status)) {
2240                 return status;
2241         }
2242
2243         /* Return variables */
2244
2245         /* Return result */
2246         if (werror) {
2247                 *werror = r.out.result;
2248         }
2249
2250         return werror_to_ntstatus(r.out.result);
2251 }
2252
2253 NTSTATUS rpccli_PNP_DetectResourceLimit(struct rpc_pipe_client *cli,
2254                                         TALLOC_CTX *mem_ctx,
2255                                         WERROR *werror)
2256 {
2257         struct PNP_DetectResourceLimit r;
2258         NTSTATUS status;
2259
2260         /* In parameters */
2261
2262         if (DEBUGLEVEL >= 10) {
2263                 NDR_PRINT_IN_DEBUG(PNP_DetectResourceLimit, &r);
2264         }
2265
2266         status = cli_do_rpc_ndr(cli,
2267                                 mem_ctx,
2268                                 &ndr_table_ntsvcs,
2269                                 NDR_PNP_DETECTRESOURCELIMIT,
2270                                 &r);
2271
2272         if (!NT_STATUS_IS_OK(status)) {
2273                 return status;
2274         }
2275
2276         if (DEBUGLEVEL >= 10) {
2277                 NDR_PRINT_OUT_DEBUG(PNP_DetectResourceLimit, &r);
2278         }
2279
2280         if (NT_STATUS_IS_ERR(status)) {
2281                 return status;
2282         }
2283
2284         /* Return variables */
2285
2286         /* Return result */
2287         if (werror) {
2288                 *werror = r.out.result;
2289         }
2290
2291         return werror_to_ntstatus(r.out.result);
2292 }
2293
2294 NTSTATUS rpccli_PNP_QueryResConfList(struct rpc_pipe_client *cli,
2295                                      TALLOC_CTX *mem_ctx,
2296                                      WERROR *werror)
2297 {
2298         struct PNP_QueryResConfList r;
2299         NTSTATUS status;
2300
2301         /* In parameters */
2302
2303         if (DEBUGLEVEL >= 10) {
2304                 NDR_PRINT_IN_DEBUG(PNP_QueryResConfList, &r);
2305         }
2306
2307         status = cli_do_rpc_ndr(cli,
2308                                 mem_ctx,
2309                                 &ndr_table_ntsvcs,
2310                                 NDR_PNP_QUERYRESCONFLIST,
2311                                 &r);
2312
2313         if (!NT_STATUS_IS_OK(status)) {
2314                 return status;
2315         }
2316
2317         if (DEBUGLEVEL >= 10) {
2318                 NDR_PRINT_OUT_DEBUG(PNP_QueryResConfList, &r);
2319         }
2320
2321         if (NT_STATUS_IS_ERR(status)) {
2322                 return status;
2323         }
2324
2325         /* Return variables */
2326
2327         /* Return result */
2328         if (werror) {
2329                 *werror = r.out.result;
2330         }
2331
2332         return werror_to_ntstatus(r.out.result);
2333 }
2334
2335 NTSTATUS rpccli_PNP_SetHwProf(struct rpc_pipe_client *cli,
2336                               TALLOC_CTX *mem_ctx,
2337                               WERROR *werror)
2338 {
2339         struct PNP_SetHwProf r;
2340         NTSTATUS status;
2341
2342         /* In parameters */
2343
2344         if (DEBUGLEVEL >= 10) {
2345                 NDR_PRINT_IN_DEBUG(PNP_SetHwProf, &r);
2346         }
2347
2348         status = cli_do_rpc_ndr(cli,
2349                                 mem_ctx,
2350                                 &ndr_table_ntsvcs,
2351                                 NDR_PNP_SETHWPROF,
2352                                 &r);
2353
2354         if (!NT_STATUS_IS_OK(status)) {
2355                 return status;
2356         }
2357
2358         if (DEBUGLEVEL >= 10) {
2359                 NDR_PRINT_OUT_DEBUG(PNP_SetHwProf, &r);
2360         }
2361
2362         if (NT_STATUS_IS_ERR(status)) {
2363                 return status;
2364         }
2365
2366         /* Return variables */
2367
2368         /* Return result */
2369         if (werror) {
2370                 *werror = r.out.result;
2371         }
2372
2373         return werror_to_ntstatus(r.out.result);
2374 }
2375
2376 NTSTATUS rpccli_PNP_QueryArbitratorFreeData(struct rpc_pipe_client *cli,
2377                                             TALLOC_CTX *mem_ctx,
2378                                             WERROR *werror)
2379 {
2380         struct PNP_QueryArbitratorFreeData r;
2381         NTSTATUS status;
2382
2383         /* In parameters */
2384
2385         if (DEBUGLEVEL >= 10) {
2386                 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeData, &r);
2387         }
2388
2389         status = cli_do_rpc_ndr(cli,
2390                                 mem_ctx,
2391                                 &ndr_table_ntsvcs,
2392                                 NDR_PNP_QUERYARBITRATORFREEDATA,
2393                                 &r);
2394
2395         if (!NT_STATUS_IS_OK(status)) {
2396                 return status;
2397         }
2398
2399         if (DEBUGLEVEL >= 10) {
2400                 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeData, &r);
2401         }
2402
2403         if (NT_STATUS_IS_ERR(status)) {
2404                 return status;
2405         }
2406
2407         /* Return variables */
2408
2409         /* Return result */
2410         if (werror) {
2411                 *werror = r.out.result;
2412         }
2413
2414         return werror_to_ntstatus(r.out.result);
2415 }
2416
2417 NTSTATUS rpccli_PNP_QueryArbitratorFreeSize(struct rpc_pipe_client *cli,
2418                                             TALLOC_CTX *mem_ctx,
2419                                             WERROR *werror)
2420 {
2421         struct PNP_QueryArbitratorFreeSize r;
2422         NTSTATUS status;
2423
2424         /* In parameters */
2425
2426         if (DEBUGLEVEL >= 10) {
2427                 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeSize, &r);
2428         }
2429
2430         status = cli_do_rpc_ndr(cli,
2431                                 mem_ctx,
2432                                 &ndr_table_ntsvcs,
2433                                 NDR_PNP_QUERYARBITRATORFREESIZE,
2434                                 &r);
2435
2436         if (!NT_STATUS_IS_OK(status)) {
2437                 return status;
2438         }
2439
2440         if (DEBUGLEVEL >= 10) {
2441                 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeSize, &r);
2442         }
2443
2444         if (NT_STATUS_IS_ERR(status)) {
2445                 return status;
2446         }
2447
2448         /* Return variables */
2449
2450         /* Return result */
2451         if (werror) {
2452                 *werror = r.out.result;
2453         }
2454
2455         return werror_to_ntstatus(r.out.result);
2456 }
2457
2458 NTSTATUS rpccli_PNP_RunDetection(struct rpc_pipe_client *cli,
2459                                  TALLOC_CTX *mem_ctx,
2460                                  WERROR *werror)
2461 {
2462         struct PNP_RunDetection r;
2463         NTSTATUS status;
2464
2465         /* In parameters */
2466
2467         if (DEBUGLEVEL >= 10) {
2468                 NDR_PRINT_IN_DEBUG(PNP_RunDetection, &r);
2469         }
2470
2471         status = cli_do_rpc_ndr(cli,
2472                                 mem_ctx,
2473                                 &ndr_table_ntsvcs,
2474                                 NDR_PNP_RUNDETECTION,
2475                                 &r);
2476
2477         if (!NT_STATUS_IS_OK(status)) {
2478                 return status;
2479         }
2480
2481         if (DEBUGLEVEL >= 10) {
2482                 NDR_PRINT_OUT_DEBUG(PNP_RunDetection, &r);
2483         }
2484
2485         if (NT_STATUS_IS_ERR(status)) {
2486                 return status;
2487         }
2488
2489         /* Return variables */
2490
2491         /* Return result */
2492         if (werror) {
2493                 *werror = r.out.result;
2494         }
2495
2496         return werror_to_ntstatus(r.out.result);
2497 }
2498
2499 NTSTATUS rpccli_PNP_RegisterNotification(struct rpc_pipe_client *cli,
2500                                          TALLOC_CTX *mem_ctx,
2501                                          WERROR *werror)
2502 {
2503         struct PNP_RegisterNotification r;
2504         NTSTATUS status;
2505
2506         /* In parameters */
2507
2508         if (DEBUGLEVEL >= 10) {
2509                 NDR_PRINT_IN_DEBUG(PNP_RegisterNotification, &r);
2510         }
2511
2512         status = cli_do_rpc_ndr(cli,
2513                                 mem_ctx,
2514                                 &ndr_table_ntsvcs,
2515                                 NDR_PNP_REGISTERNOTIFICATION,
2516                                 &r);
2517
2518         if (!NT_STATUS_IS_OK(status)) {
2519                 return status;
2520         }
2521
2522         if (DEBUGLEVEL >= 10) {
2523                 NDR_PRINT_OUT_DEBUG(PNP_RegisterNotification, &r);
2524         }
2525
2526         if (NT_STATUS_IS_ERR(status)) {
2527                 return status;
2528         }
2529
2530         /* Return variables */
2531
2532         /* Return result */
2533         if (werror) {
2534                 *werror = r.out.result;
2535         }
2536
2537         return werror_to_ntstatus(r.out.result);
2538 }
2539
2540 NTSTATUS rpccli_PNP_UnregisterNotification(struct rpc_pipe_client *cli,
2541                                            TALLOC_CTX *mem_ctx,
2542                                            WERROR *werror)
2543 {
2544         struct PNP_UnregisterNotification r;
2545         NTSTATUS status;
2546
2547         /* In parameters */
2548
2549         if (DEBUGLEVEL >= 10) {
2550                 NDR_PRINT_IN_DEBUG(PNP_UnregisterNotification, &r);
2551         }
2552
2553         status = cli_do_rpc_ndr(cli,
2554                                 mem_ctx,
2555                                 &ndr_table_ntsvcs,
2556                                 NDR_PNP_UNREGISTERNOTIFICATION,
2557                                 &r);
2558
2559         if (!NT_STATUS_IS_OK(status)) {
2560                 return status;
2561         }
2562
2563         if (DEBUGLEVEL >= 10) {
2564                 NDR_PRINT_OUT_DEBUG(PNP_UnregisterNotification, &r);
2565         }
2566
2567         if (NT_STATUS_IS_ERR(status)) {
2568                 return status;
2569         }
2570
2571         /* Return variables */
2572
2573         /* Return result */
2574         if (werror) {
2575                 *werror = r.out.result;
2576         }
2577
2578         return werror_to_ntstatus(r.out.result);
2579 }
2580
2581 NTSTATUS rpccli_PNP_GetCustomDevProp(struct rpc_pipe_client *cli,
2582                                      TALLOC_CTX *mem_ctx,
2583                                      WERROR *werror)
2584 {
2585         struct PNP_GetCustomDevProp r;
2586         NTSTATUS status;
2587
2588         /* In parameters */
2589
2590         if (DEBUGLEVEL >= 10) {
2591                 NDR_PRINT_IN_DEBUG(PNP_GetCustomDevProp, &r);
2592         }
2593
2594         status = cli_do_rpc_ndr(cli,
2595                                 mem_ctx,
2596                                 &ndr_table_ntsvcs,
2597                                 NDR_PNP_GETCUSTOMDEVPROP,
2598                                 &r);
2599
2600         if (!NT_STATUS_IS_OK(status)) {
2601                 return status;
2602         }
2603
2604         if (DEBUGLEVEL >= 10) {
2605                 NDR_PRINT_OUT_DEBUG(PNP_GetCustomDevProp, &r);
2606         }
2607
2608         if (NT_STATUS_IS_ERR(status)) {
2609                 return status;
2610         }
2611
2612         /* Return variables */
2613
2614         /* Return result */
2615         if (werror) {
2616                 *werror = r.out.result;
2617         }
2618
2619         return werror_to_ntstatus(r.out.result);
2620 }
2621
2622 NTSTATUS rpccli_PNP_GetVersionInternal(struct rpc_pipe_client *cli,
2623                                        TALLOC_CTX *mem_ctx,
2624                                        WERROR *werror)
2625 {
2626         struct PNP_GetVersionInternal r;
2627         NTSTATUS status;
2628
2629         /* In parameters */
2630
2631         if (DEBUGLEVEL >= 10) {
2632                 NDR_PRINT_IN_DEBUG(PNP_GetVersionInternal, &r);
2633         }
2634
2635         status = cli_do_rpc_ndr(cli,
2636                                 mem_ctx,
2637                                 &ndr_table_ntsvcs,
2638                                 NDR_PNP_GETVERSIONINTERNAL,
2639                                 &r);
2640
2641         if (!NT_STATUS_IS_OK(status)) {
2642                 return status;
2643         }
2644
2645         if (DEBUGLEVEL >= 10) {
2646                 NDR_PRINT_OUT_DEBUG(PNP_GetVersionInternal, &r);
2647         }
2648
2649         if (NT_STATUS_IS_ERR(status)) {
2650                 return status;
2651         }
2652
2653         /* Return variables */
2654
2655         /* Return result */
2656         if (werror) {
2657                 *werror = r.out.result;
2658         }
2659
2660         return werror_to_ntstatus(r.out.result);
2661 }
2662
2663 NTSTATUS rpccli_PNP_GetBlockedDriverInfo(struct rpc_pipe_client *cli,
2664                                          TALLOC_CTX *mem_ctx,
2665                                          WERROR *werror)
2666 {
2667         struct PNP_GetBlockedDriverInfo r;
2668         NTSTATUS status;
2669
2670         /* In parameters */
2671
2672         if (DEBUGLEVEL >= 10) {
2673                 NDR_PRINT_IN_DEBUG(PNP_GetBlockedDriverInfo, &r);
2674         }
2675
2676         status = cli_do_rpc_ndr(cli,
2677                                 mem_ctx,
2678                                 &ndr_table_ntsvcs,
2679                                 NDR_PNP_GETBLOCKEDDRIVERINFO,
2680                                 &r);
2681
2682         if (!NT_STATUS_IS_OK(status)) {
2683                 return status;
2684         }
2685
2686         if (DEBUGLEVEL >= 10) {
2687                 NDR_PRINT_OUT_DEBUG(PNP_GetBlockedDriverInfo, &r);
2688         }
2689
2690         if (NT_STATUS_IS_ERR(status)) {
2691                 return status;
2692         }
2693
2694         /* Return variables */
2695
2696         /* Return result */
2697         if (werror) {
2698                 *werror = r.out.result;
2699         }
2700
2701         return werror_to_ntstatus(r.out.result);
2702 }
2703
2704 NTSTATUS rpccli_PNP_GetServerSideDeviceInstallFlags(struct rpc_pipe_client *cli,
2705                                                     TALLOC_CTX *mem_ctx,
2706                                                     WERROR *werror)
2707 {
2708         struct PNP_GetServerSideDeviceInstallFlags r;
2709         NTSTATUS status;
2710
2711         /* In parameters */
2712
2713         if (DEBUGLEVEL >= 10) {
2714                 NDR_PRINT_IN_DEBUG(PNP_GetServerSideDeviceInstallFlags, &r);
2715         }
2716
2717         status = cli_do_rpc_ndr(cli,
2718                                 mem_ctx,
2719                                 &ndr_table_ntsvcs,
2720                                 NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS,
2721                                 &r);
2722
2723         if (!NT_STATUS_IS_OK(status)) {
2724                 return status;
2725         }
2726
2727         if (DEBUGLEVEL >= 10) {
2728                 NDR_PRINT_OUT_DEBUG(PNP_GetServerSideDeviceInstallFlags, &r);
2729         }
2730
2731         if (NT_STATUS_IS_ERR(status)) {
2732                 return status;
2733         }
2734
2735         /* Return variables */
2736
2737         /* Return result */
2738         if (werror) {
2739                 *werror = r.out.result;
2740         }
2741
2742         return werror_to_ntstatus(r.out.result);
2743 }
2744