1/* 2 * Unix SMB/CIFS implementation. 3 * server auto-generated by pidl. DO NOT MODIFY! 4 */ 5 6#include "includes.h" 7#include "../librpc/gen_ndr/srv_ntsvcs.h" 8 9static bool api_PNP_Disconnect(pipes_struct *p) 10{ 11 const struct ndr_interface_call *call; 12 struct ndr_pull *pull; 13 struct ndr_push *push; 14 enum ndr_err_code ndr_err; 15 DATA_BLOB blob; 16 struct PNP_Disconnect *r; 17 18 call = &ndr_table_ntsvcs.calls[NDR_PNP_DISCONNECT]; 19 20 r = talloc(talloc_tos(), struct PNP_Disconnect); 21 if (r == NULL) { 22 return false; 23 } 24 25 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 26 talloc_free(r); 27 return false; 28 } 29 30 pull = ndr_pull_init_blob(&blob, r, NULL); 31 if (pull == NULL) { 32 talloc_free(r); 33 return false; 34 } 35 36 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 37 ndr_err = call->ndr_pull(pull, NDR_IN, r); 38 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 39 talloc_free(r); 40 return false; 41 } 42 43 if (DEBUGLEVEL >= 10) { 44 NDR_PRINT_IN_DEBUG(PNP_Disconnect, r); 45 } 46 47 r->out.result = _PNP_Disconnect(p, r); 48 49 if (p->rng_fault_state) { 50 talloc_free(r); 51 /* Return true here, srv_pipe_hnd.c will take care */ 52 return true; 53 } 54 55 if (DEBUGLEVEL >= 10) { 56 NDR_PRINT_OUT_DEBUG(PNP_Disconnect, r); 57 } 58 59 push = ndr_push_init_ctx(r, NULL); 60 if (push == NULL) { 61 talloc_free(r); 62 return false; 63 } 64 65 ndr_err = call->ndr_push(push, NDR_OUT, r); 66 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 67 talloc_free(r); 68 return false; 69 } 70 71 blob = ndr_push_blob(push); 72 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 73 talloc_free(r); 74 return false; 75 } 76 77 talloc_free(r); 78 79 return true; 80} 81 82static bool api_PNP_Connect(pipes_struct *p) 83{ 84 const struct ndr_interface_call *call; 85 struct ndr_pull *pull; 86 struct ndr_push *push; 87 enum ndr_err_code ndr_err; 88 DATA_BLOB blob; 89 struct PNP_Connect *r; 90 91 call = &ndr_table_ntsvcs.calls[NDR_PNP_CONNECT]; 92 93 r = talloc(talloc_tos(), struct PNP_Connect); 94 if (r == NULL) { 95 return false; 96 } 97 98 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 99 talloc_free(r); 100 return false; 101 } 102 103 pull = ndr_pull_init_blob(&blob, r, NULL); 104 if (pull == NULL) { 105 talloc_free(r); 106 return false; 107 } 108 109 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 110 ndr_err = call->ndr_pull(pull, NDR_IN, r); 111 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 112 talloc_free(r); 113 return false; 114 } 115 116 if (DEBUGLEVEL >= 10) { 117 NDR_PRINT_IN_DEBUG(PNP_Connect, r); 118 } 119 120 r->out.result = _PNP_Connect(p, r); 121 122 if (p->rng_fault_state) { 123 talloc_free(r); 124 /* Return true here, srv_pipe_hnd.c will take care */ 125 return true; 126 } 127 128 if (DEBUGLEVEL >= 10) { 129 NDR_PRINT_OUT_DEBUG(PNP_Connect, r); 130 } 131 132 push = ndr_push_init_ctx(r, NULL); 133 if (push == NULL) { 134 talloc_free(r); 135 return false; 136 } 137 138 ndr_err = call->ndr_push(push, NDR_OUT, r); 139 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 140 talloc_free(r); 141 return false; 142 } 143 144 blob = ndr_push_blob(push); 145 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 146 talloc_free(r); 147 return false; 148 } 149 150 talloc_free(r); 151 152 return true; 153} 154 155static bool api_PNP_GetVersion(pipes_struct *p) 156{ 157 const struct ndr_interface_call *call; 158 struct ndr_pull *pull; 159 struct ndr_push *push; 160 enum ndr_err_code ndr_err; 161 DATA_BLOB blob; 162 struct PNP_GetVersion *r; 163 164 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETVERSION]; 165 166 r = talloc(talloc_tos(), struct PNP_GetVersion); 167 if (r == NULL) { 168 return false; 169 } 170 171 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 172 talloc_free(r); 173 return false; 174 } 175 176 pull = ndr_pull_init_blob(&blob, r, NULL); 177 if (pull == NULL) { 178 talloc_free(r); 179 return false; 180 } 181 182 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 183 ndr_err = call->ndr_pull(pull, NDR_IN, r); 184 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 185 talloc_free(r); 186 return false; 187 } 188 189 if (DEBUGLEVEL >= 10) { 190 NDR_PRINT_IN_DEBUG(PNP_GetVersion, r); 191 } 192 193 ZERO_STRUCT(r->out); 194 r->out.version = talloc_zero(r, uint16_t); 195 if (r->out.version == NULL) { 196 talloc_free(r); 197 return false; 198 } 199 200 r->out.result = _PNP_GetVersion(p, r); 201 202 if (p->rng_fault_state) { 203 talloc_free(r); 204 /* Return true here, srv_pipe_hnd.c will take care */ 205 return true; 206 } 207 208 if (DEBUGLEVEL >= 10) { 209 NDR_PRINT_OUT_DEBUG(PNP_GetVersion, r); 210 } 211 212 push = ndr_push_init_ctx(r, NULL); 213 if (push == NULL) { 214 talloc_free(r); 215 return false; 216 } 217 218 ndr_err = call->ndr_push(push, NDR_OUT, r); 219 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 220 talloc_free(r); 221 return false; 222 } 223 224 blob = ndr_push_blob(push); 225 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 226 talloc_free(r); 227 return false; 228 } 229 230 talloc_free(r); 231 232 return true; 233} 234 235static bool api_PNP_GetGlobalState(pipes_struct *p) 236{ 237 const struct ndr_interface_call *call; 238 struct ndr_pull *pull; 239 struct ndr_push *push; 240 enum ndr_err_code ndr_err; 241 DATA_BLOB blob; 242 struct PNP_GetGlobalState *r; 243 244 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETGLOBALSTATE]; 245 246 r = talloc(talloc_tos(), struct PNP_GetGlobalState); 247 if (r == NULL) { 248 return false; 249 } 250 251 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 252 talloc_free(r); 253 return false; 254 } 255 256 pull = ndr_pull_init_blob(&blob, r, NULL); 257 if (pull == NULL) { 258 talloc_free(r); 259 return false; 260 } 261 262 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 263 ndr_err = call->ndr_pull(pull, NDR_IN, r); 264 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 265 talloc_free(r); 266 return false; 267 } 268 269 if (DEBUGLEVEL >= 10) { 270 NDR_PRINT_IN_DEBUG(PNP_GetGlobalState, r); 271 } 272 273 r->out.result = _PNP_GetGlobalState(p, r); 274 275 if (p->rng_fault_state) { 276 talloc_free(r); 277 /* Return true here, srv_pipe_hnd.c will take care */ 278 return true; 279 } 280 281 if (DEBUGLEVEL >= 10) { 282 NDR_PRINT_OUT_DEBUG(PNP_GetGlobalState, r); 283 } 284 285 push = ndr_push_init_ctx(r, NULL); 286 if (push == NULL) { 287 talloc_free(r); 288 return false; 289 } 290 291 ndr_err = call->ndr_push(push, NDR_OUT, r); 292 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 293 talloc_free(r); 294 return false; 295 } 296 297 blob = ndr_push_blob(push); 298 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 299 talloc_free(r); 300 return false; 301 } 302 303 talloc_free(r); 304 305 return true; 306} 307 308static bool api_PNP_InitDetection(pipes_struct *p) 309{ 310 const struct ndr_interface_call *call; 311 struct ndr_pull *pull; 312 struct ndr_push *push; 313 enum ndr_err_code ndr_err; 314 DATA_BLOB blob; 315 struct PNP_InitDetection *r; 316 317 call = &ndr_table_ntsvcs.calls[NDR_PNP_INITDETECTION]; 318 319 r = talloc(talloc_tos(), struct PNP_InitDetection); 320 if (r == NULL) { 321 return false; 322 } 323 324 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 325 talloc_free(r); 326 return false; 327 } 328 329 pull = ndr_pull_init_blob(&blob, r, NULL); 330 if (pull == NULL) { 331 talloc_free(r); 332 return false; 333 } 334 335 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 336 ndr_err = call->ndr_pull(pull, NDR_IN, r); 337 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 338 talloc_free(r); 339 return false; 340 } 341 342 if (DEBUGLEVEL >= 10) { 343 NDR_PRINT_IN_DEBUG(PNP_InitDetection, r); 344 } 345 346 r->out.result = _PNP_InitDetection(p, r); 347 348 if (p->rng_fault_state) { 349 talloc_free(r); 350 /* Return true here, srv_pipe_hnd.c will take care */ 351 return true; 352 } 353 354 if (DEBUGLEVEL >= 10) { 355 NDR_PRINT_OUT_DEBUG(PNP_InitDetection, r); 356 } 357 358 push = ndr_push_init_ctx(r, NULL); 359 if (push == NULL) { 360 talloc_free(r); 361 return false; 362 } 363 364 ndr_err = call->ndr_push(push, NDR_OUT, r); 365 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 366 talloc_free(r); 367 return false; 368 } 369 370 blob = ndr_push_blob(push); 371 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 372 talloc_free(r); 373 return false; 374 } 375 376 talloc_free(r); 377 378 return true; 379} 380 381static bool api_PNP_ReportLogOn(pipes_struct *p) 382{ 383 const struct ndr_interface_call *call; 384 struct ndr_pull *pull; 385 struct ndr_push *push; 386 enum ndr_err_code ndr_err; 387 DATA_BLOB blob; 388 struct PNP_ReportLogOn *r; 389 390 call = &ndr_table_ntsvcs.calls[NDR_PNP_REPORTLOGON]; 391 392 r = talloc(talloc_tos(), struct PNP_ReportLogOn); 393 if (r == NULL) { 394 return false; 395 } 396 397 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 398 talloc_free(r); 399 return false; 400 } 401 402 pull = ndr_pull_init_blob(&blob, r, NULL); 403 if (pull == NULL) { 404 talloc_free(r); 405 return false; 406 } 407 408 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 409 ndr_err = call->ndr_pull(pull, NDR_IN, r); 410 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 411 talloc_free(r); 412 return false; 413 } 414 415 if (DEBUGLEVEL >= 10) { 416 NDR_PRINT_IN_DEBUG(PNP_ReportLogOn, r); 417 } 418 419 r->out.result = _PNP_ReportLogOn(p, r); 420 421 if (p->rng_fault_state) { 422 talloc_free(r); 423 /* Return true here, srv_pipe_hnd.c will take care */ 424 return true; 425 } 426 427 if (DEBUGLEVEL >= 10) { 428 NDR_PRINT_OUT_DEBUG(PNP_ReportLogOn, r); 429 } 430 431 push = ndr_push_init_ctx(r, NULL); 432 if (push == NULL) { 433 talloc_free(r); 434 return false; 435 } 436 437 ndr_err = call->ndr_push(push, NDR_OUT, r); 438 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 439 talloc_free(r); 440 return false; 441 } 442 443 blob = ndr_push_blob(push); 444 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 445 talloc_free(r); 446 return false; 447 } 448 449 talloc_free(r); 450 451 return true; 452} 453 454static bool api_PNP_ValidateDeviceInstance(pipes_struct *p) 455{ 456 const struct ndr_interface_call *call; 457 struct ndr_pull *pull; 458 struct ndr_push *push; 459 enum ndr_err_code ndr_err; 460 DATA_BLOB blob; 461 struct PNP_ValidateDeviceInstance *r; 462 463 call = &ndr_table_ntsvcs.calls[NDR_PNP_VALIDATEDEVICEINSTANCE]; 464 465 r = talloc(talloc_tos(), struct PNP_ValidateDeviceInstance); 466 if (r == NULL) { 467 return false; 468 } 469 470 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 471 talloc_free(r); 472 return false; 473 } 474 475 pull = ndr_pull_init_blob(&blob, r, NULL); 476 if (pull == NULL) { 477 talloc_free(r); 478 return false; 479 } 480 481 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 482 ndr_err = call->ndr_pull(pull, NDR_IN, r); 483 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 484 talloc_free(r); 485 return false; 486 } 487 488 if (DEBUGLEVEL >= 10) { 489 NDR_PRINT_IN_DEBUG(PNP_ValidateDeviceInstance, r); 490 } 491 492 r->out.result = _PNP_ValidateDeviceInstance(p, r); 493 494 if (p->rng_fault_state) { 495 talloc_free(r); 496 /* Return true here, srv_pipe_hnd.c will take care */ 497 return true; 498 } 499 500 if (DEBUGLEVEL >= 10) { 501 NDR_PRINT_OUT_DEBUG(PNP_ValidateDeviceInstance, r); 502 } 503 504 push = ndr_push_init_ctx(r, NULL); 505 if (push == NULL) { 506 talloc_free(r); 507 return false; 508 } 509 510 ndr_err = call->ndr_push(push, NDR_OUT, r); 511 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 512 talloc_free(r); 513 return false; 514 } 515 516 blob = ndr_push_blob(push); 517 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 518 talloc_free(r); 519 return false; 520 } 521 522 talloc_free(r); 523 524 return true; 525} 526 527static bool api_PNP_GetRootDeviceInstance(pipes_struct *p) 528{ 529 const struct ndr_interface_call *call; 530 struct ndr_pull *pull; 531 struct ndr_push *push; 532 enum ndr_err_code ndr_err; 533 DATA_BLOB blob; 534 struct PNP_GetRootDeviceInstance *r; 535 536 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETROOTDEVICEINSTANCE]; 537 538 r = talloc(talloc_tos(), struct PNP_GetRootDeviceInstance); 539 if (r == NULL) { 540 return false; 541 } 542 543 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 544 talloc_free(r); 545 return false; 546 } 547 548 pull = ndr_pull_init_blob(&blob, r, NULL); 549 if (pull == NULL) { 550 talloc_free(r); 551 return false; 552 } 553 554 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 555 ndr_err = call->ndr_pull(pull, NDR_IN, r); 556 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 557 talloc_free(r); 558 return false; 559 } 560 561 if (DEBUGLEVEL >= 10) { 562 NDR_PRINT_IN_DEBUG(PNP_GetRootDeviceInstance, r); 563 } 564 565 r->out.result = _PNP_GetRootDeviceInstance(p, r); 566 567 if (p->rng_fault_state) { 568 talloc_free(r); 569 /* Return true here, srv_pipe_hnd.c will take care */ 570 return true; 571 } 572 573 if (DEBUGLEVEL >= 10) { 574 NDR_PRINT_OUT_DEBUG(PNP_GetRootDeviceInstance, r); 575 } 576 577 push = ndr_push_init_ctx(r, NULL); 578 if (push == NULL) { 579 talloc_free(r); 580 return false; 581 } 582 583 ndr_err = call->ndr_push(push, NDR_OUT, r); 584 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 585 talloc_free(r); 586 return false; 587 } 588 589 blob = ndr_push_blob(push); 590 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 591 talloc_free(r); 592 return false; 593 } 594 595 talloc_free(r); 596 597 return true; 598} 599 600static bool api_PNP_GetRelatedDeviceInstance(pipes_struct *p) 601{ 602 const struct ndr_interface_call *call; 603 struct ndr_pull *pull; 604 struct ndr_push *push; 605 enum ndr_err_code ndr_err; 606 DATA_BLOB blob; 607 struct PNP_GetRelatedDeviceInstance *r; 608 609 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETRELATEDDEVICEINSTANCE]; 610 611 r = talloc(talloc_tos(), struct PNP_GetRelatedDeviceInstance); 612 if (r == NULL) { 613 return false; 614 } 615 616 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 617 talloc_free(r); 618 return false; 619 } 620 621 pull = ndr_pull_init_blob(&blob, r, NULL); 622 if (pull == NULL) { 623 talloc_free(r); 624 return false; 625 } 626 627 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 628 ndr_err = call->ndr_pull(pull, NDR_IN, r); 629 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 630 talloc_free(r); 631 return false; 632 } 633 634 if (DEBUGLEVEL >= 10) { 635 NDR_PRINT_IN_DEBUG(PNP_GetRelatedDeviceInstance, r); 636 } 637 638 r->out.result = _PNP_GetRelatedDeviceInstance(p, r); 639 640 if (p->rng_fault_state) { 641 talloc_free(r); 642 /* Return true here, srv_pipe_hnd.c will take care */ 643 return true; 644 } 645 646 if (DEBUGLEVEL >= 10) { 647 NDR_PRINT_OUT_DEBUG(PNP_GetRelatedDeviceInstance, r); 648 } 649 650 push = ndr_push_init_ctx(r, NULL); 651 if (push == NULL) { 652 talloc_free(r); 653 return false; 654 } 655 656 ndr_err = call->ndr_push(push, NDR_OUT, r); 657 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 658 talloc_free(r); 659 return false; 660 } 661 662 blob = ndr_push_blob(push); 663 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 664 talloc_free(r); 665 return false; 666 } 667 668 talloc_free(r); 669 670 return true; 671} 672 673static bool api_PNP_EnumerateSubKeys(pipes_struct *p) 674{ 675 const struct ndr_interface_call *call; 676 struct ndr_pull *pull; 677 struct ndr_push *push; 678 enum ndr_err_code ndr_err; 679 DATA_BLOB blob; 680 struct PNP_EnumerateSubKeys *r; 681 682 call = &ndr_table_ntsvcs.calls[NDR_PNP_ENUMERATESUBKEYS]; 683 684 r = talloc(talloc_tos(), struct PNP_EnumerateSubKeys); 685 if (r == NULL) { 686 return false; 687 } 688 689 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 690 talloc_free(r); 691 return false; 692 } 693 694 pull = ndr_pull_init_blob(&blob, r, NULL); 695 if (pull == NULL) { 696 talloc_free(r); 697 return false; 698 } 699 700 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 701 ndr_err = call->ndr_pull(pull, NDR_IN, r); 702 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 703 talloc_free(r); 704 return false; 705 } 706 707 if (DEBUGLEVEL >= 10) { 708 NDR_PRINT_IN_DEBUG(PNP_EnumerateSubKeys, r); 709 } 710 711 r->out.result = _PNP_EnumerateSubKeys(p, r); 712 713 if (p->rng_fault_state) { 714 talloc_free(r); 715 /* Return true here, srv_pipe_hnd.c will take care */ 716 return true; 717 } 718 719 if (DEBUGLEVEL >= 10) { 720 NDR_PRINT_OUT_DEBUG(PNP_EnumerateSubKeys, r); 721 } 722 723 push = ndr_push_init_ctx(r, NULL); 724 if (push == NULL) { 725 talloc_free(r); 726 return false; 727 } 728 729 ndr_err = call->ndr_push(push, NDR_OUT, r); 730 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 731 talloc_free(r); 732 return false; 733 } 734 735 blob = ndr_push_blob(push); 736 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 737 talloc_free(r); 738 return false; 739 } 740 741 talloc_free(r); 742 743 return true; 744} 745 746static bool api_PNP_GetDeviceList(pipes_struct *p) 747{ 748 const struct ndr_interface_call *call; 749 struct ndr_pull *pull; 750 struct ndr_push *push; 751 enum ndr_err_code ndr_err; 752 DATA_BLOB blob; 753 struct PNP_GetDeviceList *r; 754 755 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETDEVICELIST]; 756 757 r = talloc(talloc_tos(), struct PNP_GetDeviceList); 758 if (r == NULL) { 759 return false; 760 } 761 762 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 763 talloc_free(r); 764 return false; 765 } 766 767 pull = ndr_pull_init_blob(&blob, r, NULL); 768 if (pull == NULL) { 769 talloc_free(r); 770 return false; 771 } 772 773 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 774 ndr_err = call->ndr_pull(pull, NDR_IN, r); 775 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 776 talloc_free(r); 777 return false; 778 } 779 780 if (DEBUGLEVEL >= 10) { 781 NDR_PRINT_IN_DEBUG(PNP_GetDeviceList, r); 782 } 783 784 ZERO_STRUCT(r->out); 785 r->out.length = r->in.length; 786 r->out.buffer = talloc_zero_array(r, uint16_t, *r->out.length); 787 if (r->out.buffer == NULL) { 788 talloc_free(r); 789 return false; 790 } 791 792 r->out.result = _PNP_GetDeviceList(p, r); 793 794 if (p->rng_fault_state) { 795 talloc_free(r); 796 /* Return true here, srv_pipe_hnd.c will take care */ 797 return true; 798 } 799 800 if (DEBUGLEVEL >= 10) { 801 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceList, r); 802 } 803 804 push = ndr_push_init_ctx(r, NULL); 805 if (push == NULL) { 806 talloc_free(r); 807 return false; 808 } 809 810 ndr_err = call->ndr_push(push, NDR_OUT, r); 811 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 812 talloc_free(r); 813 return false; 814 } 815 816 blob = ndr_push_blob(push); 817 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 818 talloc_free(r); 819 return false; 820 } 821 822 talloc_free(r); 823 824 return true; 825} 826 827static bool api_PNP_GetDeviceListSize(pipes_struct *p) 828{ 829 const struct ndr_interface_call *call; 830 struct ndr_pull *pull; 831 struct ndr_push *push; 832 enum ndr_err_code ndr_err; 833 DATA_BLOB blob; 834 struct PNP_GetDeviceListSize *r; 835 836 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETDEVICELISTSIZE]; 837 838 r = talloc(talloc_tos(), struct PNP_GetDeviceListSize); 839 if (r == NULL) { 840 return false; 841 } 842 843 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 844 talloc_free(r); 845 return false; 846 } 847 848 pull = ndr_pull_init_blob(&blob, r, NULL); 849 if (pull == NULL) { 850 talloc_free(r); 851 return false; 852 } 853 854 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 855 ndr_err = call->ndr_pull(pull, NDR_IN, r); 856 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 857 talloc_free(r); 858 return false; 859 } 860 861 if (DEBUGLEVEL >= 10) { 862 NDR_PRINT_IN_DEBUG(PNP_GetDeviceListSize, r); 863 } 864 865 ZERO_STRUCT(r->out); 866 r->out.size = talloc_zero(r, uint32_t); 867 if (r->out.size == NULL) { 868 talloc_free(r); 869 return false; 870 } 871 872 r->out.result = _PNP_GetDeviceListSize(p, r); 873 874 if (p->rng_fault_state) { 875 talloc_free(r); 876 /* Return true here, srv_pipe_hnd.c will take care */ 877 return true; 878 } 879 880 if (DEBUGLEVEL >= 10) { 881 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceListSize, r); 882 } 883 884 push = ndr_push_init_ctx(r, NULL); 885 if (push == NULL) { 886 talloc_free(r); 887 return false; 888 } 889 890 ndr_err = call->ndr_push(push, NDR_OUT, r); 891 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 892 talloc_free(r); 893 return false; 894 } 895 896 blob = ndr_push_blob(push); 897 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 898 talloc_free(r); 899 return false; 900 } 901 902 talloc_free(r); 903 904 return true; 905} 906 907static bool api_PNP_GetDepth(pipes_struct *p) 908{ 909 const struct ndr_interface_call *call; 910 struct ndr_pull *pull; 911 struct ndr_push *push; 912 enum ndr_err_code ndr_err; 913 DATA_BLOB blob; 914 struct PNP_GetDepth *r; 915 916 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETDEPTH]; 917 918 r = talloc(talloc_tos(), struct PNP_GetDepth); 919 if (r == NULL) { 920 return false; 921 } 922 923 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 924 talloc_free(r); 925 return false; 926 } 927 928 pull = ndr_pull_init_blob(&blob, r, NULL); 929 if (pull == NULL) { 930 talloc_free(r); 931 return false; 932 } 933 934 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 935 ndr_err = call->ndr_pull(pull, NDR_IN, r); 936 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 937 talloc_free(r); 938 return false; 939 } 940 941 if (DEBUGLEVEL >= 10) { 942 NDR_PRINT_IN_DEBUG(PNP_GetDepth, r); 943 } 944 945 r->out.result = _PNP_GetDepth(p, r); 946 947 if (p->rng_fault_state) { 948 talloc_free(r); 949 /* Return true here, srv_pipe_hnd.c will take care */ 950 return true; 951 } 952 953 if (DEBUGLEVEL >= 10) { 954 NDR_PRINT_OUT_DEBUG(PNP_GetDepth, r); 955 } 956 957 push = ndr_push_init_ctx(r, NULL); 958 if (push == NULL) { 959 talloc_free(r); 960 return false; 961 } 962 963 ndr_err = call->ndr_push(push, NDR_OUT, r); 964 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 965 talloc_free(r); 966 return false; 967 } 968 969 blob = ndr_push_blob(push); 970 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 971 talloc_free(r); 972 return false; 973 } 974 975 talloc_free(r); 976 977 return true; 978} 979 980static bool api_PNP_GetDeviceRegProp(pipes_struct *p) 981{ 982 const struct ndr_interface_call *call; 983 struct ndr_pull *pull; 984 struct ndr_push *push; 985 enum ndr_err_code ndr_err; 986 DATA_BLOB blob; 987 struct PNP_GetDeviceRegProp *r; 988 989 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETDEVICEREGPROP]; 990 991 r = talloc(talloc_tos(), struct PNP_GetDeviceRegProp); 992 if (r == NULL) { 993 return false; 994 } 995 996 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 997 talloc_free(r); 998 return false; 999 } 1000 1001 pull = ndr_pull_init_blob(&blob, r, NULL); 1002 if (pull == NULL) { 1003 talloc_free(r); 1004 return false; 1005 } 1006 1007 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1008 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1009 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1010 talloc_free(r); 1011 return false; 1012 } 1013 1014 if (DEBUGLEVEL >= 10) { 1015 NDR_PRINT_IN_DEBUG(PNP_GetDeviceRegProp, r); 1016 } 1017 1018 ZERO_STRUCT(r->out); 1019 r->out.reg_data_type = r->in.reg_data_type; 1020 r->out.buffer_size = r->in.buffer_size; 1021 r->out.needed = r->in.needed; 1022 r->out.buffer = talloc_zero_array(r, uint8_t, *r->out.buffer_size); 1023 if (r->out.buffer == NULL) { 1024 talloc_free(r); 1025 return false; 1026 } 1027 1028 r->out.result = _PNP_GetDeviceRegProp(p, r); 1029 1030 if (p->rng_fault_state) { 1031 talloc_free(r); 1032 /* Return true here, srv_pipe_hnd.c will take care */ 1033 return true; 1034 } 1035 1036 if (DEBUGLEVEL >= 10) { 1037 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceRegProp, r); 1038 } 1039 1040 push = ndr_push_init_ctx(r, NULL); 1041 if (push == NULL) { 1042 talloc_free(r); 1043 return false; 1044 } 1045 1046 ndr_err = call->ndr_push(push, NDR_OUT, r); 1047 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1048 talloc_free(r); 1049 return false; 1050 } 1051 1052 blob = ndr_push_blob(push); 1053 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1054 talloc_free(r); 1055 return false; 1056 } 1057 1058 talloc_free(r); 1059 1060 return true; 1061} 1062 1063static bool api_PNP_SetDeviceRegProp(pipes_struct *p) 1064{ 1065 const struct ndr_interface_call *call; 1066 struct ndr_pull *pull; 1067 struct ndr_push *push; 1068 enum ndr_err_code ndr_err; 1069 DATA_BLOB blob; 1070 struct PNP_SetDeviceRegProp *r; 1071 1072 call = &ndr_table_ntsvcs.calls[NDR_PNP_SETDEVICEREGPROP]; 1073 1074 r = talloc(talloc_tos(), struct PNP_SetDeviceRegProp); 1075 if (r == NULL) { 1076 return false; 1077 } 1078 1079 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1080 talloc_free(r); 1081 return false; 1082 } 1083 1084 pull = ndr_pull_init_blob(&blob, r, NULL); 1085 if (pull == NULL) { 1086 talloc_free(r); 1087 return false; 1088 } 1089 1090 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1091 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1092 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1093 talloc_free(r); 1094 return false; 1095 } 1096 1097 if (DEBUGLEVEL >= 10) { 1098 NDR_PRINT_IN_DEBUG(PNP_SetDeviceRegProp, r); 1099 } 1100 1101 r->out.result = _PNP_SetDeviceRegProp(p, r); 1102 1103 if (p->rng_fault_state) { 1104 talloc_free(r); 1105 /* Return true here, srv_pipe_hnd.c will take care */ 1106 return true; 1107 } 1108 1109 if (DEBUGLEVEL >= 10) { 1110 NDR_PRINT_OUT_DEBUG(PNP_SetDeviceRegProp, r); 1111 } 1112 1113 push = ndr_push_init_ctx(r, NULL); 1114 if (push == NULL) { 1115 talloc_free(r); 1116 return false; 1117 } 1118 1119 ndr_err = call->ndr_push(push, NDR_OUT, r); 1120 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1121 talloc_free(r); 1122 return false; 1123 } 1124 1125 blob = ndr_push_blob(push); 1126 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1127 talloc_free(r); 1128 return false; 1129 } 1130 1131 talloc_free(r); 1132 1133 return true; 1134} 1135 1136static bool api_PNP_GetClassInstance(pipes_struct *p) 1137{ 1138 const struct ndr_interface_call *call; 1139 struct ndr_pull *pull; 1140 struct ndr_push *push; 1141 enum ndr_err_code ndr_err; 1142 DATA_BLOB blob; 1143 struct PNP_GetClassInstance *r; 1144 1145 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCLASSINSTANCE]; 1146 1147 r = talloc(talloc_tos(), struct PNP_GetClassInstance); 1148 if (r == NULL) { 1149 return false; 1150 } 1151 1152 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1153 talloc_free(r); 1154 return false; 1155 } 1156 1157 pull = ndr_pull_init_blob(&blob, r, NULL); 1158 if (pull == NULL) { 1159 talloc_free(r); 1160 return false; 1161 } 1162 1163 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1164 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1165 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1166 talloc_free(r); 1167 return false; 1168 } 1169 1170 if (DEBUGLEVEL >= 10) { 1171 NDR_PRINT_IN_DEBUG(PNP_GetClassInstance, r); 1172 } 1173 1174 r->out.result = _PNP_GetClassInstance(p, r); 1175 1176 if (p->rng_fault_state) { 1177 talloc_free(r); 1178 /* Return true here, srv_pipe_hnd.c will take care */ 1179 return true; 1180 } 1181 1182 if (DEBUGLEVEL >= 10) { 1183 NDR_PRINT_OUT_DEBUG(PNP_GetClassInstance, r); 1184 } 1185 1186 push = ndr_push_init_ctx(r, NULL); 1187 if (push == NULL) { 1188 talloc_free(r); 1189 return false; 1190 } 1191 1192 ndr_err = call->ndr_push(push, NDR_OUT, r); 1193 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1194 talloc_free(r); 1195 return false; 1196 } 1197 1198 blob = ndr_push_blob(push); 1199 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1200 talloc_free(r); 1201 return false; 1202 } 1203 1204 talloc_free(r); 1205 1206 return true; 1207} 1208 1209static bool api_PNP_CreateKey(pipes_struct *p) 1210{ 1211 const struct ndr_interface_call *call; 1212 struct ndr_pull *pull; 1213 struct ndr_push *push; 1214 enum ndr_err_code ndr_err; 1215 DATA_BLOB blob; 1216 struct PNP_CreateKey *r; 1217 1218 call = &ndr_table_ntsvcs.calls[NDR_PNP_CREATEKEY]; 1219 1220 r = talloc(talloc_tos(), struct PNP_CreateKey); 1221 if (r == NULL) { 1222 return false; 1223 } 1224 1225 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1226 talloc_free(r); 1227 return false; 1228 } 1229 1230 pull = ndr_pull_init_blob(&blob, r, NULL); 1231 if (pull == NULL) { 1232 talloc_free(r); 1233 return false; 1234 } 1235 1236 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1237 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1238 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1239 talloc_free(r); 1240 return false; 1241 } 1242 1243 if (DEBUGLEVEL >= 10) { 1244 NDR_PRINT_IN_DEBUG(PNP_CreateKey, r); 1245 } 1246 1247 r->out.result = _PNP_CreateKey(p, r); 1248 1249 if (p->rng_fault_state) { 1250 talloc_free(r); 1251 /* Return true here, srv_pipe_hnd.c will take care */ 1252 return true; 1253 } 1254 1255 if (DEBUGLEVEL >= 10) { 1256 NDR_PRINT_OUT_DEBUG(PNP_CreateKey, r); 1257 } 1258 1259 push = ndr_push_init_ctx(r, NULL); 1260 if (push == NULL) { 1261 talloc_free(r); 1262 return false; 1263 } 1264 1265 ndr_err = call->ndr_push(push, NDR_OUT, r); 1266 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1267 talloc_free(r); 1268 return false; 1269 } 1270 1271 blob = ndr_push_blob(push); 1272 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1273 talloc_free(r); 1274 return false; 1275 } 1276 1277 talloc_free(r); 1278 1279 return true; 1280} 1281 1282static bool api_PNP_DeleteRegistryKey(pipes_struct *p) 1283{ 1284 const struct ndr_interface_call *call; 1285 struct ndr_pull *pull; 1286 struct ndr_push *push; 1287 enum ndr_err_code ndr_err; 1288 DATA_BLOB blob; 1289 struct PNP_DeleteRegistryKey *r; 1290 1291 call = &ndr_table_ntsvcs.calls[NDR_PNP_DELETEREGISTRYKEY]; 1292 1293 r = talloc(talloc_tos(), struct PNP_DeleteRegistryKey); 1294 if (r == NULL) { 1295 return false; 1296 } 1297 1298 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1299 talloc_free(r); 1300 return false; 1301 } 1302 1303 pull = ndr_pull_init_blob(&blob, r, NULL); 1304 if (pull == NULL) { 1305 talloc_free(r); 1306 return false; 1307 } 1308 1309 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1310 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1311 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1312 talloc_free(r); 1313 return false; 1314 } 1315 1316 if (DEBUGLEVEL >= 10) { 1317 NDR_PRINT_IN_DEBUG(PNP_DeleteRegistryKey, r); 1318 } 1319 1320 r->out.result = _PNP_DeleteRegistryKey(p, r); 1321 1322 if (p->rng_fault_state) { 1323 talloc_free(r); 1324 /* Return true here, srv_pipe_hnd.c will take care */ 1325 return true; 1326 } 1327 1328 if (DEBUGLEVEL >= 10) { 1329 NDR_PRINT_OUT_DEBUG(PNP_DeleteRegistryKey, r); 1330 } 1331 1332 push = ndr_push_init_ctx(r, NULL); 1333 if (push == NULL) { 1334 talloc_free(r); 1335 return false; 1336 } 1337 1338 ndr_err = call->ndr_push(push, NDR_OUT, r); 1339 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1340 talloc_free(r); 1341 return false; 1342 } 1343 1344 blob = ndr_push_blob(push); 1345 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1346 talloc_free(r); 1347 return false; 1348 } 1349 1350 talloc_free(r); 1351 1352 return true; 1353} 1354 1355static bool api_PNP_GetClassCount(pipes_struct *p) 1356{ 1357 const struct ndr_interface_call *call; 1358 struct ndr_pull *pull; 1359 struct ndr_push *push; 1360 enum ndr_err_code ndr_err; 1361 DATA_BLOB blob; 1362 struct PNP_GetClassCount *r; 1363 1364 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCLASSCOUNT]; 1365 1366 r = talloc(talloc_tos(), struct PNP_GetClassCount); 1367 if (r == NULL) { 1368 return false; 1369 } 1370 1371 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1372 talloc_free(r); 1373 return false; 1374 } 1375 1376 pull = ndr_pull_init_blob(&blob, r, NULL); 1377 if (pull == NULL) { 1378 talloc_free(r); 1379 return false; 1380 } 1381 1382 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1383 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1384 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1385 talloc_free(r); 1386 return false; 1387 } 1388 1389 if (DEBUGLEVEL >= 10) { 1390 NDR_PRINT_IN_DEBUG(PNP_GetClassCount, r); 1391 } 1392 1393 r->out.result = _PNP_GetClassCount(p, r); 1394 1395 if (p->rng_fault_state) { 1396 talloc_free(r); 1397 /* Return true here, srv_pipe_hnd.c will take care */ 1398 return true; 1399 } 1400 1401 if (DEBUGLEVEL >= 10) { 1402 NDR_PRINT_OUT_DEBUG(PNP_GetClassCount, r); 1403 } 1404 1405 push = ndr_push_init_ctx(r, NULL); 1406 if (push == NULL) { 1407 talloc_free(r); 1408 return false; 1409 } 1410 1411 ndr_err = call->ndr_push(push, NDR_OUT, r); 1412 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1413 talloc_free(r); 1414 return false; 1415 } 1416 1417 blob = ndr_push_blob(push); 1418 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1419 talloc_free(r); 1420 return false; 1421 } 1422 1423 talloc_free(r); 1424 1425 return true; 1426} 1427 1428static bool api_PNP_GetClassName(pipes_struct *p) 1429{ 1430 const struct ndr_interface_call *call; 1431 struct ndr_pull *pull; 1432 struct ndr_push *push; 1433 enum ndr_err_code ndr_err; 1434 DATA_BLOB blob; 1435 struct PNP_GetClassName *r; 1436 1437 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCLASSNAME]; 1438 1439 r = talloc(talloc_tos(), struct PNP_GetClassName); 1440 if (r == NULL) { 1441 return false; 1442 } 1443 1444 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1445 talloc_free(r); 1446 return false; 1447 } 1448 1449 pull = ndr_pull_init_blob(&blob, r, NULL); 1450 if (pull == NULL) { 1451 talloc_free(r); 1452 return false; 1453 } 1454 1455 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1456 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1457 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1458 talloc_free(r); 1459 return false; 1460 } 1461 1462 if (DEBUGLEVEL >= 10) { 1463 NDR_PRINT_IN_DEBUG(PNP_GetClassName, r); 1464 } 1465 1466 r->out.result = _PNP_GetClassName(p, r); 1467 1468 if (p->rng_fault_state) { 1469 talloc_free(r); 1470 /* Return true here, srv_pipe_hnd.c will take care */ 1471 return true; 1472 } 1473 1474 if (DEBUGLEVEL >= 10) { 1475 NDR_PRINT_OUT_DEBUG(PNP_GetClassName, r); 1476 } 1477 1478 push = ndr_push_init_ctx(r, NULL); 1479 if (push == NULL) { 1480 talloc_free(r); 1481 return false; 1482 } 1483 1484 ndr_err = call->ndr_push(push, NDR_OUT, r); 1485 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1486 talloc_free(r); 1487 return false; 1488 } 1489 1490 blob = ndr_push_blob(push); 1491 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1492 talloc_free(r); 1493 return false; 1494 } 1495 1496 talloc_free(r); 1497 1498 return true; 1499} 1500 1501static bool api_PNP_DeleteClassKey(pipes_struct *p) 1502{ 1503 const struct ndr_interface_call *call; 1504 struct ndr_pull *pull; 1505 struct ndr_push *push; 1506 enum ndr_err_code ndr_err; 1507 DATA_BLOB blob; 1508 struct PNP_DeleteClassKey *r; 1509 1510 call = &ndr_table_ntsvcs.calls[NDR_PNP_DELETECLASSKEY]; 1511 1512 r = talloc(talloc_tos(), struct PNP_DeleteClassKey); 1513 if (r == NULL) { 1514 return false; 1515 } 1516 1517 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1518 talloc_free(r); 1519 return false; 1520 } 1521 1522 pull = ndr_pull_init_blob(&blob, r, NULL); 1523 if (pull == NULL) { 1524 talloc_free(r); 1525 return false; 1526 } 1527 1528 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1529 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1530 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1531 talloc_free(r); 1532 return false; 1533 } 1534 1535 if (DEBUGLEVEL >= 10) { 1536 NDR_PRINT_IN_DEBUG(PNP_DeleteClassKey, r); 1537 } 1538 1539 r->out.result = _PNP_DeleteClassKey(p, r); 1540 1541 if (p->rng_fault_state) { 1542 talloc_free(r); 1543 /* Return true here, srv_pipe_hnd.c will take care */ 1544 return true; 1545 } 1546 1547 if (DEBUGLEVEL >= 10) { 1548 NDR_PRINT_OUT_DEBUG(PNP_DeleteClassKey, r); 1549 } 1550 1551 push = ndr_push_init_ctx(r, NULL); 1552 if (push == NULL) { 1553 talloc_free(r); 1554 return false; 1555 } 1556 1557 ndr_err = call->ndr_push(push, NDR_OUT, r); 1558 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1559 talloc_free(r); 1560 return false; 1561 } 1562 1563 blob = ndr_push_blob(push); 1564 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1565 talloc_free(r); 1566 return false; 1567 } 1568 1569 talloc_free(r); 1570 1571 return true; 1572} 1573 1574static bool api_PNP_GetInterfaceDeviceAlias(pipes_struct *p) 1575{ 1576 const struct ndr_interface_call *call; 1577 struct ndr_pull *pull; 1578 struct ndr_push *push; 1579 enum ndr_err_code ndr_err; 1580 DATA_BLOB blob; 1581 struct PNP_GetInterfaceDeviceAlias *r; 1582 1583 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETINTERFACEDEVICEALIAS]; 1584 1585 r = talloc(talloc_tos(), struct PNP_GetInterfaceDeviceAlias); 1586 if (r == NULL) { 1587 return false; 1588 } 1589 1590 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1591 talloc_free(r); 1592 return false; 1593 } 1594 1595 pull = ndr_pull_init_blob(&blob, r, NULL); 1596 if (pull == NULL) { 1597 talloc_free(r); 1598 return false; 1599 } 1600 1601 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1602 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1603 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1604 talloc_free(r); 1605 return false; 1606 } 1607 1608 if (DEBUGLEVEL >= 10) { 1609 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceAlias, r); 1610 } 1611 1612 r->out.result = _PNP_GetInterfaceDeviceAlias(p, r); 1613 1614 if (p->rng_fault_state) { 1615 talloc_free(r); 1616 /* Return true here, srv_pipe_hnd.c will take care */ 1617 return true; 1618 } 1619 1620 if (DEBUGLEVEL >= 10) { 1621 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceAlias, r); 1622 } 1623 1624 push = ndr_push_init_ctx(r, NULL); 1625 if (push == NULL) { 1626 talloc_free(r); 1627 return false; 1628 } 1629 1630 ndr_err = call->ndr_push(push, NDR_OUT, r); 1631 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1632 talloc_free(r); 1633 return false; 1634 } 1635 1636 blob = ndr_push_blob(push); 1637 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1638 talloc_free(r); 1639 return false; 1640 } 1641 1642 talloc_free(r); 1643 1644 return true; 1645} 1646 1647static bool api_PNP_GetInterfaceDeviceList(pipes_struct *p) 1648{ 1649 const struct ndr_interface_call *call; 1650 struct ndr_pull *pull; 1651 struct ndr_push *push; 1652 enum ndr_err_code ndr_err; 1653 DATA_BLOB blob; 1654 struct PNP_GetInterfaceDeviceList *r; 1655 1656 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETINTERFACEDEVICELIST]; 1657 1658 r = talloc(talloc_tos(), struct PNP_GetInterfaceDeviceList); 1659 if (r == NULL) { 1660 return false; 1661 } 1662 1663 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1664 talloc_free(r); 1665 return false; 1666 } 1667 1668 pull = ndr_pull_init_blob(&blob, r, NULL); 1669 if (pull == NULL) { 1670 talloc_free(r); 1671 return false; 1672 } 1673 1674 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1675 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1676 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1677 talloc_free(r); 1678 return false; 1679 } 1680 1681 if (DEBUGLEVEL >= 10) { 1682 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceList, r); 1683 } 1684 1685 r->out.result = _PNP_GetInterfaceDeviceList(p, r); 1686 1687 if (p->rng_fault_state) { 1688 talloc_free(r); 1689 /* Return true here, srv_pipe_hnd.c will take care */ 1690 return true; 1691 } 1692 1693 if (DEBUGLEVEL >= 10) { 1694 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceList, r); 1695 } 1696 1697 push = ndr_push_init_ctx(r, NULL); 1698 if (push == NULL) { 1699 talloc_free(r); 1700 return false; 1701 } 1702 1703 ndr_err = call->ndr_push(push, NDR_OUT, r); 1704 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1705 talloc_free(r); 1706 return false; 1707 } 1708 1709 blob = ndr_push_blob(push); 1710 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1711 talloc_free(r); 1712 return false; 1713 } 1714 1715 talloc_free(r); 1716 1717 return true; 1718} 1719 1720static bool api_PNP_GetInterfaceDeviceListSize(pipes_struct *p) 1721{ 1722 const struct ndr_interface_call *call; 1723 struct ndr_pull *pull; 1724 struct ndr_push *push; 1725 enum ndr_err_code ndr_err; 1726 DATA_BLOB blob; 1727 struct PNP_GetInterfaceDeviceListSize *r; 1728 1729 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETINTERFACEDEVICELISTSIZE]; 1730 1731 r = talloc(talloc_tos(), struct PNP_GetInterfaceDeviceListSize); 1732 if (r == NULL) { 1733 return false; 1734 } 1735 1736 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1737 talloc_free(r); 1738 return false; 1739 } 1740 1741 pull = ndr_pull_init_blob(&blob, r, NULL); 1742 if (pull == NULL) { 1743 talloc_free(r); 1744 return false; 1745 } 1746 1747 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1748 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1749 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1750 talloc_free(r); 1751 return false; 1752 } 1753 1754 if (DEBUGLEVEL >= 10) { 1755 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceListSize, r); 1756 } 1757 1758 r->out.result = _PNP_GetInterfaceDeviceListSize(p, r); 1759 1760 if (p->rng_fault_state) { 1761 talloc_free(r); 1762 /* Return true here, srv_pipe_hnd.c will take care */ 1763 return true; 1764 } 1765 1766 if (DEBUGLEVEL >= 10) { 1767 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceListSize, r); 1768 } 1769 1770 push = ndr_push_init_ctx(r, NULL); 1771 if (push == NULL) { 1772 talloc_free(r); 1773 return false; 1774 } 1775 1776 ndr_err = call->ndr_push(push, NDR_OUT, r); 1777 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1778 talloc_free(r); 1779 return false; 1780 } 1781 1782 blob = ndr_push_blob(push); 1783 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1784 talloc_free(r); 1785 return false; 1786 } 1787 1788 talloc_free(r); 1789 1790 return true; 1791} 1792 1793static bool api_PNP_RegisterDeviceClassAssociation(pipes_struct *p) 1794{ 1795 const struct ndr_interface_call *call; 1796 struct ndr_pull *pull; 1797 struct ndr_push *push; 1798 enum ndr_err_code ndr_err; 1799 DATA_BLOB blob; 1800 struct PNP_RegisterDeviceClassAssociation *r; 1801 1802 call = &ndr_table_ntsvcs.calls[NDR_PNP_REGISTERDEVICECLASSASSOCIATION]; 1803 1804 r = talloc(talloc_tos(), struct PNP_RegisterDeviceClassAssociation); 1805 if (r == NULL) { 1806 return false; 1807 } 1808 1809 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1810 talloc_free(r); 1811 return false; 1812 } 1813 1814 pull = ndr_pull_init_blob(&blob, r, NULL); 1815 if (pull == NULL) { 1816 talloc_free(r); 1817 return false; 1818 } 1819 1820 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1821 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1822 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1823 talloc_free(r); 1824 return false; 1825 } 1826 1827 if (DEBUGLEVEL >= 10) { 1828 NDR_PRINT_IN_DEBUG(PNP_RegisterDeviceClassAssociation, r); 1829 } 1830 1831 r->out.result = _PNP_RegisterDeviceClassAssociation(p, r); 1832 1833 if (p->rng_fault_state) { 1834 talloc_free(r); 1835 /* Return true here, srv_pipe_hnd.c will take care */ 1836 return true; 1837 } 1838 1839 if (DEBUGLEVEL >= 10) { 1840 NDR_PRINT_OUT_DEBUG(PNP_RegisterDeviceClassAssociation, r); 1841 } 1842 1843 push = ndr_push_init_ctx(r, NULL); 1844 if (push == NULL) { 1845 talloc_free(r); 1846 return false; 1847 } 1848 1849 ndr_err = call->ndr_push(push, NDR_OUT, r); 1850 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1851 talloc_free(r); 1852 return false; 1853 } 1854 1855 blob = ndr_push_blob(push); 1856 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1857 talloc_free(r); 1858 return false; 1859 } 1860 1861 talloc_free(r); 1862 1863 return true; 1864} 1865 1866static bool api_PNP_UnregisterDeviceClassAssociation(pipes_struct *p) 1867{ 1868 const struct ndr_interface_call *call; 1869 struct ndr_pull *pull; 1870 struct ndr_push *push; 1871 enum ndr_err_code ndr_err; 1872 DATA_BLOB blob; 1873 struct PNP_UnregisterDeviceClassAssociation *r; 1874 1875 call = &ndr_table_ntsvcs.calls[NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION]; 1876 1877 r = talloc(talloc_tos(), struct PNP_UnregisterDeviceClassAssociation); 1878 if (r == NULL) { 1879 return false; 1880 } 1881 1882 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1883 talloc_free(r); 1884 return false; 1885 } 1886 1887 pull = ndr_pull_init_blob(&blob, r, NULL); 1888 if (pull == NULL) { 1889 talloc_free(r); 1890 return false; 1891 } 1892 1893 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1894 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1895 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1896 talloc_free(r); 1897 return false; 1898 } 1899 1900 if (DEBUGLEVEL >= 10) { 1901 NDR_PRINT_IN_DEBUG(PNP_UnregisterDeviceClassAssociation, r); 1902 } 1903 1904 r->out.result = _PNP_UnregisterDeviceClassAssociation(p, r); 1905 1906 if (p->rng_fault_state) { 1907 talloc_free(r); 1908 /* Return true here, srv_pipe_hnd.c will take care */ 1909 return true; 1910 } 1911 1912 if (DEBUGLEVEL >= 10) { 1913 NDR_PRINT_OUT_DEBUG(PNP_UnregisterDeviceClassAssociation, r); 1914 } 1915 1916 push = ndr_push_init_ctx(r, NULL); 1917 if (push == NULL) { 1918 talloc_free(r); 1919 return false; 1920 } 1921 1922 ndr_err = call->ndr_push(push, NDR_OUT, r); 1923 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1924 talloc_free(r); 1925 return false; 1926 } 1927 1928 blob = ndr_push_blob(push); 1929 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1930 talloc_free(r); 1931 return false; 1932 } 1933 1934 talloc_free(r); 1935 1936 return true; 1937} 1938 1939static bool api_PNP_GetClassRegProp(pipes_struct *p) 1940{ 1941 const struct ndr_interface_call *call; 1942 struct ndr_pull *pull; 1943 struct ndr_push *push; 1944 enum ndr_err_code ndr_err; 1945 DATA_BLOB blob; 1946 struct PNP_GetClassRegProp *r; 1947 1948 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCLASSREGPROP]; 1949 1950 r = talloc(talloc_tos(), struct PNP_GetClassRegProp); 1951 if (r == NULL) { 1952 return false; 1953 } 1954 1955 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1956 talloc_free(r); 1957 return false; 1958 } 1959 1960 pull = ndr_pull_init_blob(&blob, r, NULL); 1961 if (pull == NULL) { 1962 talloc_free(r); 1963 return false; 1964 } 1965 1966 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1967 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1968 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1969 talloc_free(r); 1970 return false; 1971 } 1972 1973 if (DEBUGLEVEL >= 10) { 1974 NDR_PRINT_IN_DEBUG(PNP_GetClassRegProp, r); 1975 } 1976 1977 r->out.result = _PNP_GetClassRegProp(p, r); 1978 1979 if (p->rng_fault_state) { 1980 talloc_free(r); 1981 /* Return true here, srv_pipe_hnd.c will take care */ 1982 return true; 1983 } 1984 1985 if (DEBUGLEVEL >= 10) { 1986 NDR_PRINT_OUT_DEBUG(PNP_GetClassRegProp, r); 1987 } 1988 1989 push = ndr_push_init_ctx(r, NULL); 1990 if (push == NULL) { 1991 talloc_free(r); 1992 return false; 1993 } 1994 1995 ndr_err = call->ndr_push(push, NDR_OUT, r); 1996 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1997 talloc_free(r); 1998 return false; 1999 } 2000 2001 blob = ndr_push_blob(push); 2002 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2003 talloc_free(r); 2004 return false; 2005 } 2006 2007 talloc_free(r); 2008 2009 return true; 2010} 2011 2012static bool api_PNP_SetClassRegProp(pipes_struct *p) 2013{ 2014 const struct ndr_interface_call *call; 2015 struct ndr_pull *pull; 2016 struct ndr_push *push; 2017 enum ndr_err_code ndr_err; 2018 DATA_BLOB blob; 2019 struct PNP_SetClassRegProp *r; 2020 2021 call = &ndr_table_ntsvcs.calls[NDR_PNP_SETCLASSREGPROP]; 2022 2023 r = talloc(talloc_tos(), struct PNP_SetClassRegProp); 2024 if (r == NULL) { 2025 return false; 2026 } 2027 2028 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2029 talloc_free(r); 2030 return false; 2031 } 2032 2033 pull = ndr_pull_init_blob(&blob, r, NULL); 2034 if (pull == NULL) { 2035 talloc_free(r); 2036 return false; 2037 } 2038 2039 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2040 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2041 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2042 talloc_free(r); 2043 return false; 2044 } 2045 2046 if (DEBUGLEVEL >= 10) { 2047 NDR_PRINT_IN_DEBUG(PNP_SetClassRegProp, r); 2048 } 2049 2050 r->out.result = _PNP_SetClassRegProp(p, r); 2051 2052 if (p->rng_fault_state) { 2053 talloc_free(r); 2054 /* Return true here, srv_pipe_hnd.c will take care */ 2055 return true; 2056 } 2057 2058 if (DEBUGLEVEL >= 10) { 2059 NDR_PRINT_OUT_DEBUG(PNP_SetClassRegProp, r); 2060 } 2061 2062 push = ndr_push_init_ctx(r, NULL); 2063 if (push == NULL) { 2064 talloc_free(r); 2065 return false; 2066 } 2067 2068 ndr_err = call->ndr_push(push, NDR_OUT, r); 2069 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2070 talloc_free(r); 2071 return false; 2072 } 2073 2074 blob = ndr_push_blob(push); 2075 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2076 talloc_free(r); 2077 return false; 2078 } 2079 2080 talloc_free(r); 2081 2082 return true; 2083} 2084 2085static bool api_PNP_CreateDevInst(pipes_struct *p) 2086{ 2087 const struct ndr_interface_call *call; 2088 struct ndr_pull *pull; 2089 struct ndr_push *push; 2090 enum ndr_err_code ndr_err; 2091 DATA_BLOB blob; 2092 struct PNP_CreateDevInst *r; 2093 2094 call = &ndr_table_ntsvcs.calls[NDR_PNP_CREATEDEVINST]; 2095 2096 r = talloc(talloc_tos(), struct PNP_CreateDevInst); 2097 if (r == NULL) { 2098 return false; 2099 } 2100 2101 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2102 talloc_free(r); 2103 return false; 2104 } 2105 2106 pull = ndr_pull_init_blob(&blob, r, NULL); 2107 if (pull == NULL) { 2108 talloc_free(r); 2109 return false; 2110 } 2111 2112 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2113 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2114 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2115 talloc_free(r); 2116 return false; 2117 } 2118 2119 if (DEBUGLEVEL >= 10) { 2120 NDR_PRINT_IN_DEBUG(PNP_CreateDevInst, r); 2121 } 2122 2123 r->out.result = _PNP_CreateDevInst(p, r); 2124 2125 if (p->rng_fault_state) { 2126 talloc_free(r); 2127 /* Return true here, srv_pipe_hnd.c will take care */ 2128 return true; 2129 } 2130 2131 if (DEBUGLEVEL >= 10) { 2132 NDR_PRINT_OUT_DEBUG(PNP_CreateDevInst, r); 2133 } 2134 2135 push = ndr_push_init_ctx(r, NULL); 2136 if (push == NULL) { 2137 talloc_free(r); 2138 return false; 2139 } 2140 2141 ndr_err = call->ndr_push(push, NDR_OUT, r); 2142 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2143 talloc_free(r); 2144 return false; 2145 } 2146 2147 blob = ndr_push_blob(push); 2148 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2149 talloc_free(r); 2150 return false; 2151 } 2152 2153 talloc_free(r); 2154 2155 return true; 2156} 2157 2158static bool api_PNP_DeviceInstanceAction(pipes_struct *p) 2159{ 2160 const struct ndr_interface_call *call; 2161 struct ndr_pull *pull; 2162 struct ndr_push *push; 2163 enum ndr_err_code ndr_err; 2164 DATA_BLOB blob; 2165 struct PNP_DeviceInstanceAction *r; 2166 2167 call = &ndr_table_ntsvcs.calls[NDR_PNP_DEVICEINSTANCEACTION]; 2168 2169 r = talloc(talloc_tos(), struct PNP_DeviceInstanceAction); 2170 if (r == NULL) { 2171 return false; 2172 } 2173 2174 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2175 talloc_free(r); 2176 return false; 2177 } 2178 2179 pull = ndr_pull_init_blob(&blob, r, NULL); 2180 if (pull == NULL) { 2181 talloc_free(r); 2182 return false; 2183 } 2184 2185 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2186 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2187 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2188 talloc_free(r); 2189 return false; 2190 } 2191 2192 if (DEBUGLEVEL >= 10) { 2193 NDR_PRINT_IN_DEBUG(PNP_DeviceInstanceAction, r); 2194 } 2195 2196 r->out.result = _PNP_DeviceInstanceAction(p, r); 2197 2198 if (p->rng_fault_state) { 2199 talloc_free(r); 2200 /* Return true here, srv_pipe_hnd.c will take care */ 2201 return true; 2202 } 2203 2204 if (DEBUGLEVEL >= 10) { 2205 NDR_PRINT_OUT_DEBUG(PNP_DeviceInstanceAction, r); 2206 } 2207 2208 push = ndr_push_init_ctx(r, NULL); 2209 if (push == NULL) { 2210 talloc_free(r); 2211 return false; 2212 } 2213 2214 ndr_err = call->ndr_push(push, NDR_OUT, r); 2215 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2216 talloc_free(r); 2217 return false; 2218 } 2219 2220 blob = ndr_push_blob(push); 2221 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2222 talloc_free(r); 2223 return false; 2224 } 2225 2226 talloc_free(r); 2227 2228 return true; 2229} 2230 2231static bool api_PNP_GetDeviceStatus(pipes_struct *p) 2232{ 2233 const struct ndr_interface_call *call; 2234 struct ndr_pull *pull; 2235 struct ndr_push *push; 2236 enum ndr_err_code ndr_err; 2237 DATA_BLOB blob; 2238 struct PNP_GetDeviceStatus *r; 2239 2240 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETDEVICESTATUS]; 2241 2242 r = talloc(talloc_tos(), struct PNP_GetDeviceStatus); 2243 if (r == NULL) { 2244 return false; 2245 } 2246 2247 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2248 talloc_free(r); 2249 return false; 2250 } 2251 2252 pull = ndr_pull_init_blob(&blob, r, NULL); 2253 if (pull == NULL) { 2254 talloc_free(r); 2255 return false; 2256 } 2257 2258 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2259 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2260 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2261 talloc_free(r); 2262 return false; 2263 } 2264 2265 if (DEBUGLEVEL >= 10) { 2266 NDR_PRINT_IN_DEBUG(PNP_GetDeviceStatus, r); 2267 } 2268 2269 r->out.result = _PNP_GetDeviceStatus(p, r); 2270 2271 if (p->rng_fault_state) { 2272 talloc_free(r); 2273 /* Return true here, srv_pipe_hnd.c will take care */ 2274 return true; 2275 } 2276 2277 if (DEBUGLEVEL >= 10) { 2278 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceStatus, r); 2279 } 2280 2281 push = ndr_push_init_ctx(r, NULL); 2282 if (push == NULL) { 2283 talloc_free(r); 2284 return false; 2285 } 2286 2287 ndr_err = call->ndr_push(push, NDR_OUT, r); 2288 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2289 talloc_free(r); 2290 return false; 2291 } 2292 2293 blob = ndr_push_blob(push); 2294 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2295 talloc_free(r); 2296 return false; 2297 } 2298 2299 talloc_free(r); 2300 2301 return true; 2302} 2303 2304static bool api_PNP_SetDeviceProblem(pipes_struct *p) 2305{ 2306 const struct ndr_interface_call *call; 2307 struct ndr_pull *pull; 2308 struct ndr_push *push; 2309 enum ndr_err_code ndr_err; 2310 DATA_BLOB blob; 2311 struct PNP_SetDeviceProblem *r; 2312 2313 call = &ndr_table_ntsvcs.calls[NDR_PNP_SETDEVICEPROBLEM]; 2314 2315 r = talloc(talloc_tos(), struct PNP_SetDeviceProblem); 2316 if (r == NULL) { 2317 return false; 2318 } 2319 2320 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2321 talloc_free(r); 2322 return false; 2323 } 2324 2325 pull = ndr_pull_init_blob(&blob, r, NULL); 2326 if (pull == NULL) { 2327 talloc_free(r); 2328 return false; 2329 } 2330 2331 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2332 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2333 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2334 talloc_free(r); 2335 return false; 2336 } 2337 2338 if (DEBUGLEVEL >= 10) { 2339 NDR_PRINT_IN_DEBUG(PNP_SetDeviceProblem, r); 2340 } 2341 2342 r->out.result = _PNP_SetDeviceProblem(p, r); 2343 2344 if (p->rng_fault_state) { 2345 talloc_free(r); 2346 /* Return true here, srv_pipe_hnd.c will take care */ 2347 return true; 2348 } 2349 2350 if (DEBUGLEVEL >= 10) { 2351 NDR_PRINT_OUT_DEBUG(PNP_SetDeviceProblem, r); 2352 } 2353 2354 push = ndr_push_init_ctx(r, NULL); 2355 if (push == NULL) { 2356 talloc_free(r); 2357 return false; 2358 } 2359 2360 ndr_err = call->ndr_push(push, NDR_OUT, r); 2361 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2362 talloc_free(r); 2363 return false; 2364 } 2365 2366 blob = ndr_push_blob(push); 2367 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2368 talloc_free(r); 2369 return false; 2370 } 2371 2372 talloc_free(r); 2373 2374 return true; 2375} 2376 2377static bool api_PNP_DisableDevInst(pipes_struct *p) 2378{ 2379 const struct ndr_interface_call *call; 2380 struct ndr_pull *pull; 2381 struct ndr_push *push; 2382 enum ndr_err_code ndr_err; 2383 DATA_BLOB blob; 2384 struct PNP_DisableDevInst *r; 2385 2386 call = &ndr_table_ntsvcs.calls[NDR_PNP_DISABLEDEVINST]; 2387 2388 r = talloc(talloc_tos(), struct PNP_DisableDevInst); 2389 if (r == NULL) { 2390 return false; 2391 } 2392 2393 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2394 talloc_free(r); 2395 return false; 2396 } 2397 2398 pull = ndr_pull_init_blob(&blob, r, NULL); 2399 if (pull == NULL) { 2400 talloc_free(r); 2401 return false; 2402 } 2403 2404 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2405 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2406 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2407 talloc_free(r); 2408 return false; 2409 } 2410 2411 if (DEBUGLEVEL >= 10) { 2412 NDR_PRINT_IN_DEBUG(PNP_DisableDevInst, r); 2413 } 2414 2415 r->out.result = _PNP_DisableDevInst(p, r); 2416 2417 if (p->rng_fault_state) { 2418 talloc_free(r); 2419 /* Return true here, srv_pipe_hnd.c will take care */ 2420 return true; 2421 } 2422 2423 if (DEBUGLEVEL >= 10) { 2424 NDR_PRINT_OUT_DEBUG(PNP_DisableDevInst, r); 2425 } 2426 2427 push = ndr_push_init_ctx(r, NULL); 2428 if (push == NULL) { 2429 talloc_free(r); 2430 return false; 2431 } 2432 2433 ndr_err = call->ndr_push(push, NDR_OUT, r); 2434 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2435 talloc_free(r); 2436 return false; 2437 } 2438 2439 blob = ndr_push_blob(push); 2440 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2441 talloc_free(r); 2442 return false; 2443 } 2444 2445 talloc_free(r); 2446 2447 return true; 2448} 2449 2450static bool api_PNP_UninstallDevInst(pipes_struct *p) 2451{ 2452 const struct ndr_interface_call *call; 2453 struct ndr_pull *pull; 2454 struct ndr_push *push; 2455 enum ndr_err_code ndr_err; 2456 DATA_BLOB blob; 2457 struct PNP_UninstallDevInst *r; 2458 2459 call = &ndr_table_ntsvcs.calls[NDR_PNP_UNINSTALLDEVINST]; 2460 2461 r = talloc(talloc_tos(), struct PNP_UninstallDevInst); 2462 if (r == NULL) { 2463 return false; 2464 } 2465 2466 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2467 talloc_free(r); 2468 return false; 2469 } 2470 2471 pull = ndr_pull_init_blob(&blob, r, NULL); 2472 if (pull == NULL) { 2473 talloc_free(r); 2474 return false; 2475 } 2476 2477 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2478 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2479 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2480 talloc_free(r); 2481 return false; 2482 } 2483 2484 if (DEBUGLEVEL >= 10) { 2485 NDR_PRINT_IN_DEBUG(PNP_UninstallDevInst, r); 2486 } 2487 2488 r->out.result = _PNP_UninstallDevInst(p, r); 2489 2490 if (p->rng_fault_state) { 2491 talloc_free(r); 2492 /* Return true here, srv_pipe_hnd.c will take care */ 2493 return true; 2494 } 2495 2496 if (DEBUGLEVEL >= 10) { 2497 NDR_PRINT_OUT_DEBUG(PNP_UninstallDevInst, r); 2498 } 2499 2500 push = ndr_push_init_ctx(r, NULL); 2501 if (push == NULL) { 2502 talloc_free(r); 2503 return false; 2504 } 2505 2506 ndr_err = call->ndr_push(push, NDR_OUT, r); 2507 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2508 talloc_free(r); 2509 return false; 2510 } 2511 2512 blob = ndr_push_blob(push); 2513 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2514 talloc_free(r); 2515 return false; 2516 } 2517 2518 talloc_free(r); 2519 2520 return true; 2521} 2522 2523static bool api_PNP_AddID(pipes_struct *p) 2524{ 2525 const struct ndr_interface_call *call; 2526 struct ndr_pull *pull; 2527 struct ndr_push *push; 2528 enum ndr_err_code ndr_err; 2529 DATA_BLOB blob; 2530 struct PNP_AddID *r; 2531 2532 call = &ndr_table_ntsvcs.calls[NDR_PNP_ADDID]; 2533 2534 r = talloc(talloc_tos(), struct PNP_AddID); 2535 if (r == NULL) { 2536 return false; 2537 } 2538 2539 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2540 talloc_free(r); 2541 return false; 2542 } 2543 2544 pull = ndr_pull_init_blob(&blob, r, NULL); 2545 if (pull == NULL) { 2546 talloc_free(r); 2547 return false; 2548 } 2549 2550 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2551 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2552 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2553 talloc_free(r); 2554 return false; 2555 } 2556 2557 if (DEBUGLEVEL >= 10) { 2558 NDR_PRINT_IN_DEBUG(PNP_AddID, r); 2559 } 2560 2561 r->out.result = _PNP_AddID(p, r); 2562 2563 if (p->rng_fault_state) { 2564 talloc_free(r); 2565 /* Return true here, srv_pipe_hnd.c will take care */ 2566 return true; 2567 } 2568 2569 if (DEBUGLEVEL >= 10) { 2570 NDR_PRINT_OUT_DEBUG(PNP_AddID, r); 2571 } 2572 2573 push = ndr_push_init_ctx(r, NULL); 2574 if (push == NULL) { 2575 talloc_free(r); 2576 return false; 2577 } 2578 2579 ndr_err = call->ndr_push(push, NDR_OUT, r); 2580 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2581 talloc_free(r); 2582 return false; 2583 } 2584 2585 blob = ndr_push_blob(push); 2586 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2587 talloc_free(r); 2588 return false; 2589 } 2590 2591 talloc_free(r); 2592 2593 return true; 2594} 2595 2596static bool api_PNP_RegisterDriver(pipes_struct *p) 2597{ 2598 const struct ndr_interface_call *call; 2599 struct ndr_pull *pull; 2600 struct ndr_push *push; 2601 enum ndr_err_code ndr_err; 2602 DATA_BLOB blob; 2603 struct PNP_RegisterDriver *r; 2604 2605 call = &ndr_table_ntsvcs.calls[NDR_PNP_REGISTERDRIVER]; 2606 2607 r = talloc(talloc_tos(), struct PNP_RegisterDriver); 2608 if (r == NULL) { 2609 return false; 2610 } 2611 2612 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2613 talloc_free(r); 2614 return false; 2615 } 2616 2617 pull = ndr_pull_init_blob(&blob, r, NULL); 2618 if (pull == NULL) { 2619 talloc_free(r); 2620 return false; 2621 } 2622 2623 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2624 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2625 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2626 talloc_free(r); 2627 return false; 2628 } 2629 2630 if (DEBUGLEVEL >= 10) { 2631 NDR_PRINT_IN_DEBUG(PNP_RegisterDriver, r); 2632 } 2633 2634 r->out.result = _PNP_RegisterDriver(p, r); 2635 2636 if (p->rng_fault_state) { 2637 talloc_free(r); 2638 /* Return true here, srv_pipe_hnd.c will take care */ 2639 return true; 2640 } 2641 2642 if (DEBUGLEVEL >= 10) { 2643 NDR_PRINT_OUT_DEBUG(PNP_RegisterDriver, r); 2644 } 2645 2646 push = ndr_push_init_ctx(r, NULL); 2647 if (push == NULL) { 2648 talloc_free(r); 2649 return false; 2650 } 2651 2652 ndr_err = call->ndr_push(push, NDR_OUT, r); 2653 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2654 talloc_free(r); 2655 return false; 2656 } 2657 2658 blob = ndr_push_blob(push); 2659 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2660 talloc_free(r); 2661 return false; 2662 } 2663 2664 talloc_free(r); 2665 2666 return true; 2667} 2668 2669static bool api_PNP_QueryRemove(pipes_struct *p) 2670{ 2671 const struct ndr_interface_call *call; 2672 struct ndr_pull *pull; 2673 struct ndr_push *push; 2674 enum ndr_err_code ndr_err; 2675 DATA_BLOB blob; 2676 struct PNP_QueryRemove *r; 2677 2678 call = &ndr_table_ntsvcs.calls[NDR_PNP_QUERYREMOVE]; 2679 2680 r = talloc(talloc_tos(), struct PNP_QueryRemove); 2681 if (r == NULL) { 2682 return false; 2683 } 2684 2685 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2686 talloc_free(r); 2687 return false; 2688 } 2689 2690 pull = ndr_pull_init_blob(&blob, r, NULL); 2691 if (pull == NULL) { 2692 talloc_free(r); 2693 return false; 2694 } 2695 2696 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2697 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2698 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2699 talloc_free(r); 2700 return false; 2701 } 2702 2703 if (DEBUGLEVEL >= 10) { 2704 NDR_PRINT_IN_DEBUG(PNP_QueryRemove, r); 2705 } 2706 2707 r->out.result = _PNP_QueryRemove(p, r); 2708 2709 if (p->rng_fault_state) { 2710 talloc_free(r); 2711 /* Return true here, srv_pipe_hnd.c will take care */ 2712 return true; 2713 } 2714 2715 if (DEBUGLEVEL >= 10) { 2716 NDR_PRINT_OUT_DEBUG(PNP_QueryRemove, r); 2717 } 2718 2719 push = ndr_push_init_ctx(r, NULL); 2720 if (push == NULL) { 2721 talloc_free(r); 2722 return false; 2723 } 2724 2725 ndr_err = call->ndr_push(push, NDR_OUT, r); 2726 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2727 talloc_free(r); 2728 return false; 2729 } 2730 2731 blob = ndr_push_blob(push); 2732 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2733 talloc_free(r); 2734 return false; 2735 } 2736 2737 talloc_free(r); 2738 2739 return true; 2740} 2741 2742static bool api_PNP_RequestDeviceEject(pipes_struct *p) 2743{ 2744 const struct ndr_interface_call *call; 2745 struct ndr_pull *pull; 2746 struct ndr_push *push; 2747 enum ndr_err_code ndr_err; 2748 DATA_BLOB blob; 2749 struct PNP_RequestDeviceEject *r; 2750 2751 call = &ndr_table_ntsvcs.calls[NDR_PNP_REQUESTDEVICEEJECT]; 2752 2753 r = talloc(talloc_tos(), struct PNP_RequestDeviceEject); 2754 if (r == NULL) { 2755 return false; 2756 } 2757 2758 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2759 talloc_free(r); 2760 return false; 2761 } 2762 2763 pull = ndr_pull_init_blob(&blob, r, NULL); 2764 if (pull == NULL) { 2765 talloc_free(r); 2766 return false; 2767 } 2768 2769 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2770 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2771 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2772 talloc_free(r); 2773 return false; 2774 } 2775 2776 if (DEBUGLEVEL >= 10) { 2777 NDR_PRINT_IN_DEBUG(PNP_RequestDeviceEject, r); 2778 } 2779 2780 r->out.result = _PNP_RequestDeviceEject(p, r); 2781 2782 if (p->rng_fault_state) { 2783 talloc_free(r); 2784 /* Return true here, srv_pipe_hnd.c will take care */ 2785 return true; 2786 } 2787 2788 if (DEBUGLEVEL >= 10) { 2789 NDR_PRINT_OUT_DEBUG(PNP_RequestDeviceEject, r); 2790 } 2791 2792 push = ndr_push_init_ctx(r, NULL); 2793 if (push == NULL) { 2794 talloc_free(r); 2795 return false; 2796 } 2797 2798 ndr_err = call->ndr_push(push, NDR_OUT, r); 2799 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2800 talloc_free(r); 2801 return false; 2802 } 2803 2804 blob = ndr_push_blob(push); 2805 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2806 talloc_free(r); 2807 return false; 2808 } 2809 2810 talloc_free(r); 2811 2812 return true; 2813} 2814 2815static bool api_PNP_IsDockStationPresent(pipes_struct *p) 2816{ 2817 const struct ndr_interface_call *call; 2818 struct ndr_pull *pull; 2819 struct ndr_push *push; 2820 enum ndr_err_code ndr_err; 2821 DATA_BLOB blob; 2822 struct PNP_IsDockStationPresent *r; 2823 2824 call = &ndr_table_ntsvcs.calls[NDR_PNP_ISDOCKSTATIONPRESENT]; 2825 2826 r = talloc(talloc_tos(), struct PNP_IsDockStationPresent); 2827 if (r == NULL) { 2828 return false; 2829 } 2830 2831 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2832 talloc_free(r); 2833 return false; 2834 } 2835 2836 pull = ndr_pull_init_blob(&blob, r, NULL); 2837 if (pull == NULL) { 2838 talloc_free(r); 2839 return false; 2840 } 2841 2842 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2843 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2844 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2845 talloc_free(r); 2846 return false; 2847 } 2848 2849 if (DEBUGLEVEL >= 10) { 2850 NDR_PRINT_IN_DEBUG(PNP_IsDockStationPresent, r); 2851 } 2852 2853 r->out.result = _PNP_IsDockStationPresent(p, r); 2854 2855 if (p->rng_fault_state) { 2856 talloc_free(r); 2857 /* Return true here, srv_pipe_hnd.c will take care */ 2858 return true; 2859 } 2860 2861 if (DEBUGLEVEL >= 10) { 2862 NDR_PRINT_OUT_DEBUG(PNP_IsDockStationPresent, r); 2863 } 2864 2865 push = ndr_push_init_ctx(r, NULL); 2866 if (push == NULL) { 2867 talloc_free(r); 2868 return false; 2869 } 2870 2871 ndr_err = call->ndr_push(push, NDR_OUT, r); 2872 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2873 talloc_free(r); 2874 return false; 2875 } 2876 2877 blob = ndr_push_blob(push); 2878 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2879 talloc_free(r); 2880 return false; 2881 } 2882 2883 talloc_free(r); 2884 2885 return true; 2886} 2887 2888static bool api_PNP_RequestEjectPC(pipes_struct *p) 2889{ 2890 const struct ndr_interface_call *call; 2891 struct ndr_pull *pull; 2892 struct ndr_push *push; 2893 enum ndr_err_code ndr_err; 2894 DATA_BLOB blob; 2895 struct PNP_RequestEjectPC *r; 2896 2897 call = &ndr_table_ntsvcs.calls[NDR_PNP_REQUESTEJECTPC]; 2898 2899 r = talloc(talloc_tos(), struct PNP_RequestEjectPC); 2900 if (r == NULL) { 2901 return false; 2902 } 2903 2904 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2905 talloc_free(r); 2906 return false; 2907 } 2908 2909 pull = ndr_pull_init_blob(&blob, r, NULL); 2910 if (pull == NULL) { 2911 talloc_free(r); 2912 return false; 2913 } 2914 2915 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2916 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2917 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2918 talloc_free(r); 2919 return false; 2920 } 2921 2922 if (DEBUGLEVEL >= 10) { 2923 NDR_PRINT_IN_DEBUG(PNP_RequestEjectPC, r); 2924 } 2925 2926 r->out.result = _PNP_RequestEjectPC(p, r); 2927 2928 if (p->rng_fault_state) { 2929 talloc_free(r); 2930 /* Return true here, srv_pipe_hnd.c will take care */ 2931 return true; 2932 } 2933 2934 if (DEBUGLEVEL >= 10) { 2935 NDR_PRINT_OUT_DEBUG(PNP_RequestEjectPC, r); 2936 } 2937 2938 push = ndr_push_init_ctx(r, NULL); 2939 if (push == NULL) { 2940 talloc_free(r); 2941 return false; 2942 } 2943 2944 ndr_err = call->ndr_push(push, NDR_OUT, r); 2945 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2946 talloc_free(r); 2947 return false; 2948 } 2949 2950 blob = ndr_push_blob(push); 2951 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2952 talloc_free(r); 2953 return false; 2954 } 2955 2956 talloc_free(r); 2957 2958 return true; 2959} 2960 2961static bool api_PNP_HwProfFlags(pipes_struct *p) 2962{ 2963 const struct ndr_interface_call *call; 2964 struct ndr_pull *pull; 2965 struct ndr_push *push; 2966 enum ndr_err_code ndr_err; 2967 DATA_BLOB blob; 2968 struct PNP_HwProfFlags *r; 2969 2970 call = &ndr_table_ntsvcs.calls[NDR_PNP_HWPROFFLAGS]; 2971 2972 r = talloc(talloc_tos(), struct PNP_HwProfFlags); 2973 if (r == NULL) { 2974 return false; 2975 } 2976 2977 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2978 talloc_free(r); 2979 return false; 2980 } 2981 2982 pull = ndr_pull_init_blob(&blob, r, NULL); 2983 if (pull == NULL) { 2984 talloc_free(r); 2985 return false; 2986 } 2987 2988 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2989 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2990 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2991 talloc_free(r); 2992 return false; 2993 } 2994 2995 if (DEBUGLEVEL >= 10) { 2996 NDR_PRINT_IN_DEBUG(PNP_HwProfFlags, r); 2997 } 2998 2999 ZERO_STRUCT(r->out); 3000 r->out.profile_flags = r->in.profile_flags; 3001 r->out.veto_type = r->in.veto_type; 3002 r->out.unknown5a = talloc_zero(r, const char *); 3003 if (r->out.unknown5a == NULL) { 3004 talloc_free(r); 3005 return false; 3006 } 3007 3008 r->out.result = _PNP_HwProfFlags(p, r); 3009 3010 if (p->rng_fault_state) { 3011 talloc_free(r); 3012 /* Return true here, srv_pipe_hnd.c will take care */ 3013 return true; 3014 } 3015 3016 if (DEBUGLEVEL >= 10) { 3017 NDR_PRINT_OUT_DEBUG(PNP_HwProfFlags, r); 3018 } 3019 3020 push = ndr_push_init_ctx(r, NULL); 3021 if (push == NULL) { 3022 talloc_free(r); 3023 return false; 3024 } 3025 3026 ndr_err = call->ndr_push(push, NDR_OUT, r); 3027 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3028 talloc_free(r); 3029 return false; 3030 } 3031 3032 blob = ndr_push_blob(push); 3033 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3034 talloc_free(r); 3035 return false; 3036 } 3037 3038 talloc_free(r); 3039 3040 return true; 3041} 3042 3043static bool api_PNP_GetHwProfInfo(pipes_struct *p) 3044{ 3045 const struct ndr_interface_call *call; 3046 struct ndr_pull *pull; 3047 struct ndr_push *push; 3048 enum ndr_err_code ndr_err; 3049 DATA_BLOB blob; 3050 struct PNP_GetHwProfInfo *r; 3051 3052 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETHWPROFINFO]; 3053 3054 r = talloc(talloc_tos(), struct PNP_GetHwProfInfo); 3055 if (r == NULL) { 3056 return false; 3057 } 3058 3059 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3060 talloc_free(r); 3061 return false; 3062 } 3063 3064 pull = ndr_pull_init_blob(&blob, r, NULL); 3065 if (pull == NULL) { 3066 talloc_free(r); 3067 return false; 3068 } 3069 3070 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3071 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3072 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3073 talloc_free(r); 3074 return false; 3075 } 3076 3077 if (DEBUGLEVEL >= 10) { 3078 NDR_PRINT_IN_DEBUG(PNP_GetHwProfInfo, r); 3079 } 3080 3081 ZERO_STRUCT(r->out); 3082 r->out.info = r->in.info; 3083 r->out.result = _PNP_GetHwProfInfo(p, r); 3084 3085 if (p->rng_fault_state) { 3086 talloc_free(r); 3087 /* Return true here, srv_pipe_hnd.c will take care */ 3088 return true; 3089 } 3090 3091 if (DEBUGLEVEL >= 10) { 3092 NDR_PRINT_OUT_DEBUG(PNP_GetHwProfInfo, r); 3093 } 3094 3095 push = ndr_push_init_ctx(r, NULL); 3096 if (push == NULL) { 3097 talloc_free(r); 3098 return false; 3099 } 3100 3101 ndr_err = call->ndr_push(push, NDR_OUT, r); 3102 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3103 talloc_free(r); 3104 return false; 3105 } 3106 3107 blob = ndr_push_blob(push); 3108 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3109 talloc_free(r); 3110 return false; 3111 } 3112 3113 talloc_free(r); 3114 3115 return true; 3116} 3117 3118static bool api_PNP_AddEmptyLogConf(pipes_struct *p) 3119{ 3120 const struct ndr_interface_call *call; 3121 struct ndr_pull *pull; 3122 struct ndr_push *push; 3123 enum ndr_err_code ndr_err; 3124 DATA_BLOB blob; 3125 struct PNP_AddEmptyLogConf *r; 3126 3127 call = &ndr_table_ntsvcs.calls[NDR_PNP_ADDEMPTYLOGCONF]; 3128 3129 r = talloc(talloc_tos(), struct PNP_AddEmptyLogConf); 3130 if (r == NULL) { 3131 return false; 3132 } 3133 3134 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3135 talloc_free(r); 3136 return false; 3137 } 3138 3139 pull = ndr_pull_init_blob(&blob, r, NULL); 3140 if (pull == NULL) { 3141 talloc_free(r); 3142 return false; 3143 } 3144 3145 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3146 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3147 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3148 talloc_free(r); 3149 return false; 3150 } 3151 3152 if (DEBUGLEVEL >= 10) { 3153 NDR_PRINT_IN_DEBUG(PNP_AddEmptyLogConf, r); 3154 } 3155 3156 r->out.result = _PNP_AddEmptyLogConf(p, r); 3157 3158 if (p->rng_fault_state) { 3159 talloc_free(r); 3160 /* Return true here, srv_pipe_hnd.c will take care */ 3161 return true; 3162 } 3163 3164 if (DEBUGLEVEL >= 10) { 3165 NDR_PRINT_OUT_DEBUG(PNP_AddEmptyLogConf, r); 3166 } 3167 3168 push = ndr_push_init_ctx(r, NULL); 3169 if (push == NULL) { 3170 talloc_free(r); 3171 return false; 3172 } 3173 3174 ndr_err = call->ndr_push(push, NDR_OUT, r); 3175 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3176 talloc_free(r); 3177 return false; 3178 } 3179 3180 blob = ndr_push_blob(push); 3181 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3182 talloc_free(r); 3183 return false; 3184 } 3185 3186 talloc_free(r); 3187 3188 return true; 3189} 3190 3191static bool api_PNP_FreeLogConf(pipes_struct *p) 3192{ 3193 const struct ndr_interface_call *call; 3194 struct ndr_pull *pull; 3195 struct ndr_push *push; 3196 enum ndr_err_code ndr_err; 3197 DATA_BLOB blob; 3198 struct PNP_FreeLogConf *r; 3199 3200 call = &ndr_table_ntsvcs.calls[NDR_PNP_FREELOGCONF]; 3201 3202 r = talloc(talloc_tos(), struct PNP_FreeLogConf); 3203 if (r == NULL) { 3204 return false; 3205 } 3206 3207 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3208 talloc_free(r); 3209 return false; 3210 } 3211 3212 pull = ndr_pull_init_blob(&blob, r, NULL); 3213 if (pull == NULL) { 3214 talloc_free(r); 3215 return false; 3216 } 3217 3218 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3219 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3220 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3221 talloc_free(r); 3222 return false; 3223 } 3224 3225 if (DEBUGLEVEL >= 10) { 3226 NDR_PRINT_IN_DEBUG(PNP_FreeLogConf, r); 3227 } 3228 3229 r->out.result = _PNP_FreeLogConf(p, r); 3230 3231 if (p->rng_fault_state) { 3232 talloc_free(r); 3233 /* Return true here, srv_pipe_hnd.c will take care */ 3234 return true; 3235 } 3236 3237 if (DEBUGLEVEL >= 10) { 3238 NDR_PRINT_OUT_DEBUG(PNP_FreeLogConf, r); 3239 } 3240 3241 push = ndr_push_init_ctx(r, NULL); 3242 if (push == NULL) { 3243 talloc_free(r); 3244 return false; 3245 } 3246 3247 ndr_err = call->ndr_push(push, NDR_OUT, r); 3248 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3249 talloc_free(r); 3250 return false; 3251 } 3252 3253 blob = ndr_push_blob(push); 3254 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3255 talloc_free(r); 3256 return false; 3257 } 3258 3259 talloc_free(r); 3260 3261 return true; 3262} 3263 3264static bool api_PNP_GetFirstLogConf(pipes_struct *p) 3265{ 3266 const struct ndr_interface_call *call; 3267 struct ndr_pull *pull; 3268 struct ndr_push *push; 3269 enum ndr_err_code ndr_err; 3270 DATA_BLOB blob; 3271 struct PNP_GetFirstLogConf *r; 3272 3273 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETFIRSTLOGCONF]; 3274 3275 r = talloc(talloc_tos(), struct PNP_GetFirstLogConf); 3276 if (r == NULL) { 3277 return false; 3278 } 3279 3280 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3281 talloc_free(r); 3282 return false; 3283 } 3284 3285 pull = ndr_pull_init_blob(&blob, r, NULL); 3286 if (pull == NULL) { 3287 talloc_free(r); 3288 return false; 3289 } 3290 3291 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3292 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3293 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3294 talloc_free(r); 3295 return false; 3296 } 3297 3298 if (DEBUGLEVEL >= 10) { 3299 NDR_PRINT_IN_DEBUG(PNP_GetFirstLogConf, r); 3300 } 3301 3302 r->out.result = _PNP_GetFirstLogConf(p, r); 3303 3304 if (p->rng_fault_state) { 3305 talloc_free(r); 3306 /* Return true here, srv_pipe_hnd.c will take care */ 3307 return true; 3308 } 3309 3310 if (DEBUGLEVEL >= 10) { 3311 NDR_PRINT_OUT_DEBUG(PNP_GetFirstLogConf, r); 3312 } 3313 3314 push = ndr_push_init_ctx(r, NULL); 3315 if (push == NULL) { 3316 talloc_free(r); 3317 return false; 3318 } 3319 3320 ndr_err = call->ndr_push(push, NDR_OUT, r); 3321 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3322 talloc_free(r); 3323 return false; 3324 } 3325 3326 blob = ndr_push_blob(push); 3327 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3328 talloc_free(r); 3329 return false; 3330 } 3331 3332 talloc_free(r); 3333 3334 return true; 3335} 3336 3337static bool api_PNP_GetNextLogConf(pipes_struct *p) 3338{ 3339 const struct ndr_interface_call *call; 3340 struct ndr_pull *pull; 3341 struct ndr_push *push; 3342 enum ndr_err_code ndr_err; 3343 DATA_BLOB blob; 3344 struct PNP_GetNextLogConf *r; 3345 3346 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETNEXTLOGCONF]; 3347 3348 r = talloc(talloc_tos(), struct PNP_GetNextLogConf); 3349 if (r == NULL) { 3350 return false; 3351 } 3352 3353 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3354 talloc_free(r); 3355 return false; 3356 } 3357 3358 pull = ndr_pull_init_blob(&blob, r, NULL); 3359 if (pull == NULL) { 3360 talloc_free(r); 3361 return false; 3362 } 3363 3364 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3365 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3366 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3367 talloc_free(r); 3368 return false; 3369 } 3370 3371 if (DEBUGLEVEL >= 10) { 3372 NDR_PRINT_IN_DEBUG(PNP_GetNextLogConf, r); 3373 } 3374 3375 r->out.result = _PNP_GetNextLogConf(p, r); 3376 3377 if (p->rng_fault_state) { 3378 talloc_free(r); 3379 /* Return true here, srv_pipe_hnd.c will take care */ 3380 return true; 3381 } 3382 3383 if (DEBUGLEVEL >= 10) { 3384 NDR_PRINT_OUT_DEBUG(PNP_GetNextLogConf, r); 3385 } 3386 3387 push = ndr_push_init_ctx(r, NULL); 3388 if (push == NULL) { 3389 talloc_free(r); 3390 return false; 3391 } 3392 3393 ndr_err = call->ndr_push(push, NDR_OUT, r); 3394 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3395 talloc_free(r); 3396 return false; 3397 } 3398 3399 blob = ndr_push_blob(push); 3400 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3401 talloc_free(r); 3402 return false; 3403 } 3404 3405 talloc_free(r); 3406 3407 return true; 3408} 3409 3410static bool api_PNP_GetLogConfPriority(pipes_struct *p) 3411{ 3412 const struct ndr_interface_call *call; 3413 struct ndr_pull *pull; 3414 struct ndr_push *push; 3415 enum ndr_err_code ndr_err; 3416 DATA_BLOB blob; 3417 struct PNP_GetLogConfPriority *r; 3418 3419 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETLOGCONFPRIORITY]; 3420 3421 r = talloc(talloc_tos(), struct PNP_GetLogConfPriority); 3422 if (r == NULL) { 3423 return false; 3424 } 3425 3426 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3427 talloc_free(r); 3428 return false; 3429 } 3430 3431 pull = ndr_pull_init_blob(&blob, r, NULL); 3432 if (pull == NULL) { 3433 talloc_free(r); 3434 return false; 3435 } 3436 3437 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3438 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3439 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3440 talloc_free(r); 3441 return false; 3442 } 3443 3444 if (DEBUGLEVEL >= 10) { 3445 NDR_PRINT_IN_DEBUG(PNP_GetLogConfPriority, r); 3446 } 3447 3448 r->out.result = _PNP_GetLogConfPriority(p, r); 3449 3450 if (p->rng_fault_state) { 3451 talloc_free(r); 3452 /* Return true here, srv_pipe_hnd.c will take care */ 3453 return true; 3454 } 3455 3456 if (DEBUGLEVEL >= 10) { 3457 NDR_PRINT_OUT_DEBUG(PNP_GetLogConfPriority, r); 3458 } 3459 3460 push = ndr_push_init_ctx(r, NULL); 3461 if (push == NULL) { 3462 talloc_free(r); 3463 return false; 3464 } 3465 3466 ndr_err = call->ndr_push(push, NDR_OUT, r); 3467 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3468 talloc_free(r); 3469 return false; 3470 } 3471 3472 blob = ndr_push_blob(push); 3473 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3474 talloc_free(r); 3475 return false; 3476 } 3477 3478 talloc_free(r); 3479 3480 return true; 3481} 3482 3483static bool api_PNP_AddResDes(pipes_struct *p) 3484{ 3485 const struct ndr_interface_call *call; 3486 struct ndr_pull *pull; 3487 struct ndr_push *push; 3488 enum ndr_err_code ndr_err; 3489 DATA_BLOB blob; 3490 struct PNP_AddResDes *r; 3491 3492 call = &ndr_table_ntsvcs.calls[NDR_PNP_ADDRESDES]; 3493 3494 r = talloc(talloc_tos(), struct PNP_AddResDes); 3495 if (r == NULL) { 3496 return false; 3497 } 3498 3499 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3500 talloc_free(r); 3501 return false; 3502 } 3503 3504 pull = ndr_pull_init_blob(&blob, r, NULL); 3505 if (pull == NULL) { 3506 talloc_free(r); 3507 return false; 3508 } 3509 3510 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3511 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3512 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3513 talloc_free(r); 3514 return false; 3515 } 3516 3517 if (DEBUGLEVEL >= 10) { 3518 NDR_PRINT_IN_DEBUG(PNP_AddResDes, r); 3519 } 3520 3521 r->out.result = _PNP_AddResDes(p, r); 3522 3523 if (p->rng_fault_state) { 3524 talloc_free(r); 3525 /* Return true here, srv_pipe_hnd.c will take care */ 3526 return true; 3527 } 3528 3529 if (DEBUGLEVEL >= 10) { 3530 NDR_PRINT_OUT_DEBUG(PNP_AddResDes, r); 3531 } 3532 3533 push = ndr_push_init_ctx(r, NULL); 3534 if (push == NULL) { 3535 talloc_free(r); 3536 return false; 3537 } 3538 3539 ndr_err = call->ndr_push(push, NDR_OUT, r); 3540 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3541 talloc_free(r); 3542 return false; 3543 } 3544 3545 blob = ndr_push_blob(push); 3546 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3547 talloc_free(r); 3548 return false; 3549 } 3550 3551 talloc_free(r); 3552 3553 return true; 3554} 3555 3556static bool api_PNP_FreeResDes(pipes_struct *p) 3557{ 3558 const struct ndr_interface_call *call; 3559 struct ndr_pull *pull; 3560 struct ndr_push *push; 3561 enum ndr_err_code ndr_err; 3562 DATA_BLOB blob; 3563 struct PNP_FreeResDes *r; 3564 3565 call = &ndr_table_ntsvcs.calls[NDR_PNP_FREERESDES]; 3566 3567 r = talloc(talloc_tos(), struct PNP_FreeResDes); 3568 if (r == NULL) { 3569 return false; 3570 } 3571 3572 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3573 talloc_free(r); 3574 return false; 3575 } 3576 3577 pull = ndr_pull_init_blob(&blob, r, NULL); 3578 if (pull == NULL) { 3579 talloc_free(r); 3580 return false; 3581 } 3582 3583 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3584 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3585 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3586 talloc_free(r); 3587 return false; 3588 } 3589 3590 if (DEBUGLEVEL >= 10) { 3591 NDR_PRINT_IN_DEBUG(PNP_FreeResDes, r); 3592 } 3593 3594 r->out.result = _PNP_FreeResDes(p, r); 3595 3596 if (p->rng_fault_state) { 3597 talloc_free(r); 3598 /* Return true here, srv_pipe_hnd.c will take care */ 3599 return true; 3600 } 3601 3602 if (DEBUGLEVEL >= 10) { 3603 NDR_PRINT_OUT_DEBUG(PNP_FreeResDes, r); 3604 } 3605 3606 push = ndr_push_init_ctx(r, NULL); 3607 if (push == NULL) { 3608 talloc_free(r); 3609 return false; 3610 } 3611 3612 ndr_err = call->ndr_push(push, NDR_OUT, r); 3613 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3614 talloc_free(r); 3615 return false; 3616 } 3617 3618 blob = ndr_push_blob(push); 3619 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3620 talloc_free(r); 3621 return false; 3622 } 3623 3624 talloc_free(r); 3625 3626 return true; 3627} 3628 3629static bool api_PNP_GetNextResDes(pipes_struct *p) 3630{ 3631 const struct ndr_interface_call *call; 3632 struct ndr_pull *pull; 3633 struct ndr_push *push; 3634 enum ndr_err_code ndr_err; 3635 DATA_BLOB blob; 3636 struct PNP_GetNextResDes *r; 3637 3638 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETNEXTRESDES]; 3639 3640 r = talloc(talloc_tos(), struct PNP_GetNextResDes); 3641 if (r == NULL) { 3642 return false; 3643 } 3644 3645 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3646 talloc_free(r); 3647 return false; 3648 } 3649 3650 pull = ndr_pull_init_blob(&blob, r, NULL); 3651 if (pull == NULL) { 3652 talloc_free(r); 3653 return false; 3654 } 3655 3656 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3657 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3658 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3659 talloc_free(r); 3660 return false; 3661 } 3662 3663 if (DEBUGLEVEL >= 10) { 3664 NDR_PRINT_IN_DEBUG(PNP_GetNextResDes, r); 3665 } 3666 3667 r->out.result = _PNP_GetNextResDes(p, r); 3668 3669 if (p->rng_fault_state) { 3670 talloc_free(r); 3671 /* Return true here, srv_pipe_hnd.c will take care */ 3672 return true; 3673 } 3674 3675 if (DEBUGLEVEL >= 10) { 3676 NDR_PRINT_OUT_DEBUG(PNP_GetNextResDes, r); 3677 } 3678 3679 push = ndr_push_init_ctx(r, NULL); 3680 if (push == NULL) { 3681 talloc_free(r); 3682 return false; 3683 } 3684 3685 ndr_err = call->ndr_push(push, NDR_OUT, r); 3686 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3687 talloc_free(r); 3688 return false; 3689 } 3690 3691 blob = ndr_push_blob(push); 3692 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3693 talloc_free(r); 3694 return false; 3695 } 3696 3697 talloc_free(r); 3698 3699 return true; 3700} 3701 3702static bool api_PNP_GetResDesData(pipes_struct *p) 3703{ 3704 const struct ndr_interface_call *call; 3705 struct ndr_pull *pull; 3706 struct ndr_push *push; 3707 enum ndr_err_code ndr_err; 3708 DATA_BLOB blob; 3709 struct PNP_GetResDesData *r; 3710 3711 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETRESDESDATA]; 3712 3713 r = talloc(talloc_tos(), struct PNP_GetResDesData); 3714 if (r == NULL) { 3715 return false; 3716 } 3717 3718 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3719 talloc_free(r); 3720 return false; 3721 } 3722 3723 pull = ndr_pull_init_blob(&blob, r, NULL); 3724 if (pull == NULL) { 3725 talloc_free(r); 3726 return false; 3727 } 3728 3729 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3730 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3731 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3732 talloc_free(r); 3733 return false; 3734 } 3735 3736 if (DEBUGLEVEL >= 10) { 3737 NDR_PRINT_IN_DEBUG(PNP_GetResDesData, r); 3738 } 3739 3740 r->out.result = _PNP_GetResDesData(p, r); 3741 3742 if (p->rng_fault_state) { 3743 talloc_free(r); 3744 /* Return true here, srv_pipe_hnd.c will take care */ 3745 return true; 3746 } 3747 3748 if (DEBUGLEVEL >= 10) { 3749 NDR_PRINT_OUT_DEBUG(PNP_GetResDesData, r); 3750 } 3751 3752 push = ndr_push_init_ctx(r, NULL); 3753 if (push == NULL) { 3754 talloc_free(r); 3755 return false; 3756 } 3757 3758 ndr_err = call->ndr_push(push, NDR_OUT, r); 3759 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3760 talloc_free(r); 3761 return false; 3762 } 3763 3764 blob = ndr_push_blob(push); 3765 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3766 talloc_free(r); 3767 return false; 3768 } 3769 3770 talloc_free(r); 3771 3772 return true; 3773} 3774 3775static bool api_PNP_GetResDesDataSize(pipes_struct *p) 3776{ 3777 const struct ndr_interface_call *call; 3778 struct ndr_pull *pull; 3779 struct ndr_push *push; 3780 enum ndr_err_code ndr_err; 3781 DATA_BLOB blob; 3782 struct PNP_GetResDesDataSize *r; 3783 3784 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETRESDESDATASIZE]; 3785 3786 r = talloc(talloc_tos(), struct PNP_GetResDesDataSize); 3787 if (r == NULL) { 3788 return false; 3789 } 3790 3791 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3792 talloc_free(r); 3793 return false; 3794 } 3795 3796 pull = ndr_pull_init_blob(&blob, r, NULL); 3797 if (pull == NULL) { 3798 talloc_free(r); 3799 return false; 3800 } 3801 3802 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3803 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3804 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3805 talloc_free(r); 3806 return false; 3807 } 3808 3809 if (DEBUGLEVEL >= 10) { 3810 NDR_PRINT_IN_DEBUG(PNP_GetResDesDataSize, r); 3811 } 3812 3813 r->out.result = _PNP_GetResDesDataSize(p, r); 3814 3815 if (p->rng_fault_state) { 3816 talloc_free(r); 3817 /* Return true here, srv_pipe_hnd.c will take care */ 3818 return true; 3819 } 3820 3821 if (DEBUGLEVEL >= 10) { 3822 NDR_PRINT_OUT_DEBUG(PNP_GetResDesDataSize, r); 3823 } 3824 3825 push = ndr_push_init_ctx(r, NULL); 3826 if (push == NULL) { 3827 talloc_free(r); 3828 return false; 3829 } 3830 3831 ndr_err = call->ndr_push(push, NDR_OUT, r); 3832 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3833 talloc_free(r); 3834 return false; 3835 } 3836 3837 blob = ndr_push_blob(push); 3838 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3839 talloc_free(r); 3840 return false; 3841 } 3842 3843 talloc_free(r); 3844 3845 return true; 3846} 3847 3848static bool api_PNP_ModifyResDes(pipes_struct *p) 3849{ 3850 const struct ndr_interface_call *call; 3851 struct ndr_pull *pull; 3852 struct ndr_push *push; 3853 enum ndr_err_code ndr_err; 3854 DATA_BLOB blob; 3855 struct PNP_ModifyResDes *r; 3856 3857 call = &ndr_table_ntsvcs.calls[NDR_PNP_MODIFYRESDES]; 3858 3859 r = talloc(talloc_tos(), struct PNP_ModifyResDes); 3860 if (r == NULL) { 3861 return false; 3862 } 3863 3864 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3865 talloc_free(r); 3866 return false; 3867 } 3868 3869 pull = ndr_pull_init_blob(&blob, r, NULL); 3870 if (pull == NULL) { 3871 talloc_free(r); 3872 return false; 3873 } 3874 3875 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3876 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3877 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3878 talloc_free(r); 3879 return false; 3880 } 3881 3882 if (DEBUGLEVEL >= 10) { 3883 NDR_PRINT_IN_DEBUG(PNP_ModifyResDes, r); 3884 } 3885 3886 r->out.result = _PNP_ModifyResDes(p, r); 3887 3888 if (p->rng_fault_state) { 3889 talloc_free(r); 3890 /* Return true here, srv_pipe_hnd.c will take care */ 3891 return true; 3892 } 3893 3894 if (DEBUGLEVEL >= 10) { 3895 NDR_PRINT_OUT_DEBUG(PNP_ModifyResDes, r); 3896 } 3897 3898 push = ndr_push_init_ctx(r, NULL); 3899 if (push == NULL) { 3900 talloc_free(r); 3901 return false; 3902 } 3903 3904 ndr_err = call->ndr_push(push, NDR_OUT, r); 3905 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3906 talloc_free(r); 3907 return false; 3908 } 3909 3910 blob = ndr_push_blob(push); 3911 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3912 talloc_free(r); 3913 return false; 3914 } 3915 3916 talloc_free(r); 3917 3918 return true; 3919} 3920 3921static bool api_PNP_DetectResourceLimit(pipes_struct *p) 3922{ 3923 const struct ndr_interface_call *call; 3924 struct ndr_pull *pull; 3925 struct ndr_push *push; 3926 enum ndr_err_code ndr_err; 3927 DATA_BLOB blob; 3928 struct PNP_DetectResourceLimit *r; 3929 3930 call = &ndr_table_ntsvcs.calls[NDR_PNP_DETECTRESOURCELIMIT]; 3931 3932 r = talloc(talloc_tos(), struct PNP_DetectResourceLimit); 3933 if (r == NULL) { 3934 return false; 3935 } 3936 3937 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3938 talloc_free(r); 3939 return false; 3940 } 3941 3942 pull = ndr_pull_init_blob(&blob, r, NULL); 3943 if (pull == NULL) { 3944 talloc_free(r); 3945 return false; 3946 } 3947 3948 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3949 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3950 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3951 talloc_free(r); 3952 return false; 3953 } 3954 3955 if (DEBUGLEVEL >= 10) { 3956 NDR_PRINT_IN_DEBUG(PNP_DetectResourceLimit, r); 3957 } 3958 3959 r->out.result = _PNP_DetectResourceLimit(p, r); 3960 3961 if (p->rng_fault_state) { 3962 talloc_free(r); 3963 /* Return true here, srv_pipe_hnd.c will take care */ 3964 return true; 3965 } 3966 3967 if (DEBUGLEVEL >= 10) { 3968 NDR_PRINT_OUT_DEBUG(PNP_DetectResourceLimit, r); 3969 } 3970 3971 push = ndr_push_init_ctx(r, NULL); 3972 if (push == NULL) { 3973 talloc_free(r); 3974 return false; 3975 } 3976 3977 ndr_err = call->ndr_push(push, NDR_OUT, r); 3978 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3979 talloc_free(r); 3980 return false; 3981 } 3982 3983 blob = ndr_push_blob(push); 3984 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3985 talloc_free(r); 3986 return false; 3987 } 3988 3989 talloc_free(r); 3990 3991 return true; 3992} 3993 3994static bool api_PNP_QueryResConfList(pipes_struct *p) 3995{ 3996 const struct ndr_interface_call *call; 3997 struct ndr_pull *pull; 3998 struct ndr_push *push; 3999 enum ndr_err_code ndr_err; 4000 DATA_BLOB blob; 4001 struct PNP_QueryResConfList *r; 4002 4003 call = &ndr_table_ntsvcs.calls[NDR_PNP_QUERYRESCONFLIST]; 4004 4005 r = talloc(talloc_tos(), struct PNP_QueryResConfList); 4006 if (r == NULL) { 4007 return false; 4008 } 4009 4010 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4011 talloc_free(r); 4012 return false; 4013 } 4014 4015 pull = ndr_pull_init_blob(&blob, r, NULL); 4016 if (pull == NULL) { 4017 talloc_free(r); 4018 return false; 4019 } 4020 4021 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4022 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4023 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4024 talloc_free(r); 4025 return false; 4026 } 4027 4028 if (DEBUGLEVEL >= 10) { 4029 NDR_PRINT_IN_DEBUG(PNP_QueryResConfList, r); 4030 } 4031 4032 r->out.result = _PNP_QueryResConfList(p, r); 4033 4034 if (p->rng_fault_state) { 4035 talloc_free(r); 4036 /* Return true here, srv_pipe_hnd.c will take care */ 4037 return true; 4038 } 4039 4040 if (DEBUGLEVEL >= 10) { 4041 NDR_PRINT_OUT_DEBUG(PNP_QueryResConfList, r); 4042 } 4043 4044 push = ndr_push_init_ctx(r, NULL); 4045 if (push == NULL) { 4046 talloc_free(r); 4047 return false; 4048 } 4049 4050 ndr_err = call->ndr_push(push, NDR_OUT, r); 4051 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4052 talloc_free(r); 4053 return false; 4054 } 4055 4056 blob = ndr_push_blob(push); 4057 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4058 talloc_free(r); 4059 return false; 4060 } 4061 4062 talloc_free(r); 4063 4064 return true; 4065} 4066 4067static bool api_PNP_SetHwProf(pipes_struct *p) 4068{ 4069 const struct ndr_interface_call *call; 4070 struct ndr_pull *pull; 4071 struct ndr_push *push; 4072 enum ndr_err_code ndr_err; 4073 DATA_BLOB blob; 4074 struct PNP_SetHwProf *r; 4075 4076 call = &ndr_table_ntsvcs.calls[NDR_PNP_SETHWPROF]; 4077 4078 r = talloc(talloc_tos(), struct PNP_SetHwProf); 4079 if (r == NULL) { 4080 return false; 4081 } 4082 4083 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4084 talloc_free(r); 4085 return false; 4086 } 4087 4088 pull = ndr_pull_init_blob(&blob, r, NULL); 4089 if (pull == NULL) { 4090 talloc_free(r); 4091 return false; 4092 } 4093 4094 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4095 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4096 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4097 talloc_free(r); 4098 return false; 4099 } 4100 4101 if (DEBUGLEVEL >= 10) { 4102 NDR_PRINT_IN_DEBUG(PNP_SetHwProf, r); 4103 } 4104 4105 r->out.result = _PNP_SetHwProf(p, r); 4106 4107 if (p->rng_fault_state) { 4108 talloc_free(r); 4109 /* Return true here, srv_pipe_hnd.c will take care */ 4110 return true; 4111 } 4112 4113 if (DEBUGLEVEL >= 10) { 4114 NDR_PRINT_OUT_DEBUG(PNP_SetHwProf, r); 4115 } 4116 4117 push = ndr_push_init_ctx(r, NULL); 4118 if (push == NULL) { 4119 talloc_free(r); 4120 return false; 4121 } 4122 4123 ndr_err = call->ndr_push(push, NDR_OUT, r); 4124 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4125 talloc_free(r); 4126 return false; 4127 } 4128 4129 blob = ndr_push_blob(push); 4130 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4131 talloc_free(r); 4132 return false; 4133 } 4134 4135 talloc_free(r); 4136 4137 return true; 4138} 4139 4140static bool api_PNP_QueryArbitratorFreeData(pipes_struct *p) 4141{ 4142 const struct ndr_interface_call *call; 4143 struct ndr_pull *pull; 4144 struct ndr_push *push; 4145 enum ndr_err_code ndr_err; 4146 DATA_BLOB blob; 4147 struct PNP_QueryArbitratorFreeData *r; 4148 4149 call = &ndr_table_ntsvcs.calls[NDR_PNP_QUERYARBITRATORFREEDATA]; 4150 4151 r = talloc(talloc_tos(), struct PNP_QueryArbitratorFreeData); 4152 if (r == NULL) { 4153 return false; 4154 } 4155 4156 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4157 talloc_free(r); 4158 return false; 4159 } 4160 4161 pull = ndr_pull_init_blob(&blob, r, NULL); 4162 if (pull == NULL) { 4163 talloc_free(r); 4164 return false; 4165 } 4166 4167 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4168 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4169 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4170 talloc_free(r); 4171 return false; 4172 } 4173 4174 if (DEBUGLEVEL >= 10) { 4175 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeData, r); 4176 } 4177 4178 r->out.result = _PNP_QueryArbitratorFreeData(p, r); 4179 4180 if (p->rng_fault_state) { 4181 talloc_free(r); 4182 /* Return true here, srv_pipe_hnd.c will take care */ 4183 return true; 4184 } 4185 4186 if (DEBUGLEVEL >= 10) { 4187 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeData, r); 4188 } 4189 4190 push = ndr_push_init_ctx(r, NULL); 4191 if (push == NULL) { 4192 talloc_free(r); 4193 return false; 4194 } 4195 4196 ndr_err = call->ndr_push(push, NDR_OUT, r); 4197 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4198 talloc_free(r); 4199 return false; 4200 } 4201 4202 blob = ndr_push_blob(push); 4203 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4204 talloc_free(r); 4205 return false; 4206 } 4207 4208 talloc_free(r); 4209 4210 return true; 4211} 4212 4213static bool api_PNP_QueryArbitratorFreeSize(pipes_struct *p) 4214{ 4215 const struct ndr_interface_call *call; 4216 struct ndr_pull *pull; 4217 struct ndr_push *push; 4218 enum ndr_err_code ndr_err; 4219 DATA_BLOB blob; 4220 struct PNP_QueryArbitratorFreeSize *r; 4221 4222 call = &ndr_table_ntsvcs.calls[NDR_PNP_QUERYARBITRATORFREESIZE]; 4223 4224 r = talloc(talloc_tos(), struct PNP_QueryArbitratorFreeSize); 4225 if (r == NULL) { 4226 return false; 4227 } 4228 4229 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4230 talloc_free(r); 4231 return false; 4232 } 4233 4234 pull = ndr_pull_init_blob(&blob, r, NULL); 4235 if (pull == NULL) { 4236 talloc_free(r); 4237 return false; 4238 } 4239 4240 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4241 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4242 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4243 talloc_free(r); 4244 return false; 4245 } 4246 4247 if (DEBUGLEVEL >= 10) { 4248 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeSize, r); 4249 } 4250 4251 r->out.result = _PNP_QueryArbitratorFreeSize(p, r); 4252 4253 if (p->rng_fault_state) { 4254 talloc_free(r); 4255 /* Return true here, srv_pipe_hnd.c will take care */ 4256 return true; 4257 } 4258 4259 if (DEBUGLEVEL >= 10) { 4260 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeSize, r); 4261 } 4262 4263 push = ndr_push_init_ctx(r, NULL); 4264 if (push == NULL) { 4265 talloc_free(r); 4266 return false; 4267 } 4268 4269 ndr_err = call->ndr_push(push, NDR_OUT, r); 4270 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4271 talloc_free(r); 4272 return false; 4273 } 4274 4275 blob = ndr_push_blob(push); 4276 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4277 talloc_free(r); 4278 return false; 4279 } 4280 4281 talloc_free(r); 4282 4283 return true; 4284} 4285 4286static bool api_PNP_RunDetection(pipes_struct *p) 4287{ 4288 const struct ndr_interface_call *call; 4289 struct ndr_pull *pull; 4290 struct ndr_push *push; 4291 enum ndr_err_code ndr_err; 4292 DATA_BLOB blob; 4293 struct PNP_RunDetection *r; 4294 4295 call = &ndr_table_ntsvcs.calls[NDR_PNP_RUNDETECTION]; 4296 4297 r = talloc(talloc_tos(), struct PNP_RunDetection); 4298 if (r == NULL) { 4299 return false; 4300 } 4301 4302 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4303 talloc_free(r); 4304 return false; 4305 } 4306 4307 pull = ndr_pull_init_blob(&blob, r, NULL); 4308 if (pull == NULL) { 4309 talloc_free(r); 4310 return false; 4311 } 4312 4313 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4314 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4315 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4316 talloc_free(r); 4317 return false; 4318 } 4319 4320 if (DEBUGLEVEL >= 10) { 4321 NDR_PRINT_IN_DEBUG(PNP_RunDetection, r); 4322 } 4323 4324 r->out.result = _PNP_RunDetection(p, r); 4325 4326 if (p->rng_fault_state) { 4327 talloc_free(r); 4328 /* Return true here, srv_pipe_hnd.c will take care */ 4329 return true; 4330 } 4331 4332 if (DEBUGLEVEL >= 10) { 4333 NDR_PRINT_OUT_DEBUG(PNP_RunDetection, r); 4334 } 4335 4336 push = ndr_push_init_ctx(r, NULL); 4337 if (push == NULL) { 4338 talloc_free(r); 4339 return false; 4340 } 4341 4342 ndr_err = call->ndr_push(push, NDR_OUT, r); 4343 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4344 talloc_free(r); 4345 return false; 4346 } 4347 4348 blob = ndr_push_blob(push); 4349 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4350 talloc_free(r); 4351 return false; 4352 } 4353 4354 talloc_free(r); 4355 4356 return true; 4357} 4358 4359static bool api_PNP_RegisterNotification(pipes_struct *p) 4360{ 4361 const struct ndr_interface_call *call; 4362 struct ndr_pull *pull; 4363 struct ndr_push *push; 4364 enum ndr_err_code ndr_err; 4365 DATA_BLOB blob; 4366 struct PNP_RegisterNotification *r; 4367 4368 call = &ndr_table_ntsvcs.calls[NDR_PNP_REGISTERNOTIFICATION]; 4369 4370 r = talloc(talloc_tos(), struct PNP_RegisterNotification); 4371 if (r == NULL) { 4372 return false; 4373 } 4374 4375 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4376 talloc_free(r); 4377 return false; 4378 } 4379 4380 pull = ndr_pull_init_blob(&blob, r, NULL); 4381 if (pull == NULL) { 4382 talloc_free(r); 4383 return false; 4384 } 4385 4386 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4387 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4388 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4389 talloc_free(r); 4390 return false; 4391 } 4392 4393 if (DEBUGLEVEL >= 10) { 4394 NDR_PRINT_IN_DEBUG(PNP_RegisterNotification, r); 4395 } 4396 4397 r->out.result = _PNP_RegisterNotification(p, r); 4398 4399 if (p->rng_fault_state) { 4400 talloc_free(r); 4401 /* Return true here, srv_pipe_hnd.c will take care */ 4402 return true; 4403 } 4404 4405 if (DEBUGLEVEL >= 10) { 4406 NDR_PRINT_OUT_DEBUG(PNP_RegisterNotification, r); 4407 } 4408 4409 push = ndr_push_init_ctx(r, NULL); 4410 if (push == NULL) { 4411 talloc_free(r); 4412 return false; 4413 } 4414 4415 ndr_err = call->ndr_push(push, NDR_OUT, r); 4416 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4417 talloc_free(r); 4418 return false; 4419 } 4420 4421 blob = ndr_push_blob(push); 4422 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4423 talloc_free(r); 4424 return false; 4425 } 4426 4427 talloc_free(r); 4428 4429 return true; 4430} 4431 4432static bool api_PNP_UnregisterNotification(pipes_struct *p) 4433{ 4434 const struct ndr_interface_call *call; 4435 struct ndr_pull *pull; 4436 struct ndr_push *push; 4437 enum ndr_err_code ndr_err; 4438 DATA_BLOB blob; 4439 struct PNP_UnregisterNotification *r; 4440 4441 call = &ndr_table_ntsvcs.calls[NDR_PNP_UNREGISTERNOTIFICATION]; 4442 4443 r = talloc(talloc_tos(), struct PNP_UnregisterNotification); 4444 if (r == NULL) { 4445 return false; 4446 } 4447 4448 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4449 talloc_free(r); 4450 return false; 4451 } 4452 4453 pull = ndr_pull_init_blob(&blob, r, NULL); 4454 if (pull == NULL) { 4455 talloc_free(r); 4456 return false; 4457 } 4458 4459 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4460 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4461 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4462 talloc_free(r); 4463 return false; 4464 } 4465 4466 if (DEBUGLEVEL >= 10) { 4467 NDR_PRINT_IN_DEBUG(PNP_UnregisterNotification, r); 4468 } 4469 4470 r->out.result = _PNP_UnregisterNotification(p, r); 4471 4472 if (p->rng_fault_state) { 4473 talloc_free(r); 4474 /* Return true here, srv_pipe_hnd.c will take care */ 4475 return true; 4476 } 4477 4478 if (DEBUGLEVEL >= 10) { 4479 NDR_PRINT_OUT_DEBUG(PNP_UnregisterNotification, r); 4480 } 4481 4482 push = ndr_push_init_ctx(r, NULL); 4483 if (push == NULL) { 4484 talloc_free(r); 4485 return false; 4486 } 4487 4488 ndr_err = call->ndr_push(push, NDR_OUT, r); 4489 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4490 talloc_free(r); 4491 return false; 4492 } 4493 4494 blob = ndr_push_blob(push); 4495 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4496 talloc_free(r); 4497 return false; 4498 } 4499 4500 talloc_free(r); 4501 4502 return true; 4503} 4504 4505static bool api_PNP_GetCustomDevProp(pipes_struct *p) 4506{ 4507 const struct ndr_interface_call *call; 4508 struct ndr_pull *pull; 4509 struct ndr_push *push; 4510 enum ndr_err_code ndr_err; 4511 DATA_BLOB blob; 4512 struct PNP_GetCustomDevProp *r; 4513 4514 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCUSTOMDEVPROP]; 4515 4516 r = talloc(talloc_tos(), struct PNP_GetCustomDevProp); 4517 if (r == NULL) { 4518 return false; 4519 } 4520 4521 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4522 talloc_free(r); 4523 return false; 4524 } 4525 4526 pull = ndr_pull_init_blob(&blob, r, NULL); 4527 if (pull == NULL) { 4528 talloc_free(r); 4529 return false; 4530 } 4531 4532 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4533 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4534 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4535 talloc_free(r); 4536 return false; 4537 } 4538 4539 if (DEBUGLEVEL >= 10) { 4540 NDR_PRINT_IN_DEBUG(PNP_GetCustomDevProp, r); 4541 } 4542 4543 r->out.result = _PNP_GetCustomDevProp(p, r); 4544 4545 if (p->rng_fault_state) { 4546 talloc_free(r); 4547 /* Return true here, srv_pipe_hnd.c will take care */ 4548 return true; 4549 } 4550 4551 if (DEBUGLEVEL >= 10) { 4552 NDR_PRINT_OUT_DEBUG(PNP_GetCustomDevProp, r); 4553 } 4554 4555 push = ndr_push_init_ctx(r, NULL); 4556 if (push == NULL) { 4557 talloc_free(r); 4558 return false; 4559 } 4560 4561 ndr_err = call->ndr_push(push, NDR_OUT, r); 4562 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4563 talloc_free(r); 4564 return false; 4565 } 4566 4567 blob = ndr_push_blob(push); 4568 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4569 talloc_free(r); 4570 return false; 4571 } 4572 4573 talloc_free(r); 4574 4575 return true; 4576} 4577 4578static bool api_PNP_GetVersionInternal(pipes_struct *p) 4579{ 4580 const struct ndr_interface_call *call; 4581 struct ndr_pull *pull; 4582 struct ndr_push *push; 4583 enum ndr_err_code ndr_err; 4584 DATA_BLOB blob; 4585 struct PNP_GetVersionInternal *r; 4586 4587 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETVERSIONINTERNAL]; 4588 4589 r = talloc(talloc_tos(), struct PNP_GetVersionInternal); 4590 if (r == NULL) { 4591 return false; 4592 } 4593 4594 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4595 talloc_free(r); 4596 return false; 4597 } 4598 4599 pull = ndr_pull_init_blob(&blob, r, NULL); 4600 if (pull == NULL) { 4601 talloc_free(r); 4602 return false; 4603 } 4604 4605 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4606 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4607 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4608 talloc_free(r); 4609 return false; 4610 } 4611 4612 if (DEBUGLEVEL >= 10) { 4613 NDR_PRINT_IN_DEBUG(PNP_GetVersionInternal, r); 4614 } 4615 4616 r->out.result = _PNP_GetVersionInternal(p, r); 4617 4618 if (p->rng_fault_state) { 4619 talloc_free(r); 4620 /* Return true here, srv_pipe_hnd.c will take care */ 4621 return true; 4622 } 4623 4624 if (DEBUGLEVEL >= 10) { 4625 NDR_PRINT_OUT_DEBUG(PNP_GetVersionInternal, r); 4626 } 4627 4628 push = ndr_push_init_ctx(r, NULL); 4629 if (push == NULL) { 4630 talloc_free(r); 4631 return false; 4632 } 4633 4634 ndr_err = call->ndr_push(push, NDR_OUT, r); 4635 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4636 talloc_free(r); 4637 return false; 4638 } 4639 4640 blob = ndr_push_blob(push); 4641 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4642 talloc_free(r); 4643 return false; 4644 } 4645 4646 talloc_free(r); 4647 4648 return true; 4649} 4650 4651static bool api_PNP_GetBlockedDriverInfo(pipes_struct *p) 4652{ 4653 const struct ndr_interface_call *call; 4654 struct ndr_pull *pull; 4655 struct ndr_push *push; 4656 enum ndr_err_code ndr_err; 4657 DATA_BLOB blob; 4658 struct PNP_GetBlockedDriverInfo *r; 4659 4660 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETBLOCKEDDRIVERINFO]; 4661 4662 r = talloc(talloc_tos(), struct PNP_GetBlockedDriverInfo); 4663 if (r == NULL) { 4664 return false; 4665 } 4666 4667 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4668 talloc_free(r); 4669 return false; 4670 } 4671 4672 pull = ndr_pull_init_blob(&blob, r, NULL); 4673 if (pull == NULL) { 4674 talloc_free(r); 4675 return false; 4676 } 4677 4678 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4679 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4680 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4681 talloc_free(r); 4682 return false; 4683 } 4684 4685 if (DEBUGLEVEL >= 10) { 4686 NDR_PRINT_IN_DEBUG(PNP_GetBlockedDriverInfo, r); 4687 } 4688 4689 r->out.result = _PNP_GetBlockedDriverInfo(p, r); 4690 4691 if (p->rng_fault_state) { 4692 talloc_free(r); 4693 /* Return true here, srv_pipe_hnd.c will take care */ 4694 return true; 4695 } 4696 4697 if (DEBUGLEVEL >= 10) { 4698 NDR_PRINT_OUT_DEBUG(PNP_GetBlockedDriverInfo, r); 4699 } 4700 4701 push = ndr_push_init_ctx(r, NULL); 4702 if (push == NULL) { 4703 talloc_free(r); 4704 return false; 4705 } 4706 4707 ndr_err = call->ndr_push(push, NDR_OUT, r); 4708 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4709 talloc_free(r); 4710 return false; 4711 } 4712 4713 blob = ndr_push_blob(push); 4714 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4715 talloc_free(r); 4716 return false; 4717 } 4718 4719 talloc_free(r); 4720 4721 return true; 4722} 4723 4724static bool api_PNP_GetServerSideDeviceInstallFlags(pipes_struct *p) 4725{ 4726 const struct ndr_interface_call *call; 4727 struct ndr_pull *pull; 4728 struct ndr_push *push; 4729 enum ndr_err_code ndr_err; 4730 DATA_BLOB blob; 4731 struct PNP_GetServerSideDeviceInstallFlags *r; 4732 4733 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS]; 4734 4735 r = talloc(talloc_tos(), struct PNP_GetServerSideDeviceInstallFlags); 4736 if (r == NULL) { 4737 return false; 4738 } 4739 4740 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4741 talloc_free(r); 4742 return false; 4743 } 4744 4745 pull = ndr_pull_init_blob(&blob, r, NULL); 4746 if (pull == NULL) { 4747 talloc_free(r); 4748 return false; 4749 } 4750 4751 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4752 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4753 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4754 talloc_free(r); 4755 return false; 4756 } 4757 4758 if (DEBUGLEVEL >= 10) { 4759 NDR_PRINT_IN_DEBUG(PNP_GetServerSideDeviceInstallFlags, r); 4760 } 4761 4762 r->out.result = _PNP_GetServerSideDeviceInstallFlags(p, r); 4763 4764 if (p->rng_fault_state) { 4765 talloc_free(r); 4766 /* Return true here, srv_pipe_hnd.c will take care */ 4767 return true; 4768 } 4769 4770 if (DEBUGLEVEL >= 10) { 4771 NDR_PRINT_OUT_DEBUG(PNP_GetServerSideDeviceInstallFlags, r); 4772 } 4773 4774 push = ndr_push_init_ctx(r, NULL); 4775 if (push == NULL) { 4776 talloc_free(r); 4777 return false; 4778 } 4779 4780 ndr_err = call->ndr_push(push, NDR_OUT, r); 4781 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4782 talloc_free(r); 4783 return false; 4784 } 4785 4786 blob = ndr_push_blob(push); 4787 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4788 talloc_free(r); 4789 return false; 4790 } 4791 4792 talloc_free(r); 4793 4794 return true; 4795} 4796 4797 4798/* Tables */ 4799static struct api_struct api_ntsvcs_cmds[] = 4800{ 4801 {"PNP_DISCONNECT", NDR_PNP_DISCONNECT, api_PNP_Disconnect}, 4802 {"PNP_CONNECT", NDR_PNP_CONNECT, api_PNP_Connect}, 4803 {"PNP_GETVERSION", NDR_PNP_GETVERSION, api_PNP_GetVersion}, 4804 {"PNP_GETGLOBALSTATE", NDR_PNP_GETGLOBALSTATE, api_PNP_GetGlobalState}, 4805 {"PNP_INITDETECTION", NDR_PNP_INITDETECTION, api_PNP_InitDetection}, 4806 {"PNP_REPORTLOGON", NDR_PNP_REPORTLOGON, api_PNP_ReportLogOn}, 4807 {"PNP_VALIDATEDEVICEINSTANCE", NDR_PNP_VALIDATEDEVICEINSTANCE, api_PNP_ValidateDeviceInstance}, 4808 {"PNP_GETROOTDEVICEINSTANCE", NDR_PNP_GETROOTDEVICEINSTANCE, api_PNP_GetRootDeviceInstance}, 4809 {"PNP_GETRELATEDDEVICEINSTANCE", NDR_PNP_GETRELATEDDEVICEINSTANCE, api_PNP_GetRelatedDeviceInstance}, 4810 {"PNP_ENUMERATESUBKEYS", NDR_PNP_ENUMERATESUBKEYS, api_PNP_EnumerateSubKeys}, 4811 {"PNP_GETDEVICELIST", NDR_PNP_GETDEVICELIST, api_PNP_GetDeviceList}, 4812 {"PNP_GETDEVICELISTSIZE", NDR_PNP_GETDEVICELISTSIZE, api_PNP_GetDeviceListSize}, 4813 {"PNP_GETDEPTH", NDR_PNP_GETDEPTH, api_PNP_GetDepth}, 4814 {"PNP_GETDEVICEREGPROP", NDR_PNP_GETDEVICEREGPROP, api_PNP_GetDeviceRegProp}, 4815 {"PNP_SETDEVICEREGPROP", NDR_PNP_SETDEVICEREGPROP, api_PNP_SetDeviceRegProp}, 4816 {"PNP_GETCLASSINSTANCE", NDR_PNP_GETCLASSINSTANCE, api_PNP_GetClassInstance}, 4817 {"PNP_CREATEKEY", NDR_PNP_CREATEKEY, api_PNP_CreateKey}, 4818 {"PNP_DELETEREGISTRYKEY", NDR_PNP_DELETEREGISTRYKEY, api_PNP_DeleteRegistryKey}, 4819 {"PNP_GETCLASSCOUNT", NDR_PNP_GETCLASSCOUNT, api_PNP_GetClassCount}, 4820 {"PNP_GETCLASSNAME", NDR_PNP_GETCLASSNAME, api_PNP_GetClassName}, 4821 {"PNP_DELETECLASSKEY", NDR_PNP_DELETECLASSKEY, api_PNP_DeleteClassKey}, 4822 {"PNP_GETINTERFACEDEVICEALIAS", NDR_PNP_GETINTERFACEDEVICEALIAS, api_PNP_GetInterfaceDeviceAlias}, 4823 {"PNP_GETINTERFACEDEVICELIST", NDR_PNP_GETINTERFACEDEVICELIST, api_PNP_GetInterfaceDeviceList}, 4824 {"PNP_GETINTERFACEDEVICELISTSIZE", NDR_PNP_GETINTERFACEDEVICELISTSIZE, api_PNP_GetInterfaceDeviceListSize}, 4825 {"PNP_REGISTERDEVICECLASSASSOCIATION", NDR_PNP_REGISTERDEVICECLASSASSOCIATION, api_PNP_RegisterDeviceClassAssociation}, 4826 {"PNP_UNREGISTERDEVICECLASSASSOCIATION", NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION, api_PNP_UnregisterDeviceClassAssociation}, 4827 {"PNP_GETCLASSREGPROP", NDR_PNP_GETCLASSREGPROP, api_PNP_GetClassRegProp}, 4828 {"PNP_SETCLASSREGPROP", NDR_PNP_SETCLASSREGPROP, api_PNP_SetClassRegProp}, 4829 {"PNP_CREATEDEVINST", NDR_PNP_CREATEDEVINST, api_PNP_CreateDevInst}, 4830 {"PNP_DEVICEINSTANCEACTION", NDR_PNP_DEVICEINSTANCEACTION, api_PNP_DeviceInstanceAction}, 4831 {"PNP_GETDEVICESTATUS", NDR_PNP_GETDEVICESTATUS, api_PNP_GetDeviceStatus}, 4832 {"PNP_SETDEVICEPROBLEM", NDR_PNP_SETDEVICEPROBLEM, api_PNP_SetDeviceProblem}, 4833 {"PNP_DISABLEDEVINST", NDR_PNP_DISABLEDEVINST, api_PNP_DisableDevInst}, 4834 {"PNP_UNINSTALLDEVINST", NDR_PNP_UNINSTALLDEVINST, api_PNP_UninstallDevInst}, 4835 {"PNP_ADDID", NDR_PNP_ADDID, api_PNP_AddID}, 4836 {"PNP_REGISTERDRIVER", NDR_PNP_REGISTERDRIVER, api_PNP_RegisterDriver}, 4837 {"PNP_QUERYREMOVE", NDR_PNP_QUERYREMOVE, api_PNP_QueryRemove}, 4838 {"PNP_REQUESTDEVICEEJECT", NDR_PNP_REQUESTDEVICEEJECT, api_PNP_RequestDeviceEject}, 4839 {"PNP_ISDOCKSTATIONPRESENT", NDR_PNP_ISDOCKSTATIONPRESENT, api_PNP_IsDockStationPresent}, 4840 {"PNP_REQUESTEJECTPC", NDR_PNP_REQUESTEJECTPC, api_PNP_RequestEjectPC}, 4841 {"PNP_HWPROFFLAGS", NDR_PNP_HWPROFFLAGS, api_PNP_HwProfFlags}, 4842 {"PNP_GETHWPROFINFO", NDR_PNP_GETHWPROFINFO, api_PNP_GetHwProfInfo}, 4843 {"PNP_ADDEMPTYLOGCONF", NDR_PNP_ADDEMPTYLOGCONF, api_PNP_AddEmptyLogConf}, 4844 {"PNP_FREELOGCONF", NDR_PNP_FREELOGCONF, api_PNP_FreeLogConf}, 4845 {"PNP_GETFIRSTLOGCONF", NDR_PNP_GETFIRSTLOGCONF, api_PNP_GetFirstLogConf}, 4846 {"PNP_GETNEXTLOGCONF", NDR_PNP_GETNEXTLOGCONF, api_PNP_GetNextLogConf}, 4847 {"PNP_GETLOGCONFPRIORITY", NDR_PNP_GETLOGCONFPRIORITY, api_PNP_GetLogConfPriority}, 4848 {"PNP_ADDRESDES", NDR_PNP_ADDRESDES, api_PNP_AddResDes}, 4849 {"PNP_FREERESDES", NDR_PNP_FREERESDES, api_PNP_FreeResDes}, 4850 {"PNP_GETNEXTRESDES", NDR_PNP_GETNEXTRESDES, api_PNP_GetNextResDes}, 4851 {"PNP_GETRESDESDATA", NDR_PNP_GETRESDESDATA, api_PNP_GetResDesData}, 4852 {"PNP_GETRESDESDATASIZE", NDR_PNP_GETRESDESDATASIZE, api_PNP_GetResDesDataSize}, 4853 {"PNP_MODIFYRESDES", NDR_PNP_MODIFYRESDES, api_PNP_ModifyResDes}, 4854 {"PNP_DETECTRESOURCELIMIT", NDR_PNP_DETECTRESOURCELIMIT, api_PNP_DetectResourceLimit}, 4855 {"PNP_QUERYRESCONFLIST", NDR_PNP_QUERYRESCONFLIST, api_PNP_QueryResConfList}, 4856 {"PNP_SETHWPROF", NDR_PNP_SETHWPROF, api_PNP_SetHwProf}, 4857 {"PNP_QUERYARBITRATORFREEDATA", NDR_PNP_QUERYARBITRATORFREEDATA, api_PNP_QueryArbitratorFreeData}, 4858 {"PNP_QUERYARBITRATORFREESIZE", NDR_PNP_QUERYARBITRATORFREESIZE, api_PNP_QueryArbitratorFreeSize}, 4859 {"PNP_RUNDETECTION", NDR_PNP_RUNDETECTION, api_PNP_RunDetection}, 4860 {"PNP_REGISTERNOTIFICATION", NDR_PNP_REGISTERNOTIFICATION, api_PNP_RegisterNotification}, 4861 {"PNP_UNREGISTERNOTIFICATION", NDR_PNP_UNREGISTERNOTIFICATION, api_PNP_UnregisterNotification}, 4862 {"PNP_GETCUSTOMDEVPROP", NDR_PNP_GETCUSTOMDEVPROP, api_PNP_GetCustomDevProp}, 4863 {"PNP_GETVERSIONINTERNAL", NDR_PNP_GETVERSIONINTERNAL, api_PNP_GetVersionInternal}, 4864 {"PNP_GETBLOCKEDDRIVERINFO", NDR_PNP_GETBLOCKEDDRIVERINFO, api_PNP_GetBlockedDriverInfo}, 4865 {"PNP_GETSERVERSIDEDEVICEINSTALLFLAGS", NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS, api_PNP_GetServerSideDeviceInstallFlags}, 4866}; 4867 4868void ntsvcs_get_pipe_fns(struct api_struct **fns, int *n_fns) 4869{ 4870 *fns = api_ntsvcs_cmds; 4871 *n_fns = sizeof(api_ntsvcs_cmds) / sizeof(struct api_struct); 4872} 4873 4874NTSTATUS rpc_ntsvcs_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r) 4875{ 4876 if (cli->pipes_struct == NULL) { 4877 return NT_STATUS_INVALID_PARAMETER; 4878 } 4879 4880 switch (opnum) 4881 { 4882 case NDR_PNP_DISCONNECT: { 4883 struct PNP_Disconnect *r = (struct PNP_Disconnect *)_r; 4884 r->out.result = _PNP_Disconnect(cli->pipes_struct, r); 4885 return NT_STATUS_OK; 4886 } 4887 4888 case NDR_PNP_CONNECT: { 4889 struct PNP_Connect *r = (struct PNP_Connect *)_r; 4890 r->out.result = _PNP_Connect(cli->pipes_struct, r); 4891 return NT_STATUS_OK; 4892 } 4893 4894 case NDR_PNP_GETVERSION: { 4895 struct PNP_GetVersion *r = (struct PNP_GetVersion *)_r; 4896 ZERO_STRUCT(r->out); 4897 r->out.version = talloc_zero(mem_ctx, uint16_t); 4898 if (r->out.version == NULL) { 4899 return NT_STATUS_NO_MEMORY; 4900 } 4901 4902 r->out.result = _PNP_GetVersion(cli->pipes_struct, r); 4903 return NT_STATUS_OK; 4904 } 4905 4906 case NDR_PNP_GETGLOBALSTATE: { 4907 struct PNP_GetGlobalState *r = (struct PNP_GetGlobalState *)_r; 4908 r->out.result = _PNP_GetGlobalState(cli->pipes_struct, r); 4909 return NT_STATUS_OK; 4910 } 4911 4912 case NDR_PNP_INITDETECTION: { 4913 struct PNP_InitDetection *r = (struct PNP_InitDetection *)_r; 4914 r->out.result = _PNP_InitDetection(cli->pipes_struct, r); 4915 return NT_STATUS_OK; 4916 } 4917 4918 case NDR_PNP_REPORTLOGON: { 4919 struct PNP_ReportLogOn *r = (struct PNP_ReportLogOn *)_r; 4920 r->out.result = _PNP_ReportLogOn(cli->pipes_struct, r); 4921 return NT_STATUS_OK; 4922 } 4923 4924 case NDR_PNP_VALIDATEDEVICEINSTANCE: { 4925 struct PNP_ValidateDeviceInstance *r = (struct PNP_ValidateDeviceInstance *)_r; 4926 r->out.result = _PNP_ValidateDeviceInstance(cli->pipes_struct, r); 4927 return NT_STATUS_OK; 4928 } 4929 4930 case NDR_PNP_GETROOTDEVICEINSTANCE: { 4931 struct PNP_GetRootDeviceInstance *r = (struct PNP_GetRootDeviceInstance *)_r; 4932 r->out.result = _PNP_GetRootDeviceInstance(cli->pipes_struct, r); 4933 return NT_STATUS_OK; 4934 } 4935 4936 case NDR_PNP_GETRELATEDDEVICEINSTANCE: { 4937 struct PNP_GetRelatedDeviceInstance *r = (struct PNP_GetRelatedDeviceInstance *)_r; 4938 r->out.result = _PNP_GetRelatedDeviceInstance(cli->pipes_struct, r); 4939 return NT_STATUS_OK; 4940 } 4941 4942 case NDR_PNP_ENUMERATESUBKEYS: { 4943 struct PNP_EnumerateSubKeys *r = (struct PNP_EnumerateSubKeys *)_r; 4944 r->out.result = _PNP_EnumerateSubKeys(cli->pipes_struct, r); 4945 return NT_STATUS_OK; 4946 } 4947 4948 case NDR_PNP_GETDEVICELIST: { 4949 struct PNP_GetDeviceList *r = (struct PNP_GetDeviceList *)_r; 4950 ZERO_STRUCT(r->out); 4951 r->out.length = r->in.length; 4952 r->out.buffer = talloc_zero_array(mem_ctx, uint16_t, *r->out.length); 4953 if (r->out.buffer == NULL) { 4954 return NT_STATUS_NO_MEMORY; 4955 } 4956 4957 r->out.result = _PNP_GetDeviceList(cli->pipes_struct, r); 4958 return NT_STATUS_OK; 4959 } 4960 4961 case NDR_PNP_GETDEVICELISTSIZE: { 4962 struct PNP_GetDeviceListSize *r = (struct PNP_GetDeviceListSize *)_r; 4963 ZERO_STRUCT(r->out); 4964 r->out.size = talloc_zero(mem_ctx, uint32_t); 4965 if (r->out.size == NULL) { 4966 return NT_STATUS_NO_MEMORY; 4967 } 4968 4969 r->out.result = _PNP_GetDeviceListSize(cli->pipes_struct, r); 4970 return NT_STATUS_OK; 4971 } 4972 4973 case NDR_PNP_GETDEPTH: { 4974 struct PNP_GetDepth *r = (struct PNP_GetDepth *)_r; 4975 r->out.result = _PNP_GetDepth(cli->pipes_struct, r); 4976 return NT_STATUS_OK; 4977 } 4978 4979 case NDR_PNP_GETDEVICEREGPROP: { 4980 struct PNP_GetDeviceRegProp *r = (struct PNP_GetDeviceRegProp *)_r; 4981 ZERO_STRUCT(r->out); 4982 r->out.reg_data_type = r->in.reg_data_type; 4983 r->out.buffer_size = r->in.buffer_size; 4984 r->out.needed = r->in.needed; 4985 r->out.buffer = talloc_zero_array(mem_ctx, uint8_t, *r->out.buffer_size); 4986 if (r->out.buffer == NULL) { 4987 return NT_STATUS_NO_MEMORY; 4988 } 4989 4990 r->out.result = _PNP_GetDeviceRegProp(cli->pipes_struct, r); 4991 return NT_STATUS_OK; 4992 } 4993 4994 case NDR_PNP_SETDEVICEREGPROP: { 4995 struct PNP_SetDeviceRegProp *r = (struct PNP_SetDeviceRegProp *)_r; 4996 r->out.result = _PNP_SetDeviceRegProp(cli->pipes_struct, r); 4997 return NT_STATUS_OK; 4998 } 4999 5000 case NDR_PNP_GETCLASSINSTANCE: { 5001 struct PNP_GetClassInstance *r = (struct PNP_GetClassInstance *)_r; 5002 r->out.result = _PNP_GetClassInstance(cli->pipes_struct, r); 5003 return NT_STATUS_OK; 5004 } 5005 5006 case NDR_PNP_CREATEKEY: { 5007 struct PNP_CreateKey *r = (struct PNP_CreateKey *)_r; 5008 r->out.result = _PNP_CreateKey(cli->pipes_struct, r); 5009 return NT_STATUS_OK; 5010 } 5011 5012 case NDR_PNP_DELETEREGISTRYKEY: { 5013 struct PNP_DeleteRegistryKey *r = (struct PNP_DeleteRegistryKey *)_r; 5014 r->out.result = _PNP_DeleteRegistryKey(cli->pipes_struct, r); 5015 return NT_STATUS_OK; 5016 } 5017 5018 case NDR_PNP_GETCLASSCOUNT: { 5019 struct PNP_GetClassCount *r = (struct PNP_GetClassCount *)_r; 5020 r->out.result = _PNP_GetClassCount(cli->pipes_struct, r); 5021 return NT_STATUS_OK; 5022 } 5023 5024 case NDR_PNP_GETCLASSNAME: { 5025 struct PNP_GetClassName *r = (struct PNP_GetClassName *)_r; 5026 r->out.result = _PNP_GetClassName(cli->pipes_struct, r); 5027 return NT_STATUS_OK; 5028 } 5029 5030 case NDR_PNP_DELETECLASSKEY: { 5031 struct PNP_DeleteClassKey *r = (struct PNP_DeleteClassKey *)_r; 5032 r->out.result = _PNP_DeleteClassKey(cli->pipes_struct, r); 5033 return NT_STATUS_OK; 5034 } 5035 5036 case NDR_PNP_GETINTERFACEDEVICEALIAS: { 5037 struct PNP_GetInterfaceDeviceAlias *r = (struct PNP_GetInterfaceDeviceAlias *)_r; 5038 r->out.result = _PNP_GetInterfaceDeviceAlias(cli->pipes_struct, r); 5039 return NT_STATUS_OK; 5040 } 5041 5042 case NDR_PNP_GETINTERFACEDEVICELIST: { 5043 struct PNP_GetInterfaceDeviceList *r = (struct PNP_GetInterfaceDeviceList *)_r; 5044 r->out.result = _PNP_GetInterfaceDeviceList(cli->pipes_struct, r); 5045 return NT_STATUS_OK; 5046 } 5047 5048 case NDR_PNP_GETINTERFACEDEVICELISTSIZE: { 5049 struct PNP_GetInterfaceDeviceListSize *r = (struct PNP_GetInterfaceDeviceListSize *)_r; 5050 r->out.result = _PNP_GetInterfaceDeviceListSize(cli->pipes_struct, r); 5051 return NT_STATUS_OK; 5052 } 5053 5054 case NDR_PNP_REGISTERDEVICECLASSASSOCIATION: { 5055 struct PNP_RegisterDeviceClassAssociation *r = (struct PNP_RegisterDeviceClassAssociation *)_r; 5056 r->out.result = _PNP_RegisterDeviceClassAssociation(cli->pipes_struct, r); 5057 return NT_STATUS_OK; 5058 } 5059 5060 case NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION: { 5061 struct PNP_UnregisterDeviceClassAssociation *r = (struct PNP_UnregisterDeviceClassAssociation *)_r; 5062 r->out.result = _PNP_UnregisterDeviceClassAssociation(cli->pipes_struct, r); 5063 return NT_STATUS_OK; 5064 } 5065 5066 case NDR_PNP_GETCLASSREGPROP: { 5067 struct PNP_GetClassRegProp *r = (struct PNP_GetClassRegProp *)_r; 5068 r->out.result = _PNP_GetClassRegProp(cli->pipes_struct, r); 5069 return NT_STATUS_OK; 5070 } 5071 5072 case NDR_PNP_SETCLASSREGPROP: { 5073 struct PNP_SetClassRegProp *r = (struct PNP_SetClassRegProp *)_r; 5074 r->out.result = _PNP_SetClassRegProp(cli->pipes_struct, r); 5075 return NT_STATUS_OK; 5076 } 5077 5078 case NDR_PNP_CREATEDEVINST: { 5079 struct PNP_CreateDevInst *r = (struct PNP_CreateDevInst *)_r; 5080 r->out.result = _PNP_CreateDevInst(cli->pipes_struct, r); 5081 return NT_STATUS_OK; 5082 } 5083 5084 case NDR_PNP_DEVICEINSTANCEACTION: { 5085 struct PNP_DeviceInstanceAction *r = (struct PNP_DeviceInstanceAction *)_r; 5086 r->out.result = _PNP_DeviceInstanceAction(cli->pipes_struct, r); 5087 return NT_STATUS_OK; 5088 } 5089 5090 case NDR_PNP_GETDEVICESTATUS: { 5091 struct PNP_GetDeviceStatus *r = (struct PNP_GetDeviceStatus *)_r; 5092 r->out.result = _PNP_GetDeviceStatus(cli->pipes_struct, r); 5093 return NT_STATUS_OK; 5094 } 5095 5096 case NDR_PNP_SETDEVICEPROBLEM: { 5097 struct PNP_SetDeviceProblem *r = (struct PNP_SetDeviceProblem *)_r; 5098 r->out.result = _PNP_SetDeviceProblem(cli->pipes_struct, r); 5099 return NT_STATUS_OK; 5100 } 5101 5102 case NDR_PNP_DISABLEDEVINST: { 5103 struct PNP_DisableDevInst *r = (struct PNP_DisableDevInst *)_r; 5104 r->out.result = _PNP_DisableDevInst(cli->pipes_struct, r); 5105 return NT_STATUS_OK; 5106 } 5107 5108 case NDR_PNP_UNINSTALLDEVINST: { 5109 struct PNP_UninstallDevInst *r = (struct PNP_UninstallDevInst *)_r; 5110 r->out.result = _PNP_UninstallDevInst(cli->pipes_struct, r); 5111 return NT_STATUS_OK; 5112 } 5113 5114 case NDR_PNP_ADDID: { 5115 struct PNP_AddID *r = (struct PNP_AddID *)_r; 5116 r->out.result = _PNP_AddID(cli->pipes_struct, r); 5117 return NT_STATUS_OK; 5118 } 5119 5120 case NDR_PNP_REGISTERDRIVER: { 5121 struct PNP_RegisterDriver *r = (struct PNP_RegisterDriver *)_r; 5122 r->out.result = _PNP_RegisterDriver(cli->pipes_struct, r); 5123 return NT_STATUS_OK; 5124 } 5125 5126 case NDR_PNP_QUERYREMOVE: { 5127 struct PNP_QueryRemove *r = (struct PNP_QueryRemove *)_r; 5128 r->out.result = _PNP_QueryRemove(cli->pipes_struct, r); 5129 return NT_STATUS_OK; 5130 } 5131 5132 case NDR_PNP_REQUESTDEVICEEJECT: { 5133 struct PNP_RequestDeviceEject *r = (struct PNP_RequestDeviceEject *)_r; 5134 r->out.result = _PNP_RequestDeviceEject(cli->pipes_struct, r); 5135 return NT_STATUS_OK; 5136 } 5137 5138 case NDR_PNP_ISDOCKSTATIONPRESENT: { 5139 struct PNP_IsDockStationPresent *r = (struct PNP_IsDockStationPresent *)_r; 5140 r->out.result = _PNP_IsDockStationPresent(cli->pipes_struct, r); 5141 return NT_STATUS_OK; 5142 } 5143 5144 case NDR_PNP_REQUESTEJECTPC: { 5145 struct PNP_RequestEjectPC *r = (struct PNP_RequestEjectPC *)_r; 5146 r->out.result = _PNP_RequestEjectPC(cli->pipes_struct, r); 5147 return NT_STATUS_OK; 5148 } 5149 5150 case NDR_PNP_HWPROFFLAGS: { 5151 struct PNP_HwProfFlags *r = (struct PNP_HwProfFlags *)_r; 5152 ZERO_STRUCT(r->out); 5153 r->out.profile_flags = r->in.profile_flags; 5154 r->out.veto_type = r->in.veto_type; 5155 r->out.unknown5a = talloc_zero(mem_ctx, const char *); 5156 if (r->out.unknown5a == NULL) { 5157 return NT_STATUS_NO_MEMORY; 5158 } 5159 5160 r->out.result = _PNP_HwProfFlags(cli->pipes_struct, r); 5161 return NT_STATUS_OK; 5162 } 5163 5164 case NDR_PNP_GETHWPROFINFO: { 5165 struct PNP_GetHwProfInfo *r = (struct PNP_GetHwProfInfo *)_r; 5166 ZERO_STRUCT(r->out); 5167 r->out.info = r->in.info; 5168 r->out.result = _PNP_GetHwProfInfo(cli->pipes_struct, r); 5169 return NT_STATUS_OK; 5170 } 5171 5172 case NDR_PNP_ADDEMPTYLOGCONF: { 5173 struct PNP_AddEmptyLogConf *r = (struct PNP_AddEmptyLogConf *)_r; 5174 r->out.result = _PNP_AddEmptyLogConf(cli->pipes_struct, r); 5175 return NT_STATUS_OK; 5176 } 5177 5178 case NDR_PNP_FREELOGCONF: { 5179 struct PNP_FreeLogConf *r = (struct PNP_FreeLogConf *)_r; 5180 r->out.result = _PNP_FreeLogConf(cli->pipes_struct, r); 5181 return NT_STATUS_OK; 5182 } 5183 5184 case NDR_PNP_GETFIRSTLOGCONF: { 5185 struct PNP_GetFirstLogConf *r = (struct PNP_GetFirstLogConf *)_r; 5186 r->out.result = _PNP_GetFirstLogConf(cli->pipes_struct, r); 5187 return NT_STATUS_OK; 5188 } 5189 5190 case NDR_PNP_GETNEXTLOGCONF: { 5191 struct PNP_GetNextLogConf *r = (struct PNP_GetNextLogConf *)_r; 5192 r->out.result = _PNP_GetNextLogConf(cli->pipes_struct, r); 5193 return NT_STATUS_OK; 5194 } 5195 5196 case NDR_PNP_GETLOGCONFPRIORITY: { 5197 struct PNP_GetLogConfPriority *r = (struct PNP_GetLogConfPriority *)_r; 5198 r->out.result = _PNP_GetLogConfPriority(cli->pipes_struct, r); 5199 return NT_STATUS_OK; 5200 } 5201 5202 case NDR_PNP_ADDRESDES: { 5203 struct PNP_AddResDes *r = (struct PNP_AddResDes *)_r; 5204 r->out.result = _PNP_AddResDes(cli->pipes_struct, r); 5205 return NT_STATUS_OK; 5206 } 5207 5208 case NDR_PNP_FREERESDES: { 5209 struct PNP_FreeResDes *r = (struct PNP_FreeResDes *)_r; 5210 r->out.result = _PNP_FreeResDes(cli->pipes_struct, r); 5211 return NT_STATUS_OK; 5212 } 5213 5214 case NDR_PNP_GETNEXTRESDES: { 5215 struct PNP_GetNextResDes *r = (struct PNP_GetNextResDes *)_r; 5216 r->out.result = _PNP_GetNextResDes(cli->pipes_struct, r); 5217 return NT_STATUS_OK; 5218 } 5219 5220 case NDR_PNP_GETRESDESDATA: { 5221 struct PNP_GetResDesData *r = (struct PNP_GetResDesData *)_r; 5222 r->out.result = _PNP_GetResDesData(cli->pipes_struct, r); 5223 return NT_STATUS_OK; 5224 } 5225 5226 case NDR_PNP_GETRESDESDATASIZE: { 5227 struct PNP_GetResDesDataSize *r = (struct PNP_GetResDesDataSize *)_r; 5228 r->out.result = _PNP_GetResDesDataSize(cli->pipes_struct, r); 5229 return NT_STATUS_OK; 5230 } 5231 5232 case NDR_PNP_MODIFYRESDES: { 5233 struct PNP_ModifyResDes *r = (struct PNP_ModifyResDes *)_r; 5234 r->out.result = _PNP_ModifyResDes(cli->pipes_struct, r); 5235 return NT_STATUS_OK; 5236 } 5237 5238 case NDR_PNP_DETECTRESOURCELIMIT: { 5239 struct PNP_DetectResourceLimit *r = (struct PNP_DetectResourceLimit *)_r; 5240 r->out.result = _PNP_DetectResourceLimit(cli->pipes_struct, r); 5241 return NT_STATUS_OK; 5242 } 5243 5244 case NDR_PNP_QUERYRESCONFLIST: { 5245 struct PNP_QueryResConfList *r = (struct PNP_QueryResConfList *)_r; 5246 r->out.result = _PNP_QueryResConfList(cli->pipes_struct, r); 5247 return NT_STATUS_OK; 5248 } 5249 5250 case NDR_PNP_SETHWPROF: { 5251 struct PNP_SetHwProf *r = (struct PNP_SetHwProf *)_r; 5252 r->out.result = _PNP_SetHwProf(cli->pipes_struct, r); 5253 return NT_STATUS_OK; 5254 } 5255 5256 case NDR_PNP_QUERYARBITRATORFREEDATA: { 5257 struct PNP_QueryArbitratorFreeData *r = (struct PNP_QueryArbitratorFreeData *)_r; 5258 r->out.result = _PNP_QueryArbitratorFreeData(cli->pipes_struct, r); 5259 return NT_STATUS_OK; 5260 } 5261 5262 case NDR_PNP_QUERYARBITRATORFREESIZE: { 5263 struct PNP_QueryArbitratorFreeSize *r = (struct PNP_QueryArbitratorFreeSize *)_r; 5264 r->out.result = _PNP_QueryArbitratorFreeSize(cli->pipes_struct, r); 5265 return NT_STATUS_OK; 5266 } 5267 5268 case NDR_PNP_RUNDETECTION: { 5269 struct PNP_RunDetection *r = (struct PNP_RunDetection *)_r; 5270 r->out.result = _PNP_RunDetection(cli->pipes_struct, r); 5271 return NT_STATUS_OK; 5272 } 5273 5274 case NDR_PNP_REGISTERNOTIFICATION: { 5275 struct PNP_RegisterNotification *r = (struct PNP_RegisterNotification *)_r; 5276 r->out.result = _PNP_RegisterNotification(cli->pipes_struct, r); 5277 return NT_STATUS_OK; 5278 } 5279 5280 case NDR_PNP_UNREGISTERNOTIFICATION: { 5281 struct PNP_UnregisterNotification *r = (struct PNP_UnregisterNotification *)_r; 5282 r->out.result = _PNP_UnregisterNotification(cli->pipes_struct, r); 5283 return NT_STATUS_OK; 5284 } 5285 5286 case NDR_PNP_GETCUSTOMDEVPROP: { 5287 struct PNP_GetCustomDevProp *r = (struct PNP_GetCustomDevProp *)_r; 5288 r->out.result = _PNP_GetCustomDevProp(cli->pipes_struct, r); 5289 return NT_STATUS_OK; 5290 } 5291 5292 case NDR_PNP_GETVERSIONINTERNAL: { 5293 struct PNP_GetVersionInternal *r = (struct PNP_GetVersionInternal *)_r; 5294 r->out.result = _PNP_GetVersionInternal(cli->pipes_struct, r); 5295 return NT_STATUS_OK; 5296 } 5297 5298 case NDR_PNP_GETBLOCKEDDRIVERINFO: { 5299 struct PNP_GetBlockedDriverInfo *r = (struct PNP_GetBlockedDriverInfo *)_r; 5300 r->out.result = _PNP_GetBlockedDriverInfo(cli->pipes_struct, r); 5301 return NT_STATUS_OK; 5302 } 5303 5304 case NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS: { 5305 struct PNP_GetServerSideDeviceInstallFlags *r = (struct PNP_GetServerSideDeviceInstallFlags *)_r; 5306 r->out.result = _PNP_GetServerSideDeviceInstallFlags(cli->pipes_struct, r); 5307 return NT_STATUS_OK; 5308 } 5309 5310 default: 5311 return NT_STATUS_NOT_IMPLEMENTED; 5312 } 5313} 5314 5315NTSTATUS rpc_ntsvcs_init(void) 5316{ 5317 return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "ntsvcs", "ntsvcs", &ndr_table_ntsvcs, api_ntsvcs_cmds, sizeof(api_ntsvcs_cmds) / sizeof(struct api_struct)); 5318} 5319