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