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_samr.h" 8 9static bool api_samr_Connect(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 samr_Connect *r; 17 18 call = &ndr_table_samr.calls[NDR_SAMR_CONNECT]; 19 20 r = talloc(talloc_tos(), struct samr_Connect); 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(samr_Connect, r); 45 } 46 47 ZERO_STRUCT(r->out); 48 r->out.connect_handle = talloc_zero(r, struct policy_handle); 49 if (r->out.connect_handle == NULL) { 50 talloc_free(r); 51 return false; 52 } 53 54 r->out.result = _samr_Connect(p, r); 55 56 if (p->rng_fault_state) { 57 talloc_free(r); 58 /* Return true here, srv_pipe_hnd.c will take care */ 59 return true; 60 } 61 62 if (DEBUGLEVEL >= 10) { 63 NDR_PRINT_OUT_DEBUG(samr_Connect, r); 64 } 65 66 push = ndr_push_init_ctx(r, NULL); 67 if (push == NULL) { 68 talloc_free(r); 69 return false; 70 } 71 72 ndr_err = call->ndr_push(push, NDR_OUT, r); 73 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 74 talloc_free(r); 75 return false; 76 } 77 78 blob = ndr_push_blob(push); 79 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 80 talloc_free(r); 81 return false; 82 } 83 84 talloc_free(r); 85 86 return true; 87} 88 89static bool api_samr_Close(pipes_struct *p) 90{ 91 const struct ndr_interface_call *call; 92 struct ndr_pull *pull; 93 struct ndr_push *push; 94 enum ndr_err_code ndr_err; 95 DATA_BLOB blob; 96 struct samr_Close *r; 97 98 call = &ndr_table_samr.calls[NDR_SAMR_CLOSE]; 99 100 r = talloc(talloc_tos(), struct samr_Close); 101 if (r == NULL) { 102 return false; 103 } 104 105 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 106 talloc_free(r); 107 return false; 108 } 109 110 pull = ndr_pull_init_blob(&blob, r, NULL); 111 if (pull == NULL) { 112 talloc_free(r); 113 return false; 114 } 115 116 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 117 ndr_err = call->ndr_pull(pull, NDR_IN, r); 118 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 119 talloc_free(r); 120 return false; 121 } 122 123 if (DEBUGLEVEL >= 10) { 124 NDR_PRINT_IN_DEBUG(samr_Close, r); 125 } 126 127 ZERO_STRUCT(r->out); 128 r->out.handle = r->in.handle; 129 r->out.result = _samr_Close(p, r); 130 131 if (p->rng_fault_state) { 132 talloc_free(r); 133 /* Return true here, srv_pipe_hnd.c will take care */ 134 return true; 135 } 136 137 if (DEBUGLEVEL >= 10) { 138 NDR_PRINT_OUT_DEBUG(samr_Close, r); 139 } 140 141 push = ndr_push_init_ctx(r, NULL); 142 if (push == NULL) { 143 talloc_free(r); 144 return false; 145 } 146 147 ndr_err = call->ndr_push(push, NDR_OUT, r); 148 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 149 talloc_free(r); 150 return false; 151 } 152 153 blob = ndr_push_blob(push); 154 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 155 talloc_free(r); 156 return false; 157 } 158 159 talloc_free(r); 160 161 return true; 162} 163 164static bool api_samr_SetSecurity(pipes_struct *p) 165{ 166 const struct ndr_interface_call *call; 167 struct ndr_pull *pull; 168 struct ndr_push *push; 169 enum ndr_err_code ndr_err; 170 DATA_BLOB blob; 171 struct samr_SetSecurity *r; 172 173 call = &ndr_table_samr.calls[NDR_SAMR_SETSECURITY]; 174 175 r = talloc(talloc_tos(), struct samr_SetSecurity); 176 if (r == NULL) { 177 return false; 178 } 179 180 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 181 talloc_free(r); 182 return false; 183 } 184 185 pull = ndr_pull_init_blob(&blob, r, NULL); 186 if (pull == NULL) { 187 talloc_free(r); 188 return false; 189 } 190 191 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 192 ndr_err = call->ndr_pull(pull, NDR_IN, r); 193 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 194 talloc_free(r); 195 return false; 196 } 197 198 if (DEBUGLEVEL >= 10) { 199 NDR_PRINT_IN_DEBUG(samr_SetSecurity, r); 200 } 201 202 r->out.result = _samr_SetSecurity(p, r); 203 204 if (p->rng_fault_state) { 205 talloc_free(r); 206 /* Return true here, srv_pipe_hnd.c will take care */ 207 return true; 208 } 209 210 if (DEBUGLEVEL >= 10) { 211 NDR_PRINT_OUT_DEBUG(samr_SetSecurity, r); 212 } 213 214 push = ndr_push_init_ctx(r, NULL); 215 if (push == NULL) { 216 talloc_free(r); 217 return false; 218 } 219 220 ndr_err = call->ndr_push(push, NDR_OUT, r); 221 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 222 talloc_free(r); 223 return false; 224 } 225 226 blob = ndr_push_blob(push); 227 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 228 talloc_free(r); 229 return false; 230 } 231 232 talloc_free(r); 233 234 return true; 235} 236 237static bool api_samr_QuerySecurity(pipes_struct *p) 238{ 239 const struct ndr_interface_call *call; 240 struct ndr_pull *pull; 241 struct ndr_push *push; 242 enum ndr_err_code ndr_err; 243 DATA_BLOB blob; 244 struct samr_QuerySecurity *r; 245 246 call = &ndr_table_samr.calls[NDR_SAMR_QUERYSECURITY]; 247 248 r = talloc(talloc_tos(), struct samr_QuerySecurity); 249 if (r == NULL) { 250 return false; 251 } 252 253 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 254 talloc_free(r); 255 return false; 256 } 257 258 pull = ndr_pull_init_blob(&blob, r, NULL); 259 if (pull == NULL) { 260 talloc_free(r); 261 return false; 262 } 263 264 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 265 ndr_err = call->ndr_pull(pull, NDR_IN, r); 266 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 267 talloc_free(r); 268 return false; 269 } 270 271 if (DEBUGLEVEL >= 10) { 272 NDR_PRINT_IN_DEBUG(samr_QuerySecurity, r); 273 } 274 275 ZERO_STRUCT(r->out); 276 r->out.sdbuf = talloc_zero(r, struct sec_desc_buf *); 277 if (r->out.sdbuf == NULL) { 278 talloc_free(r); 279 return false; 280 } 281 282 r->out.result = _samr_QuerySecurity(p, r); 283 284 if (p->rng_fault_state) { 285 talloc_free(r); 286 /* Return true here, srv_pipe_hnd.c will take care */ 287 return true; 288 } 289 290 if (DEBUGLEVEL >= 10) { 291 NDR_PRINT_OUT_DEBUG(samr_QuerySecurity, r); 292 } 293 294 push = ndr_push_init_ctx(r, NULL); 295 if (push == NULL) { 296 talloc_free(r); 297 return false; 298 } 299 300 ndr_err = call->ndr_push(push, NDR_OUT, r); 301 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 302 talloc_free(r); 303 return false; 304 } 305 306 blob = ndr_push_blob(push); 307 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 308 talloc_free(r); 309 return false; 310 } 311 312 talloc_free(r); 313 314 return true; 315} 316 317static bool api_samr_Shutdown(pipes_struct *p) 318{ 319 const struct ndr_interface_call *call; 320 struct ndr_pull *pull; 321 struct ndr_push *push; 322 enum ndr_err_code ndr_err; 323 DATA_BLOB blob; 324 struct samr_Shutdown *r; 325 326 call = &ndr_table_samr.calls[NDR_SAMR_SHUTDOWN]; 327 328 r = talloc(talloc_tos(), struct samr_Shutdown); 329 if (r == NULL) { 330 return false; 331 } 332 333 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 334 talloc_free(r); 335 return false; 336 } 337 338 pull = ndr_pull_init_blob(&blob, r, NULL); 339 if (pull == NULL) { 340 talloc_free(r); 341 return false; 342 } 343 344 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 345 ndr_err = call->ndr_pull(pull, NDR_IN, r); 346 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 347 talloc_free(r); 348 return false; 349 } 350 351 if (DEBUGLEVEL >= 10) { 352 NDR_PRINT_IN_DEBUG(samr_Shutdown, r); 353 } 354 355 r->out.result = _samr_Shutdown(p, r); 356 357 if (p->rng_fault_state) { 358 talloc_free(r); 359 /* Return true here, srv_pipe_hnd.c will take care */ 360 return true; 361 } 362 363 if (DEBUGLEVEL >= 10) { 364 NDR_PRINT_OUT_DEBUG(samr_Shutdown, r); 365 } 366 367 push = ndr_push_init_ctx(r, NULL); 368 if (push == NULL) { 369 talloc_free(r); 370 return false; 371 } 372 373 ndr_err = call->ndr_push(push, NDR_OUT, r); 374 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 375 talloc_free(r); 376 return false; 377 } 378 379 blob = ndr_push_blob(push); 380 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 381 talloc_free(r); 382 return false; 383 } 384 385 talloc_free(r); 386 387 return true; 388} 389 390static bool api_samr_LookupDomain(pipes_struct *p) 391{ 392 const struct ndr_interface_call *call; 393 struct ndr_pull *pull; 394 struct ndr_push *push; 395 enum ndr_err_code ndr_err; 396 DATA_BLOB blob; 397 struct samr_LookupDomain *r; 398 399 call = &ndr_table_samr.calls[NDR_SAMR_LOOKUPDOMAIN]; 400 401 r = talloc(talloc_tos(), struct samr_LookupDomain); 402 if (r == NULL) { 403 return false; 404 } 405 406 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 407 talloc_free(r); 408 return false; 409 } 410 411 pull = ndr_pull_init_blob(&blob, r, NULL); 412 if (pull == NULL) { 413 talloc_free(r); 414 return false; 415 } 416 417 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 418 ndr_err = call->ndr_pull(pull, NDR_IN, r); 419 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 420 talloc_free(r); 421 return false; 422 } 423 424 if (DEBUGLEVEL >= 10) { 425 NDR_PRINT_IN_DEBUG(samr_LookupDomain, r); 426 } 427 428 ZERO_STRUCT(r->out); 429 r->out.sid = talloc_zero(r, struct dom_sid2 *); 430 if (r->out.sid == NULL) { 431 talloc_free(r); 432 return false; 433 } 434 435 r->out.result = _samr_LookupDomain(p, r); 436 437 if (p->rng_fault_state) { 438 talloc_free(r); 439 /* Return true here, srv_pipe_hnd.c will take care */ 440 return true; 441 } 442 443 if (DEBUGLEVEL >= 10) { 444 NDR_PRINT_OUT_DEBUG(samr_LookupDomain, r); 445 } 446 447 push = ndr_push_init_ctx(r, NULL); 448 if (push == NULL) { 449 talloc_free(r); 450 return false; 451 } 452 453 ndr_err = call->ndr_push(push, NDR_OUT, r); 454 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 455 talloc_free(r); 456 return false; 457 } 458 459 blob = ndr_push_blob(push); 460 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 461 talloc_free(r); 462 return false; 463 } 464 465 talloc_free(r); 466 467 return true; 468} 469 470static bool api_samr_EnumDomains(pipes_struct *p) 471{ 472 const struct ndr_interface_call *call; 473 struct ndr_pull *pull; 474 struct ndr_push *push; 475 enum ndr_err_code ndr_err; 476 DATA_BLOB blob; 477 struct samr_EnumDomains *r; 478 479 call = &ndr_table_samr.calls[NDR_SAMR_ENUMDOMAINS]; 480 481 r = talloc(talloc_tos(), struct samr_EnumDomains); 482 if (r == NULL) { 483 return false; 484 } 485 486 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 487 talloc_free(r); 488 return false; 489 } 490 491 pull = ndr_pull_init_blob(&blob, r, NULL); 492 if (pull == NULL) { 493 talloc_free(r); 494 return false; 495 } 496 497 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 498 ndr_err = call->ndr_pull(pull, NDR_IN, r); 499 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 500 talloc_free(r); 501 return false; 502 } 503 504 if (DEBUGLEVEL >= 10) { 505 NDR_PRINT_IN_DEBUG(samr_EnumDomains, r); 506 } 507 508 ZERO_STRUCT(r->out); 509 r->out.resume_handle = r->in.resume_handle; 510 r->out.sam = talloc_zero(r, struct samr_SamArray *); 511 if (r->out.sam == NULL) { 512 talloc_free(r); 513 return false; 514 } 515 516 r->out.num_entries = talloc_zero(r, uint32_t); 517 if (r->out.num_entries == NULL) { 518 talloc_free(r); 519 return false; 520 } 521 522 r->out.result = _samr_EnumDomains(p, r); 523 524 if (p->rng_fault_state) { 525 talloc_free(r); 526 /* Return true here, srv_pipe_hnd.c will take care */ 527 return true; 528 } 529 530 if (DEBUGLEVEL >= 10) { 531 NDR_PRINT_OUT_DEBUG(samr_EnumDomains, r); 532 } 533 534 push = ndr_push_init_ctx(r, NULL); 535 if (push == NULL) { 536 talloc_free(r); 537 return false; 538 } 539 540 ndr_err = call->ndr_push(push, NDR_OUT, r); 541 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 542 talloc_free(r); 543 return false; 544 } 545 546 blob = ndr_push_blob(push); 547 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 548 talloc_free(r); 549 return false; 550 } 551 552 talloc_free(r); 553 554 return true; 555} 556 557static bool api_samr_OpenDomain(pipes_struct *p) 558{ 559 const struct ndr_interface_call *call; 560 struct ndr_pull *pull; 561 struct ndr_push *push; 562 enum ndr_err_code ndr_err; 563 DATA_BLOB blob; 564 struct samr_OpenDomain *r; 565 566 call = &ndr_table_samr.calls[NDR_SAMR_OPENDOMAIN]; 567 568 r = talloc(talloc_tos(), struct samr_OpenDomain); 569 if (r == NULL) { 570 return false; 571 } 572 573 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 574 talloc_free(r); 575 return false; 576 } 577 578 pull = ndr_pull_init_blob(&blob, r, NULL); 579 if (pull == NULL) { 580 talloc_free(r); 581 return false; 582 } 583 584 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 585 ndr_err = call->ndr_pull(pull, NDR_IN, r); 586 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 587 talloc_free(r); 588 return false; 589 } 590 591 if (DEBUGLEVEL >= 10) { 592 NDR_PRINT_IN_DEBUG(samr_OpenDomain, r); 593 } 594 595 ZERO_STRUCT(r->out); 596 r->out.domain_handle = talloc_zero(r, struct policy_handle); 597 if (r->out.domain_handle == NULL) { 598 talloc_free(r); 599 return false; 600 } 601 602 r->out.result = _samr_OpenDomain(p, r); 603 604 if (p->rng_fault_state) { 605 talloc_free(r); 606 /* Return true here, srv_pipe_hnd.c will take care */ 607 return true; 608 } 609 610 if (DEBUGLEVEL >= 10) { 611 NDR_PRINT_OUT_DEBUG(samr_OpenDomain, r); 612 } 613 614 push = ndr_push_init_ctx(r, NULL); 615 if (push == NULL) { 616 talloc_free(r); 617 return false; 618 } 619 620 ndr_err = call->ndr_push(push, NDR_OUT, r); 621 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 622 talloc_free(r); 623 return false; 624 } 625 626 blob = ndr_push_blob(push); 627 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 628 talloc_free(r); 629 return false; 630 } 631 632 talloc_free(r); 633 634 return true; 635} 636 637static bool api_samr_QueryDomainInfo(pipes_struct *p) 638{ 639 const struct ndr_interface_call *call; 640 struct ndr_pull *pull; 641 struct ndr_push *push; 642 enum ndr_err_code ndr_err; 643 DATA_BLOB blob; 644 struct samr_QueryDomainInfo *r; 645 646 call = &ndr_table_samr.calls[NDR_SAMR_QUERYDOMAININFO]; 647 648 r = talloc(talloc_tos(), struct samr_QueryDomainInfo); 649 if (r == NULL) { 650 return false; 651 } 652 653 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 654 talloc_free(r); 655 return false; 656 } 657 658 pull = ndr_pull_init_blob(&blob, r, NULL); 659 if (pull == NULL) { 660 talloc_free(r); 661 return false; 662 } 663 664 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 665 ndr_err = call->ndr_pull(pull, NDR_IN, r); 666 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 667 talloc_free(r); 668 return false; 669 } 670 671 if (DEBUGLEVEL >= 10) { 672 NDR_PRINT_IN_DEBUG(samr_QueryDomainInfo, r); 673 } 674 675 ZERO_STRUCT(r->out); 676 r->out.info = talloc_zero(r, union samr_DomainInfo *); 677 if (r->out.info == NULL) { 678 talloc_free(r); 679 return false; 680 } 681 682 r->out.result = _samr_QueryDomainInfo(p, r); 683 684 if (p->rng_fault_state) { 685 talloc_free(r); 686 /* Return true here, srv_pipe_hnd.c will take care */ 687 return true; 688 } 689 690 if (DEBUGLEVEL >= 10) { 691 NDR_PRINT_OUT_DEBUG(samr_QueryDomainInfo, r); 692 } 693 694 push = ndr_push_init_ctx(r, NULL); 695 if (push == NULL) { 696 talloc_free(r); 697 return false; 698 } 699 700 ndr_err = call->ndr_push(push, NDR_OUT, r); 701 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 702 talloc_free(r); 703 return false; 704 } 705 706 blob = ndr_push_blob(push); 707 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 708 talloc_free(r); 709 return false; 710 } 711 712 talloc_free(r); 713 714 return true; 715} 716 717static bool api_samr_SetDomainInfo(pipes_struct *p) 718{ 719 const struct ndr_interface_call *call; 720 struct ndr_pull *pull; 721 struct ndr_push *push; 722 enum ndr_err_code ndr_err; 723 DATA_BLOB blob; 724 struct samr_SetDomainInfo *r; 725 726 call = &ndr_table_samr.calls[NDR_SAMR_SETDOMAININFO]; 727 728 r = talloc(talloc_tos(), struct samr_SetDomainInfo); 729 if (r == NULL) { 730 return false; 731 } 732 733 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 734 talloc_free(r); 735 return false; 736 } 737 738 pull = ndr_pull_init_blob(&blob, r, NULL); 739 if (pull == NULL) { 740 talloc_free(r); 741 return false; 742 } 743 744 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 745 ndr_err = call->ndr_pull(pull, NDR_IN, r); 746 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 747 talloc_free(r); 748 return false; 749 } 750 751 if (DEBUGLEVEL >= 10) { 752 NDR_PRINT_IN_DEBUG(samr_SetDomainInfo, r); 753 } 754 755 r->out.result = _samr_SetDomainInfo(p, r); 756 757 if (p->rng_fault_state) { 758 talloc_free(r); 759 /* Return true here, srv_pipe_hnd.c will take care */ 760 return true; 761 } 762 763 if (DEBUGLEVEL >= 10) { 764 NDR_PRINT_OUT_DEBUG(samr_SetDomainInfo, r); 765 } 766 767 push = ndr_push_init_ctx(r, NULL); 768 if (push == NULL) { 769 talloc_free(r); 770 return false; 771 } 772 773 ndr_err = call->ndr_push(push, NDR_OUT, r); 774 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 775 talloc_free(r); 776 return false; 777 } 778 779 blob = ndr_push_blob(push); 780 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 781 talloc_free(r); 782 return false; 783 } 784 785 talloc_free(r); 786 787 return true; 788} 789 790static bool api_samr_CreateDomainGroup(pipes_struct *p) 791{ 792 const struct ndr_interface_call *call; 793 struct ndr_pull *pull; 794 struct ndr_push *push; 795 enum ndr_err_code ndr_err; 796 DATA_BLOB blob; 797 struct samr_CreateDomainGroup *r; 798 799 call = &ndr_table_samr.calls[NDR_SAMR_CREATEDOMAINGROUP]; 800 801 r = talloc(talloc_tos(), struct samr_CreateDomainGroup); 802 if (r == NULL) { 803 return false; 804 } 805 806 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 807 talloc_free(r); 808 return false; 809 } 810 811 pull = ndr_pull_init_blob(&blob, r, NULL); 812 if (pull == NULL) { 813 talloc_free(r); 814 return false; 815 } 816 817 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 818 ndr_err = call->ndr_pull(pull, NDR_IN, r); 819 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 820 talloc_free(r); 821 return false; 822 } 823 824 if (DEBUGLEVEL >= 10) { 825 NDR_PRINT_IN_DEBUG(samr_CreateDomainGroup, r); 826 } 827 828 ZERO_STRUCT(r->out); 829 r->out.group_handle = talloc_zero(r, struct policy_handle); 830 if (r->out.group_handle == NULL) { 831 talloc_free(r); 832 return false; 833 } 834 835 r->out.rid = talloc_zero(r, uint32_t); 836 if (r->out.rid == NULL) { 837 talloc_free(r); 838 return false; 839 } 840 841 r->out.result = _samr_CreateDomainGroup(p, r); 842 843 if (p->rng_fault_state) { 844 talloc_free(r); 845 /* Return true here, srv_pipe_hnd.c will take care */ 846 return true; 847 } 848 849 if (DEBUGLEVEL >= 10) { 850 NDR_PRINT_OUT_DEBUG(samr_CreateDomainGroup, r); 851 } 852 853 push = ndr_push_init_ctx(r, NULL); 854 if (push == NULL) { 855 talloc_free(r); 856 return false; 857 } 858 859 ndr_err = call->ndr_push(push, NDR_OUT, r); 860 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 861 talloc_free(r); 862 return false; 863 } 864 865 blob = ndr_push_blob(push); 866 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 867 talloc_free(r); 868 return false; 869 } 870 871 talloc_free(r); 872 873 return true; 874} 875 876static bool api_samr_EnumDomainGroups(pipes_struct *p) 877{ 878 const struct ndr_interface_call *call; 879 struct ndr_pull *pull; 880 struct ndr_push *push; 881 enum ndr_err_code ndr_err; 882 DATA_BLOB blob; 883 struct samr_EnumDomainGroups *r; 884 885 call = &ndr_table_samr.calls[NDR_SAMR_ENUMDOMAINGROUPS]; 886 887 r = talloc(talloc_tos(), struct samr_EnumDomainGroups); 888 if (r == NULL) { 889 return false; 890 } 891 892 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 893 talloc_free(r); 894 return false; 895 } 896 897 pull = ndr_pull_init_blob(&blob, r, NULL); 898 if (pull == NULL) { 899 talloc_free(r); 900 return false; 901 } 902 903 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 904 ndr_err = call->ndr_pull(pull, NDR_IN, r); 905 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 906 talloc_free(r); 907 return false; 908 } 909 910 if (DEBUGLEVEL >= 10) { 911 NDR_PRINT_IN_DEBUG(samr_EnumDomainGroups, r); 912 } 913 914 ZERO_STRUCT(r->out); 915 r->out.resume_handle = r->in.resume_handle; 916 r->out.sam = talloc_zero(r, struct samr_SamArray *); 917 if (r->out.sam == NULL) { 918 talloc_free(r); 919 return false; 920 } 921 922 r->out.num_entries = talloc_zero(r, uint32_t); 923 if (r->out.num_entries == NULL) { 924 talloc_free(r); 925 return false; 926 } 927 928 r->out.result = _samr_EnumDomainGroups(p, r); 929 930 if (p->rng_fault_state) { 931 talloc_free(r); 932 /* Return true here, srv_pipe_hnd.c will take care */ 933 return true; 934 } 935 936 if (DEBUGLEVEL >= 10) { 937 NDR_PRINT_OUT_DEBUG(samr_EnumDomainGroups, r); 938 } 939 940 push = ndr_push_init_ctx(r, NULL); 941 if (push == NULL) { 942 talloc_free(r); 943 return false; 944 } 945 946 ndr_err = call->ndr_push(push, NDR_OUT, r); 947 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 948 talloc_free(r); 949 return false; 950 } 951 952 blob = ndr_push_blob(push); 953 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 954 talloc_free(r); 955 return false; 956 } 957 958 talloc_free(r); 959 960 return true; 961} 962 963static bool api_samr_CreateUser(pipes_struct *p) 964{ 965 const struct ndr_interface_call *call; 966 struct ndr_pull *pull; 967 struct ndr_push *push; 968 enum ndr_err_code ndr_err; 969 DATA_BLOB blob; 970 struct samr_CreateUser *r; 971 972 call = &ndr_table_samr.calls[NDR_SAMR_CREATEUSER]; 973 974 r = talloc(talloc_tos(), struct samr_CreateUser); 975 if (r == NULL) { 976 return false; 977 } 978 979 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 980 talloc_free(r); 981 return false; 982 } 983 984 pull = ndr_pull_init_blob(&blob, r, NULL); 985 if (pull == NULL) { 986 talloc_free(r); 987 return false; 988 } 989 990 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 991 ndr_err = call->ndr_pull(pull, NDR_IN, r); 992 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 993 talloc_free(r); 994 return false; 995 } 996 997 if (DEBUGLEVEL >= 10) { 998 NDR_PRINT_IN_DEBUG(samr_CreateUser, r); 999 } 1000 1001 ZERO_STRUCT(r->out); 1002 r->out.user_handle = talloc_zero(r, struct policy_handle); 1003 if (r->out.user_handle == NULL) { 1004 talloc_free(r); 1005 return false; 1006 } 1007 1008 r->out.rid = talloc_zero(r, uint32_t); 1009 if (r->out.rid == NULL) { 1010 talloc_free(r); 1011 return false; 1012 } 1013 1014 r->out.result = _samr_CreateUser(p, r); 1015 1016 if (p->rng_fault_state) { 1017 talloc_free(r); 1018 /* Return true here, srv_pipe_hnd.c will take care */ 1019 return true; 1020 } 1021 1022 if (DEBUGLEVEL >= 10) { 1023 NDR_PRINT_OUT_DEBUG(samr_CreateUser, r); 1024 } 1025 1026 push = ndr_push_init_ctx(r, NULL); 1027 if (push == NULL) { 1028 talloc_free(r); 1029 return false; 1030 } 1031 1032 ndr_err = call->ndr_push(push, NDR_OUT, r); 1033 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1034 talloc_free(r); 1035 return false; 1036 } 1037 1038 blob = ndr_push_blob(push); 1039 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1040 talloc_free(r); 1041 return false; 1042 } 1043 1044 talloc_free(r); 1045 1046 return true; 1047} 1048 1049static bool api_samr_EnumDomainUsers(pipes_struct *p) 1050{ 1051 const struct ndr_interface_call *call; 1052 struct ndr_pull *pull; 1053 struct ndr_push *push; 1054 enum ndr_err_code ndr_err; 1055 DATA_BLOB blob; 1056 struct samr_EnumDomainUsers *r; 1057 1058 call = &ndr_table_samr.calls[NDR_SAMR_ENUMDOMAINUSERS]; 1059 1060 r = talloc(talloc_tos(), struct samr_EnumDomainUsers); 1061 if (r == NULL) { 1062 return false; 1063 } 1064 1065 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1066 talloc_free(r); 1067 return false; 1068 } 1069 1070 pull = ndr_pull_init_blob(&blob, r, NULL); 1071 if (pull == NULL) { 1072 talloc_free(r); 1073 return false; 1074 } 1075 1076 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1077 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1078 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1079 talloc_free(r); 1080 return false; 1081 } 1082 1083 if (DEBUGLEVEL >= 10) { 1084 NDR_PRINT_IN_DEBUG(samr_EnumDomainUsers, r); 1085 } 1086 1087 ZERO_STRUCT(r->out); 1088 r->out.resume_handle = r->in.resume_handle; 1089 r->out.sam = talloc_zero(r, struct samr_SamArray *); 1090 if (r->out.sam == NULL) { 1091 talloc_free(r); 1092 return false; 1093 } 1094 1095 r->out.num_entries = talloc_zero(r, uint32_t); 1096 if (r->out.num_entries == NULL) { 1097 talloc_free(r); 1098 return false; 1099 } 1100 1101 r->out.result = _samr_EnumDomainUsers(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(samr_EnumDomainUsers, 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_samr_CreateDomAlias(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 samr_CreateDomAlias *r; 1144 1145 call = &ndr_table_samr.calls[NDR_SAMR_CREATEDOMALIAS]; 1146 1147 r = talloc(talloc_tos(), struct samr_CreateDomAlias); 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(samr_CreateDomAlias, r); 1172 } 1173 1174 ZERO_STRUCT(r->out); 1175 r->out.alias_handle = talloc_zero(r, struct policy_handle); 1176 if (r->out.alias_handle == NULL) { 1177 talloc_free(r); 1178 return false; 1179 } 1180 1181 r->out.rid = talloc_zero(r, uint32_t); 1182 if (r->out.rid == NULL) { 1183 talloc_free(r); 1184 return false; 1185 } 1186 1187 r->out.result = _samr_CreateDomAlias(p, r); 1188 1189 if (p->rng_fault_state) { 1190 talloc_free(r); 1191 /* Return true here, srv_pipe_hnd.c will take care */ 1192 return true; 1193 } 1194 1195 if (DEBUGLEVEL >= 10) { 1196 NDR_PRINT_OUT_DEBUG(samr_CreateDomAlias, r); 1197 } 1198 1199 push = ndr_push_init_ctx(r, NULL); 1200 if (push == NULL) { 1201 talloc_free(r); 1202 return false; 1203 } 1204 1205 ndr_err = call->ndr_push(push, NDR_OUT, r); 1206 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1207 talloc_free(r); 1208 return false; 1209 } 1210 1211 blob = ndr_push_blob(push); 1212 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1213 talloc_free(r); 1214 return false; 1215 } 1216 1217 talloc_free(r); 1218 1219 return true; 1220} 1221 1222static bool api_samr_EnumDomainAliases(pipes_struct *p) 1223{ 1224 const struct ndr_interface_call *call; 1225 struct ndr_pull *pull; 1226 struct ndr_push *push; 1227 enum ndr_err_code ndr_err; 1228 DATA_BLOB blob; 1229 struct samr_EnumDomainAliases *r; 1230 1231 call = &ndr_table_samr.calls[NDR_SAMR_ENUMDOMAINALIASES]; 1232 1233 r = talloc(talloc_tos(), struct samr_EnumDomainAliases); 1234 if (r == NULL) { 1235 return false; 1236 } 1237 1238 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1239 talloc_free(r); 1240 return false; 1241 } 1242 1243 pull = ndr_pull_init_blob(&blob, r, NULL); 1244 if (pull == NULL) { 1245 talloc_free(r); 1246 return false; 1247 } 1248 1249 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1250 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1251 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1252 talloc_free(r); 1253 return false; 1254 } 1255 1256 if (DEBUGLEVEL >= 10) { 1257 NDR_PRINT_IN_DEBUG(samr_EnumDomainAliases, r); 1258 } 1259 1260 ZERO_STRUCT(r->out); 1261 r->out.resume_handle = r->in.resume_handle; 1262 r->out.sam = talloc_zero(r, struct samr_SamArray *); 1263 if (r->out.sam == NULL) { 1264 talloc_free(r); 1265 return false; 1266 } 1267 1268 r->out.num_entries = talloc_zero(r, uint32_t); 1269 if (r->out.num_entries == NULL) { 1270 talloc_free(r); 1271 return false; 1272 } 1273 1274 r->out.result = _samr_EnumDomainAliases(p, r); 1275 1276 if (p->rng_fault_state) { 1277 talloc_free(r); 1278 /* Return true here, srv_pipe_hnd.c will take care */ 1279 return true; 1280 } 1281 1282 if (DEBUGLEVEL >= 10) { 1283 NDR_PRINT_OUT_DEBUG(samr_EnumDomainAliases, r); 1284 } 1285 1286 push = ndr_push_init_ctx(r, NULL); 1287 if (push == NULL) { 1288 talloc_free(r); 1289 return false; 1290 } 1291 1292 ndr_err = call->ndr_push(push, NDR_OUT, r); 1293 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1294 talloc_free(r); 1295 return false; 1296 } 1297 1298 blob = ndr_push_blob(push); 1299 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1300 talloc_free(r); 1301 return false; 1302 } 1303 1304 talloc_free(r); 1305 1306 return true; 1307} 1308 1309static bool api_samr_GetAliasMembership(pipes_struct *p) 1310{ 1311 const struct ndr_interface_call *call; 1312 struct ndr_pull *pull; 1313 struct ndr_push *push; 1314 enum ndr_err_code ndr_err; 1315 DATA_BLOB blob; 1316 struct samr_GetAliasMembership *r; 1317 1318 call = &ndr_table_samr.calls[NDR_SAMR_GETALIASMEMBERSHIP]; 1319 1320 r = talloc(talloc_tos(), struct samr_GetAliasMembership); 1321 if (r == NULL) { 1322 return false; 1323 } 1324 1325 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1326 talloc_free(r); 1327 return false; 1328 } 1329 1330 pull = ndr_pull_init_blob(&blob, r, NULL); 1331 if (pull == NULL) { 1332 talloc_free(r); 1333 return false; 1334 } 1335 1336 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1337 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1338 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1339 talloc_free(r); 1340 return false; 1341 } 1342 1343 if (DEBUGLEVEL >= 10) { 1344 NDR_PRINT_IN_DEBUG(samr_GetAliasMembership, r); 1345 } 1346 1347 ZERO_STRUCT(r->out); 1348 r->out.rids = talloc_zero(r, struct samr_Ids); 1349 if (r->out.rids == NULL) { 1350 talloc_free(r); 1351 return false; 1352 } 1353 1354 r->out.result = _samr_GetAliasMembership(p, r); 1355 1356 if (p->rng_fault_state) { 1357 talloc_free(r); 1358 /* Return true here, srv_pipe_hnd.c will take care */ 1359 return true; 1360 } 1361 1362 if (DEBUGLEVEL >= 10) { 1363 NDR_PRINT_OUT_DEBUG(samr_GetAliasMembership, r); 1364 } 1365 1366 push = ndr_push_init_ctx(r, NULL); 1367 if (push == NULL) { 1368 talloc_free(r); 1369 return false; 1370 } 1371 1372 ndr_err = call->ndr_push(push, NDR_OUT, r); 1373 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1374 talloc_free(r); 1375 return false; 1376 } 1377 1378 blob = ndr_push_blob(push); 1379 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1380 talloc_free(r); 1381 return false; 1382 } 1383 1384 talloc_free(r); 1385 1386 return true; 1387} 1388 1389static bool api_samr_LookupNames(pipes_struct *p) 1390{ 1391 const struct ndr_interface_call *call; 1392 struct ndr_pull *pull; 1393 struct ndr_push *push; 1394 enum ndr_err_code ndr_err; 1395 DATA_BLOB blob; 1396 struct samr_LookupNames *r; 1397 1398 call = &ndr_table_samr.calls[NDR_SAMR_LOOKUPNAMES]; 1399 1400 r = talloc(talloc_tos(), struct samr_LookupNames); 1401 if (r == NULL) { 1402 return false; 1403 } 1404 1405 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1406 talloc_free(r); 1407 return false; 1408 } 1409 1410 pull = ndr_pull_init_blob(&blob, r, NULL); 1411 if (pull == NULL) { 1412 talloc_free(r); 1413 return false; 1414 } 1415 1416 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1417 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1418 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1419 talloc_free(r); 1420 return false; 1421 } 1422 1423 if (DEBUGLEVEL >= 10) { 1424 NDR_PRINT_IN_DEBUG(samr_LookupNames, r); 1425 } 1426 1427 ZERO_STRUCT(r->out); 1428 r->out.rids = talloc_zero(r, struct samr_Ids); 1429 if (r->out.rids == NULL) { 1430 talloc_free(r); 1431 return false; 1432 } 1433 1434 r->out.types = talloc_zero(r, struct samr_Ids); 1435 if (r->out.types == NULL) { 1436 talloc_free(r); 1437 return false; 1438 } 1439 1440 r->out.result = _samr_LookupNames(p, r); 1441 1442 if (p->rng_fault_state) { 1443 talloc_free(r); 1444 /* Return true here, srv_pipe_hnd.c will take care */ 1445 return true; 1446 } 1447 1448 if (DEBUGLEVEL >= 10) { 1449 NDR_PRINT_OUT_DEBUG(samr_LookupNames, r); 1450 } 1451 1452 push = ndr_push_init_ctx(r, NULL); 1453 if (push == NULL) { 1454 talloc_free(r); 1455 return false; 1456 } 1457 1458 ndr_err = call->ndr_push(push, NDR_OUT, r); 1459 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1460 talloc_free(r); 1461 return false; 1462 } 1463 1464 blob = ndr_push_blob(push); 1465 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1466 talloc_free(r); 1467 return false; 1468 } 1469 1470 talloc_free(r); 1471 1472 return true; 1473} 1474 1475static bool api_samr_LookupRids(pipes_struct *p) 1476{ 1477 const struct ndr_interface_call *call; 1478 struct ndr_pull *pull; 1479 struct ndr_push *push; 1480 enum ndr_err_code ndr_err; 1481 DATA_BLOB blob; 1482 struct samr_LookupRids *r; 1483 1484 call = &ndr_table_samr.calls[NDR_SAMR_LOOKUPRIDS]; 1485 1486 r = talloc(talloc_tos(), struct samr_LookupRids); 1487 if (r == NULL) { 1488 return false; 1489 } 1490 1491 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1492 talloc_free(r); 1493 return false; 1494 } 1495 1496 pull = ndr_pull_init_blob(&blob, r, NULL); 1497 if (pull == NULL) { 1498 talloc_free(r); 1499 return false; 1500 } 1501 1502 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1503 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1504 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1505 talloc_free(r); 1506 return false; 1507 } 1508 1509 if (DEBUGLEVEL >= 10) { 1510 NDR_PRINT_IN_DEBUG(samr_LookupRids, r); 1511 } 1512 1513 ZERO_STRUCT(r->out); 1514 r->out.names = talloc_zero(r, struct lsa_Strings); 1515 if (r->out.names == NULL) { 1516 talloc_free(r); 1517 return false; 1518 } 1519 1520 r->out.types = talloc_zero(r, struct samr_Ids); 1521 if (r->out.types == NULL) { 1522 talloc_free(r); 1523 return false; 1524 } 1525 1526 r->out.result = _samr_LookupRids(p, r); 1527 1528 if (p->rng_fault_state) { 1529 talloc_free(r); 1530 /* Return true here, srv_pipe_hnd.c will take care */ 1531 return true; 1532 } 1533 1534 if (DEBUGLEVEL >= 10) { 1535 NDR_PRINT_OUT_DEBUG(samr_LookupRids, r); 1536 } 1537 1538 push = ndr_push_init_ctx(r, NULL); 1539 if (push == NULL) { 1540 talloc_free(r); 1541 return false; 1542 } 1543 1544 ndr_err = call->ndr_push(push, NDR_OUT, r); 1545 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1546 talloc_free(r); 1547 return false; 1548 } 1549 1550 blob = ndr_push_blob(push); 1551 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1552 talloc_free(r); 1553 return false; 1554 } 1555 1556 talloc_free(r); 1557 1558 return true; 1559} 1560 1561static bool api_samr_OpenGroup(pipes_struct *p) 1562{ 1563 const struct ndr_interface_call *call; 1564 struct ndr_pull *pull; 1565 struct ndr_push *push; 1566 enum ndr_err_code ndr_err; 1567 DATA_BLOB blob; 1568 struct samr_OpenGroup *r; 1569 1570 call = &ndr_table_samr.calls[NDR_SAMR_OPENGROUP]; 1571 1572 r = talloc(talloc_tos(), struct samr_OpenGroup); 1573 if (r == NULL) { 1574 return false; 1575 } 1576 1577 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1578 talloc_free(r); 1579 return false; 1580 } 1581 1582 pull = ndr_pull_init_blob(&blob, r, NULL); 1583 if (pull == NULL) { 1584 talloc_free(r); 1585 return false; 1586 } 1587 1588 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1589 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1590 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1591 talloc_free(r); 1592 return false; 1593 } 1594 1595 if (DEBUGLEVEL >= 10) { 1596 NDR_PRINT_IN_DEBUG(samr_OpenGroup, r); 1597 } 1598 1599 ZERO_STRUCT(r->out); 1600 r->out.group_handle = talloc_zero(r, struct policy_handle); 1601 if (r->out.group_handle == NULL) { 1602 talloc_free(r); 1603 return false; 1604 } 1605 1606 r->out.result = _samr_OpenGroup(p, r); 1607 1608 if (p->rng_fault_state) { 1609 talloc_free(r); 1610 /* Return true here, srv_pipe_hnd.c will take care */ 1611 return true; 1612 } 1613 1614 if (DEBUGLEVEL >= 10) { 1615 NDR_PRINT_OUT_DEBUG(samr_OpenGroup, r); 1616 } 1617 1618 push = ndr_push_init_ctx(r, NULL); 1619 if (push == NULL) { 1620 talloc_free(r); 1621 return false; 1622 } 1623 1624 ndr_err = call->ndr_push(push, NDR_OUT, r); 1625 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1626 talloc_free(r); 1627 return false; 1628 } 1629 1630 blob = ndr_push_blob(push); 1631 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1632 talloc_free(r); 1633 return false; 1634 } 1635 1636 talloc_free(r); 1637 1638 return true; 1639} 1640 1641static bool api_samr_QueryGroupInfo(pipes_struct *p) 1642{ 1643 const struct ndr_interface_call *call; 1644 struct ndr_pull *pull; 1645 struct ndr_push *push; 1646 enum ndr_err_code ndr_err; 1647 DATA_BLOB blob; 1648 struct samr_QueryGroupInfo *r; 1649 1650 call = &ndr_table_samr.calls[NDR_SAMR_QUERYGROUPINFO]; 1651 1652 r = talloc(talloc_tos(), struct samr_QueryGroupInfo); 1653 if (r == NULL) { 1654 return false; 1655 } 1656 1657 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1658 talloc_free(r); 1659 return false; 1660 } 1661 1662 pull = ndr_pull_init_blob(&blob, r, NULL); 1663 if (pull == NULL) { 1664 talloc_free(r); 1665 return false; 1666 } 1667 1668 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1669 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1670 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1671 talloc_free(r); 1672 return false; 1673 } 1674 1675 if (DEBUGLEVEL >= 10) { 1676 NDR_PRINT_IN_DEBUG(samr_QueryGroupInfo, r); 1677 } 1678 1679 ZERO_STRUCT(r->out); 1680 r->out.info = talloc_zero(r, union samr_GroupInfo *); 1681 if (r->out.info == NULL) { 1682 talloc_free(r); 1683 return false; 1684 } 1685 1686 r->out.result = _samr_QueryGroupInfo(p, r); 1687 1688 if (p->rng_fault_state) { 1689 talloc_free(r); 1690 /* Return true here, srv_pipe_hnd.c will take care */ 1691 return true; 1692 } 1693 1694 if (DEBUGLEVEL >= 10) { 1695 NDR_PRINT_OUT_DEBUG(samr_QueryGroupInfo, r); 1696 } 1697 1698 push = ndr_push_init_ctx(r, NULL); 1699 if (push == NULL) { 1700 talloc_free(r); 1701 return false; 1702 } 1703 1704 ndr_err = call->ndr_push(push, NDR_OUT, r); 1705 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1706 talloc_free(r); 1707 return false; 1708 } 1709 1710 blob = ndr_push_blob(push); 1711 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1712 talloc_free(r); 1713 return false; 1714 } 1715 1716 talloc_free(r); 1717 1718 return true; 1719} 1720 1721static bool api_samr_SetGroupInfo(pipes_struct *p) 1722{ 1723 const struct ndr_interface_call *call; 1724 struct ndr_pull *pull; 1725 struct ndr_push *push; 1726 enum ndr_err_code ndr_err; 1727 DATA_BLOB blob; 1728 struct samr_SetGroupInfo *r; 1729 1730 call = &ndr_table_samr.calls[NDR_SAMR_SETGROUPINFO]; 1731 1732 r = talloc(talloc_tos(), struct samr_SetGroupInfo); 1733 if (r == NULL) { 1734 return false; 1735 } 1736 1737 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1738 talloc_free(r); 1739 return false; 1740 } 1741 1742 pull = ndr_pull_init_blob(&blob, r, NULL); 1743 if (pull == NULL) { 1744 talloc_free(r); 1745 return false; 1746 } 1747 1748 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1749 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1750 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1751 talloc_free(r); 1752 return false; 1753 } 1754 1755 if (DEBUGLEVEL >= 10) { 1756 NDR_PRINT_IN_DEBUG(samr_SetGroupInfo, r); 1757 } 1758 1759 r->out.result = _samr_SetGroupInfo(p, r); 1760 1761 if (p->rng_fault_state) { 1762 talloc_free(r); 1763 /* Return true here, srv_pipe_hnd.c will take care */ 1764 return true; 1765 } 1766 1767 if (DEBUGLEVEL >= 10) { 1768 NDR_PRINT_OUT_DEBUG(samr_SetGroupInfo, r); 1769 } 1770 1771 push = ndr_push_init_ctx(r, NULL); 1772 if (push == NULL) { 1773 talloc_free(r); 1774 return false; 1775 } 1776 1777 ndr_err = call->ndr_push(push, NDR_OUT, r); 1778 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1779 talloc_free(r); 1780 return false; 1781 } 1782 1783 blob = ndr_push_blob(push); 1784 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1785 talloc_free(r); 1786 return false; 1787 } 1788 1789 talloc_free(r); 1790 1791 return true; 1792} 1793 1794static bool api_samr_AddGroupMember(pipes_struct *p) 1795{ 1796 const struct ndr_interface_call *call; 1797 struct ndr_pull *pull; 1798 struct ndr_push *push; 1799 enum ndr_err_code ndr_err; 1800 DATA_BLOB blob; 1801 struct samr_AddGroupMember *r; 1802 1803 call = &ndr_table_samr.calls[NDR_SAMR_ADDGROUPMEMBER]; 1804 1805 r = talloc(talloc_tos(), struct samr_AddGroupMember); 1806 if (r == NULL) { 1807 return false; 1808 } 1809 1810 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1811 talloc_free(r); 1812 return false; 1813 } 1814 1815 pull = ndr_pull_init_blob(&blob, r, NULL); 1816 if (pull == NULL) { 1817 talloc_free(r); 1818 return false; 1819 } 1820 1821 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1822 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1823 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1824 talloc_free(r); 1825 return false; 1826 } 1827 1828 if (DEBUGLEVEL >= 10) { 1829 NDR_PRINT_IN_DEBUG(samr_AddGroupMember, r); 1830 } 1831 1832 r->out.result = _samr_AddGroupMember(p, r); 1833 1834 if (p->rng_fault_state) { 1835 talloc_free(r); 1836 /* Return true here, srv_pipe_hnd.c will take care */ 1837 return true; 1838 } 1839 1840 if (DEBUGLEVEL >= 10) { 1841 NDR_PRINT_OUT_DEBUG(samr_AddGroupMember, r); 1842 } 1843 1844 push = ndr_push_init_ctx(r, NULL); 1845 if (push == NULL) { 1846 talloc_free(r); 1847 return false; 1848 } 1849 1850 ndr_err = call->ndr_push(push, NDR_OUT, r); 1851 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1852 talloc_free(r); 1853 return false; 1854 } 1855 1856 blob = ndr_push_blob(push); 1857 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1858 talloc_free(r); 1859 return false; 1860 } 1861 1862 talloc_free(r); 1863 1864 return true; 1865} 1866 1867static bool api_samr_DeleteDomainGroup(pipes_struct *p) 1868{ 1869 const struct ndr_interface_call *call; 1870 struct ndr_pull *pull; 1871 struct ndr_push *push; 1872 enum ndr_err_code ndr_err; 1873 DATA_BLOB blob; 1874 struct samr_DeleteDomainGroup *r; 1875 1876 call = &ndr_table_samr.calls[NDR_SAMR_DELETEDOMAINGROUP]; 1877 1878 r = talloc(talloc_tos(), struct samr_DeleteDomainGroup); 1879 if (r == NULL) { 1880 return false; 1881 } 1882 1883 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1884 talloc_free(r); 1885 return false; 1886 } 1887 1888 pull = ndr_pull_init_blob(&blob, r, NULL); 1889 if (pull == NULL) { 1890 talloc_free(r); 1891 return false; 1892 } 1893 1894 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1895 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1896 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1897 talloc_free(r); 1898 return false; 1899 } 1900 1901 if (DEBUGLEVEL >= 10) { 1902 NDR_PRINT_IN_DEBUG(samr_DeleteDomainGroup, r); 1903 } 1904 1905 ZERO_STRUCT(r->out); 1906 r->out.group_handle = r->in.group_handle; 1907 r->out.result = _samr_DeleteDomainGroup(p, r); 1908 1909 if (p->rng_fault_state) { 1910 talloc_free(r); 1911 /* Return true here, srv_pipe_hnd.c will take care */ 1912 return true; 1913 } 1914 1915 if (DEBUGLEVEL >= 10) { 1916 NDR_PRINT_OUT_DEBUG(samr_DeleteDomainGroup, r); 1917 } 1918 1919 push = ndr_push_init_ctx(r, NULL); 1920 if (push == NULL) { 1921 talloc_free(r); 1922 return false; 1923 } 1924 1925 ndr_err = call->ndr_push(push, NDR_OUT, r); 1926 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1927 talloc_free(r); 1928 return false; 1929 } 1930 1931 blob = ndr_push_blob(push); 1932 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1933 talloc_free(r); 1934 return false; 1935 } 1936 1937 talloc_free(r); 1938 1939 return true; 1940} 1941 1942static bool api_samr_DeleteGroupMember(pipes_struct *p) 1943{ 1944 const struct ndr_interface_call *call; 1945 struct ndr_pull *pull; 1946 struct ndr_push *push; 1947 enum ndr_err_code ndr_err; 1948 DATA_BLOB blob; 1949 struct samr_DeleteGroupMember *r; 1950 1951 call = &ndr_table_samr.calls[NDR_SAMR_DELETEGROUPMEMBER]; 1952 1953 r = talloc(talloc_tos(), struct samr_DeleteGroupMember); 1954 if (r == NULL) { 1955 return false; 1956 } 1957 1958 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1959 talloc_free(r); 1960 return false; 1961 } 1962 1963 pull = ndr_pull_init_blob(&blob, r, NULL); 1964 if (pull == NULL) { 1965 talloc_free(r); 1966 return false; 1967 } 1968 1969 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1970 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1971 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1972 talloc_free(r); 1973 return false; 1974 } 1975 1976 if (DEBUGLEVEL >= 10) { 1977 NDR_PRINT_IN_DEBUG(samr_DeleteGroupMember, r); 1978 } 1979 1980 r->out.result = _samr_DeleteGroupMember(p, r); 1981 1982 if (p->rng_fault_state) { 1983 talloc_free(r); 1984 /* Return true here, srv_pipe_hnd.c will take care */ 1985 return true; 1986 } 1987 1988 if (DEBUGLEVEL >= 10) { 1989 NDR_PRINT_OUT_DEBUG(samr_DeleteGroupMember, r); 1990 } 1991 1992 push = ndr_push_init_ctx(r, NULL); 1993 if (push == NULL) { 1994 talloc_free(r); 1995 return false; 1996 } 1997 1998 ndr_err = call->ndr_push(push, NDR_OUT, r); 1999 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2000 talloc_free(r); 2001 return false; 2002 } 2003 2004 blob = ndr_push_blob(push); 2005 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2006 talloc_free(r); 2007 return false; 2008 } 2009 2010 talloc_free(r); 2011 2012 return true; 2013} 2014 2015static bool api_samr_QueryGroupMember(pipes_struct *p) 2016{ 2017 const struct ndr_interface_call *call; 2018 struct ndr_pull *pull; 2019 struct ndr_push *push; 2020 enum ndr_err_code ndr_err; 2021 DATA_BLOB blob; 2022 struct samr_QueryGroupMember *r; 2023 2024 call = &ndr_table_samr.calls[NDR_SAMR_QUERYGROUPMEMBER]; 2025 2026 r = talloc(talloc_tos(), struct samr_QueryGroupMember); 2027 if (r == NULL) { 2028 return false; 2029 } 2030 2031 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2032 talloc_free(r); 2033 return false; 2034 } 2035 2036 pull = ndr_pull_init_blob(&blob, r, NULL); 2037 if (pull == NULL) { 2038 talloc_free(r); 2039 return false; 2040 } 2041 2042 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2043 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2044 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2045 talloc_free(r); 2046 return false; 2047 } 2048 2049 if (DEBUGLEVEL >= 10) { 2050 NDR_PRINT_IN_DEBUG(samr_QueryGroupMember, r); 2051 } 2052 2053 ZERO_STRUCT(r->out); 2054 r->out.rids = talloc_zero(r, struct samr_RidTypeArray *); 2055 if (r->out.rids == NULL) { 2056 talloc_free(r); 2057 return false; 2058 } 2059 2060 r->out.result = _samr_QueryGroupMember(p, r); 2061 2062 if (p->rng_fault_state) { 2063 talloc_free(r); 2064 /* Return true here, srv_pipe_hnd.c will take care */ 2065 return true; 2066 } 2067 2068 if (DEBUGLEVEL >= 10) { 2069 NDR_PRINT_OUT_DEBUG(samr_QueryGroupMember, r); 2070 } 2071 2072 push = ndr_push_init_ctx(r, NULL); 2073 if (push == NULL) { 2074 talloc_free(r); 2075 return false; 2076 } 2077 2078 ndr_err = call->ndr_push(push, NDR_OUT, r); 2079 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2080 talloc_free(r); 2081 return false; 2082 } 2083 2084 blob = ndr_push_blob(push); 2085 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2086 talloc_free(r); 2087 return false; 2088 } 2089 2090 talloc_free(r); 2091 2092 return true; 2093} 2094 2095static bool api_samr_SetMemberAttributesOfGroup(pipes_struct *p) 2096{ 2097 const struct ndr_interface_call *call; 2098 struct ndr_pull *pull; 2099 struct ndr_push *push; 2100 enum ndr_err_code ndr_err; 2101 DATA_BLOB blob; 2102 struct samr_SetMemberAttributesOfGroup *r; 2103 2104 call = &ndr_table_samr.calls[NDR_SAMR_SETMEMBERATTRIBUTESOFGROUP]; 2105 2106 r = talloc(talloc_tos(), struct samr_SetMemberAttributesOfGroup); 2107 if (r == NULL) { 2108 return false; 2109 } 2110 2111 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2112 talloc_free(r); 2113 return false; 2114 } 2115 2116 pull = ndr_pull_init_blob(&blob, r, NULL); 2117 if (pull == NULL) { 2118 talloc_free(r); 2119 return false; 2120 } 2121 2122 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2123 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2124 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2125 talloc_free(r); 2126 return false; 2127 } 2128 2129 if (DEBUGLEVEL >= 10) { 2130 NDR_PRINT_IN_DEBUG(samr_SetMemberAttributesOfGroup, r); 2131 } 2132 2133 r->out.result = _samr_SetMemberAttributesOfGroup(p, r); 2134 2135 if (p->rng_fault_state) { 2136 talloc_free(r); 2137 /* Return true here, srv_pipe_hnd.c will take care */ 2138 return true; 2139 } 2140 2141 if (DEBUGLEVEL >= 10) { 2142 NDR_PRINT_OUT_DEBUG(samr_SetMemberAttributesOfGroup, r); 2143 } 2144 2145 push = ndr_push_init_ctx(r, NULL); 2146 if (push == NULL) { 2147 talloc_free(r); 2148 return false; 2149 } 2150 2151 ndr_err = call->ndr_push(push, NDR_OUT, r); 2152 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2153 talloc_free(r); 2154 return false; 2155 } 2156 2157 blob = ndr_push_blob(push); 2158 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2159 talloc_free(r); 2160 return false; 2161 } 2162 2163 talloc_free(r); 2164 2165 return true; 2166} 2167 2168static bool api_samr_OpenAlias(pipes_struct *p) 2169{ 2170 const struct ndr_interface_call *call; 2171 struct ndr_pull *pull; 2172 struct ndr_push *push; 2173 enum ndr_err_code ndr_err; 2174 DATA_BLOB blob; 2175 struct samr_OpenAlias *r; 2176 2177 call = &ndr_table_samr.calls[NDR_SAMR_OPENALIAS]; 2178 2179 r = talloc(talloc_tos(), struct samr_OpenAlias); 2180 if (r == NULL) { 2181 return false; 2182 } 2183 2184 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2185 talloc_free(r); 2186 return false; 2187 } 2188 2189 pull = ndr_pull_init_blob(&blob, r, NULL); 2190 if (pull == NULL) { 2191 talloc_free(r); 2192 return false; 2193 } 2194 2195 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2196 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2197 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2198 talloc_free(r); 2199 return false; 2200 } 2201 2202 if (DEBUGLEVEL >= 10) { 2203 NDR_PRINT_IN_DEBUG(samr_OpenAlias, r); 2204 } 2205 2206 ZERO_STRUCT(r->out); 2207 r->out.alias_handle = talloc_zero(r, struct policy_handle); 2208 if (r->out.alias_handle == NULL) { 2209 talloc_free(r); 2210 return false; 2211 } 2212 2213 r->out.result = _samr_OpenAlias(p, r); 2214 2215 if (p->rng_fault_state) { 2216 talloc_free(r); 2217 /* Return true here, srv_pipe_hnd.c will take care */ 2218 return true; 2219 } 2220 2221 if (DEBUGLEVEL >= 10) { 2222 NDR_PRINT_OUT_DEBUG(samr_OpenAlias, r); 2223 } 2224 2225 push = ndr_push_init_ctx(r, NULL); 2226 if (push == NULL) { 2227 talloc_free(r); 2228 return false; 2229 } 2230 2231 ndr_err = call->ndr_push(push, NDR_OUT, r); 2232 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2233 talloc_free(r); 2234 return false; 2235 } 2236 2237 blob = ndr_push_blob(push); 2238 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2239 talloc_free(r); 2240 return false; 2241 } 2242 2243 talloc_free(r); 2244 2245 return true; 2246} 2247 2248static bool api_samr_QueryAliasInfo(pipes_struct *p) 2249{ 2250 const struct ndr_interface_call *call; 2251 struct ndr_pull *pull; 2252 struct ndr_push *push; 2253 enum ndr_err_code ndr_err; 2254 DATA_BLOB blob; 2255 struct samr_QueryAliasInfo *r; 2256 2257 call = &ndr_table_samr.calls[NDR_SAMR_QUERYALIASINFO]; 2258 2259 r = talloc(talloc_tos(), struct samr_QueryAliasInfo); 2260 if (r == NULL) { 2261 return false; 2262 } 2263 2264 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2265 talloc_free(r); 2266 return false; 2267 } 2268 2269 pull = ndr_pull_init_blob(&blob, r, NULL); 2270 if (pull == NULL) { 2271 talloc_free(r); 2272 return false; 2273 } 2274 2275 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2276 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2277 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2278 talloc_free(r); 2279 return false; 2280 } 2281 2282 if (DEBUGLEVEL >= 10) { 2283 NDR_PRINT_IN_DEBUG(samr_QueryAliasInfo, r); 2284 } 2285 2286 ZERO_STRUCT(r->out); 2287 r->out.info = talloc_zero(r, union samr_AliasInfo *); 2288 if (r->out.info == NULL) { 2289 talloc_free(r); 2290 return false; 2291 } 2292 2293 r->out.result = _samr_QueryAliasInfo(p, r); 2294 2295 if (p->rng_fault_state) { 2296 talloc_free(r); 2297 /* Return true here, srv_pipe_hnd.c will take care */ 2298 return true; 2299 } 2300 2301 if (DEBUGLEVEL >= 10) { 2302 NDR_PRINT_OUT_DEBUG(samr_QueryAliasInfo, r); 2303 } 2304 2305 push = ndr_push_init_ctx(r, NULL); 2306 if (push == NULL) { 2307 talloc_free(r); 2308 return false; 2309 } 2310 2311 ndr_err = call->ndr_push(push, NDR_OUT, r); 2312 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2313 talloc_free(r); 2314 return false; 2315 } 2316 2317 blob = ndr_push_blob(push); 2318 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2319 talloc_free(r); 2320 return false; 2321 } 2322 2323 talloc_free(r); 2324 2325 return true; 2326} 2327 2328static bool api_samr_SetAliasInfo(pipes_struct *p) 2329{ 2330 const struct ndr_interface_call *call; 2331 struct ndr_pull *pull; 2332 struct ndr_push *push; 2333 enum ndr_err_code ndr_err; 2334 DATA_BLOB blob; 2335 struct samr_SetAliasInfo *r; 2336 2337 call = &ndr_table_samr.calls[NDR_SAMR_SETALIASINFO]; 2338 2339 r = talloc(talloc_tos(), struct samr_SetAliasInfo); 2340 if (r == NULL) { 2341 return false; 2342 } 2343 2344 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2345 talloc_free(r); 2346 return false; 2347 } 2348 2349 pull = ndr_pull_init_blob(&blob, r, NULL); 2350 if (pull == NULL) { 2351 talloc_free(r); 2352 return false; 2353 } 2354 2355 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2356 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2357 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2358 talloc_free(r); 2359 return false; 2360 } 2361 2362 if (DEBUGLEVEL >= 10) { 2363 NDR_PRINT_IN_DEBUG(samr_SetAliasInfo, r); 2364 } 2365 2366 r->out.result = _samr_SetAliasInfo(p, r); 2367 2368 if (p->rng_fault_state) { 2369 talloc_free(r); 2370 /* Return true here, srv_pipe_hnd.c will take care */ 2371 return true; 2372 } 2373 2374 if (DEBUGLEVEL >= 10) { 2375 NDR_PRINT_OUT_DEBUG(samr_SetAliasInfo, r); 2376 } 2377 2378 push = ndr_push_init_ctx(r, NULL); 2379 if (push == NULL) { 2380 talloc_free(r); 2381 return false; 2382 } 2383 2384 ndr_err = call->ndr_push(push, NDR_OUT, r); 2385 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2386 talloc_free(r); 2387 return false; 2388 } 2389 2390 blob = ndr_push_blob(push); 2391 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2392 talloc_free(r); 2393 return false; 2394 } 2395 2396 talloc_free(r); 2397 2398 return true; 2399} 2400 2401static bool api_samr_DeleteDomAlias(pipes_struct *p) 2402{ 2403 const struct ndr_interface_call *call; 2404 struct ndr_pull *pull; 2405 struct ndr_push *push; 2406 enum ndr_err_code ndr_err; 2407 DATA_BLOB blob; 2408 struct samr_DeleteDomAlias *r; 2409 2410 call = &ndr_table_samr.calls[NDR_SAMR_DELETEDOMALIAS]; 2411 2412 r = talloc(talloc_tos(), struct samr_DeleteDomAlias); 2413 if (r == NULL) { 2414 return false; 2415 } 2416 2417 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2418 talloc_free(r); 2419 return false; 2420 } 2421 2422 pull = ndr_pull_init_blob(&blob, r, NULL); 2423 if (pull == NULL) { 2424 talloc_free(r); 2425 return false; 2426 } 2427 2428 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2429 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2430 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2431 talloc_free(r); 2432 return false; 2433 } 2434 2435 if (DEBUGLEVEL >= 10) { 2436 NDR_PRINT_IN_DEBUG(samr_DeleteDomAlias, r); 2437 } 2438 2439 ZERO_STRUCT(r->out); 2440 r->out.alias_handle = r->in.alias_handle; 2441 r->out.result = _samr_DeleteDomAlias(p, r); 2442 2443 if (p->rng_fault_state) { 2444 talloc_free(r); 2445 /* Return true here, srv_pipe_hnd.c will take care */ 2446 return true; 2447 } 2448 2449 if (DEBUGLEVEL >= 10) { 2450 NDR_PRINT_OUT_DEBUG(samr_DeleteDomAlias, r); 2451 } 2452 2453 push = ndr_push_init_ctx(r, NULL); 2454 if (push == NULL) { 2455 talloc_free(r); 2456 return false; 2457 } 2458 2459 ndr_err = call->ndr_push(push, NDR_OUT, r); 2460 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2461 talloc_free(r); 2462 return false; 2463 } 2464 2465 blob = ndr_push_blob(push); 2466 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2467 talloc_free(r); 2468 return false; 2469 } 2470 2471 talloc_free(r); 2472 2473 return true; 2474} 2475 2476static bool api_samr_AddAliasMember(pipes_struct *p) 2477{ 2478 const struct ndr_interface_call *call; 2479 struct ndr_pull *pull; 2480 struct ndr_push *push; 2481 enum ndr_err_code ndr_err; 2482 DATA_BLOB blob; 2483 struct samr_AddAliasMember *r; 2484 2485 call = &ndr_table_samr.calls[NDR_SAMR_ADDALIASMEMBER]; 2486 2487 r = talloc(talloc_tos(), struct samr_AddAliasMember); 2488 if (r == NULL) { 2489 return false; 2490 } 2491 2492 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2493 talloc_free(r); 2494 return false; 2495 } 2496 2497 pull = ndr_pull_init_blob(&blob, r, NULL); 2498 if (pull == NULL) { 2499 talloc_free(r); 2500 return false; 2501 } 2502 2503 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2504 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2505 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2506 talloc_free(r); 2507 return false; 2508 } 2509 2510 if (DEBUGLEVEL >= 10) { 2511 NDR_PRINT_IN_DEBUG(samr_AddAliasMember, r); 2512 } 2513 2514 r->out.result = _samr_AddAliasMember(p, r); 2515 2516 if (p->rng_fault_state) { 2517 talloc_free(r); 2518 /* Return true here, srv_pipe_hnd.c will take care */ 2519 return true; 2520 } 2521 2522 if (DEBUGLEVEL >= 10) { 2523 NDR_PRINT_OUT_DEBUG(samr_AddAliasMember, r); 2524 } 2525 2526 push = ndr_push_init_ctx(r, NULL); 2527 if (push == NULL) { 2528 talloc_free(r); 2529 return false; 2530 } 2531 2532 ndr_err = call->ndr_push(push, NDR_OUT, r); 2533 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2534 talloc_free(r); 2535 return false; 2536 } 2537 2538 blob = ndr_push_blob(push); 2539 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2540 talloc_free(r); 2541 return false; 2542 } 2543 2544 talloc_free(r); 2545 2546 return true; 2547} 2548 2549static bool api_samr_DeleteAliasMember(pipes_struct *p) 2550{ 2551 const struct ndr_interface_call *call; 2552 struct ndr_pull *pull; 2553 struct ndr_push *push; 2554 enum ndr_err_code ndr_err; 2555 DATA_BLOB blob; 2556 struct samr_DeleteAliasMember *r; 2557 2558 call = &ndr_table_samr.calls[NDR_SAMR_DELETEALIASMEMBER]; 2559 2560 r = talloc(talloc_tos(), struct samr_DeleteAliasMember); 2561 if (r == NULL) { 2562 return false; 2563 } 2564 2565 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2566 talloc_free(r); 2567 return false; 2568 } 2569 2570 pull = ndr_pull_init_blob(&blob, r, NULL); 2571 if (pull == NULL) { 2572 talloc_free(r); 2573 return false; 2574 } 2575 2576 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2577 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2578 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2579 talloc_free(r); 2580 return false; 2581 } 2582 2583 if (DEBUGLEVEL >= 10) { 2584 NDR_PRINT_IN_DEBUG(samr_DeleteAliasMember, r); 2585 } 2586 2587 r->out.result = _samr_DeleteAliasMember(p, r); 2588 2589 if (p->rng_fault_state) { 2590 talloc_free(r); 2591 /* Return true here, srv_pipe_hnd.c will take care */ 2592 return true; 2593 } 2594 2595 if (DEBUGLEVEL >= 10) { 2596 NDR_PRINT_OUT_DEBUG(samr_DeleteAliasMember, r); 2597 } 2598 2599 push = ndr_push_init_ctx(r, NULL); 2600 if (push == NULL) { 2601 talloc_free(r); 2602 return false; 2603 } 2604 2605 ndr_err = call->ndr_push(push, NDR_OUT, r); 2606 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2607 talloc_free(r); 2608 return false; 2609 } 2610 2611 blob = ndr_push_blob(push); 2612 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2613 talloc_free(r); 2614 return false; 2615 } 2616 2617 talloc_free(r); 2618 2619 return true; 2620} 2621 2622static bool api_samr_GetMembersInAlias(pipes_struct *p) 2623{ 2624 const struct ndr_interface_call *call; 2625 struct ndr_pull *pull; 2626 struct ndr_push *push; 2627 enum ndr_err_code ndr_err; 2628 DATA_BLOB blob; 2629 struct samr_GetMembersInAlias *r; 2630 2631 call = &ndr_table_samr.calls[NDR_SAMR_GETMEMBERSINALIAS]; 2632 2633 r = talloc(talloc_tos(), struct samr_GetMembersInAlias); 2634 if (r == NULL) { 2635 return false; 2636 } 2637 2638 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2639 talloc_free(r); 2640 return false; 2641 } 2642 2643 pull = ndr_pull_init_blob(&blob, r, NULL); 2644 if (pull == NULL) { 2645 talloc_free(r); 2646 return false; 2647 } 2648 2649 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2650 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2651 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2652 talloc_free(r); 2653 return false; 2654 } 2655 2656 if (DEBUGLEVEL >= 10) { 2657 NDR_PRINT_IN_DEBUG(samr_GetMembersInAlias, r); 2658 } 2659 2660 ZERO_STRUCT(r->out); 2661 r->out.sids = talloc_zero(r, struct lsa_SidArray); 2662 if (r->out.sids == NULL) { 2663 talloc_free(r); 2664 return false; 2665 } 2666 2667 r->out.result = _samr_GetMembersInAlias(p, r); 2668 2669 if (p->rng_fault_state) { 2670 talloc_free(r); 2671 /* Return true here, srv_pipe_hnd.c will take care */ 2672 return true; 2673 } 2674 2675 if (DEBUGLEVEL >= 10) { 2676 NDR_PRINT_OUT_DEBUG(samr_GetMembersInAlias, r); 2677 } 2678 2679 push = ndr_push_init_ctx(r, NULL); 2680 if (push == NULL) { 2681 talloc_free(r); 2682 return false; 2683 } 2684 2685 ndr_err = call->ndr_push(push, NDR_OUT, r); 2686 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2687 talloc_free(r); 2688 return false; 2689 } 2690 2691 blob = ndr_push_blob(push); 2692 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2693 talloc_free(r); 2694 return false; 2695 } 2696 2697 talloc_free(r); 2698 2699 return true; 2700} 2701 2702static bool api_samr_OpenUser(pipes_struct *p) 2703{ 2704 const struct ndr_interface_call *call; 2705 struct ndr_pull *pull; 2706 struct ndr_push *push; 2707 enum ndr_err_code ndr_err; 2708 DATA_BLOB blob; 2709 struct samr_OpenUser *r; 2710 2711 call = &ndr_table_samr.calls[NDR_SAMR_OPENUSER]; 2712 2713 r = talloc(talloc_tos(), struct samr_OpenUser); 2714 if (r == NULL) { 2715 return false; 2716 } 2717 2718 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2719 talloc_free(r); 2720 return false; 2721 } 2722 2723 pull = ndr_pull_init_blob(&blob, r, NULL); 2724 if (pull == NULL) { 2725 talloc_free(r); 2726 return false; 2727 } 2728 2729 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2730 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2731 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2732 talloc_free(r); 2733 return false; 2734 } 2735 2736 if (DEBUGLEVEL >= 10) { 2737 NDR_PRINT_IN_DEBUG(samr_OpenUser, r); 2738 } 2739 2740 ZERO_STRUCT(r->out); 2741 r->out.user_handle = talloc_zero(r, struct policy_handle); 2742 if (r->out.user_handle == NULL) { 2743 talloc_free(r); 2744 return false; 2745 } 2746 2747 r->out.result = _samr_OpenUser(p, r); 2748 2749 if (p->rng_fault_state) { 2750 talloc_free(r); 2751 /* Return true here, srv_pipe_hnd.c will take care */ 2752 return true; 2753 } 2754 2755 if (DEBUGLEVEL >= 10) { 2756 NDR_PRINT_OUT_DEBUG(samr_OpenUser, r); 2757 } 2758 2759 push = ndr_push_init_ctx(r, NULL); 2760 if (push == NULL) { 2761 talloc_free(r); 2762 return false; 2763 } 2764 2765 ndr_err = call->ndr_push(push, NDR_OUT, r); 2766 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2767 talloc_free(r); 2768 return false; 2769 } 2770 2771 blob = ndr_push_blob(push); 2772 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2773 talloc_free(r); 2774 return false; 2775 } 2776 2777 talloc_free(r); 2778 2779 return true; 2780} 2781 2782static bool api_samr_DeleteUser(pipes_struct *p) 2783{ 2784 const struct ndr_interface_call *call; 2785 struct ndr_pull *pull; 2786 struct ndr_push *push; 2787 enum ndr_err_code ndr_err; 2788 DATA_BLOB blob; 2789 struct samr_DeleteUser *r; 2790 2791 call = &ndr_table_samr.calls[NDR_SAMR_DELETEUSER]; 2792 2793 r = talloc(talloc_tos(), struct samr_DeleteUser); 2794 if (r == NULL) { 2795 return false; 2796 } 2797 2798 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2799 talloc_free(r); 2800 return false; 2801 } 2802 2803 pull = ndr_pull_init_blob(&blob, r, NULL); 2804 if (pull == NULL) { 2805 talloc_free(r); 2806 return false; 2807 } 2808 2809 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2810 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2811 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2812 talloc_free(r); 2813 return false; 2814 } 2815 2816 if (DEBUGLEVEL >= 10) { 2817 NDR_PRINT_IN_DEBUG(samr_DeleteUser, r); 2818 } 2819 2820 ZERO_STRUCT(r->out); 2821 r->out.user_handle = r->in.user_handle; 2822 r->out.result = _samr_DeleteUser(p, r); 2823 2824 if (p->rng_fault_state) { 2825 talloc_free(r); 2826 /* Return true here, srv_pipe_hnd.c will take care */ 2827 return true; 2828 } 2829 2830 if (DEBUGLEVEL >= 10) { 2831 NDR_PRINT_OUT_DEBUG(samr_DeleteUser, r); 2832 } 2833 2834 push = ndr_push_init_ctx(r, NULL); 2835 if (push == NULL) { 2836 talloc_free(r); 2837 return false; 2838 } 2839 2840 ndr_err = call->ndr_push(push, NDR_OUT, r); 2841 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2842 talloc_free(r); 2843 return false; 2844 } 2845 2846 blob = ndr_push_blob(push); 2847 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2848 talloc_free(r); 2849 return false; 2850 } 2851 2852 talloc_free(r); 2853 2854 return true; 2855} 2856 2857static bool api_samr_QueryUserInfo(pipes_struct *p) 2858{ 2859 const struct ndr_interface_call *call; 2860 struct ndr_pull *pull; 2861 struct ndr_push *push; 2862 enum ndr_err_code ndr_err; 2863 DATA_BLOB blob; 2864 struct samr_QueryUserInfo *r; 2865 2866 call = &ndr_table_samr.calls[NDR_SAMR_QUERYUSERINFO]; 2867 2868 r = talloc(talloc_tos(), struct samr_QueryUserInfo); 2869 if (r == NULL) { 2870 return false; 2871 } 2872 2873 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2874 talloc_free(r); 2875 return false; 2876 } 2877 2878 pull = ndr_pull_init_blob(&blob, r, NULL); 2879 if (pull == NULL) { 2880 talloc_free(r); 2881 return false; 2882 } 2883 2884 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2885 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2886 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2887 talloc_free(r); 2888 return false; 2889 } 2890 2891 if (DEBUGLEVEL >= 10) { 2892 NDR_PRINT_IN_DEBUG(samr_QueryUserInfo, r); 2893 } 2894 2895 ZERO_STRUCT(r->out); 2896 r->out.info = talloc_zero(r, union samr_UserInfo *); 2897 if (r->out.info == NULL) { 2898 talloc_free(r); 2899 return false; 2900 } 2901 2902 r->out.result = _samr_QueryUserInfo(p, r); 2903 2904 if (p->rng_fault_state) { 2905 talloc_free(r); 2906 /* Return true here, srv_pipe_hnd.c will take care */ 2907 return true; 2908 } 2909 2910 if (DEBUGLEVEL >= 10) { 2911 NDR_PRINT_OUT_DEBUG(samr_QueryUserInfo, r); 2912 } 2913 2914 push = ndr_push_init_ctx(r, NULL); 2915 if (push == NULL) { 2916 talloc_free(r); 2917 return false; 2918 } 2919 2920 ndr_err = call->ndr_push(push, NDR_OUT, r); 2921 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2922 talloc_free(r); 2923 return false; 2924 } 2925 2926 blob = ndr_push_blob(push); 2927 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2928 talloc_free(r); 2929 return false; 2930 } 2931 2932 talloc_free(r); 2933 2934 return true; 2935} 2936 2937static bool api_samr_SetUserInfo(pipes_struct *p) 2938{ 2939 const struct ndr_interface_call *call; 2940 struct ndr_pull *pull; 2941 struct ndr_push *push; 2942 enum ndr_err_code ndr_err; 2943 DATA_BLOB blob; 2944 struct samr_SetUserInfo *r; 2945 2946 call = &ndr_table_samr.calls[NDR_SAMR_SETUSERINFO]; 2947 2948 r = talloc(talloc_tos(), struct samr_SetUserInfo); 2949 if (r == NULL) { 2950 return false; 2951 } 2952 2953 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2954 talloc_free(r); 2955 return false; 2956 } 2957 2958 pull = ndr_pull_init_blob(&blob, r, NULL); 2959 if (pull == NULL) { 2960 talloc_free(r); 2961 return false; 2962 } 2963 2964 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2965 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2966 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2967 talloc_free(r); 2968 return false; 2969 } 2970 2971 if (DEBUGLEVEL >= 10) { 2972 NDR_PRINT_IN_DEBUG(samr_SetUserInfo, r); 2973 } 2974 2975 r->out.result = _samr_SetUserInfo(p, r); 2976 2977 if (p->rng_fault_state) { 2978 talloc_free(r); 2979 /* Return true here, srv_pipe_hnd.c will take care */ 2980 return true; 2981 } 2982 2983 if (DEBUGLEVEL >= 10) { 2984 NDR_PRINT_OUT_DEBUG(samr_SetUserInfo, r); 2985 } 2986 2987 push = ndr_push_init_ctx(r, NULL); 2988 if (push == NULL) { 2989 talloc_free(r); 2990 return false; 2991 } 2992 2993 ndr_err = call->ndr_push(push, NDR_OUT, r); 2994 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2995 talloc_free(r); 2996 return false; 2997 } 2998 2999 blob = ndr_push_blob(push); 3000 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3001 talloc_free(r); 3002 return false; 3003 } 3004 3005 talloc_free(r); 3006 3007 return true; 3008} 3009 3010static bool api_samr_ChangePasswordUser(pipes_struct *p) 3011{ 3012 const struct ndr_interface_call *call; 3013 struct ndr_pull *pull; 3014 struct ndr_push *push; 3015 enum ndr_err_code ndr_err; 3016 DATA_BLOB blob; 3017 struct samr_ChangePasswordUser *r; 3018 3019 call = &ndr_table_samr.calls[NDR_SAMR_CHANGEPASSWORDUSER]; 3020 3021 r = talloc(talloc_tos(), struct samr_ChangePasswordUser); 3022 if (r == NULL) { 3023 return false; 3024 } 3025 3026 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3027 talloc_free(r); 3028 return false; 3029 } 3030 3031 pull = ndr_pull_init_blob(&blob, r, NULL); 3032 if (pull == NULL) { 3033 talloc_free(r); 3034 return false; 3035 } 3036 3037 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3038 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3039 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3040 talloc_free(r); 3041 return false; 3042 } 3043 3044 if (DEBUGLEVEL >= 10) { 3045 NDR_PRINT_IN_DEBUG(samr_ChangePasswordUser, r); 3046 } 3047 3048 r->out.result = _samr_ChangePasswordUser(p, r); 3049 3050 if (p->rng_fault_state) { 3051 talloc_free(r); 3052 /* Return true here, srv_pipe_hnd.c will take care */ 3053 return true; 3054 } 3055 3056 if (DEBUGLEVEL >= 10) { 3057 NDR_PRINT_OUT_DEBUG(samr_ChangePasswordUser, r); 3058 } 3059 3060 push = ndr_push_init_ctx(r, NULL); 3061 if (push == NULL) { 3062 talloc_free(r); 3063 return false; 3064 } 3065 3066 ndr_err = call->ndr_push(push, NDR_OUT, r); 3067 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3068 talloc_free(r); 3069 return false; 3070 } 3071 3072 blob = ndr_push_blob(push); 3073 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3074 talloc_free(r); 3075 return false; 3076 } 3077 3078 talloc_free(r); 3079 3080 return true; 3081} 3082 3083static bool api_samr_GetGroupsForUser(pipes_struct *p) 3084{ 3085 const struct ndr_interface_call *call; 3086 struct ndr_pull *pull; 3087 struct ndr_push *push; 3088 enum ndr_err_code ndr_err; 3089 DATA_BLOB blob; 3090 struct samr_GetGroupsForUser *r; 3091 3092 call = &ndr_table_samr.calls[NDR_SAMR_GETGROUPSFORUSER]; 3093 3094 r = talloc(talloc_tos(), struct samr_GetGroupsForUser); 3095 if (r == NULL) { 3096 return false; 3097 } 3098 3099 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3100 talloc_free(r); 3101 return false; 3102 } 3103 3104 pull = ndr_pull_init_blob(&blob, r, NULL); 3105 if (pull == NULL) { 3106 talloc_free(r); 3107 return false; 3108 } 3109 3110 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3111 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3112 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3113 talloc_free(r); 3114 return false; 3115 } 3116 3117 if (DEBUGLEVEL >= 10) { 3118 NDR_PRINT_IN_DEBUG(samr_GetGroupsForUser, r); 3119 } 3120 3121 ZERO_STRUCT(r->out); 3122 r->out.rids = talloc_zero(r, struct samr_RidWithAttributeArray *); 3123 if (r->out.rids == NULL) { 3124 talloc_free(r); 3125 return false; 3126 } 3127 3128 r->out.result = _samr_GetGroupsForUser(p, r); 3129 3130 if (p->rng_fault_state) { 3131 talloc_free(r); 3132 /* Return true here, srv_pipe_hnd.c will take care */ 3133 return true; 3134 } 3135 3136 if (DEBUGLEVEL >= 10) { 3137 NDR_PRINT_OUT_DEBUG(samr_GetGroupsForUser, r); 3138 } 3139 3140 push = ndr_push_init_ctx(r, NULL); 3141 if (push == NULL) { 3142 talloc_free(r); 3143 return false; 3144 } 3145 3146 ndr_err = call->ndr_push(push, NDR_OUT, r); 3147 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3148 talloc_free(r); 3149 return false; 3150 } 3151 3152 blob = ndr_push_blob(push); 3153 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3154 talloc_free(r); 3155 return false; 3156 } 3157 3158 talloc_free(r); 3159 3160 return true; 3161} 3162 3163static bool api_samr_QueryDisplayInfo(pipes_struct *p) 3164{ 3165 const struct ndr_interface_call *call; 3166 struct ndr_pull *pull; 3167 struct ndr_push *push; 3168 enum ndr_err_code ndr_err; 3169 DATA_BLOB blob; 3170 struct samr_QueryDisplayInfo *r; 3171 3172 call = &ndr_table_samr.calls[NDR_SAMR_QUERYDISPLAYINFO]; 3173 3174 r = talloc(talloc_tos(), struct samr_QueryDisplayInfo); 3175 if (r == NULL) { 3176 return false; 3177 } 3178 3179 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3180 talloc_free(r); 3181 return false; 3182 } 3183 3184 pull = ndr_pull_init_blob(&blob, r, NULL); 3185 if (pull == NULL) { 3186 talloc_free(r); 3187 return false; 3188 } 3189 3190 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3191 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3192 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3193 talloc_free(r); 3194 return false; 3195 } 3196 3197 if (DEBUGLEVEL >= 10) { 3198 NDR_PRINT_IN_DEBUG(samr_QueryDisplayInfo, r); 3199 } 3200 3201 ZERO_STRUCT(r->out); 3202 r->out.total_size = talloc_zero(r, uint32_t); 3203 if (r->out.total_size == NULL) { 3204 talloc_free(r); 3205 return false; 3206 } 3207 3208 r->out.returned_size = talloc_zero(r, uint32_t); 3209 if (r->out.returned_size == NULL) { 3210 talloc_free(r); 3211 return false; 3212 } 3213 3214 r->out.info = talloc_zero(r, union samr_DispInfo); 3215 if (r->out.info == NULL) { 3216 talloc_free(r); 3217 return false; 3218 } 3219 3220 r->out.result = _samr_QueryDisplayInfo(p, r); 3221 3222 if (p->rng_fault_state) { 3223 talloc_free(r); 3224 /* Return true here, srv_pipe_hnd.c will take care */ 3225 return true; 3226 } 3227 3228 if (DEBUGLEVEL >= 10) { 3229 NDR_PRINT_OUT_DEBUG(samr_QueryDisplayInfo, r); 3230 } 3231 3232 push = ndr_push_init_ctx(r, NULL); 3233 if (push == NULL) { 3234 talloc_free(r); 3235 return false; 3236 } 3237 3238 ndr_err = call->ndr_push(push, NDR_OUT, r); 3239 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3240 talloc_free(r); 3241 return false; 3242 } 3243 3244 blob = ndr_push_blob(push); 3245 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3246 talloc_free(r); 3247 return false; 3248 } 3249 3250 talloc_free(r); 3251 3252 return true; 3253} 3254 3255static bool api_samr_GetDisplayEnumerationIndex(pipes_struct *p) 3256{ 3257 const struct ndr_interface_call *call; 3258 struct ndr_pull *pull; 3259 struct ndr_push *push; 3260 enum ndr_err_code ndr_err; 3261 DATA_BLOB blob; 3262 struct samr_GetDisplayEnumerationIndex *r; 3263 3264 call = &ndr_table_samr.calls[NDR_SAMR_GETDISPLAYENUMERATIONINDEX]; 3265 3266 r = talloc(talloc_tos(), struct samr_GetDisplayEnumerationIndex); 3267 if (r == NULL) { 3268 return false; 3269 } 3270 3271 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3272 talloc_free(r); 3273 return false; 3274 } 3275 3276 pull = ndr_pull_init_blob(&blob, r, NULL); 3277 if (pull == NULL) { 3278 talloc_free(r); 3279 return false; 3280 } 3281 3282 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3283 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3284 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3285 talloc_free(r); 3286 return false; 3287 } 3288 3289 if (DEBUGLEVEL >= 10) { 3290 NDR_PRINT_IN_DEBUG(samr_GetDisplayEnumerationIndex, r); 3291 } 3292 3293 ZERO_STRUCT(r->out); 3294 r->out.idx = talloc_zero(r, uint32_t); 3295 if (r->out.idx == NULL) { 3296 talloc_free(r); 3297 return false; 3298 } 3299 3300 r->out.result = _samr_GetDisplayEnumerationIndex(p, r); 3301 3302 if (p->rng_fault_state) { 3303 talloc_free(r); 3304 /* Return true here, srv_pipe_hnd.c will take care */ 3305 return true; 3306 } 3307 3308 if (DEBUGLEVEL >= 10) { 3309 NDR_PRINT_OUT_DEBUG(samr_GetDisplayEnumerationIndex, r); 3310 } 3311 3312 push = ndr_push_init_ctx(r, NULL); 3313 if (push == NULL) { 3314 talloc_free(r); 3315 return false; 3316 } 3317 3318 ndr_err = call->ndr_push(push, NDR_OUT, r); 3319 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3320 talloc_free(r); 3321 return false; 3322 } 3323 3324 blob = ndr_push_blob(push); 3325 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3326 talloc_free(r); 3327 return false; 3328 } 3329 3330 talloc_free(r); 3331 3332 return true; 3333} 3334 3335static bool api_samr_TestPrivateFunctionsDomain(pipes_struct *p) 3336{ 3337 const struct ndr_interface_call *call; 3338 struct ndr_pull *pull; 3339 struct ndr_push *push; 3340 enum ndr_err_code ndr_err; 3341 DATA_BLOB blob; 3342 struct samr_TestPrivateFunctionsDomain *r; 3343 3344 call = &ndr_table_samr.calls[NDR_SAMR_TESTPRIVATEFUNCTIONSDOMAIN]; 3345 3346 r = talloc(talloc_tos(), struct samr_TestPrivateFunctionsDomain); 3347 if (r == NULL) { 3348 return false; 3349 } 3350 3351 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3352 talloc_free(r); 3353 return false; 3354 } 3355 3356 pull = ndr_pull_init_blob(&blob, r, NULL); 3357 if (pull == NULL) { 3358 talloc_free(r); 3359 return false; 3360 } 3361 3362 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3363 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3364 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3365 talloc_free(r); 3366 return false; 3367 } 3368 3369 if (DEBUGLEVEL >= 10) { 3370 NDR_PRINT_IN_DEBUG(samr_TestPrivateFunctionsDomain, r); 3371 } 3372 3373 r->out.result = _samr_TestPrivateFunctionsDomain(p, r); 3374 3375 if (p->rng_fault_state) { 3376 talloc_free(r); 3377 /* Return true here, srv_pipe_hnd.c will take care */ 3378 return true; 3379 } 3380 3381 if (DEBUGLEVEL >= 10) { 3382 NDR_PRINT_OUT_DEBUG(samr_TestPrivateFunctionsDomain, r); 3383 } 3384 3385 push = ndr_push_init_ctx(r, NULL); 3386 if (push == NULL) { 3387 talloc_free(r); 3388 return false; 3389 } 3390 3391 ndr_err = call->ndr_push(push, NDR_OUT, r); 3392 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3393 talloc_free(r); 3394 return false; 3395 } 3396 3397 blob = ndr_push_blob(push); 3398 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3399 talloc_free(r); 3400 return false; 3401 } 3402 3403 talloc_free(r); 3404 3405 return true; 3406} 3407 3408static bool api_samr_TestPrivateFunctionsUser(pipes_struct *p) 3409{ 3410 const struct ndr_interface_call *call; 3411 struct ndr_pull *pull; 3412 struct ndr_push *push; 3413 enum ndr_err_code ndr_err; 3414 DATA_BLOB blob; 3415 struct samr_TestPrivateFunctionsUser *r; 3416 3417 call = &ndr_table_samr.calls[NDR_SAMR_TESTPRIVATEFUNCTIONSUSER]; 3418 3419 r = talloc(talloc_tos(), struct samr_TestPrivateFunctionsUser); 3420 if (r == NULL) { 3421 return false; 3422 } 3423 3424 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3425 talloc_free(r); 3426 return false; 3427 } 3428 3429 pull = ndr_pull_init_blob(&blob, r, NULL); 3430 if (pull == NULL) { 3431 talloc_free(r); 3432 return false; 3433 } 3434 3435 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3436 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3437 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3438 talloc_free(r); 3439 return false; 3440 } 3441 3442 if (DEBUGLEVEL >= 10) { 3443 NDR_PRINT_IN_DEBUG(samr_TestPrivateFunctionsUser, r); 3444 } 3445 3446 r->out.result = _samr_TestPrivateFunctionsUser(p, r); 3447 3448 if (p->rng_fault_state) { 3449 talloc_free(r); 3450 /* Return true here, srv_pipe_hnd.c will take care */ 3451 return true; 3452 } 3453 3454 if (DEBUGLEVEL >= 10) { 3455 NDR_PRINT_OUT_DEBUG(samr_TestPrivateFunctionsUser, r); 3456 } 3457 3458 push = ndr_push_init_ctx(r, NULL); 3459 if (push == NULL) { 3460 talloc_free(r); 3461 return false; 3462 } 3463 3464 ndr_err = call->ndr_push(push, NDR_OUT, r); 3465 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3466 talloc_free(r); 3467 return false; 3468 } 3469 3470 blob = ndr_push_blob(push); 3471 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3472 talloc_free(r); 3473 return false; 3474 } 3475 3476 talloc_free(r); 3477 3478 return true; 3479} 3480 3481static bool api_samr_GetUserPwInfo(pipes_struct *p) 3482{ 3483 const struct ndr_interface_call *call; 3484 struct ndr_pull *pull; 3485 struct ndr_push *push; 3486 enum ndr_err_code ndr_err; 3487 DATA_BLOB blob; 3488 struct samr_GetUserPwInfo *r; 3489 3490 call = &ndr_table_samr.calls[NDR_SAMR_GETUSERPWINFO]; 3491 3492 r = talloc(talloc_tos(), struct samr_GetUserPwInfo); 3493 if (r == NULL) { 3494 return false; 3495 } 3496 3497 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3498 talloc_free(r); 3499 return false; 3500 } 3501 3502 pull = ndr_pull_init_blob(&blob, r, NULL); 3503 if (pull == NULL) { 3504 talloc_free(r); 3505 return false; 3506 } 3507 3508 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3509 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3510 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3511 talloc_free(r); 3512 return false; 3513 } 3514 3515 if (DEBUGLEVEL >= 10) { 3516 NDR_PRINT_IN_DEBUG(samr_GetUserPwInfo, r); 3517 } 3518 3519 ZERO_STRUCT(r->out); 3520 r->out.info = talloc_zero(r, struct samr_PwInfo); 3521 if (r->out.info == NULL) { 3522 talloc_free(r); 3523 return false; 3524 } 3525 3526 r->out.result = _samr_GetUserPwInfo(p, r); 3527 3528 if (p->rng_fault_state) { 3529 talloc_free(r); 3530 /* Return true here, srv_pipe_hnd.c will take care */ 3531 return true; 3532 } 3533 3534 if (DEBUGLEVEL >= 10) { 3535 NDR_PRINT_OUT_DEBUG(samr_GetUserPwInfo, r); 3536 } 3537 3538 push = ndr_push_init_ctx(r, NULL); 3539 if (push == NULL) { 3540 talloc_free(r); 3541 return false; 3542 } 3543 3544 ndr_err = call->ndr_push(push, NDR_OUT, r); 3545 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3546 talloc_free(r); 3547 return false; 3548 } 3549 3550 blob = ndr_push_blob(push); 3551 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3552 talloc_free(r); 3553 return false; 3554 } 3555 3556 talloc_free(r); 3557 3558 return true; 3559} 3560 3561static bool api_samr_RemoveMemberFromForeignDomain(pipes_struct *p) 3562{ 3563 const struct ndr_interface_call *call; 3564 struct ndr_pull *pull; 3565 struct ndr_push *push; 3566 enum ndr_err_code ndr_err; 3567 DATA_BLOB blob; 3568 struct samr_RemoveMemberFromForeignDomain *r; 3569 3570 call = &ndr_table_samr.calls[NDR_SAMR_REMOVEMEMBERFROMFOREIGNDOMAIN]; 3571 3572 r = talloc(talloc_tos(), struct samr_RemoveMemberFromForeignDomain); 3573 if (r == NULL) { 3574 return false; 3575 } 3576 3577 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3578 talloc_free(r); 3579 return false; 3580 } 3581 3582 pull = ndr_pull_init_blob(&blob, r, NULL); 3583 if (pull == NULL) { 3584 talloc_free(r); 3585 return false; 3586 } 3587 3588 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3589 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3590 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3591 talloc_free(r); 3592 return false; 3593 } 3594 3595 if (DEBUGLEVEL >= 10) { 3596 NDR_PRINT_IN_DEBUG(samr_RemoveMemberFromForeignDomain, r); 3597 } 3598 3599 r->out.result = _samr_RemoveMemberFromForeignDomain(p, r); 3600 3601 if (p->rng_fault_state) { 3602 talloc_free(r); 3603 /* Return true here, srv_pipe_hnd.c will take care */ 3604 return true; 3605 } 3606 3607 if (DEBUGLEVEL >= 10) { 3608 NDR_PRINT_OUT_DEBUG(samr_RemoveMemberFromForeignDomain, r); 3609 } 3610 3611 push = ndr_push_init_ctx(r, NULL); 3612 if (push == NULL) { 3613 talloc_free(r); 3614 return false; 3615 } 3616 3617 ndr_err = call->ndr_push(push, NDR_OUT, r); 3618 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3619 talloc_free(r); 3620 return false; 3621 } 3622 3623 blob = ndr_push_blob(push); 3624 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3625 talloc_free(r); 3626 return false; 3627 } 3628 3629 talloc_free(r); 3630 3631 return true; 3632} 3633 3634static bool api_samr_QueryDomainInfo2(pipes_struct *p) 3635{ 3636 const struct ndr_interface_call *call; 3637 struct ndr_pull *pull; 3638 struct ndr_push *push; 3639 enum ndr_err_code ndr_err; 3640 DATA_BLOB blob; 3641 struct samr_QueryDomainInfo2 *r; 3642 3643 call = &ndr_table_samr.calls[NDR_SAMR_QUERYDOMAININFO2]; 3644 3645 r = talloc(talloc_tos(), struct samr_QueryDomainInfo2); 3646 if (r == NULL) { 3647 return false; 3648 } 3649 3650 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3651 talloc_free(r); 3652 return false; 3653 } 3654 3655 pull = ndr_pull_init_blob(&blob, r, NULL); 3656 if (pull == NULL) { 3657 talloc_free(r); 3658 return false; 3659 } 3660 3661 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3662 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3663 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3664 talloc_free(r); 3665 return false; 3666 } 3667 3668 if (DEBUGLEVEL >= 10) { 3669 NDR_PRINT_IN_DEBUG(samr_QueryDomainInfo2, r); 3670 } 3671 3672 ZERO_STRUCT(r->out); 3673 r->out.info = talloc_zero(r, union samr_DomainInfo *); 3674 if (r->out.info == NULL) { 3675 talloc_free(r); 3676 return false; 3677 } 3678 3679 r->out.result = _samr_QueryDomainInfo2(p, r); 3680 3681 if (p->rng_fault_state) { 3682 talloc_free(r); 3683 /* Return true here, srv_pipe_hnd.c will take care */ 3684 return true; 3685 } 3686 3687 if (DEBUGLEVEL >= 10) { 3688 NDR_PRINT_OUT_DEBUG(samr_QueryDomainInfo2, r); 3689 } 3690 3691 push = ndr_push_init_ctx(r, NULL); 3692 if (push == NULL) { 3693 talloc_free(r); 3694 return false; 3695 } 3696 3697 ndr_err = call->ndr_push(push, NDR_OUT, r); 3698 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3699 talloc_free(r); 3700 return false; 3701 } 3702 3703 blob = ndr_push_blob(push); 3704 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3705 talloc_free(r); 3706 return false; 3707 } 3708 3709 talloc_free(r); 3710 3711 return true; 3712} 3713 3714static bool api_samr_QueryUserInfo2(pipes_struct *p) 3715{ 3716 const struct ndr_interface_call *call; 3717 struct ndr_pull *pull; 3718 struct ndr_push *push; 3719 enum ndr_err_code ndr_err; 3720 DATA_BLOB blob; 3721 struct samr_QueryUserInfo2 *r; 3722 3723 call = &ndr_table_samr.calls[NDR_SAMR_QUERYUSERINFO2]; 3724 3725 r = talloc(talloc_tos(), struct samr_QueryUserInfo2); 3726 if (r == NULL) { 3727 return false; 3728 } 3729 3730 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3731 talloc_free(r); 3732 return false; 3733 } 3734 3735 pull = ndr_pull_init_blob(&blob, r, NULL); 3736 if (pull == NULL) { 3737 talloc_free(r); 3738 return false; 3739 } 3740 3741 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3742 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3743 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3744 talloc_free(r); 3745 return false; 3746 } 3747 3748 if (DEBUGLEVEL >= 10) { 3749 NDR_PRINT_IN_DEBUG(samr_QueryUserInfo2, r); 3750 } 3751 3752 ZERO_STRUCT(r->out); 3753 r->out.info = talloc_zero(r, union samr_UserInfo *); 3754 if (r->out.info == NULL) { 3755 talloc_free(r); 3756 return false; 3757 } 3758 3759 r->out.result = _samr_QueryUserInfo2(p, r); 3760 3761 if (p->rng_fault_state) { 3762 talloc_free(r); 3763 /* Return true here, srv_pipe_hnd.c will take care */ 3764 return true; 3765 } 3766 3767 if (DEBUGLEVEL >= 10) { 3768 NDR_PRINT_OUT_DEBUG(samr_QueryUserInfo2, r); 3769 } 3770 3771 push = ndr_push_init_ctx(r, NULL); 3772 if (push == NULL) { 3773 talloc_free(r); 3774 return false; 3775 } 3776 3777 ndr_err = call->ndr_push(push, NDR_OUT, r); 3778 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3779 talloc_free(r); 3780 return false; 3781 } 3782 3783 blob = ndr_push_blob(push); 3784 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3785 talloc_free(r); 3786 return false; 3787 } 3788 3789 talloc_free(r); 3790 3791 return true; 3792} 3793 3794static bool api_samr_QueryDisplayInfo2(pipes_struct *p) 3795{ 3796 const struct ndr_interface_call *call; 3797 struct ndr_pull *pull; 3798 struct ndr_push *push; 3799 enum ndr_err_code ndr_err; 3800 DATA_BLOB blob; 3801 struct samr_QueryDisplayInfo2 *r; 3802 3803 call = &ndr_table_samr.calls[NDR_SAMR_QUERYDISPLAYINFO2]; 3804 3805 r = talloc(talloc_tos(), struct samr_QueryDisplayInfo2); 3806 if (r == NULL) { 3807 return false; 3808 } 3809 3810 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3811 talloc_free(r); 3812 return false; 3813 } 3814 3815 pull = ndr_pull_init_blob(&blob, r, NULL); 3816 if (pull == NULL) { 3817 talloc_free(r); 3818 return false; 3819 } 3820 3821 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3822 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3823 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3824 talloc_free(r); 3825 return false; 3826 } 3827 3828 if (DEBUGLEVEL >= 10) { 3829 NDR_PRINT_IN_DEBUG(samr_QueryDisplayInfo2, r); 3830 } 3831 3832 ZERO_STRUCT(r->out); 3833 r->out.total_size = talloc_zero(r, uint32_t); 3834 if (r->out.total_size == NULL) { 3835 talloc_free(r); 3836 return false; 3837 } 3838 3839 r->out.returned_size = talloc_zero(r, uint32_t); 3840 if (r->out.returned_size == NULL) { 3841 talloc_free(r); 3842 return false; 3843 } 3844 3845 r->out.info = talloc_zero(r, union samr_DispInfo); 3846 if (r->out.info == NULL) { 3847 talloc_free(r); 3848 return false; 3849 } 3850 3851 r->out.result = _samr_QueryDisplayInfo2(p, r); 3852 3853 if (p->rng_fault_state) { 3854 talloc_free(r); 3855 /* Return true here, srv_pipe_hnd.c will take care */ 3856 return true; 3857 } 3858 3859 if (DEBUGLEVEL >= 10) { 3860 NDR_PRINT_OUT_DEBUG(samr_QueryDisplayInfo2, r); 3861 } 3862 3863 push = ndr_push_init_ctx(r, NULL); 3864 if (push == NULL) { 3865 talloc_free(r); 3866 return false; 3867 } 3868 3869 ndr_err = call->ndr_push(push, NDR_OUT, r); 3870 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3871 talloc_free(r); 3872 return false; 3873 } 3874 3875 blob = ndr_push_blob(push); 3876 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3877 talloc_free(r); 3878 return false; 3879 } 3880 3881 talloc_free(r); 3882 3883 return true; 3884} 3885 3886static bool api_samr_GetDisplayEnumerationIndex2(pipes_struct *p) 3887{ 3888 const struct ndr_interface_call *call; 3889 struct ndr_pull *pull; 3890 struct ndr_push *push; 3891 enum ndr_err_code ndr_err; 3892 DATA_BLOB blob; 3893 struct samr_GetDisplayEnumerationIndex2 *r; 3894 3895 call = &ndr_table_samr.calls[NDR_SAMR_GETDISPLAYENUMERATIONINDEX2]; 3896 3897 r = talloc(talloc_tos(), struct samr_GetDisplayEnumerationIndex2); 3898 if (r == NULL) { 3899 return false; 3900 } 3901 3902 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3903 talloc_free(r); 3904 return false; 3905 } 3906 3907 pull = ndr_pull_init_blob(&blob, r, NULL); 3908 if (pull == NULL) { 3909 talloc_free(r); 3910 return false; 3911 } 3912 3913 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3914 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3915 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3916 talloc_free(r); 3917 return false; 3918 } 3919 3920 if (DEBUGLEVEL >= 10) { 3921 NDR_PRINT_IN_DEBUG(samr_GetDisplayEnumerationIndex2, r); 3922 } 3923 3924 ZERO_STRUCT(r->out); 3925 r->out.idx = talloc_zero(r, uint32_t); 3926 if (r->out.idx == NULL) { 3927 talloc_free(r); 3928 return false; 3929 } 3930 3931 r->out.result = _samr_GetDisplayEnumerationIndex2(p, r); 3932 3933 if (p->rng_fault_state) { 3934 talloc_free(r); 3935 /* Return true here, srv_pipe_hnd.c will take care */ 3936 return true; 3937 } 3938 3939 if (DEBUGLEVEL >= 10) { 3940 NDR_PRINT_OUT_DEBUG(samr_GetDisplayEnumerationIndex2, r); 3941 } 3942 3943 push = ndr_push_init_ctx(r, NULL); 3944 if (push == NULL) { 3945 talloc_free(r); 3946 return false; 3947 } 3948 3949 ndr_err = call->ndr_push(push, NDR_OUT, r); 3950 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3951 talloc_free(r); 3952 return false; 3953 } 3954 3955 blob = ndr_push_blob(push); 3956 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3957 talloc_free(r); 3958 return false; 3959 } 3960 3961 talloc_free(r); 3962 3963 return true; 3964} 3965 3966static bool api_samr_CreateUser2(pipes_struct *p) 3967{ 3968 const struct ndr_interface_call *call; 3969 struct ndr_pull *pull; 3970 struct ndr_push *push; 3971 enum ndr_err_code ndr_err; 3972 DATA_BLOB blob; 3973 struct samr_CreateUser2 *r; 3974 3975 call = &ndr_table_samr.calls[NDR_SAMR_CREATEUSER2]; 3976 3977 r = talloc(talloc_tos(), struct samr_CreateUser2); 3978 if (r == NULL) { 3979 return false; 3980 } 3981 3982 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3983 talloc_free(r); 3984 return false; 3985 } 3986 3987 pull = ndr_pull_init_blob(&blob, r, NULL); 3988 if (pull == NULL) { 3989 talloc_free(r); 3990 return false; 3991 } 3992 3993 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3994 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3995 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3996 talloc_free(r); 3997 return false; 3998 } 3999 4000 if (DEBUGLEVEL >= 10) { 4001 NDR_PRINT_IN_DEBUG(samr_CreateUser2, r); 4002 } 4003 4004 ZERO_STRUCT(r->out); 4005 r->out.user_handle = talloc_zero(r, struct policy_handle); 4006 if (r->out.user_handle == NULL) { 4007 talloc_free(r); 4008 return false; 4009 } 4010 4011 r->out.access_granted = talloc_zero(r, uint32_t); 4012 if (r->out.access_granted == NULL) { 4013 talloc_free(r); 4014 return false; 4015 } 4016 4017 r->out.rid = talloc_zero(r, uint32_t); 4018 if (r->out.rid == NULL) { 4019 talloc_free(r); 4020 return false; 4021 } 4022 4023 r->out.result = _samr_CreateUser2(p, r); 4024 4025 if (p->rng_fault_state) { 4026 talloc_free(r); 4027 /* Return true here, srv_pipe_hnd.c will take care */ 4028 return true; 4029 } 4030 4031 if (DEBUGLEVEL >= 10) { 4032 NDR_PRINT_OUT_DEBUG(samr_CreateUser2, r); 4033 } 4034 4035 push = ndr_push_init_ctx(r, NULL); 4036 if (push == NULL) { 4037 talloc_free(r); 4038 return false; 4039 } 4040 4041 ndr_err = call->ndr_push(push, NDR_OUT, r); 4042 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4043 talloc_free(r); 4044 return false; 4045 } 4046 4047 blob = ndr_push_blob(push); 4048 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4049 talloc_free(r); 4050 return false; 4051 } 4052 4053 talloc_free(r); 4054 4055 return true; 4056} 4057 4058static bool api_samr_QueryDisplayInfo3(pipes_struct *p) 4059{ 4060 const struct ndr_interface_call *call; 4061 struct ndr_pull *pull; 4062 struct ndr_push *push; 4063 enum ndr_err_code ndr_err; 4064 DATA_BLOB blob; 4065 struct samr_QueryDisplayInfo3 *r; 4066 4067 call = &ndr_table_samr.calls[NDR_SAMR_QUERYDISPLAYINFO3]; 4068 4069 r = talloc(talloc_tos(), struct samr_QueryDisplayInfo3); 4070 if (r == NULL) { 4071 return false; 4072 } 4073 4074 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4075 talloc_free(r); 4076 return false; 4077 } 4078 4079 pull = ndr_pull_init_blob(&blob, r, NULL); 4080 if (pull == NULL) { 4081 talloc_free(r); 4082 return false; 4083 } 4084 4085 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4086 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4087 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4088 talloc_free(r); 4089 return false; 4090 } 4091 4092 if (DEBUGLEVEL >= 10) { 4093 NDR_PRINT_IN_DEBUG(samr_QueryDisplayInfo3, r); 4094 } 4095 4096 ZERO_STRUCT(r->out); 4097 r->out.total_size = talloc_zero(r, uint32_t); 4098 if (r->out.total_size == NULL) { 4099 talloc_free(r); 4100 return false; 4101 } 4102 4103 r->out.returned_size = talloc_zero(r, uint32_t); 4104 if (r->out.returned_size == NULL) { 4105 talloc_free(r); 4106 return false; 4107 } 4108 4109 r->out.info = talloc_zero(r, union samr_DispInfo); 4110 if (r->out.info == NULL) { 4111 talloc_free(r); 4112 return false; 4113 } 4114 4115 r->out.result = _samr_QueryDisplayInfo3(p, r); 4116 4117 if (p->rng_fault_state) { 4118 talloc_free(r); 4119 /* Return true here, srv_pipe_hnd.c will take care */ 4120 return true; 4121 } 4122 4123 if (DEBUGLEVEL >= 10) { 4124 NDR_PRINT_OUT_DEBUG(samr_QueryDisplayInfo3, r); 4125 } 4126 4127 push = ndr_push_init_ctx(r, NULL); 4128 if (push == NULL) { 4129 talloc_free(r); 4130 return false; 4131 } 4132 4133 ndr_err = call->ndr_push(push, NDR_OUT, r); 4134 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4135 talloc_free(r); 4136 return false; 4137 } 4138 4139 blob = ndr_push_blob(push); 4140 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4141 talloc_free(r); 4142 return false; 4143 } 4144 4145 talloc_free(r); 4146 4147 return true; 4148} 4149 4150static bool api_samr_AddMultipleMembersToAlias(pipes_struct *p) 4151{ 4152 const struct ndr_interface_call *call; 4153 struct ndr_pull *pull; 4154 struct ndr_push *push; 4155 enum ndr_err_code ndr_err; 4156 DATA_BLOB blob; 4157 struct samr_AddMultipleMembersToAlias *r; 4158 4159 call = &ndr_table_samr.calls[NDR_SAMR_ADDMULTIPLEMEMBERSTOALIAS]; 4160 4161 r = talloc(talloc_tos(), struct samr_AddMultipleMembersToAlias); 4162 if (r == NULL) { 4163 return false; 4164 } 4165 4166 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4167 talloc_free(r); 4168 return false; 4169 } 4170 4171 pull = ndr_pull_init_blob(&blob, r, NULL); 4172 if (pull == NULL) { 4173 talloc_free(r); 4174 return false; 4175 } 4176 4177 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4178 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4179 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4180 talloc_free(r); 4181 return false; 4182 } 4183 4184 if (DEBUGLEVEL >= 10) { 4185 NDR_PRINT_IN_DEBUG(samr_AddMultipleMembersToAlias, r); 4186 } 4187 4188 r->out.result = _samr_AddMultipleMembersToAlias(p, r); 4189 4190 if (p->rng_fault_state) { 4191 talloc_free(r); 4192 /* Return true here, srv_pipe_hnd.c will take care */ 4193 return true; 4194 } 4195 4196 if (DEBUGLEVEL >= 10) { 4197 NDR_PRINT_OUT_DEBUG(samr_AddMultipleMembersToAlias, r); 4198 } 4199 4200 push = ndr_push_init_ctx(r, NULL); 4201 if (push == NULL) { 4202 talloc_free(r); 4203 return false; 4204 } 4205 4206 ndr_err = call->ndr_push(push, NDR_OUT, r); 4207 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4208 talloc_free(r); 4209 return false; 4210 } 4211 4212 blob = ndr_push_blob(push); 4213 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4214 talloc_free(r); 4215 return false; 4216 } 4217 4218 talloc_free(r); 4219 4220 return true; 4221} 4222 4223static bool api_samr_RemoveMultipleMembersFromAlias(pipes_struct *p) 4224{ 4225 const struct ndr_interface_call *call; 4226 struct ndr_pull *pull; 4227 struct ndr_push *push; 4228 enum ndr_err_code ndr_err; 4229 DATA_BLOB blob; 4230 struct samr_RemoveMultipleMembersFromAlias *r; 4231 4232 call = &ndr_table_samr.calls[NDR_SAMR_REMOVEMULTIPLEMEMBERSFROMALIAS]; 4233 4234 r = talloc(talloc_tos(), struct samr_RemoveMultipleMembersFromAlias); 4235 if (r == NULL) { 4236 return false; 4237 } 4238 4239 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4240 talloc_free(r); 4241 return false; 4242 } 4243 4244 pull = ndr_pull_init_blob(&blob, r, NULL); 4245 if (pull == NULL) { 4246 talloc_free(r); 4247 return false; 4248 } 4249 4250 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4251 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4252 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4253 talloc_free(r); 4254 return false; 4255 } 4256 4257 if (DEBUGLEVEL >= 10) { 4258 NDR_PRINT_IN_DEBUG(samr_RemoveMultipleMembersFromAlias, r); 4259 } 4260 4261 r->out.result = _samr_RemoveMultipleMembersFromAlias(p, r); 4262 4263 if (p->rng_fault_state) { 4264 talloc_free(r); 4265 /* Return true here, srv_pipe_hnd.c will take care */ 4266 return true; 4267 } 4268 4269 if (DEBUGLEVEL >= 10) { 4270 NDR_PRINT_OUT_DEBUG(samr_RemoveMultipleMembersFromAlias, r); 4271 } 4272 4273 push = ndr_push_init_ctx(r, NULL); 4274 if (push == NULL) { 4275 talloc_free(r); 4276 return false; 4277 } 4278 4279 ndr_err = call->ndr_push(push, NDR_OUT, r); 4280 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4281 talloc_free(r); 4282 return false; 4283 } 4284 4285 blob = ndr_push_blob(push); 4286 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4287 talloc_free(r); 4288 return false; 4289 } 4290 4291 talloc_free(r); 4292 4293 return true; 4294} 4295 4296static bool api_samr_OemChangePasswordUser2(pipes_struct *p) 4297{ 4298 const struct ndr_interface_call *call; 4299 struct ndr_pull *pull; 4300 struct ndr_push *push; 4301 enum ndr_err_code ndr_err; 4302 DATA_BLOB blob; 4303 struct samr_OemChangePasswordUser2 *r; 4304 4305 call = &ndr_table_samr.calls[NDR_SAMR_OEMCHANGEPASSWORDUSER2]; 4306 4307 r = talloc(talloc_tos(), struct samr_OemChangePasswordUser2); 4308 if (r == NULL) { 4309 return false; 4310 } 4311 4312 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4313 talloc_free(r); 4314 return false; 4315 } 4316 4317 pull = ndr_pull_init_blob(&blob, r, NULL); 4318 if (pull == NULL) { 4319 talloc_free(r); 4320 return false; 4321 } 4322 4323 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4324 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4325 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4326 talloc_free(r); 4327 return false; 4328 } 4329 4330 if (DEBUGLEVEL >= 10) { 4331 NDR_PRINT_IN_DEBUG(samr_OemChangePasswordUser2, r); 4332 } 4333 4334 r->out.result = _samr_OemChangePasswordUser2(p, r); 4335 4336 if (p->rng_fault_state) { 4337 talloc_free(r); 4338 /* Return true here, srv_pipe_hnd.c will take care */ 4339 return true; 4340 } 4341 4342 if (DEBUGLEVEL >= 10) { 4343 NDR_PRINT_OUT_DEBUG(samr_OemChangePasswordUser2, r); 4344 } 4345 4346 push = ndr_push_init_ctx(r, NULL); 4347 if (push == NULL) { 4348 talloc_free(r); 4349 return false; 4350 } 4351 4352 ndr_err = call->ndr_push(push, NDR_OUT, r); 4353 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4354 talloc_free(r); 4355 return false; 4356 } 4357 4358 blob = ndr_push_blob(push); 4359 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4360 talloc_free(r); 4361 return false; 4362 } 4363 4364 talloc_free(r); 4365 4366 return true; 4367} 4368 4369static bool api_samr_ChangePasswordUser2(pipes_struct *p) 4370{ 4371 const struct ndr_interface_call *call; 4372 struct ndr_pull *pull; 4373 struct ndr_push *push; 4374 enum ndr_err_code ndr_err; 4375 DATA_BLOB blob; 4376 struct samr_ChangePasswordUser2 *r; 4377 4378 call = &ndr_table_samr.calls[NDR_SAMR_CHANGEPASSWORDUSER2]; 4379 4380 r = talloc(talloc_tos(), struct samr_ChangePasswordUser2); 4381 if (r == NULL) { 4382 return false; 4383 } 4384 4385 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4386 talloc_free(r); 4387 return false; 4388 } 4389 4390 pull = ndr_pull_init_blob(&blob, r, NULL); 4391 if (pull == NULL) { 4392 talloc_free(r); 4393 return false; 4394 } 4395 4396 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4397 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4398 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4399 talloc_free(r); 4400 return false; 4401 } 4402 4403 if (DEBUGLEVEL >= 10) { 4404 NDR_PRINT_IN_DEBUG(samr_ChangePasswordUser2, r); 4405 } 4406 4407 r->out.result = _samr_ChangePasswordUser2(p, r); 4408 4409 if (p->rng_fault_state) { 4410 talloc_free(r); 4411 /* Return true here, srv_pipe_hnd.c will take care */ 4412 return true; 4413 } 4414 4415 if (DEBUGLEVEL >= 10) { 4416 NDR_PRINT_OUT_DEBUG(samr_ChangePasswordUser2, r); 4417 } 4418 4419 push = ndr_push_init_ctx(r, NULL); 4420 if (push == NULL) { 4421 talloc_free(r); 4422 return false; 4423 } 4424 4425 ndr_err = call->ndr_push(push, NDR_OUT, r); 4426 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4427 talloc_free(r); 4428 return false; 4429 } 4430 4431 blob = ndr_push_blob(push); 4432 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4433 talloc_free(r); 4434 return false; 4435 } 4436 4437 talloc_free(r); 4438 4439 return true; 4440} 4441 4442static bool api_samr_GetDomPwInfo(pipes_struct *p) 4443{ 4444 const struct ndr_interface_call *call; 4445 struct ndr_pull *pull; 4446 struct ndr_push *push; 4447 enum ndr_err_code ndr_err; 4448 DATA_BLOB blob; 4449 struct samr_GetDomPwInfo *r; 4450 4451 call = &ndr_table_samr.calls[NDR_SAMR_GETDOMPWINFO]; 4452 4453 r = talloc(talloc_tos(), struct samr_GetDomPwInfo); 4454 if (r == NULL) { 4455 return false; 4456 } 4457 4458 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4459 talloc_free(r); 4460 return false; 4461 } 4462 4463 pull = ndr_pull_init_blob(&blob, r, NULL); 4464 if (pull == NULL) { 4465 talloc_free(r); 4466 return false; 4467 } 4468 4469 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4470 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4471 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4472 talloc_free(r); 4473 return false; 4474 } 4475 4476 if (DEBUGLEVEL >= 10) { 4477 NDR_PRINT_IN_DEBUG(samr_GetDomPwInfo, r); 4478 } 4479 4480 ZERO_STRUCT(r->out); 4481 r->out.info = talloc_zero(r, struct samr_PwInfo); 4482 if (r->out.info == NULL) { 4483 talloc_free(r); 4484 return false; 4485 } 4486 4487 r->out.result = _samr_GetDomPwInfo(p, r); 4488 4489 if (p->rng_fault_state) { 4490 talloc_free(r); 4491 /* Return true here, srv_pipe_hnd.c will take care */ 4492 return true; 4493 } 4494 4495 if (DEBUGLEVEL >= 10) { 4496 NDR_PRINT_OUT_DEBUG(samr_GetDomPwInfo, r); 4497 } 4498 4499 push = ndr_push_init_ctx(r, NULL); 4500 if (push == NULL) { 4501 talloc_free(r); 4502 return false; 4503 } 4504 4505 ndr_err = call->ndr_push(push, NDR_OUT, r); 4506 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4507 talloc_free(r); 4508 return false; 4509 } 4510 4511 blob = ndr_push_blob(push); 4512 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4513 talloc_free(r); 4514 return false; 4515 } 4516 4517 talloc_free(r); 4518 4519 return true; 4520} 4521 4522static bool api_samr_Connect2(pipes_struct *p) 4523{ 4524 const struct ndr_interface_call *call; 4525 struct ndr_pull *pull; 4526 struct ndr_push *push; 4527 enum ndr_err_code ndr_err; 4528 DATA_BLOB blob; 4529 struct samr_Connect2 *r; 4530 4531 call = &ndr_table_samr.calls[NDR_SAMR_CONNECT2]; 4532 4533 r = talloc(talloc_tos(), struct samr_Connect2); 4534 if (r == NULL) { 4535 return false; 4536 } 4537 4538 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4539 talloc_free(r); 4540 return false; 4541 } 4542 4543 pull = ndr_pull_init_blob(&blob, r, NULL); 4544 if (pull == NULL) { 4545 talloc_free(r); 4546 return false; 4547 } 4548 4549 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4550 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4551 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4552 talloc_free(r); 4553 return false; 4554 } 4555 4556 if (DEBUGLEVEL >= 10) { 4557 NDR_PRINT_IN_DEBUG(samr_Connect2, r); 4558 } 4559 4560 ZERO_STRUCT(r->out); 4561 r->out.connect_handle = talloc_zero(r, struct policy_handle); 4562 if (r->out.connect_handle == NULL) { 4563 talloc_free(r); 4564 return false; 4565 } 4566 4567 r->out.result = _samr_Connect2(p, r); 4568 4569 if (p->rng_fault_state) { 4570 talloc_free(r); 4571 /* Return true here, srv_pipe_hnd.c will take care */ 4572 return true; 4573 } 4574 4575 if (DEBUGLEVEL >= 10) { 4576 NDR_PRINT_OUT_DEBUG(samr_Connect2, r); 4577 } 4578 4579 push = ndr_push_init_ctx(r, NULL); 4580 if (push == NULL) { 4581 talloc_free(r); 4582 return false; 4583 } 4584 4585 ndr_err = call->ndr_push(push, NDR_OUT, r); 4586 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4587 talloc_free(r); 4588 return false; 4589 } 4590 4591 blob = ndr_push_blob(push); 4592 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4593 talloc_free(r); 4594 return false; 4595 } 4596 4597 talloc_free(r); 4598 4599 return true; 4600} 4601 4602static bool api_samr_SetUserInfo2(pipes_struct *p) 4603{ 4604 const struct ndr_interface_call *call; 4605 struct ndr_pull *pull; 4606 struct ndr_push *push; 4607 enum ndr_err_code ndr_err; 4608 DATA_BLOB blob; 4609 struct samr_SetUserInfo2 *r; 4610 4611 call = &ndr_table_samr.calls[NDR_SAMR_SETUSERINFO2]; 4612 4613 r = talloc(talloc_tos(), struct samr_SetUserInfo2); 4614 if (r == NULL) { 4615 return false; 4616 } 4617 4618 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4619 talloc_free(r); 4620 return false; 4621 } 4622 4623 pull = ndr_pull_init_blob(&blob, r, NULL); 4624 if (pull == NULL) { 4625 talloc_free(r); 4626 return false; 4627 } 4628 4629 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4630 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4631 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4632 talloc_free(r); 4633 return false; 4634 } 4635 4636 if (DEBUGLEVEL >= 10) { 4637 NDR_PRINT_IN_DEBUG(samr_SetUserInfo2, r); 4638 } 4639 4640 r->out.result = _samr_SetUserInfo2(p, r); 4641 4642 if (p->rng_fault_state) { 4643 talloc_free(r); 4644 /* Return true here, srv_pipe_hnd.c will take care */ 4645 return true; 4646 } 4647 4648 if (DEBUGLEVEL >= 10) { 4649 NDR_PRINT_OUT_DEBUG(samr_SetUserInfo2, r); 4650 } 4651 4652 push = ndr_push_init_ctx(r, NULL); 4653 if (push == NULL) { 4654 talloc_free(r); 4655 return false; 4656 } 4657 4658 ndr_err = call->ndr_push(push, NDR_OUT, r); 4659 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4660 talloc_free(r); 4661 return false; 4662 } 4663 4664 blob = ndr_push_blob(push); 4665 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4666 talloc_free(r); 4667 return false; 4668 } 4669 4670 talloc_free(r); 4671 4672 return true; 4673} 4674 4675static bool api_samr_SetBootKeyInformation(pipes_struct *p) 4676{ 4677 const struct ndr_interface_call *call; 4678 struct ndr_pull *pull; 4679 struct ndr_push *push; 4680 enum ndr_err_code ndr_err; 4681 DATA_BLOB blob; 4682 struct samr_SetBootKeyInformation *r; 4683 4684 call = &ndr_table_samr.calls[NDR_SAMR_SETBOOTKEYINFORMATION]; 4685 4686 r = talloc(talloc_tos(), struct samr_SetBootKeyInformation); 4687 if (r == NULL) { 4688 return false; 4689 } 4690 4691 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4692 talloc_free(r); 4693 return false; 4694 } 4695 4696 pull = ndr_pull_init_blob(&blob, r, NULL); 4697 if (pull == NULL) { 4698 talloc_free(r); 4699 return false; 4700 } 4701 4702 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4703 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4704 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4705 talloc_free(r); 4706 return false; 4707 } 4708 4709 if (DEBUGLEVEL >= 10) { 4710 NDR_PRINT_IN_DEBUG(samr_SetBootKeyInformation, r); 4711 } 4712 4713 r->out.result = _samr_SetBootKeyInformation(p, r); 4714 4715 if (p->rng_fault_state) { 4716 talloc_free(r); 4717 /* Return true here, srv_pipe_hnd.c will take care */ 4718 return true; 4719 } 4720 4721 if (DEBUGLEVEL >= 10) { 4722 NDR_PRINT_OUT_DEBUG(samr_SetBootKeyInformation, r); 4723 } 4724 4725 push = ndr_push_init_ctx(r, NULL); 4726 if (push == NULL) { 4727 talloc_free(r); 4728 return false; 4729 } 4730 4731 ndr_err = call->ndr_push(push, NDR_OUT, r); 4732 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4733 talloc_free(r); 4734 return false; 4735 } 4736 4737 blob = ndr_push_blob(push); 4738 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4739 talloc_free(r); 4740 return false; 4741 } 4742 4743 talloc_free(r); 4744 4745 return true; 4746} 4747 4748static bool api_samr_GetBootKeyInformation(pipes_struct *p) 4749{ 4750 const struct ndr_interface_call *call; 4751 struct ndr_pull *pull; 4752 struct ndr_push *push; 4753 enum ndr_err_code ndr_err; 4754 DATA_BLOB blob; 4755 struct samr_GetBootKeyInformation *r; 4756 4757 call = &ndr_table_samr.calls[NDR_SAMR_GETBOOTKEYINFORMATION]; 4758 4759 r = talloc(talloc_tos(), struct samr_GetBootKeyInformation); 4760 if (r == NULL) { 4761 return false; 4762 } 4763 4764 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4765 talloc_free(r); 4766 return false; 4767 } 4768 4769 pull = ndr_pull_init_blob(&blob, r, NULL); 4770 if (pull == NULL) { 4771 talloc_free(r); 4772 return false; 4773 } 4774 4775 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4776 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4777 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4778 talloc_free(r); 4779 return false; 4780 } 4781 4782 if (DEBUGLEVEL >= 10) { 4783 NDR_PRINT_IN_DEBUG(samr_GetBootKeyInformation, r); 4784 } 4785 4786 ZERO_STRUCT(r->out); 4787 r->out.unknown = talloc_zero(r, uint32_t); 4788 if (r->out.unknown == NULL) { 4789 talloc_free(r); 4790 return false; 4791 } 4792 4793 r->out.result = _samr_GetBootKeyInformation(p, r); 4794 4795 if (p->rng_fault_state) { 4796 talloc_free(r); 4797 /* Return true here, srv_pipe_hnd.c will take care */ 4798 return true; 4799 } 4800 4801 if (DEBUGLEVEL >= 10) { 4802 NDR_PRINT_OUT_DEBUG(samr_GetBootKeyInformation, r); 4803 } 4804 4805 push = ndr_push_init_ctx(r, NULL); 4806 if (push == NULL) { 4807 talloc_free(r); 4808 return false; 4809 } 4810 4811 ndr_err = call->ndr_push(push, NDR_OUT, r); 4812 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4813 talloc_free(r); 4814 return false; 4815 } 4816 4817 blob = ndr_push_blob(push); 4818 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4819 talloc_free(r); 4820 return false; 4821 } 4822 4823 talloc_free(r); 4824 4825 return true; 4826} 4827 4828static bool api_samr_Connect3(pipes_struct *p) 4829{ 4830 const struct ndr_interface_call *call; 4831 struct ndr_pull *pull; 4832 struct ndr_push *push; 4833 enum ndr_err_code ndr_err; 4834 DATA_BLOB blob; 4835 struct samr_Connect3 *r; 4836 4837 call = &ndr_table_samr.calls[NDR_SAMR_CONNECT3]; 4838 4839 r = talloc(talloc_tos(), struct samr_Connect3); 4840 if (r == NULL) { 4841 return false; 4842 } 4843 4844 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4845 talloc_free(r); 4846 return false; 4847 } 4848 4849 pull = ndr_pull_init_blob(&blob, r, NULL); 4850 if (pull == NULL) { 4851 talloc_free(r); 4852 return false; 4853 } 4854 4855 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4856 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4857 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4858 talloc_free(r); 4859 return false; 4860 } 4861 4862 if (DEBUGLEVEL >= 10) { 4863 NDR_PRINT_IN_DEBUG(samr_Connect3, r); 4864 } 4865 4866 ZERO_STRUCT(r->out); 4867 r->out.connect_handle = talloc_zero(r, struct policy_handle); 4868 if (r->out.connect_handle == NULL) { 4869 talloc_free(r); 4870 return false; 4871 } 4872 4873 r->out.result = _samr_Connect3(p, r); 4874 4875 if (p->rng_fault_state) { 4876 talloc_free(r); 4877 /* Return true here, srv_pipe_hnd.c will take care */ 4878 return true; 4879 } 4880 4881 if (DEBUGLEVEL >= 10) { 4882 NDR_PRINT_OUT_DEBUG(samr_Connect3, r); 4883 } 4884 4885 push = ndr_push_init_ctx(r, NULL); 4886 if (push == NULL) { 4887 talloc_free(r); 4888 return false; 4889 } 4890 4891 ndr_err = call->ndr_push(push, NDR_OUT, r); 4892 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4893 talloc_free(r); 4894 return false; 4895 } 4896 4897 blob = ndr_push_blob(push); 4898 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4899 talloc_free(r); 4900 return false; 4901 } 4902 4903 talloc_free(r); 4904 4905 return true; 4906} 4907 4908static bool api_samr_Connect4(pipes_struct *p) 4909{ 4910 const struct ndr_interface_call *call; 4911 struct ndr_pull *pull; 4912 struct ndr_push *push; 4913 enum ndr_err_code ndr_err; 4914 DATA_BLOB blob; 4915 struct samr_Connect4 *r; 4916 4917 call = &ndr_table_samr.calls[NDR_SAMR_CONNECT4]; 4918 4919 r = talloc(talloc_tos(), struct samr_Connect4); 4920 if (r == NULL) { 4921 return false; 4922 } 4923 4924 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4925 talloc_free(r); 4926 return false; 4927 } 4928 4929 pull = ndr_pull_init_blob(&blob, r, NULL); 4930 if (pull == NULL) { 4931 talloc_free(r); 4932 return false; 4933 } 4934 4935 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4936 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4937 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4938 talloc_free(r); 4939 return false; 4940 } 4941 4942 if (DEBUGLEVEL >= 10) { 4943 NDR_PRINT_IN_DEBUG(samr_Connect4, r); 4944 } 4945 4946 ZERO_STRUCT(r->out); 4947 r->out.connect_handle = talloc_zero(r, struct policy_handle); 4948 if (r->out.connect_handle == NULL) { 4949 talloc_free(r); 4950 return false; 4951 } 4952 4953 r->out.result = _samr_Connect4(p, r); 4954 4955 if (p->rng_fault_state) { 4956 talloc_free(r); 4957 /* Return true here, srv_pipe_hnd.c will take care */ 4958 return true; 4959 } 4960 4961 if (DEBUGLEVEL >= 10) { 4962 NDR_PRINT_OUT_DEBUG(samr_Connect4, r); 4963 } 4964 4965 push = ndr_push_init_ctx(r, NULL); 4966 if (push == NULL) { 4967 talloc_free(r); 4968 return false; 4969 } 4970 4971 ndr_err = call->ndr_push(push, NDR_OUT, r); 4972 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4973 talloc_free(r); 4974 return false; 4975 } 4976 4977 blob = ndr_push_blob(push); 4978 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4979 talloc_free(r); 4980 return false; 4981 } 4982 4983 talloc_free(r); 4984 4985 return true; 4986} 4987 4988static bool api_samr_ChangePasswordUser3(pipes_struct *p) 4989{ 4990 const struct ndr_interface_call *call; 4991 struct ndr_pull *pull; 4992 struct ndr_push *push; 4993 enum ndr_err_code ndr_err; 4994 DATA_BLOB blob; 4995 struct samr_ChangePasswordUser3 *r; 4996 4997 call = &ndr_table_samr.calls[NDR_SAMR_CHANGEPASSWORDUSER3]; 4998 4999 r = talloc(talloc_tos(), struct samr_ChangePasswordUser3); 5000 if (r == NULL) { 5001 return false; 5002 } 5003 5004 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 5005 talloc_free(r); 5006 return false; 5007 } 5008 5009 pull = ndr_pull_init_blob(&blob, r, NULL); 5010 if (pull == NULL) { 5011 talloc_free(r); 5012 return false; 5013 } 5014 5015 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 5016 ndr_err = call->ndr_pull(pull, NDR_IN, r); 5017 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 5018 talloc_free(r); 5019 return false; 5020 } 5021 5022 if (DEBUGLEVEL >= 10) { 5023 NDR_PRINT_IN_DEBUG(samr_ChangePasswordUser3, r); 5024 } 5025 5026 ZERO_STRUCT(r->out); 5027 r->out.dominfo = talloc_zero(r, struct samr_DomInfo1 *); 5028 if (r->out.dominfo == NULL) { 5029 talloc_free(r); 5030 return false; 5031 } 5032 5033 r->out.reject = talloc_zero(r, struct samr_ChangeReject *); 5034 if (r->out.reject == NULL) { 5035 talloc_free(r); 5036 return false; 5037 } 5038 5039 r->out.result = _samr_ChangePasswordUser3(p, r); 5040 5041 if (p->rng_fault_state) { 5042 talloc_free(r); 5043 /* Return true here, srv_pipe_hnd.c will take care */ 5044 return true; 5045 } 5046 5047 if (DEBUGLEVEL >= 10) { 5048 NDR_PRINT_OUT_DEBUG(samr_ChangePasswordUser3, r); 5049 } 5050 5051 push = ndr_push_init_ctx(r, NULL); 5052 if (push == NULL) { 5053 talloc_free(r); 5054 return false; 5055 } 5056 5057 ndr_err = call->ndr_push(push, NDR_OUT, r); 5058 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 5059 talloc_free(r); 5060 return false; 5061 } 5062 5063 blob = ndr_push_blob(push); 5064 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 5065 talloc_free(r); 5066 return false; 5067 } 5068 5069 talloc_free(r); 5070 5071 return true; 5072} 5073 5074static bool api_samr_Connect5(pipes_struct *p) 5075{ 5076 const struct ndr_interface_call *call; 5077 struct ndr_pull *pull; 5078 struct ndr_push *push; 5079 enum ndr_err_code ndr_err; 5080 DATA_BLOB blob; 5081 struct samr_Connect5 *r; 5082 5083 call = &ndr_table_samr.calls[NDR_SAMR_CONNECT5]; 5084 5085 r = talloc(talloc_tos(), struct samr_Connect5); 5086 if (r == NULL) { 5087 return false; 5088 } 5089 5090 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 5091 talloc_free(r); 5092 return false; 5093 } 5094 5095 pull = ndr_pull_init_blob(&blob, r, NULL); 5096 if (pull == NULL) { 5097 talloc_free(r); 5098 return false; 5099 } 5100 5101 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 5102 ndr_err = call->ndr_pull(pull, NDR_IN, r); 5103 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 5104 talloc_free(r); 5105 return false; 5106 } 5107 5108 if (DEBUGLEVEL >= 10) { 5109 NDR_PRINT_IN_DEBUG(samr_Connect5, r); 5110 } 5111 5112 ZERO_STRUCT(r->out); 5113 r->out.level_out = talloc_zero(r, uint32_t); 5114 if (r->out.level_out == NULL) { 5115 talloc_free(r); 5116 return false; 5117 } 5118 5119 r->out.info_out = talloc_zero(r, union samr_ConnectInfo); 5120 if (r->out.info_out == NULL) { 5121 talloc_free(r); 5122 return false; 5123 } 5124 5125 r->out.connect_handle = talloc_zero(r, struct policy_handle); 5126 if (r->out.connect_handle == NULL) { 5127 talloc_free(r); 5128 return false; 5129 } 5130 5131 r->out.result = _samr_Connect5(p, r); 5132 5133 if (p->rng_fault_state) { 5134 talloc_free(r); 5135 /* Return true here, srv_pipe_hnd.c will take care */ 5136 return true; 5137 } 5138 5139 if (DEBUGLEVEL >= 10) { 5140 NDR_PRINT_OUT_DEBUG(samr_Connect5, r); 5141 } 5142 5143 push = ndr_push_init_ctx(r, NULL); 5144 if (push == NULL) { 5145 talloc_free(r); 5146 return false; 5147 } 5148 5149 ndr_err = call->ndr_push(push, NDR_OUT, r); 5150 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 5151 talloc_free(r); 5152 return false; 5153 } 5154 5155 blob = ndr_push_blob(push); 5156 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 5157 talloc_free(r); 5158 return false; 5159 } 5160 5161 talloc_free(r); 5162 5163 return true; 5164} 5165 5166static bool api_samr_RidToSid(pipes_struct *p) 5167{ 5168 const struct ndr_interface_call *call; 5169 struct ndr_pull *pull; 5170 struct ndr_push *push; 5171 enum ndr_err_code ndr_err; 5172 DATA_BLOB blob; 5173 struct samr_RidToSid *r; 5174 5175 call = &ndr_table_samr.calls[NDR_SAMR_RIDTOSID]; 5176 5177 r = talloc(talloc_tos(), struct samr_RidToSid); 5178 if (r == NULL) { 5179 return false; 5180 } 5181 5182 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 5183 talloc_free(r); 5184 return false; 5185 } 5186 5187 pull = ndr_pull_init_blob(&blob, r, NULL); 5188 if (pull == NULL) { 5189 talloc_free(r); 5190 return false; 5191 } 5192 5193 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 5194 ndr_err = call->ndr_pull(pull, NDR_IN, r); 5195 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 5196 talloc_free(r); 5197 return false; 5198 } 5199 5200 if (DEBUGLEVEL >= 10) { 5201 NDR_PRINT_IN_DEBUG(samr_RidToSid, r); 5202 } 5203 5204 ZERO_STRUCT(r->out); 5205 r->out.sid = talloc_zero(r, struct dom_sid2 *); 5206 if (r->out.sid == NULL) { 5207 talloc_free(r); 5208 return false; 5209 } 5210 5211 r->out.result = _samr_RidToSid(p, r); 5212 5213 if (p->rng_fault_state) { 5214 talloc_free(r); 5215 /* Return true here, srv_pipe_hnd.c will take care */ 5216 return true; 5217 } 5218 5219 if (DEBUGLEVEL >= 10) { 5220 NDR_PRINT_OUT_DEBUG(samr_RidToSid, r); 5221 } 5222 5223 push = ndr_push_init_ctx(r, NULL); 5224 if (push == NULL) { 5225 talloc_free(r); 5226 return false; 5227 } 5228 5229 ndr_err = call->ndr_push(push, NDR_OUT, r); 5230 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 5231 talloc_free(r); 5232 return false; 5233 } 5234 5235 blob = ndr_push_blob(push); 5236 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 5237 talloc_free(r); 5238 return false; 5239 } 5240 5241 talloc_free(r); 5242 5243 return true; 5244} 5245 5246static bool api_samr_SetDsrmPassword(pipes_struct *p) 5247{ 5248 const struct ndr_interface_call *call; 5249 struct ndr_pull *pull; 5250 struct ndr_push *push; 5251 enum ndr_err_code ndr_err; 5252 DATA_BLOB blob; 5253 struct samr_SetDsrmPassword *r; 5254 5255 call = &ndr_table_samr.calls[NDR_SAMR_SETDSRMPASSWORD]; 5256 5257 r = talloc(talloc_tos(), struct samr_SetDsrmPassword); 5258 if (r == NULL) { 5259 return false; 5260 } 5261 5262 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 5263 talloc_free(r); 5264 return false; 5265 } 5266 5267 pull = ndr_pull_init_blob(&blob, r, NULL); 5268 if (pull == NULL) { 5269 talloc_free(r); 5270 return false; 5271 } 5272 5273 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 5274 ndr_err = call->ndr_pull(pull, NDR_IN, r); 5275 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 5276 talloc_free(r); 5277 return false; 5278 } 5279 5280 if (DEBUGLEVEL >= 10) { 5281 NDR_PRINT_IN_DEBUG(samr_SetDsrmPassword, r); 5282 } 5283 5284 r->out.result = _samr_SetDsrmPassword(p, r); 5285 5286 if (p->rng_fault_state) { 5287 talloc_free(r); 5288 /* Return true here, srv_pipe_hnd.c will take care */ 5289 return true; 5290 } 5291 5292 if (DEBUGLEVEL >= 10) { 5293 NDR_PRINT_OUT_DEBUG(samr_SetDsrmPassword, r); 5294 } 5295 5296 push = ndr_push_init_ctx(r, NULL); 5297 if (push == NULL) { 5298 talloc_free(r); 5299 return false; 5300 } 5301 5302 ndr_err = call->ndr_push(push, NDR_OUT, r); 5303 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 5304 talloc_free(r); 5305 return false; 5306 } 5307 5308 blob = ndr_push_blob(push); 5309 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 5310 talloc_free(r); 5311 return false; 5312 } 5313 5314 talloc_free(r); 5315 5316 return true; 5317} 5318 5319static bool api_samr_ValidatePassword(pipes_struct *p) 5320{ 5321 const struct ndr_interface_call *call; 5322 struct ndr_pull *pull; 5323 struct ndr_push *push; 5324 enum ndr_err_code ndr_err; 5325 DATA_BLOB blob; 5326 struct samr_ValidatePassword *r; 5327 5328 call = &ndr_table_samr.calls[NDR_SAMR_VALIDATEPASSWORD]; 5329 5330 r = talloc(talloc_tos(), struct samr_ValidatePassword); 5331 if (r == NULL) { 5332 return false; 5333 } 5334 5335 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 5336 talloc_free(r); 5337 return false; 5338 } 5339 5340 pull = ndr_pull_init_blob(&blob, r, NULL); 5341 if (pull == NULL) { 5342 talloc_free(r); 5343 return false; 5344 } 5345 5346 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 5347 ndr_err = call->ndr_pull(pull, NDR_IN, r); 5348 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 5349 talloc_free(r); 5350 return false; 5351 } 5352 5353 if (DEBUGLEVEL >= 10) { 5354 NDR_PRINT_IN_DEBUG(samr_ValidatePassword, r); 5355 } 5356 5357 ZERO_STRUCT(r->out); 5358 r->out.rep = talloc_zero(r, union samr_ValidatePasswordRep *); 5359 if (r->out.rep == NULL) { 5360 talloc_free(r); 5361 return false; 5362 } 5363 5364 r->out.result = _samr_ValidatePassword(p, r); 5365 5366 if (p->rng_fault_state) { 5367 talloc_free(r); 5368 /* Return true here, srv_pipe_hnd.c will take care */ 5369 return true; 5370 } 5371 5372 if (DEBUGLEVEL >= 10) { 5373 NDR_PRINT_OUT_DEBUG(samr_ValidatePassword, r); 5374 } 5375 5376 push = ndr_push_init_ctx(r, NULL); 5377 if (push == NULL) { 5378 talloc_free(r); 5379 return false; 5380 } 5381 5382 ndr_err = call->ndr_push(push, NDR_OUT, r); 5383 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 5384 talloc_free(r); 5385 return false; 5386 } 5387 5388 blob = ndr_push_blob(push); 5389 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 5390 talloc_free(r); 5391 return false; 5392 } 5393 5394 talloc_free(r); 5395 5396 return true; 5397} 5398 5399 5400/* Tables */ 5401static struct api_struct api_samr_cmds[] = 5402{ 5403 {"SAMR_CONNECT", NDR_SAMR_CONNECT, api_samr_Connect}, 5404 {"SAMR_CLOSE", NDR_SAMR_CLOSE, api_samr_Close}, 5405 {"SAMR_SETSECURITY", NDR_SAMR_SETSECURITY, api_samr_SetSecurity}, 5406 {"SAMR_QUERYSECURITY", NDR_SAMR_QUERYSECURITY, api_samr_QuerySecurity}, 5407 {"SAMR_SHUTDOWN", NDR_SAMR_SHUTDOWN, api_samr_Shutdown}, 5408 {"SAMR_LOOKUPDOMAIN", NDR_SAMR_LOOKUPDOMAIN, api_samr_LookupDomain}, 5409 {"SAMR_ENUMDOMAINS", NDR_SAMR_ENUMDOMAINS, api_samr_EnumDomains}, 5410 {"SAMR_OPENDOMAIN", NDR_SAMR_OPENDOMAIN, api_samr_OpenDomain}, 5411 {"SAMR_QUERYDOMAININFO", NDR_SAMR_QUERYDOMAININFO, api_samr_QueryDomainInfo}, 5412 {"SAMR_SETDOMAININFO", NDR_SAMR_SETDOMAININFO, api_samr_SetDomainInfo}, 5413 {"SAMR_CREATEDOMAINGROUP", NDR_SAMR_CREATEDOMAINGROUP, api_samr_CreateDomainGroup}, 5414 {"SAMR_ENUMDOMAINGROUPS", NDR_SAMR_ENUMDOMAINGROUPS, api_samr_EnumDomainGroups}, 5415 {"SAMR_CREATEUSER", NDR_SAMR_CREATEUSER, api_samr_CreateUser}, 5416 {"SAMR_ENUMDOMAINUSERS", NDR_SAMR_ENUMDOMAINUSERS, api_samr_EnumDomainUsers}, 5417 {"SAMR_CREATEDOMALIAS", NDR_SAMR_CREATEDOMALIAS, api_samr_CreateDomAlias}, 5418 {"SAMR_ENUMDOMAINALIASES", NDR_SAMR_ENUMDOMAINALIASES, api_samr_EnumDomainAliases}, 5419 {"SAMR_GETALIASMEMBERSHIP", NDR_SAMR_GETALIASMEMBERSHIP, api_samr_GetAliasMembership}, 5420 {"SAMR_LOOKUPNAMES", NDR_SAMR_LOOKUPNAMES, api_samr_LookupNames}, 5421 {"SAMR_LOOKUPRIDS", NDR_SAMR_LOOKUPRIDS, api_samr_LookupRids}, 5422 {"SAMR_OPENGROUP", NDR_SAMR_OPENGROUP, api_samr_OpenGroup}, 5423 {"SAMR_QUERYGROUPINFO", NDR_SAMR_QUERYGROUPINFO, api_samr_QueryGroupInfo}, 5424 {"SAMR_SETGROUPINFO", NDR_SAMR_SETGROUPINFO, api_samr_SetGroupInfo}, 5425 {"SAMR_ADDGROUPMEMBER", NDR_SAMR_ADDGROUPMEMBER, api_samr_AddGroupMember}, 5426 {"SAMR_DELETEDOMAINGROUP", NDR_SAMR_DELETEDOMAINGROUP, api_samr_DeleteDomainGroup}, 5427 {"SAMR_DELETEGROUPMEMBER", NDR_SAMR_DELETEGROUPMEMBER, api_samr_DeleteGroupMember}, 5428 {"SAMR_QUERYGROUPMEMBER", NDR_SAMR_QUERYGROUPMEMBER, api_samr_QueryGroupMember}, 5429 {"SAMR_SETMEMBERATTRIBUTESOFGROUP", NDR_SAMR_SETMEMBERATTRIBUTESOFGROUP, api_samr_SetMemberAttributesOfGroup}, 5430 {"SAMR_OPENALIAS", NDR_SAMR_OPENALIAS, api_samr_OpenAlias}, 5431 {"SAMR_QUERYALIASINFO", NDR_SAMR_QUERYALIASINFO, api_samr_QueryAliasInfo}, 5432 {"SAMR_SETALIASINFO", NDR_SAMR_SETALIASINFO, api_samr_SetAliasInfo}, 5433 {"SAMR_DELETEDOMALIAS", NDR_SAMR_DELETEDOMALIAS, api_samr_DeleteDomAlias}, 5434 {"SAMR_ADDALIASMEMBER", NDR_SAMR_ADDALIASMEMBER, api_samr_AddAliasMember}, 5435 {"SAMR_DELETEALIASMEMBER", NDR_SAMR_DELETEALIASMEMBER, api_samr_DeleteAliasMember}, 5436 {"SAMR_GETMEMBERSINALIAS", NDR_SAMR_GETMEMBERSINALIAS, api_samr_GetMembersInAlias}, 5437 {"SAMR_OPENUSER", NDR_SAMR_OPENUSER, api_samr_OpenUser}, 5438 {"SAMR_DELETEUSER", NDR_SAMR_DELETEUSER, api_samr_DeleteUser}, 5439 {"SAMR_QUERYUSERINFO", NDR_SAMR_QUERYUSERINFO, api_samr_QueryUserInfo}, 5440 {"SAMR_SETUSERINFO", NDR_SAMR_SETUSERINFO, api_samr_SetUserInfo}, 5441 {"SAMR_CHANGEPASSWORDUSER", NDR_SAMR_CHANGEPASSWORDUSER, api_samr_ChangePasswordUser}, 5442 {"SAMR_GETGROUPSFORUSER", NDR_SAMR_GETGROUPSFORUSER, api_samr_GetGroupsForUser}, 5443 {"SAMR_QUERYDISPLAYINFO", NDR_SAMR_QUERYDISPLAYINFO, api_samr_QueryDisplayInfo}, 5444 {"SAMR_GETDISPLAYENUMERATIONINDEX", NDR_SAMR_GETDISPLAYENUMERATIONINDEX, api_samr_GetDisplayEnumerationIndex}, 5445 {"SAMR_TESTPRIVATEFUNCTIONSDOMAIN", NDR_SAMR_TESTPRIVATEFUNCTIONSDOMAIN, api_samr_TestPrivateFunctionsDomain}, 5446 {"SAMR_TESTPRIVATEFUNCTIONSUSER", NDR_SAMR_TESTPRIVATEFUNCTIONSUSER, api_samr_TestPrivateFunctionsUser}, 5447 {"SAMR_GETUSERPWINFO", NDR_SAMR_GETUSERPWINFO, api_samr_GetUserPwInfo}, 5448 {"SAMR_REMOVEMEMBERFROMFOREIGNDOMAIN", NDR_SAMR_REMOVEMEMBERFROMFOREIGNDOMAIN, api_samr_RemoveMemberFromForeignDomain}, 5449 {"SAMR_QUERYDOMAININFO2", NDR_SAMR_QUERYDOMAININFO2, api_samr_QueryDomainInfo2}, 5450 {"SAMR_QUERYUSERINFO2", NDR_SAMR_QUERYUSERINFO2, api_samr_QueryUserInfo2}, 5451 {"SAMR_QUERYDISPLAYINFO2", NDR_SAMR_QUERYDISPLAYINFO2, api_samr_QueryDisplayInfo2}, 5452 {"SAMR_GETDISPLAYENUMERATIONINDEX2", NDR_SAMR_GETDISPLAYENUMERATIONINDEX2, api_samr_GetDisplayEnumerationIndex2}, 5453 {"SAMR_CREATEUSER2", NDR_SAMR_CREATEUSER2, api_samr_CreateUser2}, 5454 {"SAMR_QUERYDISPLAYINFO3", NDR_SAMR_QUERYDISPLAYINFO3, api_samr_QueryDisplayInfo3}, 5455 {"SAMR_ADDMULTIPLEMEMBERSTOALIAS", NDR_SAMR_ADDMULTIPLEMEMBERSTOALIAS, api_samr_AddMultipleMembersToAlias}, 5456 {"SAMR_REMOVEMULTIPLEMEMBERSFROMALIAS", NDR_SAMR_REMOVEMULTIPLEMEMBERSFROMALIAS, api_samr_RemoveMultipleMembersFromAlias}, 5457 {"SAMR_OEMCHANGEPASSWORDUSER2", NDR_SAMR_OEMCHANGEPASSWORDUSER2, api_samr_OemChangePasswordUser2}, 5458 {"SAMR_CHANGEPASSWORDUSER2", NDR_SAMR_CHANGEPASSWORDUSER2, api_samr_ChangePasswordUser2}, 5459 {"SAMR_GETDOMPWINFO", NDR_SAMR_GETDOMPWINFO, api_samr_GetDomPwInfo}, 5460 {"SAMR_CONNECT2", NDR_SAMR_CONNECT2, api_samr_Connect2}, 5461 {"SAMR_SETUSERINFO2", NDR_SAMR_SETUSERINFO2, api_samr_SetUserInfo2}, 5462 {"SAMR_SETBOOTKEYINFORMATION", NDR_SAMR_SETBOOTKEYINFORMATION, api_samr_SetBootKeyInformation}, 5463 {"SAMR_GETBOOTKEYINFORMATION", NDR_SAMR_GETBOOTKEYINFORMATION, api_samr_GetBootKeyInformation}, 5464 {"SAMR_CONNECT3", NDR_SAMR_CONNECT3, api_samr_Connect3}, 5465 {"SAMR_CONNECT4", NDR_SAMR_CONNECT4, api_samr_Connect4}, 5466 {"SAMR_CHANGEPASSWORDUSER3", NDR_SAMR_CHANGEPASSWORDUSER3, api_samr_ChangePasswordUser3}, 5467 {"SAMR_CONNECT5", NDR_SAMR_CONNECT5, api_samr_Connect5}, 5468 {"SAMR_RIDTOSID", NDR_SAMR_RIDTOSID, api_samr_RidToSid}, 5469 {"SAMR_SETDSRMPASSWORD", NDR_SAMR_SETDSRMPASSWORD, api_samr_SetDsrmPassword}, 5470 {"SAMR_VALIDATEPASSWORD", NDR_SAMR_VALIDATEPASSWORD, api_samr_ValidatePassword}, 5471}; 5472 5473void samr_get_pipe_fns(struct api_struct **fns, int *n_fns) 5474{ 5475 *fns = api_samr_cmds; 5476 *n_fns = sizeof(api_samr_cmds) / sizeof(struct api_struct); 5477} 5478 5479NTSTATUS rpc_samr_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r) 5480{ 5481 if (cli->pipes_struct == NULL) { 5482 return NT_STATUS_INVALID_PARAMETER; 5483 } 5484 5485 switch (opnum) 5486 { 5487 case NDR_SAMR_CONNECT: { 5488 struct samr_Connect *r = (struct samr_Connect *)_r; 5489 ZERO_STRUCT(r->out); 5490 r->out.connect_handle = talloc_zero(mem_ctx, struct policy_handle); 5491 if (r->out.connect_handle == NULL) { 5492 return NT_STATUS_NO_MEMORY; 5493 } 5494 5495 r->out.result = _samr_Connect(cli->pipes_struct, r); 5496 return NT_STATUS_OK; 5497 } 5498 5499 case NDR_SAMR_CLOSE: { 5500 struct samr_Close *r = (struct samr_Close *)_r; 5501 ZERO_STRUCT(r->out); 5502 r->out.handle = r->in.handle; 5503 r->out.result = _samr_Close(cli->pipes_struct, r); 5504 return NT_STATUS_OK; 5505 } 5506 5507 case NDR_SAMR_SETSECURITY: { 5508 struct samr_SetSecurity *r = (struct samr_SetSecurity *)_r; 5509 r->out.result = _samr_SetSecurity(cli->pipes_struct, r); 5510 return NT_STATUS_OK; 5511 } 5512 5513 case NDR_SAMR_QUERYSECURITY: { 5514 struct samr_QuerySecurity *r = (struct samr_QuerySecurity *)_r; 5515 ZERO_STRUCT(r->out); 5516 r->out.sdbuf = talloc_zero(mem_ctx, struct sec_desc_buf *); 5517 if (r->out.sdbuf == NULL) { 5518 return NT_STATUS_NO_MEMORY; 5519 } 5520 5521 r->out.result = _samr_QuerySecurity(cli->pipes_struct, r); 5522 return NT_STATUS_OK; 5523 } 5524 5525 case NDR_SAMR_SHUTDOWN: { 5526 struct samr_Shutdown *r = (struct samr_Shutdown *)_r; 5527 r->out.result = _samr_Shutdown(cli->pipes_struct, r); 5528 return NT_STATUS_OK; 5529 } 5530 5531 case NDR_SAMR_LOOKUPDOMAIN: { 5532 struct samr_LookupDomain *r = (struct samr_LookupDomain *)_r; 5533 ZERO_STRUCT(r->out); 5534 r->out.sid = talloc_zero(mem_ctx, struct dom_sid2 *); 5535 if (r->out.sid == NULL) { 5536 return NT_STATUS_NO_MEMORY; 5537 } 5538 5539 r->out.result = _samr_LookupDomain(cli->pipes_struct, r); 5540 return NT_STATUS_OK; 5541 } 5542 5543 case NDR_SAMR_ENUMDOMAINS: { 5544 struct samr_EnumDomains *r = (struct samr_EnumDomains *)_r; 5545 ZERO_STRUCT(r->out); 5546 r->out.resume_handle = r->in.resume_handle; 5547 r->out.sam = talloc_zero(mem_ctx, struct samr_SamArray *); 5548 if (r->out.sam == NULL) { 5549 return NT_STATUS_NO_MEMORY; 5550 } 5551 5552 r->out.num_entries = talloc_zero(mem_ctx, uint32_t); 5553 if (r->out.num_entries == NULL) { 5554 return NT_STATUS_NO_MEMORY; 5555 } 5556 5557 r->out.result = _samr_EnumDomains(cli->pipes_struct, r); 5558 return NT_STATUS_OK; 5559 } 5560 5561 case NDR_SAMR_OPENDOMAIN: { 5562 struct samr_OpenDomain *r = (struct samr_OpenDomain *)_r; 5563 ZERO_STRUCT(r->out); 5564 r->out.domain_handle = talloc_zero(mem_ctx, struct policy_handle); 5565 if (r->out.domain_handle == NULL) { 5566 return NT_STATUS_NO_MEMORY; 5567 } 5568 5569 r->out.result = _samr_OpenDomain(cli->pipes_struct, r); 5570 return NT_STATUS_OK; 5571 } 5572 5573 case NDR_SAMR_QUERYDOMAININFO: { 5574 struct samr_QueryDomainInfo *r = (struct samr_QueryDomainInfo *)_r; 5575 ZERO_STRUCT(r->out); 5576 r->out.info = talloc_zero(mem_ctx, union samr_DomainInfo *); 5577 if (r->out.info == NULL) { 5578 return NT_STATUS_NO_MEMORY; 5579 } 5580 5581 r->out.result = _samr_QueryDomainInfo(cli->pipes_struct, r); 5582 return NT_STATUS_OK; 5583 } 5584 5585 case NDR_SAMR_SETDOMAININFO: { 5586 struct samr_SetDomainInfo *r = (struct samr_SetDomainInfo *)_r; 5587 r->out.result = _samr_SetDomainInfo(cli->pipes_struct, r); 5588 return NT_STATUS_OK; 5589 } 5590 5591 case NDR_SAMR_CREATEDOMAINGROUP: { 5592 struct samr_CreateDomainGroup *r = (struct samr_CreateDomainGroup *)_r; 5593 ZERO_STRUCT(r->out); 5594 r->out.group_handle = talloc_zero(mem_ctx, struct policy_handle); 5595 if (r->out.group_handle == NULL) { 5596 return NT_STATUS_NO_MEMORY; 5597 } 5598 5599 r->out.rid = talloc_zero(mem_ctx, uint32_t); 5600 if (r->out.rid == NULL) { 5601 return NT_STATUS_NO_MEMORY; 5602 } 5603 5604 r->out.result = _samr_CreateDomainGroup(cli->pipes_struct, r); 5605 return NT_STATUS_OK; 5606 } 5607 5608 case NDR_SAMR_ENUMDOMAINGROUPS: { 5609 struct samr_EnumDomainGroups *r = (struct samr_EnumDomainGroups *)_r; 5610 ZERO_STRUCT(r->out); 5611 r->out.resume_handle = r->in.resume_handle; 5612 r->out.sam = talloc_zero(mem_ctx, struct samr_SamArray *); 5613 if (r->out.sam == NULL) { 5614 return NT_STATUS_NO_MEMORY; 5615 } 5616 5617 r->out.num_entries = talloc_zero(mem_ctx, uint32_t); 5618 if (r->out.num_entries == NULL) { 5619 return NT_STATUS_NO_MEMORY; 5620 } 5621 5622 r->out.result = _samr_EnumDomainGroups(cli->pipes_struct, r); 5623 return NT_STATUS_OK; 5624 } 5625 5626 case NDR_SAMR_CREATEUSER: { 5627 struct samr_CreateUser *r = (struct samr_CreateUser *)_r; 5628 ZERO_STRUCT(r->out); 5629 r->out.user_handle = talloc_zero(mem_ctx, struct policy_handle); 5630 if (r->out.user_handle == NULL) { 5631 return NT_STATUS_NO_MEMORY; 5632 } 5633 5634 r->out.rid = talloc_zero(mem_ctx, uint32_t); 5635 if (r->out.rid == NULL) { 5636 return NT_STATUS_NO_MEMORY; 5637 } 5638 5639 r->out.result = _samr_CreateUser(cli->pipes_struct, r); 5640 return NT_STATUS_OK; 5641 } 5642 5643 case NDR_SAMR_ENUMDOMAINUSERS: { 5644 struct samr_EnumDomainUsers *r = (struct samr_EnumDomainUsers *)_r; 5645 ZERO_STRUCT(r->out); 5646 r->out.resume_handle = r->in.resume_handle; 5647 r->out.sam = talloc_zero(mem_ctx, struct samr_SamArray *); 5648 if (r->out.sam == NULL) { 5649 return NT_STATUS_NO_MEMORY; 5650 } 5651 5652 r->out.num_entries = talloc_zero(mem_ctx, uint32_t); 5653 if (r->out.num_entries == NULL) { 5654 return NT_STATUS_NO_MEMORY; 5655 } 5656 5657 r->out.result = _samr_EnumDomainUsers(cli->pipes_struct, r); 5658 return NT_STATUS_OK; 5659 } 5660 5661 case NDR_SAMR_CREATEDOMALIAS: { 5662 struct samr_CreateDomAlias *r = (struct samr_CreateDomAlias *)_r; 5663 ZERO_STRUCT(r->out); 5664 r->out.alias_handle = talloc_zero(mem_ctx, struct policy_handle); 5665 if (r->out.alias_handle == NULL) { 5666 return NT_STATUS_NO_MEMORY; 5667 } 5668 5669 r->out.rid = talloc_zero(mem_ctx, uint32_t); 5670 if (r->out.rid == NULL) { 5671 return NT_STATUS_NO_MEMORY; 5672 } 5673 5674 r->out.result = _samr_CreateDomAlias(cli->pipes_struct, r); 5675 return NT_STATUS_OK; 5676 } 5677 5678 case NDR_SAMR_ENUMDOMAINALIASES: { 5679 struct samr_EnumDomainAliases *r = (struct samr_EnumDomainAliases *)_r; 5680 ZERO_STRUCT(r->out); 5681 r->out.resume_handle = r->in.resume_handle; 5682 r->out.sam = talloc_zero(mem_ctx, struct samr_SamArray *); 5683 if (r->out.sam == NULL) { 5684 return NT_STATUS_NO_MEMORY; 5685 } 5686 5687 r->out.num_entries = talloc_zero(mem_ctx, uint32_t); 5688 if (r->out.num_entries == NULL) { 5689 return NT_STATUS_NO_MEMORY; 5690 } 5691 5692 r->out.result = _samr_EnumDomainAliases(cli->pipes_struct, r); 5693 return NT_STATUS_OK; 5694 } 5695 5696 case NDR_SAMR_GETALIASMEMBERSHIP: { 5697 struct samr_GetAliasMembership *r = (struct samr_GetAliasMembership *)_r; 5698 ZERO_STRUCT(r->out); 5699 r->out.rids = talloc_zero(mem_ctx, struct samr_Ids); 5700 if (r->out.rids == NULL) { 5701 return NT_STATUS_NO_MEMORY; 5702 } 5703 5704 r->out.result = _samr_GetAliasMembership(cli->pipes_struct, r); 5705 return NT_STATUS_OK; 5706 } 5707 5708 case NDR_SAMR_LOOKUPNAMES: { 5709 struct samr_LookupNames *r = (struct samr_LookupNames *)_r; 5710 ZERO_STRUCT(r->out); 5711 r->out.rids = talloc_zero(mem_ctx, struct samr_Ids); 5712 if (r->out.rids == NULL) { 5713 return NT_STATUS_NO_MEMORY; 5714 } 5715 5716 r->out.types = talloc_zero(mem_ctx, struct samr_Ids); 5717 if (r->out.types == NULL) { 5718 return NT_STATUS_NO_MEMORY; 5719 } 5720 5721 r->out.result = _samr_LookupNames(cli->pipes_struct, r); 5722 return NT_STATUS_OK; 5723 } 5724 5725 case NDR_SAMR_LOOKUPRIDS: { 5726 struct samr_LookupRids *r = (struct samr_LookupRids *)_r; 5727 ZERO_STRUCT(r->out); 5728 r->out.names = talloc_zero(mem_ctx, struct lsa_Strings); 5729 if (r->out.names == NULL) { 5730 return NT_STATUS_NO_MEMORY; 5731 } 5732 5733 r->out.types = talloc_zero(mem_ctx, struct samr_Ids); 5734 if (r->out.types == NULL) { 5735 return NT_STATUS_NO_MEMORY; 5736 } 5737 5738 r->out.result = _samr_LookupRids(cli->pipes_struct, r); 5739 return NT_STATUS_OK; 5740 } 5741 5742 case NDR_SAMR_OPENGROUP: { 5743 struct samr_OpenGroup *r = (struct samr_OpenGroup *)_r; 5744 ZERO_STRUCT(r->out); 5745 r->out.group_handle = talloc_zero(mem_ctx, struct policy_handle); 5746 if (r->out.group_handle == NULL) { 5747 return NT_STATUS_NO_MEMORY; 5748 } 5749 5750 r->out.result = _samr_OpenGroup(cli->pipes_struct, r); 5751 return NT_STATUS_OK; 5752 } 5753 5754 case NDR_SAMR_QUERYGROUPINFO: { 5755 struct samr_QueryGroupInfo *r = (struct samr_QueryGroupInfo *)_r; 5756 ZERO_STRUCT(r->out); 5757 r->out.info = talloc_zero(mem_ctx, union samr_GroupInfo *); 5758 if (r->out.info == NULL) { 5759 return NT_STATUS_NO_MEMORY; 5760 } 5761 5762 r->out.result = _samr_QueryGroupInfo(cli->pipes_struct, r); 5763 return NT_STATUS_OK; 5764 } 5765 5766 case NDR_SAMR_SETGROUPINFO: { 5767 struct samr_SetGroupInfo *r = (struct samr_SetGroupInfo *)_r; 5768 r->out.result = _samr_SetGroupInfo(cli->pipes_struct, r); 5769 return NT_STATUS_OK; 5770 } 5771 5772 case NDR_SAMR_ADDGROUPMEMBER: { 5773 struct samr_AddGroupMember *r = (struct samr_AddGroupMember *)_r; 5774 r->out.result = _samr_AddGroupMember(cli->pipes_struct, r); 5775 return NT_STATUS_OK; 5776 } 5777 5778 case NDR_SAMR_DELETEDOMAINGROUP: { 5779 struct samr_DeleteDomainGroup *r = (struct samr_DeleteDomainGroup *)_r; 5780 ZERO_STRUCT(r->out); 5781 r->out.group_handle = r->in.group_handle; 5782 r->out.result = _samr_DeleteDomainGroup(cli->pipes_struct, r); 5783 return NT_STATUS_OK; 5784 } 5785 5786 case NDR_SAMR_DELETEGROUPMEMBER: { 5787 struct samr_DeleteGroupMember *r = (struct samr_DeleteGroupMember *)_r; 5788 r->out.result = _samr_DeleteGroupMember(cli->pipes_struct, r); 5789 return NT_STATUS_OK; 5790 } 5791 5792 case NDR_SAMR_QUERYGROUPMEMBER: { 5793 struct samr_QueryGroupMember *r = (struct samr_QueryGroupMember *)_r; 5794 ZERO_STRUCT(r->out); 5795 r->out.rids = talloc_zero(mem_ctx, struct samr_RidTypeArray *); 5796 if (r->out.rids == NULL) { 5797 return NT_STATUS_NO_MEMORY; 5798 } 5799 5800 r->out.result = _samr_QueryGroupMember(cli->pipes_struct, r); 5801 return NT_STATUS_OK; 5802 } 5803 5804 case NDR_SAMR_SETMEMBERATTRIBUTESOFGROUP: { 5805 struct samr_SetMemberAttributesOfGroup *r = (struct samr_SetMemberAttributesOfGroup *)_r; 5806 r->out.result = _samr_SetMemberAttributesOfGroup(cli->pipes_struct, r); 5807 return NT_STATUS_OK; 5808 } 5809 5810 case NDR_SAMR_OPENALIAS: { 5811 struct samr_OpenAlias *r = (struct samr_OpenAlias *)_r; 5812 ZERO_STRUCT(r->out); 5813 r->out.alias_handle = talloc_zero(mem_ctx, struct policy_handle); 5814 if (r->out.alias_handle == NULL) { 5815 return NT_STATUS_NO_MEMORY; 5816 } 5817 5818 r->out.result = _samr_OpenAlias(cli->pipes_struct, r); 5819 return NT_STATUS_OK; 5820 } 5821 5822 case NDR_SAMR_QUERYALIASINFO: { 5823 struct samr_QueryAliasInfo *r = (struct samr_QueryAliasInfo *)_r; 5824 ZERO_STRUCT(r->out); 5825 r->out.info = talloc_zero(mem_ctx, union samr_AliasInfo *); 5826 if (r->out.info == NULL) { 5827 return NT_STATUS_NO_MEMORY; 5828 } 5829 5830 r->out.result = _samr_QueryAliasInfo(cli->pipes_struct, r); 5831 return NT_STATUS_OK; 5832 } 5833 5834 case NDR_SAMR_SETALIASINFO: { 5835 struct samr_SetAliasInfo *r = (struct samr_SetAliasInfo *)_r; 5836 r->out.result = _samr_SetAliasInfo(cli->pipes_struct, r); 5837 return NT_STATUS_OK; 5838 } 5839 5840 case NDR_SAMR_DELETEDOMALIAS: { 5841 struct samr_DeleteDomAlias *r = (struct samr_DeleteDomAlias *)_r; 5842 ZERO_STRUCT(r->out); 5843 r->out.alias_handle = r->in.alias_handle; 5844 r->out.result = _samr_DeleteDomAlias(cli->pipes_struct, r); 5845 return NT_STATUS_OK; 5846 } 5847 5848 case NDR_SAMR_ADDALIASMEMBER: { 5849 struct samr_AddAliasMember *r = (struct samr_AddAliasMember *)_r; 5850 r->out.result = _samr_AddAliasMember(cli->pipes_struct, r); 5851 return NT_STATUS_OK; 5852 } 5853 5854 case NDR_SAMR_DELETEALIASMEMBER: { 5855 struct samr_DeleteAliasMember *r = (struct samr_DeleteAliasMember *)_r; 5856 r->out.result = _samr_DeleteAliasMember(cli->pipes_struct, r); 5857 return NT_STATUS_OK; 5858 } 5859 5860 case NDR_SAMR_GETMEMBERSINALIAS: { 5861 struct samr_GetMembersInAlias *r = (struct samr_GetMembersInAlias *)_r; 5862 ZERO_STRUCT(r->out); 5863 r->out.sids = talloc_zero(mem_ctx, struct lsa_SidArray); 5864 if (r->out.sids == NULL) { 5865 return NT_STATUS_NO_MEMORY; 5866 } 5867 5868 r->out.result = _samr_GetMembersInAlias(cli->pipes_struct, r); 5869 return NT_STATUS_OK; 5870 } 5871 5872 case NDR_SAMR_OPENUSER: { 5873 struct samr_OpenUser *r = (struct samr_OpenUser *)_r; 5874 ZERO_STRUCT(r->out); 5875 r->out.user_handle = talloc_zero(mem_ctx, struct policy_handle); 5876 if (r->out.user_handle == NULL) { 5877 return NT_STATUS_NO_MEMORY; 5878 } 5879 5880 r->out.result = _samr_OpenUser(cli->pipes_struct, r); 5881 return NT_STATUS_OK; 5882 } 5883 5884 case NDR_SAMR_DELETEUSER: { 5885 struct samr_DeleteUser *r = (struct samr_DeleteUser *)_r; 5886 ZERO_STRUCT(r->out); 5887 r->out.user_handle = r->in.user_handle; 5888 r->out.result = _samr_DeleteUser(cli->pipes_struct, r); 5889 return NT_STATUS_OK; 5890 } 5891 5892 case NDR_SAMR_QUERYUSERINFO: { 5893 struct samr_QueryUserInfo *r = (struct samr_QueryUserInfo *)_r; 5894 ZERO_STRUCT(r->out); 5895 r->out.info = talloc_zero(mem_ctx, union samr_UserInfo *); 5896 if (r->out.info == NULL) { 5897 return NT_STATUS_NO_MEMORY; 5898 } 5899 5900 r->out.result = _samr_QueryUserInfo(cli->pipes_struct, r); 5901 return NT_STATUS_OK; 5902 } 5903 5904 case NDR_SAMR_SETUSERINFO: { 5905 struct samr_SetUserInfo *r = (struct samr_SetUserInfo *)_r; 5906 r->out.result = _samr_SetUserInfo(cli->pipes_struct, r); 5907 return NT_STATUS_OK; 5908 } 5909 5910 case NDR_SAMR_CHANGEPASSWORDUSER: { 5911 struct samr_ChangePasswordUser *r = (struct samr_ChangePasswordUser *)_r; 5912 r->out.result = _samr_ChangePasswordUser(cli->pipes_struct, r); 5913 return NT_STATUS_OK; 5914 } 5915 5916 case NDR_SAMR_GETGROUPSFORUSER: { 5917 struct samr_GetGroupsForUser *r = (struct samr_GetGroupsForUser *)_r; 5918 ZERO_STRUCT(r->out); 5919 r->out.rids = talloc_zero(mem_ctx, struct samr_RidWithAttributeArray *); 5920 if (r->out.rids == NULL) { 5921 return NT_STATUS_NO_MEMORY; 5922 } 5923 5924 r->out.result = _samr_GetGroupsForUser(cli->pipes_struct, r); 5925 return NT_STATUS_OK; 5926 } 5927 5928 case NDR_SAMR_QUERYDISPLAYINFO: { 5929 struct samr_QueryDisplayInfo *r = (struct samr_QueryDisplayInfo *)_r; 5930 ZERO_STRUCT(r->out); 5931 r->out.total_size = talloc_zero(mem_ctx, uint32_t); 5932 if (r->out.total_size == NULL) { 5933 return NT_STATUS_NO_MEMORY; 5934 } 5935 5936 r->out.returned_size = talloc_zero(mem_ctx, uint32_t); 5937 if (r->out.returned_size == NULL) { 5938 return NT_STATUS_NO_MEMORY; 5939 } 5940 5941 r->out.info = talloc_zero(mem_ctx, union samr_DispInfo); 5942 if (r->out.info == NULL) { 5943 return NT_STATUS_NO_MEMORY; 5944 } 5945 5946 r->out.result = _samr_QueryDisplayInfo(cli->pipes_struct, r); 5947 return NT_STATUS_OK; 5948 } 5949 5950 case NDR_SAMR_GETDISPLAYENUMERATIONINDEX: { 5951 struct samr_GetDisplayEnumerationIndex *r = (struct samr_GetDisplayEnumerationIndex *)_r; 5952 ZERO_STRUCT(r->out); 5953 r->out.idx = talloc_zero(mem_ctx, uint32_t); 5954 if (r->out.idx == NULL) { 5955 return NT_STATUS_NO_MEMORY; 5956 } 5957 5958 r->out.result = _samr_GetDisplayEnumerationIndex(cli->pipes_struct, r); 5959 return NT_STATUS_OK; 5960 } 5961 5962 case NDR_SAMR_TESTPRIVATEFUNCTIONSDOMAIN: { 5963 struct samr_TestPrivateFunctionsDomain *r = (struct samr_TestPrivateFunctionsDomain *)_r; 5964 r->out.result = _samr_TestPrivateFunctionsDomain(cli->pipes_struct, r); 5965 return NT_STATUS_OK; 5966 } 5967 5968 case NDR_SAMR_TESTPRIVATEFUNCTIONSUSER: { 5969 struct samr_TestPrivateFunctionsUser *r = (struct samr_TestPrivateFunctionsUser *)_r; 5970 r->out.result = _samr_TestPrivateFunctionsUser(cli->pipes_struct, r); 5971 return NT_STATUS_OK; 5972 } 5973 5974 case NDR_SAMR_GETUSERPWINFO: { 5975 struct samr_GetUserPwInfo *r = (struct samr_GetUserPwInfo *)_r; 5976 ZERO_STRUCT(r->out); 5977 r->out.info = talloc_zero(mem_ctx, struct samr_PwInfo); 5978 if (r->out.info == NULL) { 5979 return NT_STATUS_NO_MEMORY; 5980 } 5981 5982 r->out.result = _samr_GetUserPwInfo(cli->pipes_struct, r); 5983 return NT_STATUS_OK; 5984 } 5985 5986 case NDR_SAMR_REMOVEMEMBERFROMFOREIGNDOMAIN: { 5987 struct samr_RemoveMemberFromForeignDomain *r = (struct samr_RemoveMemberFromForeignDomain *)_r; 5988 r->out.result = _samr_RemoveMemberFromForeignDomain(cli->pipes_struct, r); 5989 return NT_STATUS_OK; 5990 } 5991 5992 case NDR_SAMR_QUERYDOMAININFO2: { 5993 struct samr_QueryDomainInfo2 *r = (struct samr_QueryDomainInfo2 *)_r; 5994 ZERO_STRUCT(r->out); 5995 r->out.info = talloc_zero(mem_ctx, union samr_DomainInfo *); 5996 if (r->out.info == NULL) { 5997 return NT_STATUS_NO_MEMORY; 5998 } 5999 6000 r->out.result = _samr_QueryDomainInfo2(cli->pipes_struct, r); 6001 return NT_STATUS_OK; 6002 } 6003 6004 case NDR_SAMR_QUERYUSERINFO2: { 6005 struct samr_QueryUserInfo2 *r = (struct samr_QueryUserInfo2 *)_r; 6006 ZERO_STRUCT(r->out); 6007 r->out.info = talloc_zero(mem_ctx, union samr_UserInfo *); 6008 if (r->out.info == NULL) { 6009 return NT_STATUS_NO_MEMORY; 6010 } 6011 6012 r->out.result = _samr_QueryUserInfo2(cli->pipes_struct, r); 6013 return NT_STATUS_OK; 6014 } 6015 6016 case NDR_SAMR_QUERYDISPLAYINFO2: { 6017 struct samr_QueryDisplayInfo2 *r = (struct samr_QueryDisplayInfo2 *)_r; 6018 ZERO_STRUCT(r->out); 6019 r->out.total_size = talloc_zero(mem_ctx, uint32_t); 6020 if (r->out.total_size == NULL) { 6021 return NT_STATUS_NO_MEMORY; 6022 } 6023 6024 r->out.returned_size = talloc_zero(mem_ctx, uint32_t); 6025 if (r->out.returned_size == NULL) { 6026 return NT_STATUS_NO_MEMORY; 6027 } 6028 6029 r->out.info = talloc_zero(mem_ctx, union samr_DispInfo); 6030 if (r->out.info == NULL) { 6031 return NT_STATUS_NO_MEMORY; 6032 } 6033 6034 r->out.result = _samr_QueryDisplayInfo2(cli->pipes_struct, r); 6035 return NT_STATUS_OK; 6036 } 6037 6038 case NDR_SAMR_GETDISPLAYENUMERATIONINDEX2: { 6039 struct samr_GetDisplayEnumerationIndex2 *r = (struct samr_GetDisplayEnumerationIndex2 *)_r; 6040 ZERO_STRUCT(r->out); 6041 r->out.idx = talloc_zero(mem_ctx, uint32_t); 6042 if (r->out.idx == NULL) { 6043 return NT_STATUS_NO_MEMORY; 6044 } 6045 6046 r->out.result = _samr_GetDisplayEnumerationIndex2(cli->pipes_struct, r); 6047 return NT_STATUS_OK; 6048 } 6049 6050 case NDR_SAMR_CREATEUSER2: { 6051 struct samr_CreateUser2 *r = (struct samr_CreateUser2 *)_r; 6052 ZERO_STRUCT(r->out); 6053 r->out.user_handle = talloc_zero(mem_ctx, struct policy_handle); 6054 if (r->out.user_handle == NULL) { 6055 return NT_STATUS_NO_MEMORY; 6056 } 6057 6058 r->out.access_granted = talloc_zero(mem_ctx, uint32_t); 6059 if (r->out.access_granted == NULL) { 6060 return NT_STATUS_NO_MEMORY; 6061 } 6062 6063 r->out.rid = talloc_zero(mem_ctx, uint32_t); 6064 if (r->out.rid == NULL) { 6065 return NT_STATUS_NO_MEMORY; 6066 } 6067 6068 r->out.result = _samr_CreateUser2(cli->pipes_struct, r); 6069 return NT_STATUS_OK; 6070 } 6071 6072 case NDR_SAMR_QUERYDISPLAYINFO3: { 6073 struct samr_QueryDisplayInfo3 *r = (struct samr_QueryDisplayInfo3 *)_r; 6074 ZERO_STRUCT(r->out); 6075 r->out.total_size = talloc_zero(mem_ctx, uint32_t); 6076 if (r->out.total_size == NULL) { 6077 return NT_STATUS_NO_MEMORY; 6078 } 6079 6080 r->out.returned_size = talloc_zero(mem_ctx, uint32_t); 6081 if (r->out.returned_size == NULL) { 6082 return NT_STATUS_NO_MEMORY; 6083 } 6084 6085 r->out.info = talloc_zero(mem_ctx, union samr_DispInfo); 6086 if (r->out.info == NULL) { 6087 return NT_STATUS_NO_MEMORY; 6088 } 6089 6090 r->out.result = _samr_QueryDisplayInfo3(cli->pipes_struct, r); 6091 return NT_STATUS_OK; 6092 } 6093 6094 case NDR_SAMR_ADDMULTIPLEMEMBERSTOALIAS: { 6095 struct samr_AddMultipleMembersToAlias *r = (struct samr_AddMultipleMembersToAlias *)_r; 6096 r->out.result = _samr_AddMultipleMembersToAlias(cli->pipes_struct, r); 6097 return NT_STATUS_OK; 6098 } 6099 6100 case NDR_SAMR_REMOVEMULTIPLEMEMBERSFROMALIAS: { 6101 struct samr_RemoveMultipleMembersFromAlias *r = (struct samr_RemoveMultipleMembersFromAlias *)_r; 6102 r->out.result = _samr_RemoveMultipleMembersFromAlias(cli->pipes_struct, r); 6103 return NT_STATUS_OK; 6104 } 6105 6106 case NDR_SAMR_OEMCHANGEPASSWORDUSER2: { 6107 struct samr_OemChangePasswordUser2 *r = (struct samr_OemChangePasswordUser2 *)_r; 6108 r->out.result = _samr_OemChangePasswordUser2(cli->pipes_struct, r); 6109 return NT_STATUS_OK; 6110 } 6111 6112 case NDR_SAMR_CHANGEPASSWORDUSER2: { 6113 struct samr_ChangePasswordUser2 *r = (struct samr_ChangePasswordUser2 *)_r; 6114 r->out.result = _samr_ChangePasswordUser2(cli->pipes_struct, r); 6115 return NT_STATUS_OK; 6116 } 6117 6118 case NDR_SAMR_GETDOMPWINFO: { 6119 struct samr_GetDomPwInfo *r = (struct samr_GetDomPwInfo *)_r; 6120 ZERO_STRUCT(r->out); 6121 r->out.info = talloc_zero(mem_ctx, struct samr_PwInfo); 6122 if (r->out.info == NULL) { 6123 return NT_STATUS_NO_MEMORY; 6124 } 6125 6126 r->out.result = _samr_GetDomPwInfo(cli->pipes_struct, r); 6127 return NT_STATUS_OK; 6128 } 6129 6130 case NDR_SAMR_CONNECT2: { 6131 struct samr_Connect2 *r = (struct samr_Connect2 *)_r; 6132 ZERO_STRUCT(r->out); 6133 r->out.connect_handle = talloc_zero(mem_ctx, struct policy_handle); 6134 if (r->out.connect_handle == NULL) { 6135 return NT_STATUS_NO_MEMORY; 6136 } 6137 6138 r->out.result = _samr_Connect2(cli->pipes_struct, r); 6139 return NT_STATUS_OK; 6140 } 6141 6142 case NDR_SAMR_SETUSERINFO2: { 6143 struct samr_SetUserInfo2 *r = (struct samr_SetUserInfo2 *)_r; 6144 r->out.result = _samr_SetUserInfo2(cli->pipes_struct, r); 6145 return NT_STATUS_OK; 6146 } 6147 6148 case NDR_SAMR_SETBOOTKEYINFORMATION: { 6149 struct samr_SetBootKeyInformation *r = (struct samr_SetBootKeyInformation *)_r; 6150 r->out.result = _samr_SetBootKeyInformation(cli->pipes_struct, r); 6151 return NT_STATUS_OK; 6152 } 6153 6154 case NDR_SAMR_GETBOOTKEYINFORMATION: { 6155 struct samr_GetBootKeyInformation *r = (struct samr_GetBootKeyInformation *)_r; 6156 ZERO_STRUCT(r->out); 6157 r->out.unknown = talloc_zero(mem_ctx, uint32_t); 6158 if (r->out.unknown == NULL) { 6159 return NT_STATUS_NO_MEMORY; 6160 } 6161 6162 r->out.result = _samr_GetBootKeyInformation(cli->pipes_struct, r); 6163 return NT_STATUS_OK; 6164 } 6165 6166 case NDR_SAMR_CONNECT3: { 6167 struct samr_Connect3 *r = (struct samr_Connect3 *)_r; 6168 ZERO_STRUCT(r->out); 6169 r->out.connect_handle = talloc_zero(mem_ctx, struct policy_handle); 6170 if (r->out.connect_handle == NULL) { 6171 return NT_STATUS_NO_MEMORY; 6172 } 6173 6174 r->out.result = _samr_Connect3(cli->pipes_struct, r); 6175 return NT_STATUS_OK; 6176 } 6177 6178 case NDR_SAMR_CONNECT4: { 6179 struct samr_Connect4 *r = (struct samr_Connect4 *)_r; 6180 ZERO_STRUCT(r->out); 6181 r->out.connect_handle = talloc_zero(mem_ctx, struct policy_handle); 6182 if (r->out.connect_handle == NULL) { 6183 return NT_STATUS_NO_MEMORY; 6184 } 6185 6186 r->out.result = _samr_Connect4(cli->pipes_struct, r); 6187 return NT_STATUS_OK; 6188 } 6189 6190 case NDR_SAMR_CHANGEPASSWORDUSER3: { 6191 struct samr_ChangePasswordUser3 *r = (struct samr_ChangePasswordUser3 *)_r; 6192 ZERO_STRUCT(r->out); 6193 r->out.dominfo = talloc_zero(mem_ctx, struct samr_DomInfo1 *); 6194 if (r->out.dominfo == NULL) { 6195 return NT_STATUS_NO_MEMORY; 6196 } 6197 6198 r->out.reject = talloc_zero(mem_ctx, struct samr_ChangeReject *); 6199 if (r->out.reject == NULL) { 6200 return NT_STATUS_NO_MEMORY; 6201 } 6202 6203 r->out.result = _samr_ChangePasswordUser3(cli->pipes_struct, r); 6204 return NT_STATUS_OK; 6205 } 6206 6207 case NDR_SAMR_CONNECT5: { 6208 struct samr_Connect5 *r = (struct samr_Connect5 *)_r; 6209 ZERO_STRUCT(r->out); 6210 r->out.level_out = talloc_zero(mem_ctx, uint32_t); 6211 if (r->out.level_out == NULL) { 6212 return NT_STATUS_NO_MEMORY; 6213 } 6214 6215 r->out.info_out = talloc_zero(mem_ctx, union samr_ConnectInfo); 6216 if (r->out.info_out == NULL) { 6217 return NT_STATUS_NO_MEMORY; 6218 } 6219 6220 r->out.connect_handle = talloc_zero(mem_ctx, struct policy_handle); 6221 if (r->out.connect_handle == NULL) { 6222 return NT_STATUS_NO_MEMORY; 6223 } 6224 6225 r->out.result = _samr_Connect5(cli->pipes_struct, r); 6226 return NT_STATUS_OK; 6227 } 6228 6229 case NDR_SAMR_RIDTOSID: { 6230 struct samr_RidToSid *r = (struct samr_RidToSid *)_r; 6231 ZERO_STRUCT(r->out); 6232 r->out.sid = talloc_zero(mem_ctx, struct dom_sid2 *); 6233 if (r->out.sid == NULL) { 6234 return NT_STATUS_NO_MEMORY; 6235 } 6236 6237 r->out.result = _samr_RidToSid(cli->pipes_struct, r); 6238 return NT_STATUS_OK; 6239 } 6240 6241 case NDR_SAMR_SETDSRMPASSWORD: { 6242 struct samr_SetDsrmPassword *r = (struct samr_SetDsrmPassword *)_r; 6243 r->out.result = _samr_SetDsrmPassword(cli->pipes_struct, r); 6244 return NT_STATUS_OK; 6245 } 6246 6247 case NDR_SAMR_VALIDATEPASSWORD: { 6248 struct samr_ValidatePassword *r = (struct samr_ValidatePassword *)_r; 6249 ZERO_STRUCT(r->out); 6250 r->out.rep = talloc_zero(mem_ctx, union samr_ValidatePasswordRep *); 6251 if (r->out.rep == NULL) { 6252 return NT_STATUS_NO_MEMORY; 6253 } 6254 6255 r->out.result = _samr_ValidatePassword(cli->pipes_struct, r); 6256 return NT_STATUS_OK; 6257 } 6258 6259 default: 6260 return NT_STATUS_NOT_IMPLEMENTED; 6261 } 6262} 6263 6264NTSTATUS rpc_samr_init(void) 6265{ 6266 return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "samr", "samr", &ndr_table_samr, api_samr_cmds, sizeof(api_samr_cmds) / sizeof(struct api_struct)); 6267} 6268