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