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                                      WERROR *werror)
 570 {
 571         struct PNP_GetDeviceRegProp r;
 572         NTSTATUS status;
 573
 574         /* In parameters */
 575
 576         if (DEBUGLEVEL >= 10) {
 577                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceRegProp, &r);
 578         }
 579
 580         status = cli_do_rpc_ndr(cli,
 581                                 mem_ctx,
 582                                 PI_NTSVCS,
 583                                 &ndr_table_ntsvcs,
 584                                 NDR_PNP_GETDEVICEREGPROP,
 585                                 &r);
 586
 587         if (!NT_STATUS_IS_OK(status)) {
 588                 return status;
 589         }
 590
 591         if (DEBUGLEVEL >= 10) {
 592                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceRegProp, &r);
 593         }
 594
 595         if (NT_STATUS_IS_ERR(status)) {
 596                 return status;
 597         }
 598
 599         /* Return variables */
 600
 601         /* Return result */
 602         if (werror) {
 603                 *werror = r.out.result;
 604         }
 605
 606         return werror_to_ntstatus(r.out.result);
 607 }
 608
 609 NTSTATUS rpccli_PNP_SetDeviceRegProp(struct rpc_pipe_client *cli,
 610                                      TALLOC_CTX *mem_ctx,
 611                                      WERROR *werror)
 612 {
 613         struct PNP_SetDeviceRegProp r;
 614         NTSTATUS status;
 615
 616         /* In parameters */
 617
 618         if (DEBUGLEVEL >= 10) {
 619                 NDR_PRINT_IN_DEBUG(PNP_SetDeviceRegProp, &r);
 620         }
 621
 622         status = cli_do_rpc_ndr(cli,
 623                                 mem_ctx,
 624                                 PI_NTSVCS,
 625                                 &ndr_table_ntsvcs,
 626                                 NDR_PNP_SETDEVICEREGPROP,
 627                                 &r);
 628
 629         if (!NT_STATUS_IS_OK(status)) {
 630                 return status;
 631         }
 632
 633         if (DEBUGLEVEL >= 10) {
 634                 NDR_PRINT_OUT_DEBUG(PNP_SetDeviceRegProp, &r);
 635         }
 636
 637         if (NT_STATUS_IS_ERR(status)) {
 638                 return status;
 639         }
 640
 641         /* Return variables */
 642
 643         /* Return result */
 644         if (werror) {
 645                 *werror = r.out.result;
 646         }
 647
 648         return werror_to_ntstatus(r.out.result);
 649 }
 650
 651 NTSTATUS rpccli_PNP_GetClassInstance(struct rpc_pipe_client *cli,
 652                                      TALLOC_CTX *mem_ctx,
 653                                      WERROR *werror)
 654 {
 655         struct PNP_GetClassInstance r;
 656         NTSTATUS status;
 657
 658         /* In parameters */
 659
 660         if (DEBUGLEVEL >= 10) {
 661                 NDR_PRINT_IN_DEBUG(PNP_GetClassInstance, &r);
 662         }
 663
 664         status = cli_do_rpc_ndr(cli,
 665                                 mem_ctx,
 666                                 PI_NTSVCS,
 667                                 &ndr_table_ntsvcs,
 668                                 NDR_PNP_GETCLASSINSTANCE,
 669                                 &r);
 670
 671         if (!NT_STATUS_IS_OK(status)) {
 672                 return status;
 673         }
 674
 675         if (DEBUGLEVEL >= 10) {
 676                 NDR_PRINT_OUT_DEBUG(PNP_GetClassInstance, &r);
 677         }
 678
 679         if (NT_STATUS_IS_ERR(status)) {
 680                 return status;
 681         }
 682
 683         /* Return variables */
 684
 685         /* Return result */
 686         if (werror) {
 687                 *werror = r.out.result;
 688         }
 689
 690         return werror_to_ntstatus(r.out.result);
 691 }
 692
 693 NTSTATUS rpccli_PNP_CreateKey(struct rpc_pipe_client *cli,
 694                               TALLOC_CTX *mem_ctx,
 695                               WERROR *werror)
 696 {
 697         struct PNP_CreateKey r;
 698         NTSTATUS status;
 699
 700         /* In parameters */
 701
 702         if (DEBUGLEVEL >= 10) {
 703                 NDR_PRINT_IN_DEBUG(PNP_CreateKey, &r);
 704         }
 705
 706         status = cli_do_rpc_ndr(cli,
 707                                 mem_ctx,
 708                                 PI_NTSVCS,
 709                                 &ndr_table_ntsvcs,
 710                                 NDR_PNP_CREATEKEY,
 711                                 &r);
 712
 713         if (!NT_STATUS_IS_OK(status)) {
 714                 return status;
 715         }
 716
 717         if (DEBUGLEVEL >= 10) {
 718                 NDR_PRINT_OUT_DEBUG(PNP_CreateKey, &r);
 719         }
 720
 721         if (NT_STATUS_IS_ERR(status)) {
 722                 return status;
 723         }
 724
 725         /* Return variables */
 726
 727         /* Return result */
 728         if (werror) {
 729                 *werror = r.out.result;
 730         }
 731
 732         return werror_to_ntstatus(r.out.result);
 733 }
 734
 735 NTSTATUS rpccli_PNP_DeleteRegistryKey(struct rpc_pipe_client *cli,
 736                                       TALLOC_CTX *mem_ctx,
 737                                       WERROR *werror)
 738 {
 739         struct PNP_DeleteRegistryKey r;
 740         NTSTATUS status;
 741
 742         /* In parameters */
 743
 744         if (DEBUGLEVEL >= 10) {
 745                 NDR_PRINT_IN_DEBUG(PNP_DeleteRegistryKey, &r);
 746         }
 747
 748         status = cli_do_rpc_ndr(cli,
 749                                 mem_ctx,
 750                                 PI_NTSVCS,
 751                                 &ndr_table_ntsvcs,
 752                                 NDR_PNP_DELETEREGISTRYKEY,
 753                                 &r);
 754
 755         if (!NT_STATUS_IS_OK(status)) {
 756                 return status;
 757         }
 758
 759         if (DEBUGLEVEL >= 10) {
 760                 NDR_PRINT_OUT_DEBUG(PNP_DeleteRegistryKey, &r);
 761         }
 762
 763         if (NT_STATUS_IS_ERR(status)) {
 764                 return status;
 765         }
 766
 767         /* Return variables */
 768
 769         /* Return result */
 770         if (werror) {
 771                 *werror = r.out.result;
 772         }
 773
 774         return werror_to_ntstatus(r.out.result);
 775 }
 776
 777 NTSTATUS rpccli_PNP_GetClassCount(struct rpc_pipe_client *cli,
 778                                   TALLOC_CTX *mem_ctx,
 779                                   WERROR *werror)
 780 {
 781         struct PNP_GetClassCount r;
 782         NTSTATUS status;
 783
 784         /* In parameters */
 785
 786         if (DEBUGLEVEL >= 10) {
 787                 NDR_PRINT_IN_DEBUG(PNP_GetClassCount, &r);
 788         }
 789
 790         status = cli_do_rpc_ndr(cli,
 791                                 mem_ctx,
 792                                 PI_NTSVCS,
 793                                 &ndr_table_ntsvcs,
 794                                 NDR_PNP_GETCLASSCOUNT,
 795                                 &r);
 796
 797         if (!NT_STATUS_IS_OK(status)) {
 798                 return status;
 799         }
 800
 801         if (DEBUGLEVEL >= 10) {
 802                 NDR_PRINT_OUT_DEBUG(PNP_GetClassCount, &r);
 803         }
 804
 805         if (NT_STATUS_IS_ERR(status)) {
 806                 return status;
 807         }
 808
 809         /* Return variables */
 810
 811         /* Return result */
 812         if (werror) {
 813                 *werror = r.out.result;
 814         }
 815
 816         return werror_to_ntstatus(r.out.result);
 817 }
 818
 819 NTSTATUS rpccli_PNP_GetClassName(struct rpc_pipe_client *cli,
 820                                  TALLOC_CTX *mem_ctx,
 821                                  WERROR *werror)
 822 {
 823         struct PNP_GetClassName r;
 824         NTSTATUS status;
 825
 826         /* In parameters */
 827
 828         if (DEBUGLEVEL >= 10) {
 829                 NDR_PRINT_IN_DEBUG(PNP_GetClassName, &r);
 830         }
 831
 832         status = cli_do_rpc_ndr(cli,
 833                                 mem_ctx,
 834                                 PI_NTSVCS,
 835                                 &ndr_table_ntsvcs,
 836                                 NDR_PNP_GETCLASSNAME,
 837                                 &r);
 838
 839         if (!NT_STATUS_IS_OK(status)) {
 840                 return status;
 841         }
 842
 843         if (DEBUGLEVEL >= 10) {
 844                 NDR_PRINT_OUT_DEBUG(PNP_GetClassName, &r);
 845         }
 846
 847         if (NT_STATUS_IS_ERR(status)) {
 848                 return status;
 849         }
 850
 851         /* Return variables */
 852
 853         /* Return result */
 854         if (werror) {
 855                 *werror = r.out.result;
 856         }
 857
 858         return werror_to_ntstatus(r.out.result);
 859 }
 860
 861 NTSTATUS rpccli_PNP_DeleteClassKey(struct rpc_pipe_client *cli,
 862                                    TALLOC_CTX *mem_ctx,
 863                                    WERROR *werror)
 864 {
 865         struct PNP_DeleteClassKey r;
 866         NTSTATUS status;
 867
 868         /* In parameters */
 869
 870         if (DEBUGLEVEL >= 10) {
 871                 NDR_PRINT_IN_DEBUG(PNP_DeleteClassKey, &r);
 872         }
 873
 874         status = cli_do_rpc_ndr(cli,
 875                                 mem_ctx,
 876                                 PI_NTSVCS,
 877                                 &ndr_table_ntsvcs,
 878                                 NDR_PNP_DELETECLASSKEY,
 879                                 &r);
 880
 881         if (!NT_STATUS_IS_OK(status)) {
 882                 return status;
 883         }
 884
 885         if (DEBUGLEVEL >= 10) {
 886                 NDR_PRINT_OUT_DEBUG(PNP_DeleteClassKey, &r);
 887         }
 888
 889         if (NT_STATUS_IS_ERR(status)) {
 890                 return status;
 891         }
 892
 893         /* Return variables */
 894
 895         /* Return result */
 896         if (werror) {
 897                 *werror = r.out.result;
 898         }
 899
 900         return werror_to_ntstatus(r.out.result);
 901 }
 902
 903 NTSTATUS rpccli_PNP_GetInterfaceDeviceAlias(struct rpc_pipe_client *cli,
 904                                             TALLOC_CTX *mem_ctx,
 905                                             WERROR *werror)
 906 {
 907         struct PNP_GetInterfaceDeviceAlias r;
 908         NTSTATUS status;
 909
 910         /* In parameters */
 911
 912         if (DEBUGLEVEL >= 10) {
 913                 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceAlias, &r);
 914         }
 915
 916         status = cli_do_rpc_ndr(cli,
 917                                 mem_ctx,
 918                                 PI_NTSVCS,
 919                                 &ndr_table_ntsvcs,
 920                                 NDR_PNP_GETINTERFACEDEVICEALIAS,
 921                                 &r);
 922
 923         if (!NT_STATUS_IS_OK(status)) {
 924                 return status;
 925         }
 926
 927         if (DEBUGLEVEL >= 10) {
 928                 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceAlias, &r);
 929         }
 930
 931         if (NT_STATUS_IS_ERR(status)) {
 932                 return status;
 933         }
 934
 935         /* Return variables */
 936
 937         /* Return result */
 938         if (werror) {
 939                 *werror = r.out.result;
 940         }
 941
 942         return werror_to_ntstatus(r.out.result);
 943 }
 944
 945 NTSTATUS rpccli_PNP_GetInterfaceDeviceList(struct rpc_pipe_client *cli,
 946                                            TALLOC_CTX *mem_ctx,
 947                                            WERROR *werror)
 948 {
 949         struct PNP_GetInterfaceDeviceList r;
 950         NTSTATUS status;
 951
 952         /* In parameters */
 953
 954         if (DEBUGLEVEL >= 10) {
 955                 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceList, &r);
 956         }
 957
 958         status = cli_do_rpc_ndr(cli,
 959                                 mem_ctx,
 960                                 PI_NTSVCS,
 961                                 &ndr_table_ntsvcs,
 962                                 NDR_PNP_GETINTERFACEDEVICELIST,
 963                                 &r);
 964
 965         if (!NT_STATUS_IS_OK(status)) {
 966                 return status;
 967         }
 968
 969         if (DEBUGLEVEL >= 10) {
 970                 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceList, &r);
 971         }
 972
 973         if (NT_STATUS_IS_ERR(status)) {
 974                 return status;
 975         }
 976
 977         /* Return variables */
 978
 979         /* Return result */
 980         if (werror) {
 981                 *werror = r.out.result;
 982         }
 983
 984         return werror_to_ntstatus(r.out.result);
 985 }
 986
 987 NTSTATUS rpccli_PNP_GetInterfaceDeviceListSize(struct rpc_pipe_client *cli,
 988                                                TALLOC_CTX *mem_ctx,
 989                                                WERROR *werror)
 990 {
 991         struct PNP_GetInterfaceDeviceListSize r;
 992         NTSTATUS status;
 993
 994         /* In parameters */
 995
 996         if (DEBUGLEVEL >= 10) {
 997                 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceListSize, &r);
 998         }
 999
