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