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 struct rpccli_PNP_Disconnect_state {
  10         struct PNP_Disconnect orig;
  11         struct PNP_Disconnect tmp;
  12         TALLOC_CTX *out_mem_ctx;
  13         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
  14 };
  15
  16 static void rpccli_PNP_Disconnect_done(struct tevent_req *subreq);
  17
  18 struct tevent_req *rpccli_PNP_Disconnect_send(TALLOC_CTX *mem_ctx,
  19                                               struct tevent_context *ev,
  20                                               struct rpc_pipe_client *cli)
  21 {
  22         struct tevent_req *req;
  23         struct rpccli_PNP_Disconnect_state *state;
  24         struct tevent_req *subreq;
  25
  26         req = tevent_req_create(mem_ctx, &state,
  27                                 struct rpccli_PNP_Disconnect_state);
  28         if (req == NULL) {
  29                 return NULL;
  30         }
  31         state->out_mem_ctx = NULL;
  32         state->dispatch_recv = cli->dispatch_recv;
  33
  34         /* In parameters */
  35
  36         /* Out parameters */
  37
  38         /* Result */
  39         ZERO_STRUCT(state->orig.out.result);
  40
  41         if (DEBUGLEVEL >= 10) {
  42                 NDR_PRINT_IN_DEBUG(PNP_Disconnect, &state->orig);
  43         }
  44
  45         /* make a temporary copy, that we pass to the dispatch function */
  46         state->tmp = state->orig;
  47
  48         subreq = cli->dispatch_send(state, ev, cli,
  49                                     &ndr_table_ntsvcs,
  50                                     NDR_PNP_DISCONNECT,
  51                                     &state->tmp);
  52         if (tevent_req_nomem(subreq, req)) {
  53                 return tevent_req_post(req, ev);
  54         }
  55         tevent_req_set_callback(subreq, rpccli_PNP_Disconnect_done, req);
  56         return req;
  57 }
  58
  59 static void rpccli_PNP_Disconnect_done(struct tevent_req *subreq)
  60 {
  61         struct tevent_req *req = tevent_req_callback_data(
  62                 subreq, struct tevent_req);
  63         struct rpccli_PNP_Disconnect_state *state = tevent_req_data(
  64                 req, struct rpccli_PNP_Disconnect_state);
  65         NTSTATUS status;
  66         TALLOC_CTX *mem_ctx;
  67
  68         if (state->out_mem_ctx) {
  69                 mem_ctx = state->out_mem_ctx;
  70         } else {
  71                 mem_ctx = state;
  72         }
  73
  74         status = state->dispatch_recv(subreq, mem_ctx);
  75         TALLOC_FREE(subreq);
  76         if (!NT_STATUS_IS_OK(status)) {
  77                 tevent_req_nterror(req, status);
  78                 return;
  79         }
  80
  81         /* Copy out parameters */
  82
  83         /* Copy result */
  84         state->orig.out.result = state->tmp.out.result;
  85
  86         /* Reset temporary structure */
  87         ZERO_STRUCT(state->tmp);
  88
  89         if (DEBUGLEVEL >= 10) {
  90                 NDR_PRINT_OUT_DEBUG(PNP_Disconnect, &state->orig);
  91         }
  92
  93         tevent_req_done(req);
  94 }
  95
  96 NTSTATUS rpccli_PNP_Disconnect_recv(struct tevent_req *req,
  97                                     TALLOC_CTX *mem_ctx,
  98                                     WERROR *result)
  99 {
 100         struct rpccli_PNP_Disconnect_state *state = tevent_req_data(
 101                 req, struct rpccli_PNP_Disconnect_state);
 102         NTSTATUS status;
 103
 104         if (tevent_req_is_nterror(req, &status)) {
 105                 tevent_req_received(req);
 106                 return status;
 107         }
 108
 109         /* Steal possbile out parameters to the callers context */
 110         talloc_steal(mem_ctx, state->out_mem_ctx);
 111
 112         /* Return result */
 113         *result = state->orig.out.result;
 114
 115         tevent_req_received(req);
 116         return NT_STATUS_OK;
 117 }
 118
 119 NTSTATUS rpccli_PNP_Disconnect(struct rpc_pipe_client *cli,
 120                                TALLOC_CTX *mem_ctx,
 121                                WERROR *werror)
 122 {
 123         struct PNP_Disconnect r;
 124         NTSTATUS status;
 125
 126         /* In parameters */
 127
 128         if (DEBUGLEVEL >= 10) {
 129                 NDR_PRINT_IN_DEBUG(PNP_Disconnect, &r);
 130         }
 131
 132         status = cli->dispatch(cli,
 133                                 mem_ctx,
 134                                 &ndr_table_ntsvcs,
 135                                 NDR_PNP_DISCONNECT,
 136                                 &r);
 137
 138         if (!NT_STATUS_IS_OK(status)) {
 139                 return status;
 140         }
 141
 142         if (DEBUGLEVEL >= 10) {
 143                 NDR_PRINT_OUT_DEBUG(PNP_Disconnect, &r);
 144         }
 145
 146         if (NT_STATUS_IS_ERR(status)) {
 147                 return status;
 148         }
 149
 150         /* Return variables */
 151
 152         /* Return result */
 153         if (werror) {
 154                 *werror = r.out.result;
 155         }
 156
 157         return werror_to_ntstatus(r.out.result);
 158 }
 159
 160 struct rpccli_PNP_Connect_state {
 161         struct PNP_Connect orig;
 162         struct PNP_Connect tmp;
 163         TALLOC_CTX *out_mem_ctx;
 164         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 165 };
 166
 167 static void rpccli_PNP_Connect_done(struct tevent_req *subreq);
 168
 169 struct tevent_req *rpccli_PNP_Connect_send(TALLOC_CTX *mem_ctx,
 170                                            struct tevent_context *ev,
 171                                            struct rpc_pipe_client *cli)
 172 {
 173         struct tevent_req *req;
 174         struct rpccli_PNP_Connect_state *state;
 175         struct tevent_req *subreq;
 176
 177         req = tevent_req_create(mem_ctx, &state,
 178                                 struct rpccli_PNP_Connect_state);
 179         if (req == NULL) {
 180                 return NULL;
 181         }
 182         state->out_mem_ctx = NULL;
 183         state->dispatch_recv = cli->dispatch_recv;
 184
 185         /* In parameters */
 186
 187         /* Out parameters */
 188
 189         /* Result */
 190         ZERO_STRUCT(state->orig.out.result);
 191
 192         if (DEBUGLEVEL >= 10) {
 193                 NDR_PRINT_IN_DEBUG(PNP_Connect, &state->orig);
 194         }
 195
 196         /* make a temporary copy, that we pass to the dispatch function */
 197         state->tmp = state->orig;
 198
 199         subreq = cli->dispatch_send(state, ev, cli,
 200                                     &ndr_table_ntsvcs,
 201                                     NDR_PNP_CONNECT,
 202                                     &state->tmp);
 203         if (tevent_req_nomem(subreq, req)) {
 204                 return tevent_req_post(req, ev);
 205         }
 206         tevent_req_set_callback(subreq, rpccli_PNP_Connect_done, req);
 207         return req;
 208 }
 209
 210 static void rpccli_PNP_Connect_done(struct tevent_req *subreq)
 211 {
 212         struct tevent_req *req = tevent_req_callback_data(
 213                 subreq, struct tevent_req);
 214         struct rpccli_PNP_Connect_state *state = tevent_req_data(
 215                 req, struct rpccli_PNP_Connect_state);
 216         NTSTATUS status;
 217         TALLOC_CTX *mem_ctx;
 218
 219         if (state->out_mem_ctx) {
 220                 mem_ctx = state->out_mem_ctx;
 221         } else {
 222                 mem_ctx = state;
 223         }
 224
 225         status = state->dispatch_recv(subreq, mem_ctx);
 226         TALLOC_FREE(subreq);
 227         if (!NT_STATUS_IS_OK(status)) {
 228                 tevent_req_nterror(req, status);
 229                 return;
 230         }
 231
 232         /* Copy out parameters */
 233
 234         /* Copy result */
 235         state->orig.out.result = state->tmp.out.result;
 236
 237         /* Reset temporary structure */
 238         ZERO_STRUCT(state->tmp);
 239
 240         if (DEBUGLEVEL >= 10) {
 241                 NDR_PRINT_OUT_DEBUG(PNP_Connect, &state->orig);
 242         }
 243
 244         tevent_req_done(req);
 245 }
 246
 247 NTSTATUS rpccli_PNP_Connect_recv(struct tevent_req *req,
 248                                  TALLOC_CTX *mem_ctx,
 249                                  WERROR *result)
 250 {
 251         struct rpccli_PNP_Connect_state *state = tevent_req_data(
 252                 req, struct rpccli_PNP_Connect_state);
 253         NTSTATUS status;
 254
 255         if (tevent_req_is_nterror(req, &status)) {
 256                 tevent_req_received(req);
 257                 return status;
 258         }
 259
 260         /* Steal possbile out parameters to the callers context */
 261         talloc_steal(mem_ctx, state->out_mem_ctx);
 262
 263         /* Return result */
 264         *result = state->orig.out.result;
 265
 266         tevent_req_received(req);
 267         return NT_STATUS_OK;
 268 }
 269
 270 NTSTATUS rpccli_PNP_Connect(struct rpc_pipe_client *cli,
 271                             TALLOC_CTX *mem_ctx,
 272                             WERROR *werror)
 273 {
 274         struct PNP_Connect r;
 275         NTSTATUS status;
 276
 277         /* In parameters */
 278
 279         if (DEBUGLEVEL >= 10) {
 280                 NDR_PRINT_IN_DEBUG(PNP_Connect, &r);
 281         }
 282
 283         status = cli->dispatch(cli,
 284                                 mem_ctx,
 285                                 &ndr_table_ntsvcs,
 286                                 NDR_PNP_CONNECT,
 287                                 &r);
 288
 289         if (!NT_STATUS_IS_OK(status)) {
 290                 return status;
 291         }
 292
 293         if (DEBUGLEVEL >= 10) {
 294                 NDR_PRINT_OUT_DEBUG(PNP_Connect, &r);
 295         }
 296
 297         if (NT_STATUS_IS_ERR(status)) {
 298                 return status;
 299         }
 300
 301         /* Return variables */
 302
 303         /* Return result */
 304         if (werror) {
 305                 *werror = r.out.result;
 306         }
 307
 308         return werror_to_ntstatus(r.out.result);
 309 }
 310
 311 struct rpccli_PNP_GetVersion_state {
 312         struct PNP_GetVersion orig;
 313         struct PNP_GetVersion tmp;
 314         TALLOC_CTX *out_mem_ctx;
 315         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 316 };
 317
 318 static void rpccli_PNP_GetVersion_done(struct tevent_req *subreq);
 319
 320 struct tevent_req *rpccli_PNP_GetVersion_send(TALLOC_CTX *mem_ctx,
 321                                               struct tevent_context *ev,
 322                                               struct rpc_pipe_client *cli,
 323                                               uint16_t *_version /* [out] [ref] */)
 324 {
 325         struct tevent_req *req;
 326         struct rpccli_PNP_GetVersion_state *state;
 327         struct tevent_req *subreq;
 328
 329         req = tevent_req_create(mem_ctx, &state,
 330                                 struct rpccli_PNP_GetVersion_state);
 331         if (req == NULL) {
 332                 return NULL;
 333         }
 334         state->out_mem_ctx = NULL;
 335         state->dispatch_recv = cli->dispatch_recv;
 336
 337         /* In parameters */
 338
 339         /* Out parameters */
 340         state->orig.out.version = _version;
 341
 342         /* Result */
 343         ZERO_STRUCT(state->orig.out.result);
 344
 345         if (DEBUGLEVEL >= 10) {
 346                 NDR_PRINT_IN_DEBUG(PNP_GetVersion, &state->orig);
 347         }
 348
 349         state->out_mem_ctx = talloc_named_const(state, 0,
 350                              "rpccli_PNP_GetVersion_out_memory");
 351         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 352                 return tevent_req_post(req, ev);
 353         }
 354
 355         /* make a temporary copy, that we pass to the dispatch function */
 356         state->tmp = state->orig;
 357
 358         subreq = cli->dispatch_send(state, ev, cli,
 359                                     &ndr_table_ntsvcs,
 360                                     NDR_PNP_GETVERSION,
 361                                     &state->tmp);
 362         if (tevent_req_nomem(subreq, req)) {
 363                 return tevent_req_post(req, ev);
 364         }
 365         tevent_req_set_callback(subreq, rpccli_PNP_GetVersion_done, req);
 366         return req;
 367 }
 368
 369 static void rpccli_PNP_GetVersion_done(struct tevent_req *subreq)
 370 {
 371         struct tevent_req *req = tevent_req_callback_data(
 372                 subreq, struct tevent_req);
 373         struct rpccli_PNP_GetVersion_state *state = tevent_req_data(
 374                 req, struct rpccli_PNP_GetVersion_state);
 375         NTSTATUS status;
 376         TALLOC_CTX *mem_ctx;
 377
 378         if (state->out_mem_ctx) {
 379                 mem_ctx = state->out_mem_ctx;
 380         } else {
 381                 mem_ctx = state;
 382         }
 383
 384         status = state->dispatch_recv(subreq, mem_ctx);
 385         TALLOC_FREE(subreq);
 386         if (!NT_STATUS_IS_OK(status)) {
 387                 tevent_req_nterror(req, status);
 388                 return;
 389         }
 390
 391         /* Copy out parameters */
 392         *state->orig.out.version = *state->tmp.out.version;
 393
 394         /* Copy result */
 395         state->orig.out.result = state->tmp.out.result;
 396
 397         /* Reset temporary structure */
 398         ZERO_STRUCT(state->tmp);
 399
 400         if (DEBUGLEVEL >= 10) {
 401                 NDR_PRINT_OUT_DEBUG(PNP_GetVersion, &state->orig);
 402         }
 403
 404         tevent_req_done(req);
 405 }
 406
 407 NTSTATUS rpccli_PNP_GetVersion_recv(struct tevent_req *req,
 408                                     TALLOC_CTX *mem_ctx,
 409                                     WERROR *result)
 410 {
 411         struct rpccli_PNP_GetVersion_state *state = tevent_req_data(
 412                 req, struct rpccli_PNP_GetVersion_state);
 413         NTSTATUS status;
 414
 415         if (tevent_req_is_nterror(req, &status)) {
 416                 tevent_req_received(req);
 417                 return status;
 418         }
 419
 420         /* Steal possbile out parameters to the callers context */
 421         talloc_steal(mem_ctx, state->out_mem_ctx);
 422
 423         /* Return result */
 424         *result = state->orig.out.result;
 425
 426         tevent_req_received(req);
 427         return NT_STATUS_OK;
 428 }
 429
 430 NTSTATUS rpccli_PNP_GetVersion(struct rpc_pipe_client *cli,
 431                                TALLOC_CTX *mem_ctx,
 432                                uint16_t *version /* [out] [ref] */,
 433                                WERROR *werror)
 434 {
 435         struct PNP_GetVersion r;
 436         NTSTATUS status;
 437
 438         /* In parameters */
 439
 440         if (DEBUGLEVEL >= 10) {
 441                 NDR_PRINT_IN_DEBUG(PNP_GetVersion, &r);
 442         }
 443
 444         status = cli->dispatch(cli,
 445                                 mem_ctx,
 446                                 &ndr_table_ntsvcs,
 447                                 NDR_PNP_GETVERSION,
 448                                 &r);
 449
 450         if (!NT_STATUS_IS_OK(status)) {
 451                 return status;
 452         }
 453
 454         if (DEBUGLEVEL >= 10) {
 455                 NDR_PRINT_OUT_DEBUG(PNP_GetVersion, &r);
 456         }
 457
 458         if (NT_STATUS_IS_ERR(status)) {
 459                 return status;
 460         }
 461
 462         /* Return variables */
 463         *version = *r.out.version;
 464
 465         /* Return result */
 466         if (werror) {
 467                 *werror = r.out.result;
 468         }
 469
 470         return werror_to_ntstatus(r.out.result);
 471 }
 472
 473 struct rpccli_PNP_GetGlobalState_state {
 474         struct PNP_GetGlobalState orig;
 475         struct PNP_GetGlobalState tmp;
 476         TALLOC_CTX *out_mem_ctx;
 477         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 478 };
 479
 480 static void rpccli_PNP_GetGlobalState_done(struct tevent_req *subreq);
 481
 482 struct tevent_req *rpccli_PNP_GetGlobalState_send(TALLOC_CTX *mem_ctx,
 483                                                   struct tevent_context *ev,
 484                                                   struct rpc_pipe_client *cli)
 485 {
 486         struct tevent_req *req;
 487         struct rpccli_PNP_GetGlobalState_state *state;
 488         struct tevent_req *subreq;
 489
 490         req = tevent_req_create(mem_ctx, &state,
 491                                 struct rpccli_PNP_GetGlobalState_state);
 492         if (req == NULL) {
 493                 return NULL;
 494         }
 495         state->out_mem_ctx = NULL;
 496         state->dispatch_recv = cli->dispatch_recv;
 497
 498         /* In parameters */
 499
 500         /* Out parameters */
 501
 502         /* Result */
 503         ZERO_STRUCT(state->orig.out.result);
 504
 505         if (DEBUGLEVEL >= 10) {
 506                 NDR_PRINT_IN_DEBUG(PNP_GetGlobalState, &state->orig);
 507         }
 508
 509         /* make a temporary copy, that we pass to the dispatch function */
 510         state->tmp = state->orig;
 511
 512         subreq = cli->dispatch_send(state, ev, cli,
 513                                     &ndr_table_ntsvcs,
 514                                     NDR_PNP_GETGLOBALSTATE,
 515                                     &state->tmp);
 516         if (tevent_req_nomem(subreq, req)) {
 517                 return tevent_req_post(req, ev);
 518         }
 519         tevent_req_set_callback(subreq, rpccli_PNP_GetGlobalState_done, req);
 520         return req;
 521 }
 522
 523 static void rpccli_PNP_GetGlobalState_done(struct tevent_req *subreq)
 524 {
 525         struct tevent_req *req = tevent_req_callback_data(
 526                 subreq, struct tevent_req);
 527         struct rpccli_PNP_GetGlobalState_state *state = tevent_req_data(
 528                 req, struct rpccli_PNP_GetGlobalState_state);
 529         NTSTATUS status;
 530         TALLOC_CTX *mem_ctx;
 531
 532         if (state->out_mem_ctx) {
 533                 mem_ctx = state->out_mem_ctx;
 534         } else {
 535                 mem_ctx = state;
 536         }
 537
 538         status = state->dispatch_recv(subreq, mem_ctx);
 539         TALLOC_FREE(subreq);
 540         if (!NT_STATUS_IS_OK(status)) {
 541                 tevent_req_nterror(req, status);
 542                 return;
 543         }
 544
 545         /* Copy out parameters */
 546
 547         /* Copy result */
 548         state->orig.out.result = state->tmp.out.result;
 549
 550         /* Reset temporary structure */
 551         ZERO_STRUCT(state->tmp);
 552
 553         if (DEBUGLEVEL >= 10) {
 554                 NDR_PRINT_OUT_DEBUG(PNP_GetGlobalState, &state->orig);
 555         }
 556
 557         tevent_req_done(req);
 558 }
 559
 560 NTSTATUS rpccli_PNP_GetGlobalState_recv(struct tevent_req *req,
 561                                         TALLOC_CTX *mem_ctx,
 562                                         WERROR *result)
 563 {
 564         struct rpccli_PNP_GetGlobalState_state *state = tevent_req_data(
 565                 req, struct rpccli_PNP_GetGlobalState_state);
 566         NTSTATUS status;
 567
 568         if (tevent_req_is_nterror(req, &status)) {
 569                 tevent_req_received(req);
 570                 return status;
 571         }
 572
 573         /* Steal possbile out parameters to the callers context */
 574         talloc_steal(mem_ctx, state->out_mem_ctx);
 575
 576         /* Return result */
 577         *result = state->orig.out.result;
 578
 579         tevent_req_received(req);
 580         return NT_STATUS_OK;
 581 }
 582
 583 NTSTATUS rpccli_PNP_GetGlobalState(struct rpc_pipe_client *cli,
 584                                    TALLOC_CTX *mem_ctx,
 585                                    WERROR *werror)
 586 {
 587         struct PNP_GetGlobalState r;
 588         NTSTATUS status;
 589
 590         /* In parameters */
 591
 592         if (DEBUGLEVEL >= 10) {
 593                 NDR_PRINT_IN_DEBUG(PNP_GetGlobalState, &r);
 594         }
 595
 596         status = cli->dispatch(cli,
 597                                 mem_ctx,
 598                                 &ndr_table_ntsvcs,
 599                                 NDR_PNP_GETGLOBALSTATE,
 600                                 &r);
 601
 602         if (!NT_STATUS_IS_OK(status)) {
 603                 return status;
 604         }
 605
 606         if (DEBUGLEVEL >= 10) {
 607                 NDR_PRINT_OUT_DEBUG(PNP_GetGlobalState, &r);
 608         }
 609
 610         if (NT_STATUS_IS_ERR(status)) {
 611                 return status;
 612         }
 613
 614         /* Return variables */
 615
 616         /* Return result */
 617         if (werror) {
 618                 *werror = r.out.result;
 619         }
 620
 621         return werror_to_ntstatus(r.out.result);
 622 }
 623
 624 struct rpccli_PNP_InitDetection_state {
 625         struct PNP_InitDetection orig;
 626         struct PNP_InitDetection tmp;
 627         TALLOC_CTX *out_mem_ctx;
 628         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 629 };
 630
 631 static void rpccli_PNP_InitDetection_done(struct tevent_req *subreq);
 632
 633 struct tevent_req *rpccli_PNP_InitDetection_send(TALLOC_CTX *mem_ctx,
 634                                                  struct tevent_context *ev,
 635                                                  struct rpc_pipe_client *cli)
 636 {
 637         struct tevent_req *req;
 638         struct rpccli_PNP_InitDetection_state *state;
 639         struct tevent_req *subreq;
 640
 641         req = tevent_req_create(mem_ctx, &state,
 642                                 struct rpccli_PNP_InitDetection_state);
 643         if (req == NULL) {
 644                 return NULL;
 645         }
 646         state->out_mem_ctx = NULL;
 647         state->dispatch_recv = cli->dispatch_recv;
 648
 649         /* In parameters */
 650
 651         /* Out parameters */
 652
 653         /* Result */
 654         ZERO_STRUCT(state->orig.out.result);
 655
 656         if (DEBUGLEVEL >= 10) {
 657                 NDR_PRINT_IN_DEBUG(PNP_InitDetection, &state->orig);
 658         }
 659
 660         /* make a temporary copy, that we pass to the dispatch function */
 661         state->tmp = state->orig;
 662
 663         subreq = cli->dispatch_send(state, ev, cli,
 664                                     &ndr_table_ntsvcs,
 665                                     NDR_PNP_INITDETECTION,
 666                                     &state->tmp);
 667         if (tevent_req_nomem(subreq, req)) {
 668                 return tevent_req_post(req, ev);
 669         }
 670         tevent_req_set_callback(subreq, rpccli_PNP_InitDetection_done, req);
 671         return req;
 672 }
 673
 674 static void rpccli_PNP_InitDetection_done(struct tevent_req *subreq)
 675 {
 676         struct tevent_req *req = tevent_req_callback_data(
 677                 subreq, struct tevent_req);
 678         struct rpccli_PNP_InitDetection_state *state = tevent_req_data(
 679                 req, struct rpccli_PNP_InitDetection_state);
 680         NTSTATUS status;
 681         TALLOC_CTX *mem_ctx;
 682
 683         if (state->out_mem_ctx) {
 684                 mem_ctx = state->out_mem_ctx;
 685         } else {
 686                 mem_ctx = state;
 687         }
 688
 689         status = state->dispatch_recv(subreq, mem_ctx);
 690         TALLOC_FREE(subreq);
 691         if (!NT_STATUS_IS_OK(status)) {
 692                 tevent_req_nterror(req, status);
 693                 return;
 694         }
 695
 696         /* Copy out parameters */
 697
 698         /* Copy result */
 699         state->orig.out.result = state->tmp.out.result;
 700
 701         /* Reset temporary structure */
 702         ZERO_STRUCT(state->tmp);
 703
 704         if (DEBUGLEVEL >= 10) {
 705                 NDR_PRINT_OUT_DEBUG(PNP_InitDetection, &state->orig);
 706         }
 707
 708         tevent_req_done(req);
 709 }
 710
 711 NTSTATUS rpccli_PNP_InitDetection_recv(struct tevent_req *req,
 712                                        TALLOC_CTX *mem_ctx,
 713                                        WERROR *result)
 714 {
 715         struct rpccli_PNP_InitDetection_state *state = tevent_req_data(
 716                 req, struct rpccli_PNP_InitDetection_state);
 717         NTSTATUS status;
 718
 719         if (tevent_req_is_nterror(req, &status)) {
 720                 tevent_req_received(req);
 721                 return status;
 722         }
 723
 724         /* Steal possbile out parameters to the callers context */
 725         talloc_steal(mem_ctx, state->out_mem_ctx);
 726
 727         /* Return result */
 728         *result = state->orig.out.result;
 729
 730         tevent_req_received(req);
 731         return NT_STATUS_OK;
 732 }
 733
 734 NTSTATUS rpccli_PNP_InitDetection(struct rpc_pipe_client *cli,
 735                                   TALLOC_CTX *mem_ctx,
 736                                   WERROR *werror)
 737 {
 738         struct PNP_InitDetection r;
 739         NTSTATUS status;
 740
 741         /* In parameters */
 742
 743         if (DEBUGLEVEL >= 10) {
 744                 NDR_PRINT_IN_DEBUG(PNP_InitDetection, &r);
 745         }
 746
 747         status = cli->dispatch(cli,
 748                                 mem_ctx,
 749                                 &ndr_table_ntsvcs,
 750                                 NDR_PNP_INITDETECTION,
 751                                 &r);
 752
 753         if (!NT_STATUS_IS_OK(status)) {
 754                 return status;
 755         }
 756
 757         if (DEBUGLEVEL >= 10) {
 758                 NDR_PRINT_OUT_DEBUG(PNP_InitDetection, &r);
 759         }
 760
 761         if (NT_STATUS_IS_ERR(status)) {
 762                 return status;
 763         }
 764
 765         /* Return variables */
 766
 767         /* Return result */
 768         if (werror) {
 769                 *werror = r.out.result;
 770         }
 771
 772         return werror_to_ntstatus(r.out.result);
 773 }
 774
 775 struct rpccli_PNP_ReportLogOn_state {
 776         struct PNP_ReportLogOn orig;
 777         struct PNP_ReportLogOn tmp;
 778         TALLOC_CTX *out_mem_ctx;
 779         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 780 };
 781
 782 static void rpccli_PNP_ReportLogOn_done(struct tevent_req *subreq);
 783
 784 struct tevent_req *rpccli_PNP_ReportLogOn_send(TALLOC_CTX *mem_ctx,
 785                                                struct tevent_context *ev,
 786                                                struct rpc_pipe_client *cli)
 787 {
 788         struct tevent_req *req;
 789         struct rpccli_PNP_ReportLogOn_state *state;
 790         struct tevent_req *subreq;
 791
 792         req = tevent_req_create(mem_ctx, &state,
 793                                 struct rpccli_PNP_ReportLogOn_state);
 794         if (req == NULL) {
 795                 return NULL;
 796         }
 797         state->out_mem_ctx = NULL;
 798         state->dispatch_recv = cli->dispatch_recv;
 799
 800         /* In parameters */
 801
 802         /* Out parameters */
 803
 804         /* Result */
 805         ZERO_STRUCT(state->orig.out.result);
 806
 807         if (DEBUGLEVEL >= 10) {
 808                 NDR_PRINT_IN_DEBUG(PNP_ReportLogOn, &state->orig);
 809         }
 810
 811         /* make a temporary copy, that we pass to the dispatch function */
 812         state->tmp = state->orig;
 813
 814         subreq = cli->dispatch_send(state, ev, cli,
 815                                     &ndr_table_ntsvcs,
 816                                     NDR_PNP_REPORTLOGON,
 817                                     &state->tmp);
 818         if (tevent_req_nomem(subreq, req)) {
 819                 return tevent_req_post(req, ev);
 820         }
 821         tevent_req_set_callback(subreq, rpccli_PNP_ReportLogOn_done, req);
 822         return req;
 823 }
 824
 825 static void rpccli_PNP_ReportLogOn_done(struct tevent_req *subreq)
 826 {
 827         struct tevent_req *req = tevent_req_callback_data(
 828                 subreq, struct tevent_req);
 829         struct rpccli_PNP_ReportLogOn_state *state = tevent_req_data(
 830                 req, struct rpccli_PNP_ReportLogOn_state);
 831         NTSTATUS status;
 832         TALLOC_CTX *mem_ctx;
 833
 834         if (state->out_mem_ctx) {
 835                 mem_ctx = state->out_mem_ctx;
 836         } else {
 837                 mem_ctx = state;
 838         }
 839
 840         status = state->dispatch_recv(subreq, mem_ctx);
 841         TALLOC_FREE(subreq);
 842         if (!NT_STATUS_IS_OK(status)) {
 843                 tevent_req_nterror(req, status);
 844                 return;
 845         }
 846
 847         /* Copy out parameters */
 848
 849         /* Copy result */
 850         state->orig.out.result = state->tmp.out.result;
 851
 852         /* Reset temporary structure */
 853         ZERO_STRUCT(state->tmp);
 854
 855         if (DEBUGLEVEL >= 10) {
 856                 NDR_PRINT_OUT_DEBUG(PNP_ReportLogOn, &state->orig);
 857         }
 858
 859         tevent_req_done(req);
 860 }
 861
 862 NTSTATUS rpccli_PNP_ReportLogOn_recv(struct tevent_req *req,
 863                                      TALLOC_CTX *mem_ctx,
 864                                      WERROR *result)
 865 {
 866         struct rpccli_PNP_ReportLogOn_state *state = tevent_req_data(
 867                 req, struct rpccli_PNP_ReportLogOn_state);
 868         NTSTATUS status;
 869
 870         if (tevent_req_is_nterror(req, &status)) {
 871                 tevent_req_received(req);
 872                 return status;
 873         }
 874
 875         /* Steal possbile out parameters to the callers context */
 876         talloc_steal(mem_ctx, state->out_mem_ctx);
 877
 878         /* Return result */
 879         *result = state->orig.out.result;
 880
 881         tevent_req_received(req);
 882         return NT_STATUS_OK;
 883 }
 884
 885 NTSTATUS rpccli_PNP_ReportLogOn(struct rpc_pipe_client *cli,
 886                                 TALLOC_CTX *mem_ctx,
 887                                 WERROR *werror)
 888 {
 889         struct PNP_ReportLogOn r;
 890         NTSTATUS status;
 891
 892         /* In parameters */
 893
 894         if (DEBUGLEVEL >= 10) {
 895                 NDR_PRINT_IN_DEBUG(PNP_ReportLogOn, &r);
 896         }
 897
 898         status = cli->dispatch(cli,
 899                                 mem_ctx,
 900                                 &ndr_table_ntsvcs,
 901                                 NDR_PNP_REPORTLOGON,
 902                                 &r);
 903
 904         if (!NT_STATUS_IS_OK(status)) {
 905                 return status;
 906         }
 907
 908         if (DEBUGLEVEL >= 10) {
 909                 NDR_PRINT_OUT_DEBUG(PNP_ReportLogOn, &r);
 910         }
 911
 912         if (NT_STATUS_IS_ERR(status)) {
 913                 return status;
 914         }
 915
 916         /* Return variables */
 917
 918         /* Return result */
 919         if (werror) {
 920                 *werror = r.out.result;
 921         }
 922
 923         return werror_to_ntstatus(r.out.result);
 924 }
 925
 926 struct rpccli_PNP_ValidateDeviceInstance_state {
 927         struct PNP_ValidateDeviceInstance orig;
 928         struct PNP_ValidateDeviceInstance tmp;
 929         TALLOC_CTX *out_mem_ctx;
 930         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 931 };
 932
 933 static void rpccli_PNP_ValidateDeviceInstance_done(struct tevent_req *subreq);
 934
 935 struct tevent_req *rpccli_PNP_ValidateDeviceInstance_send(TALLOC_CTX *mem_ctx,
 936                                                           struct tevent_context *ev,
 937                                                           struct rpc_pipe_client *cli,
 938                                                           const char *_devicepath /* [in] [ref,charset(UTF16)] */,
 939                                                           uint32_t _flags /* [in]  */)
 940 {
 941         struct tevent_req *req;
 942         struct rpccli_PNP_ValidateDeviceInstance_state *state;
 943         struct tevent_req *subreq;
 944
 945         req = tevent_req_create(mem_ctx, &state,
 946                                 struct rpccli_PNP_ValidateDeviceInstance_state);
 947         if (req == NULL) {
 948                 return NULL;
 949         }
 950         state->out_mem_ctx = NULL;
 951         state->dispatch_recv = cli->dispatch_recv;
 952
 953         /* In parameters */
 954         state->orig.in.devicepath = _devicepath;
 955         state->orig.in.flags = _flags;
 956
 957         /* Out parameters */
 958
 959         /* Result */
 960         ZERO_STRUCT(state->orig.out.result);
 961
 962         if (DEBUGLEVEL >= 10) {
 963                 NDR_PRINT_IN_DEBUG(PNP_ValidateDeviceInstance, &state->orig);
 964         }
 965
 966         /* make a temporary copy, that we pass to the dispatch function */
 967         state->tmp = state->orig;
 968
 969         subreq = cli->dispatch_send(state, ev, cli,
 970                                     &ndr_table_ntsvcs,
 971                                     NDR_PNP_VALIDATEDEVICEINSTANCE,
 972                                     &state->tmp);
 973         if (tevent_req_nomem(subreq, req)) {
 974                 return tevent_req_post(req, ev);
 975         }
 976         tevent_req_set_callback(subreq, rpccli_PNP_ValidateDeviceInstance_done, req);
 977         return req;
 978 }
 979
 980 static void rpccli_PNP_ValidateDeviceInstance_done(struct tevent_req *subreq)
 981 {
 982         struct tevent_req *req = tevent_req_callback_data(
 983                 subreq, struct tevent_req);
 984         struct rpccli_PNP_ValidateDeviceInstance_state *state = tevent_req_data(
 985                 req, struct rpccli_PNP_ValidateDeviceInstance_state);
 986         NTSTATUS status;
 987         TALLOC_CTX *mem_ctx;
 988
 989         if (state->out_mem_ctx) {
 990                 mem_ctx = state->out_mem_ctx;
 991         } else {
 992                 mem_ctx = state;
 993         }
 994
 995         status = state->dispatch_recv(subreq, mem_ctx);
 996         TALLOC_FREE(subreq);
 997         if (!NT_STATUS_IS_OK(status)) {
 998                 tevent_req_nterror(req, status);
 999                 return;
1000         }
1001
1002         /* Copy out parameters */
1003
1004         /* Copy result */
1005         state->orig.out.result = state->tmp.out.result;
1006
1007         /* Reset temporary structure */
1008         ZERO_STRUCT(state->tmp);
1009
1010         if (DEBUGLEVEL >= 10) {
1011                 NDR_PRINT_OUT_DEBUG(PNP_ValidateDeviceInstance, &state->orig);
1012         }
1013
1014         tevent_req_done(req);
1015 }
1016
1017 NTSTATUS rpccli_PNP_ValidateDeviceInstance_recv(struct tevent_req *req,
1018                                                 TALLOC_CTX *mem_ctx,
1019                                                 WERROR *result)
1020 {
1021         struct rpccli_PNP_ValidateDeviceInstance_state *state = tevent_req_data(
1022                 req, struct rpccli_PNP_ValidateDeviceInstance_state);
1023         NTSTATUS status;
1024
1025         if (tevent_req_is_nterror(req, &status)) {
1026                 tevent_req_received(req);
1027                 return status;
1028         }
1029
1030         /* Steal possbile out parameters to the callers context */
1031         talloc_steal(mem_ctx, state->out_mem_ctx);
1032
1033         /* Return result */
1034         *result = state->orig.out.result;
1035
1036         tevent_req_received(req);
1037         return NT_STATUS_OK;
1038 }
1039
1040 NTSTATUS rpccli_PNP_ValidateDeviceInstance(struct rpc_pipe_client *cli,
1041                                            TALLOC_CTX *mem_ctx,
1042                                            const char *devicepath /* [in] [ref,charset(UTF16)] */,
1043                                            uint32_t flags /* [in]  */,
1044                                            WERROR *werror)
1045 {
1046         struct PNP_ValidateDeviceInstance r;
1047         NTSTATUS status;
1048
1049         /* In parameters */
1050         r.in.devicepath = devicepath;
1051         r.in.flags = flags;
1052
1053         if (DEBUGLEVEL >= 10) {
1054                 NDR_PRINT_IN_DEBUG(PNP_ValidateDeviceInstance, &r);
1055         }
1056
1057         status = cli->dispatch(cli,
1058                                 mem_ctx,
1059                                 &ndr_table_ntsvcs,
1060                                 NDR_PNP_VALIDATEDEVICEINSTANCE,
1061                                 &r);
1062
1063         if (!NT_STATUS_IS_OK(status)) {
1064                 return status;
1065         }
1066
1067         if (DEBUGLEVEL >= 10) {
1068                 NDR_PRINT_OUT_DEBUG(PNP_ValidateDeviceInstance, &r);
1069         }
1070
1071         if (NT_STATUS_IS_ERR(status)) {
1072                 return status;
1073         }
1074
1075         /* Return variables */
1076
1077         /* Return result */
1078         if (werror) {
1079                 *werror = r.out.result;
1080         }
1081
1082         return werror_to_ntstatus(r.out.result);
1083 }
1084
1085 struct rpccli_PNP_GetRootDeviceInstance_state {
1086         struct PNP_GetRootDeviceInstance orig;
1087         struct PNP_GetRootDeviceInstance tmp;
1088         TALLOC_CTX *out_mem_ctx;
1089         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1090 };
1091
1092 static void rpccli_PNP_GetRootDeviceInstance_done(struct tevent_req *subreq);
1093
1094 struct tevent_req *rpccli_PNP_GetRootDeviceInstance_send(TALLOC_CTX *mem_ctx,
1095                                                          struct tevent_context *ev,
1096                                                          struct rpc_pipe_client *cli)
1097 {
1098         struct tevent_req *req;
1099         struct rpccli_PNP_GetRootDeviceInstance_state *state;
1100         struct tevent_req *subreq;
1101
1102         req = tevent_req_create(mem_ctx, &state,
1103                                 struct rpccli_PNP_GetRootDeviceInstance_state);
1104         if (req == NULL) {
1105                 return NULL;
1106         }
1107         state->out_mem_ctx = NULL;
1108         state->dispatch_recv = cli->dispatch_recv;
1109
1110         /* In parameters */
1111
1112         /* Out parameters */
1113
1114         /* Result */
1115         ZERO_STRUCT(state->orig.out.result);
1116
1117         if (DEBUGLEVEL >= 10) {
1118                 NDR_PRINT_IN_DEBUG(PNP_GetRootDeviceInstance, &state->orig);
1119         }
1120
1121         /* make a temporary copy, that we pass to the dispatch function */
1122         state->tmp = state->orig;
1123
1124         subreq = cli->dispatch_send(state, ev, cli,
1125                                     &ndr_table_ntsvcs,
1126                                     NDR_PNP_GETROOTDEVICEINSTANCE,
1127                                     &state->tmp);
1128         if (tevent_req_nomem(subreq, req)) {
1129                 return tevent_req_post(req, ev);
1130         }
1131         tevent_req_set_callback(subreq, rpccli_PNP_GetRootDeviceInstance_done, req);
1132         return req;
1133 }
1134
1135 static void rpccli_PNP_GetRootDeviceInstance_done(struct tevent_req *subreq)
1136 {
1137         struct tevent_req *req = tevent_req_callback_data(
1138                 subreq, struct tevent_req);
1139         struct rpccli_PNP_GetRootDeviceInstance_state *state = tevent_req_data(
1140                 req, struct rpccli_PNP_GetRootDeviceInstance_state);
1141         NTSTATUS status;
1142         TALLOC_CTX *mem_ctx;
1143
1144         if (state->out_mem_ctx) {
1145                 mem_ctx = state->out_mem_ctx;
1146         } else {
1147                 mem_ctx = state;
1148         }
1149
1150         status = state->dispatch_recv(subreq, mem_ctx);
1151         TALLOC_FREE(subreq);
1152         if (!NT_STATUS_IS_OK(status)) {
1153                 tevent_req_nterror(req, status);
1154                 return;
1155         }
1156
1157         /* Copy out parameters */
1158
1159         /* Copy result */
1160         state->orig.out.result = state->tmp.out.result;
1161
1162         /* Reset temporary structure */
1163         ZERO_STRUCT(state->tmp);
1164
1165         if (DEBUGLEVEL >= 10) {
1166                 NDR_PRINT_OUT_DEBUG(PNP_GetRootDeviceInstance, &state->orig);
1167         }
1168
1169         tevent_req_done(req);
1170 }
1171
1172 NTSTATUS rpccli_PNP_GetRootDeviceInstance_recv(struct tevent_req *req,
1173                                                TALLOC_CTX *mem_ctx,
1174                                                WERROR *result)
1175 {
1176         struct rpccli_PNP_GetRootDeviceInstance_state *state = tevent_req_data(
1177                 req, struct rpccli_PNP_GetRootDeviceInstance_state);
1178         NTSTATUS status;
1179
1180         if (tevent_req_is_nterror(req, &status)) {
1181                 tevent_req_received(req);
1182                 return status;
1183         }
1184
1185         /* Steal possbile out parameters to the callers context */
1186         talloc_steal(mem_ctx, state->out_mem_ctx);
1187
1188         /* Return result */
1189         *result = state->orig.out.result;
1190
1191         tevent_req_received(req);
1192         return NT_STATUS_OK;
1193 }
1194
1195 NTSTATUS rpccli_PNP_GetRootDeviceInstance(struct rpc_pipe_client *cli,
1196                                           TALLOC_CTX *mem_ctx,
1197                                           WERROR *werror)
1198 {
1199         struct PNP_GetRootDeviceInstance r;
1200         NTSTATUS status;
1201
1202         /* In parameters */
1203
1204         if (DEBUGLEVEL >= 10) {
1205                 NDR_PRINT_IN_DEBUG(PNP_GetRootDeviceInstance, &r);
1206         }
1207
1208         status = cli->dispatch(cli,
1209                                 mem_ctx,
1210                                 &ndr_table_ntsvcs,
1211                                 NDR_PNP_GETROOTDEVICEINSTANCE,
1212                                 &r);
1213
1214         if (!NT_STATUS_IS_OK(status)) {
1215                 return status;
1216         }
1217
1218         if (DEBUGLEVEL >= 10) {
1219                 NDR_PRINT_OUT_DEBUG(PNP_GetRootDeviceInstance, &r);
1220         }
1221
1222         if (NT_STATUS_IS_ERR(status)) {
1223                 return status;
1224         }
1225
1226         /* Return variables */
1227
1228         /* Return result */
1229         if (werror) {
1230                 *werror = r.out.result;
1231         }
1232
1233         return werror_to_ntstatus(r.out.result);
1234 }
1235
1236 struct rpccli_PNP_GetRelatedDeviceInstance_state {
1237         struct PNP_GetRelatedDeviceInstance orig;
1238         struct PNP_GetRelatedDeviceInstance tmp;
1239         TALLOC_CTX *out_mem_ctx;
1240         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1241 };
1242
1243 static void rpccli_PNP_GetRelatedDeviceInstance_done(struct tevent_req *subreq);
1244
1245 struct tevent_req *rpccli_PNP_GetRelatedDeviceInstance_send(TALLOC_CTX *mem_ctx,
1246                                                             struct tevent_context *ev,
1247                                                             struct rpc_pipe_client *cli)
1248 {
1249         struct tevent_req *req;
1250         struct rpccli_PNP_GetRelatedDeviceInstance_state *state;
1251         struct tevent_req *subreq;
1252
1253         req = tevent_req_create(mem_ctx, &state,
1254                                 struct rpccli_PNP_GetRelatedDeviceInstance_state);
1255         if (req == NULL) {
1256                 return NULL;
1257         }
1258         state->out_mem_ctx = NULL;
1259         state->dispatch_recv = cli->dispatch_recv;
1260
1261         /* In parameters */
1262
1263         /* Out parameters */
1264
1265         /* Result */
1266         ZERO_STRUCT(state->orig.out.result);
1267
1268         if (DEBUGLEVEL >= 10) {
1269                 NDR_PRINT_IN_DEBUG(PNP_GetRelatedDeviceInstance, &state->orig);
1270         }
1271
1272         /* make a temporary copy, that we pass to the dispatch function */
1273         state->tmp = state->orig;
1274
1275         subreq = cli->dispatch_send(state, ev, cli,
1276                                     &ndr_table_ntsvcs,
1277                                     NDR_PNP_GETRELATEDDEVICEINSTANCE,
1278                                     &state->tmp);
1279         if (tevent_req_nomem(subreq, req)) {
1280                 return tevent_req_post(req, ev);
1281         }
1282         tevent_req_set_callback(subreq, rpccli_PNP_GetRelatedDeviceInstance_done, req);
1283         return req;
1284 }
1285
1286 static void rpccli_PNP_GetRelatedDeviceInstance_done(struct tevent_req *subreq)
1287 {
1288         struct tevent_req *req = tevent_req_callback_data(
1289                 subreq, struct tevent_req);
1290         struct rpccli_PNP_GetRelatedDeviceInstance_state *state = tevent_req_data(
1291                 req, struct rpccli_PNP_GetRelatedDeviceInstance_state);
1292         NTSTATUS status;
1293         TALLOC_CTX *mem_ctx;
1294
1295         if (state->out_mem_ctx) {
1296                 mem_ctx = state->out_mem_ctx;
1297         } else {
1298                 mem_ctx = state;
1299         }
1300
1301         status = state->dispatch_recv(subreq, mem_ctx);
1302         TALLOC_FREE(subreq);
1303         if (!NT_STATUS_IS_OK(status)) {
1304                 tevent_req_nterror(req, status);
1305                 return;
1306         }
1307
1308         /* Copy out parameters */
1309
1310         /* Copy result */
1311         state->orig.out.result = state->tmp.out.result;
1312
1313         /* Reset temporary structure */
1314         ZERO_STRUCT(state->tmp);
1315
1316         if (DEBUGLEVEL >= 10) {
1317                 NDR_PRINT_OUT_DEBUG(PNP_GetRelatedDeviceInstance, &state->orig);
1318         }
1319
1320         tevent_req_done(req);
1321 }
1322
1323 NTSTATUS rpccli_PNP_GetRelatedDeviceInstance_recv(struct tevent_req *req,
1324                                                   TALLOC_CTX *mem_ctx,
1325                                                   WERROR *result)
1326 {
1327         struct rpccli_PNP_GetRelatedDeviceInstance_state *state = tevent_req_data(
1328                 req, struct rpccli_PNP_GetRelatedDeviceInstance_state);
1329         NTSTATUS status;
1330
1331         if (tevent_req_is_nterror(req, &status)) {
1332                 tevent_req_received(req);
1333                 return status;
1334         }
1335
1336         /* Steal possbile out parameters to the callers context */
1337         talloc_steal(mem_ctx, state->out_mem_ctx);
1338
1339         /* Return result */
1340         *result = state->orig.out.result;
1341
1342         tevent_req_received(req);
1343         return NT_STATUS_OK;
1344 }
1345
1346 NTSTATUS rpccli_PNP_GetRelatedDeviceInstance(struct rpc_pipe_client *cli,
1347                                              TALLOC_CTX *mem_ctx,
1348                                              WERROR *werror)
1349 {
1350         struct PNP_GetRelatedDeviceInstance r;
1351         NTSTATUS status;
1352
1353         /* In parameters */
1354
1355         if (DEBUGLEVEL >= 10) {
1356                 NDR_PRINT_IN_DEBUG(PNP_GetRelatedDeviceInstance, &r);
1357         }
1358
1359         status = cli->dispatch(cli,
1360                                 mem_ctx,
1361                                 &ndr_table_ntsvcs,
1362                                 NDR_PNP_GETRELATEDDEVICEINSTANCE,
1363                                 &r);
1364
1365         if (!NT_STATUS_IS_OK(status)) {
1366                 return status;
1367         }
1368
1369         if (DEBUGLEVEL >= 10) {
1370                 NDR_PRINT_OUT_DEBUG(PNP_GetRelatedDeviceInstance, &r);
1371         }
1372
1373         if (NT_STATUS_IS_ERR(status)) {
1374                 return status;
1375         }
1376
1377         /* Return variables */
1378
1379         /* Return result */
1380         if (werror) {
1381                 *werror = r.out.result;
1382         }
1383
1384         return werror_to_ntstatus(r.out.result);
1385 }
1386
1387 struct rpccli_PNP_EnumerateSubKeys_state {
1388         struct PNP_EnumerateSubKeys orig;
1389         struct PNP_EnumerateSubKeys tmp;
1390         TALLOC_CTX *out_mem_ctx;
1391         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1392 };
1393
1394 static void rpccli_PNP_EnumerateSubKeys_done(struct tevent_req *subreq);
1395
1396 struct tevent_req *rpccli_PNP_EnumerateSubKeys_send(TALLOC_CTX *mem_ctx,
1397                                                     struct tevent_context *ev,
1398                                                     struct rpc_pipe_client *cli)
1399 {
1400         struct tevent_req *req;
1401         struct rpccli_PNP_EnumerateSubKeys_state *state;
1402         struct tevent_req *subreq;
1403
1404         req = tevent_req_create(mem_ctx, &state,
1405                                 struct rpccli_PNP_EnumerateSubKeys_state);
1406         if (req == NULL) {
1407                 return NULL;
1408         }
1409         state->out_mem_ctx = NULL;
1410         state->dispatch_recv = cli->dispatch_recv;
1411
1412         /* In parameters */
1413
1414         /* Out parameters */
1415
1416         /* Result */
1417         ZERO_STRUCT(state->orig.out.result);
1418
1419         if (DEBUGLEVEL >= 10) {
1420                 NDR_PRINT_IN_DEBUG(PNP_EnumerateSubKeys, &state->orig);
1421         }
1422
1423         /* make a temporary copy, that we pass to the dispatch function */
1424         state->tmp = state->orig;
1425
1426         subreq = cli->dispatch_send(state, ev, cli,
1427                                     &ndr_table_ntsvcs,
1428                                     NDR_PNP_ENUMERATESUBKEYS,
1429                                     &state->tmp);
1430         if (tevent_req_nomem(subreq, req)) {
1431                 return tevent_req_post(req, ev);
1432         }
1433         tevent_req_set_callback(subreq, rpccli_PNP_EnumerateSubKeys_done, req);
1434         return req;
1435 }
1436
1437 static void rpccli_PNP_EnumerateSubKeys_done(struct tevent_req *subreq)
1438 {
1439         struct tevent_req *req = tevent_req_callback_data(
1440                 subreq, struct tevent_req);
1441         struct rpccli_PNP_EnumerateSubKeys_state *state = tevent_req_data(
1442                 req, struct rpccli_PNP_EnumerateSubKeys_state);
1443         NTSTATUS status;
1444         TALLOC_CTX *mem_ctx;
1445
1446         if (state->out_mem_ctx) {
1447                 mem_ctx = state->out_mem_ctx;
1448         } else {
1449                 mem_ctx = state;
1450         }
1451
1452         status = state->dispatch_recv(subreq, mem_ctx);
1453         TALLOC_FREE(subreq);
1454         if (!NT_STATUS_IS_OK(status)) {
1455                 tevent_req_nterror(req, status);
1456                 return;
1457         }
1458
1459         /* Copy out parameters */
1460
1461         /* Copy result */
1462         state->orig.out.result = state->tmp.out.result;
1463
1464         /* Reset temporary structure */
1465         ZERO_STRUCT(state->tmp);
1466
1467         if (DEBUGLEVEL >= 10) {
1468                 NDR_PRINT_OUT_DEBUG(PNP_EnumerateSubKeys, &state->orig);
1469         }
1470
1471         tevent_req_done(req);
1472 }
1473
1474 NTSTATUS rpccli_PNP_EnumerateSubKeys_recv(struct tevent_req *req,
1475                                           TALLOC_CTX *mem_ctx,
1476                                           WERROR *result)
1477 {
1478         struct rpccli_PNP_EnumerateSubKeys_state *state = tevent_req_data(
1479                 req, struct rpccli_PNP_EnumerateSubKeys_state);
1480         NTSTATUS status;
1481
1482         if (tevent_req_is_nterror(req, &status)) {
1483                 tevent_req_received(req);
1484                 return status;
1485         }
1486
1487         /* Steal possbile out parameters to the callers context */
1488         talloc_steal(mem_ctx, state->out_mem_ctx);
1489
1490         /* Return result */
1491         *result = state->orig.out.result;
1492
1493         tevent_req_received(req);
1494         return NT_STATUS_OK;
1495 }
1496
1497 NTSTATUS rpccli_PNP_EnumerateSubKeys(struct rpc_pipe_client *cli,
1498                                      TALLOC_CTX *mem_ctx,
1499                                      WERROR *werror)
1500 {
1501         struct PNP_EnumerateSubKeys r;
1502         NTSTATUS status;
1503
1504         /* In parameters */
1505
1506         if (DEBUGLEVEL >= 10) {
1507                 NDR_PRINT_IN_DEBUG(PNP_EnumerateSubKeys, &r);
1508         }
1509
1510         status = cli->dispatch(cli,
1511                                 mem_ctx,
1512                                 &ndr_table_ntsvcs,
1513                                 NDR_PNP_ENUMERATESUBKEYS,
1514                                 &r);
1515
1516         if (!NT_STATUS_IS_OK(status)) {
1517                 return status;
1518         }
1519
1520         if (DEBUGLEVEL >= 10) {
1521                 NDR_PRINT_OUT_DEBUG(PNP_EnumerateSubKeys, &r);
1522         }
1523
1524         if (NT_STATUS_IS_ERR(status)) {
1525                 return status;
1526         }
1527
1528         /* Return variables */
1529
1530         /* Return result */
1531         if (werror) {
1532                 *werror = r.out.result;
1533         }
1534
1535         return werror_to_ntstatus(r.out.result);
1536 }
1537
1538 struct rpccli_PNP_GetDeviceList_state {
1539         struct PNP_GetDeviceList orig;
1540         struct PNP_GetDeviceList tmp;
1541         TALLOC_CTX *out_mem_ctx;
1542         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1543 };
1544
1545 static void rpccli_PNP_GetDeviceList_done(struct tevent_req *subreq);
1546
1547 struct tevent_req *rpccli_PNP_GetDeviceList_send(TALLOC_CTX *mem_ctx,
1548                                                  struct tevent_context *ev,
1549                                                  struct rpc_pipe_client *cli,
1550                                                  const char *_filter /* [in] [unique,charset(UTF16)] */,
1551                                                  uint16_t *_buffer /* [out] [ref,length_is(*length),size_is(*length)] */,
1552                                                  uint32_t *_length /* [in,out] [ref] */,
1553                                                  uint32_t _flags /* [in]  */)
1554 {
1555         struct tevent_req *req;
1556         struct rpccli_PNP_GetDeviceList_state *state;
1557         struct tevent_req *subreq;
1558
1559         req = tevent_req_create(mem_ctx, &state,
1560                                 struct rpccli_PNP_GetDeviceList_state);
1561         if (req == NULL) {
1562                 return NULL;
1563         }
1564         state->out_mem_ctx = NULL;
1565         state->dispatch_recv = cli->dispatch_recv;
1566
1567         /* In parameters */
1568         state->orig.in.filter = _filter;
1569         state->orig.in.length = _length;
1570         state->orig.in.flags = _flags;
1571
1572         /* Out parameters */
1573         state->orig.out.buffer = _buffer;
1574         state->orig.out.length = _length;
1575
1576         /* Result */
1577         ZERO_STRUCT(state->orig.out.result);
1578
1579         if (DEBUGLEVEL >= 10) {
1580                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceList, &state->orig);
1581         }
1582
1583         state->out_mem_ctx = talloc_named_const(state, 0,
1584                              "rpccli_PNP_GetDeviceList_out_memory");
1585         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1586                 return tevent_req_post(req, ev);
1587         }
1588
1589         /* make a temporary copy, that we pass to the dispatch function */
1590         state->tmp = state->orig;
1591
1592         subreq = cli->dispatch_send(state, ev, cli,
1593                                     &ndr_table_ntsvcs,
1594                                     NDR_PNP_GETDEVICELIST,
1595                                     &state->tmp);
1596         if (tevent_req_nomem(subreq, req)) {
1597                 return tevent_req_post(req, ev);
1598         }
1599         tevent_req_set_callback(subreq, rpccli_PNP_GetDeviceList_done, req);
1600         return req;
1601 }
1602
1603 static void rpccli_PNP_GetDeviceList_done(struct tevent_req *subreq)
1604 {
1605         struct tevent_req *req = tevent_req_callback_data(
1606                 subreq, struct tevent_req);
1607         struct rpccli_PNP_GetDeviceList_state *state = tevent_req_data(
1608                 req, struct rpccli_PNP_GetDeviceList_state);
1609         NTSTATUS status;
1610         TALLOC_CTX *mem_ctx;
1611
1612         if (state->out_mem_ctx) {
1613                 mem_ctx = state->out_mem_ctx;
1614         } else {
1615                 mem_ctx = state;
1616         }
1617
1618         status = state->dispatch_recv(subreq, mem_ctx);
1619         TALLOC_FREE(subreq);
1620         if (!NT_STATUS_IS_OK(status)) {
1621                 tevent_req_nterror(req, status);
1622                 return;
1623         }
1624
1625         /* Copy out parameters */
1626         memcpy(state->orig.out.buffer, state->tmp.out.buffer, *state->tmp.in.length * sizeof(*state->orig.out.buffer));
1627         *state->orig.out.length = *state->tmp.out.length;
1628
1629         /* Copy result */
1630         state->orig.out.result = state->tmp.out.result;
1631
1632         /* Reset temporary structure */
1633         ZERO_STRUCT(state->tmp);
1634
1635         if (DEBUGLEVEL >= 10) {
1636                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceList, &state->orig);
1637         }
1638
1639         tevent_req_done(req);
1640 }
1641
1642 NTSTATUS rpccli_PNP_GetDeviceList_recv(struct tevent_req *req,
1643                                        TALLOC_CTX *mem_ctx,
1644                                        WERROR *result)
1645 {
1646         struct rpccli_PNP_GetDeviceList_state *state = tevent_req_data(
1647                 req, struct rpccli_PNP_GetDeviceList_state);
1648         NTSTATUS status;
1649
1650         if (tevent_req_is_nterror(req, &status)) {
1651                 tevent_req_received(req);
1652                 return status;
1653         }
1654
1655         /* Steal possbile out parameters to the callers context */
1656         talloc_steal(mem_ctx, state->out_mem_ctx);
1657
1658         /* Return result */
1659         *result = state->orig.out.result;
1660
1661         tevent_req_received(req);
1662         return NT_STATUS_OK;
1663 }
1664
1665 NTSTATUS rpccli_PNP_GetDeviceList(struct rpc_pipe_client *cli,
1666                                   TALLOC_CTX *mem_ctx,
1667                                   const char *filter /* [in] [unique,charset(UTF16)] */,
1668                                   uint16_t *buffer /* [out] [ref,length_is(*length),size_is(*length)] */,
1669                                   uint32_t *length /* [in,out] [ref] */,
1670                                   uint32_t flags /* [in]  */,
1671                                   WERROR *werror)
1672 {
1673         struct PNP_GetDeviceList r;
1674         NTSTATUS status;
1675
1676         /* In parameters */
1677         r.in.filter = filter;
1678         r.in.length = length;
1679         r.in.flags = flags;
1680
1681         if (DEBUGLEVEL >= 10) {
1682                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceList, &r);
1683         }
1684
1685         status = cli->dispatch(cli,
1686                                 mem_ctx,
1687                                 &ndr_table_ntsvcs,
1688                                 NDR_PNP_GETDEVICELIST,
1689                                 &r);
1690
1691         if (!NT_STATUS_IS_OK(status)) {
1692                 return status;
1693         }
1694
1695         if (DEBUGLEVEL >= 10) {
1696                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceList, &r);
1697         }
1698
1699         if (NT_STATUS_IS_ERR(status)) {
1700                 return status;
1701         }
1702
1703         /* Return variables */
1704         memcpy(buffer, r.out.buffer, *r.in.length * sizeof(*buffer));
1705         *length = *r.out.length;
1706
1707         /* Return result */
1708         if (werror) {
1709                 *werror = r.out.result;
1710         }
1711
1712         return werror_to_ntstatus(r.out.result);
1713 }
1714
1715 struct rpccli_PNP_GetDeviceListSize_state {
1716         struct PNP_GetDeviceListSize orig;
1717         struct PNP_GetDeviceListSize tmp;
1718         TALLOC_CTX *out_mem_ctx;
1719         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1720 };
1721
1722 static void rpccli_PNP_GetDeviceListSize_done(struct tevent_req *subreq);
1723
1724 struct tevent_req *rpccli_PNP_GetDeviceListSize_send(TALLOC_CTX *mem_ctx,
1725                                                      struct tevent_context *ev,
1726                                                      struct rpc_pipe_client *cli,
1727                                                      const char *_devicename /* [in] [unique,charset(UTF16)] */,
1728                                                      uint32_t *_size /* [out] [ref] */,
1729                                                      uint32_t _flags /* [in]  */)
1730 {
1731         struct tevent_req *req;
1732         struct rpccli_PNP_GetDeviceListSize_state *state;
1733         struct tevent_req *subreq;
1734
1735         req = tevent_req_create(mem_ctx, &state,
1736                                 struct rpccli_PNP_GetDeviceListSize_state);
1737         if (req == NULL) {
1738                 return NULL;
1739         }
1740         state->out_mem_ctx = NULL;
1741         state->dispatch_recv = cli->dispatch_recv;
1742
1743         /* In parameters */
1744         state->orig.in.devicename = _devicename;
1745         state->orig.in.flags = _flags;
1746
1747         /* Out parameters */
1748         state->orig.out.size = _size;
1749
1750         /* Result */
1751         ZERO_STRUCT(state->orig.out.result);
1752
1753         if (DEBUGLEVEL >= 10) {
1754                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceListSize, &state->orig);
1755         }
1756
1757         state->out_mem_ctx = talloc_named_const(state, 0,
1758                              "rpccli_PNP_GetDeviceListSize_out_memory");
1759         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1760                 return tevent_req_post(req, ev);
1761         }
1762
1763         /* make a temporary copy, that we pass to the dispatch function */
1764         state->tmp = state->orig;
1765
1766         subreq = cli->dispatch_send(state, ev, cli,
1767                                     &ndr_table_ntsvcs,
1768                                     NDR_PNP_GETDEVICELISTSIZE,
1769                                     &state->tmp);
1770         if (tevent_req_nomem(subreq, req)) {
1771                 return tevent_req_post(req, ev);
1772         }
1773         tevent_req_set_callback(subreq, rpccli_PNP_GetDeviceListSize_done, req);
1774         return req;
1775 }
1776
1777 static void rpccli_PNP_GetDeviceListSize_done(struct tevent_req *subreq)
1778 {
1779         struct tevent_req *req = tevent_req_callback_data(
1780                 subreq, struct tevent_req);
1781         struct rpccli_PNP_GetDeviceListSize_state *state = tevent_req_data(
1782                 req, struct rpccli_PNP_GetDeviceListSize_state);
1783         NTSTATUS status;
1784         TALLOC_CTX *mem_ctx;
1785
1786         if (state->out_mem_ctx) {
1787                 mem_ctx = state->out_mem_ctx;
1788         } else {
1789                 mem_ctx = state;
1790         }
1791
1792         status = state->dispatch_recv(subreq, mem_ctx);
1793         TALLOC_FREE(subreq);
1794         if (!NT_STATUS_IS_OK(status)) {
1795                 tevent_req_nterror(req, status);
1796                 return;
1797         }
1798
1799         /* Copy out parameters */
1800         *state->orig.out.size = *state->tmp.out.size;
1801
1802         /* Copy result */
1803         state->orig.out.result = state->tmp.out.result;
1804
1805         /* Reset temporary structure */
1806         ZERO_STRUCT(state->tmp);
1807
1808         if (DEBUGLEVEL >= 10) {
1809                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceListSize, &state->orig);
1810         }
1811
1812         tevent_req_done(req);
1813 }
1814
1815 NTSTATUS rpccli_PNP_GetDeviceListSize_recv(struct tevent_req *req,
1816                                            TALLOC_CTX *mem_ctx,
1817                                            WERROR *result)
1818 {
1819         struct rpccli_PNP_GetDeviceListSize_state *state = tevent_req_data(
1820                 req, struct rpccli_PNP_GetDeviceListSize_state);
1821         NTSTATUS status;
1822
1823         if (tevent_req_is_nterror(req, &status)) {
1824                 tevent_req_received(req);
1825                 return status;
1826         }
1827
1828         /* Steal possbile out parameters to the callers context */
1829         talloc_steal(mem_ctx, state->out_mem_ctx);
1830
1831         /* Return result */
1832         *result = state->orig.out.result;
1833
1834         tevent_req_received(req);
1835         return NT_STATUS_OK;
1836 }
1837
1838 NTSTATUS rpccli_PNP_GetDeviceListSize(struct rpc_pipe_client *cli,
1839                                       TALLOC_CTX *mem_ctx,
1840                                       const char *devicename /* [in] [unique,charset(UTF16)] */,
1841                                       uint32_t *size /* [out] [ref] */,
1842                                       uint32_t flags /* [in]  */,
1843                                       WERROR *werror)
1844 {
1845         struct PNP_GetDeviceListSize r;
1846         NTSTATUS status;
1847
1848         /* In parameters */
1849         r.in.devicename = devicename;
1850         r.in.flags = flags;
1851
1852         if (DEBUGLEVEL >= 10) {
1853                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceListSize, &r);
1854         }
1855
1856         status = cli->dispatch(cli,
1857                                 mem_ctx,
1858                                 &ndr_table_ntsvcs,
1859                                 NDR_PNP_GETDEVICELISTSIZE,
1860                                 &r);
1861
1862         if (!NT_STATUS_IS_OK(status)) {
1863                 return status;
1864         }
1865
1866         if (DEBUGLEVEL >= 10) {
1867                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceListSize, &r);
1868         }
1869
1870         if (NT_STATUS_IS_ERR(status)) {
1871                 return status;
1872         }
1873
1874         /* Return variables */
1875         *size = *r.out.size;
1876
1877         /* Return result */
1878         if (werror) {
1879                 *werror = r.out.result;
1880         }
1881
1882         return werror_to_ntstatus(r.out.result);
1883 }
1884
1885 struct rpccli_PNP_GetDepth_state {
1886         struct PNP_GetDepth orig;
1887         struct PNP_GetDepth tmp;
1888         TALLOC_CTX *out_mem_ctx;
1889         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1890 };
1891
1892 static void rpccli_PNP_GetDepth_done(struct tevent_req *subreq);
1893
1894 struct tevent_req *rpccli_PNP_GetDepth_send(TALLOC_CTX *mem_ctx,
1895                                             struct tevent_context *ev,
1896                                             struct rpc_pipe_client *cli)
1897 {
1898         struct tevent_req *req;
1899         struct rpccli_PNP_GetDepth_state *state;
1900         struct tevent_req *subreq;
1901
1902         req = tevent_req_create(mem_ctx, &state,
1903                                 struct rpccli_PNP_GetDepth_state);
1904         if (req == NULL) {
1905                 return NULL;
1906         }
1907         state->out_mem_ctx = NULL;
1908         state->dispatch_recv = cli->dispatch_recv;
1909
1910         /* In parameters */
1911
1912         /* Out parameters */
1913
1914         /* Result */
1915         ZERO_STRUCT(state->orig.out.result);
1916
1917         if (DEBUGLEVEL >= 10) {
1918                 NDR_PRINT_IN_DEBUG(PNP_GetDepth, &state->orig);
1919         }
1920
1921         /* make a temporary copy, that we pass to the dispatch function */
1922         state->tmp = state->orig;
1923
1924         subreq = cli->dispatch_send(state, ev, cli,
1925                                     &ndr_table_ntsvcs,
1926                                     NDR_PNP_GETDEPTH,
1927                                     &state->tmp);
1928         if (tevent_req_nomem(subreq, req)) {
1929                 return tevent_req_post(req, ev);
1930         }
1931         tevent_req_set_callback(subreq, rpccli_PNP_GetDepth_done, req);
1932         return req;
1933 }
1934
1935 static void rpccli_PNP_GetDepth_done(struct tevent_req *subreq)
1936 {
1937         struct tevent_req *req = tevent_req_callback_data(
1938                 subreq, struct tevent_req);
1939         struct rpccli_PNP_GetDepth_state *state = tevent_req_data(
1940                 req, struct rpccli_PNP_GetDepth_state);
1941         NTSTATUS status;
1942         TALLOC_CTX *mem_ctx;
1943
1944         if (state->out_mem_ctx) {
1945                 mem_ctx = state->out_mem_ctx;
1946         } else {
1947                 mem_ctx = state;
1948         }
1949
1950         status = state->dispatch_recv(subreq, mem_ctx);
1951         TALLOC_FREE(subreq);
1952         if (!NT_STATUS_IS_OK(status)) {
1953                 tevent_req_nterror(req, status);
1954                 return;
1955         }
1956
1957         /* Copy out parameters */
1958
1959         /* Copy result */
1960         state->orig.out.result = state->tmp.out.result;
1961
1962         /* Reset temporary structure */
1963         ZERO_STRUCT(state->tmp);
1964
1965         if (DEBUGLEVEL >= 10) {
1966                 NDR_PRINT_OUT_DEBUG(PNP_GetDepth, &state->orig);
1967         }
1968
1969         tevent_req_done(req);
1970 }
1971
1972 NTSTATUS rpccli_PNP_GetDepth_recv(struct tevent_req *req,
1973                                   TALLOC_CTX *mem_ctx,
1974                                   WERROR *result)
1975 {
1976         struct rpccli_PNP_GetDepth_state *state = tevent_req_data(
1977                 req, struct rpccli_PNP_GetDepth_state);
1978         NTSTATUS status;
1979
1980         if (tevent_req_is_nterror(req, &status)) {
1981                 tevent_req_received(req);
1982                 return status;
1983         }
1984
1985         /* Steal possbile out parameters to the callers context */
1986         talloc_steal(mem_ctx, state->out_mem_ctx);
1987
1988         /* Return result */
1989         *result = state->orig.out.result;
1990
1991         tevent_req_received(req);
1992         return NT_STATUS_OK;
1993 }
1994
1995 NTSTATUS rpccli_PNP_GetDepth(struct rpc_pipe_client *cli,
1996                              TALLOC_CTX *mem_ctx,
1997                              WERROR *werror)
1998 {
1999         struct PNP_GetDepth r;
2000         NTSTATUS status;
2001
2002         /* In parameters */
2003
2004         if (DEBUGLEVEL >= 10) {
2005                 NDR_PRINT_IN_DEBUG(PNP_GetDepth, &r);
2006         }
2007
2008         status = cli->dispatch(cli,
2009                                 mem_ctx,
2010                                 &ndr_table_ntsvcs,
2011                                 NDR_PNP_GETDEPTH,
2012                                 &r);
2013
2014         if (!NT_STATUS_IS_OK(status)) {
2015                 return status;
2016         }
2017
2018         if (DEBUGLEVEL >= 10) {
2019                 NDR_PRINT_OUT_DEBUG(PNP_GetDepth, &r);
2020         }
2021
2022         if (NT_STATUS_IS_ERR(status)) {
2023                 return status;
2024         }
2025
2026         /* Return variables */
2027
2028         /* Return result */
2029         if (werror) {
2030                 *werror = r.out.result;
2031         }
2032
2033         return werror_to_ntstatus(r.out.result);
2034 }
2035
2036 struct rpccli_PNP_GetDeviceRegProp_state {
2037         struct PNP_GetDeviceRegProp orig;
2038         struct PNP_GetDeviceRegProp tmp;
2039         TALLOC_CTX *out_mem_ctx;
2040         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2041 };
2042
2043 static void rpccli_PNP_GetDeviceRegProp_done(struct tevent_req *subreq);
2044
2045 struct tevent_req *rpccli_PNP_GetDeviceRegProp_send(TALLOC_CTX *mem_ctx,
2046                                                     struct tevent_context *ev,
2047                                                     struct rpc_pipe_client *cli,
2048                                                     const char *_devicepath /* [in] [ref,charset(UTF16)] */,
2049                                                     uint32_t _property /* [in]  */,
2050                                                     enum winreg_Type *_reg_data_type /* [in,out] [ref] */,
2051                                                     uint8_t *_buffer /* [out] [ref,length_is(*buffer_size),size_is(*buffer_size)] */,
2052                                                     uint32_t *_buffer_size /* [in,out] [ref] */,
2053                                                     uint32_t *_needed /* [in,out] [ref] */,
2054                                                     uint32_t _flags /* [in]  */)
2055 {
2056         struct tevent_req *req;
2057         struct rpccli_PNP_GetDeviceRegProp_state *state;
2058         struct tevent_req *subreq;
2059
2060         req = tevent_req_create(mem_ctx, &state,
2061                                 struct rpccli_PNP_GetDeviceRegProp_state);
2062         if (req == NULL) {
2063                 return NULL;
2064         }
2065         state->out_mem_ctx = NULL;
2066         state->dispatch_recv = cli->dispatch_recv;
2067
2068         /* In parameters */
2069         state->orig.in.devicepath = _devicepath;
2070         state->orig.in.property = _property;
2071         state->orig.in.reg_data_type = _reg_data_type;
2072         state->orig.in.buffer_size = _buffer_size;
2073         state->orig.in.needed = _needed;
2074         state->orig.in.flags = _flags;
2075
2076         /* Out parameters */
2077         state->orig.out.reg_data_type = _reg_data_type;
2078         state->orig.out.buffer = _buffer;
2079         state->orig.out.buffer_size = _buffer_size;
2080         state->orig.out.needed = _needed;
2081
2082         /* Result */
2083         ZERO_STRUCT(state->orig.out.result);
2084
2085         if (DEBUGLEVEL >= 10) {
2086                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceRegProp, &state->orig);
2087         }
2088
2089         state->out_mem_ctx = talloc_named_const(state, 0,
2090                              "rpccli_PNP_GetDeviceRegProp_out_memory");
2091         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2092                 return tevent_req_post(req, ev);
2093         }
2094
2095         /* make a temporary copy, that we pass to the dispatch function */
2096         state->tmp = state->orig;
2097
2098         subreq = cli->dispatch_send(state, ev, cli,
2099                                     &ndr_table_ntsvcs,
2100                                     NDR_PNP_GETDEVICEREGPROP,
2101                                     &state->tmp);
2102         if (tevent_req_nomem(subreq, req)) {
2103                 return tevent_req_post(req, ev);
2104         }
2105         tevent_req_set_callback(subreq, rpccli_PNP_GetDeviceRegProp_done, req);
2106         return req;
2107 }
2108
2109 static void rpccli_PNP_GetDeviceRegProp_done(struct tevent_req *subreq)
2110 {
2111         struct tevent_req *req = tevent_req_callback_data(
2112                 subreq, struct tevent_req);
2113         struct rpccli_PNP_GetDeviceRegProp_state *state = tevent_req_data(
2114                 req, struct rpccli_PNP_GetDeviceRegProp_state);
2115         NTSTATUS status;
2116         TALLOC_CTX *mem_ctx;
2117
2118         if (state->out_mem_ctx) {
2119                 mem_ctx = state->out_mem_ctx;
2120         } else {
2121                 mem_ctx = state;
2122         }
2123
2124         status = state->dispatch_recv(subreq, mem_ctx);
2125         TALLOC_FREE(subreq);
2126         if (!NT_STATUS_IS_OK(status)) {
2127                 tevent_req_nterror(req, status);
2128                 return;
2129         }
2130
2131         /* Copy out parameters */
2132         *state->orig.out.reg_data_type = *state->tmp.out.reg_data_type;
2133         memcpy(state->orig.out.buffer, state->tmp.out.buffer, *state->tmp.in.buffer_size * sizeof(*state->orig.out.buffer));
2134         *state->orig.out.buffer_size = *state->tmp.out.buffer_size;
2135         *state->orig.out.needed = *state->tmp.out.needed;
2136
2137         /* Copy result */
2138         state->orig.out.result = state->tmp.out.result;
2139
2140         /* Reset temporary structure */
2141         ZERO_STRUCT(state->tmp);
2142
2143         if (DEBUGLEVEL >= 10) {
2144                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceRegProp, &state->orig);
2145         }
2146
2147         tevent_req_done(req);
2148 }
2149
2150 NTSTATUS rpccli_PNP_GetDeviceRegProp_recv(struct tevent_req *req,
2151                                           TALLOC_CTX *mem_ctx,
2152                                           WERROR *result)
2153 {
2154         struct rpccli_PNP_GetDeviceRegProp_state *state = tevent_req_data(
2155                 req, struct rpccli_PNP_GetDeviceRegProp_state);
2156         NTSTATUS status;
2157
2158         if (tevent_req_is_nterror(req, &status)) {
2159                 tevent_req_received(req);
2160                 return status;
2161         }
2162
2163         /* Steal possbile out parameters to the callers context */
2164         talloc_steal(mem_ctx, state->out_mem_ctx);
2165
2166         /* Return result */
2167         *result = state->orig.out.result;
2168
2169         tevent_req_received(req);
2170         return NT_STATUS_OK;
2171 }
2172
2173 NTSTATUS rpccli_PNP_GetDeviceRegProp(struct rpc_pipe_client *cli,
2174                                      TALLOC_CTX *mem_ctx,
2175                                      const char *devicepath /* [in] [ref,charset(UTF16)] */,
2176                                      uint32_t property /* [in]  */,
2177                                      enum winreg_Type *reg_data_type /* [in,out] [ref] */,
2178                                      uint8_t *buffer /* [out] [ref,length_is(*buffer_size),size_is(*buffer_size)] */,
2179                                      uint32_t *buffer_size /* [in,out] [ref] */,
2180                                      uint32_t *needed /* [in,out] [ref] */,
2181                                      uint32_t flags /* [in]  */,
2182                                      WERROR *werror)
2183 {
2184         struct PNP_GetDeviceRegProp r;
2185         NTSTATUS status;
2186
2187         /* In parameters */
2188         r.in.devicepath = devicepath;
2189         r.in.property = property;
2190         r.in.reg_data_type = reg_data_type;
2191         r.in.buffer_size = buffer_size;
2192         r.in.needed = needed;
2193         r.in.flags = flags;
2194
2195         if (DEBUGLEVEL >= 10) {
2196                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceRegProp, &r);
2197         }
2198
2199         status = cli->dispatch(cli,
2200                                 mem_ctx,
2201                                 &ndr_table_ntsvcs,
2202                                 NDR_PNP_GETDEVICEREGPROP,
2203                                 &r);
2204
2205         if (!NT_STATUS_IS_OK(status)) {
2206                 return status;
2207         }
2208
2209         if (DEBUGLEVEL >= 10) {
2210                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceRegProp, &r);
2211         }
2212
2213         if (NT_STATUS_IS_ERR(status)) {
2214                 return status;
2215         }
2216
2217         /* Return variables */
2218         *reg_data_type = *r.out.reg_data_type;
2219         memcpy(buffer, r.out.buffer, *r.in.buffer_size * sizeof(*buffer));
2220         *buffer_size = *r.out.buffer_size;
2221         *needed = *r.out.needed;
2222
2223         /* Return result */
2224         if (werror) {
2225                 *werror = r.out.result;
2226         }
2227
2228         return werror_to_ntstatus(r.out.result);
2229 }
2230
2231 struct rpccli_PNP_SetDeviceRegProp_state {
2232         struct PNP_SetDeviceRegProp orig;
2233         struct PNP_SetDeviceRegProp tmp;
2234         TALLOC_CTX *out_mem_ctx;
2235         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2236 };
2237
2238 static void rpccli_PNP_SetDeviceRegProp_done(struct tevent_req *subreq);
2239
2240 struct tevent_req *rpccli_PNP_SetDeviceRegProp_send(TALLOC_CTX *mem_ctx,
2241                                                     struct tevent_context *ev,
2242                                                     struct rpc_pipe_client *cli)
2243 {
2244         struct tevent_req *req;
2245         struct rpccli_PNP_SetDeviceRegProp_state *state;
2246         struct tevent_req *subreq;
2247
2248         req = tevent_req_create(mem_ctx, &state,
2249                                 struct rpccli_PNP_SetDeviceRegProp_state);
2250         if (req == NULL) {
2251                 return NULL;
2252         }
2253         state->out_mem_ctx = NULL;
2254         state->dispatch_recv = cli->dispatch_recv;
2255
2256         /* In parameters */
2257
2258         /* Out parameters */
2259
2260         /* Result */
2261         ZERO_STRUCT(state->orig.out.result);
2262
2263         if (DEBUGLEVEL >= 10) {
2264                 NDR_PRINT_IN_DEBUG(PNP_SetDeviceRegProp, &state->orig);
2265         }
2266
2267         /* make a temporary copy, that we pass to the dispatch function */
2268         state->tmp = state->orig;
2269
2270         subreq = cli->dispatch_send(state, ev, cli,
2271                                     &ndr_table_ntsvcs,
2272                                     NDR_PNP_SETDEVICEREGPROP,
2273                                     &state->tmp);
2274         if (tevent_req_nomem(subreq, req)) {
2275                 return tevent_req_post(req, ev);
2276         }
2277         tevent_req_set_callback(subreq, rpccli_PNP_SetDeviceRegProp_done, req);
2278         return req;
2279 }
2280
2281 static void rpccli_PNP_SetDeviceRegProp_done(struct tevent_req *subreq)
2282 {
2283         struct tevent_req *req = tevent_req_callback_data(
2284                 subreq, struct tevent_req);
2285         struct rpccli_PNP_SetDeviceRegProp_state *state = tevent_req_data(
2286                 req, struct rpccli_PNP_SetDeviceRegProp_state);
2287         NTSTATUS status;
2288         TALLOC_CTX *mem_ctx;
2289
2290         if (state->out_mem_ctx) {
2291                 mem_ctx = state->out_mem_ctx;
2292         } else {
2293                 mem_ctx = state;
2294         }
2295
2296         status = state->dispatch_recv(subreq, mem_ctx);
2297         TALLOC_FREE(subreq);
2298         if (!NT_STATUS_IS_OK(status)) {
2299                 tevent_req_nterror(req, status);
2300                 return;
2301         }
2302
2303         /* Copy out parameters */
2304
2305         /* Copy result */
2306         state->orig.out.result = state->tmp.out.result;
2307
2308         /* Reset temporary structure */
2309         ZERO_STRUCT(state->tmp);
2310
2311         if (DEBUGLEVEL >= 10) {
2312                 NDR_PRINT_OUT_DEBUG(PNP_SetDeviceRegProp, &state->orig);
2313         }
2314
2315         tevent_req_done(req);
2316 }
2317
2318 NTSTATUS rpccli_PNP_SetDeviceRegProp_recv(struct tevent_req *req,
2319                                           TALLOC_CTX *mem_ctx,
2320                                           WERROR *result)
2321 {
2322         struct rpccli_PNP_SetDeviceRegProp_state *state = tevent_req_data(
2323                 req, struct rpccli_PNP_SetDeviceRegProp_state);
2324         NTSTATUS status;
2325
2326         if (tevent_req_is_nterror(req, &status)) {
2327                 tevent_req_received(req);
2328                 return status;
2329         }
2330
2331         /* Steal possbile out parameters to the callers context */
2332         talloc_steal(mem_ctx, state->out_mem_ctx);
2333
2334         /* Return result */
2335         *result = state->orig.out.result;
2336
2337         tevent_req_received(req);
2338         return NT_STATUS_OK;
2339 }
2340
2341 NTSTATUS rpccli_PNP_SetDeviceRegProp(struct rpc_pipe_client *cli,
2342                                      TALLOC_CTX *mem_ctx,
2343                                      WERROR *werror)
2344 {
2345         struct PNP_SetDeviceRegProp r;
2346         NTSTATUS status;
2347
2348         /* In parameters */
2349
2350         if (DEBUGLEVEL >= 10) {
2351                 NDR_PRINT_IN_DEBUG(PNP_SetDeviceRegProp, &r);
2352         }
2353
2354         status = cli->dispatch(cli,
2355                                 mem_ctx,
2356                                 &ndr_table_ntsvcs,
2357                                 NDR_PNP_SETDEVICEREGPROP,
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_SetDeviceRegProp, &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 struct rpccli_PNP_GetClassInstance_state {
2383         struct PNP_GetClassInstance orig;
2384         struct PNP_GetClassInstance tmp;
2385         TALLOC_CTX *out_mem_ctx;
2386         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2387 };
2388
2389 static void rpccli_PNP_GetClassInstance_done(struct tevent_req *subreq);
2390
2391 struct tevent_req *rpccli_PNP_GetClassInstance_send(TALLOC_CTX *mem_ctx,
2392                                                     struct tevent_context *ev,
2393                                                     struct rpc_pipe_client *cli)
2394 {
2395         struct tevent_req *req;
2396         struct rpccli_PNP_GetClassInstance_state *state;
2397         struct tevent_req *subreq;
2398
2399         req = tevent_req_create(mem_ctx, &state,
2400                                 struct rpccli_PNP_GetClassInstance_state);
2401         if (req == NULL) {
2402                 return NULL;
2403         }
2404         state->out_mem_ctx = NULL;
2405         state->dispatch_recv = cli->dispatch_recv;
2406
2407         /* In parameters */
2408
2409         /* Out parameters */
2410
2411         /* Result */
2412         ZERO_STRUCT(state->orig.out.result);
2413
2414         if (DEBUGLEVEL >= 10) {
2415                 NDR_PRINT_IN_DEBUG(PNP_GetClassInstance, &state->orig);
2416         }
2417
2418         /* make a temporary copy, that we pass to the dispatch function */
2419         state->tmp = state->orig;
2420
2421         subreq = cli->dispatch_send(state, ev, cli,
2422                                     &ndr_table_ntsvcs,
2423                                     NDR_PNP_GETCLASSINSTANCE,
2424                                     &state->tmp);
2425         if (tevent_req_nomem(subreq, req)) {
2426                 return tevent_req_post(req, ev);
2427         }
2428         tevent_req_set_callback(subreq, rpccli_PNP_GetClassInstance_done, req);
2429         return req;
2430 }
2431
2432 static void rpccli_PNP_GetClassInstance_done(struct tevent_req *subreq)
2433 {
2434         struct tevent_req *req = tevent_req_callback_data(
2435                 subreq, struct tevent_req);
2436         struct rpccli_PNP_GetClassInstance_state *state = tevent_req_data(
2437                 req, struct rpccli_PNP_GetClassInstance_state);
2438         NTSTATUS status;
2439         TALLOC_CTX *mem_ctx;
2440
2441         if (state->out_mem_ctx) {
2442                 mem_ctx = state->out_mem_ctx;
2443         } else {
2444                 mem_ctx = state;
2445         }
2446
2447         status = state->dispatch_recv(subreq, mem_ctx);
2448         TALLOC_FREE(subreq);
2449         if (!NT_STATUS_IS_OK(status)) {
2450                 tevent_req_nterror(req, status);
2451                 return;
2452         }
2453
2454         /* Copy out parameters */
2455
2456         /* Copy result */
2457         state->orig.out.result = state->tmp.out.result;
2458
2459         /* Reset temporary structure */
2460         ZERO_STRUCT(state->tmp);
2461
2462         if (DEBUGLEVEL >= 10) {
2463                 NDR_PRINT_OUT_DEBUG(PNP_GetClassInstance, &state->orig);
2464         }
2465
2466         tevent_req_done(req);
2467 }
2468
2469 NTSTATUS rpccli_PNP_GetClassInstance_recv(struct tevent_req *req,
2470                                           TALLOC_CTX *mem_ctx,
2471                                           WERROR *result)
2472 {
2473         struct rpccli_PNP_GetClassInstance_state *state = tevent_req_data(
2474                 req, struct rpccli_PNP_GetClassInstance_state);
2475         NTSTATUS status;
2476
2477         if (tevent_req_is_nterror(req, &status)) {
2478                 tevent_req_received(req);
2479                 return status;
2480         }
2481
2482         /* Steal possbile out parameters to the callers context */
2483         talloc_steal(mem_ctx, state->out_mem_ctx);
2484
2485         /* Return result */
2486         *result = state->orig.out.result;
2487
2488         tevent_req_received(req);
2489         return NT_STATUS_OK;
2490 }
2491
2492 NTSTATUS rpccli_PNP_GetClassInstance(struct rpc_pipe_client *cli,
2493                                      TALLOC_CTX *mem_ctx,
2494                                      WERROR *werror)
2495 {
2496         struct PNP_GetClassInstance r;
2497         NTSTATUS status;
2498
2499         /* In parameters */
2500
2501         if (DEBUGLEVEL >= 10) {
2502                 NDR_PRINT_IN_DEBUG(PNP_GetClassInstance, &r);
2503         }
2504
2505         status = cli->dispatch(cli,
2506                                 mem_ctx,
2507                                 &ndr_table_ntsvcs,
2508                                 NDR_PNP_GETCLASSINSTANCE,
2509                                 &r);
2510
2511         if (!NT_STATUS_IS_OK(status)) {
2512                 return status;
2513         }
2514
2515         if (DEBUGLEVEL >= 10) {
2516                 NDR_PRINT_OUT_DEBUG(PNP_GetClassInstance, &r);
2517         }
2518
2519         if (NT_STATUS_IS_ERR(status)) {
2520                 return status;
2521         }
2522
2523         /* Return variables */
2524
2525         /* Return result */
2526         if (werror) {
2527                 *werror = r.out.result;
2528         }
2529
2530         return werror_to_ntstatus(r.out.result);
2531 }
2532
2533 struct rpccli_PNP_CreateKey_state {
2534         struct PNP_CreateKey orig;
2535         struct PNP_CreateKey tmp;
2536         TALLOC_CTX *out_mem_ctx;
2537         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2538 };
2539
2540 static void rpccli_PNP_CreateKey_done(struct tevent_req *subreq);
2541
2542 struct tevent_req *rpccli_PNP_CreateKey_send(TALLOC_CTX *mem_ctx,
2543                                              struct tevent_context *ev,
2544                                              struct rpc_pipe_client *cli)
2545 {
2546         struct tevent_req *req;
2547         struct rpccli_PNP_CreateKey_state *state;
2548         struct tevent_req *subreq;
2549
2550         req = tevent_req_create(mem_ctx, &state,
2551                                 struct rpccli_PNP_CreateKey_state);
2552         if (req == NULL) {
2553                 return NULL;
2554         }
2555         state->out_mem_ctx = NULL;
2556         state->dispatch_recv = cli->dispatch_recv;
2557
2558         /* In parameters */
2559
2560         /* Out parameters */
2561
2562         /* Result */
2563         ZERO_STRUCT(state->orig.out.result);
2564
2565         if (DEBUGLEVEL >= 10) {
2566                 NDR_PRINT_IN_DEBUG(PNP_CreateKey, &state->orig);
2567         }
2568
2569         /* make a temporary copy, that we pass to the dispatch function */
2570         state->tmp = state->orig;
2571
2572         subreq = cli->dispatch_send(state, ev, cli,
2573                                     &ndr_table_ntsvcs,
2574                                     NDR_PNP_CREATEKEY,
2575                                     &state->tmp);
2576         if (tevent_req_nomem(subreq, req)) {
2577                 return tevent_req_post(req, ev);
2578         }
2579         tevent_req_set_callback(subreq, rpccli_PNP_CreateKey_done, req);
2580         return req;
2581 }
2582
2583 static void rpccli_PNP_CreateKey_done(struct tevent_req *subreq)
2584 {
2585         struct tevent_req *req = tevent_req_callback_data(
2586                 subreq, struct tevent_req);
2587         struct rpccli_PNP_CreateKey_state *state = tevent_req_data(
2588                 req, struct rpccli_PNP_CreateKey_state);
2589         NTSTATUS status;
2590         TALLOC_CTX *mem_ctx;
2591
2592         if (state->out_mem_ctx) {
2593                 mem_ctx = state->out_mem_ctx;
2594         } else {
2595                 mem_ctx = state;
2596         }
2597
2598         status = state->dispatch_recv(subreq, mem_ctx);
2599         TALLOC_FREE(subreq);
2600         if (!NT_STATUS_IS_OK(status)) {
2601                 tevent_req_nterror(req, status);
2602                 return;
2603         }
2604
2605         /* Copy out parameters */
2606
2607         /* Copy result */
2608         state->orig.out.result = state->tmp.out.result;
2609
2610         /* Reset temporary structure */
2611         ZERO_STRUCT(state->tmp);
2612
2613         if (DEBUGLEVEL >= 10) {
2614                 NDR_PRINT_OUT_DEBUG(PNP_CreateKey, &state->orig);
2615         }
2616
2617         tevent_req_done(req);
2618 }
2619
2620 NTSTATUS rpccli_PNP_CreateKey_recv(struct tevent_req *req,
2621                                    TALLOC_CTX *mem_ctx,
2622                                    WERROR *result)
2623 {
2624         struct rpccli_PNP_CreateKey_state *state = tevent_req_data(
2625                 req, struct rpccli_PNP_CreateKey_state);
2626         NTSTATUS status;
2627
2628         if (tevent_req_is_nterror(req, &status)) {
2629                 tevent_req_received(req);
2630                 return status;
2631         }
2632
2633         /* Steal possbile out parameters to the callers context */
2634         talloc_steal(mem_ctx, state->out_mem_ctx);
2635
2636         /* Return result */
2637         *result = state->orig.out.result;
2638
2639         tevent_req_received(req);
2640         return NT_STATUS_OK;
2641 }
2642
2643 NTSTATUS rpccli_PNP_CreateKey(struct rpc_pipe_client *cli,
2644                               TALLOC_CTX *mem_ctx,
2645                               WERROR *werror)
2646 {
2647         struct PNP_CreateKey r;
2648         NTSTATUS status;
2649
2650         /* In parameters */
2651
2652         if (DEBUGLEVEL >= 10) {
2653                 NDR_PRINT_IN_DEBUG(PNP_CreateKey, &r);
2654         }
2655
2656         status = cli->dispatch(cli,
2657                                 mem_ctx,
2658                                 &ndr_table_ntsvcs,
2659                                 NDR_PNP_CREATEKEY,
2660                                 &r);
2661
2662         if (!NT_STATUS_IS_OK(status)) {
2663                 return status;
2664         }
2665
2666         if (DEBUGLEVEL >= 10) {
2667                 NDR_PRINT_OUT_DEBUG(PNP_CreateKey, &r);
2668         }
2669
2670         if (NT_STATUS_IS_ERR(status)) {
2671                 return status;
2672         }
2673
2674         /* Return variables */
2675
2676         /* Return result */
2677         if (werror) {
2678                 *werror = r.out.result;
2679         }
2680
2681         return werror_to_ntstatus(r.out.result);
2682 }
2683
2684 struct rpccli_PNP_DeleteRegistryKey_state {
2685         struct PNP_DeleteRegistryKey orig;
2686         struct PNP_DeleteRegistryKey tmp;
2687         TALLOC_CTX *out_mem_ctx;
2688         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2689 };
2690
2691 static void rpccli_PNP_DeleteRegistryKey_done(struct tevent_req *subreq);
2692
2693 struct tevent_req *rpccli_PNP_DeleteRegistryKey_send(TALLOC_CTX *mem_ctx,
2694                                                      struct tevent_context *ev,
2695                                                      struct rpc_pipe_client *cli)
2696 {
2697         struct tevent_req *req;
2698         struct rpccli_PNP_DeleteRegistryKey_state *state;
2699         struct tevent_req *subreq;
2700
2701         req = tevent_req_create(mem_ctx, &state,
2702                                 struct rpccli_PNP_DeleteRegistryKey_state);
2703         if (req == NULL) {
2704                 return NULL;
2705         }
2706         state->out_mem_ctx = NULL;
2707         state->dispatch_recv = cli->dispatch_recv;
2708
2709         /* In parameters */
2710
2711         /* Out parameters */
2712
2713         /* Result */
2714         ZERO_STRUCT(state->orig.out.result);
2715
2716         if (DEBUGLEVEL >= 10) {
2717                 NDR_PRINT_IN_DEBUG(PNP_DeleteRegistryKey, &state->orig);
2718         }
2719
2720         /* make a temporary copy, that we pass to the dispatch function */
2721         state->tmp = state->orig;
2722
2723         subreq = cli->dispatch_send(state, ev, cli,
2724                                     &ndr_table_ntsvcs,
2725                                     NDR_PNP_DELETEREGISTRYKEY,
2726                                     &state->tmp);
2727         if (tevent_req_nomem(subreq, req)) {
2728                 return tevent_req_post(req, ev);
2729         }
2730         tevent_req_set_callback(subreq, rpccli_PNP_DeleteRegistryKey_done, req);
2731         return req;
2732 }
2733
2734 static void rpccli_PNP_DeleteRegistryKey_done(struct tevent_req *subreq)
2735 {
2736         struct tevent_req *req = tevent_req_callback_data(
2737                 subreq, struct tevent_req);
2738         struct rpccli_PNP_DeleteRegistryKey_state *state = tevent_req_data(
2739                 req, struct rpccli_PNP_DeleteRegistryKey_state);
2740         NTSTATUS status;
2741         TALLOC_CTX *mem_ctx;
2742
2743         if (state->out_mem_ctx) {
2744                 mem_ctx = state->out_mem_ctx;
2745         } else {
2746                 mem_ctx = state;
2747         }
2748
2749         status = state->dispatch_recv(subreq, mem_ctx);
2750         TALLOC_FREE(subreq);
2751         if (!NT_STATUS_IS_OK(status)) {
2752                 tevent_req_nterror(req, status);
2753                 return;
2754         }
2755
2756         /* Copy out parameters */
2757
2758         /* Copy result */
2759         state->orig.out.result = state->tmp.out.result;
2760
2761         /* Reset temporary structure */
2762         ZERO_STRUCT(state->tmp);
2763
2764         if (DEBUGLEVEL >= 10) {
2765                 NDR_PRINT_OUT_DEBUG(PNP_DeleteRegistryKey, &state->orig);
2766         }
2767
2768         tevent_req_done(req);
2769 }
2770
2771 NTSTATUS rpccli_PNP_DeleteRegistryKey_recv(struct tevent_req *req,
2772                                            TALLOC_CTX *mem_ctx,
2773                                            WERROR *result)
2774 {
2775         struct rpccli_PNP_DeleteRegistryKey_state *state = tevent_req_data(
2776                 req, struct rpccli_PNP_DeleteRegistryKey_state);
2777         NTSTATUS status;
2778
2779         if (tevent_req_is_nterror(req, &status)) {
2780                 tevent_req_received(req);
2781                 return status;
2782         }
2783
2784         /* Steal possbile out parameters to the callers context */
2785         talloc_steal(mem_ctx, state->out_mem_ctx);
2786
2787         /* Return result */
2788         *result = state->orig.out.result;
2789
2790         tevent_req_received(req);
2791         return NT_STATUS_OK;
2792 }
2793
2794 NTSTATUS rpccli_PNP_DeleteRegistryKey(struct rpc_pipe_client *cli,
2795                                       TALLOC_CTX *mem_ctx,
2796                                       WERROR *werror)
2797 {
2798         struct PNP_DeleteRegistryKey r;
2799         NTSTATUS status;
2800
2801         /* In parameters */
2802
2803         if (DEBUGLEVEL >= 10) {
2804                 NDR_PRINT_IN_DEBUG(PNP_DeleteRegistryKey, &r);
2805         }
2806
2807         status = cli->dispatch(cli,
2808                                 mem_ctx,
2809                                 &ndr_table_ntsvcs,
2810                                 NDR_PNP_DELETEREGISTRYKEY,
2811                                 &r);
2812
2813         if (!NT_STATUS_IS_OK(status)) {
2814                 return status;
2815         }
2816
2817         if (DEBUGLEVEL >= 10) {
2818                 NDR_PRINT_OUT_DEBUG(PNP_DeleteRegistryKey, &r);
2819         }
2820
2821         if (NT_STATUS_IS_ERR(status)) {
2822                 return status;
2823         }
2824
2825         /* Return variables */
2826
2827         /* Return result */
2828         if (werror) {
2829                 *werror = r.out.result;
2830         }
2831
2832         return werror_to_ntstatus(r.out.result);
2833 }
2834
2835 struct rpccli_PNP_GetClassCount_state {
2836         struct PNP_GetClassCount orig;
2837         struct PNP_GetClassCount tmp;
2838         TALLOC_CTX *out_mem_ctx;
2839         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2840 };
2841
2842 static void rpccli_PNP_GetClassCount_done(struct tevent_req *subreq);
2843
2844 struct tevent_req *rpccli_PNP_GetClassCount_send(TALLOC_CTX *mem_ctx,
2845                                                  struct tevent_context *ev,
2846                                                  struct rpc_pipe_client *cli)
2847 {
2848         struct tevent_req *req;
2849         struct rpccli_PNP_GetClassCount_state *state;
2850         struct tevent_req *subreq;
2851
2852         req = tevent_req_create(mem_ctx, &state,
2853                                 struct rpccli_PNP_GetClassCount_state);
2854         if (req == NULL) {
2855                 return NULL;
2856         }
2857         state->out_mem_ctx = NULL;
2858         state->dispatch_recv = cli->dispatch_recv;
2859
2860         /* In parameters */
2861
2862         /* Out parameters */
2863
2864         /* Result */
2865         ZERO_STRUCT(state->orig.out.result);
2866
2867         if (DEBUGLEVEL >= 10) {
2868                 NDR_PRINT_IN_DEBUG(PNP_GetClassCount, &state->orig);
2869         }
2870
2871         /* make a temporary copy, that we pass to the dispatch function */
2872         state->tmp = state->orig;
2873
2874         subreq = cli->dispatch_send(state, ev, cli,
2875                                     &ndr_table_ntsvcs,
2876                                     NDR_PNP_GETCLASSCOUNT,
2877                                     &state->tmp);
2878         if (tevent_req_nomem(subreq, req)) {
2879                 return tevent_req_post(req, ev);
2880         }
2881         tevent_req_set_callback(subreq, rpccli_PNP_GetClassCount_done, req);
2882         return req;
2883 }
2884
2885 static void rpccli_PNP_GetClassCount_done(struct tevent_req *subreq)
2886 {
2887         struct tevent_req *req = tevent_req_callback_data(
2888                 subreq, struct tevent_req);
2889         struct rpccli_PNP_GetClassCount_state *state = tevent_req_data(
2890                 req, struct rpccli_PNP_GetClassCount_state);
2891         NTSTATUS status;
2892         TALLOC_CTX *mem_ctx;
2893
2894         if (state->out_mem_ctx) {
2895                 mem_ctx = state->out_mem_ctx;
2896         } else {
2897                 mem_ctx = state;
2898         }
2899
2900         status = state->dispatch_recv(subreq, mem_ctx);
2901         TALLOC_FREE(subreq);
2902         if (!NT_STATUS_IS_OK(status)) {
2903                 tevent_req_nterror(req, status);
2904                 return;
2905         }
2906
2907         /* Copy out parameters */
2908
2909         /* Copy result */
2910         state->orig.out.result = state->tmp.out.result;
2911
2912         /* Reset temporary structure */
2913         ZERO_STRUCT(state->tmp);
2914
2915         if (DEBUGLEVEL >= 10) {
2916                 NDR_PRINT_OUT_DEBUG(PNP_GetClassCount, &state->orig);
2917         }
2918
2919         tevent_req_done(req);
2920 }
2921
2922 NTSTATUS rpccli_PNP_GetClassCount_recv(struct tevent_req *req,
2923                                        TALLOC_CTX *mem_ctx,
2924                                        WERROR *result)
2925 {
2926         struct rpccli_PNP_GetClassCount_state *state = tevent_req_data(
2927                 req, struct rpccli_PNP_GetClassCount_state);
2928         NTSTATUS status;
2929
2930         if (tevent_req_is_nterror(req, &status)) {
2931                 tevent_req_received(req);
2932                 return status;
2933         }
2934
2935         /* Steal possbile out parameters to the callers context */
2936         talloc_steal(mem_ctx, state->out_mem_ctx);
2937
2938         /* Return result */
2939         *result = state->orig.out.result;
2940
2941         tevent_req_received(req);
2942         return NT_STATUS_OK;
2943 }
2944
2945 NTSTATUS rpccli_PNP_GetClassCount(struct rpc_pipe_client *cli,
2946                                   TALLOC_CTX *mem_ctx,
2947                                   WERROR *werror)
2948 {
2949         struct PNP_GetClassCount r;
2950         NTSTATUS status;
2951
2952         /* In parameters */
2953
2954         if (DEBUGLEVEL >= 10) {
2955                 NDR_PRINT_IN_DEBUG(PNP_GetClassCount, &r);
2956         }
2957
2958         status = cli->dispatch(cli,
2959                                 mem_ctx,
2960                                 &ndr_table_ntsvcs,
2961                                 NDR_PNP_GETCLASSCOUNT,
2962                                 &r);
2963
2964         if (!NT_STATUS_IS_OK(status)) {
2965                 return status;
2966         }
2967
2968         if (DEBUGLEVEL >= 10) {
2969                 NDR_PRINT_OUT_DEBUG(PNP_GetClassCount, &r);
2970         }
2971
2972         if (NT_STATUS_IS_ERR(status)) {
2973                 return status;
2974         }
2975
2976         /* Return variables */
2977
2978         /* Return result */
2979         if (werror) {
2980                 *werror = r.out.result;
2981         }
2982
2983         return werror_to_ntstatus(r.out.result);
2984 }
2985
2986 struct rpccli_PNP_GetClassName_state {
2987         struct PNP_GetClassName orig;
2988         struct PNP_GetClassName tmp;
2989         TALLOC_CTX *out_mem_ctx;
2990         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2991 };
2992
2993 static void rpccli_PNP_GetClassName_done(struct tevent_req *subreq);
2994
2995 struct tevent_req *rpccli_PNP_GetClassName_send(TALLOC_CTX *mem_ctx,
2996                                                 struct tevent_context *ev,
2997                                                 struct rpc_pipe_client *cli)
2998 {
2999         struct tevent_req *req;
3000         struct rpccli_PNP_GetClassName_state *state;
3001         struct tevent_req *subreq;
3002
3003         req = tevent_req_create(mem_ctx, &state,
3004                                 struct rpccli_PNP_GetClassName_state);
3005         if (req == NULL) {
3006                 return NULL;
3007         }
3008         state->out_mem_ctx = NULL;
3009         state->dispatch_recv = cli->dispatch_recv;
3010
3011         /* In parameters */
3012
3013         /* Out parameters */
3014
3015         /* Result */
3016         ZERO_STRUCT(state->orig.out.result);
3017
3018         if (DEBUGLEVEL >= 10) {
3019                 NDR_PRINT_IN_DEBUG(PNP_GetClassName, &state->orig);
3020         }
3021
3022         /* make a temporary copy, that we pass to the dispatch function */
3023         state->tmp = state->orig;
3024
3025         subreq = cli->dispatch_send(state, ev, cli,
3026                                     &ndr_table_ntsvcs,
3027                                     NDR_PNP_GETCLASSNAME,
3028                                     &state->tmp);
3029         if (tevent_req_nomem(subreq, req)) {
3030                 return tevent_req_post(req, ev);
3031         }
3032         tevent_req_set_callback(subreq, rpccli_PNP_GetClassName_done, req);
3033         return req;
3034 }
3035
3036 static void rpccli_PNP_GetClassName_done(struct tevent_req *subreq)
3037 {
3038         struct tevent_req *req = tevent_req_callback_data(
3039                 subreq, struct tevent_req);
3040         struct rpccli_PNP_GetClassName_state *state = tevent_req_data(
3041                 req, struct rpccli_PNP_GetClassName_state);
3042         NTSTATUS status;
3043         TALLOC_CTX *mem_ctx;
3044
3045         if (state->out_mem_ctx) {
3046                 mem_ctx = state->out_mem_ctx;
3047         } else {
3048                 mem_ctx = state;
3049         }
3050
3051         status = state->dispatch_recv(subreq, mem_ctx);
3052         TALLOC_FREE(subreq);
3053         if (!NT_STATUS_IS_OK(status)) {
3054                 tevent_req_nterror(req, status);
3055                 return;
3056         }
3057
3058         /* Copy out parameters */
3059
3060         /* Copy result */
3061         state->orig.out.result = state->tmp.out.result;
3062
3063         /* Reset temporary structure */
3064         ZERO_STRUCT(state->tmp);
3065
3066         if (DEBUGLEVEL >= 10) {
3067                 NDR_PRINT_OUT_DEBUG(PNP_GetClassName, &state->orig);
3068         }
3069
3070         tevent_req_done(req);
3071 }
3072
3073 NTSTATUS rpccli_PNP_GetClassName_recv(struct tevent_req *req,
3074                                       TALLOC_CTX *mem_ctx,
3075                                       WERROR *result)
3076 {
3077         struct rpccli_PNP_GetClassName_state *state = tevent_req_data(
3078                 req, struct rpccli_PNP_GetClassName_state);
3079         NTSTATUS status;
3080
3081         if (tevent_req_is_nterror(req, &status)) {
3082                 tevent_req_received(req);
3083                 return status;
3084         }
3085
3086         /* Steal possbile out parameters to the callers context */
3087         talloc_steal(mem_ctx, state->out_mem_ctx);
3088
3089         /* Return result */
3090         *result = state->orig.out.result;
3091
3092         tevent_req_received(req);
3093         return NT_STATUS_OK;
3094 }
3095
3096 NTSTATUS rpccli_PNP_GetClassName(struct rpc_pipe_client *cli,
3097                                  TALLOC_CTX *mem_ctx,
3098                                  WERROR *werror)
3099 {
3100         struct PNP_GetClassName r;
3101         NTSTATUS status;
3102
3103         /* In parameters */
3104
3105         if (DEBUGLEVEL >= 10) {
3106                 NDR_PRINT_IN_DEBUG(PNP_GetClassName, &r);
3107         }
3108
3109         status = cli->dispatch(cli,
3110                                 mem_ctx,
3111                                 &ndr_table_ntsvcs,
3112                                 NDR_PNP_GETCLASSNAME,
3113                                 &r);
3114
3115         if (!NT_STATUS_IS_OK(status)) {
3116                 return status;
3117         }
3118
3119         if (DEBUGLEVEL >= 10) {
3120                 NDR_PRINT_OUT_DEBUG(PNP_GetClassName, &r);
3121         }
3122
3123         if (NT_STATUS_IS_ERR(status)) {
3124                 return status;
3125         }
3126
3127         /* Return variables */
3128
3129         /* Return result */
3130         if (werror) {
3131                 *werror = r.out.result;
3132         }
3133
3134         return werror_to_ntstatus(r.out.result);
3135 }
3136
3137 struct rpccli_PNP_DeleteClassKey_state {
3138         struct PNP_DeleteClassKey orig;
3139         struct PNP_DeleteClassKey tmp;
3140         TALLOC_CTX *out_mem_ctx;
3141         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3142 };
3143
3144 static void rpccli_PNP_DeleteClassKey_done(struct tevent_req *subreq);
3145
3146 struct tevent_req *rpccli_PNP_DeleteClassKey_send(TALLOC_CTX *mem_ctx,
3147                                                   struct tevent_context *ev,
3148                                                   struct rpc_pipe_client *cli)
3149 {
3150         struct tevent_req *req;
3151         struct rpccli_PNP_DeleteClassKey_state *state;
3152         struct tevent_req *subreq;
3153
3154         req = tevent_req_create(mem_ctx, &state,
3155                                 struct rpccli_PNP_DeleteClassKey_state);
3156         if (req == NULL) {
3157                 return NULL;
3158         }
3159         state->out_mem_ctx = NULL;
3160         state->dispatch_recv = cli->dispatch_recv;
3161
3162         /* In parameters */
3163
3164         /* Out parameters */
3165
3166         /* Result */
3167         ZERO_STRUCT(state->orig.out.result);
3168
3169         if (DEBUGLEVEL >= 10) {
3170                 NDR_PRINT_IN_DEBUG(PNP_DeleteClassKey, &state->orig);
3171         }
3172
3173         /* make a temporary copy, that we pass to the dispatch function */
3174         state->tmp = state->orig;
3175
3176         subreq = cli->dispatch_send(state, ev, cli,
3177                                     &ndr_table_ntsvcs,
3178                                     NDR_PNP_DELETECLASSKEY,
3179                                     &state->tmp);
3180         if (tevent_req_nomem(subreq, req)) {
3181                 return tevent_req_post(req, ev);
3182         }
3183         tevent_req_set_callback(subreq, rpccli_PNP_DeleteClassKey_done, req);
3184         return req;
3185 }
3186
3187 static void rpccli_PNP_DeleteClassKey_done(struct tevent_req *subreq)
3188 {
3189         struct tevent_req *req = tevent_req_callback_data(
3190                 subreq, struct tevent_req);
3191         struct rpccli_PNP_DeleteClassKey_state *state = tevent_req_data(
3192                 req, struct rpccli_PNP_DeleteClassKey_state);
3193         NTSTATUS status;
3194         TALLOC_CTX *mem_ctx;
3195
3196         if (state->out_mem_ctx) {
3197                 mem_ctx = state->out_mem_ctx;
3198         } else {
3199                 mem_ctx = state;
3200         }
3201
3202         status = state->dispatch_recv(subreq, mem_ctx);
3203         TALLOC_FREE(subreq);
3204         if (!NT_STATUS_IS_OK(status)) {
3205                 tevent_req_nterror(req, status);
3206                 return;
3207         }
3208
3209         /* Copy out parameters */
3210
3211         /* Copy result */
3212         state->orig.out.result = state->tmp.out.result;
3213
3214         /* Reset temporary structure */
3215         ZERO_STRUCT(state->tmp);
3216
3217         if (DEBUGLEVEL >= 10) {
3218                 NDR_PRINT_OUT_DEBUG(PNP_DeleteClassKey, &state->orig);
3219         }
3220
3221         tevent_req_done(req);
3222 }
3223
3224 NTSTATUS rpccli_PNP_DeleteClassKey_recv(struct tevent_req *req,
3225                                         TALLOC_CTX *mem_ctx,
3226                                         WERROR *result)
3227 {
3228         struct rpccli_PNP_DeleteClassKey_state *state = tevent_req_data(
3229                 req, struct rpccli_PNP_DeleteClassKey_state);
3230         NTSTATUS status;
3231
3232         if (tevent_req_is_nterror(req, &status)) {
3233                 tevent_req_received(req);
3234                 return status;
3235         }
3236
3237         /* Steal possbile out parameters to the callers context */
3238         talloc_steal(mem_ctx, state->out_mem_ctx);
3239
3240         /* Return result */
3241         *result = state->orig.out.result;
3242
3243         tevent_req_received(req);
3244         return NT_STATUS_OK;
3245 }
3246
3247 NTSTATUS rpccli_PNP_DeleteClassKey(struct rpc_pipe_client *cli,
3248                                    TALLOC_CTX *mem_ctx,
3249                                    WERROR *werror)
3250 {
3251         struct PNP_DeleteClassKey r;
3252         NTSTATUS status;
3253
3254         /* In parameters */
3255
3256         if (DEBUGLEVEL >= 10) {
3257                 NDR_PRINT_IN_DEBUG(PNP_DeleteClassKey, &r);
3258         }
3259
3260         status = cli->dispatch(cli,
3261                                 mem_ctx,
3262                                 &ndr_table_ntsvcs,
3263                                 NDR_PNP_DELETECLASSKEY,
3264                                 &r);
3265
3266         if (!NT_STATUS_IS_OK(status)) {
3267                 return status;
3268         }
3269
3270         if (DEBUGLEVEL >= 10) {
3271                 NDR_PRINT_OUT_DEBUG(PNP_DeleteClassKey, &r);
3272         }
3273
3274         if (NT_STATUS_IS_ERR(status)) {
3275                 return status;
3276         }
3277
3278         /* Return variables */
3279
3280         /* Return result */
3281         if (werror) {
3282                 *werror = r.out.result;
3283         }
3284
3285         return werror_to_ntstatus(r.out.result);
3286 }
3287
3288 struct rpccli_PNP_GetInterfaceDeviceAlias_state {
3289         struct PNP_GetInterfaceDeviceAlias orig;
3290         struct PNP_GetInterfaceDeviceAlias tmp;
3291         TALLOC_CTX *out_mem_ctx;
3292         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3293 };
3294
3295 static void rpccli_PNP_GetInterfaceDeviceAlias_done(struct tevent_req *subreq);
3296
3297 struct tevent_req *rpccli_PNP_GetInterfaceDeviceAlias_send(TALLOC_CTX *mem_ctx,
3298                                                            struct tevent_context *ev,
3299                                                            struct rpc_pipe_client *cli)
3300 {
3301         struct tevent_req *req;
3302         struct rpccli_PNP_GetInterfaceDeviceAlias_state *state;
3303         struct tevent_req *subreq;
3304
3305         req = tevent_req_create(mem_ctx, &state,
3306                                 struct rpccli_PNP_GetInterfaceDeviceAlias_state);
3307         if (req == NULL) {
3308                 return NULL;
3309         }
3310         state->out_mem_ctx = NULL;
3311         state->dispatch_recv = cli->dispatch_recv;
3312
3313         /* In parameters */
3314
3315         /* Out parameters */
3316
3317         /* Result */
3318         ZERO_STRUCT(state->orig.out.result);
3319
3320         if (DEBUGLEVEL >= 10) {
3321                 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceAlias, &state->orig);
3322         }
3323
3324         /* make a temporary copy, that we pass to the dispatch function */
3325         state->tmp = state->orig;
3326
3327         subreq = cli->dispatch_send(state, ev, cli,
3328                                     &ndr_table_ntsvcs,
3329                                     NDR_PNP_GETINTERFACEDEVICEALIAS,
3330                                     &state->tmp);
3331         if (tevent_req_nomem(subreq, req)) {
3332                 return tevent_req_post(req, ev);
3333         }
3334         tevent_req_set_callback(subreq, rpccli_PNP_GetInterfaceDeviceAlias_done, req);
3335         return req;
3336 }
3337
3338 static void rpccli_PNP_GetInterfaceDeviceAlias_done(struct tevent_req *subreq)
3339 {
3340         struct tevent_req *req = tevent_req_callback_data(
3341                 subreq, struct tevent_req);
3342         struct rpccli_PNP_GetInterfaceDeviceAlias_state *state = tevent_req_data(
3343                 req, struct rpccli_PNP_GetInterfaceDeviceAlias_state);
3344         NTSTATUS status;
3345         TALLOC_CTX *mem_ctx;
3346
3347         if (state->out_mem_ctx) {
3348                 mem_ctx = state->out_mem_ctx;
3349         } else {
3350                 mem_ctx = state;
3351         }
3352
3353         status = state->dispatch_recv(subreq, mem_ctx);
3354         TALLOC_FREE(subreq);
3355         if (!NT_STATUS_IS_OK(status)) {
3356                 tevent_req_nterror(req, status);
3357                 return;
3358         }
3359
3360         /* Copy out parameters */
3361
3362         /* Copy result */
3363         state->orig.out.result = state->tmp.out.result;
3364
3365         /* Reset temporary structure */
3366         ZERO_STRUCT(state->tmp);
3367
3368         if (DEBUGLEVEL >= 10) {
3369                 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceAlias, &state->orig);
3370         }
3371
3372         tevent_req_done(req);
3373 }
3374
3375 NTSTATUS rpccli_PNP_GetInterfaceDeviceAlias_recv(struct tevent_req *req,
3376                                                  TALLOC_CTX *mem_ctx,
3377                                                  WERROR *result)
3378 {
3379         struct rpccli_PNP_GetInterfaceDeviceAlias_state *state = tevent_req_data(
3380                 req, struct rpccli_PNP_GetInterfaceDeviceAlias_state);
3381         NTSTATUS status;
3382
3383         if (tevent_req_is_nterror(req, &status)) {
3384                 tevent_req_received(req);
3385                 return status;
3386         }
3387
3388         /* Steal possbile out parameters to the callers context */
3389         talloc_steal(mem_ctx, state->out_mem_ctx);
3390
3391         /* Return result */
3392         *result = state->orig.out.result;
3393
3394         tevent_req_received(req);
3395         return NT_STATUS_OK;
3396 }
3397
3398 NTSTATUS rpccli_PNP_GetInterfaceDeviceAlias(struct rpc_pipe_client *cli,
3399                                             TALLOC_CTX *mem_ctx,
3400                                             WERROR *werror)
3401 {
3402         struct PNP_GetInterfaceDeviceAlias r;
3403         NTSTATUS status;
3404
3405         /* In parameters */
3406
3407         if (DEBUGLEVEL >= 10) {
3408                 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceAlias, &r);
3409         }
3410
3411         status = cli->dispatch(cli,
3412                                 mem_ctx,
3413                                 &ndr_table_ntsvcs,
3414                                 NDR_PNP_GETINTERFACEDEVICEALIAS,
3415                                 &r);
3416
3417         if (!NT_STATUS_IS_OK(status)) {
3418                 return status;
3419         }
3420
3421         if (DEBUGLEVEL >= 10) {
3422                 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceAlias, &r);
3423         }
3424
3425         if (NT_STATUS_IS_ERR(status)) {
3426                 return status;
3427         }
3428
3429         /* Return variables */
3430
3431         /* Return result */
3432         if (werror) {
3433                 *werror = r.out.result;
3434         }
3435
3436         return werror_to_ntstatus(r.out.result);
3437 }
3438
3439 struct rpccli_PNP_GetInterfaceDeviceList_state {
3440         struct PNP_GetInterfaceDeviceList orig;
3441         struct PNP_GetInterfaceDeviceList tmp;
3442         TALLOC_CTX *out_mem_ctx;
3443         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3444 };
3445
3446 static void rpccli_PNP_GetInterfaceDeviceList_done(struct tevent_req *subreq);
3447
3448 struct tevent_req *rpccli_PNP_GetInterfaceDeviceList_send(TALLOC_CTX *mem_ctx,
3449                                                           struct tevent_context *ev,
3450                                                           struct rpc_pipe_client *cli)
3451 {
3452         struct tevent_req *req;
3453         struct rpccli_PNP_GetInterfaceDeviceList_state *state;
3454         struct tevent_req *subreq;
3455
3456         req = tevent_req_create(mem_ctx, &state,
3457                                 struct rpccli_PNP_GetInterfaceDeviceList_state);
3458         if (req == NULL) {
3459                 return NULL;
3460         }
3461         state->out_mem_ctx = NULL;
3462         state->dispatch_recv = cli->dispatch_recv;
3463
3464         /* In parameters */
3465
3466         /* Out parameters */
3467
3468         /* Result */
3469         ZERO_STRUCT(state->orig.out.result);
3470
3471         if (DEBUGLEVEL >= 10) {
3472                 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceList, &state->orig);
3473         }
3474
3475         /* make a temporary copy, that we pass to the dispatch function */
3476         state->tmp = state->orig;
3477
3478         subreq = cli->dispatch_send(state, ev, cli,
3479                                     &ndr_table_ntsvcs,
3480                                     NDR_PNP_GETINTERFACEDEVICELIST,
3481                                     &state->tmp);
3482         if (tevent_req_nomem(subreq, req)) {
3483                 return tevent_req_post(req, ev);
3484         }
3485         tevent_req_set_callback(subreq, rpccli_PNP_GetInterfaceDeviceList_done, req);
3486         return req;
3487 }
3488
3489 static void rpccli_PNP_GetInterfaceDeviceList_done(struct tevent_req *subreq)
3490 {
3491         struct tevent_req *req = tevent_req_callback_data(
3492                 subreq, struct tevent_req);
3493         struct rpccli_PNP_GetInterfaceDeviceList_state *state = tevent_req_data(
3494                 req, struct rpccli_PNP_GetInterfaceDeviceList_state);
3495         NTSTATUS status;
3496         TALLOC_CTX *mem_ctx;
3497
3498         if (state->out_mem_ctx) {
3499                 mem_ctx = state->out_mem_ctx;
3500         } else {
3501                 mem_ctx = state;
3502         }
3503
3504         status = state->dispatch_recv(subreq, mem_ctx);
3505         TALLOC_FREE(subreq);
3506         if (!NT_STATUS_IS_OK(status)) {
3507                 tevent_req_nterror(req, status);
3508                 return;
3509         }
3510
3511         /* Copy out parameters */
3512
3513         /* Copy result */
3514         state->orig.out.result = state->tmp.out.result;
3515
3516         /* Reset temporary structure */
3517         ZERO_STRUCT(state->tmp);
3518
3519         if (DEBUGLEVEL >= 10) {
3520                 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceList, &state->orig);
3521         }
3522
3523         tevent_req_done(req);
3524 }
3525
3526 NTSTATUS rpccli_PNP_GetInterfaceDeviceList_recv(struct tevent_req *req,
3527                                                 TALLOC_CTX *mem_ctx,
3528                                                 WERROR *result)
3529 {
3530         struct rpccli_PNP_GetInterfaceDeviceList_state *state = tevent_req_data(
3531                 req, struct rpccli_PNP_GetInterfaceDeviceList_state);
3532         NTSTATUS status;
3533
3534         if (tevent_req_is_nterror(req, &status)) {
3535                 tevent_req_received(req);
3536                 return status;
3537         }
3538
3539         /* Steal possbile out parameters to the callers context */
3540         talloc_steal(mem_ctx, state->out_mem_ctx);
3541
3542         /* Return result */
3543         *result = state->orig.out.result;
3544
3545         tevent_req_received(req);
3546         return NT_STATUS_OK;
3547 }
3548
3549 NTSTATUS rpccli_PNP_GetInterfaceDeviceList(struct rpc_pipe_client *cli,
3550                                            TALLOC_CTX *mem_ctx,
3551                                            WERROR *werror)
3552 {
3553         struct PNP_GetInterfaceDeviceList r;
3554         NTSTATUS status;
3555
3556         /* In parameters */
3557
3558         if (DEBUGLEVEL >= 10) {
3559                 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceList, &r);
3560         }
3561
3562         status = cli->dispatch(cli,
3563                                 mem_ctx,
3564                                 &ndr_table_ntsvcs,
3565                                 NDR_PNP_GETINTERFACEDEVICELIST,
3566                                 &r);
3567
3568         if (!NT_STATUS_IS_OK(status)) {
3569                 return status;
3570         }
3571
3572         if (DEBUGLEVEL >= 10) {
3573                 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceList, &r);
3574         }
3575
3576         if (NT_STATUS_IS_ERR(status)) {
3577                 return status;
3578         }
3579
3580         /* Return variables */
3581
3582         /* Return result */
3583         if (werror) {
3584                 *werror = r.out.result;
3585         }
3586
3587         return werror_to_ntstatus(r.out.result);
3588 }
3589
3590 struct rpccli_PNP_GetInterfaceDeviceListSize_state {
3591         struct PNP_GetInterfaceDeviceListSize orig;
3592         struct PNP_GetInterfaceDeviceListSize tmp;
3593         TALLOC_CTX *out_mem_ctx;
3594         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3595 };
3596
3597 static void rpccli_PNP_GetInterfaceDeviceListSize_done(struct tevent_req *subreq);
3598
3599 struct tevent_req *rpccli_PNP_GetInterfaceDeviceListSize_send(TALLOC_CTX *mem_ctx,
3600                                                               struct tevent_context *ev,
3601                                                               struct rpc_pipe_client *cli)
3602 {
3603         struct tevent_req *req;
3604         struct rpccli_PNP_GetInterfaceDeviceListSize_state *state;
3605         struct tevent_req *subreq;
3606
3607         req = tevent_req_create(mem_ctx, &state,
3608                                 struct rpccli_PNP_GetInterfaceDeviceListSize_state);
3609         if (req == NULL) {
3610                 return NULL;
3611         }
3612         state->out_mem_ctx = NULL;
3613         state->dispatch_recv = cli->dispatch_recv;
3614
3615         /* In parameters */
3616
3617         /* Out parameters */
3618
3619         /* Result */
3620         ZERO_STRUCT(state->orig.out.result);
3621
3622         if (DEBUGLEVEL >= 10) {
3623                 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceListSize, &state->orig);
3624         }
3625
3626         /* make a temporary copy, that we pass to the dispatch function */
3627         state->tmp = state->orig;
3628
3629         subreq = cli->dispatch_send(state, ev, cli,
3630                                     &ndr_table_ntsvcs,
3631                                     NDR_PNP_GETINTERFACEDEVICELISTSIZE,
3632                                     &state->tmp);
3633         if (tevent_req_nomem(subreq, req)) {
3634                 return tevent_req_post(req, ev);
3635         }
3636         tevent_req_set_callback(subreq, rpccli_PNP_GetInterfaceDeviceListSize_done, req);
3637         return req;
3638 }
3639
3640 static void rpccli_PNP_GetInterfaceDeviceListSize_done(struct tevent_req *subreq)
3641 {
3642         struct tevent_req *req = tevent_req_callback_data(
3643                 subreq, struct tevent_req);
3644         struct rpccli_PNP_GetInterfaceDeviceListSize_state *state = tevent_req_data(
3645                 req, struct rpccli_PNP_GetInterfaceDeviceListSize_state);
3646         NTSTATUS status;
3647         TALLOC_CTX *mem_ctx;
3648
3649         if (state->out_mem_ctx) {
3650                 mem_ctx = state->out_mem_ctx;
3651         } else {
3652                 mem_ctx = state;
3653         }
3654
3655         status = state->dispatch_recv(subreq, mem_ctx);
3656         TALLOC_FREE(subreq);
3657         if (!NT_STATUS_IS_OK(status)) {
3658                 tevent_req_nterror(req, status);
3659                 return;
3660         }
3661
3662         /* Copy out parameters */
3663
3664         /* Copy result */
3665         state->orig.out.result = state->tmp.out.result;
3666
3667         /* Reset temporary structure */
3668         ZERO_STRUCT(state->tmp);
3669
3670         if (DEBUGLEVEL >= 10) {
3671                 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceListSize, &state->orig);
3672         }
3673
3674         tevent_req_done(req);
3675 }
3676
3677 NTSTATUS rpccli_PNP_GetInterfaceDeviceListSize_recv(struct tevent_req *req,
3678                                                     TALLOC_CTX *mem_ctx,
3679                                                     WERROR *result)
3680 {
3681         struct rpccli_PNP_GetInterfaceDeviceListSize_state *state = tevent_req_data(
3682                 req, struct rpccli_PNP_GetInterfaceDeviceListSize_state);
3683         NTSTATUS status;
3684
3685         if (tevent_req_is_nterror(req, &status)) {
3686                 tevent_req_received(req);
3687                 return status;
3688         }
3689
3690         /* Steal possbile out parameters to the callers context */
3691         talloc_steal(mem_ctx, state->out_mem_ctx);
3692
3693         /* Return result */
3694         *result = state->orig.out.result;
3695
3696         tevent_req_received(req);
3697         return NT_STATUS_OK;
3698 }
3699
3700 NTSTATUS rpccli_PNP_GetInterfaceDeviceListSize(struct rpc_pipe_client *cli,
3701                                                TALLOC_CTX *mem_ctx,
3702                                                WERROR *werror)
3703 {
3704         struct PNP_GetInterfaceDeviceListSize r;
3705         NTSTATUS status;
3706
3707         /* In parameters */
3708
3709         if (DEBUGLEVEL >= 10) {
3710                 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceListSize, &r);
3711         }
3712
3713         status = cli->dispatch(cli,
3714                                 mem_ctx,
3715                                 &ndr_table_ntsvcs,
3716                                 NDR_PNP_GETINTERFACEDEVICELISTSIZE,
3717                                 &r);
3718
3719         if (!NT_STATUS_IS_OK(status)) {
3720                 return status;
3721         }
3722
3723         if (DEBUGLEVEL >= 10) {
3724                 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceListSize, &r);
3725         }
3726
3727         if (NT_STATUS_IS_ERR(status)) {
3728                 return status;
3729         }
3730
3731         /* Return variables */
3732
3733         /* Return result */
3734         if (werror) {
3735                 *werror = r.out.result;
3736         }
3737
3738         return werror_to_ntstatus(r.out.result);
3739 }
3740
3741 struct rpccli_PNP_RegisterDeviceClassAssociation_state {
3742         struct PNP_RegisterDeviceClassAssociation orig;
3743         struct PNP_RegisterDeviceClassAssociation tmp;
3744         TALLOC_CTX *out_mem_ctx;
3745         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3746 };
3747
3748 static void rpccli_PNP_RegisterDeviceClassAssociation_done(struct tevent_req *subreq);
3749
3750 struct tevent_req *rpccli_PNP_RegisterDeviceClassAssociation_send(TALLOC_CTX *mem_ctx,
3751                                                                   struct tevent_context *ev,
3752                                                                   struct rpc_pipe_client *cli)
3753 {
3754         struct tevent_req *req;
3755         struct rpccli_PNP_RegisterDeviceClassAssociation_state *state;
3756         struct tevent_req *subreq;
3757
3758         req = tevent_req_create(mem_ctx, &state,
3759                                 struct rpccli_PNP_RegisterDeviceClassAssociation_state);
3760         if (req == NULL) {
3761                 return NULL;
3762         }
3763         state->out_mem_ctx = NULL;
3764         state->dispatch_recv = cli->dispatch_recv;
3765
3766         /* In parameters */
3767
3768         /* Out parameters */
3769
3770         /* Result */
3771         ZERO_STRUCT(state->orig.out.result);
3772
3773         if (DEBUGLEVEL >= 10) {
3774                 NDR_PRINT_IN_DEBUG(PNP_RegisterDeviceClassAssociation, &state->orig);
3775         }
3776
3777         /* make a temporary copy, that we pass to the dispatch function */
3778         state->tmp = state->orig;
3779
3780         subreq = cli->dispatch_send(state, ev, cli,
3781                                     &ndr_table_ntsvcs,
3782                                     NDR_PNP_REGISTERDEVICECLASSASSOCIATION,
3783                                     &state->tmp);
3784         if (tevent_req_nomem(subreq, req)) {
3785                 return tevent_req_post(req, ev);
3786         }
3787         tevent_req_set_callback(subreq, rpccli_PNP_RegisterDeviceClassAssociation_done, req);
3788         return req;
3789 }
3790
3791 static void rpccli_PNP_RegisterDeviceClassAssociation_done(struct tevent_req *subreq)
3792 {
3793         struct tevent_req *req = tevent_req_callback_data(
3794                 subreq, struct tevent_req);
3795         struct rpccli_PNP_RegisterDeviceClassAssociation_state *state = tevent_req_data(
3796                 req, struct rpccli_PNP_RegisterDeviceClassAssociation_state);
3797         NTSTATUS status;
3798         TALLOC_CTX *mem_ctx;
3799
3800         if (state->out_mem_ctx) {
3801                 mem_ctx = state->out_mem_ctx;
3802         } else {
3803                 mem_ctx = state;
3804         }
3805
3806         status = state->dispatch_recv(subreq, mem_ctx);
3807         TALLOC_FREE(subreq);
3808         if (!NT_STATUS_IS_OK(status)) {
3809                 tevent_req_nterror(req, status);
3810                 return;
3811         }
3812
3813         /* Copy out parameters */
3814
3815         /* Copy result */
3816         state->orig.out.result = state->tmp.out.result;
3817
3818         /* Reset temporary structure */
3819         ZERO_STRUCT(state->tmp);
3820
3821         if (DEBUGLEVEL >= 10) {
3822                 NDR_PRINT_OUT_DEBUG(PNP_RegisterDeviceClassAssociation, &state->orig);
3823         }
3824
3825         tevent_req_done(req);
3826 }
3827
3828 NTSTATUS rpccli_PNP_RegisterDeviceClassAssociation_recv(struct tevent_req *req,
3829                                                         TALLOC_CTX *mem_ctx,
3830                                                         WERROR *result)
3831 {
3832         struct rpccli_PNP_RegisterDeviceClassAssociation_state *state = tevent_req_data(
3833                 req, struct rpccli_PNP_RegisterDeviceClassAssociation_state);
3834         NTSTATUS status;
3835
3836         if (tevent_req_is_nterror(req, &status)) {
3837                 tevent_req_received(req);
3838                 return status;
3839         }
3840
3841         /* Steal possbile out parameters to the callers context */
3842         talloc_steal(mem_ctx, state->out_mem_ctx);
3843
3844         /* Return result */
3845         *result = state->orig.out.result;
3846
3847         tevent_req_received(req);
3848         return NT_STATUS_OK;
3849 }
3850
3851 NTSTATUS rpccli_PNP_RegisterDeviceClassAssociation(struct rpc_pipe_client *cli,
3852                                                    TALLOC_CTX *mem_ctx,
3853                                                    WERROR *werror)
3854 {
3855         struct PNP_RegisterDeviceClassAssociation r;
3856         NTSTATUS status;
3857
3858         /* In parameters */
3859
3860         if (DEBUGLEVEL >= 10) {
3861                 NDR_PRINT_IN_DEBUG(PNP_RegisterDeviceClassAssociation, &r);
3862         }
3863
3864         status = cli->dispatch(cli,
3865                                 mem_ctx,
3866                                 &ndr_table_ntsvcs,
3867                                 NDR_PNP_REGISTERDEVICECLASSASSOCIATION,
3868                                 &r);
3869
3870         if (!NT_STATUS_IS_OK(status)) {
3871                 return status;
3872         }
3873
3874         if (DEBUGLEVEL >= 10) {
3875                 NDR_PRINT_OUT_DEBUG(PNP_RegisterDeviceClassAssociation, &r);
3876         }
3877
3878         if (NT_STATUS_IS_ERR(status)) {
3879                 return status;
3880         }
3881
3882         /* Return variables */
3883
3884         /* Return result */
3885         if (werror) {
3886                 *werror = r.out.result;
3887         }
3888
3889         return werror_to_ntstatus(r.out.result);
3890 }
3891
3892 struct rpccli_PNP_UnregisterDeviceClassAssociation_state {
3893         struct PNP_UnregisterDeviceClassAssociation orig;
3894         struct PNP_UnregisterDeviceClassAssociation tmp;
3895         TALLOC_CTX *out_mem_ctx;
3896         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3897 };
3898
3899 static void rpccli_PNP_UnregisterDeviceClassAssociation_done(struct tevent_req *subreq);
3900
3901 struct tevent_req *rpccli_PNP_UnregisterDeviceClassAssociation_send(TALLOC_CTX *mem_ctx,
3902                                                                     struct tevent_context *ev,
3903                                                                     struct rpc_pipe_client *cli)
3904 {
3905         struct tevent_req *req;
3906         struct rpccli_PNP_UnregisterDeviceClassAssociation_state *state;
3907         struct tevent_req *subreq;
3908
3909         req = tevent_req_create(mem_ctx, &state,
3910                                 struct rpccli_PNP_UnregisterDeviceClassAssociation_state);
3911         if (req == NULL) {
3912                 return NULL;
3913         }
3914         state->out_mem_ctx = NULL;
3915         state->dispatch_recv = cli->dispatch_recv;
3916
3917         /* In parameters */
3918
3919         /* Out parameters */
3920
3921         /* Result */
3922         ZERO_STRUCT(state->orig.out.result);
3923
3924         if (DEBUGLEVEL >= 10) {
3925                 NDR_PRINT_IN_DEBUG(PNP_UnregisterDeviceClassAssociation, &state->orig);
3926         }
3927
3928         /* make a temporary copy, that we pass to the dispatch function */
3929         state->tmp = state->orig;
3930
3931         subreq = cli->dispatch_send(state, ev, cli,
3932                                     &ndr_table_ntsvcs,
3933                                     NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION,
3934                                     &state->tmp);
3935         if (tevent_req_nomem(subreq, req)) {
3936                 return tevent_req_post(req, ev);
3937         }
3938         tevent_req_set_callback(subreq, rpccli_PNP_UnregisterDeviceClassAssociation_done, req);
3939         return req;
3940 }
3941
3942 static void rpccli_PNP_UnregisterDeviceClassAssociation_done(struct tevent_req *subreq)
3943 {
3944         struct tevent_req *req = tevent_req_callback_data(
3945                 subreq, struct tevent_req);
3946         struct rpccli_PNP_UnregisterDeviceClassAssociation_state *state = tevent_req_data(
3947                 req, struct rpccli_PNP_UnregisterDeviceClassAssociation_state);
3948         NTSTATUS status;
3949         TALLOC_CTX *mem_ctx;
3950
3951         if (state->out_mem_ctx) {
3952                 mem_ctx = state->out_mem_ctx;
3953         } else {
3954                 mem_ctx = state;
3955         }
3956
3957         status = state->dispatch_recv(subreq, mem_ctx);
3958         TALLOC_FREE(subreq);
3959         if (!NT_STATUS_IS_OK(status)) {
3960                 tevent_req_nterror(req, status);
3961                 return;
3962         }
3963
3964         /* Copy out parameters */
3965
3966         /* Copy result */
3967         state->orig.out.result = state->tmp.out.result;
3968
3969         /* Reset temporary structure */
3970         ZERO_STRUCT(state->tmp);
3971
3972         if (DEBUGLEVEL >= 10) {
3973                 NDR_PRINT_OUT_DEBUG(PNP_UnregisterDeviceClassAssociation, &state->orig);
3974         }
3975
3976         tevent_req_done(req);
3977 }
3978
3979 NTSTATUS rpccli_PNP_UnregisterDeviceClassAssociation_recv(struct tevent_req *req,
3980                                                           TALLOC_CTX *mem_ctx,
3981                                                           WERROR *result)
3982 {
3983         struct rpccli_PNP_UnregisterDeviceClassAssociation_state *state = tevent_req_data(
3984                 req, struct rpccli_PNP_UnregisterDeviceClassAssociation_state);
3985         NTSTATUS status;
3986
3987         if (tevent_req_is_nterror(req, &status)) {
3988                 tevent_req_received(req);
3989                 return status;
3990         }
3991
3992         /* Steal possbile out parameters to the callers context */
3993         talloc_steal(mem_ctx, state->out_mem_ctx);
3994
3995         /* Return result */
3996         *result = state->orig.out.result;
3997
3998         tevent_req_received(req);
3999         return NT_STATUS_OK;
4000 }
4001
4002 NTSTATUS rpccli_PNP_UnregisterDeviceClassAssociation(struct rpc_pipe_client *cli,
4003                                                      TALLOC_CTX *mem_ctx,
4004                                                      WERROR *werror)
4005 {
4006         struct PNP_UnregisterDeviceClassAssociation r;
4007         NTSTATUS status;
4008
4009         /* In parameters */
4010
4011         if (DEBUGLEVEL >= 10) {
4012                 NDR_PRINT_IN_DEBUG(PNP_UnregisterDeviceClassAssociation, &r);
4013         }
4014
4015         status = cli->dispatch(cli,
4016                                 mem_ctx,
4017                                 &ndr_table_ntsvcs,
4018                                 NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION,
4019                                 &r);
4020
4021         if (!NT_STATUS_IS_OK(status)) {
4022                 return status;
4023         }
4024
4025         if (DEBUGLEVEL >= 10) {
4026                 NDR_PRINT_OUT_DEBUG(PNP_UnregisterDeviceClassAssociation, &r);
4027         }
4028
4029         if (NT_STATUS_IS_ERR(status)) {
4030                 return status;
4031         }
4032
4033         /* Return variables */
4034
4035         /* Return result */
4036         if (werror) {
4037                 *werror = r.out.result;
4038         }
4039
4040         return werror_to_ntstatus(r.out.result);
4041 }
4042
4043 struct rpccli_PNP_GetClassRegProp_state {
4044         struct PNP_GetClassRegProp orig;
4045         struct PNP_GetClassRegProp tmp;
4046         TALLOC_CTX *out_mem_ctx;
4047         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4048 };
4049
4050 static void rpccli_PNP_GetClassRegProp_done(struct tevent_req *subreq);
4051
4052 struct tevent_req *rpccli_PNP_GetClassRegProp_send(TALLOC_CTX *mem_ctx,
4053                                                    struct tevent_context *ev,
4054                                                    struct rpc_pipe_client *cli)
4055 {
4056         struct tevent_req *req;
4057         struct rpccli_PNP_GetClassRegProp_state *state;
4058         struct tevent_req *subreq;
4059
4060         req = tevent_req_create(mem_ctx, &state,
4061                                 struct rpccli_PNP_GetClassRegProp_state);
4062         if (req == NULL) {
4063                 return NULL;
4064         }
4065         state->out_mem_ctx = NULL;
4066         state->dispatch_recv = cli->dispatch_recv;
4067
4068         /* In parameters */
4069
4070         /* Out parameters */
4071
4072         /* Result */
4073         ZERO_STRUCT(state->orig.out.result);
4074
4075         if (DEBUGLEVEL >= 10) {
4076                 NDR_PRINT_IN_DEBUG(PNP_GetClassRegProp, &state->orig);
4077         }
4078
4079         /* make a temporary copy, that we pass to the dispatch function */
4080         state->tmp = state->orig;
4081
4082         subreq = cli->dispatch_send(state, ev, cli,
4083                                     &ndr_table_ntsvcs,
4084                                     NDR_PNP_GETCLASSREGPROP,
4085                                     &state->tmp);
4086         if (tevent_req_nomem(subreq, req)) {
4087                 return tevent_req_post(req, ev);
4088         }
4089         tevent_req_set_callback(subreq, rpccli_PNP_GetClassRegProp_done, req);
4090         return req;
4091 }
4092
4093 static void rpccli_PNP_GetClassRegProp_done(struct tevent_req *subreq)
4094 {
4095         struct tevent_req *req = tevent_req_callback_data(
4096                 subreq, struct tevent_req);
4097         struct rpccli_PNP_GetClassRegProp_state *state = tevent_req_data(
4098                 req, struct rpccli_PNP_GetClassRegProp_state);
4099         NTSTATUS status;
4100         TALLOC_CTX *mem_ctx;
4101
4102         if (state->out_mem_ctx) {
4103                 mem_ctx = state->out_mem_ctx;
4104         } else {
4105                 mem_ctx = state;
4106         }
4107
4108         status = state->dispatch_recv(subreq, mem_ctx);
4109         TALLOC_FREE(subreq);
4110         if (!NT_STATUS_IS_OK(status)) {
4111                 tevent_req_nterror(req, status);
4112                 return;
4113         }
4114
4115         /* Copy out parameters */
4116
4117         /* Copy result */
4118         state->orig.out.result = state->tmp.out.result;
4119
4120         /* Reset temporary structure */
4121         ZERO_STRUCT(state->tmp);
4122
4123         if (DEBUGLEVEL >= 10) {
4124                 NDR_PRINT_OUT_DEBUG(PNP_GetClassRegProp, &state->orig);
4125         }
4126
4127         tevent_req_done(req);
4128 }
4129
4130 NTSTATUS rpccli_PNP_GetClassRegProp_recv(struct tevent_req *req,
4131                                          TALLOC_CTX *mem_ctx,
4132                                          WERROR *result)
4133 {
4134         struct rpccli_PNP_GetClassRegProp_state *state = tevent_req_data(
4135                 req, struct rpccli_PNP_GetClassRegProp_state);
4136         NTSTATUS status;
4137
4138         if (tevent_req_is_nterror(req, &status)) {
4139                 tevent_req_received(req);
4140                 return status;
4141         }
4142
4143         /* Steal possbile out parameters to the callers context */
4144         talloc_steal(mem_ctx, state->out_mem_ctx);
4145
4146         /* Return result */
4147         *result = state->orig.out.result;
4148
4149         tevent_req_received(req);
4150         return NT_STATUS_OK;
4151 }
4152
4153 NTSTATUS rpccli_PNP_GetClassRegProp(struct rpc_pipe_client *cli,
4154                                     TALLOC_CTX *mem_ctx,
4155                                     WERROR *werror)
4156 {
4157         struct PNP_GetClassRegProp r;
4158         NTSTATUS status;
4159
4160         /* In parameters */
4161
4162         if (DEBUGLEVEL >= 10) {
4163                 NDR_PRINT_IN_DEBUG(PNP_GetClassRegProp, &r);
4164         }
4165
4166         status = cli->dispatch(cli,
4167                                 mem_ctx,
4168                                 &ndr_table_ntsvcs,
4169                                 NDR_PNP_GETCLASSREGPROP,
4170                                 &r);
4171
4172         if (!NT_STATUS_IS_OK(status)) {
4173                 return status;
4174         }
4175
4176         if (DEBUGLEVEL >= 10) {
4177                 NDR_PRINT_OUT_DEBUG(PNP_GetClassRegProp, &r);
4178         }
4179
4180         if (NT_STATUS_IS_ERR(status)) {
4181                 return status;
4182         }
4183
4184         /* Return variables */
4185
4186         /* Return result */
4187         if (werror) {
4188                 *werror = r.out.result;
4189         }
4190
4191         return werror_to_ntstatus(r.out.result);
4192 }
4193
4194 struct rpccli_PNP_SetClassRegProp_state {
4195         struct PNP_SetClassRegProp orig;
4196         struct PNP_SetClassRegProp tmp;
4197         TALLOC_CTX *out_mem_ctx;
4198         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4199 };
4200
4201 static void rpccli_PNP_SetClassRegProp_done(struct tevent_req *subreq);
4202
4203 struct tevent_req *rpccli_PNP_SetClassRegProp_send(TALLOC_CTX *mem_ctx,
4204                                                    struct tevent_context *ev,
4205                                                    struct rpc_pipe_client *cli)
4206 {
4207         struct tevent_req *req;
4208         struct rpccli_PNP_SetClassRegProp_state *state;
4209         struct tevent_req *subreq;
4210
4211         req = tevent_req_create(mem_ctx, &state,
4212                                 struct rpccli_PNP_SetClassRegProp_state);
4213         if (req == NULL) {
4214                 return NULL;
4215         }
4216         state->out_mem_ctx = NULL;
4217         state->dispatch_recv = cli->dispatch_recv;
4218
4219         /* In parameters */
4220
4221         /* Out parameters */
4222
4223         /* Result */
4224         ZERO_STRUCT(state->orig.out.result);
4225
4226         if (DEBUGLEVEL >= 10) {
4227                 NDR_PRINT_IN_DEBUG(PNP_SetClassRegProp, &state->orig);
4228         }
4229
4230         /* make a temporary copy, that we pass to the dispatch function */
4231         state->tmp = state->orig;
4232
4233         subreq = cli->dispatch_send(state, ev, cli,
4234                                     &ndr_table_ntsvcs,
4235                                     NDR_PNP_SETCLASSREGPROP,
4236                                     &state->tmp);
4237         if (tevent_req_nomem(subreq, req)) {
4238                 return tevent_req_post(req, ev);
4239         }
4240         tevent_req_set_callback(subreq, rpccli_PNP_SetClassRegProp_done, req);
4241         return req;
4242 }
4243
4244 static void rpccli_PNP_SetClassRegProp_done(struct tevent_req *subreq)
4245 {
4246         struct tevent_req *req = tevent_req_callback_data(
4247                 subreq, struct tevent_req);
4248         struct rpccli_PNP_SetClassRegProp_state *state = tevent_req_data(
4249                 req, struct rpccli_PNP_SetClassRegProp_state);
4250         NTSTATUS status;
4251         TALLOC_CTX *mem_ctx;
4252
4253         if (state->out_mem_ctx) {
4254                 mem_ctx = state->out_mem_ctx;
4255         } else {
4256                 mem_ctx = state;
4257         }
4258
4259         status = state->dispatch_recv(subreq, mem_ctx);
4260         TALLOC_FREE(subreq);
4261         if (!NT_STATUS_IS_OK(status)) {
4262                 tevent_req_nterror(req, status);
4263                 return;
4264         }
4265
4266         /* Copy out parameters */
4267
4268         /* Copy result */
4269         state->orig.out.result = state->tmp.out.result;
4270
4271         /* Reset temporary structure */
4272         ZERO_STRUCT(state->tmp);
4273
4274         if (DEBUGLEVEL >= 10) {
4275                 NDR_PRINT_OUT_DEBUG(PNP_SetClassRegProp, &state->orig);
4276         }
4277
4278         tevent_req_done(req);
4279 }
4280
4281 NTSTATUS rpccli_PNP_SetClassRegProp_recv(struct tevent_req *req,
4282                                          TALLOC_CTX *mem_ctx,
4283                                          WERROR *result)
4284 {
4285         struct rpccli_PNP_SetClassRegProp_state *state = tevent_req_data(
4286                 req, struct rpccli_PNP_SetClassRegProp_state);
4287         NTSTATUS status;
4288
4289         if (tevent_req_is_nterror(req, &status)) {
4290                 tevent_req_received(req);
4291                 return status;
4292         }
4293
4294         /* Steal possbile out parameters to the callers context */
4295         talloc_steal(mem_ctx, state->out_mem_ctx);
4296
4297         /* Return result */
4298         *result = state->orig.out.result;
4299
4300         tevent_req_received(req);
4301         return NT_STATUS_OK;
4302 }
4303
4304 NTSTATUS rpccli_PNP_SetClassRegProp(struct rpc_pipe_client *cli,
4305                                     TALLOC_CTX *mem_ctx,
4306                                     WERROR *werror)
4307 {
4308         struct PNP_SetClassRegProp r;
4309         NTSTATUS status;
4310
4311         /* In parameters */
4312
4313         if (DEBUGLEVEL >= 10) {
4314                 NDR_PRINT_IN_DEBUG(PNP_SetClassRegProp, &r);
4315         }
4316
4317         status = cli->dispatch(cli,
4318                                 mem_ctx,
4319                                 &ndr_table_ntsvcs,
4320                                 NDR_PNP_SETCLASSREGPROP,
4321                                 &r);
4322
4323         if (!NT_STATUS_IS_OK(status)) {
4324                 return status;
4325         }
4326
4327         if (DEBUGLEVEL >= 10) {
4328                 NDR_PRINT_OUT_DEBUG(PNP_SetClassRegProp, &r);
4329         }
4330
4331         if (NT_STATUS_IS_ERR(status)) {
4332                 return status;
4333         }
4334
4335         /* Return variables */
4336
4337         /* Return result */
4338         if (werror) {
4339                 *werror = r.out.result;
4340         }
4341
4342         return werror_to_ntstatus(r.out.result);
4343 }
4344
4345 struct rpccli_PNP_CreateDevInst_state {
4346         struct PNP_CreateDevInst orig;
4347         struct PNP_CreateDevInst tmp;
4348         TALLOC_CTX *out_mem_ctx;
4349         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4350 };
4351
4352 static void rpccli_PNP_CreateDevInst_done(struct tevent_req *subreq);
4353
4354 struct tevent_req *rpccli_PNP_CreateDevInst_send(TALLOC_CTX *mem_ctx,
4355                                                  struct tevent_context *ev,
4356                                                  struct rpc_pipe_client *cli)
4357 {
4358         struct tevent_req *req;
4359         struct rpccli_PNP_CreateDevInst_state *state;
4360         struct tevent_req *subreq;
4361
4362         req = tevent_req_create(mem_ctx, &state,
4363                                 struct rpccli_PNP_CreateDevInst_state);
4364         if (req == NULL) {
4365                 return NULL;
4366         }
4367         state->out_mem_ctx = NULL;
4368         state->dispatch_recv = cli->dispatch_recv;
4369
4370         /* In parameters */
4371
4372         /* Out parameters */
4373
4374         /* Result */
4375         ZERO_STRUCT(state->orig.out.result);
4376
4377         if (DEBUGLEVEL >= 10) {
4378                 NDR_PRINT_IN_DEBUG(PNP_CreateDevInst, &state->orig);
4379         }
4380
4381         /* make a temporary copy, that we pass to the dispatch function */
4382         state->tmp = state->orig;
4383
4384         subreq = cli->dispatch_send(state, ev, cli,
4385                                     &ndr_table_ntsvcs,
4386                                     NDR_PNP_CREATEDEVINST,
4387                                     &state->tmp);
4388         if (tevent_req_nomem(subreq, req)) {
4389                 return tevent_req_post(req, ev);
4390         }
4391         tevent_req_set_callback(subreq, rpccli_PNP_CreateDevInst_done, req);
4392         return req;
4393 }
4394
4395 static void rpccli_PNP_CreateDevInst_done(struct tevent_req *subreq)
4396 {
4397         struct tevent_req *req = tevent_req_callback_data(
4398                 subreq, struct tevent_req);
4399         struct rpccli_PNP_CreateDevInst_state *state = tevent_req_data(
4400                 req, struct rpccli_PNP_CreateDevInst_state);
4401         NTSTATUS status;
4402         TALLOC_CTX *mem_ctx;
4403
4404         if (state->out_mem_ctx) {
4405                 mem_ctx = state->out_mem_ctx;
4406         } else {
4407                 mem_ctx = state;
4408         }
4409
4410         status = state->dispatch_recv(subreq, mem_ctx);
4411         TALLOC_FREE(subreq);
4412         if (!NT_STATUS_IS_OK(status)) {
4413                 tevent_req_nterror(req, status);
4414                 return;
4415         }
4416
4417         /* Copy out parameters */
4418
4419         /* Copy result */
4420         state->orig.out.result = state->tmp.out.result;
4421
4422         /* Reset temporary structure */
4423         ZERO_STRUCT(state->tmp);
4424
4425         if (DEBUGLEVEL >= 10) {
4426                 NDR_PRINT_OUT_DEBUG(PNP_CreateDevInst, &state->orig);
4427         }
4428
4429         tevent_req_done(req);
4430 }
4431
4432 NTSTATUS rpccli_PNP_CreateDevInst_recv(struct tevent_req *req,
4433                                        TALLOC_CTX *mem_ctx,
4434                                        WERROR *result)
4435 {
4436         struct rpccli_PNP_CreateDevInst_state *state = tevent_req_data(
4437                 req, struct rpccli_PNP_CreateDevInst_state);
4438         NTSTATUS status;
4439
4440         if (tevent_req_is_nterror(req, &status)) {
4441                 tevent_req_received(req);
4442                 return status;
4443         }
4444
4445         /* Steal possbile out parameters to the callers context */
4446         talloc_steal(mem_ctx, state->out_mem_ctx);
4447
4448         /* Return result */
4449         *result = state->orig.out.result;
4450
4451         tevent_req_received(req);
4452         return NT_STATUS_OK;
4453 }
4454
4455 NTSTATUS rpccli_PNP_CreateDevInst(struct rpc_pipe_client *cli,
4456                                   TALLOC_CTX *mem_ctx,
4457                                   WERROR *werror)
4458 {
4459         struct PNP_CreateDevInst r;
4460         NTSTATUS status;
4461
4462         /* In parameters */
4463
4464         if (DEBUGLEVEL >= 10) {
4465                 NDR_PRINT_IN_DEBUG(PNP_CreateDevInst, &r);
4466         }
4467
4468         status = cli->dispatch(cli,
4469                                 mem_ctx,
4470                                 &ndr_table_ntsvcs,
4471                                 NDR_PNP_CREATEDEVINST,
4472                                 &r);
4473
4474         if (!NT_STATUS_IS_OK(status)) {
4475                 return status;
4476         }
4477
4478         if (DEBUGLEVEL >= 10) {
4479                 NDR_PRINT_OUT_DEBUG(PNP_CreateDevInst, &r);
4480         }
4481
4482         if (NT_STATUS_IS_ERR(status)) {
4483                 return status;
4484         }
4485
4486         /* Return variables */
4487
4488         /* Return result */
4489         if (werror) {
4490                 *werror = r.out.result;
4491         }
4492
4493         return werror_to_ntstatus(r.out.result);
4494 }
4495
4496 struct rpccli_PNP_DeviceInstanceAction_state {
4497         struct PNP_DeviceInstanceAction orig;
4498         struct PNP_DeviceInstanceAction tmp;
4499         TALLOC_CTX *out_mem_ctx;
4500         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4501 };
4502
4503 static void rpccli_PNP_DeviceInstanceAction_done(struct tevent_req *subreq);
4504
4505 struct tevent_req *rpccli_PNP_DeviceInstanceAction_send(TALLOC_CTX *mem_ctx,
4506                                                         struct tevent_context *ev,
4507                                                         struct rpc_pipe_client *cli)
4508 {
4509         struct tevent_req *req;
4510         struct rpccli_PNP_DeviceInstanceAction_state *state;
4511         struct tevent_req *subreq;
4512
4513         req = tevent_req_create(mem_ctx, &state,
4514                                 struct rpccli_PNP_DeviceInstanceAction_state);
4515         if (req == NULL) {
4516                 return NULL;
4517         }
4518         state->out_mem_ctx = NULL;
4519         state->dispatch_recv = cli->dispatch_recv;
4520
4521         /* In parameters */
4522
4523         /* Out parameters */
4524
4525         /* Result */
4526         ZERO_STRUCT(state->orig.out.result);
4527
4528         if (DEBUGLEVEL >= 10) {
4529                 NDR_PRINT_IN_DEBUG(PNP_DeviceInstanceAction, &state->orig);
4530         }
4531
4532         /* make a temporary copy, that we pass to the dispatch function */
4533         state->tmp = state->orig;
4534
4535         subreq = cli->dispatch_send(state, ev, cli,
4536                                     &ndr_table_ntsvcs,
4537                                     NDR_PNP_DEVICEINSTANCEACTION,
4538                                     &state->tmp);
4539         if (tevent_req_nomem(subreq, req)) {
4540                 return tevent_req_post(req, ev);
4541         }
4542         tevent_req_set_callback(subreq, rpccli_PNP_DeviceInstanceAction_done, req);
4543         return req;
4544 }
4545
4546 static void rpccli_PNP_DeviceInstanceAction_done(struct tevent_req *subreq)
4547 {
4548         struct tevent_req *req = tevent_req_callback_data(
4549                 subreq, struct tevent_req);
4550         struct rpccli_PNP_DeviceInstanceAction_state *state = tevent_req_data(
4551                 req, struct rpccli_PNP_DeviceInstanceAction_state);
4552         NTSTATUS status;
4553         TALLOC_CTX *mem_ctx;
4554
4555         if (state->out_mem_ctx) {
4556                 mem_ctx = state->out_mem_ctx;
4557         } else {
4558                 mem_ctx = state;
4559         }
4560
4561         status = state->dispatch_recv(subreq, mem_ctx);
4562         TALLOC_FREE(subreq);
4563         if (!NT_STATUS_IS_OK(status)) {
4564                 tevent_req_nterror(req, status);
4565                 return;
4566         }
4567
4568         /* Copy out parameters */
4569
4570         /* Copy result */
4571         state->orig.out.result = state->tmp.out.result;
4572
4573         /* Reset temporary structure */
4574         ZERO_STRUCT(state->tmp);
4575
4576         if (DEBUGLEVEL >= 10) {
4577                 NDR_PRINT_OUT_DEBUG(PNP_DeviceInstanceAction, &state->orig);
4578         }
4579
4580         tevent_req_done(req);
4581 }
4582
4583 NTSTATUS rpccli_PNP_DeviceInstanceAction_recv(struct tevent_req *req,
4584                                               TALLOC_CTX *mem_ctx,
4585                                               WERROR *result)
4586 {
4587         struct rpccli_PNP_DeviceInstanceAction_state *state = tevent_req_data(
4588                 req, struct rpccli_PNP_DeviceInstanceAction_state);
4589         NTSTATUS status;
4590
4591         if (tevent_req_is_nterror(req, &status)) {
4592                 tevent_req_received(req);
4593                 return status;
4594         }
4595
4596         /* Steal possbile out parameters to the callers context */
4597         talloc_steal(mem_ctx, state->out_mem_ctx);
4598
4599         /* Return result */
4600         *result = state->orig.out.result;
4601
4602         tevent_req_received(req);
4603         return NT_STATUS_OK;
4604 }
4605
4606 NTSTATUS rpccli_PNP_DeviceInstanceAction(struct rpc_pipe_client *cli,
4607                                          TALLOC_CTX *mem_ctx,
4608                                          WERROR *werror)
4609 {
4610         struct PNP_DeviceInstanceAction r;
4611         NTSTATUS status;
4612
4613         /* In parameters */
4614
4615         if (DEBUGLEVEL >= 10) {
4616                 NDR_PRINT_IN_DEBUG(PNP_DeviceInstanceAction, &r);
4617         }
4618
4619         status = cli->dispatch(cli,
4620                                 mem_ctx,
4621                                 &ndr_table_ntsvcs,
4622                                 NDR_PNP_DEVICEINSTANCEACTION,
4623                                 &r);
4624
4625         if (!NT_STATUS_IS_OK(status)) {
4626                 return status;
4627         }
4628
4629         if (DEBUGLEVEL >= 10) {
4630                 NDR_PRINT_OUT_DEBUG(PNP_DeviceInstanceAction, &r);
4631         }
4632
4633         if (NT_STATUS_IS_ERR(status)) {
4634                 return status;
4635         }
4636
4637         /* Return variables */
4638
4639         /* Return result */
4640         if (werror) {
4641                 *werror = r.out.result;
4642         }
4643
4644         return werror_to_ntstatus(r.out.result);
4645 }
4646
4647 struct rpccli_PNP_GetDeviceStatus_state {
4648         struct PNP_GetDeviceStatus orig;
4649         struct PNP_GetDeviceStatus tmp;
4650         TALLOC_CTX *out_mem_ctx;
4651         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4652 };
4653
4654 static void rpccli_PNP_GetDeviceStatus_done(struct tevent_req *subreq);
4655
4656 struct tevent_req *rpccli_PNP_GetDeviceStatus_send(TALLOC_CTX *mem_ctx,
4657                                                    struct tevent_context *ev,
4658                                                    struct rpc_pipe_client *cli)
4659 {
4660         struct tevent_req *req;
4661         struct rpccli_PNP_GetDeviceStatus_state *state;
4662         struct tevent_req *subreq;
4663
4664         req = tevent_req_create(mem_ctx, &state,
4665                                 struct rpccli_PNP_GetDeviceStatus_state);
4666         if (req == NULL) {
4667                 return NULL;
4668         }
4669         state->out_mem_ctx = NULL;
4670         state->dispatch_recv = cli->dispatch_recv;
4671
4672         /* In parameters */
4673
4674         /* Out parameters */
4675
4676         /* Result */
4677         ZERO_STRUCT(state->orig.out.result);
4678
4679         if (DEBUGLEVEL >= 10) {
4680                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceStatus, &state->orig);
4681         }
4682
4683         /* make a temporary copy, that we pass to the dispatch function */
4684         state->tmp = state->orig;
4685
4686         subreq = cli->dispatch_send(state, ev, cli,
4687                                     &ndr_table_ntsvcs,
4688                                     NDR_PNP_GETDEVICESTATUS,
4689                                     &state->tmp);
4690         if (tevent_req_nomem(subreq, req)) {
4691                 return tevent_req_post(req, ev);
4692         }
4693         tevent_req_set_callback(subreq, rpccli_PNP_GetDeviceStatus_done, req);
4694         return req;
4695 }
4696
4697 static void rpccli_PNP_GetDeviceStatus_done(struct tevent_req *subreq)
4698 {
4699         struct tevent_req *req = tevent_req_callback_data(
4700                 subreq, struct tevent_req);
4701         struct rpccli_PNP_GetDeviceStatus_state *state = tevent_req_data(
4702                 req, struct rpccli_PNP_GetDeviceStatus_state);
4703         NTSTATUS status;
4704         TALLOC_CTX *mem_ctx;
4705
4706         if (state->out_mem_ctx) {
4707                 mem_ctx = state->out_mem_ctx;
4708         } else {
4709                 mem_ctx = state;
4710         }
4711
4712         status = state->dispatch_recv(subreq, mem_ctx);
4713         TALLOC_FREE(subreq);
4714         if (!NT_STATUS_IS_OK(status)) {
4715                 tevent_req_nterror(req, status);
4716                 return;
4717         }
4718
4719         /* Copy out parameters */
4720
4721         /* Copy result */
4722         state->orig.out.result = state->tmp.out.result;
4723
4724         /* Reset temporary structure */
4725         ZERO_STRUCT(state->tmp);
4726
4727         if (DEBUGLEVEL >= 10) {
4728                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceStatus, &state->orig);
4729         }
4730
4731         tevent_req_done(req);
4732 }
4733
4734 NTSTATUS rpccli_PNP_GetDeviceStatus_recv(struct tevent_req *req,
4735                                          TALLOC_CTX *mem_ctx,
4736                                          WERROR *result)
4737 {
4738         struct rpccli_PNP_GetDeviceStatus_state *state = tevent_req_data(
4739                 req, struct rpccli_PNP_GetDeviceStatus_state);
4740         NTSTATUS status;
4741
4742         if (tevent_req_is_nterror(req, &status)) {
4743                 tevent_req_received(req);
4744                 return status;
4745         }
4746
4747         /* Steal possbile out parameters to the callers context */
4748         talloc_steal(mem_ctx, state->out_mem_ctx);
4749
4750         /* Return result */
4751         *result = state->orig.out.result;
4752
4753         tevent_req_received(req);
4754         return NT_STATUS_OK;
4755 }
4756
4757 NTSTATUS rpccli_PNP_GetDeviceStatus(struct rpc_pipe_client *cli,
4758                                     TALLOC_CTX *mem_ctx,
4759                                     WERROR *werror)
4760 {
4761         struct PNP_GetDeviceStatus r;
4762         NTSTATUS status;
4763
4764         /* In parameters */
4765
4766         if (DEBUGLEVEL >= 10) {
4767                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceStatus, &r);
4768         }
4769
4770         status = cli->dispatch(cli,
4771                                 mem_ctx,
4772                                 &ndr_table_ntsvcs,
4773                                 NDR_PNP_GETDEVICESTATUS,
4774                                 &r);
4775
4776         if (!NT_STATUS_IS_OK(status)) {
4777                 return status;
4778         }
4779
4780         if (DEBUGLEVEL >= 10) {
4781                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceStatus, &r);
4782         }
4783
4784         if (NT_STATUS_IS_ERR(status)) {
4785                 return status;
4786         }
4787
4788         /* Return variables */
4789
4790         /* Return result */
4791         if (werror) {
4792                 *werror = r.out.result;
4793         }
4794
4795         return werror_to_ntstatus(r.out.result);
4796 }
4797
4798 struct rpccli_PNP_SetDeviceProblem_state {
4799         struct PNP_SetDeviceProblem orig;
4800         struct PNP_SetDeviceProblem tmp;
4801         TALLOC_CTX *out_mem_ctx;
4802         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4803 };
4804
4805 static void rpccli_PNP_SetDeviceProblem_done(struct tevent_req *subreq);
4806
4807 struct tevent_req *rpccli_PNP_SetDeviceProblem_send(TALLOC_CTX *mem_ctx,
4808                                                     struct tevent_context *ev,
4809                                                     struct rpc_pipe_client *cli)
4810 {
4811         struct tevent_req *req;
4812         struct rpccli_PNP_SetDeviceProblem_state *state;
4813         struct tevent_req *subreq;
4814
4815         req = tevent_req_create(mem_ctx, &state,
4816                                 struct rpccli_PNP_SetDeviceProblem_state);
4817         if (req == NULL) {
4818                 return NULL;
4819         }
4820         state->out_mem_ctx = NULL;
4821         state->dispatch_recv = cli->dispatch_recv;
4822
4823         /* In parameters */
4824
4825         /* Out parameters */
4826
4827         /* Result */
4828         ZERO_STRUCT(state->orig.out.result);
4829
4830         if (DEBUGLEVEL >= 10) {
4831                 NDR_PRINT_IN_DEBUG(PNP_SetDeviceProblem, &state->orig);
4832         }
4833
4834         /* make a temporary copy, that we pass to the dispatch function */
4835         state->tmp = state->orig;
4836
4837         subreq = cli->dispatch_send(state, ev, cli,
4838                                     &ndr_table_ntsvcs,
4839                                     NDR_PNP_SETDEVICEPROBLEM,
4840                                     &state->tmp);
4841         if (tevent_req_nomem(subreq, req)) {
4842                 return tevent_req_post(req, ev);
4843         }
4844         tevent_req_set_callback(subreq, rpccli_PNP_SetDeviceProblem_done, req);
4845         return req;
4846 }
4847
4848 static void rpccli_PNP_SetDeviceProblem_done(struct tevent_req *subreq)
4849 {
4850         struct tevent_req *req = tevent_req_callback_data(
4851                 subreq, struct tevent_req);
4852         struct rpccli_PNP_SetDeviceProblem_state *state = tevent_req_data(
4853                 req, struct rpccli_PNP_SetDeviceProblem_state);
4854         NTSTATUS status;
4855         TALLOC_CTX *mem_ctx;
4856
4857         if (state->out_mem_ctx) {
4858                 mem_ctx = state->out_mem_ctx;
4859         } else {
4860                 mem_ctx = state;
4861         }
4862
4863         status = state->dispatch_recv(subreq, mem_ctx);
4864         TALLOC_FREE(subreq);
4865         if (!NT_STATUS_IS_OK(status)) {
4866                 tevent_req_nterror(req, status);
4867                 return;
4868         }
4869
4870         /* Copy out parameters */
4871
4872         /* Copy result */
4873         state->orig.out.result = state->tmp.out.result;
4874
4875         /* Reset temporary structure */
4876         ZERO_STRUCT(state->tmp);
4877
4878         if (DEBUGLEVEL >= 10) {
4879                 NDR_PRINT_OUT_DEBUG(PNP_SetDeviceProblem, &state->orig);
4880         }
4881
4882         tevent_req_done(req);
4883 }
4884
4885 NTSTATUS rpccli_PNP_SetDeviceProblem_recv(struct tevent_req *req,
4886                                           TALLOC_CTX *mem_ctx,
4887                                           WERROR *result)
4888 {
4889         struct rpccli_PNP_SetDeviceProblem_state *state = tevent_req_data(
4890                 req, struct rpccli_PNP_SetDeviceProblem_state);
4891         NTSTATUS status;
4892
4893         if (tevent_req_is_nterror(req, &status)) {
4894                 tevent_req_received(req);
4895                 return status;
4896         }
4897
4898         /* Steal possbile out parameters to the callers context */
4899         talloc_steal(mem_ctx, state->out_mem_ctx);
4900
4901         /* Return result */
4902         *result = state->orig.out.result;
4903
4904         tevent_req_received(req);
4905         return NT_STATUS_OK;
4906 }
4907
4908 NTSTATUS rpccli_PNP_SetDeviceProblem(struct rpc_pipe_client *cli,
4909                                      TALLOC_CTX *mem_ctx,
4910                                      WERROR *werror)
4911 {
4912         struct PNP_SetDeviceProblem r;
4913         NTSTATUS status;
4914
4915         /* In parameters */
4916
4917         if (DEBUGLEVEL >= 10) {
4918                 NDR_PRINT_IN_DEBUG(PNP_SetDeviceProblem, &r);
4919         }
4920
4921         status = cli->dispatch(cli,
4922                                 mem_ctx,
4923                                 &ndr_table_ntsvcs,
4924                                 NDR_PNP_SETDEVICEPROBLEM,
4925                                 &r);
4926
4927         if (!NT_STATUS_IS_OK(status)) {
4928                 return status;
4929         }
4930
4931         if (DEBUGLEVEL >= 10) {
4932                 NDR_PRINT_OUT_DEBUG(PNP_SetDeviceProblem, &r);
4933         }
4934
4935         if (NT_STATUS_IS_ERR(status)) {
4936                 return status;
4937         }
4938
4939         /* Return variables */
4940
4941         /* Return result */
4942         if (werror) {
4943                 *werror = r.out.result;
4944         }
4945
4946         return werror_to_ntstatus(r.out.result);
4947 }
4948
4949 struct rpccli_PNP_DisableDevInst_state {
4950         struct PNP_DisableDevInst orig;
4951         struct PNP_DisableDevInst tmp;
4952         TALLOC_CTX *out_mem_ctx;
4953         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4954 };
4955
4956 static void rpccli_PNP_DisableDevInst_done(struct tevent_req *subreq);
4957
4958 struct tevent_req *rpccli_PNP_DisableDevInst_send(TALLOC_CTX *mem_ctx,
4959                                                   struct tevent_context *ev,
4960                                                   struct rpc_pipe_client *cli)
4961 {
4962         struct tevent_req *req;
4963         struct rpccli_PNP_DisableDevInst_state *state;
4964         struct tevent_req *subreq;
4965
4966         req = tevent_req_create(mem_ctx, &state,
4967                                 struct rpccli_PNP_DisableDevInst_state);
4968         if (req == NULL) {
4969                 return NULL;
4970         }
4971         state->out_mem_ctx = NULL;
4972         state->dispatch_recv = cli->dispatch_recv;
4973
4974         /* In parameters */
4975
4976         /* Out parameters */
4977
4978         /* Result */
4979         ZERO_STRUCT(state->orig.out.result);
4980
4981         if (DEBUGLEVEL >= 10) {
4982                 NDR_PRINT_IN_DEBUG(PNP_DisableDevInst, &state->orig);
4983         }
4984
4985         /* make a temporary copy, that we pass to the dispatch function */
4986         state->tmp = state->orig;
4987
4988         subreq = cli->dispatch_send(state, ev, cli,
4989                                     &ndr_table_ntsvcs,
4990                                     NDR_PNP_DISABLEDEVINST,
4991                                     &state->tmp);
4992         if (tevent_req_nomem(subreq, req)) {
4993                 return tevent_req_post(req, ev);
4994         }
4995         tevent_req_set_callback(subreq, rpccli_PNP_DisableDevInst_done, req);
4996         return req;
4997 }
4998
4999 static void rpccli_PNP_DisableDevInst_done(struct tevent_req *subreq)
5000 {
5001         struct tevent_req *req = tevent_req_callback_data(
5002                 subreq, struct tevent_req);
5003         struct rpccli_PNP_DisableDevInst_state *state = tevent_req_data(
5004                 req, struct rpccli_PNP_DisableDevInst_state);
5005         NTSTATUS status;
5006         TALLOC_CTX *mem_ctx;
5007
5008         if (state->out_mem_ctx) {
5009                 mem_ctx = state->out_mem_ctx;
5010         } else {
5011                 mem_ctx = state;
5012         }
5013
5014         status = state->dispatch_recv(subreq, mem_ctx);
5015         TALLOC_FREE(subreq);
5016         if (!NT_STATUS_IS_OK(status)) {
5017                 tevent_req_nterror(req, status);
5018                 return;
5019         }
5020
5021         /* Copy out parameters */
5022
5023         /* Copy result */
5024         state->orig.out.result = state->tmp.out.result;
5025
5026         /* Reset temporary structure */
5027         ZERO_STRUCT(state->tmp);
5028
5029         if (DEBUGLEVEL >= 10) {
5030                 NDR_PRINT_OUT_DEBUG(PNP_DisableDevInst, &state->orig);
5031         }
5032
5033         tevent_req_done(req);
5034 }
5035
5036 NTSTATUS rpccli_PNP_DisableDevInst_recv(struct tevent_req *req,
5037                                         TALLOC_CTX *mem_ctx,
5038                                         WERROR *result)
5039 {
5040         struct rpccli_PNP_DisableDevInst_state *state = tevent_req_data(
5041                 req, struct rpccli_PNP_DisableDevInst_state);
5042         NTSTATUS status;
5043
5044         if (tevent_req_is_nterror(req, &status)) {
5045                 tevent_req_received(req);
5046                 return status;
5047         }
5048
5049         /* Steal possbile out parameters to the callers context */
5050         talloc_steal(mem_ctx, state->out_mem_ctx);
5051
5052         /* Return result */
5053         *result = state->orig.out.result;
5054
5055         tevent_req_received(req);
5056         return NT_STATUS_OK;
5057 }
5058
5059 NTSTATUS rpccli_PNP_DisableDevInst(struct rpc_pipe_client *cli,
5060                                    TALLOC_CTX *mem_ctx,
5061                                    WERROR *werror)
5062 {
5063         struct PNP_DisableDevInst r;
5064         NTSTATUS status;
5065
5066         /* In parameters */
5067
5068         if (DEBUGLEVEL >= 10) {
5069                 NDR_PRINT_IN_DEBUG(PNP_DisableDevInst, &r);
5070         }
5071
5072         status = cli->dispatch(cli,
5073                                 mem_ctx,
5074                                 &ndr_table_ntsvcs,
5075                                 NDR_PNP_DISABLEDEVINST,
5076                                 &r);
5077
5078         if (!NT_STATUS_IS_OK(status)) {
5079                 return status;
5080         }
5081
5082         if (DEBUGLEVEL >= 10) {
5083                 NDR_PRINT_OUT_DEBUG(PNP_DisableDevInst, &r);
5084         }
5085
5086         if (NT_STATUS_IS_ERR(status)) {
5087                 return status;
5088         }
5089
5090         /* Return variables */
5091
5092         /* Return result */
5093         if (werror) {
5094                 *werror = r.out.result;
5095         }
5096
5097         return werror_to_ntstatus(r.out.result);
5098 }
5099
5100 struct rpccli_PNP_UninstallDevInst_state {
5101         struct PNP_UninstallDevInst orig;
5102         struct PNP_UninstallDevInst tmp;
5103         TALLOC_CTX *out_mem_ctx;
5104         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5105 };
5106
5107 static void rpccli_PNP_UninstallDevInst_done(struct tevent_req *subreq);
5108
5109 struct tevent_req *rpccli_PNP_UninstallDevInst_send(TALLOC_CTX *mem_ctx,
5110                                                     struct tevent_context *ev,
5111                                                     struct rpc_pipe_client *cli)
5112 {
5113         struct tevent_req *req;
5114         struct rpccli_PNP_UninstallDevInst_state *state;
5115         struct tevent_req *subreq;
5116
5117         req = tevent_req_create(mem_ctx, &state,
5118                                 struct rpccli_PNP_UninstallDevInst_state);
5119         if (req == NULL) {
5120                 return NULL;
5121         }
5122         state->out_mem_ctx = NULL;
5123         state->dispatch_recv = cli->dispatch_recv;
5124
5125         /* In parameters */
5126
5127         /* Out parameters */
5128
5129         /* Result */
5130         ZERO_STRUCT(state->orig.out.result);
5131
5132         if (DEBUGLEVEL >= 10) {
5133                 NDR_PRINT_IN_DEBUG(PNP_UninstallDevInst, &state->orig);
5134         }
5135
5136         /* make a temporary copy, that we pass to the dispatch function */
5137         state->tmp = state->orig;
5138
5139         subreq = cli->dispatch_send(state, ev, cli,
5140                                     &ndr_table_ntsvcs,
5141                                     NDR_PNP_UNINSTALLDEVINST,
5142                                     &state->tmp);
5143         if (tevent_req_nomem(subreq, req)) {
5144                 return tevent_req_post(req, ev);
5145         }
5146         tevent_req_set_callback(subreq, rpccli_PNP_UninstallDevInst_done, req);
5147         return req;
5148 }
5149
5150 static void rpccli_PNP_UninstallDevInst_done(struct tevent_req *subreq)
5151 {
5152         struct tevent_req *req = tevent_req_callback_data(
5153                 subreq, struct tevent_req);
5154         struct rpccli_PNP_UninstallDevInst_state *state = tevent_req_data(
5155                 req, struct rpccli_PNP_UninstallDevInst_state);
5156         NTSTATUS status;
5157         TALLOC_CTX *mem_ctx;
5158
5159         if (state->out_mem_ctx) {
5160                 mem_ctx = state->out_mem_ctx;
5161         } else {
5162                 mem_ctx = state;
5163         }
5164
5165         status = state->dispatch_recv(subreq, mem_ctx);
5166         TALLOC_FREE(subreq);
5167         if (!NT_STATUS_IS_OK(status)) {
5168                 tevent_req_nterror(req, status);
5169                 return;
5170         }
5171
5172         /* Copy out parameters */
5173
5174         /* Copy result */
5175         state->orig.out.result = state->tmp.out.result;
5176
5177         /* Reset temporary structure */
5178         ZERO_STRUCT(state->tmp);
5179
5180         if (DEBUGLEVEL >= 10) {
5181                 NDR_PRINT_OUT_DEBUG(PNP_UninstallDevInst, &state->orig);
5182         }
5183
5184         tevent_req_done(req);
5185 }
5186
5187 NTSTATUS rpccli_PNP_UninstallDevInst_recv(struct tevent_req *req,
5188                                           TALLOC_CTX *mem_ctx,
5189                                           WERROR *result)
5190 {
5191         struct rpccli_PNP_UninstallDevInst_state *state = tevent_req_data(
5192                 req, struct rpccli_PNP_UninstallDevInst_state);
5193         NTSTATUS status;
5194
5195         if (tevent_req_is_nterror(req, &status)) {
5196                 tevent_req_received(req);
5197                 return status;
5198         }
5199
5200         /* Steal possbile out parameters to the callers context */
5201         talloc_steal(mem_ctx, state->out_mem_ctx);
5202
5203         /* Return result */
5204         *result = state->orig.out.result;
5205
5206         tevent_req_received(req);
5207         return NT_STATUS_OK;
5208 }
5209
5210 NTSTATUS rpccli_PNP_UninstallDevInst(struct rpc_pipe_client *cli,
5211                                      TALLOC_CTX *mem_ctx,
5212                                      WERROR *werror)
5213 {
5214         struct PNP_UninstallDevInst r;
5215         NTSTATUS status;
5216
5217         /* In parameters */
5218
5219         if (DEBUGLEVEL >= 10) {
5220                 NDR_PRINT_IN_DEBUG(PNP_UninstallDevInst, &r);
5221         }
5222
5223         status = cli->dispatch(cli,
5224                                 mem_ctx,
5225                                 &ndr_table_ntsvcs,
5226                                 NDR_PNP_UNINSTALLDEVINST,
5227                                 &r);
5228
5229         if (!NT_STATUS_IS_OK(status)) {
5230                 return status;
5231         }
5232
5233         if (DEBUGLEVEL >= 10) {
5234                 NDR_PRINT_OUT_DEBUG(PNP_UninstallDevInst, &r);
5235         }
5236
5237         if (NT_STATUS_IS_ERR(status)) {
5238                 return status;
5239         }
5240
5241         /* Return variables */
5242
5243         /* Return result */
5244         if (werror) {
5245                 *werror = r.out.result;
5246         }
5247
5248         return werror_to_ntstatus(r.out.result);
5249 }
5250
5251 struct rpccli_PNP_AddID_state {
5252         struct PNP_AddID orig;
5253         struct PNP_AddID tmp;
5254         TALLOC_CTX *out_mem_ctx;
5255         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5256 };
5257
5258 static void rpccli_PNP_AddID_done(struct tevent_req *subreq);
5259
5260 struct tevent_req *rpccli_PNP_AddID_send(TALLOC_CTX *mem_ctx,
5261                                          struct tevent_context *ev,
5262                                          struct rpc_pipe_client *cli)
5263 {
5264         struct tevent_req *req;
5265         struct rpccli_PNP_AddID_state *state;
5266         struct tevent_req *subreq;
5267
5268         req = tevent_req_create(mem_ctx, &state,
5269                                 struct rpccli_PNP_AddID_state);
5270         if (req == NULL) {
5271                 return NULL;
5272         }
5273         state->out_mem_ctx = NULL;
5274         state->dispatch_recv = cli->dispatch_recv;
5275
5276         /* In parameters */
5277
5278         /* Out parameters */
5279
5280         /* Result */
5281         ZERO_STRUCT(state->orig.out.result);
5282
5283         if (DEBUGLEVEL >= 10) {
5284                 NDR_PRINT_IN_DEBUG(PNP_AddID, &state->orig);
5285         }
5286
5287         /* make a temporary copy, that we pass to the dispatch function */
5288         state->tmp = state->orig;
5289
5290         subreq = cli->dispatch_send(state, ev, cli,
5291                                     &ndr_table_ntsvcs,
5292                                     NDR_PNP_ADDID,
5293                                     &state->tmp);
5294         if (tevent_req_nomem(subreq, req)) {
5295                 return tevent_req_post(req, ev);
5296         }
5297         tevent_req_set_callback(subreq, rpccli_PNP_AddID_done, req);
5298         return req;
5299 }
5300
5301 static void rpccli_PNP_AddID_done(struct tevent_req *subreq)
5302 {
5303         struct tevent_req *req = tevent_req_callback_data(
5304                 subreq, struct tevent_req);
5305         struct rpccli_PNP_AddID_state *state = tevent_req_data(
5306                 req, struct rpccli_PNP_AddID_state);
5307         NTSTATUS status;
5308         TALLOC_CTX *mem_ctx;
5309
5310         if (state->out_mem_ctx) {
5311                 mem_ctx = state->out_mem_ctx;
5312         } else {
5313                 mem_ctx = state;
5314         }
5315
5316         status = state->dispatch_recv(subreq, mem_ctx);
5317         TALLOC_FREE(subreq);
5318         if (!NT_STATUS_IS_OK(status)) {
5319                 tevent_req_nterror(req, status);
5320                 return;
5321         }
5322
5323         /* Copy out parameters */
5324
5325         /* Copy result */
5326         state->orig.out.result = state->tmp.out.result;
5327
5328         /* Reset temporary structure */
5329         ZERO_STRUCT(state->tmp);
5330
5331         if (DEBUGLEVEL >= 10) {
5332                 NDR_PRINT_OUT_DEBUG(PNP_AddID, &state->orig);
5333         }
5334
5335         tevent_req_done(req);
5336 }
5337
5338 NTSTATUS rpccli_PNP_AddID_recv(struct tevent_req *req,
5339                                TALLOC_CTX *mem_ctx,
5340                                WERROR *result)
5341 {
5342         struct rpccli_PNP_AddID_state *state = tevent_req_data(
5343                 req, struct rpccli_PNP_AddID_state);
5344         NTSTATUS status;
5345
5346         if (tevent_req_is_nterror(req, &status)) {
5347                 tevent_req_received(req);
5348                 return status;
5349         }
5350
5351         /* Steal possbile out parameters to the callers context */
5352         talloc_steal(mem_ctx, state->out_mem_ctx);
5353
5354         /* Return result */
5355         *result = state->orig.out.result;
5356
5357         tevent_req_received(req);
5358         return NT_STATUS_OK;
5359 }
5360
5361 NTSTATUS rpccli_PNP_AddID(struct rpc_pipe_client *cli,
5362                           TALLOC_CTX *mem_ctx,
5363                           WERROR *werror)
5364 {
5365         struct PNP_AddID r;
5366         NTSTATUS status;
5367
5368         /* In parameters */
5369
5370         if (DEBUGLEVEL >= 10) {
5371                 NDR_PRINT_IN_DEBUG(PNP_AddID, &r);
5372         }
5373
5374         status = cli->dispatch(cli,
5375                                 mem_ctx,
5376                                 &ndr_table_ntsvcs,
5377                                 NDR_PNP_ADDID,
5378                                 &r);
5379
5380         if (!NT_STATUS_IS_OK(status)) {
5381                 return status;
5382         }
5383
5384         if (DEBUGLEVEL >= 10) {
5385                 NDR_PRINT_OUT_DEBUG(PNP_AddID, &r);
5386         }
5387
5388         if (NT_STATUS_IS_ERR(status)) {
5389                 return status;
5390         }
5391
5392         /* Return variables */
5393
5394         /* Return result */
5395         if (werror) {
5396                 *werror = r.out.result;
5397         }
5398
5399         return werror_to_ntstatus(r.out.result);
5400 }
5401
5402 struct rpccli_PNP_RegisterDriver_state {
5403         struct PNP_RegisterDriver orig;
5404         struct PNP_RegisterDriver tmp;
5405         TALLOC_CTX *out_mem_ctx;
5406         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5407 };
5408
5409 static void rpccli_PNP_RegisterDriver_done(struct tevent_req *subreq);
5410
5411 struct tevent_req *rpccli_PNP_RegisterDriver_send(TALLOC_CTX *mem_ctx,
5412                                                   struct tevent_context *ev,
5413                                                   struct rpc_pipe_client *cli)
5414 {
5415         struct tevent_req *req;
5416         struct rpccli_PNP_RegisterDriver_state *state;
5417         struct tevent_req *subreq;
5418
5419         req = tevent_req_create(mem_ctx, &state,
5420                                 struct rpccli_PNP_RegisterDriver_state);
5421         if (req == NULL) {
5422                 return NULL;
5423         }
5424         state->out_mem_ctx = NULL;
5425         state->dispatch_recv = cli->dispatch_recv;
5426
5427         /* In parameters */
5428
5429         /* Out parameters */
5430
5431         /* Result */
5432         ZERO_STRUCT(state->orig.out.result);
5433
5434         if (DEBUGLEVEL >= 10) {
5435                 NDR_PRINT_IN_DEBUG(PNP_RegisterDriver, &state->orig);
5436         }
5437
5438         /* make a temporary copy, that we pass to the dispatch function */
5439         state->tmp = state->orig;
5440
5441         subreq = cli->dispatch_send(state, ev, cli,
5442                                     &ndr_table_ntsvcs,
5443                                     NDR_PNP_REGISTERDRIVER,
5444                                     &state->tmp);
5445         if (tevent_req_nomem(subreq, req)) {
5446                 return tevent_req_post(req, ev);
5447         }
5448         tevent_req_set_callback(subreq, rpccli_PNP_RegisterDriver_done, req);
5449         return req;
5450 }
5451
5452 static void rpccli_PNP_RegisterDriver_done(struct tevent_req *subreq)
5453 {
5454         struct tevent_req *req = tevent_req_callback_data(
5455                 subreq, struct tevent_req);
5456         struct rpccli_PNP_RegisterDriver_state *state = tevent_req_data(
5457                 req, struct rpccli_PNP_RegisterDriver_state);
5458         NTSTATUS status;
5459         TALLOC_CTX *mem_ctx;
5460
5461         if (state->out_mem_ctx) {
5462                 mem_ctx = state->out_mem_ctx;
5463         } else {
5464                 mem_ctx = state;
5465         }
5466
5467         status = state->dispatch_recv(subreq, mem_ctx);
5468         TALLOC_FREE(subreq);
5469         if (!NT_STATUS_IS_OK(status)) {
5470                 tevent_req_nterror(req, status);
5471                 return;
5472         }
5473
5474         /* Copy out parameters */
5475
5476         /* Copy result */
5477         state->orig.out.result = state->tmp.out.result;
5478
5479         /* Reset temporary structure */
5480         ZERO_STRUCT(state->tmp);
5481
5482         if (DEBUGLEVEL >= 10) {
5483                 NDR_PRINT_OUT_DEBUG(PNP_RegisterDriver, &state->orig);
5484         }
5485
5486         tevent_req_done(req);
5487 }
5488
5489 NTSTATUS rpccli_PNP_RegisterDriver_recv(struct tevent_req *req,
5490                                         TALLOC_CTX *mem_ctx,
5491                                         WERROR *result)
5492 {
5493         struct rpccli_PNP_RegisterDriver_state *state = tevent_req_data(
5494                 req, struct rpccli_PNP_RegisterDriver_state);
5495         NTSTATUS status;
5496
5497         if (tevent_req_is_nterror(req, &status)) {
5498                 tevent_req_received(req);
5499                 return status;
5500         }
5501
5502         /* Steal possbile out parameters to the callers context */
5503         talloc_steal(mem_ctx, state->out_mem_ctx);
5504
5505         /* Return result */
5506         *result = state->orig.out.result;
5507
5508         tevent_req_received(req);
5509         return NT_STATUS_OK;
5510 }
5511
5512 NTSTATUS rpccli_PNP_RegisterDriver(struct rpc_pipe_client *cli,
5513                                    TALLOC_CTX *mem_ctx,
5514                                    WERROR *werror)
5515 {
5516         struct PNP_RegisterDriver r;
5517         NTSTATUS status;
5518
5519         /* In parameters */
5520
5521         if (DEBUGLEVEL >= 10) {
5522                 NDR_PRINT_IN_DEBUG(PNP_RegisterDriver, &r);
5523         }
5524
5525         status = cli->dispatch(cli,
5526                                 mem_ctx,
5527                                 &ndr_table_ntsvcs,
5528                                 NDR_PNP_REGISTERDRIVER,
5529                                 &r);
5530
5531         if (!NT_STATUS_IS_OK(status)) {
5532                 return status;
5533         }
5534
5535         if (DEBUGLEVEL >= 10) {
5536                 NDR_PRINT_OUT_DEBUG(PNP_RegisterDriver, &r);
5537         }
5538
5539         if (NT_STATUS_IS_ERR(status)) {
5540                 return status;
5541         }
5542
5543         /* Return variables */
5544
5545         /* Return result */
5546         if (werror) {
5547                 *werror = r.out.result;
5548         }
5549
5550         return werror_to_ntstatus(r.out.result);
5551 }
5552
5553 struct rpccli_PNP_QueryRemove_state {
5554         struct PNP_QueryRemove orig;
5555         struct PNP_QueryRemove tmp;
5556         TALLOC_CTX *out_mem_ctx;
5557         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5558 };
5559
5560 static void rpccli_PNP_QueryRemove_done(struct tevent_req *subreq);
5561
5562 struct tevent_req *rpccli_PNP_QueryRemove_send(TALLOC_CTX *mem_ctx,
5563                                                struct tevent_context *ev,
5564                                                struct rpc_pipe_client *cli)
5565 {
5566         struct tevent_req *req;
5567         struct rpccli_PNP_QueryRemove_state *state;
5568         struct tevent_req *subreq;
5569
5570         req = tevent_req_create(mem_ctx, &state,
5571                                 struct rpccli_PNP_QueryRemove_state);
5572         if (req == NULL) {
5573                 return NULL;
5574         }
5575         state->out_mem_ctx = NULL;
5576         state->dispatch_recv = cli->dispatch_recv;
5577
5578         /* In parameters */
5579
5580         /* Out parameters */
5581
5582         /* Result */
5583         ZERO_STRUCT(state->orig.out.result);
5584
5585         if (DEBUGLEVEL >= 10) {
5586                 NDR_PRINT_IN_DEBUG(PNP_QueryRemove, &state->orig);
5587         }
5588
5589         /* make a temporary copy, that we pass to the dispatch function */
5590         state->tmp = state->orig;
5591
5592         subreq = cli->dispatch_send(state, ev, cli,
5593                                     &ndr_table_ntsvcs,
5594                                     NDR_PNP_QUERYREMOVE,
5595                                     &state->tmp);
5596         if (tevent_req_nomem(subreq, req)) {
5597                 return tevent_req_post(req, ev);
5598         }
5599         tevent_req_set_callback(subreq, rpccli_PNP_QueryRemove_done, req);
5600         return req;
5601 }
5602
5603 static void rpccli_PNP_QueryRemove_done(struct tevent_req *subreq)
5604 {
5605         struct tevent_req *req = tevent_req_callback_data(
5606                 subreq, struct tevent_req);
5607         struct rpccli_PNP_QueryRemove_state *state = tevent_req_data(
5608                 req, struct rpccli_PNP_QueryRemove_state);
5609         NTSTATUS status;
5610         TALLOC_CTX *mem_ctx;
5611
5612         if (state->out_mem_ctx) {
5613                 mem_ctx = state->out_mem_ctx;
5614         } else {
5615                 mem_ctx = state;
5616         }
5617
5618         status = state->dispatch_recv(subreq, mem_ctx);
5619         TALLOC_FREE(subreq);
5620         if (!NT_STATUS_IS_OK(status)) {
5621                 tevent_req_nterror(req, status);
5622                 return;
5623         }
5624
5625         /* Copy out parameters */
5626
5627         /* Copy result */
5628         state->orig.out.result = state->tmp.out.result;
5629
5630         /* Reset temporary structure */
5631         ZERO_STRUCT(state->tmp);
5632
5633         if (DEBUGLEVEL >= 10) {
5634                 NDR_PRINT_OUT_DEBUG(PNP_QueryRemove, &state->orig);
5635         }
5636
5637         tevent_req_done(req);
5638 }
5639
5640 NTSTATUS rpccli_PNP_QueryRemove_recv(struct tevent_req *req,
5641                                      TALLOC_CTX *mem_ctx,
5642                                      WERROR *result)
5643 {
5644         struct rpccli_PNP_QueryRemove_state *state = tevent_req_data(
5645                 req, struct rpccli_PNP_QueryRemove_state);
5646         NTSTATUS status;
5647
5648         if (tevent_req_is_nterror(req, &status)) {
5649                 tevent_req_received(req);
5650                 return status;
5651         }
5652
5653         /* Steal possbile out parameters to the callers context */
5654         talloc_steal(mem_ctx, state->out_mem_ctx);
5655
5656         /* Return result */
5657         *result = state->orig.out.result;
5658
5659         tevent_req_received(req);
5660         return NT_STATUS_OK;
5661 }
5662
5663 NTSTATUS rpccli_PNP_QueryRemove(struct rpc_pipe_client *cli,
5664                                 TALLOC_CTX *mem_ctx,
5665                                 WERROR *werror)
5666 {
5667         struct PNP_QueryRemove r;
5668         NTSTATUS status;
5669
5670         /* In parameters */
5671
5672         if (DEBUGLEVEL >= 10) {
5673                 NDR_PRINT_IN_DEBUG(PNP_QueryRemove, &r);
5674         }
5675
5676         status = cli->dispatch(cli,
5677                                 mem_ctx,
5678                                 &ndr_table_ntsvcs,
5679                                 NDR_PNP_QUERYREMOVE,
5680                                 &r);
5681
5682         if (!NT_STATUS_IS_OK(status)) {
5683                 return status;
5684         }
5685
5686         if (DEBUGLEVEL >= 10) {
5687                 NDR_PRINT_OUT_DEBUG(PNP_QueryRemove, &r);
5688         }
5689
5690         if (NT_STATUS_IS_ERR(status)) {
5691                 return status;
5692         }
5693
5694         /* Return variables */
5695
5696         /* Return result */
5697         if (werror) {
5698                 *werror = r.out.result;
5699         }
5700
5701         return werror_to_ntstatus(r.out.result);
5702 }
5703
5704 struct rpccli_PNP_RequestDeviceEject_state {
5705         struct PNP_RequestDeviceEject orig;
5706         struct PNP_RequestDeviceEject tmp;
5707         TALLOC_CTX *out_mem_ctx;
5708         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5709 };
5710
5711 static void rpccli_PNP_RequestDeviceEject_done(struct tevent_req *subreq);
5712
5713 struct tevent_req *rpccli_PNP_RequestDeviceEject_send(TALLOC_CTX *mem_ctx,
5714                                                       struct tevent_context *ev,
5715                                                       struct rpc_pipe_client *cli)
5716 {
5717         struct tevent_req *req;
5718         struct rpccli_PNP_RequestDeviceEject_state *state;
5719         struct tevent_req *subreq;
5720
5721         req = tevent_req_create(mem_ctx, &state,
5722                                 struct rpccli_PNP_RequestDeviceEject_state);
5723         if (req == NULL) {
5724                 return NULL;
5725         }
5726         state->out_mem_ctx = NULL;
5727         state->dispatch_recv = cli->dispatch_recv;
5728
5729         /* In parameters */
5730
5731         /* Out parameters */
5732
5733         /* Result */
5734         ZERO_STRUCT(state->orig.out.result);
5735
5736         if (DEBUGLEVEL >= 10) {
5737                 NDR_PRINT_IN_DEBUG(PNP_RequestDeviceEject, &state->orig);
5738         }
5739
5740         /* make a temporary copy, that we pass to the dispatch function */
5741         state->tmp = state->orig;
5742
5743         subreq = cli->dispatch_send(state, ev, cli,
5744                                     &ndr_table_ntsvcs,
5745                                     NDR_PNP_REQUESTDEVICEEJECT,
5746                                     &state->tmp);
5747         if (tevent_req_nomem(subreq, req)) {
5748                 return tevent_req_post(req, ev);
5749         }
5750         tevent_req_set_callback(subreq, rpccli_PNP_RequestDeviceEject_done, req);
5751         return req;
5752 }
5753
5754 static void rpccli_PNP_RequestDeviceEject_done(struct tevent_req *subreq)
5755 {
5756         struct tevent_req *req = tevent_req_callback_data(
5757                 subreq, struct tevent_req);
5758         struct rpccli_PNP_RequestDeviceEject_state *state = tevent_req_data(
5759                 req, struct rpccli_PNP_RequestDeviceEject_state);
5760         NTSTATUS status;
5761         TALLOC_CTX *mem_ctx;
5762
5763         if (state->out_mem_ctx) {
5764                 mem_ctx = state->out_mem_ctx;
5765         } else {
5766                 mem_ctx = state;
5767         }
5768
5769         status = state->dispatch_recv(subreq, mem_ctx);
5770         TALLOC_FREE(subreq);
5771         if (!NT_STATUS_IS_OK(status)) {
5772                 tevent_req_nterror(req, status);
5773                 return;
5774         }
5775
5776         /* Copy out parameters */
5777
5778         /* Copy result */
5779         state->orig.out.result = state->tmp.out.result;
5780
5781         /* Reset temporary structure */
5782         ZERO_STRUCT(state->tmp);
5783
5784         if (DEBUGLEVEL >= 10) {
5785                 NDR_PRINT_OUT_DEBUG(PNP_RequestDeviceEject, &state->orig);
5786         }
5787
5788         tevent_req_done(req);
5789 }
5790
5791 NTSTATUS rpccli_PNP_RequestDeviceEject_recv(struct tevent_req *req,
5792                                             TALLOC_CTX *mem_ctx,
5793                                             WERROR *result)
5794 {
5795         struct rpccli_PNP_RequestDeviceEject_state *state = tevent_req_data(
5796                 req, struct rpccli_PNP_RequestDeviceEject_state);
5797         NTSTATUS status;
5798
5799         if (tevent_req_is_nterror(req, &status)) {
5800                 tevent_req_received(req);
5801                 return status;
5802         }
5803
5804         /* Steal possbile out parameters to the callers context */
5805         talloc_steal(mem_ctx, state->out_mem_ctx);
5806
5807         /* Return result */
5808         *result = state->orig.out.result;
5809
5810         tevent_req_received(req);
5811         return NT_STATUS_OK;
5812 }
5813
5814 NTSTATUS rpccli_PNP_RequestDeviceEject(struct rpc_pipe_client *cli,
5815                                        TALLOC_CTX *mem_ctx,
5816                                        WERROR *werror)
5817 {
5818         struct PNP_RequestDeviceEject r;
5819         NTSTATUS status;
5820
5821         /* In parameters */
5822
5823         if (DEBUGLEVEL >= 10) {
5824                 NDR_PRINT_IN_DEBUG(PNP_RequestDeviceEject, &r);
5825         }
5826
5827         status = cli->dispatch(cli,
5828                                 mem_ctx,
5829                                 &ndr_table_ntsvcs,
5830                                 NDR_PNP_REQUESTDEVICEEJECT,
5831                                 &r);
5832
5833         if (!NT_STATUS_IS_OK(status)) {
5834                 return status;
5835         }
5836
5837         if (DEBUGLEVEL >= 10) {
5838                 NDR_PRINT_OUT_DEBUG(PNP_RequestDeviceEject, &r);
5839         }
5840
5841         if (NT_STATUS_IS_ERR(status)) {
5842                 return status;
5843         }
5844
5845         /* Return variables */
5846
5847         /* Return result */
5848         if (werror) {
5849                 *werror = r.out.result;
5850         }
5851
5852         return werror_to_ntstatus(r.out.result);
5853 }
5854
5855 struct rpccli_PNP_IsDockStationPresent_state {
5856         struct PNP_IsDockStationPresent orig;
5857         struct PNP_IsDockStationPresent tmp;
5858         TALLOC_CTX *out_mem_ctx;
5859         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5860 };
5861
5862 static void rpccli_PNP_IsDockStationPresent_done(struct tevent_req *subreq);
5863
5864 struct tevent_req *rpccli_PNP_IsDockStationPresent_send(TALLOC_CTX *mem_ctx,
5865                                                         struct tevent_context *ev,
5866                                                         struct rpc_pipe_client *cli)
5867 {
5868         struct tevent_req *req;
5869         struct rpccli_PNP_IsDockStationPresent_state *state;
5870         struct tevent_req *subreq;
5871
5872         req = tevent_req_create(mem_ctx, &state,
5873                                 struct rpccli_PNP_IsDockStationPresent_state);
5874         if (req == NULL) {
5875                 return NULL;
5876         }
5877         state->out_mem_ctx = NULL;
5878         state->dispatch_recv = cli->dispatch_recv;
5879
5880         /* In parameters */
5881
5882         /* Out parameters */
5883
5884         /* Result */
5885         ZERO_STRUCT(state->orig.out.result);
5886
5887         if (DEBUGLEVEL >= 10) {
5888                 NDR_PRINT_IN_DEBUG(PNP_IsDockStationPresent, &state->orig);
5889         }
5890
5891         /* make a temporary copy, that we pass to the dispatch function */
5892         state->tmp = state->orig;
5893
5894         subreq = cli->dispatch_send(state, ev, cli,
5895                                     &ndr_table_ntsvcs,
5896                                     NDR_PNP_ISDOCKSTATIONPRESENT,
5897                                     &state->tmp);
5898         if (tevent_req_nomem(subreq, req)) {
5899                 return tevent_req_post(req, ev);
5900         }
5901         tevent_req_set_callback(subreq, rpccli_PNP_IsDockStationPresent_done, req);
5902         return req;
5903 }
5904
5905 static void rpccli_PNP_IsDockStationPresent_done(struct tevent_req *subreq)
5906 {
5907         struct tevent_req *req = tevent_req_callback_data(
5908                 subreq, struct tevent_req);
5909         struct rpccli_PNP_IsDockStationPresent_state *state = tevent_req_data(
5910                 req, struct rpccli_PNP_IsDockStationPresent_state);
5911         NTSTATUS status;
5912         TALLOC_CTX *mem_ctx;
5913
5914         if (state->out_mem_ctx) {
5915                 mem_ctx = state->out_mem_ctx;
5916         } else {
5917                 mem_ctx = state;
5918         }
5919
5920         status = state->dispatch_recv(subreq, mem_ctx);
5921         TALLOC_FREE(subreq);
5922         if (!NT_STATUS_IS_OK(status)) {
5923                 tevent_req_nterror(req, status);
5924                 return;
5925         }
5926
5927         /* Copy out parameters */
5928
5929         /* Copy result */
5930         state->orig.out.result = state->tmp.out.result;
5931
5932         /* Reset temporary structure */
5933         ZERO_STRUCT(state->tmp);
5934
5935         if (DEBUGLEVEL >= 10) {
5936                 NDR_PRINT_OUT_DEBUG(PNP_IsDockStationPresent, &state->orig);
5937         }
5938
5939         tevent_req_done(req);
5940 }
5941
5942 NTSTATUS rpccli_PNP_IsDockStationPresent_recv(struct tevent_req *req,
5943                                               TALLOC_CTX *mem_ctx,
5944                                               WERROR *result)
5945 {
5946         struct rpccli_PNP_IsDockStationPresent_state *state = tevent_req_data(
5947                 req, struct rpccli_PNP_IsDockStationPresent_state);
5948         NTSTATUS status;
5949
5950         if (tevent_req_is_nterror(req, &status)) {
5951                 tevent_req_received(req);
5952                 return status;
5953         }
5954
5955         /* Steal possbile out parameters to the callers context */
5956         talloc_steal(mem_ctx, state->out_mem_ctx);
5957
5958         /* Return result */
5959         *result = state->orig.out.result;
5960
5961         tevent_req_received(req);
5962         return NT_STATUS_OK;
5963 }
5964
5965 NTSTATUS rpccli_PNP_IsDockStationPresent(struct rpc_pipe_client *cli,
5966                                          TALLOC_CTX *mem_ctx,
5967                                          WERROR *werror)
5968 {
5969         struct PNP_IsDockStationPresent r;
5970         NTSTATUS status;
5971
5972         /* In parameters */
5973
5974         if (DEBUGLEVEL >= 10) {
5975                 NDR_PRINT_IN_DEBUG(PNP_IsDockStationPresent, &r);
5976         }
5977
5978         status = cli->dispatch(cli,
5979                                 mem_ctx,
5980                                 &ndr_table_ntsvcs,
5981                                 NDR_PNP_ISDOCKSTATIONPRESENT,
5982                                 &r);
5983
5984         if (!NT_STATUS_IS_OK(status)) {
5985                 return status;
5986         }
5987
5988         if (DEBUGLEVEL >= 10) {
5989                 NDR_PRINT_OUT_DEBUG(PNP_IsDockStationPresent, &r);
5990         }
5991
5992         if (NT_STATUS_IS_ERR(status)) {
5993                 return status;
5994         }
5995
5996         /* Return variables */
5997
5998         /* Return result */
5999         if (werror) {
6000                 *werror = r.out.result;
6001         }
6002
6003         return werror_to_ntstatus(r.out.result);
6004 }
6005
6006 struct rpccli_PNP_RequestEjectPC_state {
6007         struct PNP_RequestEjectPC orig;
6008         struct PNP_RequestEjectPC tmp;
6009         TALLOC_CTX *out_mem_ctx;
6010         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6011 };
6012
6013 static void rpccli_PNP_RequestEjectPC_done(struct tevent_req *subreq);
6014
6015 struct tevent_req *rpccli_PNP_RequestEjectPC_send(TALLOC_CTX *mem_ctx,
6016                                                   struct tevent_context *ev,
6017                                                   struct rpc_pipe_client *cli)
6018 {
6019         struct tevent_req *req;
6020         struct rpccli_PNP_RequestEjectPC_state *state;
6021         struct tevent_req *subreq;
6022
6023         req = tevent_req_create(mem_ctx, &state,
6024                                 struct rpccli_PNP_RequestEjectPC_state);
6025         if (req == NULL) {
6026                 return NULL;
6027         }
6028         state->out_mem_ctx = NULL;
6029         state->dispatch_recv = cli->dispatch_recv;
6030
6031         /* In parameters */
6032
6033         /* Out parameters */
6034
6035         /* Result */
6036         ZERO_STRUCT(state->orig.out.result);
6037
6038         if (DEBUGLEVEL >= 10) {
6039                 NDR_PRINT_IN_DEBUG(PNP_RequestEjectPC, &state->orig);
6040         }
6041
6042         /* make a temporary copy, that we pass to the dispatch function */
6043         state->tmp = state->orig;
6044
6045         subreq = cli->dispatch_send(state, ev, cli,
6046                                     &ndr_table_ntsvcs,
6047                                     NDR_PNP_REQUESTEJECTPC,
6048                                     &state->tmp);
6049         if (tevent_req_nomem(subreq, req)) {
6050                 return tevent_req_post(req, ev);
6051         }
6052         tevent_req_set_callback(subreq, rpccli_PNP_RequestEjectPC_done, req);
6053         return req;
6054 }
6055
6056 static void rpccli_PNP_RequestEjectPC_done(struct tevent_req *subreq)
6057 {
6058         struct tevent_req *req = tevent_req_callback_data(
6059                 subreq, struct tevent_req);
6060         struct rpccli_PNP_RequestEjectPC_state *state = tevent_req_data(
6061                 req, struct rpccli_PNP_RequestEjectPC_state);
6062         NTSTATUS status;
6063         TALLOC_CTX *mem_ctx;
6064
6065         if (state->out_mem_ctx) {
6066                 mem_ctx = state->out_mem_ctx;
6067         } else {
6068                 mem_ctx = state;
6069         }
6070
6071         status = state->dispatch_recv(subreq, mem_ctx);
6072         TALLOC_FREE(subreq);
6073         if (!NT_STATUS_IS_OK(status)) {
6074                 tevent_req_nterror(req, status);
6075                 return;
6076         }
6077
6078         /* Copy out parameters */
6079
6080         /* Copy result */
6081         state->orig.out.result = state->tmp.out.result;
6082
6083         /* Reset temporary structure */
6084         ZERO_STRUCT(state->tmp);
6085
6086         if (DEBUGLEVEL >= 10) {
6087                 NDR_PRINT_OUT_DEBUG(PNP_RequestEjectPC, &state->orig);
6088         }
6089
6090         tevent_req_done(req);
6091 }
6092
6093 NTSTATUS rpccli_PNP_RequestEjectPC_recv(struct tevent_req *req,
6094                                         TALLOC_CTX *mem_ctx,
6095                                         WERROR *result)
6096 {
6097         struct rpccli_PNP_RequestEjectPC_state *state = tevent_req_data(
6098                 req, struct rpccli_PNP_RequestEjectPC_state);
6099         NTSTATUS status;
6100
6101         if (tevent_req_is_nterror(req, &status)) {
6102                 tevent_req_received(req);
6103                 return status;
6104         }
6105
6106         /* Steal possbile out parameters to the callers context */
6107         talloc_steal(mem_ctx, state->out_mem_ctx);
6108
6109         /* Return result */
6110         *result = state->orig.out.result;
6111
6112         tevent_req_received(req);
6113         return NT_STATUS_OK;
6114 }
6115
6116 NTSTATUS rpccli_PNP_RequestEjectPC(struct rpc_pipe_client *cli,
6117                                    TALLOC_CTX *mem_ctx,
6118                                    WERROR *werror)
6119 {
6120         struct PNP_RequestEjectPC r;
6121         NTSTATUS status;
6122
6123         /* In parameters */
6124
6125         if (DEBUGLEVEL >= 10) {
6126                 NDR_PRINT_IN_DEBUG(PNP_RequestEjectPC, &r);
6127         }
6128
6129         status = cli->dispatch(cli,
6130                                 mem_ctx,
6131                                 &ndr_table_ntsvcs,
6132                                 NDR_PNP_REQUESTEJECTPC,
6133                                 &r);
6134
6135         if (!NT_STATUS_IS_OK(status)) {
6136                 return status;
6137         }
6138
6139         if (DEBUGLEVEL >= 10) {
6140                 NDR_PRINT_OUT_DEBUG(PNP_RequestEjectPC, &r);
6141         }
6142
6143         if (NT_STATUS_IS_ERR(status)) {
6144                 return status;
6145         }
6146
6147         /* Return variables */
6148
6149         /* Return result */
6150         if (werror) {
6151                 *werror = r.out.result;
6152         }
6153
6154         return werror_to_ntstatus(r.out.result);
6155 }
6156
6157 struct rpccli_PNP_HwProfFlags_state {
6158         struct PNP_HwProfFlags orig;
6159         struct PNP_HwProfFlags tmp;
6160         TALLOC_CTX *out_mem_ctx;
6161         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6162 };
6163
6164 static void rpccli_PNP_HwProfFlags_done(struct tevent_req *subreq);
6165
6166 struct tevent_req *rpccli_PNP_HwProfFlags_send(TALLOC_CTX *mem_ctx,
6167                                                struct tevent_context *ev,
6168                                                struct rpc_pipe_client *cli,
6169                                                uint32_t _action /* [in]  */,
6170                                                const char *_devicepath /* [in] [ref,charset(UTF16)] */,
6171                                                uint32_t _config /* [in]  */,
6172                                                uint32_t *_profile_flags /* [in,out] [ref] */,
6173                                                uint16_t *_veto_type /* [in,out] [unique] */,
6174                                                const char *_unknown5 /* [in] [unique,charset(UTF16)] */,
6175                                                const char **_unknown5a /* [out] [unique,charset(UTF16)] */,
6176                                                uint32_t _name_length /* [in]  */,
6177                                                uint32_t _flags /* [in]  */)
6178 {
6179         struct tevent_req *req;
6180         struct rpccli_PNP_HwProfFlags_state *state;
6181         struct tevent_req *subreq;
6182
6183         req = tevent_req_create(mem_ctx, &state,
6184                                 struct rpccli_PNP_HwProfFlags_state);
6185         if (req == NULL) {
6186                 return NULL;
6187         }
6188         state->out_mem_ctx = NULL;
6189         state->dispatch_recv = cli->dispatch_recv;
6190
6191         /* In parameters */
6192         state->orig.in.action = _action;
6193         state->orig.in.devicepath = _devicepath;
6194         state->orig.in.config = _config;
6195         state->orig.in.profile_flags = _profile_flags;
6196         state->orig.in.veto_type = _veto_type;
6197         state->orig.in.unknown5 = _unknown5;
6198         state->orig.in.name_length = _name_length;
6199         state->orig.in.flags = _flags;
6200
6201         /* Out parameters */
6202         state->orig.out.profile_flags = _profile_flags;
6203         state->orig.out.veto_type = _veto_type;
6204         state->orig.out.unknown5a = _unknown5a;
6205
6206         /* Result */
6207         ZERO_STRUCT(state->orig.out.result);
6208
6209         if (DEBUGLEVEL >= 10) {
6210                 NDR_PRINT_IN_DEBUG(PNP_HwProfFlags, &state->orig);
6211         }
6212
6213         state->out_mem_ctx = talloc_named_const(state, 0,
6214                              "rpccli_PNP_HwProfFlags_out_memory");
6215         if (tevent_req_nomem(state->out_mem_ctx, req)) {
6216                 return tevent_req_post(req, ev);
6217         }
6218
6219         /* make a temporary copy, that we pass to the dispatch function */
6220         state->tmp = state->orig;
6221
6222         subreq = cli->dispatch_send(state, ev, cli,
6223                                     &ndr_table_ntsvcs,
6224                                     NDR_PNP_HWPROFFLAGS,
6225                                     &state->tmp);
6226         if (tevent_req_nomem(subreq, req)) {
6227                 return tevent_req_post(req, ev);
6228         }
6229         tevent_req_set_callback(subreq, rpccli_PNP_HwProfFlags_done, req);
6230         return req;
6231 }
6232
6233 static void rpccli_PNP_HwProfFlags_done(struct tevent_req *subreq)
6234 {
6235         struct tevent_req *req = tevent_req_callback_data(
6236                 subreq, struct tevent_req);
6237         struct rpccli_PNP_HwProfFlags_state *state = tevent_req_data(
6238                 req, struct rpccli_PNP_HwProfFlags_state);
6239         NTSTATUS status;
6240         TALLOC_CTX *mem_ctx;
6241
6242         if (state->out_mem_ctx) {
6243                 mem_ctx = state->out_mem_ctx;
6244         } else {
6245                 mem_ctx = state;
6246         }
6247
6248         status = state->dispatch_recv(subreq, mem_ctx);
6249         TALLOC_FREE(subreq);
6250         if (!NT_STATUS_IS_OK(status)) {
6251                 tevent_req_nterror(req, status);
6252                 return;
6253         }
6254
6255         /* Copy out parameters */
6256         *state->orig.out.profile_flags = *state->tmp.out.profile_flags;
6257         if (state->orig.out.veto_type && state->tmp.out.veto_type) {
6258                 *state->orig.out.veto_type = *state->tmp.out.veto_type;
6259         }
6260         if (state->orig.out.unknown5a && state->tmp.out.unknown5a) {
6261                 *state->orig.out.unknown5a = *state->tmp.out.unknown5a;
6262         }
6263
6264         /* Copy result */
6265         state->orig.out.result = state->tmp.out.result;
6266
6267         /* Reset temporary structure */
6268         ZERO_STRUCT(state->tmp);
6269
6270         if (DEBUGLEVEL >= 10) {
6271                 NDR_PRINT_OUT_DEBUG(PNP_HwProfFlags, &state->orig);
6272         }
6273
6274         tevent_req_done(req);
6275 }
6276
6277 NTSTATUS rpccli_PNP_HwProfFlags_recv(struct tevent_req *req,
6278                                      TALLOC_CTX *mem_ctx,
6279                                      WERROR *result)
6280 {
6281         struct rpccli_PNP_HwProfFlags_state *state = tevent_req_data(
6282                 req, struct rpccli_PNP_HwProfFlags_state);
6283         NTSTATUS status;
6284
6285         if (tevent_req_is_nterror(req, &status)) {
6286                 tevent_req_received(req);
6287                 return status;
6288         }
6289
6290         /* Steal possbile out parameters to the callers context */
6291         talloc_steal(mem_ctx, state->out_mem_ctx);
6292
6293         /* Return result */
6294         *result = state->orig.out.result;
6295
6296         tevent_req_received(req);
6297         return NT_STATUS_OK;
6298 }
6299
6300 NTSTATUS rpccli_PNP_HwProfFlags(struct rpc_pipe_client *cli,
6301                                 TALLOC_CTX *mem_ctx,
6302                                 uint32_t action /* [in]  */,
6303                                 const char *devicepath /* [in] [ref,charset(UTF16)] */,
6304                                 uint32_t config /* [in]  */,
6305                                 uint32_t *profile_flags /* [in,out] [ref] */,
6306                                 uint16_t *veto_type /* [in,out] [unique] */,
6307                                 const char *unknown5 /* [in] [unique,charset(UTF16)] */,
6308                                 const char **unknown5a /* [out] [unique,charset(UTF16)] */,
6309                                 uint32_t name_length /* [in]  */,
6310                                 uint32_t flags /* [in]  */,
6311                                 WERROR *werror)
6312 {
6313         struct PNP_HwProfFlags r;
6314         NTSTATUS status;
6315
6316         /* In parameters */
6317         r.in.action = action;
6318         r.in.devicepath = devicepath;
6319         r.in.config = config;
6320         r.in.profile_flags = profile_flags;
6321         r.in.veto_type = veto_type;
6322         r.in.unknown5 = unknown5;
6323         r.in.name_length = name_length;
6324         r.in.flags = flags;
6325
6326         if (DEBUGLEVEL >= 10) {
6327                 NDR_PRINT_IN_DEBUG(PNP_HwProfFlags, &r);
6328         }
6329
6330         status = cli->dispatch(cli,
6331                                 mem_ctx,
6332                                 &ndr_table_ntsvcs,
6333                                 NDR_PNP_HWPROFFLAGS,
6334                                 &r);
6335
6336         if (!NT_STATUS_IS_OK(status)) {
6337                 return status;
6338         }
6339
6340         if (DEBUGLEVEL >= 10) {
6341                 NDR_PRINT_OUT_DEBUG(PNP_HwProfFlags, &r);
6342         }
6343
6344         if (NT_STATUS_IS_ERR(status)) {
6345                 return status;
6346         }
6347
6348         /* Return variables */
6349         *profile_flags = *r.out.profile_flags;
6350         if (veto_type && r.out.veto_type) {
6351                 *veto_type = *r.out.veto_type;
6352         }
6353         if (unknown5a && r.out.unknown5a) {
6354                 *unknown5a = *r.out.unknown5a;
6355         }
6356
6357         /* Return result */
6358         if (werror) {
6359                 *werror = r.out.result;
6360         }
6361
6362         return werror_to_ntstatus(r.out.result);
6363 }
6364
6365 struct rpccli_PNP_GetHwProfInfo_state {
6366         struct PNP_GetHwProfInfo orig;
6367         struct PNP_GetHwProfInfo tmp;
6368         TALLOC_CTX *out_mem_ctx;
6369         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6370 };
6371
6372 static void rpccli_PNP_GetHwProfInfo_done(struct tevent_req *subreq);
6373
6374 struct tevent_req *rpccli_PNP_GetHwProfInfo_send(TALLOC_CTX *mem_ctx,
6375                                                  struct tevent_context *ev,
6376                                                  struct rpc_pipe_client *cli,
6377                                                  uint32_t _idx /* [in]  */,
6378                                                  struct PNP_HwProfInfo *_info /* [in,out] [ref] */,
6379                                                  uint32_t _size /* [in]  */,
6380                                                  uint32_t _flags /* [in]  */)
6381 {
6382         struct tevent_req *req;
6383         struct rpccli_PNP_GetHwProfInfo_state *state;
6384         struct tevent_req *subreq;
6385
6386         req = tevent_req_create(mem_ctx, &state,
6387                                 struct rpccli_PNP_GetHwProfInfo_state);
6388         if (req == NULL) {
6389                 return NULL;
6390         }
6391         state->out_mem_ctx = NULL;
6392         state->dispatch_recv = cli->dispatch_recv;
6393
6394         /* In parameters */
6395         state->orig.in.idx = _idx;
6396         state->orig.in.info = _info;
6397         state->orig.in.size = _size;
6398         state->orig.in.flags = _flags;
6399
6400         /* Out parameters */
6401         state->orig.out.info = _info;
6402
6403         /* Result */
6404         ZERO_STRUCT(state->orig.out.result);
6405
6406         if (DEBUGLEVEL >= 10) {
6407                 NDR_PRINT_IN_DEBUG(PNP_GetHwProfInfo, &state->orig);
6408         }
6409
6410         state->out_mem_ctx = talloc_named_const(state, 0,
6411                              "rpccli_PNP_GetHwProfInfo_out_memory");
6412         if (tevent_req_nomem(state->out_mem_ctx, req)) {
6413                 return tevent_req_post(req, ev);
6414         }
6415
6416         /* make a temporary copy, that we pass to the dispatch function */
6417         state->tmp = state->orig;
6418
6419         subreq = cli->dispatch_send(state, ev, cli,
6420                                     &ndr_table_ntsvcs,
6421                                     NDR_PNP_GETHWPROFINFO,
6422                                     &state->tmp);
6423         if (tevent_req_nomem(subreq, req)) {
6424                 return tevent_req_post(req, ev);
6425         }
6426         tevent_req_set_callback(subreq, rpccli_PNP_GetHwProfInfo_done, req);
6427         return req;
6428 }
6429
6430 static void rpccli_PNP_GetHwProfInfo_done(struct tevent_req *subreq)
6431 {
6432         struct tevent_req *req = tevent_req_callback_data(
6433                 subreq, struct tevent_req);
6434         struct rpccli_PNP_GetHwProfInfo_state *state = tevent_req_data(
6435                 req, struct rpccli_PNP_GetHwProfInfo_state);
6436         NTSTATUS status;
6437         TALLOC_CTX *mem_ctx;
6438
6439         if (state->out_mem_ctx) {
6440                 mem_ctx = state->out_mem_ctx;
6441         } else {
6442                 mem_ctx = state;
6443         }
6444
6445         status = state->dispatch_recv(subreq, mem_ctx);
6446         TALLOC_FREE(subreq);
6447         if (!NT_STATUS_IS_OK(status)) {
6448                 tevent_req_nterror(req, status);
6449                 return;
6450         }
6451
6452         /* Copy out parameters */
6453         *state->orig.out.info = *state->tmp.out.info;
6454
6455         /* Copy result */
6456         state->orig.out.result = state->tmp.out.result;
6457
6458         /* Reset temporary structure */
6459         ZERO_STRUCT(state->tmp);
6460
6461         if (DEBUGLEVEL >= 10) {
6462                 NDR_PRINT_OUT_DEBUG(PNP_GetHwProfInfo, &state->orig);
6463         }
6464
6465         tevent_req_done(req);
6466 }
6467
6468 NTSTATUS rpccli_PNP_GetHwProfInfo_recv(struct tevent_req *req,
6469                                        TALLOC_CTX *mem_ctx,
6470                                        WERROR *result)
6471 {
6472         struct rpccli_PNP_GetHwProfInfo_state *state = tevent_req_data(
6473                 req, struct rpccli_PNP_GetHwProfInfo_state);
6474         NTSTATUS status;
6475
6476         if (tevent_req_is_nterror(req, &status)) {
6477                 tevent_req_received(req);
6478                 return status;
6479         }
6480
6481         /* Steal possbile out parameters to the callers context */
6482         talloc_steal(mem_ctx, state->out_mem_ctx);
6483
6484         /* Return result */
6485         *result = state->orig.out.result;
6486
6487         tevent_req_received(req);
6488         return NT_STATUS_OK;
6489 }
6490
6491 NTSTATUS rpccli_PNP_GetHwProfInfo(struct rpc_pipe_client *cli,
6492                                   TALLOC_CTX *mem_ctx,
6493                                   uint32_t idx /* [in]  */,
6494                                   struct PNP_HwProfInfo *info /* [in,out] [ref] */,
6495                                   uint32_t size /* [in]  */,
6496                                   uint32_t flags /* [in]  */,
6497                                   WERROR *werror)
6498 {
6499         struct PNP_GetHwProfInfo r;
6500         NTSTATUS status;
6501
6502         /* In parameters */
6503         r.in.idx = idx;
6504         r.in.info = info;
6505         r.in.size = size;
6506         r.in.flags = flags;
6507
6508         if (DEBUGLEVEL >= 10) {
6509                 NDR_PRINT_IN_DEBUG(PNP_GetHwProfInfo, &r);
6510         }
6511
6512         status = cli->dispatch(cli,
6513                                 mem_ctx,
6514                                 &ndr_table_ntsvcs,
6515                                 NDR_PNP_GETHWPROFINFO,
6516                                 &r);
6517
6518         if (!NT_STATUS_IS_OK(status)) {
6519                 return status;
6520         }
6521
6522         if (DEBUGLEVEL >= 10) {
6523                 NDR_PRINT_OUT_DEBUG(PNP_GetHwProfInfo, &r);
6524         }
6525
6526         if (NT_STATUS_IS_ERR(status)) {
6527                 return status;
6528         }
6529
6530         /* Return variables */
6531         *info = *r.out.info;
6532
6533         /* Return result */
6534         if (werror) {
6535                 *werror = r.out.result;
6536         }
6537
6538         return werror_to_ntstatus(r.out.result);
6539 }
6540
6541 struct rpccli_PNP_AddEmptyLogConf_state {
6542         struct PNP_AddEmptyLogConf orig;
6543         struct PNP_AddEmptyLogConf tmp;
6544         TALLOC_CTX *out_mem_ctx;
6545         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6546 };
6547
6548 static void rpccli_PNP_AddEmptyLogConf_done(struct tevent_req *subreq);
6549
6550 struct tevent_req *rpccli_PNP_AddEmptyLogConf_send(TALLOC_CTX *mem_ctx,
6551                                                    struct tevent_context *ev,
6552                                                    struct rpc_pipe_client *cli)
6553 {
6554         struct tevent_req *req;
6555         struct rpccli_PNP_AddEmptyLogConf_state *state;
6556         struct tevent_req *subreq;
6557
6558         req = tevent_req_create(mem_ctx, &state,
6559                                 struct rpccli_PNP_AddEmptyLogConf_state);
6560         if (req == NULL) {
6561                 return NULL;
6562         }
6563         state->out_mem_ctx = NULL;
6564         state->dispatch_recv = cli->dispatch_recv;
6565
6566         /* In parameters */
6567
6568         /* Out parameters */
6569
6570         /* Result */
6571         ZERO_STRUCT(state->orig.out.result);
6572
6573         if (DEBUGLEVEL >= 10) {
6574                 NDR_PRINT_IN_DEBUG(PNP_AddEmptyLogConf, &state->orig);
6575         }
6576
6577         /* make a temporary copy, that we pass to the dispatch function */
6578         state->tmp = state->orig;
6579
6580         subreq = cli->dispatch_send(state, ev, cli,
6581                                     &ndr_table_ntsvcs,
6582                                     NDR_PNP_ADDEMPTYLOGCONF,
6583                                     &state->tmp);
6584         if (tevent_req_nomem(subreq, req)) {
6585                 return tevent_req_post(req, ev);
6586         }
6587         tevent_req_set_callback(subreq, rpccli_PNP_AddEmptyLogConf_done, req);
6588         return req;
6589 }
6590
6591 static void rpccli_PNP_AddEmptyLogConf_done(struct tevent_req *subreq)
6592 {
6593         struct tevent_req *req = tevent_req_callback_data(
6594                 subreq, struct tevent_req);
6595         struct rpccli_PNP_AddEmptyLogConf_state *state = tevent_req_data(
6596                 req, struct rpccli_PNP_AddEmptyLogConf_state);
6597         NTSTATUS status;
6598         TALLOC_CTX *mem_ctx;
6599
6600         if (state->out_mem_ctx) {
6601                 mem_ctx = state->out_mem_ctx;
6602         } else {
6603                 mem_ctx = state;
6604         }
6605
6606         status = state->dispatch_recv(subreq, mem_ctx);
6607         TALLOC_FREE(subreq);
6608         if (!NT_STATUS_IS_OK(status)) {
6609                 tevent_req_nterror(req, status);
6610                 return;
6611         }
6612
6613         /* Copy out parameters */
6614
6615         /* Copy result */
6616         state->orig.out.result = state->tmp.out.result;
6617
6618         /* Reset temporary structure */
6619         ZERO_STRUCT(state->tmp);
6620
6621         if (DEBUGLEVEL >= 10) {
6622                 NDR_PRINT_OUT_DEBUG(PNP_AddEmptyLogConf, &state->orig);
6623         }
6624
6625         tevent_req_done(req);
6626 }
6627
6628 NTSTATUS rpccli_PNP_AddEmptyLogConf_recv(struct tevent_req *req,
6629                                          TALLOC_CTX *mem_ctx,
6630                                          WERROR *result)
6631 {
6632         struct rpccli_PNP_AddEmptyLogConf_state *state = tevent_req_data(
6633                 req, struct rpccli_PNP_AddEmptyLogConf_state);
6634         NTSTATUS status;
6635
6636         if (tevent_req_is_nterror(req, &status)) {
6637                 tevent_req_received(req);
6638                 return status;
6639         }
6640
6641         /* Steal possbile out parameters to the callers context */
6642         talloc_steal(mem_ctx, state->out_mem_ctx);
6643
6644         /* Return result */
6645         *result = state->orig.out.result;
6646
6647         tevent_req_received(req);
6648         return NT_STATUS_OK;
6649 }
6650
6651 NTSTATUS rpccli_PNP_AddEmptyLogConf(struct rpc_pipe_client *cli,
6652                                     TALLOC_CTX *mem_ctx,
6653                                     WERROR *werror)
6654 {
6655         struct PNP_AddEmptyLogConf r;
6656         NTSTATUS status;
6657
6658         /* In parameters */
6659
6660         if (DEBUGLEVEL >= 10) {
6661                 NDR_PRINT_IN_DEBUG(PNP_AddEmptyLogConf, &r);
6662         }
6663
6664         status = cli->dispatch(cli,
6665                                 mem_ctx,
6666                                 &ndr_table_ntsvcs,
6667                                 NDR_PNP_ADDEMPTYLOGCONF,
6668                                 &r);
6669
6670         if (!NT_STATUS_IS_OK(status)) {
6671                 return status;
6672         }
6673
6674         if (DEBUGLEVEL >= 10) {
6675                 NDR_PRINT_OUT_DEBUG(PNP_AddEmptyLogConf, &r);
6676         }
6677
6678         if (NT_STATUS_IS_ERR(status)) {
6679                 return status;
6680         }
6681
6682         /* Return variables */
6683
6684         /* Return result */
6685         if (werror) {
6686                 *werror = r.out.result;
6687         }
6688
6689         return werror_to_ntstatus(r.out.result);
6690 }
6691
6692 struct rpccli_PNP_FreeLogConf_state {
6693         struct PNP_FreeLogConf orig;
6694         struct PNP_FreeLogConf tmp;
6695         TALLOC_CTX *out_mem_ctx;
6696         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6697 };
6698
6699 static void rpccli_PNP_FreeLogConf_done(struct tevent_req *subreq);
6700
6701 struct tevent_req *rpccli_PNP_FreeLogConf_send(TALLOC_CTX *mem_ctx,
6702                                                struct tevent_context *ev,
6703                                                struct rpc_pipe_client *cli)
6704 {
6705         struct tevent_req *req;
6706         struct rpccli_PNP_FreeLogConf_state *state;
6707         struct tevent_req *subreq;
6708
6709         req = tevent_req_create(mem_ctx, &state,
6710                                 struct rpccli_PNP_FreeLogConf_state);
6711         if (req == NULL) {
6712                 return NULL;
6713         }
6714         state->out_mem_ctx = NULL;
6715         state->dispatch_recv = cli->dispatch_recv;
6716
6717         /* In parameters */
6718
6719         /* Out parameters */
6720
6721         /* Result */
6722         ZERO_STRUCT(state->orig.out.result);
6723
6724         if (DEBUGLEVEL >= 10) {
6725                 NDR_PRINT_IN_DEBUG(PNP_FreeLogConf, &state->orig);
6726         }
6727
6728         /* make a temporary copy, that we pass to the dispatch function */
6729         state->tmp = state->orig;
6730
6731         subreq = cli->dispatch_send(state, ev, cli,
6732                                     &ndr_table_ntsvcs,
6733                                     NDR_PNP_FREELOGCONF,
6734                                     &state->tmp);
6735         if (tevent_req_nomem(subreq, req)) {
6736                 return tevent_req_post(req, ev);
6737         }
6738         tevent_req_set_callback(subreq, rpccli_PNP_FreeLogConf_done, req);
6739         return req;
6740 }
6741
6742 static void rpccli_PNP_FreeLogConf_done(struct tevent_req *subreq)
6743 {
6744         struct tevent_req *req = tevent_req_callback_data(
6745                 subreq, struct tevent_req);
6746         struct rpccli_PNP_FreeLogConf_state *state = tevent_req_data(
6747                 req, struct rpccli_PNP_FreeLogConf_state);
6748         NTSTATUS status;
6749         TALLOC_CTX *mem_ctx;
6750
6751         if (state->out_mem_ctx) {
6752                 mem_ctx = state->out_mem_ctx;
6753         } else {
6754                 mem_ctx = state;
6755         }
6756
6757         status = state->dispatch_recv(subreq, mem_ctx);
6758         TALLOC_FREE(subreq);
6759         if (!NT_STATUS_IS_OK(status)) {
6760                 tevent_req_nterror(req, status);
6761                 return;
6762         }
6763
6764         /* Copy out parameters */
6765
6766         /* Copy result */
6767         state->orig.out.result = state->tmp.out.result;
6768
6769         /* Reset temporary structure */
6770         ZERO_STRUCT(state->tmp);
6771
6772         if (DEBUGLEVEL >= 10) {
6773                 NDR_PRINT_OUT_DEBUG(PNP_FreeLogConf, &state->orig);
6774         }
6775
6776         tevent_req_done(req);
6777 }
6778
6779 NTSTATUS rpccli_PNP_FreeLogConf_recv(struct tevent_req *req,
6780                                      TALLOC_CTX *mem_ctx,
6781                                      WERROR *result)
6782 {
6783         struct rpccli_PNP_FreeLogConf_state *state = tevent_req_data(
6784                 req, struct rpccli_PNP_FreeLogConf_state);
6785         NTSTATUS status;
6786
6787         if (tevent_req_is_nterror(req, &status)) {
6788                 tevent_req_received(req);
6789                 return status;
6790         }
6791
6792         /* Steal possbile out parameters to the callers context */
6793         talloc_steal(mem_ctx, state->out_mem_ctx);
6794
6795         /* Return result */
6796         *result = state->orig.out.result;
6797
6798         tevent_req_received(req);
6799         return NT_STATUS_OK;
6800 }
6801
6802 NTSTATUS rpccli_PNP_FreeLogConf(struct rpc_pipe_client *cli,
6803                                 TALLOC_CTX *mem_ctx,
6804                                 WERROR *werror)
6805 {
6806         struct PNP_FreeLogConf r;
6807         NTSTATUS status;
6808
6809         /* In parameters */
6810
6811         if (DEBUGLEVEL >= 10) {
6812                 NDR_PRINT_IN_DEBUG(PNP_FreeLogConf, &r);
6813         }
6814
6815         status = cli->dispatch(cli,
6816                                 mem_ctx,
6817                                 &ndr_table_ntsvcs,
6818                                 NDR_PNP_FREELOGCONF,
6819                                 &r);
6820
6821         if (!NT_STATUS_IS_OK(status)) {
6822                 return status;
6823         }
6824
6825         if (DEBUGLEVEL >= 10) {
6826                 NDR_PRINT_OUT_DEBUG(PNP_FreeLogConf, &r);
6827         }
6828
6829         if (NT_STATUS_IS_ERR(status)) {
6830                 return status;
6831         }
6832
6833         /* Return variables */
6834
6835         /* Return result */
6836         if (werror) {
6837                 *werror = r.out.result;
6838         }
6839
6840         return werror_to_ntstatus(r.out.result);
6841 }
6842
6843 struct rpccli_PNP_GetFirstLogConf_state {
6844         struct PNP_GetFirstLogConf orig;
6845         struct PNP_GetFirstLogConf tmp;
6846         TALLOC_CTX *out_mem_ctx;
6847         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6848 };
6849
6850 static void rpccli_PNP_GetFirstLogConf_done(struct tevent_req *subreq);
6851
6852 struct tevent_req *rpccli_PNP_GetFirstLogConf_send(TALLOC_CTX *mem_ctx,
6853                                                    struct tevent_context *ev,
6854                                                    struct rpc_pipe_client *cli)
6855 {
6856         struct tevent_req *req;
6857         struct rpccli_PNP_GetFirstLogConf_state *state;
6858         struct tevent_req *subreq;
6859
6860         req = tevent_req_create(mem_ctx, &state,
6861                                 struct rpccli_PNP_GetFirstLogConf_state);
6862         if (req == NULL) {
6863                 return NULL;
6864         }
6865         state->out_mem_ctx = NULL;
6866         state->dispatch_recv = cli->dispatch_recv;
6867
6868         /* In parameters */
6869
6870         /* Out parameters */
6871
6872         /* Result */
6873         ZERO_STRUCT(state->orig.out.result);
6874
6875         if (DEBUGLEVEL >= 10) {
6876                 NDR_PRINT_IN_DEBUG(PNP_GetFirstLogConf, &state->orig);
6877         }
6878
6879         /* make a temporary copy, that we pass to the dispatch function */
6880         state->tmp = state->orig;
6881
6882         subreq = cli->dispatch_send(state, ev, cli,
6883                                     &ndr_table_ntsvcs,
6884                                     NDR_PNP_GETFIRSTLOGCONF,
6885                                     &state->tmp);
6886         if (tevent_req_nomem(subreq, req)) {
6887                 return tevent_req_post(req, ev);
6888         }
6889         tevent_req_set_callback(subreq, rpccli_PNP_GetFirstLogConf_done, req);
6890         return req;
6891 }
6892
6893 static void rpccli_PNP_GetFirstLogConf_done(struct tevent_req *subreq)
6894 {
6895         struct tevent_req *req = tevent_req_callback_data(
6896                 subreq, struct tevent_req);
6897         struct rpccli_PNP_GetFirstLogConf_state *state = tevent_req_data(
6898                 req, struct rpccli_PNP_GetFirstLogConf_state);
6899         NTSTATUS status;
6900         TALLOC_CTX *mem_ctx;
6901
6902         if (state->out_mem_ctx) {
6903                 mem_ctx = state->out_mem_ctx;
6904         } else {
6905                 mem_ctx = state;
6906         }
6907
6908         status = state->dispatch_recv(subreq, mem_ctx);
6909         TALLOC_FREE(subreq);
6910         if (!NT_STATUS_IS_OK(status)) {
6911                 tevent_req_nterror(req, status);
6912                 return;
6913         }
6914
6915         /* Copy out parameters */
6916
6917         /* Copy result */
6918         state->orig.out.result = state->tmp.out.result;
6919
6920         /* Reset temporary structure */
6921         ZERO_STRUCT(state->tmp);
6922
6923         if (DEBUGLEVEL >= 10) {
6924                 NDR_PRINT_OUT_DEBUG(PNP_GetFirstLogConf, &state->orig);
6925         }
6926
6927         tevent_req_done(req);
6928 }
6929
6930 NTSTATUS rpccli_PNP_GetFirstLogConf_recv(struct tevent_req *req,
6931                                          TALLOC_CTX *mem_ctx,
6932                                          WERROR *result)
6933 {
6934         struct rpccli_PNP_GetFirstLogConf_state *state = tevent_req_data(
6935                 req, struct rpccli_PNP_GetFirstLogConf_state);
6936         NTSTATUS status;
6937
6938         if (tevent_req_is_nterror(req, &status)) {
6939                 tevent_req_received(req);
6940                 return status;
6941         }
6942
6943         /* Steal possbile out parameters to the callers context */
6944         talloc_steal(mem_ctx, state->out_mem_ctx);
6945
6946         /* Return result */
6947         *result = state->orig.out.result;
6948
6949         tevent_req_received(req);
6950         return NT_STATUS_OK;
6951 }
6952
6953 NTSTATUS rpccli_PNP_GetFirstLogConf(struct rpc_pipe_client *cli,
6954                                     TALLOC_CTX *mem_ctx,
6955                                     WERROR *werror)
6956 {
6957         struct PNP_GetFirstLogConf r;
6958         NTSTATUS status;
6959
6960         /* In parameters */
6961
6962         if (DEBUGLEVEL >= 10) {
6963                 NDR_PRINT_IN_DEBUG(PNP_GetFirstLogConf, &r);
6964         }
6965
6966         status = cli->dispatch(cli,
6967                                 mem_ctx,
6968                                 &ndr_table_ntsvcs,
6969                                 NDR_PNP_GETFIRSTLOGCONF,
6970                                 &r);
6971
6972         if (!NT_STATUS_IS_OK(status)) {
6973                 return status;
6974         }
6975
6976         if (DEBUGLEVEL >= 10) {
6977                 NDR_PRINT_OUT_DEBUG(PNP_GetFirstLogConf, &r);
6978         }
6979
6980         if (NT_STATUS_IS_ERR(status)) {
6981                 return status;
6982         }
6983
6984         /* Return variables */
6985
6986         /* Return result */
6987         if (werror) {
6988                 *werror = r.out.result;
6989         }
6990
6991         return werror_to_ntstatus(r.out.result);
6992 }
6993
6994 struct rpccli_PNP_GetNextLogConf_state {
6995         struct PNP_GetNextLogConf orig;
6996         struct PNP_GetNextLogConf tmp;
6997         TALLOC_CTX *out_mem_ctx;
6998         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6999 };
7000
7001 static void rpccli_PNP_GetNextLogConf_done(struct tevent_req *subreq);
7002
7003 struct tevent_req *rpccli_PNP_GetNextLogConf_send(TALLOC_CTX *mem_ctx,
7004                                                   struct tevent_context *ev,
7005                                                   struct rpc_pipe_client *cli)
7006 {
7007         struct tevent_req *req;
7008         struct rpccli_PNP_GetNextLogConf_state *state;
7009         struct tevent_req *subreq;
7010
7011         req = tevent_req_create(mem_ctx, &state,
7012                                 struct rpccli_PNP_GetNextLogConf_state);
7013         if (req == NULL) {
7014                 return NULL;
7015         }
7016         state->out_mem_ctx = NULL;
7017         state->dispatch_recv = cli->dispatch_recv;
7018
7019         /* In parameters */
7020
7021         /* Out parameters */
7022
7023         /* Result */
7024         ZERO_STRUCT(state->orig.out.result);
7025
7026         if (DEBUGLEVEL >= 10) {
7027                 NDR_PRINT_IN_DEBUG(PNP_GetNextLogConf, &state->orig);
7028         }
7029
7030         /* make a temporary copy, that we pass to the dispatch function */
7031         state->tmp = state->orig;
7032
7033         subreq = cli->dispatch_send(state, ev, cli,
7034                                     &ndr_table_ntsvcs,
7035                                     NDR_PNP_GETNEXTLOGCONF,
7036                                     &state->tmp);
7037         if (tevent_req_nomem(subreq, req)) {
7038                 return tevent_req_post(req, ev);
7039         }
7040         tevent_req_set_callback(subreq, rpccli_PNP_GetNextLogConf_done, req);
7041         return req;
7042 }
7043
7044 static void rpccli_PNP_GetNextLogConf_done(struct tevent_req *subreq)
7045 {
7046         struct tevent_req *req = tevent_req_callback_data(
7047                 subreq, struct tevent_req);
7048         struct rpccli_PNP_GetNextLogConf_state *state = tevent_req_data(
7049                 req, struct rpccli_PNP_GetNextLogConf_state);
7050         NTSTATUS status;
7051         TALLOC_CTX *mem_ctx;
7052
7053         if (state->out_mem_ctx) {
7054                 mem_ctx = state->out_mem_ctx;
7055         } else {
7056                 mem_ctx = state;
7057         }
7058
7059         status = state->dispatch_recv(subreq, mem_ctx);
7060         TALLOC_FREE(subreq);
7061         if (!NT_STATUS_IS_OK(status)) {
7062                 tevent_req_nterror(req, status);
7063                 return;
7064         }
7065
7066         /* Copy out parameters */
7067
7068         /* Copy result */
7069         state->orig.out.result = state->tmp.out.result;
7070
7071         /* Reset temporary structure */
7072         ZERO_STRUCT(state->tmp);
7073
7074         if (DEBUGLEVEL >= 10) {
7075                 NDR_PRINT_OUT_DEBUG(PNP_GetNextLogConf, &state->orig);
7076         }
7077
7078         tevent_req_done(req);
7079 }
7080
7081 NTSTATUS rpccli_PNP_GetNextLogConf_recv(struct tevent_req *req,
7082                                         TALLOC_CTX *mem_ctx,
7083                                         WERROR *result)
7084 {
7085         struct rpccli_PNP_GetNextLogConf_state *state = tevent_req_data(
7086                 req, struct rpccli_PNP_GetNextLogConf_state);
7087         NTSTATUS status;
7088
7089         if (tevent_req_is_nterror(req, &status)) {
7090                 tevent_req_received(req);
7091                 return status;
7092         }
7093
7094         /* Steal possbile out parameters to the callers context */
7095         talloc_steal(mem_ctx, state->out_mem_ctx);
7096
7097         /* Return result */
7098         *result = state->orig.out.result;
7099
7100         tevent_req_received(req);
7101         return NT_STATUS_OK;
7102 }
7103
7104 NTSTATUS rpccli_PNP_GetNextLogConf(struct rpc_pipe_client *cli,
7105                                    TALLOC_CTX *mem_ctx,
7106                                    WERROR *werror)
7107 {
7108         struct PNP_GetNextLogConf r;
7109         NTSTATUS status;
7110
7111         /* In parameters */
7112
7113         if (DEBUGLEVEL >= 10) {
7114                 NDR_PRINT_IN_DEBUG(PNP_GetNextLogConf, &r);
7115         }
7116
7117         status = cli->dispatch(cli,
7118                                 mem_ctx,
7119                                 &ndr_table_ntsvcs,
7120                                 NDR_PNP_GETNEXTLOGCONF,
7121                                 &r);
7122
7123         if (!NT_STATUS_IS_OK(status)) {
7124                 return status;
7125         }
7126
7127         if (DEBUGLEVEL >= 10) {
7128                 NDR_PRINT_OUT_DEBUG(PNP_GetNextLogConf, &r);
7129         }
7130
7131         if (NT_STATUS_IS_ERR(status)) {
7132                 return status;
7133         }
7134
7135         /* Return variables */
7136
7137         /* Return result */
7138         if (werror) {
7139                 *werror = r.out.result;
7140         }
7141
7142         return werror_to_ntstatus(r.out.result);
7143 }
7144
7145 struct rpccli_PNP_GetLogConfPriority_state {
7146         struct PNP_GetLogConfPriority orig;
7147         struct PNP_GetLogConfPriority tmp;
7148         TALLOC_CTX *out_mem_ctx;
7149         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7150 };
7151
7152 static void rpccli_PNP_GetLogConfPriority_done(struct tevent_req *subreq);
7153
7154 struct tevent_req *rpccli_PNP_GetLogConfPriority_send(TALLOC_CTX *mem_ctx,
7155                                                       struct tevent_context *ev,
7156                                                       struct rpc_pipe_client *cli)
7157 {
7158         struct tevent_req *req;
7159         struct rpccli_PNP_GetLogConfPriority_state *state;
7160         struct tevent_req *subreq;
7161
7162         req = tevent_req_create(mem_ctx, &state,
7163                                 struct rpccli_PNP_GetLogConfPriority_state);
7164         if (req == NULL) {
7165                 return NULL;
7166         }
7167         state->out_mem_ctx = NULL;
7168         state->dispatch_recv = cli->dispatch_recv;
7169
7170         /* In parameters */
7171
7172         /* Out parameters */
7173
7174         /* Result */
7175         ZERO_STRUCT(state->orig.out.result);
7176
7177         if (DEBUGLEVEL >= 10) {
7178                 NDR_PRINT_IN_DEBUG(PNP_GetLogConfPriority, &state->orig);
7179         }
7180
7181         /* make a temporary copy, that we pass to the dispatch function */
7182         state->tmp = state->orig;
7183
7184         subreq = cli->dispatch_send(state, ev, cli,
7185                                     &ndr_table_ntsvcs,
7186                                     NDR_PNP_GETLOGCONFPRIORITY,
7187                                     &state->tmp);
7188         if (tevent_req_nomem(subreq, req)) {
7189                 return tevent_req_post(req, ev);
7190         }
7191         tevent_req_set_callback(subreq, rpccli_PNP_GetLogConfPriority_done, req);
7192         return req;
7193 }
7194
7195 static void rpccli_PNP_GetLogConfPriority_done(struct tevent_req *subreq)
7196 {
7197         struct tevent_req *req = tevent_req_callback_data(
7198                 subreq, struct tevent_req);
7199         struct rpccli_PNP_GetLogConfPriority_state *state = tevent_req_data(
7200                 req, struct rpccli_PNP_GetLogConfPriority_state);
7201         NTSTATUS status;
7202         TALLOC_CTX *mem_ctx;
7203
7204         if (state->out_mem_ctx) {
7205                 mem_ctx = state->out_mem_ctx;
7206         } else {
7207                 mem_ctx = state;
7208         }
7209
7210         status = state->dispatch_recv(subreq, mem_ctx);
7211         TALLOC_FREE(subreq);
7212         if (!NT_STATUS_IS_OK(status)) {
7213                 tevent_req_nterror(req, status);
7214                 return;
7215         }
7216
7217         /* Copy out parameters */
7218
7219         /* Copy result */
7220         state->orig.out.result = state->tmp.out.result;
7221
7222         /* Reset temporary structure */
7223         ZERO_STRUCT(state->tmp);
7224
7225         if (DEBUGLEVEL >= 10) {
7226                 NDR_PRINT_OUT_DEBUG(PNP_GetLogConfPriority, &state->orig);
7227         }
7228
7229         tevent_req_done(req);
7230 }
7231
7232 NTSTATUS rpccli_PNP_GetLogConfPriority_recv(struct tevent_req *req,
7233                                             TALLOC_CTX *mem_ctx,
7234                                             WERROR *result)
7235 {
7236         struct rpccli_PNP_GetLogConfPriority_state *state = tevent_req_data(
7237                 req, struct rpccli_PNP_GetLogConfPriority_state);
7238         NTSTATUS status;
7239
7240         if (tevent_req_is_nterror(req, &status)) {
7241                 tevent_req_received(req);
7242                 return status;
7243         }
7244
7245         /* Steal possbile out parameters to the callers context */
7246         talloc_steal(mem_ctx, state->out_mem_ctx);
7247
7248         /* Return result */
7249         *result = state->orig.out.result;
7250
7251         tevent_req_received(req);
7252         return NT_STATUS_OK;
7253 }
7254
7255 NTSTATUS rpccli_PNP_GetLogConfPriority(struct rpc_pipe_client *cli,
7256                                        TALLOC_CTX *mem_ctx,
7257                                        WERROR *werror)
7258 {
7259         struct PNP_GetLogConfPriority r;
7260         NTSTATUS status;
7261
7262         /* In parameters */
7263
7264         if (DEBUGLEVEL >= 10) {
7265                 NDR_PRINT_IN_DEBUG(PNP_GetLogConfPriority, &r);
7266         }
7267
7268         status = cli->dispatch(cli,
7269                                 mem_ctx,
7270                                 &ndr_table_ntsvcs,
7271                                 NDR_PNP_GETLOGCONFPRIORITY,
7272                                 &r);
7273
7274         if (!NT_STATUS_IS_OK(status)) {
7275                 return status;
7276         }
7277
7278         if (DEBUGLEVEL >= 10) {
7279                 NDR_PRINT_OUT_DEBUG(PNP_GetLogConfPriority, &r);
7280         }
7281
7282         if (NT_STATUS_IS_ERR(status)) {
7283                 return status;
7284         }
7285
7286         /* Return variables */
7287
7288         /* Return result */
7289         if (werror) {
7290                 *werror = r.out.result;
7291         }
7292
7293         return werror_to_ntstatus(r.out.result);
7294 }
7295
7296 struct rpccli_PNP_AddResDes_state {
7297         struct PNP_AddResDes orig;
7298         struct PNP_AddResDes tmp;
7299         TALLOC_CTX *out_mem_ctx;
7300         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7301 };
7302
7303 static void rpccli_PNP_AddResDes_done(struct tevent_req *subreq);
7304
7305 struct tevent_req *rpccli_PNP_AddResDes_send(TALLOC_CTX *mem_ctx,
7306                                              struct tevent_context *ev,
7307                                              struct rpc_pipe_client *cli)
7308 {
7309         struct tevent_req *req;
7310         struct rpccli_PNP_AddResDes_state *state;
7311         struct tevent_req *subreq;
7312
7313         req = tevent_req_create(mem_ctx, &state,
7314                                 struct rpccli_PNP_AddResDes_state);
7315         if (req == NULL) {
7316                 return NULL;
7317         }
7318         state->out_mem_ctx = NULL;
7319         state->dispatch_recv = cli->dispatch_recv;
7320
7321         /* In parameters */
7322
7323         /* Out parameters */
7324
7325         /* Result */
7326         ZERO_STRUCT(state->orig.out.result);
7327
7328         if (DEBUGLEVEL >= 10) {
7329                 NDR_PRINT_IN_DEBUG(PNP_AddResDes, &state->orig);
7330         }
7331
7332         /* make a temporary copy, that we pass to the dispatch function */
7333         state->tmp = state->orig;
7334
7335         subreq = cli->dispatch_send(state, ev, cli,
7336                                     &ndr_table_ntsvcs,
7337                                     NDR_PNP_ADDRESDES,
7338                                     &state->tmp);
7339         if (tevent_req_nomem(subreq, req)) {
7340                 return tevent_req_post(req, ev);
7341         }
7342         tevent_req_set_callback(subreq, rpccli_PNP_AddResDes_done, req);
7343         return req;
7344 }
7345
7346 static void rpccli_PNP_AddResDes_done(struct tevent_req *subreq)
7347 {
7348         struct tevent_req *req = tevent_req_callback_data(
7349                 subreq, struct tevent_req);
7350         struct rpccli_PNP_AddResDes_state *state = tevent_req_data(
7351                 req, struct rpccli_PNP_AddResDes_state);
7352         NTSTATUS status;
7353         TALLOC_CTX *mem_ctx;
7354
7355         if (state->out_mem_ctx) {
7356                 mem_ctx = state->out_mem_ctx;
7357         } else {
7358                 mem_ctx = state;
7359         }
7360
7361         status = state->dispatch_recv(subreq, mem_ctx);
7362         TALLOC_FREE(subreq);
7363         if (!NT_STATUS_IS_OK(status)) {
7364                 tevent_req_nterror(req, status);
7365                 return;
7366         }
7367
7368         /* Copy out parameters */
7369
7370         /* Copy result */
7371         state->orig.out.result = state->tmp.out.result;
7372
7373         /* Reset temporary structure */
7374         ZERO_STRUCT(state->tmp);
7375
7376         if (DEBUGLEVEL >= 10) {
7377                 NDR_PRINT_OUT_DEBUG(PNP_AddResDes, &state->orig);
7378         }
7379
7380         tevent_req_done(req);
7381 }
7382
7383 NTSTATUS rpccli_PNP_AddResDes_recv(struct tevent_req *req,
7384                                    TALLOC_CTX *mem_ctx,
7385                                    WERROR *result)
7386 {
7387         struct rpccli_PNP_AddResDes_state *state = tevent_req_data(
7388                 req, struct rpccli_PNP_AddResDes_state);
7389         NTSTATUS status;
7390
7391         if (tevent_req_is_nterror(req, &status)) {
7392                 tevent_req_received(req);
7393                 return status;
7394         }
7395
7396         /* Steal possbile out parameters to the callers context */
7397         talloc_steal(mem_ctx, state->out_mem_ctx);
7398
7399         /* Return result */
7400         *result = state->orig.out.result;
7401
7402         tevent_req_received(req);
7403         return NT_STATUS_OK;
7404 }
7405
7406 NTSTATUS rpccli_PNP_AddResDes(struct rpc_pipe_client *cli,
7407                               TALLOC_CTX *mem_ctx,
7408                               WERROR *werror)
7409 {
7410         struct PNP_AddResDes r;
7411         NTSTATUS status;
7412
7413         /* In parameters */
7414
7415         if (DEBUGLEVEL >= 10) {
7416                 NDR_PRINT_IN_DEBUG(PNP_AddResDes, &r);
7417         }
7418
7419         status = cli->dispatch(cli,
7420                                 mem_ctx,
7421                                 &ndr_table_ntsvcs,
7422                                 NDR_PNP_ADDRESDES,
7423                                 &r);
7424
7425         if (!NT_STATUS_IS_OK(status)) {
7426                 return status;
7427         }
7428
7429         if (DEBUGLEVEL >= 10) {
7430                 NDR_PRINT_OUT_DEBUG(PNP_AddResDes, &r);
7431         }
7432
7433         if (NT_STATUS_IS_ERR(status)) {
7434                 return status;
7435         }
7436
7437         /* Return variables */
7438
7439         /* Return result */
7440         if (werror) {
7441                 *werror = r.out.result;
7442         }
7443
7444         return werror_to_ntstatus(r.out.result);
7445 }
7446
7447 struct rpccli_PNP_FreeResDes_state {
7448         struct PNP_FreeResDes orig;
7449         struct PNP_FreeResDes tmp;
7450         TALLOC_CTX *out_mem_ctx;
7451         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7452 };
7453
7454 static void rpccli_PNP_FreeResDes_done(struct tevent_req *subreq);
7455
7456 struct tevent_req *rpccli_PNP_FreeResDes_send(TALLOC_CTX *mem_ctx,
7457                                               struct tevent_context *ev,
7458                                               struct rpc_pipe_client *cli)
7459 {
7460         struct tevent_req *req;
7461         struct rpccli_PNP_FreeResDes_state *state;
7462         struct tevent_req *subreq;
7463
7464         req = tevent_req_create(mem_ctx, &state,
7465                                 struct rpccli_PNP_FreeResDes_state);
7466         if (req == NULL) {
7467                 return NULL;
7468         }
7469         state->out_mem_ctx = NULL;
7470         state->dispatch_recv = cli->dispatch_recv;
7471
7472         /* In parameters */
7473
7474         /* Out parameters */
7475
7476         /* Result */
7477         ZERO_STRUCT(state->orig.out.result);
7478
7479         if (DEBUGLEVEL >= 10) {
7480                 NDR_PRINT_IN_DEBUG(PNP_FreeResDes, &state->orig);
7481         }
7482
7483         /* make a temporary copy, that we pass to the dispatch function */
7484         state->tmp = state->orig;
7485
7486         subreq = cli->dispatch_send(state, ev, cli,
7487                                     &ndr_table_ntsvcs,
7488                                     NDR_PNP_FREERESDES,
7489                                     &state->tmp);
7490         if (tevent_req_nomem(subreq, req)) {
7491                 return tevent_req_post(req, ev);
7492         }
7493         tevent_req_set_callback(subreq, rpccli_PNP_FreeResDes_done, req);
7494         return req;
7495 }
7496
7497 static void rpccli_PNP_FreeResDes_done(struct tevent_req *subreq)
7498 {
7499         struct tevent_req *req = tevent_req_callback_data(
7500                 subreq, struct tevent_req);
7501         struct rpccli_PNP_FreeResDes_state *state = tevent_req_data(
7502                 req, struct rpccli_PNP_FreeResDes_state);
7503         NTSTATUS status;
7504         TALLOC_CTX *mem_ctx;
7505
7506         if (state->out_mem_ctx) {
7507                 mem_ctx = state->out_mem_ctx;
7508         } else {
7509                 mem_ctx = state;
7510         }
7511
7512         status = state->dispatch_recv(subreq, mem_ctx);
7513         TALLOC_FREE(subreq);
7514         if (!NT_STATUS_IS_OK(status)) {
7515                 tevent_req_nterror(req, status);
7516                 return;
7517         }
7518
7519         /* Copy out parameters */
7520
7521         /* Copy result */
7522         state->orig.out.result = state->tmp.out.result;
7523
7524         /* Reset temporary structure */
7525         ZERO_STRUCT(state->tmp);
7526
7527         if (DEBUGLEVEL >= 10) {
7528                 NDR_PRINT_OUT_DEBUG(PNP_FreeResDes, &state->orig);
7529         }
7530
7531         tevent_req_done(req);
7532 }
7533
7534 NTSTATUS rpccli_PNP_FreeResDes_recv(struct tevent_req *req,
7535                                     TALLOC_CTX *mem_ctx,
7536                                     WERROR *result)
7537 {
7538         struct rpccli_PNP_FreeResDes_state *state = tevent_req_data(
7539                 req, struct rpccli_PNP_FreeResDes_state);
7540         NTSTATUS status;
7541
7542         if (tevent_req_is_nterror(req, &status)) {
7543                 tevent_req_received(req);
7544                 return status;
7545         }
7546
7547         /* Steal possbile out parameters to the callers context */
7548         talloc_steal(mem_ctx, state->out_mem_ctx);
7549
7550         /* Return result */
7551         *result = state->orig.out.result;
7552
7553         tevent_req_received(req);
7554         return NT_STATUS_OK;
7555 }
7556
7557 NTSTATUS rpccli_PNP_FreeResDes(struct rpc_pipe_client *cli,
7558                                TALLOC_CTX *mem_ctx,
7559                                WERROR *werror)
7560 {
7561         struct PNP_FreeResDes r;
7562         NTSTATUS status;
7563
7564         /* In parameters */
7565
7566         if (DEBUGLEVEL >= 10) {
7567                 NDR_PRINT_IN_DEBUG(PNP_FreeResDes, &r);
7568         }
7569
7570         status = cli->dispatch(cli,
7571                                 mem_ctx,
7572                                 &ndr_table_ntsvcs,
7573                                 NDR_PNP_FREERESDES,
7574                                 &r);
7575
7576         if (!NT_STATUS_IS_OK(status)) {
7577                 return status;
7578         }
7579
7580         if (DEBUGLEVEL >= 10) {
7581                 NDR_PRINT_OUT_DEBUG(PNP_FreeResDes, &r);
7582         }
7583
7584         if (NT_STATUS_IS_ERR(status)) {
7585                 return status;
7586         }
7587
7588         /* Return variables */
7589
7590         /* Return result */
7591         if (werror) {
7592                 *werror = r.out.result;
7593         }
7594
7595         return werror_to_ntstatus(r.out.result);
7596 }
7597
7598 struct rpccli_PNP_GetNextResDes_state {
7599         struct PNP_GetNextResDes orig;
7600         struct PNP_GetNextResDes tmp;
7601         TALLOC_CTX *out_mem_ctx;
7602         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7603 };
7604
7605 static void rpccli_PNP_GetNextResDes_done(struct tevent_req *subreq);
7606
7607 struct tevent_req *rpccli_PNP_GetNextResDes_send(TALLOC_CTX *mem_ctx,
7608                                                  struct tevent_context *ev,
7609                                                  struct rpc_pipe_client *cli)
7610 {
7611         struct tevent_req *req;
7612         struct rpccli_PNP_GetNextResDes_state *state;
7613         struct tevent_req *subreq;
7614
7615         req = tevent_req_create(mem_ctx, &state,
7616                                 struct rpccli_PNP_GetNextResDes_state);
7617         if (req == NULL) {
7618                 return NULL;
7619         }
7620         state->out_mem_ctx = NULL;
7621         state->dispatch_recv = cli->dispatch_recv;
7622
7623         /* In parameters */
7624
7625         /* Out parameters */
7626
7627         /* Result */
7628         ZERO_STRUCT(state->orig.out.result);
7629
7630         if (DEBUGLEVEL >= 10) {
7631                 NDR_PRINT_IN_DEBUG(PNP_GetNextResDes, &state->orig);
7632         }
7633
7634         /* make a temporary copy, that we pass to the dispatch function */
7635         state->tmp = state->orig;
7636
7637         subreq = cli->dispatch_send(state, ev, cli,
7638                                     &ndr_table_ntsvcs,
7639                                     NDR_PNP_GETNEXTRESDES,
7640                                     &state->tmp);
7641         if (tevent_req_nomem(subreq, req)) {
7642                 return tevent_req_post(req, ev);
7643         }
7644         tevent_req_set_callback(subreq, rpccli_PNP_GetNextResDes_done, req);
7645         return req;
7646 }
7647
7648 static void rpccli_PNP_GetNextResDes_done(struct tevent_req *subreq)
7649 {
7650         struct tevent_req *req = tevent_req_callback_data(
7651                 subreq, struct tevent_req);
7652         struct rpccli_PNP_GetNextResDes_state *state = tevent_req_data(
7653                 req, struct rpccli_PNP_GetNextResDes_state);
7654         NTSTATUS status;
7655         TALLOC_CTX *mem_ctx;
7656
7657         if (state->out_mem_ctx) {
7658                 mem_ctx = state->out_mem_ctx;
7659         } else {
7660                 mem_ctx = state;
7661         }
7662
7663         status = state->dispatch_recv(subreq, mem_ctx);
7664         TALLOC_FREE(subreq);
7665         if (!NT_STATUS_IS_OK(status)) {
7666                 tevent_req_nterror(req, status);
7667                 return;
7668         }
7669
7670         /* Copy out parameters */
7671
7672         /* Copy result */
7673         state->orig.out.result = state->tmp.out.result;
7674
7675         /* Reset temporary structure */
7676         ZERO_STRUCT(state->tmp);
7677
7678         if (DEBUGLEVEL >= 10) {
7679                 NDR_PRINT_OUT_DEBUG(PNP_GetNextResDes, &state->orig);
7680         }
7681
7682         tevent_req_done(req);
7683 }
7684
7685 NTSTATUS rpccli_PNP_GetNextResDes_recv(struct tevent_req *req,
7686                                        TALLOC_CTX *mem_ctx,
7687                                        WERROR *result)
7688 {
7689         struct rpccli_PNP_GetNextResDes_state *state = tevent_req_data(
7690                 req, struct rpccli_PNP_GetNextResDes_state);
7691         NTSTATUS status;
7692
7693         if (tevent_req_is_nterror(req, &status)) {
7694                 tevent_req_received(req);
7695                 return status;
7696         }
7697
7698         /* Steal possbile out parameters to the callers context */
7699         talloc_steal(mem_ctx, state->out_mem_ctx);
7700
7701         /* Return result */
7702         *result = state->orig.out.result;
7703
7704         tevent_req_received(req);
7705         return NT_STATUS_OK;
7706 }
7707
7708 NTSTATUS rpccli_PNP_GetNextResDes(struct rpc_pipe_client *cli,
7709                                   TALLOC_CTX *mem_ctx,
7710                                   WERROR *werror)
7711 {
7712         struct PNP_GetNextResDes r;
7713         NTSTATUS status;
7714
7715         /* In parameters */
7716
7717         if (DEBUGLEVEL >= 10) {
7718                 NDR_PRINT_IN_DEBUG(PNP_GetNextResDes, &r);
7719         }
7720
7721         status = cli->dispatch(cli,
7722                                 mem_ctx,
7723                                 &ndr_table_ntsvcs,
7724                                 NDR_PNP_GETNEXTRESDES,
7725                                 &r);
7726
7727         if (!NT_STATUS_IS_OK(status)) {
7728                 return status;
7729         }
7730
7731         if (DEBUGLEVEL >= 10) {
7732                 NDR_PRINT_OUT_DEBUG(PNP_GetNextResDes, &r);
7733         }
7734
7735         if (NT_STATUS_IS_ERR(status)) {
7736                 return status;
7737         }
7738
7739         /* Return variables */
7740
7741         /* Return result */
7742         if (werror) {
7743                 *werror = r.out.result;
7744         }
7745
7746         return werror_to_ntstatus(r.out.result);
7747 }
7748
7749 struct rpccli_PNP_GetResDesData_state {
7750         struct PNP_GetResDesData orig;
7751         struct PNP_GetResDesData tmp;
7752         TALLOC_CTX *out_mem_ctx;
7753         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7754 };
7755
7756 static void rpccli_PNP_GetResDesData_done(struct tevent_req *subreq);
7757
7758 struct tevent_req *rpccli_PNP_GetResDesData_send(TALLOC_CTX *mem_ctx,
7759                                                  struct tevent_context *ev,
7760                                                  struct rpc_pipe_client *cli)
7761 {
7762         struct tevent_req *req;
7763         struct rpccli_PNP_GetResDesData_state *state;
7764         struct tevent_req *subreq;
7765
7766         req = tevent_req_create(mem_ctx, &state,
7767                                 struct rpccli_PNP_GetResDesData_state);
7768         if (req == NULL) {
7769                 return NULL;
7770         }
7771         state->out_mem_ctx = NULL;
7772         state->dispatch_recv = cli->dispatch_recv;
7773
7774         /* In parameters */
7775
7776         /* Out parameters */
7777
7778         /* Result */
7779         ZERO_STRUCT(state->orig.out.result);
7780
7781         if (DEBUGLEVEL >= 10) {
7782                 NDR_PRINT_IN_DEBUG(PNP_GetResDesData, &state->orig);
7783         }
7784
7785         /* make a temporary copy, that we pass to the dispatch function */
7786         state->tmp = state->orig;
7787
7788         subreq = cli->dispatch_send(state, ev, cli,
7789                                     &ndr_table_ntsvcs,
7790                                     NDR_PNP_GETRESDESDATA,
7791                                     &state->tmp);
7792         if (tevent_req_nomem(subreq, req)) {
7793                 return tevent_req_post(req, ev);
7794         }
7795         tevent_req_set_callback(subreq, rpccli_PNP_GetResDesData_done, req);
7796         return req;
7797 }
7798
7799 static void rpccli_PNP_GetResDesData_done(struct tevent_req *subreq)
7800 {
7801         struct tevent_req *req = tevent_req_callback_data(
7802                 subreq, struct tevent_req);
7803         struct rpccli_PNP_GetResDesData_state *state = tevent_req_data(
7804                 req, struct rpccli_PNP_GetResDesData_state);
7805         NTSTATUS status;
7806         TALLOC_CTX *mem_ctx;
7807
7808         if (state->out_mem_ctx) {
7809                 mem_ctx = state->out_mem_ctx;
7810         } else {
7811                 mem_ctx = state;
7812         }
7813
7814         status = state->dispatch_recv(subreq, mem_ctx);
7815         TALLOC_FREE(subreq);
7816         if (!NT_STATUS_IS_OK(status)) {
7817                 tevent_req_nterror(req, status);
7818                 return;
7819         }
7820
7821         /* Copy out parameters */
7822
7823         /* Copy result */
7824         state->orig.out.result = state->tmp.out.result;
7825
7826         /* Reset temporary structure */
7827         ZERO_STRUCT(state->tmp);
7828
7829         if (DEBUGLEVEL >= 10) {
7830                 NDR_PRINT_OUT_DEBUG(PNP_GetResDesData, &state->orig);
7831         }
7832
7833         tevent_req_done(req);
7834 }
7835
7836 NTSTATUS rpccli_PNP_GetResDesData_recv(struct tevent_req *req,
7837                                        TALLOC_CTX *mem_ctx,
7838                                        WERROR *result)
7839 {
7840         struct rpccli_PNP_GetResDesData_state *state = tevent_req_data(
7841                 req, struct rpccli_PNP_GetResDesData_state);
7842         NTSTATUS status;
7843
7844         if (tevent_req_is_nterror(req, &status)) {
7845                 tevent_req_received(req);
7846                 return status;
7847         }
7848
7849         /* Steal possbile out parameters to the callers context */
7850         talloc_steal(mem_ctx, state->out_mem_ctx);
7851
7852         /* Return result */
7853         *result = state->orig.out.result;
7854
7855         tevent_req_received(req);
7856         return NT_STATUS_OK;
7857 }
7858
7859 NTSTATUS rpccli_PNP_GetResDesData(struct rpc_pipe_client *cli,
7860                                   TALLOC_CTX *mem_ctx,
7861                                   WERROR *werror)
7862 {
7863         struct PNP_GetResDesData r;
7864         NTSTATUS status;
7865
7866         /* In parameters */
7867
7868         if (DEBUGLEVEL >= 10) {
7869                 NDR_PRINT_IN_DEBUG(PNP_GetResDesData, &r);
7870         }
7871
7872         status = cli->dispatch(cli,
7873                                 mem_ctx,
7874                                 &ndr_table_ntsvcs,
7875                                 NDR_PNP_GETRESDESDATA,
7876                                 &r);
7877
7878         if (!NT_STATUS_IS_OK(status)) {
7879                 return status;
7880         }
7881
7882         if (DEBUGLEVEL >= 10) {
7883                 NDR_PRINT_OUT_DEBUG(PNP_GetResDesData, &r);
7884         }
7885
7886         if (NT_STATUS_IS_ERR(status)) {
7887                 return status;
7888         }
7889
7890         /* Return variables */
7891
7892         /* Return result */
7893         if (werror) {
7894                 *werror = r.out.result;
7895         }
7896
7897         return werror_to_ntstatus(r.out.result);
7898 }
7899
7900 struct rpccli_PNP_GetResDesDataSize_state {
7901         struct PNP_GetResDesDataSize orig;
7902         struct PNP_GetResDesDataSize tmp;
7903         TALLOC_CTX *out_mem_ctx;
7904         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7905 };
7906
7907 static void rpccli_PNP_GetResDesDataSize_done(struct tevent_req *subreq);
7908
7909 struct tevent_req *rpccli_PNP_GetResDesDataSize_send(TALLOC_CTX *mem_ctx,
7910                                                      struct tevent_context *ev,
7911                                                      struct rpc_pipe_client *cli)
7912 {
7913         struct tevent_req *req;
7914         struct rpccli_PNP_GetResDesDataSize_state *state;
7915         struct tevent_req *subreq;
7916
7917         req = tevent_req_create(mem_ctx, &state,
7918                                 struct rpccli_PNP_GetResDesDataSize_state);
7919         if (req == NULL) {
7920                 return NULL;
7921         }
7922         state->out_mem_ctx = NULL;
7923         state->dispatch_recv = cli->dispatch_recv;
7924
7925         /* In parameters */
7926
7927         /* Out parameters */
7928
7929         /* Result */
7930         ZERO_STRUCT(state->orig.out.result);
7931
7932         if (DEBUGLEVEL >= 10) {
7933                 NDR_PRINT_IN_DEBUG(PNP_GetResDesDataSize, &state->orig);
7934         }
7935
7936         /* make a temporary copy, that we pass to the dispatch function */
7937         state->tmp = state->orig;
7938
7939         subreq = cli->dispatch_send(state, ev, cli,
7940                                     &ndr_table_ntsvcs,
7941                                     NDR_PNP_GETRESDESDATASIZE,
7942                                     &state->tmp);
7943         if (tevent_req_nomem(subreq, req)) {
7944                 return tevent_req_post(req, ev);
7945         }
7946         tevent_req_set_callback(subreq, rpccli_PNP_GetResDesDataSize_done, req);
7947         return req;
7948 }
7949
7950 static void rpccli_PNP_GetResDesDataSize_done(struct tevent_req *subreq)
7951 {
7952         struct tevent_req *req = tevent_req_callback_data(
7953                 subreq, struct tevent_req);
7954         struct rpccli_PNP_GetResDesDataSize_state *state = tevent_req_data(
7955                 req, struct rpccli_PNP_GetResDesDataSize_state);
7956         NTSTATUS status;
7957         TALLOC_CTX *mem_ctx;
7958
7959         if (state->out_mem_ctx) {
7960                 mem_ctx = state->out_mem_ctx;
7961         } else {
7962                 mem_ctx = state;
7963         }
7964
7965         status = state->dispatch_recv(subreq, mem_ctx);
7966         TALLOC_FREE(subreq);
7967         if (!NT_STATUS_IS_OK(status)) {
7968                 tevent_req_nterror(req, status);
7969                 return;
7970         }
7971
7972         /* Copy out parameters */
7973
7974         /* Copy result */
7975         state->orig.out.result = state->tmp.out.result;
7976
7977         /* Reset temporary structure */
7978         ZERO_STRUCT(state->tmp);
7979
7980         if (DEBUGLEVEL >= 10) {
7981                 NDR_PRINT_OUT_DEBUG(PNP_GetResDesDataSize, &state->orig);
7982         }
7983
7984         tevent_req_done(req);
7985 }
7986
7987 NTSTATUS rpccli_PNP_GetResDesDataSize_recv(struct tevent_req *req,
7988                                            TALLOC_CTX *mem_ctx,
7989                                            WERROR *result)
7990 {
7991         struct rpccli_PNP_GetResDesDataSize_state *state = tevent_req_data(
7992                 req, struct rpccli_PNP_GetResDesDataSize_state);
7993         NTSTATUS status;
7994
7995         if (tevent_req_is_nterror(req, &status)) {
7996                 tevent_req_received(req);
7997                 return status;
7998         }
7999
8000         /* Steal possbile out parameters to the callers context */
8001         talloc_steal(mem_ctx, state->out_mem_ctx);
8002
8003         /* Return result */
8004         *result = state->orig.out.result;
8005
8006         tevent_req_received(req);
8007         return NT_STATUS_OK;
8008 }
8009
8010 NTSTATUS rpccli_PNP_GetResDesDataSize(struct rpc_pipe_client *cli,
8011                                       TALLOC_CTX *mem_ctx,
8012                                       WERROR *werror)
8013 {
8014         struct PNP_GetResDesDataSize r;
8015         NTSTATUS status;
8016
8017         /* In parameters */
8018
8019         if (DEBUGLEVEL >= 10) {
8020                 NDR_PRINT_IN_DEBUG(PNP_GetResDesDataSize, &r);
8021         }
8022
8023         status = cli->dispatch(cli,
8024                                 mem_ctx,
8025                                 &ndr_table_ntsvcs,
8026                                 NDR_PNP_GETRESDESDATASIZE,
8027                                 &r);
8028
8029         if (!NT_STATUS_IS_OK(status)) {
8030                 return status;
8031         }
8032
8033         if (DEBUGLEVEL >= 10) {
8034                 NDR_PRINT_OUT_DEBUG(PNP_GetResDesDataSize, &r);
8035         }
8036
8037         if (NT_STATUS_IS_ERR(status)) {
8038                 return status;
8039         }
8040
8041         /* Return variables */
8042
8043         /* Return result */
8044         if (werror) {
8045                 *werror = r.out.result;
8046         }
8047
8048         return werror_to_ntstatus(r.out.result);
8049 }
8050
8051 struct rpccli_PNP_ModifyResDes_state {
8052         struct PNP_ModifyResDes orig;
8053         struct PNP_ModifyResDes tmp;
8054         TALLOC_CTX *out_mem_ctx;
8055         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8056 };
8057
8058 static void rpccli_PNP_ModifyResDes_done(struct tevent_req *subreq);
8059
8060 struct tevent_req *rpccli_PNP_ModifyResDes_send(TALLOC_CTX *mem_ctx,
8061                                                 struct tevent_context *ev,
8062                                                 struct rpc_pipe_client *cli)
8063 {
8064         struct tevent_req *req;
8065         struct rpccli_PNP_ModifyResDes_state *state;
8066         struct tevent_req *subreq;
8067
8068         req = tevent_req_create(mem_ctx, &state,
8069                                 struct rpccli_PNP_ModifyResDes_state);
8070         if (req == NULL) {
8071                 return NULL;
8072         }
8073         state->out_mem_ctx = NULL;
8074         state->dispatch_recv = cli->dispatch_recv;
8075
8076         /* In parameters */
8077
8078         /* Out parameters */
8079
8080         /* Result */
8081         ZERO_STRUCT(state->orig.out.result);
8082
8083         if (DEBUGLEVEL >= 10) {
8084                 NDR_PRINT_IN_DEBUG(PNP_ModifyResDes, &state->orig);
8085         }
8086
8087         /* make a temporary copy, that we pass to the dispatch function */
8088         state->tmp = state->orig;
8089
8090         subreq = cli->dispatch_send(state, ev, cli,
8091                                     &ndr_table_ntsvcs,
8092                                     NDR_PNP_MODIFYRESDES,
8093                                     &state->tmp);
8094         if (tevent_req_nomem(subreq, req)) {
8095                 return tevent_req_post(req, ev);
8096         }
8097         tevent_req_set_callback(subreq, rpccli_PNP_ModifyResDes_done, req);
8098         return req;
8099 }
8100
8101 static void rpccli_PNP_ModifyResDes_done(struct tevent_req *subreq)
8102 {
8103         struct tevent_req *req = tevent_req_callback_data(
8104                 subreq, struct tevent_req);
8105         struct rpccli_PNP_ModifyResDes_state *state = tevent_req_data(
8106                 req, struct rpccli_PNP_ModifyResDes_state);
8107         NTSTATUS status;
8108         TALLOC_CTX *mem_ctx;
8109
8110         if (state->out_mem_ctx) {
8111                 mem_ctx = state->out_mem_ctx;
8112         } else {
8113                 mem_ctx = state;
8114         }
8115
8116         status = state->dispatch_recv(subreq, mem_ctx);
8117         TALLOC_FREE(subreq);
8118         if (!NT_STATUS_IS_OK(status)) {
8119                 tevent_req_nterror(req, status);
8120                 return;
8121         }
8122
8123         /* Copy out parameters */
8124
8125         /* Copy result */
8126         state->orig.out.result = state->tmp.out.result;
8127
8128         /* Reset temporary structure */
8129         ZERO_STRUCT(state->tmp);
8130
8131         if (DEBUGLEVEL >= 10) {
8132                 NDR_PRINT_OUT_DEBUG(PNP_ModifyResDes, &state->orig);
8133         }
8134
8135         tevent_req_done(req);
8136 }
8137
8138 NTSTATUS rpccli_PNP_ModifyResDes_recv(struct tevent_req *req,
8139                                       TALLOC_CTX *mem_ctx,
8140                                       WERROR *result)
8141 {
8142         struct rpccli_PNP_ModifyResDes_state *state = tevent_req_data(
8143                 req, struct rpccli_PNP_ModifyResDes_state);
8144         NTSTATUS status;
8145
8146         if (tevent_req_is_nterror(req, &status)) {
8147                 tevent_req_received(req);
8148                 return status;
8149         }
8150
8151         /* Steal possbile out parameters to the callers context */
8152         talloc_steal(mem_ctx, state->out_mem_ctx);
8153
8154         /* Return result */
8155         *result = state->orig.out.result;
8156
8157         tevent_req_received(req);
8158         return NT_STATUS_OK;
8159 }
8160
8161 NTSTATUS rpccli_PNP_ModifyResDes(struct rpc_pipe_client *cli,
8162                                  TALLOC_CTX *mem_ctx,
8163                                  WERROR *werror)
8164 {
8165         struct PNP_ModifyResDes r;
8166         NTSTATUS status;
8167
8168         /* In parameters */
8169
8170         if (DEBUGLEVEL >= 10) {
8171                 NDR_PRINT_IN_DEBUG(PNP_ModifyResDes, &r);
8172         }
8173
8174         status = cli->dispatch(cli,
8175                                 mem_ctx,
8176                                 &ndr_table_ntsvcs,
8177                                 NDR_PNP_MODIFYRESDES,
8178                                 &r);
8179
8180         if (!NT_STATUS_IS_OK(status)) {
8181                 return status;
8182         }
8183
8184         if (DEBUGLEVEL >= 10) {
8185                 NDR_PRINT_OUT_DEBUG(PNP_ModifyResDes, &r);
8186         }
8187
8188         if (NT_STATUS_IS_ERR(status)) {
8189                 return status;
8190         }
8191
8192         /* Return variables */
8193
8194         /* Return result */
8195         if (werror) {
8196                 *werror = r.out.result;
8197         }
8198
8199         return werror_to_ntstatus(r.out.result);
8200 }
8201
8202 struct rpccli_PNP_DetectResourceLimit_state {
8203         struct PNP_DetectResourceLimit orig;
8204         struct PNP_DetectResourceLimit tmp;
8205         TALLOC_CTX *out_mem_ctx;
8206         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8207 };
8208
8209 static void rpccli_PNP_DetectResourceLimit_done(struct tevent_req *subreq);
8210
8211 struct tevent_req *rpccli_PNP_DetectResourceLimit_send(TALLOC_CTX *mem_ctx,
8212                                                        struct tevent_context *ev,
8213                                                        struct rpc_pipe_client *cli)
8214 {
8215         struct tevent_req *req;
8216         struct rpccli_PNP_DetectResourceLimit_state *state;
8217         struct tevent_req *subreq;
8218
8219         req = tevent_req_create(mem_ctx, &state,
8220                                 struct rpccli_PNP_DetectResourceLimit_state);
8221         if (req == NULL) {
8222                 return NULL;
8223         }
8224         state->out_mem_ctx = NULL;
8225         state->dispatch_recv = cli->dispatch_recv;
8226
8227         /* In parameters */
8228
8229         /* Out parameters */
8230
8231         /* Result */
8232         ZERO_STRUCT(state->orig.out.result);
8233
8234         if (DEBUGLEVEL >= 10) {
8235                 NDR_PRINT_IN_DEBUG(PNP_DetectResourceLimit, &state->orig);
8236         }
8237
8238         /* make a temporary copy, that we pass to the dispatch function */
8239         state->tmp = state->orig;
8240
8241         subreq = cli->dispatch_send(state, ev, cli,
8242                                     &ndr_table_ntsvcs,
8243                                     NDR_PNP_DETECTRESOURCELIMIT,
8244                                     &state->tmp);
8245         if (tevent_req_nomem(subreq, req)) {
8246                 return tevent_req_post(req, ev);
8247         }
8248         tevent_req_set_callback(subreq, rpccli_PNP_DetectResourceLimit_done, req);
8249         return req;
8250 }
8251
8252 static void rpccli_PNP_DetectResourceLimit_done(struct tevent_req *subreq)
8253 {
8254         struct tevent_req *req = tevent_req_callback_data(
8255                 subreq, struct tevent_req);
8256         struct rpccli_PNP_DetectResourceLimit_state *state = tevent_req_data(
8257                 req, struct rpccli_PNP_DetectResourceLimit_state);
8258         NTSTATUS status;
8259         TALLOC_CTX *mem_ctx;
8260
8261         if (state->out_mem_ctx) {
8262                 mem_ctx = state->out_mem_ctx;
8263         } else {
8264                 mem_ctx = state;
8265         }
8266
8267         status = state->dispatch_recv(subreq, mem_ctx);
8268         TALLOC_FREE(subreq);
8269         if (!NT_STATUS_IS_OK(status)) {
8270                 tevent_req_nterror(req, status);
8271                 return;
8272         }
8273
8274         /* Copy out parameters */
8275
8276         /* Copy result */
8277         state->orig.out.result = state->tmp.out.result;
8278
8279         /* Reset temporary structure */
8280         ZERO_STRUCT(state->tmp);
8281
8282         if (DEBUGLEVEL >= 10) {
8283                 NDR_PRINT_OUT_DEBUG(PNP_DetectResourceLimit, &state->orig);
8284         }
8285
8286         tevent_req_done(req);
8287 }
8288
8289 NTSTATUS rpccli_PNP_DetectResourceLimit_recv(struct tevent_req *req,
8290                                              TALLOC_CTX *mem_ctx,
8291                                              WERROR *result)
8292 {
8293         struct rpccli_PNP_DetectResourceLimit_state *state = tevent_req_data(
8294                 req, struct rpccli_PNP_DetectResourceLimit_state);
8295         NTSTATUS status;
8296
8297         if (tevent_req_is_nterror(req, &status)) {
8298                 tevent_req_received(req);
8299                 return status;
8300         }
8301
8302         /* Steal possbile out parameters to the callers context */
8303         talloc_steal(mem_ctx, state->out_mem_ctx);
8304
8305         /* Return result */
8306         *result = state->orig.out.result;
8307
8308         tevent_req_received(req);
8309         return NT_STATUS_OK;
8310 }
8311
8312 NTSTATUS rpccli_PNP_DetectResourceLimit(struct rpc_pipe_client *cli,
8313                                         TALLOC_CTX *mem_ctx,
8314                                         WERROR *werror)
8315 {
8316         struct PNP_DetectResourceLimit r;
8317         NTSTATUS status;
8318
8319         /* In parameters */
8320
8321         if (DEBUGLEVEL >= 10) {
8322                 NDR_PRINT_IN_DEBUG(PNP_DetectResourceLimit, &r);
8323         }
8324
8325         status = cli->dispatch(cli,
8326                                 mem_ctx,
8327                                 &ndr_table_ntsvcs,
8328                                 NDR_PNP_DETECTRESOURCELIMIT,
8329                                 &r);
8330
8331         if (!NT_STATUS_IS_OK(status)) {
8332                 return status;
8333         }
8334
8335         if (DEBUGLEVEL >= 10) {
8336                 NDR_PRINT_OUT_DEBUG(PNP_DetectResourceLimit, &r);
8337         }
8338
8339         if (NT_STATUS_IS_ERR(status)) {
8340                 return status;
8341         }
8342
8343         /* Return variables */
8344
8345         /* Return result */
8346         if (werror) {
8347                 *werror = r.out.result;
8348         }
8349
8350         return werror_to_ntstatus(r.out.result);
8351 }
8352
8353 struct rpccli_PNP_QueryResConfList_state {
8354         struct PNP_QueryResConfList orig;
8355         struct PNP_QueryResConfList tmp;
8356         TALLOC_CTX *out_mem_ctx;
8357         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8358 };
8359
8360 static void rpccli_PNP_QueryResConfList_done(struct tevent_req *subreq);
8361
8362 struct tevent_req *rpccli_PNP_QueryResConfList_send(TALLOC_CTX *mem_ctx,
8363                                                     struct tevent_context *ev,
8364                                                     struct rpc_pipe_client *cli)
8365 {
8366         struct tevent_req *req;
8367         struct rpccli_PNP_QueryResConfList_state *state;
8368         struct tevent_req *subreq;
8369
8370         req = tevent_req_create(mem_ctx, &state,
8371                                 struct rpccli_PNP_QueryResConfList_state);
8372         if (req == NULL) {
8373                 return NULL;
8374         }
8375         state->out_mem_ctx = NULL;
8376         state->dispatch_recv = cli->dispatch_recv;
8377
8378         /* In parameters */
8379
8380         /* Out parameters */
8381
8382         /* Result */
8383         ZERO_STRUCT(state->orig.out.result);
8384
8385         if (DEBUGLEVEL >= 10) {
8386                 NDR_PRINT_IN_DEBUG(PNP_QueryResConfList, &state->orig);
8387         }
8388
8389         /* make a temporary copy, that we pass to the dispatch function */
8390         state->tmp = state->orig;
8391
8392         subreq = cli->dispatch_send(state, ev, cli,
8393                                     &ndr_table_ntsvcs,
8394                                     NDR_PNP_QUERYRESCONFLIST,
8395                                     &state->tmp);
8396         if (tevent_req_nomem(subreq, req)) {
8397                 return tevent_req_post(req, ev);
8398         }
8399         tevent_req_set_callback(subreq, rpccli_PNP_QueryResConfList_done, req);
8400         return req;
8401 }
8402
8403 static void rpccli_PNP_QueryResConfList_done(struct tevent_req *subreq)
8404 {
8405         struct tevent_req *req = tevent_req_callback_data(
8406                 subreq, struct tevent_req);
8407         struct rpccli_PNP_QueryResConfList_state *state = tevent_req_data(
8408                 req, struct rpccli_PNP_QueryResConfList_state);
8409         NTSTATUS status;
8410         TALLOC_CTX *mem_ctx;
8411
8412         if (state->out_mem_ctx) {
8413                 mem_ctx = state->out_mem_ctx;
8414         } else {
8415                 mem_ctx = state;
8416         }
8417
8418         status = state->dispatch_recv(subreq, mem_ctx);
8419         TALLOC_FREE(subreq);
8420         if (!NT_STATUS_IS_OK(status)) {
8421                 tevent_req_nterror(req, status);
8422                 return;
8423         }
8424
8425         /* Copy out parameters */
8426
8427         /* Copy result */
8428         state->orig.out.result = state->tmp.out.result;
8429
8430         /* Reset temporary structure */
8431         ZERO_STRUCT(state->tmp);
8432
8433         if (DEBUGLEVEL >= 10) {
8434                 NDR_PRINT_OUT_DEBUG(PNP_QueryResConfList, &state->orig);
8435         }
8436
8437         tevent_req_done(req);
8438 }
8439
8440 NTSTATUS rpccli_PNP_QueryResConfList_recv(struct tevent_req *req,
8441                                           TALLOC_CTX *mem_ctx,
8442                                           WERROR *result)
8443 {
8444         struct rpccli_PNP_QueryResConfList_state *state = tevent_req_data(
8445                 req, struct rpccli_PNP_QueryResConfList_state);
8446         NTSTATUS status;
8447
8448         if (tevent_req_is_nterror(req, &status)) {
8449                 tevent_req_received(req);
8450                 return status;
8451         }
8452
8453         /* Steal possbile out parameters to the callers context */
8454         talloc_steal(mem_ctx, state->out_mem_ctx);
8455
8456         /* Return result */
8457         *result = state->orig.out.result;
8458
8459         tevent_req_received(req);
8460         return NT_STATUS_OK;
8461 }
8462
8463 NTSTATUS rpccli_PNP_QueryResConfList(struct rpc_pipe_client *cli,
8464                                      TALLOC_CTX *mem_ctx,
8465                                      WERROR *werror)
8466 {
8467         struct PNP_QueryResConfList r;
8468         NTSTATUS status;
8469
8470         /* In parameters */
8471
8472         if (DEBUGLEVEL >= 10) {
8473                 NDR_PRINT_IN_DEBUG(PNP_QueryResConfList, &r);
8474         }
8475
8476         status = cli->dispatch(cli,
8477                                 mem_ctx,
8478                                 &ndr_table_ntsvcs,
8479                                 NDR_PNP_QUERYRESCONFLIST,
8480                                 &r);
8481
8482         if (!NT_STATUS_IS_OK(status)) {
8483                 return status;
8484         }
8485
8486         if (DEBUGLEVEL >= 10) {
8487                 NDR_PRINT_OUT_DEBUG(PNP_QueryResConfList, &r);
8488         }
8489
8490         if (NT_STATUS_IS_ERR(status)) {
8491                 return status;
8492         }
8493
8494         /* Return variables */
8495
8496         /* Return result */
8497         if (werror) {
8498                 *werror = r.out.result;
8499         }
8500
8501         return werror_to_ntstatus(r.out.result);
8502 }
8503
8504 struct rpccli_PNP_SetHwProf_state {
8505         struct PNP_SetHwProf orig;
8506         struct PNP_SetHwProf tmp;
8507         TALLOC_CTX *out_mem_ctx;
8508         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8509 };
8510
8511 static void rpccli_PNP_SetHwProf_done(struct tevent_req *subreq);
8512
8513 struct tevent_req *rpccli_PNP_SetHwProf_send(TALLOC_CTX *mem_ctx,
8514                                              struct tevent_context *ev,
8515                                              struct rpc_pipe_client *cli)
8516 {
8517         struct tevent_req *req;
8518         struct rpccli_PNP_SetHwProf_state *state;
8519         struct tevent_req *subreq;
8520
8521         req = tevent_req_create(mem_ctx, &state,
8522                                 struct rpccli_PNP_SetHwProf_state);
8523         if (req == NULL) {
8524                 return NULL;
8525         }
8526         state->out_mem_ctx = NULL;
8527         state->dispatch_recv = cli->dispatch_recv;
8528
8529         /* In parameters */
8530
8531         /* Out parameters */
8532
8533         /* Result */
8534         ZERO_STRUCT(state->orig.out.result);
8535
8536         if (DEBUGLEVEL >= 10) {
8537                 NDR_PRINT_IN_DEBUG(PNP_SetHwProf, &state->orig);
8538         }
8539
8540         /* make a temporary copy, that we pass to the dispatch function */
8541         state->tmp = state->orig;
8542
8543         subreq = cli->dispatch_send(state, ev, cli,
8544                                     &ndr_table_ntsvcs,
8545                                     NDR_PNP_SETHWPROF,
8546                                     &state->tmp);
8547         if (tevent_req_nomem(subreq, req)) {
8548                 return tevent_req_post(req, ev);
8549         }
8550         tevent_req_set_callback(subreq, rpccli_PNP_SetHwProf_done, req);
8551         return req;
8552 }
8553
8554 static void rpccli_PNP_SetHwProf_done(struct tevent_req *subreq)
8555 {
8556         struct tevent_req *req = tevent_req_callback_data(
8557                 subreq, struct tevent_req);
8558         struct rpccli_PNP_SetHwProf_state *state = tevent_req_data(
8559                 req, struct rpccli_PNP_SetHwProf_state);
8560         NTSTATUS status;
8561         TALLOC_CTX *mem_ctx;
8562
8563         if (state->out_mem_ctx) {
8564                 mem_ctx = state->out_mem_ctx;
8565         } else {
8566                 mem_ctx = state;
8567         }
8568
8569         status = state->dispatch_recv(subreq, mem_ctx);
8570         TALLOC_FREE(subreq);
8571         if (!NT_STATUS_IS_OK(status)) {
8572                 tevent_req_nterror(req, status);
8573                 return;
8574         }
8575
8576         /* Copy out parameters */
8577
8578         /* Copy result */
8579         state->orig.out.result = state->tmp.out.result;
8580
8581         /* Reset temporary structure */
8582         ZERO_STRUCT(state->tmp);
8583
8584         if (DEBUGLEVEL >= 10) {
8585                 NDR_PRINT_OUT_DEBUG(PNP_SetHwProf, &state->orig);
8586         }
8587
8588         tevent_req_done(req);
8589 }
8590
8591 NTSTATUS rpccli_PNP_SetHwProf_recv(struct tevent_req *req,
8592                                    TALLOC_CTX *mem_ctx,
8593                                    WERROR *result)
8594 {
8595         struct rpccli_PNP_SetHwProf_state *state = tevent_req_data(
8596                 req, struct rpccli_PNP_SetHwProf_state);
8597         NTSTATUS status;
8598
8599         if (tevent_req_is_nterror(req, &status)) {
8600                 tevent_req_received(req);
8601                 return status;
8602         }
8603
8604         /* Steal possbile out parameters to the callers context */
8605         talloc_steal(mem_ctx, state->out_mem_ctx);
8606
8607         /* Return result */
8608         *result = state->orig.out.result;
8609
8610         tevent_req_received(req);
8611         return NT_STATUS_OK;
8612 }
8613
8614 NTSTATUS rpccli_PNP_SetHwProf(struct rpc_pipe_client *cli,
8615                               TALLOC_CTX *mem_ctx,
8616                               WERROR *werror)
8617 {
8618         struct PNP_SetHwProf r;
8619         NTSTATUS status;
8620
8621         /* In parameters */
8622
8623         if (DEBUGLEVEL >= 10) {
8624                 NDR_PRINT_IN_DEBUG(PNP_SetHwProf, &r);
8625         }
8626
8627         status = cli->dispatch(cli,
8628                                 mem_ctx,
8629                                 &ndr_table_ntsvcs,
8630                                 NDR_PNP_SETHWPROF,
8631                                 &r);
8632
8633         if (!NT_STATUS_IS_OK(status)) {
8634                 return status;
8635         }
8636
8637         if (DEBUGLEVEL >= 10) {
8638                 NDR_PRINT_OUT_DEBUG(PNP_SetHwProf, &r);
8639         }
8640
8641         if (NT_STATUS_IS_ERR(status)) {
8642                 return status;
8643         }
8644
8645         /* Return variables */
8646
8647         /* Return result */
8648         if (werror) {
8649                 *werror = r.out.result;
8650         }
8651
8652         return werror_to_ntstatus(r.out.result);
8653 }
8654
8655 struct rpccli_PNP_QueryArbitratorFreeData_state {
8656         struct PNP_QueryArbitratorFreeData orig;
8657         struct PNP_QueryArbitratorFreeData tmp;
8658         TALLOC_CTX *out_mem_ctx;
8659         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8660 };
8661
8662 static void rpccli_PNP_QueryArbitratorFreeData_done(struct tevent_req *subreq);
8663
8664 struct tevent_req *rpccli_PNP_QueryArbitratorFreeData_send(TALLOC_CTX *mem_ctx,
8665                                                            struct tevent_context *ev,
8666                                                            struct rpc_pipe_client *cli)
8667 {
8668         struct tevent_req *req;
8669         struct rpccli_PNP_QueryArbitratorFreeData_state *state;
8670         struct tevent_req *subreq;
8671
8672         req = tevent_req_create(mem_ctx, &state,
8673                                 struct rpccli_PNP_QueryArbitratorFreeData_state);
8674         if (req == NULL) {
8675                 return NULL;
8676         }
8677         state->out_mem_ctx = NULL;
8678         state->dispatch_recv = cli->dispatch_recv;
8679
8680         /* In parameters */
8681
8682         /* Out parameters */
8683
8684         /* Result */
8685         ZERO_STRUCT(state->orig.out.result);
8686
8687         if (DEBUGLEVEL >= 10) {
8688                 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeData, &state->orig);
8689         }
8690
8691         /* make a temporary copy, that we pass to the dispatch function */
8692         state->tmp = state->orig;
8693
8694         subreq = cli->dispatch_send(state, ev, cli,
8695                                     &ndr_table_ntsvcs,
8696                                     NDR_PNP_QUERYARBITRATORFREEDATA,
8697                                     &state->tmp);
8698         if (tevent_req_nomem(subreq, req)) {
8699                 return tevent_req_post(req, ev);
8700         }
8701         tevent_req_set_callback(subreq, rpccli_PNP_QueryArbitratorFreeData_done, req);
8702         return req;
8703 }
8704
8705 static void rpccli_PNP_QueryArbitratorFreeData_done(struct tevent_req *subreq)
8706 {
8707         struct tevent_req *req = tevent_req_callback_data(
8708                 subreq, struct tevent_req);
8709         struct rpccli_PNP_QueryArbitratorFreeData_state *state = tevent_req_data(
8710                 req, struct rpccli_PNP_QueryArbitratorFreeData_state);
8711         NTSTATUS status;
8712         TALLOC_CTX *mem_ctx;
8713
8714         if (state->out_mem_ctx) {
8715                 mem_ctx = state->out_mem_ctx;
8716         } else {
8717                 mem_ctx = state;
8718         }
8719
8720         status = state->dispatch_recv(subreq, mem_ctx);
8721         TALLOC_FREE(subreq);
8722         if (!NT_STATUS_IS_OK(status)) {
8723                 tevent_req_nterror(req, status);
8724                 return;
8725         }
8726
8727         /* Copy out parameters */
8728
8729         /* Copy result */
8730         state->orig.out.result = state->tmp.out.result;
8731
8732         /* Reset temporary structure */
8733         ZERO_STRUCT(state->tmp);
8734
8735         if (DEBUGLEVEL >= 10) {
8736                 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeData, &state->orig);
8737         }
8738
8739         tevent_req_done(req);
8740 }
8741
8742 NTSTATUS rpccli_PNP_QueryArbitratorFreeData_recv(struct tevent_req *req,
8743                                                  TALLOC_CTX *mem_ctx,
8744                                                  WERROR *result)
8745 {
8746         struct rpccli_PNP_QueryArbitratorFreeData_state *state = tevent_req_data(
8747                 req, struct rpccli_PNP_QueryArbitratorFreeData_state);
8748         NTSTATUS status;
8749
8750         if (tevent_req_is_nterror(req, &status)) {
8751                 tevent_req_received(req);
8752                 return status;
8753         }
8754
8755         /* Steal possbile out parameters to the callers context */
8756         talloc_steal(mem_ctx, state->out_mem_ctx);
8757
8758         /* Return result */
8759         *result = state->orig.out.result;
8760
8761         tevent_req_received(req);
8762         return NT_STATUS_OK;
8763 }
8764
8765 NTSTATUS rpccli_PNP_QueryArbitratorFreeData(struct rpc_pipe_client *cli,
8766                                             TALLOC_CTX *mem_ctx,
8767                                             WERROR *werror)
8768 {
8769         struct PNP_QueryArbitratorFreeData r;
8770         NTSTATUS status;
8771
8772         /* In parameters */
8773
8774         if (DEBUGLEVEL >= 10) {
8775                 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeData, &r);
8776         }
8777
8778         status = cli->dispatch(cli,
8779                                 mem_ctx,
8780                                 &ndr_table_ntsvcs,
8781                                 NDR_PNP_QUERYARBITRATORFREEDATA,
8782                                 &r);
8783
8784         if (!NT_STATUS_IS_OK(status)) {
8785                 return status;
8786         }
8787
8788         if (DEBUGLEVEL >= 10) {
8789                 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeData, &r);
8790         }
8791
8792         if (NT_STATUS_IS_ERR(status)) {
8793                 return status;
8794         }
8795
8796         /* Return variables */
8797
8798         /* Return result */
8799         if (werror) {
8800                 *werror = r.out.result;
8801         }
8802
8803         return werror_to_ntstatus(r.out.result);
8804 }
8805
8806 struct rpccli_PNP_QueryArbitratorFreeSize_state {
8807         struct PNP_QueryArbitratorFreeSize orig;
8808         struct PNP_QueryArbitratorFreeSize tmp;
8809         TALLOC_CTX *out_mem_ctx;
8810         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8811 };
8812
8813 static void rpccli_PNP_QueryArbitratorFreeSize_done(struct tevent_req *subreq);
8814
8815 struct tevent_req *rpccli_PNP_QueryArbitratorFreeSize_send(TALLOC_CTX *mem_ctx,
8816                                                            struct tevent_context *ev,
8817                                                            struct rpc_pipe_client *cli)
8818 {
8819         struct tevent_req *req;
8820         struct rpccli_PNP_QueryArbitratorFreeSize_state *state;
8821         struct tevent_req *subreq;
8822
8823         req = tevent_req_create(mem_ctx, &state,
8824                                 struct rpccli_PNP_QueryArbitratorFreeSize_state);
8825         if (req == NULL) {
8826                 return NULL;
8827         }
8828         state->out_mem_ctx = NULL;
8829         state->dispatch_recv = cli->dispatch_recv;
8830
8831         /* In parameters */
8832
8833         /* Out parameters */
8834
8835         /* Result */
8836         ZERO_STRUCT(state->orig.out.result);
8837
8838         if (DEBUGLEVEL >= 10) {
8839                 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeSize, &state->orig);
8840         }
8841
8842         /* make a temporary copy, that we pass to the dispatch function */
8843         state->tmp = state->orig;
8844
8845         subreq = cli->dispatch_send(state, ev, cli,
8846                                     &ndr_table_ntsvcs,
8847                                     NDR_PNP_QUERYARBITRATORFREESIZE,
8848                                     &state->tmp);
8849         if (tevent_req_nomem(subreq, req)) {
8850                 return tevent_req_post(req, ev);
8851         }
8852         tevent_req_set_callback(subreq, rpccli_PNP_QueryArbitratorFreeSize_done, req);
8853         return req;
8854 }
8855
8856 static void rpccli_PNP_QueryArbitratorFreeSize_done(struct tevent_req *subreq)
8857 {
8858         struct tevent_req *req = tevent_req_callback_data(
8859                 subreq, struct tevent_req);
8860         struct rpccli_PNP_QueryArbitratorFreeSize_state *state = tevent_req_data(
8861                 req, struct rpccli_PNP_QueryArbitratorFreeSize_state);
8862         NTSTATUS status;
8863         TALLOC_CTX *mem_ctx;
8864
8865         if (state->out_mem_ctx) {
8866                 mem_ctx = state->out_mem_ctx;
8867         } else {
8868                 mem_ctx = state;
8869         }
8870
8871         status = state->dispatch_recv(subreq, mem_ctx);
8872         TALLOC_FREE(subreq);
8873         if (!NT_STATUS_IS_OK(status)) {
8874                 tevent_req_nterror(req, status);
8875                 return;
8876         }
8877
8878         /* Copy out parameters */
8879
8880         /* Copy result */
8881         state->orig.out.result = state->tmp.out.result;
8882
8883         /* Reset temporary structure */
8884         ZERO_STRUCT(state->tmp);
8885
8886         if (DEBUGLEVEL >= 10) {
8887                 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeSize, &state->orig);
8888         }
8889
8890         tevent_req_done(req);
8891 }
8892
8893 NTSTATUS rpccli_PNP_QueryArbitratorFreeSize_recv(struct tevent_req *req,
8894                                                  TALLOC_CTX *mem_ctx,
8895                                                  WERROR *result)
8896 {
8897         struct rpccli_PNP_QueryArbitratorFreeSize_state *state = tevent_req_data(
8898                 req, struct rpccli_PNP_QueryArbitratorFreeSize_state);
8899         NTSTATUS status;
8900
8901         if (tevent_req_is_nterror(req, &status)) {
8902                 tevent_req_received(req);
8903                 return status;
8904         }
8905
8906         /* Steal possbile out parameters to the callers context */
8907         talloc_steal(mem_ctx, state->out_mem_ctx);
8908
8909         /* Return result */
8910         *result = state->orig.out.result;
8911
8912         tevent_req_received(req);
8913         return NT_STATUS_OK;
8914 }
8915
8916 NTSTATUS rpccli_PNP_QueryArbitratorFreeSize(struct rpc_pipe_client *cli,
8917                                             TALLOC_CTX *mem_ctx,
8918                                             WERROR *werror)
8919 {
8920         struct PNP_QueryArbitratorFreeSize r;
8921         NTSTATUS status;
8922
8923         /* In parameters */
8924
8925         if (DEBUGLEVEL >= 10) {
8926                 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeSize, &r);
8927         }
8928
8929         status = cli->dispatch(cli,
8930                                 mem_ctx,
8931                                 &ndr_table_ntsvcs,
8932                                 NDR_PNP_QUERYARBITRATORFREESIZE,
8933                                 &r);
8934
8935         if (!NT_STATUS_IS_OK(status)) {
8936                 return status;
8937         }
8938
8939         if (DEBUGLEVEL >= 10) {
8940                 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeSize, &r);
8941         }
8942
8943         if (NT_STATUS_IS_ERR(status)) {
8944                 return status;
8945         }
8946
8947         /* Return variables */
8948
8949         /* Return result */
8950         if (werror) {
8951                 *werror = r.out.result;
8952         }
8953
8954         return werror_to_ntstatus(r.out.result);
8955 }
8956
8957 struct rpccli_PNP_RunDetection_state {
8958         struct PNP_RunDetection orig;
8959         struct PNP_RunDetection tmp;
8960         TALLOC_CTX *out_mem_ctx;
8961         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8962 };
8963
8964 static void rpccli_PNP_RunDetection_done(struct tevent_req *subreq);
8965
8966 struct tevent_req *rpccli_PNP_RunDetection_send(TALLOC_CTX *mem_ctx,
8967                                                 struct tevent_context *ev,
8968                                                 struct rpc_pipe_client *cli)
8969 {
8970         struct tevent_req *req;
8971         struct rpccli_PNP_RunDetection_state *state;
8972         struct tevent_req *subreq;
8973
8974         req = tevent_req_create(mem_ctx, &state,
8975                                 struct rpccli_PNP_RunDetection_state);
8976         if (req == NULL) {
8977                 return NULL;
8978         }
8979         state->out_mem_ctx = NULL;
8980         state->dispatch_recv = cli->dispatch_recv;
8981
8982         /* In parameters */
8983
8984         /* Out parameters */
8985
8986         /* Result */
8987         ZERO_STRUCT(state->orig.out.result);
8988
8989         if (DEBUGLEVEL >= 10) {
8990                 NDR_PRINT_IN_DEBUG(PNP_RunDetection, &state->orig);
8991         }
8992
8993         /* make a temporary copy, that we pass to the dispatch function */
8994         state->tmp = state->orig;
8995
8996         subreq = cli->dispatch_send(state, ev, cli,
8997                                     &ndr_table_ntsvcs,
8998                                     NDR_PNP_RUNDETECTION,
8999                                     &state->tmp);
9000         if (tevent_req_nomem(subreq, req)) {
9001                 return tevent_req_post(req, ev);
9002         }
9003         tevent_req_set_callback(subreq, rpccli_PNP_RunDetection_done, req);
9004         return req;
9005 }
9006
9007 static void rpccli_PNP_RunDetection_done(struct tevent_req *subreq)
9008 {
9009         struct tevent_req *req = tevent_req_callback_data(
9010                 subreq, struct tevent_req);
9011         struct rpccli_PNP_RunDetection_state *state = tevent_req_data(
9012                 req, struct rpccli_PNP_RunDetection_state);
9013         NTSTATUS status;
9014         TALLOC_CTX *mem_ctx;
9015
9016         if (state->out_mem_ctx) {
9017                 mem_ctx = state->out_mem_ctx;
9018         } else {
9019                 mem_ctx = state;
9020         }
9021
9022         status = state->dispatch_recv(subreq, mem_ctx);
9023         TALLOC_FREE(subreq);
9024         if (!NT_STATUS_IS_OK(status)) {
9025                 tevent_req_nterror(req, status);
9026                 return;
9027         }
9028
9029         /* Copy out parameters */
9030
9031         /* Copy result */
9032         state->orig.out.result = state->tmp.out.result;
9033
9034         /* Reset temporary structure */
9035         ZERO_STRUCT(state->tmp);
9036
9037         if (DEBUGLEVEL >= 10) {
9038                 NDR_PRINT_OUT_DEBUG(PNP_RunDetection, &state->orig);
9039         }
9040
9041         tevent_req_done(req);
9042 }
9043
9044 NTSTATUS rpccli_PNP_RunDetection_recv(struct tevent_req *req,
9045                                       TALLOC_CTX *mem_ctx,
9046                                       WERROR *result)
9047 {
9048         struct rpccli_PNP_RunDetection_state *state = tevent_req_data(
9049                 req, struct rpccli_PNP_RunDetection_state);
9050         NTSTATUS status;
9051
9052         if (tevent_req_is_nterror(req, &status)) {
9053                 tevent_req_received(req);
9054                 return status;
9055         }
9056
9057         /* Steal possbile out parameters to the callers context */
9058         talloc_steal(mem_ctx, state->out_mem_ctx);
9059
9060         /* Return result */
9061         *result = state->orig.out.result;
9062
9063         tevent_req_received(req);
9064         return NT_STATUS_OK;
9065 }
9066
9067 NTSTATUS rpccli_PNP_RunDetection(struct rpc_pipe_client *cli,
9068                                  TALLOC_CTX *mem_ctx,
9069                                  WERROR *werror)
9070 {
9071         struct PNP_RunDetection r;
9072         NTSTATUS status;
9073
9074         /* In parameters */
9075
9076         if (DEBUGLEVEL >= 10) {
9077                 NDR_PRINT_IN_DEBUG(PNP_RunDetection, &r);
9078         }
9079
9080         status = cli->dispatch(cli,
9081                                 mem_ctx,
9082                                 &ndr_table_ntsvcs,
9083                                 NDR_PNP_RUNDETECTION,
9084                                 &r);
9085
9086         if (!NT_STATUS_IS_OK(status)) {
9087                 return status;
9088         }
9089
9090         if (DEBUGLEVEL >= 10) {
9091                 NDR_PRINT_OUT_DEBUG(PNP_RunDetection, &r);
9092         }
9093
9094         if (NT_STATUS_IS_ERR(status)) {
9095                 return status;
9096         }
9097
9098         /* Return variables */
9099
9100         /* Return result */
9101         if (werror) {
9102                 *werror = r.out.result;
9103         }
9104
9105         return werror_to_ntstatus(r.out.result);
9106 }
9107
9108 struct rpccli_PNP_RegisterNotification_state {
9109         struct PNP_RegisterNotification orig;
9110         struct PNP_RegisterNotification tmp;
9111         TALLOC_CTX *out_mem_ctx;
9112         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9113 };
9114
9115 static void rpccli_PNP_RegisterNotification_done(struct tevent_req *subreq);
9116
9117 struct tevent_req *rpccli_PNP_RegisterNotification_send(TALLOC_CTX *mem_ctx,
9118                                                         struct tevent_context *ev,
9119                                                         struct rpc_pipe_client *cli)
9120 {
9121         struct tevent_req *req;
9122         struct rpccli_PNP_RegisterNotification_state *state;
9123         struct tevent_req *subreq;
9124
9125         req = tevent_req_create(mem_ctx, &state,
9126                                 struct rpccli_PNP_RegisterNotification_state);
9127         if (req == NULL) {
9128                 return NULL;
9129         }
9130         state->out_mem_ctx = NULL;
9131         state->dispatch_recv = cli->dispatch_recv;
9132
9133         /* In parameters */
9134
9135         /* Out parameters */
9136
9137         /* Result */
9138         ZERO_STRUCT(state->orig.out.result);
9139
9140         if (DEBUGLEVEL >= 10) {
9141                 NDR_PRINT_IN_DEBUG(PNP_RegisterNotification, &state->orig);
9142         }
9143
9144         /* make a temporary copy, that we pass to the dispatch function */
9145         state->tmp = state->orig;
9146
9147         subreq = cli->dispatch_send(state, ev, cli,
9148                                     &ndr_table_ntsvcs,
9149                                     NDR_PNP_REGISTERNOTIFICATION,
9150                                     &state->tmp);
9151         if (tevent_req_nomem(subreq, req)) {
9152                 return tevent_req_post(req, ev);
9153         }
9154         tevent_req_set_callback(subreq, rpccli_PNP_RegisterNotification_done, req);
9155         return req;
9156 }
9157
9158 static void rpccli_PNP_RegisterNotification_done(struct tevent_req *subreq)
9159 {
9160         struct tevent_req *req = tevent_req_callback_data(
9161                 subreq, struct tevent_req);
9162         struct rpccli_PNP_RegisterNotification_state *state = tevent_req_data(
9163                 req, struct rpccli_PNP_RegisterNotification_state);
9164         NTSTATUS status;
9165         TALLOC_CTX *mem_ctx;
9166
9167         if (state->out_mem_ctx) {
9168                 mem_ctx = state->out_mem_ctx;
9169         } else {
9170                 mem_ctx = state;
9171         }
9172
9173         status = state->dispatch_recv(subreq, mem_ctx);
9174         TALLOC_FREE(subreq);
9175         if (!NT_STATUS_IS_OK(status)) {
9176                 tevent_req_nterror(req, status);
9177                 return;
9178         }
9179
9180         /* Copy out parameters */
9181
9182         /* Copy result */
9183         state->orig.out.result = state->tmp.out.result;
9184
9185         /* Reset temporary structure */
9186         ZERO_STRUCT(state->tmp);
9187
9188         if (DEBUGLEVEL >= 10) {
9189                 NDR_PRINT_OUT_DEBUG(PNP_RegisterNotification, &state->orig);
9190         }
9191
9192         tevent_req_done(req);
9193 }
9194
9195 NTSTATUS rpccli_PNP_RegisterNotification_recv(struct tevent_req *req,
9196                                               TALLOC_CTX *mem_ctx,
9197                                               WERROR *result)
9198 {
9199         struct rpccli_PNP_RegisterNotification_state *state = tevent_req_data(
9200                 req, struct rpccli_PNP_RegisterNotification_state);
9201         NTSTATUS status;
9202
9203         if (tevent_req_is_nterror(req, &status)) {
9204                 tevent_req_received(req);
9205                 return status;
9206         }
9207
9208         /* Steal possbile out parameters to the callers context */
9209         talloc_steal(mem_ctx, state->out_mem_ctx);
9210
9211         /* Return result */
9212         *result = state->orig.out.result;
9213
9214         tevent_req_received(req);
9215         return NT_STATUS_OK;
9216 }
9217
9218 NTSTATUS rpccli_PNP_RegisterNotification(struct rpc_pipe_client *cli,
9219                                          TALLOC_CTX *mem_ctx,
9220                                          WERROR *werror)
9221 {
9222         struct PNP_RegisterNotification r;
9223         NTSTATUS status;
9224
9225         /* In parameters */
9226
9227         if (DEBUGLEVEL >= 10) {
9228                 NDR_PRINT_IN_DEBUG(PNP_RegisterNotification, &r);
9229         }
9230
9231         status = cli->dispatch(cli,
9232                                 mem_ctx,
9233                                 &ndr_table_ntsvcs,
9234                                 NDR_PNP_REGISTERNOTIFICATION,
9235                                 &r);
9236
9237         if (!NT_STATUS_IS_OK(status)) {
9238                 return status;
9239         }
9240
9241         if (DEBUGLEVEL >= 10) {
9242                 NDR_PRINT_OUT_DEBUG(PNP_RegisterNotification, &r);
9243         }
9244
9245         if (NT_STATUS_IS_ERR(status)) {
9246                 return status;
9247         }
9248
9249         /* Return variables */
9250
9251         /* Return result */
9252         if (werror) {
9253                 *werror = r.out.result;
9254         }
9255
9256         return werror_to_ntstatus(r.out.result);
9257 }
9258
9259 struct rpccli_PNP_UnregisterNotification_state {
9260         struct PNP_UnregisterNotification orig;
9261         struct PNP_UnregisterNotification tmp;
9262         TALLOC_CTX *out_mem_ctx;
9263         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9264 };
9265
9266 static void rpccli_PNP_UnregisterNotification_done(struct tevent_req *subreq);
9267
9268 struct tevent_req *rpccli_PNP_UnregisterNotification_send(TALLOC_CTX *mem_ctx,
9269                                                           struct tevent_context *ev,
9270                                                           struct rpc_pipe_client *cli)
9271 {
9272         struct tevent_req *req;
9273         struct rpccli_PNP_UnregisterNotification_state *state;
9274         struct tevent_req *subreq;
9275
9276         req = tevent_req_create(mem_ctx, &state,
9277                                 struct rpccli_PNP_UnregisterNotification_state);
9278         if (req == NULL) {
9279                 return NULL;
9280         }
9281         state->out_mem_ctx = NULL;
9282         state->dispatch_recv = cli->dispatch_recv;
9283
9284         /* In parameters */
9285
9286         /* Out parameters */
9287
9288         /* Result */
9289         ZERO_STRUCT(state->orig.out.result);
9290
9291         if (DEBUGLEVEL >= 10) {
9292                 NDR_PRINT_IN_DEBUG(PNP_UnregisterNotification, &state->orig);
9293         }
9294
9295         /* make a temporary copy, that we pass to the dispatch function */
9296         state->tmp = state->orig;
9297
9298         subreq = cli->dispatch_send(state, ev, cli,
9299                                     &ndr_table_ntsvcs,
9300                                     NDR_PNP_UNREGISTERNOTIFICATION,
9301                                     &state->tmp);
9302         if (tevent_req_nomem(subreq, req)) {
9303                 return tevent_req_post(req, ev);
9304         }
9305         tevent_req_set_callback(subreq, rpccli_PNP_UnregisterNotification_done, req);
9306         return req;
9307 }
9308
9309 static void rpccli_PNP_UnregisterNotification_done(struct tevent_req *subreq)
9310 {
9311         struct tevent_req *req = tevent_req_callback_data(
9312                 subreq, struct tevent_req);
9313         struct rpccli_PNP_UnregisterNotification_state *state = tevent_req_data(
9314                 req, struct rpccli_PNP_UnregisterNotification_state);
9315         NTSTATUS status;
9316         TALLOC_CTX *mem_ctx;
9317
9318         if (state->out_mem_ctx) {
9319                 mem_ctx = state->out_mem_ctx;
9320         } else {
9321                 mem_ctx = state;
9322         }
9323
9324         status = state->dispatch_recv(subreq, mem_ctx);
9325         TALLOC_FREE(subreq);
9326         if (!NT_STATUS_IS_OK(status)) {
9327                 tevent_req_nterror(req, status);
9328                 return;
9329         }
9330
9331         /* Copy out parameters */
9332
9333         /* Copy result */
9334         state->orig.out.result = state->tmp.out.result;
9335
9336         /* Reset temporary structure */
9337         ZERO_STRUCT(state->tmp);
9338
9339         if (DEBUGLEVEL >= 10) {
9340                 NDR_PRINT_OUT_DEBUG(PNP_UnregisterNotification, &state->orig);
9341         }
9342
9343         tevent_req_done(req);
9344 }
9345
9346 NTSTATUS rpccli_PNP_UnregisterNotification_recv(struct tevent_req *req,
9347                                                 TALLOC_CTX *mem_ctx,
9348                                                 WERROR *result)
9349 {
9350         struct rpccli_PNP_UnregisterNotification_state *state = tevent_req_data(
9351                 req, struct rpccli_PNP_UnregisterNotification_state);
9352         NTSTATUS status;
9353
9354         if (tevent_req_is_nterror(req, &status)) {
9355                 tevent_req_received(req);
9356                 return status;
9357         }
9358
9359         /* Steal possbile out parameters to the callers context */
9360         talloc_steal(mem_ctx, state->out_mem_ctx);
9361
9362         /* Return result */
9363         *result = state->orig.out.result;
9364
9365         tevent_req_received(req);
9366         return NT_STATUS_OK;
9367 }
9368
9369 NTSTATUS rpccli_PNP_UnregisterNotification(struct rpc_pipe_client *cli,
9370                                            TALLOC_CTX *mem_ctx,
9371                                            WERROR *werror)
9372 {
9373         struct PNP_UnregisterNotification r;
9374         NTSTATUS status;
9375
9376         /* In parameters */
9377
9378         if (DEBUGLEVEL >= 10) {
9379                 NDR_PRINT_IN_DEBUG(PNP_UnregisterNotification, &r);
9380         }
9381
9382         status = cli->dispatch(cli,
9383                                 mem_ctx,
9384                                 &ndr_table_ntsvcs,
9385                                 NDR_PNP_UNREGISTERNOTIFICATION,
9386                                 &r);
9387
9388         if (!NT_STATUS_IS_OK(status)) {
9389                 return status;
9390         }
9391
9392         if (DEBUGLEVEL >= 10) {
9393                 NDR_PRINT_OUT_DEBUG(PNP_UnregisterNotification, &r);
9394         }
9395
9396         if (NT_STATUS_IS_ERR(status)) {
9397                 return status;
9398         }
9399
9400         /* Return variables */
9401
9402         /* Return result */
9403         if (werror) {
9404                 *werror = r.out.result;
9405         }
9406
9407         return werror_to_ntstatus(r.out.result);
9408 }
9409
9410 struct rpccli_PNP_GetCustomDevProp_state {
9411         struct PNP_GetCustomDevProp orig;
9412         struct PNP_GetCustomDevProp tmp;
9413         TALLOC_CTX *out_mem_ctx;
9414         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9415 };
9416
9417 static void rpccli_PNP_GetCustomDevProp_done(struct tevent_req *subreq);
9418
9419 struct tevent_req *rpccli_PNP_GetCustomDevProp_send(TALLOC_CTX *mem_ctx,
9420                                                     struct tevent_context *ev,
9421                                                     struct rpc_pipe_client *cli)
9422 {
9423         struct tevent_req *req;
9424         struct rpccli_PNP_GetCustomDevProp_state *state;
9425         struct tevent_req *subreq;
9426
9427         req = tevent_req_create(mem_ctx, &state,
9428                                 struct rpccli_PNP_GetCustomDevProp_state);
9429         if (req == NULL) {
9430                 return NULL;
9431         }
9432         state->out_mem_ctx = NULL;
9433         state->dispatch_recv = cli->dispatch_recv;
9434
9435         /* In parameters */
9436
9437         /* Out parameters */
9438
9439         /* Result */
9440         ZERO_STRUCT(state->orig.out.result);
9441
9442         if (DEBUGLEVEL >= 10) {
9443                 NDR_PRINT_IN_DEBUG(PNP_GetCustomDevProp, &state->orig);
9444         }
9445
9446         /* make a temporary copy, that we pass to the dispatch function */
9447         state->tmp = state->orig;
9448
9449         subreq = cli->dispatch_send(state, ev, cli,
9450                                     &ndr_table_ntsvcs,
9451                                     NDR_PNP_GETCUSTOMDEVPROP,
9452                                     &state->tmp);
9453         if (tevent_req_nomem(subreq, req)) {
9454                 return tevent_req_post(req, ev);
9455         }
9456         tevent_req_set_callback(subreq, rpccli_PNP_GetCustomDevProp_done, req);
9457         return req;
9458 }
9459
9460 static void rpccli_PNP_GetCustomDevProp_done(struct tevent_req *subreq)
9461 {
9462         struct tevent_req *req = tevent_req_callback_data(
9463                 subreq, struct tevent_req);
9464         struct rpccli_PNP_GetCustomDevProp_state *state = tevent_req_data(
9465                 req, struct rpccli_PNP_GetCustomDevProp_state);
9466         NTSTATUS status;
9467         TALLOC_CTX *mem_ctx;
9468
9469         if (state->out_mem_ctx) {
9470                 mem_ctx = state->out_mem_ctx;
9471         } else {
9472                 mem_ctx = state;
9473         }
9474
9475         status = state->dispatch_recv(subreq, mem_ctx);
9476         TALLOC_FREE(subreq);
9477         if (!NT_STATUS_IS_OK(status)) {
9478                 tevent_req_nterror(req, status);
9479                 return;
9480         }
9481
9482         /* Copy out parameters */
9483
9484         /* Copy result */
9485         state->orig.out.result = state->tmp.out.result;
9486
9487         /* Reset temporary structure */
9488         ZERO_STRUCT(state->tmp);
9489
9490         if (DEBUGLEVEL >= 10) {
9491                 NDR_PRINT_OUT_DEBUG(PNP_GetCustomDevProp, &state->orig);
9492         }
9493
9494         tevent_req_done(req);
9495 }
9496
9497 NTSTATUS rpccli_PNP_GetCustomDevProp_recv(struct tevent_req *req,
9498                                           TALLOC_CTX *mem_ctx,
9499                                           WERROR *result)
9500 {
9501         struct rpccli_PNP_GetCustomDevProp_state *state = tevent_req_data(
9502                 req, struct rpccli_PNP_GetCustomDevProp_state);
9503         NTSTATUS status;
9504
9505         if (tevent_req_is_nterror(req, &status)) {
9506                 tevent_req_received(req);
9507                 return status;
9508         }
9509
9510         /* Steal possbile out parameters to the callers context */
9511         talloc_steal(mem_ctx, state->out_mem_ctx);
9512
9513         /* Return result */
9514         *result = state->orig.out.result;
9515
9516         tevent_req_received(req);
9517         return NT_STATUS_OK;
9518 }
9519
9520 NTSTATUS rpccli_PNP_GetCustomDevProp(struct rpc_pipe_client *cli,
9521                                      TALLOC_CTX *mem_ctx,
9522                                      WERROR *werror)
9523 {
9524         struct PNP_GetCustomDevProp r;
9525         NTSTATUS status;
9526
9527         /* In parameters */
9528
9529         if (DEBUGLEVEL >= 10) {
9530                 NDR_PRINT_IN_DEBUG(PNP_GetCustomDevProp, &r);
9531         }
9532
9533         status = cli->dispatch(cli,
9534                                 mem_ctx,
9535                                 &ndr_table_ntsvcs,
9536                                 NDR_PNP_GETCUSTOMDEVPROP,
9537                                 &r);
9538
9539         if (!NT_STATUS_IS_OK(status)) {
9540                 return status;
9541         }
9542
9543         if (DEBUGLEVEL >= 10) {
9544                 NDR_PRINT_OUT_DEBUG(PNP_GetCustomDevProp, &r);
9545         }
9546
9547         if (NT_STATUS_IS_ERR(status)) {
9548                 return status;
9549         }
9550
9551         /* Return variables */
9552
9553         /* Return result */
9554         if (werror) {
9555                 *werror = r.out.result;
9556         }
9557
9558         return werror_to_ntstatus(r.out.result);
9559 }
9560
9561 struct rpccli_PNP_GetVersionInternal_state {
9562         struct PNP_GetVersionInternal orig;
9563         struct PNP_GetVersionInternal tmp;
9564         TALLOC_CTX *out_mem_ctx;
9565         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9566 };
9567
9568 static void rpccli_PNP_GetVersionInternal_done(struct tevent_req *subreq);
9569
9570 struct tevent_req *rpccli_PNP_GetVersionInternal_send(TALLOC_CTX *mem_ctx,
9571                                                       struct tevent_context *ev,
9572                                                       struct rpc_pipe_client *cli)
9573 {
9574         struct tevent_req *req;
9575         struct rpccli_PNP_GetVersionInternal_state *state;
9576         struct tevent_req *subreq;
9577
9578         req = tevent_req_create(mem_ctx, &state,
9579                                 struct rpccli_PNP_GetVersionInternal_state);
9580         if (req == NULL) {
9581                 return NULL;
9582         }
9583         state->out_mem_ctx = NULL;
9584         state->dispatch_recv = cli->dispatch_recv;
9585
9586         /* In parameters */
9587
9588         /* Out parameters */
9589
9590         /* Result */
9591         ZERO_STRUCT(state->orig.out.result);
9592
9593         if (DEBUGLEVEL >= 10) {
9594                 NDR_PRINT_IN_DEBUG(PNP_GetVersionInternal, &state->orig);
9595         }
9596
9597         /* make a temporary copy, that we pass to the dispatch function */
9598         state->tmp = state->orig;
9599
9600         subreq = cli->dispatch_send(state, ev, cli,
9601                                     &ndr_table_ntsvcs,
9602                                     NDR_PNP_GETVERSIONINTERNAL,
9603                                     &state->tmp);
9604         if (tevent_req_nomem(subreq, req)) {
9605                 return tevent_req_post(req, ev);
9606         }
9607         tevent_req_set_callback(subreq, rpccli_PNP_GetVersionInternal_done, req);
9608         return req;
9609 }
9610
9611 static void rpccli_PNP_GetVersionInternal_done(struct tevent_req *subreq)
9612 {
9613         struct tevent_req *req = tevent_req_callback_data(
9614                 subreq, struct tevent_req);
9615         struct rpccli_PNP_GetVersionInternal_state *state = tevent_req_data(
9616                 req, struct rpccli_PNP_GetVersionInternal_state);
9617         NTSTATUS status;
9618         TALLOC_CTX *mem_ctx;
9619
9620         if (state->out_mem_ctx) {
9621                 mem_ctx = state->out_mem_ctx;
9622         } else {
9623                 mem_ctx = state;
9624         }
9625
9626         status = state->dispatch_recv(subreq, mem_ctx);
9627         TALLOC_FREE(subreq);
9628         if (!NT_STATUS_IS_OK(status)) {
9629                 tevent_req_nterror(req, status);
9630                 return;
9631         }
9632
9633         /* Copy out parameters */
9634
9635         /* Copy result */
9636         state->orig.out.result = state->tmp.out.result;
9637
9638         /* Reset temporary structure */
9639         ZERO_STRUCT(state->tmp);
9640
9641         if (DEBUGLEVEL >= 10) {
9642                 NDR_PRINT_OUT_DEBUG(PNP_GetVersionInternal, &state->orig);
9643         }
9644
9645         tevent_req_done(req);
9646 }
9647
9648 NTSTATUS rpccli_PNP_GetVersionInternal_recv(struct tevent_req *req,
9649                                             TALLOC_CTX *mem_ctx,
9650                                             WERROR *result)
9651 {
9652         struct rpccli_PNP_GetVersionInternal_state *state = tevent_req_data(
9653                 req, struct rpccli_PNP_GetVersionInternal_state);
9654         NTSTATUS status;
9655
9656         if (tevent_req_is_nterror(req, &status)) {
9657                 tevent_req_received(req);
9658                 return status;
9659         }
9660
9661         /* Steal possbile out parameters to the callers context */
9662         talloc_steal(mem_ctx, state->out_mem_ctx);
9663
9664         /* Return result */
9665         *result = state->orig.out.result;
9666
9667         tevent_req_received(req);
9668         return NT_STATUS_OK;
9669 }
9670
9671 NTSTATUS rpccli_PNP_GetVersionInternal(struct rpc_pipe_client *cli,
9672                                        TALLOC_CTX *mem_ctx,
9673                                        WERROR *werror)
9674 {
9675         struct PNP_GetVersionInternal r;
9676         NTSTATUS status;
9677
9678         /* In parameters */
9679
9680         if (DEBUGLEVEL >= 10) {
9681                 NDR_PRINT_IN_DEBUG(PNP_GetVersionInternal, &r);
9682         }
9683
9684         status = cli->dispatch(cli,
9685                                 mem_ctx,
9686                                 &ndr_table_ntsvcs,
9687                                 NDR_PNP_GETVERSIONINTERNAL,
9688                                 &r);
9689
9690         if (!NT_STATUS_IS_OK(status)) {
9691                 return status;
9692         }
9693
9694         if (DEBUGLEVEL >= 10) {
9695                 NDR_PRINT_OUT_DEBUG(PNP_GetVersionInternal, &r);
9696         }
9697
9698         if (NT_STATUS_IS_ERR(status)) {
9699                 return status;
9700         }
9701
9702         /* Return variables */
9703
9704         /* Return result */
9705         if (werror) {
9706                 *werror = r.out.result;
9707         }
9708
9709         return werror_to_ntstatus(r.out.result);
9710 }
9711
9712 struct rpccli_PNP_GetBlockedDriverInfo_state {
9713         struct PNP_GetBlockedDriverInfo orig;
9714         struct PNP_GetBlockedDriverInfo tmp;
9715         TALLOC_CTX *out_mem_ctx;
9716         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9717 };
9718
9719 static void rpccli_PNP_GetBlockedDriverInfo_done(struct tevent_req *subreq);
9720
9721 struct tevent_req *rpccli_PNP_GetBlockedDriverInfo_send(TALLOC_CTX *mem_ctx,
9722                                                         struct tevent_context *ev,
9723                                                         struct rpc_pipe_client *cli)
9724 {
9725         struct tevent_req *req;
9726         struct rpccli_PNP_GetBlockedDriverInfo_state *state;
9727         struct tevent_req *subreq;
9728
9729         req = tevent_req_create(mem_ctx, &state,
9730                                 struct rpccli_PNP_GetBlockedDriverInfo_state);
9731         if (req == NULL) {
9732                 return NULL;
9733         }
9734         state->out_mem_ctx = NULL;
9735         state->dispatch_recv = cli->dispatch_recv;
9736
9737         /* In parameters */
9738
9739         /* Out parameters */
9740
9741         /* Result */
9742         ZERO_STRUCT(state->orig.out.result);
9743
9744         if (DEBUGLEVEL >= 10) {
9745                 NDR_PRINT_IN_DEBUG(PNP_GetBlockedDriverInfo, &state->orig);
9746         }
9747
9748         /* make a temporary copy, that we pass to the dispatch function */
9749         state->tmp = state->orig;
9750
9751         subreq = cli->dispatch_send(state, ev, cli,
9752                                     &ndr_table_ntsvcs,
9753                                     NDR_PNP_GETBLOCKEDDRIVERINFO,
9754                                     &state->tmp);
9755         if (tevent_req_nomem(subreq, req)) {
9756                 return tevent_req_post(req, ev);
9757         }
9758         tevent_req_set_callback(subreq, rpccli_PNP_GetBlockedDriverInfo_done, req);
9759         return req;
9760 }
9761
9762 static void rpccli_PNP_GetBlockedDriverInfo_done(struct tevent_req *subreq)
9763 {
9764         struct tevent_req *req = tevent_req_callback_data(
9765                 subreq, struct tevent_req);
9766         struct rpccli_PNP_GetBlockedDriverInfo_state *state = tevent_req_data(
9767                 req, struct rpccli_PNP_GetBlockedDriverInfo_state);
9768         NTSTATUS status;
9769         TALLOC_CTX *mem_ctx;
9770
9771         if (state->out_mem_ctx) {
9772                 mem_ctx = state->out_mem_ctx;
9773         } else {
9774                 mem_ctx = state;
9775         }
9776
9777         status = state->dispatch_recv(subreq, mem_ctx);
9778         TALLOC_FREE(subreq);
9779         if (!NT_STATUS_IS_OK(status)) {
9780                 tevent_req_nterror(req, status);
9781                 return;
9782         }
9783
9784         /* Copy out parameters */
9785
9786         /* Copy result */
9787         state->orig.out.result = state->tmp.out.result;
9788
9789         /* Reset temporary structure */
9790         ZERO_STRUCT(state->tmp);
9791
9792         if (DEBUGLEVEL >= 10) {
9793                 NDR_PRINT_OUT_DEBUG(PNP_GetBlockedDriverInfo, &state->orig);
9794         }
9795
9796         tevent_req_done(req);
9797 }
9798
9799 NTSTATUS rpccli_PNP_GetBlockedDriverInfo_recv(struct tevent_req *req,
9800                                               TALLOC_CTX *mem_ctx,
9801                                               WERROR *result)
9802 {
9803         struct rpccli_PNP_GetBlockedDriverInfo_state *state = tevent_req_data(
9804                 req, struct rpccli_PNP_GetBlockedDriverInfo_state);
9805         NTSTATUS status;
9806
9807         if (tevent_req_is_nterror(req, &status)) {
9808                 tevent_req_received(req);
9809                 return status;
9810         }
9811
9812         /* Steal possbile out parameters to the callers context */
9813         talloc_steal(mem_ctx, state->out_mem_ctx);
9814
9815         /* Return result */
9816         *result = state->orig.out.result;
9817
9818         tevent_req_received(req);
9819         return NT_STATUS_OK;
9820 }
9821
9822 NTSTATUS rpccli_PNP_GetBlockedDriverInfo(struct rpc_pipe_client *cli,
9823                                          TALLOC_CTX *mem_ctx,
9824                                          WERROR *werror)
9825 {
9826         struct PNP_GetBlockedDriverInfo r;
9827         NTSTATUS status;
9828
9829         /* In parameters */
9830
9831         if (DEBUGLEVEL >= 10) {
9832                 NDR_PRINT_IN_DEBUG(PNP_GetBlockedDriverInfo, &r);
9833         }
9834
9835         status = cli->dispatch(cli,
9836                                 mem_ctx,
9837                                 &ndr_table_ntsvcs,
9838                                 NDR_PNP_GETBLOCKEDDRIVERINFO,
9839                                 &r);
9840
9841         if (!NT_STATUS_IS_OK(status)) {
9842                 return status;
9843         }
9844
9845         if (DEBUGLEVEL >= 10) {
9846                 NDR_PRINT_OUT_DEBUG(PNP_GetBlockedDriverInfo, &r);
9847         }
9848
9849         if (NT_STATUS_IS_ERR(status)) {
9850                 return status;
9851         }
9852
9853         /* Return variables */
9854
9855         /* Return result */
9856         if (werror) {
9857                 *werror = r.out.result;
9858         }
9859
9860         return werror_to_ntstatus(r.out.result);
9861 }
9862
9863 struct rpccli_PNP_GetServerSideDeviceInstallFlags_state {
9864         struct PNP_GetServerSideDeviceInstallFlags orig;
9865         struct PNP_GetServerSideDeviceInstallFlags tmp;
9866         TALLOC_CTX *out_mem_ctx;
9867         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9868 };
9869
9870 static void rpccli_PNP_GetServerSideDeviceInstallFlags_done(struct tevent_req *subreq);
9871
9872 struct tevent_req *rpccli_PNP_GetServerSideDeviceInstallFlags_send(TALLOC_CTX *mem_ctx,
9873                                                                    struct tevent_context *ev,
9874                                                                    struct rpc_pipe_client *cli)
9875 {
9876         struct tevent_req *req;
9877         struct rpccli_PNP_GetServerSideDeviceInstallFlags_state *state;
9878         struct tevent_req *subreq;
9879
9880         req = tevent_req_create(mem_ctx, &state,
9881                                 struct rpccli_PNP_GetServerSideDeviceInstallFlags_state);
9882         if (req == NULL) {
9883                 return NULL;
9884         }
9885         state->out_mem_ctx = NULL;
9886         state->dispatch_recv = cli->dispatch_recv;
9887
9888         /* In parameters */
9889
9890         /* Out parameters */
9891
9892         /* Result */
9893         ZERO_STRUCT(state->orig.out.result);
9894
9895         if (DEBUGLEVEL >= 10) {
9896                 NDR_PRINT_IN_DEBUG(PNP_GetServerSideDeviceInstallFlags, &state->orig);
9897         }
9898
9899         /* make a temporary copy, that we pass to the dispatch function */
9900         state->tmp = state->orig;
9901
9902         subreq = cli->dispatch_send(state, ev, cli,
9903                                     &ndr_table_ntsvcs,
9904                                     NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS,
9905                                     &state->tmp);
9906         if (tevent_req_nomem(subreq, req)) {
9907                 return tevent_req_post(req, ev);
9908         }
9909         tevent_req_set_callback(subreq, rpccli_PNP_GetServerSideDeviceInstallFlags_done, req);
9910         return req;
9911 }
9912
9913 static void rpccli_PNP_GetServerSideDeviceInstallFlags_done(struct tevent_req *subreq)
9914 {
9915         struct tevent_req *req = tevent_req_callback_data(
9916                 subreq, struct tevent_req);
9917         struct rpccli_PNP_GetServerSideDeviceInstallFlags_state *state = tevent_req_data(
9918                 req, struct rpccli_PNP_GetServerSideDeviceInstallFlags_state);
9919         NTSTATUS status;
9920         TALLOC_CTX *mem_ctx;
9921
9922         if (state->out_mem_ctx) {
9923                 mem_ctx = state->out_mem_ctx;
9924         } else {
9925                 mem_ctx = state;
9926         }
9927
9928         status = state->dispatch_recv(subreq, mem_ctx);
9929         TALLOC_FREE(subreq);
9930         if (!NT_STATUS_IS_OK(status)) {
9931                 tevent_req_nterror(req, status);
9932                 return;
9933         }
9934
9935         /* Copy out parameters */
9936
9937         /* Copy result */
9938         state->orig.out.result = state->tmp.out.result;
9939
9940         /* Reset temporary structure */
9941         ZERO_STRUCT(state->tmp);
9942
9943         if (DEBUGLEVEL >= 10) {
9944                 NDR_PRINT_OUT_DEBUG(PNP_GetServerSideDeviceInstallFlags, &state->orig);
9945         }
9946
9947         tevent_req_done(req);
9948 }
9949
9950 NTSTATUS rpccli_PNP_GetServerSideDeviceInstallFlags_recv(struct tevent_req *req,
9951                                                          TALLOC_CTX *mem_ctx,
9952                                                          WERROR *result)
9953 {
9954         struct rpccli_PNP_GetServerSideDeviceInstallFlags_state *state = tevent_req_data(
9955                 req, struct rpccli_PNP_GetServerSideDeviceInstallFlags_state);
9956         NTSTATUS status;
9957
9958         if (tevent_req_is_nterror(req, &status)) {
9959                 tevent_req_received(req);
9960                 return status;
9961         }
9962
9963         /* Steal possbile out parameters to the callers context */
9964         talloc_steal(mem_ctx, state->out_mem_ctx);
9965
9966         /* Return result */
9967         *result = state->orig.out.result;
9968
9969         tevent_req_received(req);
9970         return NT_STATUS_OK;
9971 }
9972
9973 NTSTATUS rpccli_PNP_GetServerSideDeviceInstallFlags(struct rpc_pipe_client *cli,
9974                                                     TALLOC_CTX *mem_ctx,
9975                                                     WERROR *werror)
9976 {
9977         struct PNP_GetServerSideDeviceInstallFlags r;
9978         NTSTATUS status;
9979
9980         /* In parameters */
9981
9982         if (DEBUGLEVEL >= 10) {
9983                 NDR_PRINT_IN_DEBUG(PNP_GetServerSideDeviceInstallFlags, &r);
9984         }
9985
9986         status = cli->dispatch(cli,
9987                                 mem_ctx,
9988                                 &ndr_table_ntsvcs,
9989                                 NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS,
9990                                 &r);
9991
9992         if (!NT_STATUS_IS_OK(status)) {
9993                 return status;
9994         }
9995
9996         if (DEBUGLEVEL >= 10) {
9997                 NDR_PRINT_OUT_DEBUG(PNP_GetServerSideDeviceInstallFlags, &r);
9998         }
9999
10000         if (NT_STATUS_IS_ERR(status)) {
10001                 return status;
10002         }
10003
10004         /* Return variables */
10005
10006         /* Return result */
10007         if (werror) {
10008                 *werror = r.out.result;
10009         }
10010
10011         return werror_to_ntstatus(r.out.result);
10012 }
10013