1000         status = cli_do_rpc_ndr(cli,
1001                                 mem_ctx,
1002                                 PI_NTSVCS,
1003                                 &ndr_table_ntsvcs,
1004                                 NDR_PNP_GETINTERFACEDEVICELISTSIZE,
1005                                 &r);
1006
1007         if (!NT_STATUS_IS_OK(status)) {
1008                 return status;
1009         }
1010
1011         if (DEBUGLEVEL >= 10) {
1012                 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceListSize, &r);
1013         }
1014
1015         if (NT_STATUS_IS_ERR(status)) {
1016                 return status;
1017         }
1018
1019         /* Return variables */
1020
1021         /* Return result */
1022         if (werror) {
1023                 *werror = r.out.result;
1024         }
1025
1026         return werror_to_ntstatus(r.out.result);
1027 }
1028
1029 NTSTATUS rpccli_PNP_RegisterDeviceClassAssociation(struct rpc_pipe_client *cli,
1030                                                    TALLOC_CTX *mem_ctx,
1031                                                    WERROR *werror)
1032 {
1033         struct PNP_RegisterDeviceClassAssociation r;
1034         NTSTATUS status;
1035
1036         /* In parameters */
1037
1038         if (DEBUGLEVEL >= 10) {
1039                 NDR_PRINT_IN_DEBUG(PNP_RegisterDeviceClassAssociation, &r);
1040         }
1041
1042         status = cli_do_rpc_ndr(cli,
1043                                 mem_ctx,
1044                                 PI_NTSVCS,
1045                                 &ndr_table_ntsvcs,
1046                                 NDR_PNP_REGISTERDEVICECLASSASSOCIATION,
1047                                 &r);
1048
1049         if (!NT_STATUS_IS_OK(status)) {
1050                 return status;
1051         }
1052
1053         if (DEBUGLEVEL >= 10) {
1054                 NDR_PRINT_OUT_DEBUG(PNP_RegisterDeviceClassAssociation, &r);
1055         }
1056
1057         if (NT_STATUS_IS_ERR(status)) {
1058                 return status;
1059         }
1060
1061         /* Return variables */
1062
1063         /* Return result */
1064         if (werror) {
1065                 *werror = r.out.result;
1066         }
1067
1068         return werror_to_ntstatus(r.out.result);
1069 }
1070
1071 NTSTATUS rpccli_PNP_UnregisterDeviceClassAssociation(struct rpc_pipe_client *cli,
1072                                                      TALLOC_CTX *mem_ctx,
1073                                                      WERROR *werror)
1074 {
1075         struct PNP_UnregisterDeviceClassAssociation r;
1076         NTSTATUS status;
1077
1078         /* In parameters */
1079
1080         if (DEBUGLEVEL >= 10) {
1081                 NDR_PRINT_IN_DEBUG(PNP_UnregisterDeviceClassAssociation, &r);
1082         }
1083
1084         status = cli_do_rpc_ndr(cli,
1085                                 mem_ctx,
1086                                 PI_NTSVCS,
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                                 PI_NTSVCS,
1129                                 &ndr_table_ntsvcs,
1130                                 NDR_PNP_GETCLASSREGPROP,
1131                                 &r);
1132
1133         if (!NT_STATUS_IS_OK(status)) {
1134                 return status;
1135         }
1136
1137         if (DEBUGLEVEL >= 10) {
1138                 NDR_PRINT_OUT_DEBUG(PNP_GetClassRegProp, &r);
1139         }
1140
1141         if (NT_STATUS_IS_ERR(status)) {
1142                 return status;
1143         }
1144
1145         /* Return variables */
1146
1147         /* Return result */
1148         if (werror) {
1149                 *werror = r.out.result;
1150         }
1151
1152         return werror_to_ntstatus(r.out.result);
1153 }
1154
1155 NTSTATUS rpccli_PNP_SetClassRegProp(struct rpc_pipe_client *cli,
1156                                     TALLOC_CTX *mem_ctx,
1157                                     WERROR *werror)
1158 {
1159         struct PNP_SetClassRegProp r;
1160         NTSTATUS status;
1161
1162         /* In parameters */
1163
1164         if (DEBUGLEVEL >= 10) {
1165                 NDR_PRINT_IN_DEBUG(PNP_SetClassRegProp, &r);
1166         }
1167
1168         status = cli_do_rpc_ndr(cli,
1169                                 mem_ctx,
1170                                 PI_NTSVCS,
1171                                 &ndr_table_ntsvcs,
1172                                 NDR_PNP_SETCLASSREGPROP,
1173                                 &r);
1174
1175         if (!NT_STATUS_IS_OK(status)) {
1176                 return status;
1177         }
1178
1179         if (DEBUGLEVEL >= 10) {
1180                 NDR_PRINT_OUT_DEBUG(PNP_SetClassRegProp, &r);
1181         }
1182
1183         if (NT_STATUS_IS_ERR(status)) {
1184                 return status;
1185         }
1186
1187         /* Return variables */
1188
1189         /* Return result */
1190         if (werror) {
1191                 *werror = r.out.result;
1192         }
1193
1194         return werror_to_ntstatus(r.out.result);
1195 }
1196
1197 NTSTATUS rpccli_PNP_CreateDevInst(struct rpc_pipe_client *cli,
1198                                   TALLOC_CTX *mem_ctx,
1199                                   WERROR *werror)
1200 {
1201         struct PNP_CreateDevInst r;
1202         NTSTATUS status;
1203
1204         /* In parameters */
1205
1206         if (DEBUGLEVEL >= 10) {
1207                 NDR_PRINT_IN_DEBUG(PNP_CreateDevInst, &r);
1208         }
1209
1210         status = cli_do_rpc_ndr(cli,
1211                                 mem_ctx,
1212                                 PI_NTSVCS,
1213                                 &ndr_table_ntsvcs,
1214                                 NDR_PNP_CREATEDEVINST,
1215                                 &r);
1216
1217         if (!NT_STATUS_IS_OK(status)) {
1218                 return status;
1219         }
1220
1221         if (DEBUGLEVEL >= 10) {
1222                 NDR_PRINT_OUT_DEBUG(PNP_CreateDevInst, &r);
1223         }
1224
1225         if (NT_STATUS_IS_ERR(status)) {
1226                 return status;
1227         }
1228
1229         /* Return variables */
1230
1231         /* Return result */
1232         if (werror) {
1233                 *werror = r.out.result;
1234         }
1235
1236         return werror_to_ntstatus(r.out.result);
1237 }
1238
1239 NTSTATUS rpccli_PNP_DeviceInstanceAction(struct rpc_pipe_client *cli,
1240                                          TALLOC_CTX *mem_ctx,
1241                                          WERROR *werror)
1242 {
1243         struct PNP_DeviceInstanceAction r;
1244         NTSTATUS status;
1245
1246         /* In parameters */
1247
1248         if (DEBUGLEVEL >= 10) {
1249                 NDR_PRINT_IN_DEBUG(PNP_DeviceInstanceAction, &r);
1250         }
1251
1252         status = cli_do_rpc_ndr(cli,
1253                                 mem_ctx,
1254                                 PI_NTSVCS,
1255                                 &ndr_table_ntsvcs,
1256                                 NDR_PNP_DEVICEINSTANCEACTION,
1257                                 &r);
1258
1259         if (!NT_STATUS_IS_OK(status)) {
1260                 return status;
1261         }
1262
1263         if (DEBUGLEVEL >= 10) {
1264                 NDR_PRINT_OUT_DEBUG(PNP_DeviceInstanceAction, &r);
1265         }
1266
1267         if (NT_STATUS_IS_ERR(status)) {
1268                 return status;
1269         }
1270
1271         /* Return variables */
1272
1273         /* Return result */
1274         if (werror) {
1275                 *werror = r.out.result;
1276         }
1277
1278         return werror_to_ntstatus(r.out.result);
1279 }
1280
1281 NTSTATUS rpccli_PNP_GetDeviceStatus(struct rpc_pipe_client *cli,
1282                                     TALLOC_CTX *mem_ctx,
1283                                     WERROR *werror)
1284 {
1285         struct PNP_GetDeviceStatus r;
1286         NTSTATUS status;
1287
1288         /* In parameters */
1289
1290         if (DEBUGLEVEL >= 10) {
1291                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceStatus, &r);
1292         }
1293
1294         status = cli_do_rpc_ndr(cli,
1295                                 mem_ctx,
1296                                 PI_NTSVCS,
1297                                 &ndr_table_ntsvcs,
1298                                 NDR_PNP_GETDEVICESTATUS,
1299                                 &r);
1300
1301         if (!NT_STATUS_IS_OK(status)) {
1302                 return status;
1303         }
1304
1305         if (DEBUGLEVEL >= 10) {
1306                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceStatus, &r);
1307         }
1308
1309         if (NT_STATUS_IS_ERR(status)) {
1310                 return status;
1311         }
1312
1313         /* Return variables */
1314
1315         /* Return result */
1316         if (werror) {
1317                 *werror = r.out.result;
1318         }
1319
1320         return werror_to_ntstatus(r.out.result);
1321 }
1322
1323 NTSTATUS rpccli_PNP_SetDeviceProblem(struct rpc_pipe_client *cli,
1324                                      TALLOC_CTX *mem_ctx,
1325                                      WERROR *werror)
1326 {
1327         struct PNP_SetDeviceProblem r;
1328         NTSTATUS status;
1329
1330         /* In parameters */
1331
1332         if (DEBUGLEVEL >= 10) {
1333                 NDR_PRINT_IN_DEBUG(PNP_SetDeviceProblem, &r);
1334         }
1335
1336         status = cli_do_rpc_ndr(cli,
1337                                 mem_ctx,
1338                                 PI_NTSVCS,
1339                                 &ndr_table_ntsvcs,
1340                                 NDR_PNP_SETDEVICEPROBLEM,
1341                                 &r);
1342
1343         if (!NT_STATUS_IS_OK(status)) {
1344                 return status;
1345         }
1346
1347         if (DEBUGLEVEL >= 10) {
1348                 NDR_PRINT_OUT_DEBUG(PNP_SetDeviceProblem, &r);
1349         }
1350
1351         if (NT_STATUS_IS_ERR(status)) {
1352                 return status;
1353         }
1354
1355         /* Return variables */
1356
1357         /* Return result */
1358         if (werror) {
1359                 *werror = r.out.result;
1360         }
1361
1362         return werror_to_ntstatus(r.out.result);
1363 }
1364
1365 NTSTATUS rpccli_PNP_DisableDevInst(struct rpc_pipe_client *cli,
1366                                    TALLOC_CTX *mem_ctx,
1367                                    WERROR *werror)
1368 {
1369         struct PNP_DisableDevInst r;
1370         NTSTATUS status;
1371
1372         /* In parameters */
1373
1374         if (DEBUGLEVEL >= 10) {
1375                 NDR_PRINT_IN_DEBUG(PNP_DisableDevInst, &r);
1376         }
1377
1378         status = cli_do_rpc_ndr(cli,
1379                                 mem_ctx,
1380                                 PI_NTSVCS,
1381                                 &ndr_table_ntsvcs,
1382                                 NDR_PNP_DISABLEDEVINST,
1383                                 &r);
1384
1385         if (!NT_STATUS_IS_OK(status)) {
1386                 return status;
1387         }
1388
1389         if (DEBUGLEVEL >= 10) {
1390                 NDR_PRINT_OUT_DEBUG(PNP_DisableDevInst, &r);
1391         }
1392
1393         if (NT_STATUS_IS_ERR(status)) {
1394                 return status;
1395         }
1396
1397         /* Return variables */
1398
1399         /* Return result */
1400         if (werror) {
1401                 *werror = r.out.result;
1402         }
1403
1404         return werror_to_ntstatus(r.out.result);
1405 }
1406
1407 NTSTATUS rpccli_PNP_UninstallDevInst(struct rpc_pipe_client *cli,
1408                                      TALLOC_CTX *mem_ctx,
1409                                      WERROR *werror)
1410 {
1411         struct PNP_UninstallDevInst r;
1412         NTSTATUS status;
1413
1414         /* In parameters */
1415
1416         if (DEBUGLEVEL >= 10) {
1417                 NDR_PRINT_IN_DEBUG(PNP_UninstallDevInst, &r);
1418         }
1419
1420         status = cli_do_rpc_ndr(cli,
1421                                 mem_ctx,
1422                                 PI_NTSVCS,
1423                                 &ndr_table_ntsvcs,
1424                                 NDR_PNP_UNINSTALLDEVINST,
1425                                 &r);
1426
1427         if (!NT_STATUS_IS_OK(status)) {
1428                 return status;
1429         }
1430
1431         if (DEBUGLEVEL >= 10) {
1432                 NDR_PRINT_OUT_DEBUG(PNP_UninstallDevInst, &r);
1433         }
1434
1435         if (NT_STATUS_IS_ERR(status)) {
1436                 return status;
1437         }
1438
1439         /* Return variables */
1440
1441         /* Return result */
1442         if (werror) {
1443                 *werror = r.out.result;
1444         }
1445
1446         return werror_to_ntstatus(r.out.result);
1447 }
1448
1449 NTSTATUS rpccli_PNP_AddID(struct rpc_pipe_client *cli,
1450                           TALLOC_CTX *mem_ctx,
1451                           WERROR *werror)
1452 {
1453         struct PNP_AddID r;
1454         NTSTATUS status;
1455
1456         /* In parameters */
1457
1458         if (DEBUGLEVEL >= 10) {
1459                 NDR_PRINT_IN_DEBUG(PNP_AddID, &r);
1460         }
1461
1462         status = cli_do_rpc_ndr(cli,
1463                                 mem_ctx,
1464                                 PI_NTSVCS,
1465                                 &ndr_table_ntsvcs,
1466                                 NDR_PNP_ADDID,
1467                                 &r);
1468
1469         if (!NT_STATUS_IS_OK(status)) {
1470                 return status;
1471         }
1472
1473         if (DEBUGLEVEL >= 10) {
1474                 NDR_PRINT_OUT_DEBUG(PNP_AddID, &r);
1475         }
1476
1477         if (NT_STATUS_IS_ERR(status)) {
1478                 return status;
1479         }
1480
1481         /* Return variables */
1482
1483         /* Return result */
1484         if (werror) {
1485                 *werror = r.out.result;
1486         }
1487
1488         return werror_to_ntstatus(r.out.result);
1489 }
1490
1491 NTSTATUS rpccli_PNP_RegisterDriver(struct rpc_pipe_client *cli,
1492                                    TALLOC_CTX *mem_ctx,
1493                                    WERROR *werror)
1494 {
1495         struct PNP_RegisterDriver r;
1496         NTSTATUS status;
1497
1498         /* In parameters */
1499
1500         if (DEBUGLEVEL >= 10) {
1501                 NDR_PRINT_IN_DEBUG(PNP_RegisterDriver, &r);
1502         }
1503
1504         status = cli_do_rpc_ndr(cli,
1505                                 mem_ctx,
1506                                 PI_NTSVCS,
1507                                 &ndr_table_ntsvcs,
1508                                 NDR_PNP_REGISTERDRIVER,
1509                                 &r);
1510
1511         if (!NT_STATUS_IS_OK(status)) {
1512                 return status;
1513         }
1514
1515         if (DEBUGLEVEL >= 10) {
1516                 NDR_PRINT_OUT_DEBUG(PNP_RegisterDriver, &r);
1517         }
1518
1519         if (NT_STATUS_IS_ERR(status)) {
1520                 return status;
1521         }
1522
1523         /* Return variables */
1524
1525         /* Return result */
1526         if (werror) {
1527                 *werror = r.out.result;
1528         }
1529
1530         return werror_to_ntstatus(r.out.result);
1531 }
1532
1533 NTSTATUS rpccli_PNP_QueryRemove(struct rpc_pipe_client *cli,
1534                                 TALLOC_CTX *mem_ctx,
1535                                 WERROR *werror)
1536 {
1537         struct PNP_QueryRemove r;
1538         NTSTATUS status;
1539
1540         /* In parameters */
1541
1542         if (DEBUGLEVEL >= 10) {
1543                 NDR_PRINT_IN_DEBUG(PNP_QueryRemove, &r);
1544         }
1545
1546         status = cli_do_rpc_ndr(cli,
1547                                 mem_ctx,
1548                                 PI_NTSVCS,
1549                                 &ndr_table_ntsvcs,
1550                                 NDR_PNP_QUERYREMOVE,
1551                                 &r);
1552
1553         if (!NT_STATUS_IS_OK(status)) {
1554                 return status;
1555         }
1556
1557         if (DEBUGLEVEL >= 10) {
1558                 NDR_PRINT_OUT_DEBUG(PNP_QueryRemove, &r);
1559         }
1560
1561         if (NT_STATUS_IS_ERR(status)) {
1562                 return status;
1563         }
1564
1565         /* Return variables */
1566
1567         /* Return result */
1568         if (werror) {
1569                 *werror = r.out.result;
1570         }
1571
1572         return werror_to_ntstatus(r.out.result);
1573 }
1574
1575 NTSTATUS rpccli_PNP_RequestDeviceEject(struct rpc_pipe_client *cli,
1576                                        TALLOC_CTX *mem_ctx,
1577                                        WERROR *werror)
1578 {
1579         struct PNP_RequestDeviceEject r;
1580         NTSTATUS status;
1581
1582         /* In parameters */
1583
1584         if (DEBUGLEVEL >= 10) {
1585                 NDR_PRINT_IN_DEBUG(PNP_RequestDeviceEject, &r);
1586         }
1587
1588         status = cli_do_rpc_ndr(cli,
1589                                 mem_ctx,
1590                                 PI_NTSVCS,
1591                                 &ndr_table_ntsvcs,
1592                                 NDR_PNP_REQUESTDEVICEEJECT,
1593                                 &r);
1594
1595         if (!NT_STATUS_IS_OK(status)) {
1596                 return status;
1597         }
1598
1599         if (DEBUGLEVEL >= 10) {
1600                 NDR_PRINT_OUT_DEBUG(PNP_RequestDeviceEject, &r);
1601         }
1602
1603         if (NT_STATUS_IS_ERR(status)) {
1604                 return status;
1605         }
1606
1607         /* Return variables */
1608
1609         /* Return result */
1610         if (werror) {
1611                 *werror = r.out.result;
1612         }
1613
1614         return werror_to_ntstatus(r.out.result);
1615 }
1616
1617 NTSTATUS rpccli_PNP_IsDockStationPresent(struct rpc_pipe_client *cli,
1618                                          TALLOC_CTX *mem_ctx,
1619                                          WERROR *werror)
1620 {
1621         struct PNP_IsDockStationPresent r;
1622         NTSTATUS status;
1623
1624         /* In parameters */
1625
1626         if (DEBUGLEVEL >= 10) {
1627                 NDR_PRINT_IN_DEBUG(PNP_IsDockStationPresent, &r);
1628         }
1629
1630         status = cli_do_rpc_ndr(cli,
1631                                 mem_ctx,
1632                                 PI_NTSVCS,
1633                                 &ndr_table_ntsvcs,
1634                                 NDR_PNP_ISDOCKSTATIONPRESENT,
1635                                 &r);
1636
1637         if (!NT_STATUS_IS_OK(status)) {
1638                 return status;
1639         }
1640
1641         if (DEBUGLEVEL >= 10) {
1642                 NDR_PRINT_OUT_DEBUG(PNP_IsDockStationPresent, &r);
1643         }
1644
1645         if (NT_STATUS_IS_ERR(status)) {
1646                 return status;
1647         }
1648
1649         /* Return variables */
1650
1651         /* Return result */
1652         if (werror) {
1653                 *werror = r.out.result;
1654         }
1655
1656         return werror_to_ntstatus(r.out.result);
1657 }
1658
1659 NTSTATUS rpccli_PNP_RequestEjectPC(struct rpc_pipe_client *cli,
1660                                    TALLOC_CTX *mem_ctx,
1661                                    WERROR *werror)
1662 {
1663         struct PNP_RequestEjectPC r;
1664         NTSTATUS status;
1665
1666         /* In parameters */
1667
1668         if (DEBUGLEVEL >= 10) {
1669                 NDR_PRINT_IN_DEBUG(PNP_RequestEjectPC, &r);
1670         }
1671
1672         status = cli_do_rpc_ndr(cli,
1673                                 mem_ctx,
1674                                 PI_NTSVCS,
1675                                 &ndr_table_ntsvcs,
1676                                 NDR_PNP_REQUESTEJECTPC,
1677                                 &r);
1678
1679         if (!NT_STATUS_IS_OK(status)) {
1680                 return status;
1681         }
1682
1683         if (DEBUGLEVEL >= 10) {
1684                 NDR_PRINT_OUT_DEBUG(PNP_RequestEjectPC, &r);
1685         }
1686
1687         if (NT_STATUS_IS_ERR(status)) {
1688                 return status;
1689         }
1690
1691         /* Return variables */
1692
1693         /* Return result */
1694         if (werror) {
1695                 *werror = r.out.result;
1696         }
1697
1698         return werror_to_ntstatus(r.out.result);
1699 }
1700
1701 NTSTATUS rpccli_PNP_HwProfFlags(struct rpc_pipe_client *cli,
1702                                 TALLOC_CTX *mem_ctx,
1703                                 uint32_t unknown1 /* [in]  */,
1704                                 const char *devicepath /* [in] [ref,charset(UTF16)] */,
1705                                 uint32_t unknown2 /* [in]  */,
1706                                 uint32_t *unknown3 /* [in,out] [ref] */,
1707                                 uint16_t *unknown4 /* [in,out] [unique] */,
1708                                 const char *unknown5 /* [in] [unique,charset(UTF16)] */,
1709                                 const char **unknown5a /* [out] [unique,charset(UTF16)] */,
1710                                 uint32_t unknown6 /* [in]  */,
1711                                 uint32_t unknown7 /* [in]  */,
1712                                 WERROR *werror)
1713 {
1714         struct PNP_HwProfFlags r;
1715         NTSTATUS status;
1716
1717         /* In parameters */
1718         r.in.unknown1 = unknown1;
1719         r.in.devicepath = devicepath;
1720         r.in.unknown2 = unknown2;
1721         r.in.unknown3 = unknown3;
1722         r.in.unknown4 = unknown4;
1723         r.in.unknown5 = unknown5;
1724         r.in.unknown6 = unknown6;
1725         r.in.unknown7 = unknown7;
1726
1727         if (DEBUGLEVEL >= 10) {
1728                 NDR_PRINT_IN_DEBUG(PNP_HwProfFlags, &r);
1729         }
1730
1731         status = cli_do_rpc_ndr(cli,
1732                                 mem_ctx,
1733                                 PI_NTSVCS,
1734                                 &ndr_table_ntsvcs,
1735                                 NDR_PNP_HWPROFFLAGS,
1736                                 &r);
1737
1738         if (!NT_STATUS_IS_OK(status)) {
1739                 return status;
1740         }
1741
1742         if (DEBUGLEVEL >= 10) {
1743                 NDR_PRINT_OUT_DEBUG(PNP_HwProfFlags, &r);
1744         }
1745
1746         if (NT_STATUS_IS_ERR(status)) {
1747                 return status;
1748         }
1749
1750         /* Return variables */
1751         *unknown3 = *r.out.unknown3;
1752         if (unknown4 && r.out.unknown4) {
1753                 *unknown4 = *r.out.unknown4;
1754         }
1755         if (unknown5a && r.out.unknown5a) {
1756                 *unknown5a = *r.out.unknown5a;
1757         }
1758
1759         /* Return result */
1760         if (werror) {
1761                 *werror = r.out.result;
1762         }
1763
1764         return werror_to_ntstatus(r.out.result);
1765 }
1766
1767 NTSTATUS rpccli_PNP_GetHwProfInfo(struct rpc_pipe_client *cli,
1768                                   TALLOC_CTX *mem_ctx,
1769                                   uint32_t idx /* [in]  */,
1770                                   struct PNP_HwProfInfo *info /* [in,out] [ref] */,
1771                                   uint32_t size /* [in]  */,
1772                                   uint32_t flags /* [in]  */,
1773                                   WERROR *werror)
1774 {
1775         struct PNP_GetHwProfInfo r;
1776         NTSTATUS status;
1777
1778         /* In parameters */
1779         r.in.idx = idx;
1780         r.in.info = info;
1781         r.in.size = size;
1782         r.in.flags = flags;
1783
1784         if (DEBUGLEVEL >= 10) {
1785                 NDR_PRINT_IN_DEBUG(PNP_GetHwProfInfo, &r);
1786         }
1787
1788         status = cli_do_rpc_ndr(cli,
1789                                 mem_ctx,
1790                                 PI_NTSVCS,
1791                                 &ndr_table_ntsvcs,
1792                                 NDR_PNP_GETHWPROFINFO,
1793                                 &r);
1794
1795         if (!NT_STATUS_IS_OK(status)) {
1796                 return status;
1797         }
1798
1799         if (DEBUGLEVEL >= 10) {
1800                 NDR_PRINT_OUT_DEBUG(PNP_GetHwProfInfo, &r);
1801         }
1802
1803         if (NT_STATUS_IS_ERR(status)) {
1804                 return status;
1805         }
1806
1807         /* Return variables */
1808         *info = *r.out.info;
1809
1810         /* Return result */
1811         if (werror) {
1812                 *werror = r.out.result;
1813         }
1814
1815         return werror_to_ntstatus(r.out.result);
1816 }
1817
1818 NTSTATUS rpccli_PNP_AddEmptyLogConf(struct rpc_pipe_client *cli,
1819                                     TALLOC_CTX *mem_ctx,
1820                                     WERROR *werror)
1821 {
1822         struct PNP_AddEmptyLogConf r;
1823         NTSTATUS status;
1824
1825         /* In parameters */
1826
1827         if (DEBUGLEVEL >= 10) {
1828                 NDR_PRINT_IN_DEBUG(PNP_AddEmptyLogConf, &r);
1829         }
1830
1831         status = cli_do_rpc_ndr(cli,
1832                                 mem_ctx,
1833                                 PI_NTSVCS,
1834                                 &ndr_table_ntsvcs,
1835                                 NDR_PNP_ADDEMPTYLOGCONF,
1836                                 &r);
1837
1838         if (!NT_STATUS_IS_OK(status)) {
1839                 return status;
1840         }
1841
1842         if (DEBUGLEVEL >= 10) {
1843                 NDR_PRINT_OUT_DEBUG(PNP_AddEmptyLogConf, &r);
1844         }
1845
1846         if (NT_STATUS_IS_ERR(status)) {
1847                 return status;
1848         }
1849
1850         /* Return variables */
1851
1852         /* Return result */
1853         if (werror) {
1854                 *werror = r.out.result;
1855         }
1856
1857         return werror_to_ntstatus(r.out.result);
1858 }
1859
1860 NTSTATUS rpccli_PNP_FreeLogConf(struct rpc_pipe_client *cli,
1861                                 TALLOC_CTX *mem_ctx,
1862                                 WERROR *werror)
1863 {
1864         struct PNP_FreeLogConf r;
1865         NTSTATUS status;
1866
1867         /* In parameters */
1868
1869         if (DEBUGLEVEL >= 10) {
1870                 NDR_PRINT_IN_DEBUG(PNP_FreeLogConf, &r);
1871         }
1872
1873         status = cli_do_rpc_ndr(cli,
1874                                 mem_ctx,
1875                                 PI_NTSVCS,
1876                                 &ndr_table_ntsvcs,
1877                                 NDR_PNP_FREELOGCONF,
1878                                 &r);
1879
1880         if (!NT_STATUS_IS_OK(status)) {
1881                 return status;
1882         }
1883
1884         if (DEBUGLEVEL >= 10) {
1885                 NDR_PRINT_OUT_DEBUG(PNP_FreeLogConf, &r);
1886         }
1887
1888         if (NT_STATUS_IS_ERR(status)) {
1889                 return status;
1890         }
1891
1892         /* Return variables */
1893
1894         /* Return result */
1895         if (werror) {
1896                 *werror = r.out.result;
1897         }
1898
1899         return werror_to_ntstatus(r.out.result);
1900 }
1901
1902 NTSTATUS rpccli_PNP_GetFirstLogConf(struct rpc_pipe_client *cli,
1903                                     TALLOC_CTX *mem_ctx,
1904                                     WERROR *werror)
1905 {
1906         struct PNP_GetFirstLogConf r;
1907         NTSTATUS status;
1908
1909         /* In parameters */
1910
1911         if (DEBUGLEVEL >= 10) {
1912                 NDR_PRINT_IN_DEBUG(PNP_GetFirstLogConf, &r);
1913         }
1914
1915         status = cli_do_rpc_ndr(cli,
1916                                 mem_ctx,
1917                                 PI_NTSVCS,
1918                                 &ndr_table_ntsvcs,
1919                                 NDR_PNP_GETFIRSTLOGCONF,
1920                                 &r);
1921
1922         if (!NT_STATUS_IS_OK(status)) {
1923                 return status;
1924         }
1925
1926         if (DEBUGLEVEL >= 10) {
1927                 NDR_PRINT_OUT_DEBUG(PNP_GetFirstLogConf, &r);
1928         }
1929
1930         if (NT_STATUS_IS_ERR(status)) {
1931                 return status;
1932         }
1933
1934         /* Return variables */
1935
1936         /* Return result */
1937         if (werror) {
1938                 *werror = r.out.result;
1939         }
1940
1941         return werror_to_ntstatus(r.out.result);
1942 }
1943
1944 NTSTATUS rpccli_PNP_GetNextLogConf(struct rpc_pipe_client *cli,
1945                                    TALLOC_CTX *mem_ctx,
1946                                    WERROR *werror)
1947 {
1948         struct PNP_GetNextLogConf r;
1949         NTSTATUS status;
1950
1951         /* In parameters */
1952
1953         if (DEBUGLEVEL >= 10) {
1954                 NDR_PRINT_IN_DEBUG(PNP_GetNextLogConf, &r);
1955         }
1956
1957         status = cli_do_rpc_ndr(cli,
1958                                 mem_ctx,
1959                                 PI_NTSVCS,
1960                                 &ndr_table_ntsvcs,
1961                                 NDR_PNP_GETNEXTLOGCONF,
1962                                 &r);
1963
1964         if (!NT_STATUS_IS_OK(status)) {
1965                 return status;
1966         }
1967
1968         if (DEBUGLEVEL >= 10) {
1969                 NDR_PRINT_OUT_DEBUG(PNP_GetNextLogConf, &r);
1970         }
1971
1972         if (NT_STATUS_IS_ERR(status)) {
1973                 return status;
1974         }
1975
1976         /* Return variables */
1977
1978         /* Return result */
1979         if (werror) {
1980                 *werror = r.out.result;
1981         }
1982
1983         return werror_to_ntstatus(r.out.result);
1984 }
1985
1986 NTSTATUS rpccli_PNP_GetLogConfPriority(struct rpc_pipe_client *cli,
1987                                        TALLOC_CTX *mem_ctx,
1988                                        WERROR *werror)
1989 {
1990         struct PNP_GetLogConfPriority r;
1991         NTSTATUS status;
1992
1993         /* In parameters */
1994
1995         if (DEBUGLEVEL >= 10) {
1996                 NDR_PRINT_IN_DEBUG(PNP_GetLogConfPriority, &r);
1997         }
1998
1999         status = cli_do_rpc_ndr(cli,
2000                                 mem_ctx,
2001                                 PI_NTSVCS,
2002                                 &ndr_table_ntsvcs,
2003                                 NDR_PNP_GETLOGCONFPRIORITY,
2004                                 &r);
2005
2006         if (!NT_STATUS_IS_OK(status)) {
2007                 return status;
2008         }
2009
2010         if (DEBUGLEVEL >= 10) {
2011                 NDR_PRINT_OUT_DEBUG(PNP_GetLogConfPriority, &r);
2012         }
2013
2014         if (NT_STATUS_IS_ERR(status)) {
2015                 return status;
2016         }
2017
2018         /* Return variables */
2019
2020         /* Return result */
2021         if (werror) {
2022                 *werror = r.out.result;
2023         }
2024
2025         return werror_to_ntstatus(r.out.result);
2026 }
2027
2028 NTSTATUS rpccli_PNP_AddResDes(struct rpc_pipe_client *cli,
2029                               TALLOC_CTX *mem_ctx,
2030                               WERROR *werror)
2031 {
2032         struct PNP_AddResDes r;
2033         NTSTATUS status;
2034
2035         /* In parameters */
2036
2037         if (DEBUGLEVEL >= 10) {
2038                 NDR_PRINT_IN_DEBUG(PNP_AddResDes, &r);
2039         }
2040
2041         status = cli_do_rpc_ndr(cli,
2042                                 mem_ctx,
2043                                 PI_NTSVCS,
2044                                 &ndr_table_ntsvcs,
2045                                 NDR_PNP_ADDRESDES,
2046                                 &r);
2047
2048         if (!NT_STATUS_IS_OK(status)) {
2049                 return status;
2050         }
2051
2052         if (DEBUGLEVEL >= 10) {
2053                 NDR_PRINT_OUT_DEBUG(PNP_AddResDes, &r);
2054         }
2055
2056         if (NT_STATUS_IS_ERR(status)) {
2057                 return status;
2058         }
2059
2060         /* Return variables */
2061
2062         /* Return result */
2063         if (werror) {
2064                 *werror = r.out.result;
2065         }
2066
2067         return werror_to_ntstatus(r.out.result);
2068 }
2069
2070 NTSTATUS rpccli_PNP_FreeResDes(struct rpc_pipe_client *cli,
2071                                TALLOC_CTX *mem_ctx,
2072                                WERROR *werror)
2073 {
2074         struct PNP_FreeResDes r;
2075         NTSTATUS status;
2076
2077         /* In parameters */
2078
2079         if (DEBUGLEVEL >= 10) {
2080                 NDR_PRINT_IN_DEBUG(PNP_FreeResDes, &r);
2081         }
2082
2083         status = cli_do_rpc_ndr(cli,
2084                                 mem_ctx,
2085                                 PI_NTSVCS,
2086                                 &ndr_table_ntsvcs,
2087                                 NDR_PNP_FREERESDES,
2088                                 &r);
2089
2090         if (!NT_STATUS_IS_OK(status)) {
2091                 return status;
2092         }
2093
2094         if (DEBUGLEVEL >= 10) {
2095                 NDR_PRINT_OUT_DEBUG(PNP_FreeResDes, &r);
2096         }
2097
2098         if (NT_STATUS_IS_ERR(status)) {
2099                 return status;
2100         }
2101
2102         /* Return variables */
2103
2104         /* Return result */
2105         if (werror) {
2106                 *werror = r.out.result;
2107         }
2108
2109         return werror_to_ntstatus(r.out.result);
2110 }
2111
2112 NTSTATUS rpccli_PNP_GetNextResDes(struct rpc_pipe_client *cli,
2113                                   TALLOC_CTX *mem_ctx,
2114                                   WERROR *werror)
2115 {
2116         struct PNP_GetNextResDes r;
2117         NTSTATUS status;
2118
2119         /* In parameters */
2120
2121         if (DEBUGLEVEL >= 10) {
2122                 NDR_PRINT_IN_DEBUG(PNP_GetNextResDes, &r);
2123         }
2124
2125         status = cli_do_rpc_ndr(cli,
2126                                 mem_ctx,
2127                                 PI_NTSVCS,
2128                                 &ndr_table_ntsvcs,
2129                                 NDR_PNP_GETNEXTRESDES,
2130                                 &r);
2131
2132         if (!NT_STATUS_IS_OK(status)) {
2133                 return status;
2134         }
2135
2136         if (DEBUGLEVEL >= 10) {
2137                 NDR_PRINT_OUT_DEBUG(PNP_GetNextResDes, &r);
2138         }
2139
2140         if (NT_STATUS_IS_ERR(status)) {
2141                 return status;
2142         }
2143
2144         /* Return variables */
2145
2146         /* Return result */
2147         if (werror) {
2148                 *werror = r.out.result;
2149         }
2150
2151         return werror_to_ntstatus(r.out.result);
2152 }
2153
2154 NTSTATUS rpccli_PNP_GetResDesData(struct rpc_pipe_client *cli,
2155                                   TALLOC_CTX *mem_ctx,
2156                                   WERROR *werror)
2157 {
2158         struct PNP_GetResDesData r;
2159         NTSTATUS status;
2160
2161         /* In parameters */
2162
2163         if (DEBUGLEVEL >= 10) {
2164                 NDR_PRINT_IN_DEBUG(PNP_GetResDesData, &r);
2165         }
2166
2167         status = cli_do_rpc_ndr(cli,
2168                                 mem_ctx,
2169                                 PI_NTSVCS,
2170                                 &ndr_table_ntsvcs,
2171                                 NDR_PNP_GETRESDESDATA,
2172                                 &r);
2173
2174         if (!NT_STATUS_IS_OK(status)) {
2175                 return status;
2176         }
2177
2178         if (DEBUGLEVEL >= 10) {
2179                 NDR_PRINT_OUT_DEBUG(PNP_GetResDesData, &r);
2180         }
2181
2182         if (NT_STATUS_IS_ERR(status)) {
2183                 return status;
2184         }
2185
2186         /* Return variables */
2187
2188         /* Return result */
2189         if (werror) {
2190                 *werror = r.out.result;
2191         }
2192
2193         return werror_to_ntstatus(r.out.result);
2194 }
2195
2196 NTSTATUS rpccli_PNP_GetResDesDataSize(struct rpc_pipe_client *cli,
2197                                       TALLOC_CTX *mem_ctx,
2198                                       WERROR *werror)
2199 {
2200         struct PNP_GetResDesDataSize r;
2201         NTSTATUS status;
2202
2203         /* In parameters */
2204
2205         if (DEBUGLEVEL >= 10) {
2206                 NDR_PRINT_IN_DEBUG(PNP_GetResDesDataSize, &r);
2207         }
2208
2209         status = cli_do_rpc_ndr(cli,
2210                                 mem_ctx,
2211                                 PI_NTSVCS,
2212                                 &ndr_table_ntsvcs,
2213                                 NDR_PNP_GETRESDESDATASIZE,
2214                                 &r);
2215
2216         if (!NT_STATUS_IS_OK(status)) {
2217                 return status;
2218         }
2219
2220         if (DEBUGLEVEL >= 10) {
2221                 NDR_PRINT_OUT_DEBUG(PNP_GetResDesDataSize, &r);
2222         }
2223
2224         if (NT_STATUS_IS_ERR(status)) {
2225                 return status;
2226         }
2227
2228         /* Return variables */
2229
2230         /* Return result */
2231         if (werror) {
2232                 *werror = r.out.result;
2233         }
2234
2235         return werror_to_ntstatus(r.out.result);
2236 }
2237
2238 NTSTATUS rpccli_PNP_ModifyResDes(struct rpc_pipe_client *cli,
2239                                  TALLOC_CTX *mem_ctx,
2240                                  WERROR *werror)
2241 {
2242         struct PNP_ModifyResDes r;
2243         NTSTATUS status;
2244
2245         /* In parameters */
2246
2247         if (DEBUGLEVEL >= 10) {
2248                 NDR_PRINT_IN_DEBUG(PNP_ModifyResDes, &r);
2249         }
2250
2251         status = cli_do_rpc_ndr(cli,
2252                                 mem_ctx,
2253                                 PI_NTSVCS,
2254                                 &ndr_table_ntsvcs,
2255                                 NDR_PNP_MODIFYRESDES,
2256                                 &r);
2257
2258         if (!NT_STATUS_IS_OK(status)) {
2259                 return status;
2260         }
2261
2262         if (DEBUGLEVEL >= 10) {
2263                 NDR_PRINT_OUT_DEBUG(PNP_ModifyResDes, &r);
2264         }
2265
2266         if (NT_STATUS_IS_ERR(status)) {
2267                 return status;
2268         }
2269
2270         /* Return variables */
2271
2272         /* Return result */
2273         if (werror) {
2274                 *werror = r.out.result;
2275         }
2276
2277         return werror_to_ntstatus(r.out.result);
2278 }
2279
2280 NTSTATUS rpccli_PNP_DetectResourceLimit(struct rpc_pipe_client *cli,
2281                                         TALLOC_CTX *mem_ctx,
2282                                         WERROR *werror)
2283 {
2284         struct PNP_DetectResourceLimit r;
2285         NTSTATUS status;
2286
2287         /* In parameters */
2288
2289         if (DEBUGLEVEL >= 10) {
2290                 NDR_PRINT_IN_DEBUG(PNP_DetectResourceLimit, &r);
2291         }
2292
2293         status = cli_do_rpc_ndr(cli,
2294                                 mem_ctx,
2295                                 PI_NTSVCS,
2296                                 &ndr_table_ntsvcs,
2297                                 NDR_PNP_DETECTRESOURCELIMIT,
2298                                 &r);
2299
2300         if (!NT_STATUS_IS_OK(status)) {
2301                 return status;
2302         }
2303
2304         if (DEBUGLEVEL >= 10) {
2305                 NDR_PRINT_OUT_DEBUG(PNP_DetectResourceLimit, &r);
2306         }
2307
2308         if (NT_STATUS_IS_ERR(status)) {
2309                 return status;
2310         }
2311
2312         /* Return variables */
2313
2314         /* Return result */
2315         if (werror) {
2316                 *werror = r.out.result;
2317         }
2318
2319         return werror_to_ntstatus(r.out.result);
2320 }
2321
2322 NTSTATUS rpccli_PNP_QueryResConfList(struct rpc_pipe_client *cli,
2323                                      TALLOC_CTX *mem_ctx,
2324                                      WERROR *werror)
2325 {
2326         struct PNP_QueryResConfList r;
2327         NTSTATUS status;
2328
2329         /* In parameters */
2330
2331         if (DEBUGLEVEL >= 10) {
2332                 NDR_PRINT_IN_DEBUG(PNP_QueryResConfList, &r);
2333         }
2334
2335         status = cli_do_rpc_ndr(cli,
2336                                 mem_ctx,
2337                                 PI_NTSVCS,
2338                                 &ndr_table_ntsvcs,
2339                                 NDR_PNP_QUERYRESCONFLIST,
2340                                 &r);
2341
2342         if (!NT_STATUS_IS_OK(status)) {
2343                 return status;
2344         }
2345
2346         if (DEBUGLEVEL >= 10) {
2347                 NDR_PRINT_OUT_DEBUG(PNP_QueryResConfList, &r);
2348         }
2349
2350         if (NT_STATUS_IS_ERR(status)) {
2351                 return status;
2352         }
2353
2354         /* Return variables */
2355
2356         /* Return result */
2357         if (werror) {
2358                 *werror = r.out.result;
2359         }
2360
2361         return werror_to_ntstatus(r.out.result);
2362 }
2363
2364 NTSTATUS rpccli_PNP_SetHwProf(struct rpc_pipe_client *cli,
2365                               TALLOC_CTX *mem_ctx,
2366                               WERROR *werror)
2367 {
2368         struct PNP_SetHwProf r;
2369         NTSTATUS status;
2370
2371         /* In parameters */
2372
2373         if (DEBUGLEVEL >= 10) {
2374                 NDR_PRINT_IN_DEBUG(PNP_SetHwProf, &r);
2375         }
2376
2377         status = cli_do_rpc_ndr(cli,
2378                                 mem_ctx,
2379                                 PI_NTSVCS,
2380                                 &ndr_table_ntsvcs,
2381                                 NDR_PNP_SETHWPROF,
2382                                 &r);
2383
2384         if (!NT_STATUS_IS_OK(status)) {
2385                 return status;
2386         }
2387
2388         if (DEBUGLEVEL >= 10) {
2389                 NDR_PRINT_OUT_DEBUG(PNP_SetHwProf, &r);
2390         }
2391
2392         if (NT_STATUS_IS_ERR(status)) {
2393                 return status;
2394         }
2395
2396         /* Return variables */
2397
2398         /* Return result */
2399         if (werror) {
2400                 *werror = r.out.result;
2401         }
2402
2403         return werror_to_ntstatus(r.out.result);
2404 }
2405
2406 NTSTATUS rpccli_PNP_QueryArbitratorFreeData(struct rpc_pipe_client *cli,
2407                                             TALLOC_CTX *mem_ctx,
2408                                             WERROR *werror)
2409 {
2410         struct PNP_QueryArbitratorFreeData r;
2411         NTSTATUS status;
2412
2413         /* In parameters */
2414
2415         if (DEBUGLEVEL >= 10) {
2416                 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeData, &r);
2417         }
2418
2419         status = cli_do_rpc_ndr(cli,
2420                                 mem_ctx,
2421                                 PI_NTSVCS,
2422                                 &ndr_table_ntsvcs,
2423                                 NDR_PNP_QUERYARBITRATORFREEDATA,
2424                                 &r);
2425
2426         if (!NT_STATUS_IS_OK(status)) {
2427                 return status;
2428         }
2429
2430         if (DEBUGLEVEL >= 10) {
2431                 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeData, &r);
2432         }
2433
2434         if (NT_STATUS_IS_ERR(status)) {
2435                 return status;
2436         }
2437
2438         /* Return variables */
2439
2440         /* Return result */
2441         if (werror) {
2442                 *werror = r.out.result;
2443         }
2444
2445         return werror_to_ntstatus(r.out.result);
2446 }
2447
2448 NTSTATUS rpccli_PNP_QueryArbitratorFreeSize(struct rpc_pipe_client *cli,
2449                                             TALLOC_CTX *mem_ctx,
2450                                             WERROR *werror)
2451 {
2452         struct PNP_QueryArbitratorFreeSize r;
2453         NTSTATUS status;
2454
2455         /* In parameters */
2456
2457         if (DEBUGLEVEL >= 10) {
2458                 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeSize, &r);
2459         }
2460
2461         status = cli_do_rpc_ndr(cli,
2462                                 mem_ctx,
2463                                 PI_NTSVCS,
2464                                 &ndr_table_ntsvcs,
2465                                 NDR_PNP_QUERYARBITRATORFREESIZE,
2466                                 &r);
2467
2468         if (!NT_STATUS_IS_OK(status)) {
2469                 return status;
2470         }
2471
2472         if (DEBUGLEVEL >= 10) {
2473                 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeSize, &r);
2474         }
2475
2476         if (NT_STATUS_IS_ERR(status)) {
2477                 return status;
2478         }
2479
2480         /* Return variables */
2481
2482         /* Return result */
2483         if (werror) {
2484                 *werror = r.out.result;
2485         }
2486
2487         return werror_to_ntstatus(r.out.result);
2488 }
2489
2490 NTSTATUS rpccli_PNP_RunDetection(struct rpc_pipe_client *cli,
2491                                  TALLOC_CTX *mem_ctx,
2492                                  WERROR *werror)
2493 {
2494         struct PNP_RunDetection r;
2495         NTSTATUS status;
2496
2497         /* In parameters */
2498
2499         if (DEBUGLEVEL >= 10) {
2500                 NDR_PRINT_IN_DEBUG(PNP_RunDetection, &r);
2501         }
2502
2503         status = cli_do_rpc_ndr(cli,
2504                                 mem_ctx,
2505                                 PI_NTSVCS,
2506                                 &ndr_table_ntsvcs,
2507                                 NDR_PNP_RUNDETECTION,
2508                                 &r);
2509
2510         if (!NT_STATUS_IS_OK(status)) {
2511                 return status;
2512         }
2513
2514         if (DEBUGLEVEL >= 10) {
2515                 NDR_PRINT_OUT_DEBUG(PNP_RunDetection, &r);
2516         }
2517
2518         if (NT_STATUS_IS_ERR(status)) {
2519                 return status;
2520         }
2521
2522         /* Return variables */
2523
2524         /* Return result */
2525         if (werror) {
2526                 *werror = r.out.result;
2527         }
2528
2529         return werror_to_ntstatus(r.out.result);
2530 }
2531
2532 NTSTATUS rpccli_PNP_RegisterNotification(struct rpc_pipe_client *cli,
2533                                          TALLOC_CTX *mem_ctx,
2534                                          WERROR *werror)
2535 {
2536         struct PNP_RegisterNotification r;
2537         NTSTATUS status;
2538
2539         /* In parameters */
2540
2541         if (DEBUGLEVEL >= 10) {
2542                 NDR_PRINT_IN_DEBUG(PNP_RegisterNotification, &r);
2543         }
2544
2545         status = cli_do_rpc_ndr(cli,
2546                                 mem_ctx,
2547                                 PI_NTSVCS,
2548                                 &ndr_table_ntsvcs,
2549                                 NDR_PNP_REGISTERNOTIFICATION,
2550                                 &r);
2551
2552         if (!NT_STATUS_IS_OK(status)) {
2553                 return status;
2554         }
2555
2556         if (DEBUGLEVEL >= 10) {
2557                 NDR_PRINT_OUT_DEBUG(PNP_RegisterNotification, &r);
2558         }
2559
2560         if (NT_STATUS_IS_ERR(status)) {
2561                 return status;
2562         }
2563
2564         /* Return variables */
2565
2566         /* Return result */
2567         if (werror) {
2568                 *werror = r.out.result;
2569         }
2570
2571         return werror_to_ntstatus(r.out.result);
2572 }
2573
2574 NTSTATUS rpccli_PNP_UnregisterNotification(struct rpc_pipe_client *cli,
2575                                            TALLOC_CTX *mem_ctx,
2576                                            WERROR *werror)
2577 {
2578         struct PNP_UnregisterNotification r;
2579         NTSTATUS status;
2580
2581         /* In parameters */
2582
2583         if (DEBUGLEVEL >= 10) {
2584                 NDR_PRINT_IN_DEBUG(PNP_UnregisterNotification, &r);
2585         }
2586
2587         status = cli_do_rpc_ndr(cli,
2588                                 mem_ctx,
2589                                 PI_NTSVCS,
2590                                 &ndr_table_ntsvcs,
2591                                 NDR_PNP_UNREGISTERNOTIFICATION,
2592                                 &r);
2593
2594         if (!NT_STATUS_IS_OK(status)) {
2595                 return status;
2596         }
2597
2598         if (DEBUGLEVEL >= 10) {
2599                 NDR_PRINT_OUT_DEBUG(PNP_UnregisterNotification, &r);
2600         }
2601
2602         if (NT_STATUS_IS_ERR(status)) {
2603                 return status;
2604         }
2605
2606         /* Return variables */
2607
2608         /* Return result */
2609         if (werror) {
2610                 *werror = r.out.result;
2611         }
2612
2613         return werror_to_ntstatus(r.out.result);
2614 }
2615
2616 NTSTATUS rpccli_PNP_GetCustomDevProp(struct rpc_pipe_client *cli,
2617                                      TALLOC_CTX *mem_ctx,
2618                                      WERROR *werror)
2619 {
2620         struct PNP_GetCustomDevProp r;
2621         NTSTATUS status;
2622
2623         /* In parameters */
2624
2625         if (DEBUGLEVEL >= 10) {
2626                 NDR_PRINT_IN_DEBUG(PNP_GetCustomDevProp, &r);
2627         }
2628
2629         status = cli_do_rpc_ndr(cli,
2630                                 mem_ctx,
2631                                 PI_NTSVCS,
2632                                 &ndr_table_ntsvcs,
2633                                 NDR_PNP_GETCUSTOMDEVPROP,
2634                                 &r);
2635
2636         if (!NT_STATUS_IS_OK(status)) {
2637                 return status;
2638         }
2639
2640         if (DEBUGLEVEL >= 10) {
2641                 NDR_PRINT_OUT_DEBUG(PNP_GetCustomDevProp, &r);
2642         }
2643
2644         if (NT_STATUS_IS_ERR(status)) {
2645                 return status;
2646         }
2647
2648         /* Return variables */
2649
2650         /* Return result */
2651         if (werror) {
2652                 *werror = r.out.result;
2653         }
2654
2655         return werror_to_ntstatus(r.out.result);
2656 }
2657
2658 NTSTATUS rpccli_PNP_GetVersionInternal(struct rpc_pipe_client *cli,
2659                                        TALLOC_CTX *mem_ctx,
2660                                        WERROR *werror)
2661 {
2662         struct PNP_GetVersionInternal r;
2663         NTSTATUS status;
2664
2665         /* In parameters */
2666
2667         if (DEBUGLEVEL >= 10) {
2668                 NDR_PRINT_IN_DEBUG(PNP_GetVersionInternal, &r);
2669         }
2670
2671         status = cli_do_rpc_ndr(cli,
2672                                 mem_ctx,
2673                                 PI_NTSVCS,
2674                                 &ndr_table_ntsvcs,
2675                                 NDR_PNP_GETVERSIONINTERNAL,
2676                                 &r);
2677
2678         if (!NT_STATUS_IS_OK(status)) {
2679                 return status;
2680         }
2681
2682         if (DEBUGLEVEL >= 10) {
2683                 NDR_PRINT_OUT_DEBUG(PNP_GetVersionInternal, &r);
2684         }
2685
2686         if (NT_STATUS_IS_ERR(status)) {
2687                 return status;
2688         }
2689
2690         /* Return variables */
2691
2692         /* Return result */
2693         if (werror) {
2694                 *werror = r.out.result;
2695         }
2696
2697         return werror_to_ntstatus(r.out.result);
2698 }
2699
2700 NTSTATUS rpccli_PNP_GetBlockedDriverInfo(struct rpc_pipe_client *cli,
2701                                          TALLOC_CTX *mem_ctx,
2702                                          WERROR *werror)
2703 {
2704         struct PNP_GetBlockedDriverInfo r;
2705         NTSTATUS status;
2706
2707         /* In parameters */
2708
2709         if (DEBUGLEVEL >= 10) {
2710                 NDR_PRINT_IN_DEBUG(PNP_GetBlockedDriverInfo, &r);
2711         }
2712
2713         status = cli_do_rpc_ndr(cli,
2714                                 mem_ctx,
2715                                 PI_NTSVCS,
2716                                 &ndr_table_ntsvcs,
2717                                 NDR_PNP_GETBLOCKEDDRIVERINFO,
2718                                 &r);
2719
2720         if (!NT_STATUS_IS_OK(status)) {
2721                 return status;
2722         }
2723
2724         if (DEBUGLEVEL >= 10) {
2725                 NDR_PRINT_OUT_DEBUG(PNP_GetBlockedDriverInfo, &r);
2726         }
2727
2728         if (NT_STATUS_IS_ERR(status)) {
2729                 return status;
2730         }
2731
2732         /* Return variables */
2733
2734         /* Return result */
2735         if (werror) {
2736                 *werror = r.out.result;
2737         }
2738
2739         return werror_to_ntstatus(r.out.result);
2740 }
2741
2742 NTSTATUS rpccli_PNP_GetServerSideDeviceInstallFlags(struct rpc_pipe_client *cli,
2743                                                     TALLOC_CTX *mem_ctx,
2744                                                     WERROR *werror)
2745 {
2746         struct PNP_GetServerSideDeviceInstallFlags r;
2747         NTSTATUS status;
2748
2749         /* In parameters */
2750
2751         if (DEBUGLEVEL >= 10) {
2752                 NDR_PRINT_IN_DEBUG(PNP_GetServerSideDeviceInstallFlags, &r);
2753         }
2754
2755         status = cli_do_rpc_ndr(cli,
2756                                 mem_ctx,
2757                                 PI_NTSVCS,
2758                                 &ndr_table_ntsvcs,
2759                                 NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS,
2760                                 &r);
2761
2762         if (!NT_STATUS_IS_OK(status)) {
2763                 return status;
2764         }
2765
2766         if (DEBUGLEVEL >= 10) {
2767                 NDR_PRINT_OUT_DEBUG(PNP_GetServerSideDeviceInstallFlags, &r);
2768         }
2769
2770         if (NT_STATUS_IS_ERR(status)) {
2771                 return status;
2772         }
2773
2774         /* Return variables */
2775
2776         /* Return result */
2777         if (werror) {
2778                 *werror = r.out.result;
2779         }
2780
2781         return werror_to_ntstatus(r.out.result);
2782 }
2783