librpc/gen_ndr/srv_lsa.c

   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_lsa.h"
   8
   9 static bool api_lsa_Close(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 lsa_Close *r;
  17
  18         call = &ndr_table_lsarpc.calls[NDR_LSA_CLOSE];
  19
  20         r = talloc(talloc_tos(), struct lsa_Close);
  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(lsa_Close, r);
  45         }
  46
  47         ZERO_STRUCT(r->out);
  48         r->out.handle = r->in.handle;
  49         r->out.result = _lsa_Close(p, r);
  50
  51         if (p->rng_fault_state) {
  52                 talloc_free(r);
  53                 /* Return true here, srv_pipe_hnd.c will take care */
  54                 return true;
  55         }
  56
  57         if (DEBUGLEVEL >= 10) {
  58                 NDR_PRINT_OUT_DEBUG(lsa_Close, r);
  59         }
  60
  61         push = ndr_push_init_ctx(r, NULL);
  62         if (push == NULL) {
  63                 talloc_free(r);
  64                 return false;
  65         }
  66
  67         ndr_err = call->ndr_push(push, NDR_OUT, r);
  68         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  69                 talloc_free(r);
  70                 return false;
  71         }
  72
  73         blob = ndr_push_blob(push);
  74         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
  75                 talloc_free(r);
  76                 return false;
  77         }
  78
  79         talloc_free(r);
  80
  81         return true;
  82 }
  83
  84 static bool api_lsa_Delete(pipes_struct *p)
  85 {
  86         const struct ndr_interface_call *call;
  87         struct ndr_pull *pull;
  88         struct ndr_push *push;
  89         enum ndr_err_code ndr_err;
  90         DATA_BLOB blob;
  91         struct lsa_Delete *r;
  92
  93         call = &ndr_table_lsarpc.calls[NDR_LSA_DELETE];
  94
  95         r = talloc(talloc_tos(), struct lsa_Delete);
  96         if (r == NULL) {
  97                 return false;
  98         }
  99
 100         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 101                 talloc_free(r);
 102                 return false;
 103         }
 104
 105         pull = ndr_pull_init_blob(&blob, r, NULL);
 106         if (pull == NULL) {
 107                 talloc_free(r);
 108                 return false;
 109         }
 110
 111         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 112         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 113         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 114                 talloc_free(r);
 115                 return false;
 116         }
 117
 118         if (DEBUGLEVEL >= 10) {
 119                 NDR_PRINT_IN_DEBUG(lsa_Delete, r);
 120         }
 121
 122         r->out.result = _lsa_Delete(p, r);
 123
 124         if (p->rng_fault_state) {
 125                 talloc_free(r);
 126                 /* Return true here, srv_pipe_hnd.c will take care */
 127                 return true;
 128         }
 129
 130         if (DEBUGLEVEL >= 10) {
 131                 NDR_PRINT_OUT_DEBUG(lsa_Delete, r);
 132         }
 133
 134         push = ndr_push_init_ctx(r, NULL);
 135         if (push == NULL) {
 136                 talloc_free(r);
 137                 return false;
 138         }
 139
 140         ndr_err = call->ndr_push(push, NDR_OUT, r);
 141         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 142                 talloc_free(r);
 143                 return false;
 144         }
 145
 146         blob = ndr_push_blob(push);
 147         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 148                 talloc_free(r);
 149                 return false;
 150         }
 151
 152         talloc_free(r);
 153
 154         return true;
 155 }
 156
 157 static bool api_lsa_EnumPrivs(pipes_struct *p)
 158 {
 159         const struct ndr_interface_call *call;
 160         struct ndr_pull *pull;
 161         struct ndr_push *push;
 162         enum ndr_err_code ndr_err;
 163         DATA_BLOB blob;
 164         struct lsa_EnumPrivs *r;
 165
 166         call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMPRIVS];
 167
 168         r = talloc(talloc_tos(), struct lsa_EnumPrivs);
 169         if (r == NULL) {
 170                 return false;
 171         }
 172
 173         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 174                 talloc_free(r);
 175                 return false;
 176         }
 177
 178         pull = ndr_pull_init_blob(&blob, r, NULL);
 179         if (pull == NULL) {
 180                 talloc_free(r);
 181                 return false;
 182         }
 183
 184         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 185         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 186         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 187                 talloc_free(r);
 188                 return false;
 189         }
 190
 191         if (DEBUGLEVEL >= 10) {
 192                 NDR_PRINT_IN_DEBUG(lsa_EnumPrivs, r);
 193         }
 194
 195         ZERO_STRUCT(r->out);
 196         r->out.resume_handle = r->in.resume_handle;
 197         r->out.privs = talloc_zero(r, struct lsa_PrivArray);
 198         if (r->out.privs == NULL) {
 199                 talloc_free(r);
 200                 return false;
 201         }
 202
 203         r->out.result = _lsa_EnumPrivs(p, r);
 204
 205         if (p->rng_fault_state) {
 206                 talloc_free(r);
 207                 /* Return true here, srv_pipe_hnd.c will take care */
 208                 return true;
 209         }
 210
 211         if (DEBUGLEVEL >= 10) {
 212                 NDR_PRINT_OUT_DEBUG(lsa_EnumPrivs, r);
 213         }
 214
 215         push = ndr_push_init_ctx(r, NULL);
 216         if (push == NULL) {
 217                 talloc_free(r);
 218                 return false;
 219         }
 220
 221         ndr_err = call->ndr_push(push, NDR_OUT, r);
 222         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 223                 talloc_free(r);
 224                 return false;
 225         }
 226
 227         blob = ndr_push_blob(push);
 228         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 229                 talloc_free(r);
 230                 return false;
 231         }
 232
 233         talloc_free(r);
 234
 235         return true;
 236 }
 237
 238 static bool api_lsa_QuerySecurity(pipes_struct *p)
 239 {
 240         const struct ndr_interface_call *call;
 241         struct ndr_pull *pull;
 242         struct ndr_push *push;
 243         enum ndr_err_code ndr_err;
 244         DATA_BLOB blob;
 245         struct lsa_QuerySecurity *r;
 246
 247         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYSECURITY];
 248
 249         r = talloc(talloc_tos(), struct lsa_QuerySecurity);
 250         if (r == NULL) {
 251                 return false;
 252         }
 253
 254         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 255                 talloc_free(r);
 256                 return false;
 257         }
 258
 259         pull = ndr_pull_init_blob(&blob, r, NULL);
 260         if (pull == NULL) {
 261                 talloc_free(r);
 262                 return false;
 263         }
 264
 265         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 266         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 267         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 268                 talloc_free(r);
 269                 return false;
 270         }
 271
 272         if (DEBUGLEVEL >= 10) {
 273                 NDR_PRINT_IN_DEBUG(lsa_QuerySecurity, r);
 274         }
 275
 276         ZERO_STRUCT(r->out);
 277         r->out.sdbuf = talloc_zero(r, struct sec_desc_buf *);
 278         if (r->out.sdbuf == NULL) {
 279                 talloc_free(r);
 280                 return false;
 281         }
 282
 283         r->out.result = _lsa_QuerySecurity(p, r);
 284
 285         if (p->rng_fault_state) {
 286                 talloc_free(r);
 287                 /* Return true here, srv_pipe_hnd.c will take care */
 288                 return true;
 289         }
 290
 291         if (DEBUGLEVEL >= 10) {
 292                 NDR_PRINT_OUT_DEBUG(lsa_QuerySecurity, r);
 293         }
 294
 295         push = ndr_push_init_ctx(r, NULL);
 296         if (push == NULL) {
 297                 talloc_free(r);
 298                 return false;
 299         }
 300
 301         ndr_err = call->ndr_push(push, NDR_OUT, r);
 302         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 303                 talloc_free(r);
 304                 return false;
 305         }
 306
 307         blob = ndr_push_blob(push);
 308         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 309                 talloc_free(r);
 310                 return false;
 311         }
 312
 313         talloc_free(r);
 314
 315         return true;
 316 }
 317
 318 static bool api_lsa_SetSecObj(pipes_struct *p)
 319 {
 320         const struct ndr_interface_call *call;
 321         struct ndr_pull *pull;
 322         struct ndr_push *push;
 323         enum ndr_err_code ndr_err;
 324         DATA_BLOB blob;
 325         struct lsa_SetSecObj *r;
 326
 327         call = &ndr_table_lsarpc.calls[NDR_LSA_SETSECOBJ];
 328
 329         r = talloc(talloc_tos(), struct lsa_SetSecObj);
 330         if (r == NULL) {
 331                 return false;
 332         }
 333
 334         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 335                 talloc_free(r);
 336                 return false;
 337         }
 338
 339         pull = ndr_pull_init_blob(&blob, r, NULL);
 340         if (pull == NULL) {
 341                 talloc_free(r);
 342                 return false;
 343         }
 344
 345         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 346         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 347         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 348                 talloc_free(r);
 349                 return false;
 350         }
 351
 352         if (DEBUGLEVEL >= 10) {
 353                 NDR_PRINT_IN_DEBUG(lsa_SetSecObj, r);
 354         }
 355
 356         r->out.result = _lsa_SetSecObj(p, r);
 357
 358         if (p->rng_fault_state) {
 359                 talloc_free(r);
 360                 /* Return true here, srv_pipe_hnd.c will take care */
 361                 return true;
 362         }
 363
 364         if (DEBUGLEVEL >= 10) {
 365                 NDR_PRINT_OUT_DEBUG(lsa_SetSecObj, r);
 366         }
 367
 368         push = ndr_push_init_ctx(r, NULL);
 369         if (push == NULL) {
 370                 talloc_free(r);
 371                 return false;
 372         }
 373
 374         ndr_err = call->ndr_push(push, NDR_OUT, r);
 375         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 376                 talloc_free(r);
 377                 return false;
 378         }
 379
 380         blob = ndr_push_blob(push);
 381         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 382                 talloc_free(r);
 383                 return false;
 384         }
 385
 386         talloc_free(r);
 387
 388         return true;
 389 }
 390
 391 static bool api_lsa_ChangePassword(pipes_struct *p)
 392 {
 393         const struct ndr_interface_call *call;
 394         struct ndr_pull *pull;
 395         struct ndr_push *push;
 396         enum ndr_err_code ndr_err;
 397         DATA_BLOB blob;
 398         struct lsa_ChangePassword *r;
 399
 400         call = &ndr_table_lsarpc.calls[NDR_LSA_CHANGEPASSWORD];
 401
 402         r = talloc(talloc_tos(), struct lsa_ChangePassword);
 403         if (r == NULL) {
 404                 return false;
 405         }
 406
 407         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 408                 talloc_free(r);
 409                 return false;
 410         }
 411
 412         pull = ndr_pull_init_blob(&blob, r, NULL);
 413         if (pull == NULL) {
 414                 talloc_free(r);
 415                 return false;
 416         }
 417
 418         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 419         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 420         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 421                 talloc_free(r);
 422                 return false;
 423         }
 424
 425         if (DEBUGLEVEL >= 10) {
 426                 NDR_PRINT_IN_DEBUG(lsa_ChangePassword, r);
 427         }
 428
 429         r->out.result = _lsa_ChangePassword(p, r);
 430
 431         if (p->rng_fault_state) {
 432                 talloc_free(r);
 433                 /* Return true here, srv_pipe_hnd.c will take care */
 434                 return true;
 435         }
 436
 437         if (DEBUGLEVEL >= 10) {
 438                 NDR_PRINT_OUT_DEBUG(lsa_ChangePassword, r);
 439         }
 440
 441         push = ndr_push_init_ctx(r, NULL);
 442         if (push == NULL) {
 443                 talloc_free(r);
 444                 return false;
 445         }
 446
 447         ndr_err = call->ndr_push(push, NDR_OUT, r);
 448         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 449                 talloc_free(r);
 450                 return false;
 451         }
 452
 453         blob = ndr_push_blob(push);
 454         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 455                 talloc_free(r);
 456                 return false;
 457         }
 458
 459         talloc_free(r);
 460
 461         return true;
 462 }
 463
 464 static bool api_lsa_OpenPolicy(pipes_struct *p)
 465 {
 466         const struct ndr_interface_call *call;
 467         struct ndr_pull *pull;
 468         struct ndr_push *push;
 469         enum ndr_err_code ndr_err;
 470         DATA_BLOB blob;
 471         struct lsa_OpenPolicy *r;
 472
 473         call = &ndr_table_lsarpc.calls[NDR_LSA_OPENPOLICY];
 474
 475         r = talloc(talloc_tos(), struct lsa_OpenPolicy);
 476         if (r == NULL) {
 477                 return false;
 478         }
 479
 480         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 481                 talloc_free(r);
 482                 return false;
 483         }
 484
 485         pull = ndr_pull_init_blob(&blob, r, NULL);
 486         if (pull == NULL) {
 487                 talloc_free(r);
 488                 return false;
 489         }
 490
 491         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 492         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 493         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 494                 talloc_free(r);
 495                 return false;
 496         }
 497
 498         if (DEBUGLEVEL >= 10) {
 499                 NDR_PRINT_IN_DEBUG(lsa_OpenPolicy, r);
 500         }
 501
 502         ZERO_STRUCT(r->out);
 503         r->out.handle = talloc_zero(r, struct policy_handle);
 504         if (r->out.handle == NULL) {
 505                 talloc_free(r);
 506                 return false;
 507         }
 508
 509         r->out.result = _lsa_OpenPolicy(p, r);
 510
 511         if (p->rng_fault_state) {
 512                 talloc_free(r);
 513                 /* Return true here, srv_pipe_hnd.c will take care */
 514                 return true;
 515         }
 516
 517         if (DEBUGLEVEL >= 10) {
 518                 NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy, r);
 519         }
 520
 521         push = ndr_push_init_ctx(r, NULL);
 522         if (push == NULL) {
 523                 talloc_free(r);
 524                 return false;
 525         }
 526
 527         ndr_err = call->ndr_push(push, NDR_OUT, r);
 528         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 529                 talloc_free(r);
 530                 return false;
 531         }
 532
 533         blob = ndr_push_blob(push);
 534         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 535                 talloc_free(r);
 536                 return false;
 537         }
 538
 539         talloc_free(r);
 540
 541         return true;
 542 }
 543
 544 static bool api_lsa_QueryInfoPolicy(pipes_struct *p)
 545 {
 546         const struct ndr_interface_call *call;
 547         struct ndr_pull *pull;
 548         struct ndr_push *push;
 549         enum ndr_err_code ndr_err;
 550         DATA_BLOB blob;
 551         struct lsa_QueryInfoPolicy *r;
 552
 553         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYINFOPOLICY];
 554
 555         r = talloc(talloc_tos(), struct lsa_QueryInfoPolicy);
 556         if (r == NULL) {
 557                 return false;
 558         }
 559
 560         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 561                 talloc_free(r);
 562                 return false;
 563         }
 564
 565         pull = ndr_pull_init_blob(&blob, r, NULL);
 566         if (pull == NULL) {
 567                 talloc_free(r);
 568                 return false;
 569         }
 570
 571         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 572         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 573         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 574                 talloc_free(r);
 575                 return false;
 576         }
 577
 578         if (DEBUGLEVEL >= 10) {
 579                 NDR_PRINT_IN_DEBUG(lsa_QueryInfoPolicy, r);
 580         }
 581
 582         ZERO_STRUCT(r->out);
 583         r->out.info = talloc_zero(r, union lsa_PolicyInformation *);
 584         if (r->out.info == NULL) {
 585                 talloc_free(r);
 586                 return false;
 587         }
 588
 589         r->out.result = _lsa_QueryInfoPolicy(p, r);
 590
 591         if (p->rng_fault_state) {
 592                 talloc_free(r);
 593                 /* Return true here, srv_pipe_hnd.c will take care */
 594                 return true;
 595         }
 596
 597         if (DEBUGLEVEL >= 10) {
 598                 NDR_PRINT_OUT_DEBUG(lsa_QueryInfoPolicy, r);
 599         }
 600
 601         push = ndr_push_init_ctx(r, NULL);
 602         if (push == NULL) {
 603                 talloc_free(r);
 604                 return false;
 605         }
 606
 607         ndr_err = call->ndr_push(push, NDR_OUT, r);
 608         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 609                 talloc_free(r);
 610                 return false;
 611         }
 612
 613         blob = ndr_push_blob(push);
 614         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 615                 talloc_free(r);
 616                 return false;
 617         }
 618
 619         talloc_free(r);
 620
 621         return true;
 622 }
 623
 624 static bool api_lsa_SetInfoPolicy(pipes_struct *p)
 625 {
 626         const struct ndr_interface_call *call;
 627         struct ndr_pull *pull;
 628         struct ndr_push *push;
 629         enum ndr_err_code ndr_err;
 630         DATA_BLOB blob;
 631         struct lsa_SetInfoPolicy *r;
 632
 633         call = &ndr_table_lsarpc.calls[NDR_LSA_SETINFOPOLICY];
 634
 635         r = talloc(talloc_tos(), struct lsa_SetInfoPolicy);
 636         if (r == NULL) {
 637                 return false;
 638         }
 639
 640         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 641                 talloc_free(r);
 642                 return false;
 643         }
 644
 645         pull = ndr_pull_init_blob(&blob, r, NULL);
 646         if (pull == NULL) {
 647                 talloc_free(r);
 648                 return false;
 649         }
 650
 651         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 652         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 653         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 654                 talloc_free(r);
 655                 return false;
 656         }
 657
 658         if (DEBUGLEVEL >= 10) {
 659                 NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy, r);
 660         }
 661
 662         r->out.result = _lsa_SetInfoPolicy(p, r);
 663
 664         if (p->rng_fault_state) {
 665                 talloc_free(r);
 666                 /* Return true here, srv_pipe_hnd.c will take care */
 667                 return true;
 668         }
 669
 670         if (DEBUGLEVEL >= 10) {
 671                 NDR_PRINT_OUT_DEBUG(lsa_SetInfoPolicy, r);
 672         }
 673
 674         push = ndr_push_init_ctx(r, NULL);
 675         if (push == NULL) {
 676                 talloc_free(r);
 677                 return false;
 678         }
 679
 680         ndr_err = call->ndr_push(push, NDR_OUT, r);
 681         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 682                 talloc_free(r);
 683                 return false;
 684         }
 685
 686         blob = ndr_push_blob(push);
 687         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 688                 talloc_free(r);
 689                 return false;
 690         }
 691
 692         talloc_free(r);
 693
 694         return true;
 695 }
 696
 697 static bool api_lsa_ClearAuditLog(pipes_struct *p)
 698 {
 699         const struct ndr_interface_call *call;
 700         struct ndr_pull *pull;
 701         struct ndr_push *push;
 702         enum ndr_err_code ndr_err;
 703         DATA_BLOB blob;
 704         struct lsa_ClearAuditLog *r;
 705
 706         call = &ndr_table_lsarpc.calls[NDR_LSA_CLEARAUDITLOG];
 707
 708         r = talloc(talloc_tos(), struct lsa_ClearAuditLog);
 709         if (r == NULL) {
 710                 return false;
 711         }
 712
 713         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 714                 talloc_free(r);
 715                 return false;
 716         }
 717
 718         pull = ndr_pull_init_blob(&blob, r, NULL);
 719         if (pull == NULL) {
 720                 talloc_free(r);
 721                 return false;
 722         }
 723
 724         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 725         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 726         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 727                 talloc_free(r);
 728                 return false;
 729         }
 730
 731         if (DEBUGLEVEL >= 10) {
 732                 NDR_PRINT_IN_DEBUG(lsa_ClearAuditLog, r);
 733         }
 734
 735         r->out.result = _lsa_ClearAuditLog(p, r);
 736
 737         if (p->rng_fault_state) {
 738                 talloc_free(r);
 739                 /* Return true here, srv_pipe_hnd.c will take care */
 740                 return true;
 741         }
 742
 743         if (DEBUGLEVEL >= 10) {
 744                 NDR_PRINT_OUT_DEBUG(lsa_ClearAuditLog, r);
 745         }
 746
 747         push = ndr_push_init_ctx(r, NULL);
 748         if (push == NULL) {
 749                 talloc_free(r);
 750                 return false;
 751         }
 752
 753         ndr_err = call->ndr_push(push, NDR_OUT, r);
 754         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 755                 talloc_free(r);
 756                 return false;
 757         }
 758
 759         blob = ndr_push_blob(push);
 760         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 761                 talloc_free(r);
 762                 return false;
 763         }
 764
 765         talloc_free(r);
 766
 767         return true;
 768 }
 769
 770 static bool api_lsa_CreateAccount(pipes_struct *p)
 771 {
 772         const struct ndr_interface_call *call;
 773         struct ndr_pull *pull;
 774         struct ndr_push *push;
 775         enum ndr_err_code ndr_err;
 776         DATA_BLOB blob;
 777         struct lsa_CreateAccount *r;
 778
 779         call = &ndr_table_lsarpc.calls[NDR_LSA_CREATEACCOUNT];
 780
 781         r = talloc(talloc_tos(), struct lsa_CreateAccount);
 782         if (r == NULL) {
 783                 return false;
 784         }
 785
 786         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 787                 talloc_free(r);
 788                 return false;
 789         }
 790
 791         pull = ndr_pull_init_blob(&blob, r, NULL);
 792         if (pull == NULL) {
 793                 talloc_free(r);
 794                 return false;
 795         }
 796
 797         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 798         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 799         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 800                 talloc_free(r);
 801                 return false;
 802         }
 803
 804         if (DEBUGLEVEL >= 10) {
 805                 NDR_PRINT_IN_DEBUG(lsa_CreateAccount, r);
 806         }
 807
 808         ZERO_STRUCT(r->out);
 809         r->out.acct_handle = talloc_zero(r, struct policy_handle);
 810         if (r->out.acct_handle == NULL) {
 811                 talloc_free(r);
 812                 return false;
 813         }
 814
 815         r->out.result = _lsa_CreateAccount(p, r);
 816
 817         if (p->rng_fault_state) {
 818                 talloc_free(r);
 819                 /* Return true here, srv_pipe_hnd.c will take care */
 820                 return true;
 821         }
 822
 823         if (DEBUGLEVEL >= 10) {
 824                 NDR_PRINT_OUT_DEBUG(lsa_CreateAccount, r);
 825         }
 826
 827         push = ndr_push_init_ctx(r, NULL);
 828         if (push == NULL) {
 829                 talloc_free(r);
 830                 return false;
 831         }
 832
 833         ndr_err = call->ndr_push(push, NDR_OUT, r);
 834         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 835                 talloc_free(r);
 836                 return false;
 837         }
 838
 839         blob = ndr_push_blob(push);
 840         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 841                 talloc_free(r);
 842                 return false;
 843         }
 844
 845         talloc_free(r);
 846
 847         return true;
 848 }
 849
 850 static bool api_lsa_EnumAccounts(pipes_struct *p)
 851 {
 852         const struct ndr_interface_call *call;
 853         struct ndr_pull *pull;
 854         struct ndr_push *push;
 855         enum ndr_err_code ndr_err;
 856         DATA_BLOB blob;
 857         struct lsa_EnumAccounts *r;
 858
 859         call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMACCOUNTS];
 860
 861         r = talloc(talloc_tos(), struct lsa_EnumAccounts);
 862         if (r == NULL) {
 863                 return false;
 864         }
 865
 866         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 867                 talloc_free(r);
 868                 return false;
 869         }
 870
 871         pull = ndr_pull_init_blob(&blob, r, NULL);
 872         if (pull == NULL) {
 873                 talloc_free(r);
 874                 return false;
 875         }
 876
 877         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 878         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 879         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 880                 talloc_free(r);
 881                 return false;
 882         }
 883
 884         if (DEBUGLEVEL >= 10) {
 885                 NDR_PRINT_IN_DEBUG(lsa_EnumAccounts, r);
 886         }
 887
 888         ZERO_STRUCT(r->out);
 889         r->out.resume_handle = r->in.resume_handle;
 890         r->out.sids = talloc_zero(r, struct lsa_SidArray);
 891         if (r->out.sids == NULL) {
 892                 talloc_free(r);
 893                 return false;
 894         }
 895
 896         r->out.result = _lsa_EnumAccounts(p, r);
 897
 898         if (p->rng_fault_state) {
 899                 talloc_free(r);
 900                 /* Return true here, srv_pipe_hnd.c will take care */
 901                 return true;
 902         }
 903
 904         if (DEBUGLEVEL >= 10) {
 905                 NDR_PRINT_OUT_DEBUG(lsa_EnumAccounts, r);
 906         }
 907
 908         push = ndr_push_init_ctx(r, NULL);
 909         if (push == NULL) {
 910                 talloc_free(r);
 911                 return false;
 912         }
 913
 914         ndr_err = call->ndr_push(push, NDR_OUT, r);
 915         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 916                 talloc_free(r);
 917                 return false;
 918         }
 919
 920         blob = ndr_push_blob(push);
 921         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 922                 talloc_free(r);
 923                 return false;
 924         }
 925
 926         talloc_free(r);
 927
 928         return true;
 929 }
 930
 931 static bool api_lsa_CreateTrustedDomain(pipes_struct *p)
 932 {
 933         const struct ndr_interface_call *call;
 934         struct ndr_pull *pull;
 935         struct ndr_push *push;
 936         enum ndr_err_code ndr_err;
 937         DATA_BLOB blob;
 938         struct lsa_CreateTrustedDomain *r;
 939
 940         call = &ndr_table_lsarpc.calls[NDR_LSA_CREATETRUSTEDDOMAIN];
 941
 942         r = talloc(talloc_tos(), struct lsa_CreateTrustedDomain);
 943         if (r == NULL) {
 944                 return false;
 945         }
 946
 947         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 948                 talloc_free(r);
 949                 return false;
 950         }
 951
 952         pull = ndr_pull_init_blob(&blob, r, NULL);
 953         if (pull == NULL) {
 954                 talloc_free(r);
 955                 return false;
 956         }
 957
 958         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 959         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 960         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 961                 talloc_free(r);
 962                 return false;
 963         }
 964
 965         if (DEBUGLEVEL >= 10) {
 966                 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomain, r);
 967         }
 968
 969         ZERO_STRUCT(r->out);
 970         r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
 971         if (r->out.trustdom_handle == NULL) {
 972                 talloc_free(r);
 973                 return false;
 974         }
 975
 976         r->out.result = _lsa_CreateTrustedDomain(p, r);
 977
 978         if (p->rng_fault_state) {
 979                 talloc_free(r);
 980                 /* Return true here, srv_pipe_hnd.c will take care */
 981                 return true;
 982         }
 983
 984         if (DEBUGLEVEL >= 10) {
 985                 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomain, r);
 986         }
 987
 988         push = ndr_push_init_ctx(r, NULL);
 989         if (push == NULL) {
 990                 talloc_free(r);
 991                 return false;
 992         }
 993
 994         ndr_err = call->ndr_push(push, NDR_OUT, r);
 995         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 996                 talloc_free(r);
 997                 return false;
 998         }
 999
1000         blob = ndr_push_blob(push);
1001         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1002                 talloc_free(r);
1003                 return false;
1004         }
1005
1006         talloc_free(r);
1007
1008         return true;
1009 }
1010
1011 static bool api_lsa_EnumTrustDom(pipes_struct *p)
1012 {
1013         const struct ndr_interface_call *call;
1014         struct ndr_pull *pull;
1015         struct ndr_push *push;
1016         enum ndr_err_code ndr_err;
1017         DATA_BLOB blob;
1018         struct lsa_EnumTrustDom *r;
1019
1020         call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMTRUSTDOM];
1021
1022         r = talloc(talloc_tos(), struct lsa_EnumTrustDom);
1023         if (r == NULL) {
1024                 return false;
1025         }
1026
1027         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1028                 talloc_free(r);
1029                 return false;
1030         }
1031
1032         pull = ndr_pull_init_blob(&blob, r, NULL);
1033         if (pull == NULL) {
1034                 talloc_free(r);
1035                 return false;
1036         }
1037
1038         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1039         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1040         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1041                 talloc_free(r);
1042                 return false;
1043         }
1044
1045         if (DEBUGLEVEL >= 10) {
1046                 NDR_PRINT_IN_DEBUG(lsa_EnumTrustDom, r);
1047         }
1048
1049         ZERO_STRUCT(r->out);
1050         r->out.resume_handle = r->in.resume_handle;
1051         r->out.domains = talloc_zero(r, struct lsa_DomainList);
1052         if (r->out.domains == NULL) {
1053                 talloc_free(r);
1054                 return false;
1055         }
1056
1057         r->out.result = _lsa_EnumTrustDom(p, r);
1058
1059         if (p->rng_fault_state) {
1060                 talloc_free(r);
1061                 /* Return true here, srv_pipe_hnd.c will take care */
1062                 return true;
1063         }
1064
1065         if (DEBUGLEVEL >= 10) {
1066                 NDR_PRINT_OUT_DEBUG(lsa_EnumTrustDom, r);
1067         }
1068
1069         push = ndr_push_init_ctx(r, NULL);
1070         if (push == NULL) {
1071                 talloc_free(r);
1072                 return false;
1073         }
1074
1075         ndr_err = call->ndr_push(push, NDR_OUT, r);
1076         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1077                 talloc_free(r);
1078                 return false;
1079         }
1080
1081         blob = ndr_push_blob(push);
1082         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1083                 talloc_free(r);
1084                 return false;
1085         }
1086
1087         talloc_free(r);
1088
1089         return true;
1090 }
1091
1092 static bool api_lsa_LookupNames(pipes_struct *p)
1093 {
1094         const struct ndr_interface_call *call;
1095         struct ndr_pull *pull;
1096         struct ndr_push *push;
1097         enum ndr_err_code ndr_err;
1098         DATA_BLOB blob;
1099         struct lsa_LookupNames *r;
1100
1101         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPNAMES];
1102
1103         r = talloc(talloc_tos(), struct lsa_LookupNames);
1104         if (r == NULL) {
1105                 return false;
1106         }
1107
1108         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1109                 talloc_free(r);
1110                 return false;
1111         }
1112
1113         pull = ndr_pull_init_blob(&blob, r, NULL);
1114         if (pull == NULL) {
1115                 talloc_free(r);
1116                 return false;
1117         }
1118
1119         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1120         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1121         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1122                 talloc_free(r);
1123                 return false;
1124         }
1125
1126         if (DEBUGLEVEL >= 10) {
1127                 NDR_PRINT_IN_DEBUG(lsa_LookupNames, r);
1128         }
1129
1130         ZERO_STRUCT(r->out);
1131         r->out.sids = r->in.sids;
1132         r->out.count = r->in.count;
1133         r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
1134         if (r->out.domains == NULL) {
1135                 talloc_free(r);
1136                 return false;
1137         }
1138
1139         r->out.result = _lsa_LookupNames(p, r);
1140
1141         if (p->rng_fault_state) {
1142                 talloc_free(r);
1143                 /* Return true here, srv_pipe_hnd.c will take care */
1144                 return true;
1145         }
1146
1147         if (DEBUGLEVEL >= 10) {
1148                 NDR_PRINT_OUT_DEBUG(lsa_LookupNames, r);
1149         }
1150
1151         push = ndr_push_init_ctx(r, NULL);
1152         if (push == NULL) {
1153                 talloc_free(r);
1154                 return false;
1155         }
1156
1157         ndr_err = call->ndr_push(push, NDR_OUT, r);
1158         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1159                 talloc_free(r);
1160                 return false;
1161         }
1162
1163         blob = ndr_push_blob(push);
1164         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1165                 talloc_free(r);
1166                 return false;
1167         }
1168
1169         talloc_free(r);
1170
1171         return true;
1172 }
1173
1174 static bool api_lsa_LookupSids(pipes_struct *p)
1175 {
1176         const struct ndr_interface_call *call;
1177         struct ndr_pull *pull;
1178         struct ndr_push *push;
1179         enum ndr_err_code ndr_err;
1180         DATA_BLOB blob;
1181         struct lsa_LookupSids *r;
1182
1183         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPSIDS];
1184
1185         r = talloc(talloc_tos(), struct lsa_LookupSids);
1186         if (r == NULL) {
1187                 return false;
1188         }
1189
1190         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1191                 talloc_free(r);
1192                 return false;
1193         }
1194
1195         pull = ndr_pull_init_blob(&blob, r, NULL);
1196         if (pull == NULL) {
1197                 talloc_free(r);
1198                 return false;
1199         }
1200
1201         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1202         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1203         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1204                 talloc_free(r);
1205                 return false;
1206         }
1207
1208         if (DEBUGLEVEL >= 10) {
1209                 NDR_PRINT_IN_DEBUG(lsa_LookupSids, r);
1210         }
1211
1212         ZERO_STRUCT(r->out);
1213         r->out.names = r->in.names;
1214         r->out.count = r->in.count;
1215         r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
1216         if (r->out.domains == NULL) {
1217                 talloc_free(r);
1218                 return false;
1219         }
1220
1221         r->out.result = _lsa_LookupSids(p, r);
1222
1223         if (p->rng_fault_state) {
1224                 talloc_free(r);
1225                 /* Return true here, srv_pipe_hnd.c will take care */
1226                 return true;
1227         }
1228
1229         if (DEBUGLEVEL >= 10) {
1230                 NDR_PRINT_OUT_DEBUG(lsa_LookupSids, r);
1231         }
1232
1233         push = ndr_push_init_ctx(r, NULL);
1234         if (push == NULL) {
1235                 talloc_free(r);
1236                 return false;
1237         }
1238
1239         ndr_err = call->ndr_push(push, NDR_OUT, r);
1240         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1241                 talloc_free(r);
1242                 return false;
1243         }
1244
1245         blob = ndr_push_blob(push);
1246         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1247                 talloc_free(r);
1248                 return false;
1249         }
1250
1251         talloc_free(r);
1252
1253         return true;
1254 }
1255
1256 static bool api_lsa_CreateSecret(pipes_struct *p)
1257 {
1258         const struct ndr_interface_call *call;
1259         struct ndr_pull *pull;
1260         struct ndr_push *push;
1261         enum ndr_err_code ndr_err;
1262         DATA_BLOB blob;
1263         struct lsa_CreateSecret *r;
1264
1265         call = &ndr_table_lsarpc.calls[NDR_LSA_CREATESECRET];
1266
1267         r = talloc(talloc_tos(), struct lsa_CreateSecret);
1268         if (r == NULL) {
1269                 return false;
1270         }
1271
1272         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1273                 talloc_free(r);
1274                 return false;
1275         }
1276
1277         pull = ndr_pull_init_blob(&blob, r, NULL);
1278         if (pull == NULL) {
1279                 talloc_free(r);
1280                 return false;
1281         }
1282
1283         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1284         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1285         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1286                 talloc_free(r);
1287                 return false;
1288         }
1289
1290         if (DEBUGLEVEL >= 10) {
1291                 NDR_PRINT_IN_DEBUG(lsa_CreateSecret, r);
1292         }
1293
1294         ZERO_STRUCT(r->out);
1295         r->out.sec_handle = talloc_zero(r, struct policy_handle);
1296         if (r->out.sec_handle == NULL) {
1297                 talloc_free(r);
1298                 return false;
1299         }
1300
1301         r->out.result = _lsa_CreateSecret(p, r);
1302
1303         if (p->rng_fault_state) {
1304                 talloc_free(r);
1305                 /* Return true here, srv_pipe_hnd.c will take care */
1306                 return true;
1307         }
1308
1309         if (DEBUGLEVEL >= 10) {
1310                 NDR_PRINT_OUT_DEBUG(lsa_CreateSecret, r);
1311         }
1312
1313         push = ndr_push_init_ctx(r, NULL);
1314         if (push == NULL) {
1315                 talloc_free(r);
1316                 return false;
1317         }
1318
1319         ndr_err = call->ndr_push(push, NDR_OUT, r);
1320         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1321                 talloc_free(r);
1322                 return false;
1323         }
1324
1325         blob = ndr_push_blob(push);
1326         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1327                 talloc_free(r);
1328                 return false;
1329         }
1330
1331         talloc_free(r);
1332
1333         return true;
1334 }
1335
1336 static bool api_lsa_OpenAccount(pipes_struct *p)
1337 {
1338         const struct ndr_interface_call *call;
1339         struct ndr_pull *pull;
1340         struct ndr_push *push;
1341         enum ndr_err_code ndr_err;
1342         DATA_BLOB blob;
1343         struct lsa_OpenAccount *r;
1344
1345         call = &ndr_table_lsarpc.calls[NDR_LSA_OPENACCOUNT];
1346
1347         r = talloc(talloc_tos(), struct lsa_OpenAccount);
1348         if (r == NULL) {
1349                 return false;
1350         }
1351
1352         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1353                 talloc_free(r);
1354                 return false;
1355         }
1356
1357         pull = ndr_pull_init_blob(&blob, r, NULL);
1358         if (pull == NULL) {
1359                 talloc_free(r);
1360                 return false;
1361         }
1362
1363         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1364         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1365         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1366                 talloc_free(r);
1367                 return false;
1368         }
1369
1370         if (DEBUGLEVEL >= 10) {
1371                 NDR_PRINT_IN_DEBUG(lsa_OpenAccount, r);
1372         }
1373
1374         ZERO_STRUCT(r->out);
1375         r->out.acct_handle = talloc_zero(r, struct policy_handle);
1376         if (r->out.acct_handle == NULL) {
1377                 talloc_free(r);
1378                 return false;
1379         }
1380
1381         r->out.result = _lsa_OpenAccount(p, r);
1382
1383         if (p->rng_fault_state) {
1384                 talloc_free(r);
1385                 /* Return true here, srv_pipe_hnd.c will take care */
1386                 return true;
1387         }
1388
1389         if (DEBUGLEVEL >= 10) {
1390                 NDR_PRINT_OUT_DEBUG(lsa_OpenAccount, r);
1391         }
1392
1393         push = ndr_push_init_ctx(r, NULL);
1394         if (push == NULL) {
1395                 talloc_free(r);
1396                 return false;
1397         }
1398
1399         ndr_err = call->ndr_push(push, NDR_OUT, r);
1400         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1401                 talloc_free(r);
1402                 return false;
1403         }
1404
1405         blob = ndr_push_blob(push);
1406         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1407                 talloc_free(r);
1408                 return false;
1409         }
1410
1411         talloc_free(r);
1412
1413         return true;
1414 }
1415
1416 static bool api_lsa_EnumPrivsAccount(pipes_struct *p)
1417 {
1418         const struct ndr_interface_call *call;
1419         struct ndr_pull *pull;
1420         struct ndr_push *push;
1421         enum ndr_err_code ndr_err;
1422         DATA_BLOB blob;
1423         struct lsa_EnumPrivsAccount *r;
1424
1425         call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMPRIVSACCOUNT];
1426
1427         r = talloc(talloc_tos(), struct lsa_EnumPrivsAccount);
1428         if (r == NULL) {
1429                 return false;
1430         }
1431
1432         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1433                 talloc_free(r);
1434                 return false;
1435         }
1436
1437         pull = ndr_pull_init_blob(&blob, r, NULL);
1438         if (pull == NULL) {
1439                 talloc_free(r);
1440                 return false;
1441         }
1442
1443         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1444         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1445         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1446                 talloc_free(r);
1447                 return false;
1448         }
1449
1450         if (DEBUGLEVEL >= 10) {
1451                 NDR_PRINT_IN_DEBUG(lsa_EnumPrivsAccount, r);
1452         }
1453
1454         ZERO_STRUCT(r->out);
1455         r->out.privs = talloc_zero(r, struct lsa_PrivilegeSet *);
1456         if (r->out.privs == NULL) {
1457                 talloc_free(r);
1458                 return false;
1459         }
1460
1461         r->out.result = _lsa_EnumPrivsAccount(p, r);
1462
1463         if (p->rng_fault_state) {
1464                 talloc_free(r);
1465                 /* Return true here, srv_pipe_hnd.c will take care */
1466                 return true;
1467         }
1468
1469         if (DEBUGLEVEL >= 10) {
1470                 NDR_PRINT_OUT_DEBUG(lsa_EnumPrivsAccount, r);
1471         }
1472
1473         push = ndr_push_init_ctx(r, NULL);
1474         if (push == NULL) {
1475                 talloc_free(r);
1476                 return false;
1477         }
1478
1479         ndr_err = call->ndr_push(push, NDR_OUT, r);
1480         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1481                 talloc_free(r);
1482                 return false;
1483         }
1484
1485         blob = ndr_push_blob(push);
1486         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1487                 talloc_free(r);
1488                 return false;
1489         }
1490
1491         talloc_free(r);
1492
1493         return true;
1494 }
1495
1496 static bool api_lsa_AddPrivilegesToAccount(pipes_struct *p)
1497 {
1498         const struct ndr_interface_call *call;
1499         struct ndr_pull *pull;
1500         struct ndr_push *push;
1501         enum ndr_err_code ndr_err;
1502         DATA_BLOB blob;
1503         struct lsa_AddPrivilegesToAccount *r;
1504
1505         call = &ndr_table_lsarpc.calls[NDR_LSA_ADDPRIVILEGESTOACCOUNT];
1506
1507         r = talloc(talloc_tos(), struct lsa_AddPrivilegesToAccount);
1508         if (r == NULL) {
1509                 return false;
1510         }
1511
1512         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1513                 talloc_free(r);
1514                 return false;
1515         }
1516
1517         pull = ndr_pull_init_blob(&blob, r, NULL);
1518         if (pull == NULL) {
1519                 talloc_free(r);
1520                 return false;
1521         }
1522
1523         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1524         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1525         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1526                 talloc_free(r);
1527                 return false;
1528         }
1529
1530         if (DEBUGLEVEL >= 10) {
1531                 NDR_PRINT_IN_DEBUG(lsa_AddPrivilegesToAccount, r);
1532         }
1533
1534         r->out.result = _lsa_AddPrivilegesToAccount(p, r);
1535
1536         if (p->rng_fault_state) {
1537                 talloc_free(r);
1538                 /* Return true here, srv_pipe_hnd.c will take care */
1539                 return true;
1540         }
1541
1542         if (DEBUGLEVEL >= 10) {
1543                 NDR_PRINT_OUT_DEBUG(lsa_AddPrivilegesToAccount, r);
1544         }
1545
1546         push = ndr_push_init_ctx(r, NULL);
1547         if (push == NULL) {
1548                 talloc_free(r);
1549                 return false;
1550         }
1551
1552         ndr_err = call->ndr_push(push, NDR_OUT, r);
1553         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1554                 talloc_free(r);
1555                 return false;
1556         }
1557
1558         blob = ndr_push_blob(push);
1559         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1560                 talloc_free(r);
1561                 return false;
1562         }
1563
1564         talloc_free(r);
1565
1566         return true;
1567 }
1568
1569 static bool api_lsa_RemovePrivilegesFromAccount(pipes_struct *p)
1570 {
1571         const struct ndr_interface_call *call;
1572         struct ndr_pull *pull;
1573         struct ndr_push *push;
1574         enum ndr_err_code ndr_err;
1575         DATA_BLOB blob;
1576         struct lsa_RemovePrivilegesFromAccount *r;
1577
1578         call = &ndr_table_lsarpc.calls[NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT];
1579
1580         r = talloc(talloc_tos(), struct lsa_RemovePrivilegesFromAccount);
1581         if (r == NULL) {
1582                 return false;
1583         }
1584
1585         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1586                 talloc_free(r);
1587                 return false;
1588         }
1589
1590         pull = ndr_pull_init_blob(&blob, r, NULL);
1591         if (pull == NULL) {
1592                 talloc_free(r);
1593                 return false;
1594         }
1595
1596         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1597         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1598         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1599                 talloc_free(r);
1600                 return false;
1601         }
1602
1603         if (DEBUGLEVEL >= 10) {
1604                 NDR_PRINT_IN_DEBUG(lsa_RemovePrivilegesFromAccount, r);
1605         }
1606
1607         r->out.result = _lsa_RemovePrivilegesFromAccount(p, r);
1608
1609         if (p->rng_fault_state) {
1610                 talloc_free(r);
1611                 /* Return true here, srv_pipe_hnd.c will take care */
1612                 return true;
1613         }
1614
1615         if (DEBUGLEVEL >= 10) {
1616                 NDR_PRINT_OUT_DEBUG(lsa_RemovePrivilegesFromAccount, r);
1617         }
1618
1619         push = ndr_push_init_ctx(r, NULL);
1620         if (push == NULL) {
1621                 talloc_free(r);
1622                 return false;
1623         }
1624
1625         ndr_err = call->ndr_push(push, NDR_OUT, r);
1626         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1627                 talloc_free(r);
1628                 return false;
1629         }
1630
1631         blob = ndr_push_blob(push);
1632         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1633                 talloc_free(r);
1634                 return false;
1635         }
1636
1637         talloc_free(r);
1638
1639         return true;
1640 }
1641
1642 static bool api_lsa_GetQuotasForAccount(pipes_struct *p)
1643 {
1644         const struct ndr_interface_call *call;
1645         struct ndr_pull *pull;
1646         struct ndr_push *push;
1647         enum ndr_err_code ndr_err;
1648         DATA_BLOB blob;
1649         struct lsa_GetQuotasForAccount *r;
1650
1651         call = &ndr_table_lsarpc.calls[NDR_LSA_GETQUOTASFORACCOUNT];
1652
1653         r = talloc(talloc_tos(), struct lsa_GetQuotasForAccount);
1654         if (r == NULL) {
1655                 return false;
1656         }
1657
1658         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1659                 talloc_free(r);
1660                 return false;
1661         }
1662
1663         pull = ndr_pull_init_blob(&blob, r, NULL);
1664         if (pull == NULL) {
1665                 talloc_free(r);
1666                 return false;
1667         }
1668
1669         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1670         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1671         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1672                 talloc_free(r);
1673                 return false;
1674         }
1675
1676         if (DEBUGLEVEL >= 10) {
1677                 NDR_PRINT_IN_DEBUG(lsa_GetQuotasForAccount, r);
1678         }
1679
1680         r->out.result = _lsa_GetQuotasForAccount(p, r);
1681
1682         if (p->rng_fault_state) {
1683                 talloc_free(r);
1684                 /* Return true here, srv_pipe_hnd.c will take care */
1685                 return true;
1686         }
1687
1688         if (DEBUGLEVEL >= 10) {
1689                 NDR_PRINT_OUT_DEBUG(lsa_GetQuotasForAccount, r);
1690         }
1691
1692         push = ndr_push_init_ctx(r, NULL);
1693         if (push == NULL) {
1694                 talloc_free(r);
1695                 return false;
1696         }
1697
1698         ndr_err = call->ndr_push(push, NDR_OUT, r);
1699         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1700                 talloc_free(r);
1701                 return false;
1702         }
1703
1704         blob = ndr_push_blob(push);
1705         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1706                 talloc_free(r);
1707                 return false;
1708         }
1709
1710         talloc_free(r);
1711
1712         return true;
1713 }
1714
1715 static bool api_lsa_SetQuotasForAccount(pipes_struct *p)
1716 {
1717         const struct ndr_interface_call *call;
1718         struct ndr_pull *pull;
1719         struct ndr_push *push;
1720         enum ndr_err_code ndr_err;
1721         DATA_BLOB blob;
1722         struct lsa_SetQuotasForAccount *r;
1723
1724         call = &ndr_table_lsarpc.calls[NDR_LSA_SETQUOTASFORACCOUNT];
1725
1726         r = talloc(talloc_tos(), struct lsa_SetQuotasForAccount);
1727         if (r == NULL) {
1728                 return false;
1729         }
1730
1731         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1732                 talloc_free(r);
1733                 return false;
1734         }
1735
1736         pull = ndr_pull_init_blob(&blob, r, NULL);
1737         if (pull == NULL) {
1738                 talloc_free(r);
1739                 return false;
1740         }
1741
1742         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1743         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1744         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1745                 talloc_free(r);
1746                 return false;
1747         }
1748
1749         if (DEBUGLEVEL >= 10) {
1750                 NDR_PRINT_IN_DEBUG(lsa_SetQuotasForAccount, r);
1751         }
1752
1753         r->out.result = _lsa_SetQuotasForAccount(p, r);
1754
1755         if (p->rng_fault_state) {
1756                 talloc_free(r);
1757                 /* Return true here, srv_pipe_hnd.c will take care */
1758                 return true;
1759         }
1760
1761         if (DEBUGLEVEL >= 10) {
1762                 NDR_PRINT_OUT_DEBUG(lsa_SetQuotasForAccount, r);
1763         }
1764
1765         push = ndr_push_init_ctx(r, NULL);
1766         if (push == NULL) {
1767                 talloc_free(r);
1768                 return false;
1769         }
1770
1771         ndr_err = call->ndr_push(push, NDR_OUT, r);
1772         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1773                 talloc_free(r);
1774                 return false;
1775         }
1776
1777         blob = ndr_push_blob(push);
1778         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1779                 talloc_free(r);
1780                 return false;
1781         }
1782
1783         talloc_free(r);
1784
1785         return true;
1786 }
1787
1788 static bool api_lsa_GetSystemAccessAccount(pipes_struct *p)
1789 {
1790         const struct ndr_interface_call *call;
1791         struct ndr_pull *pull;
1792         struct ndr_push *push;
1793         enum ndr_err_code ndr_err;
1794         DATA_BLOB blob;
1795         struct lsa_GetSystemAccessAccount *r;
1796
1797         call = &ndr_table_lsarpc.calls[NDR_LSA_GETSYSTEMACCESSACCOUNT];
1798
1799         r = talloc(talloc_tos(), struct lsa_GetSystemAccessAccount);
1800         if (r == NULL) {
1801                 return false;
1802         }
1803
1804         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1805                 talloc_free(r);
1806                 return false;
1807         }
1808
1809         pull = ndr_pull_init_blob(&blob, r, NULL);
1810         if (pull == NULL) {
1811                 talloc_free(r);
1812                 return false;
1813         }
1814
1815         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1816         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1817         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1818                 talloc_free(r);
1819                 return false;
1820         }
1821
1822         if (DEBUGLEVEL >= 10) {
1823                 NDR_PRINT_IN_DEBUG(lsa_GetSystemAccessAccount, r);
1824         }
1825
1826         ZERO_STRUCT(r->out);
1827         r->out.access_mask = talloc_zero(r, uint32_t);
1828         if (r->out.access_mask == NULL) {
1829                 talloc_free(r);
1830                 return false;
1831         }
1832
1833         r->out.result = _lsa_GetSystemAccessAccount(p, r);
1834
1835         if (p->rng_fault_state) {
1836                 talloc_free(r);
1837                 /* Return true here, srv_pipe_hnd.c will take care */
1838                 return true;
1839         }
1840
1841         if (DEBUGLEVEL >= 10) {
1842                 NDR_PRINT_OUT_DEBUG(lsa_GetSystemAccessAccount, r);
1843         }
1844
1845         push = ndr_push_init_ctx(r, NULL);
1846         if (push == NULL) {
1847                 talloc_free(r);
1848                 return false;
1849         }
1850
1851         ndr_err = call->ndr_push(push, NDR_OUT, r);
1852         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1853                 talloc_free(r);
1854                 return false;
1855         }
1856
1857         blob = ndr_push_blob(push);
1858         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1859                 talloc_free(r);
1860                 return false;
1861         }
1862
1863         talloc_free(r);
1864
1865         return true;
1866 }
1867
1868 static bool api_lsa_SetSystemAccessAccount(pipes_struct *p)
1869 {
1870         const struct ndr_interface_call *call;
1871         struct ndr_pull *pull;
1872         struct ndr_push *push;
1873         enum ndr_err_code ndr_err;
1874         DATA_BLOB blob;
1875         struct lsa_SetSystemAccessAccount *r;
1876
1877         call = &ndr_table_lsarpc.calls[NDR_LSA_SETSYSTEMACCESSACCOUNT];
1878
1879         r = talloc(talloc_tos(), struct lsa_SetSystemAccessAccount);
1880         if (r == NULL) {
1881                 return false;
1882         }
1883
1884         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1885                 talloc_free(r);
1886                 return false;
1887         }
1888
1889         pull = ndr_pull_init_blob(&blob, r, NULL);
1890         if (pull == NULL) {
1891                 talloc_free(r);
1892                 return false;
1893         }
1894
1895         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1896         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1897         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1898                 talloc_free(r);
1899                 return false;
1900         }
1901
1902         if (DEBUGLEVEL >= 10) {
1903                 NDR_PRINT_IN_DEBUG(lsa_SetSystemAccessAccount, r);
1904         }
1905
1906         r->out.result = _lsa_SetSystemAccessAccount(p, r);
1907
1908         if (p->rng_fault_state) {
1909                 talloc_free(r);
1910                 /* Return true here, srv_pipe_hnd.c will take care */
1911                 return true;
1912         }
1913
1914         if (DEBUGLEVEL >= 10) {
1915                 NDR_PRINT_OUT_DEBUG(lsa_SetSystemAccessAccount, r);
1916         }
1917
1918         push = ndr_push_init_ctx(r, NULL);
1919         if (push == NULL) {
1920                 talloc_free(r);
1921                 return false;
1922         }
1923
1924         ndr_err = call->ndr_push(push, NDR_OUT, r);
1925         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1926                 talloc_free(r);
1927                 return false;
1928         }
1929
1930         blob = ndr_push_blob(push);
1931         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1932                 talloc_free(r);
1933                 return false;
1934         }
1935
1936         talloc_free(r);
1937
1938         return true;
1939 }
1940
1941 static bool api_lsa_OpenTrustedDomain(pipes_struct *p)
1942 {
1943         const struct ndr_interface_call *call;
1944         struct ndr_pull *pull;
1945         struct ndr_push *push;
1946         enum ndr_err_code ndr_err;
1947         DATA_BLOB blob;
1948         struct lsa_OpenTrustedDomain *r;
1949
1950         call = &ndr_table_lsarpc.calls[NDR_LSA_OPENTRUSTEDDOMAIN];
1951
1952         r = talloc(talloc_tos(), struct lsa_OpenTrustedDomain);
1953         if (r == NULL) {
1954                 return false;
1955         }
1956
1957         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1958                 talloc_free(r);
1959                 return false;
1960         }
1961
1962         pull = ndr_pull_init_blob(&blob, r, NULL);
1963         if (pull == NULL) {
1964                 talloc_free(r);
1965                 return false;
1966         }
1967
1968         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1969         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1970         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1971                 talloc_free(r);
1972                 return false;
1973         }
1974
1975         if (DEBUGLEVEL >= 10) {
1976                 NDR_PRINT_IN_DEBUG(lsa_OpenTrustedDomain, r);
1977         }
1978
1979         ZERO_STRUCT(r->out);
1980         r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
1981         if (r->out.trustdom_handle == NULL) {
1982                 talloc_free(r);
1983                 return false;
1984         }
1985
1986         r->out.result = _lsa_OpenTrustedDomain(p, r);
1987
1988         if (p->rng_fault_state) {
1989                 talloc_free(r);
1990                 /* Return true here, srv_pipe_hnd.c will take care */
1991                 return true;
1992         }
1993
1994         if (DEBUGLEVEL >= 10) {
1995                 NDR_PRINT_OUT_DEBUG(lsa_OpenTrustedDomain, r);
1996         }
1997
1998         push = ndr_push_init_ctx(r, NULL);
1999         if (push == NULL) {
2000                 talloc_free(r);
2001                 return false;
2002         }
2003
2004         ndr_err = call->ndr_push(push, NDR_OUT, r);
2005         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2006                 talloc_free(r);
2007                 return false;
2008         }
2009
2010         blob = ndr_push_blob(push);
2011         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2012                 talloc_free(r);
2013                 return false;
2014         }
2015
2016         talloc_free(r);
2017
2018         return true;
2019 }
2020
2021 static bool api_lsa_QueryTrustedDomainInfo(pipes_struct *p)
2022 {
2023         const struct ndr_interface_call *call;
2024         struct ndr_pull *pull;
2025         struct ndr_push *push;
2026         enum ndr_err_code ndr_err;
2027         DATA_BLOB blob;
2028         struct lsa_QueryTrustedDomainInfo *r;
2029
2030         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYTRUSTEDDOMAININFO];
2031
2032         r = talloc(talloc_tos(), struct lsa_QueryTrustedDomainInfo);
2033         if (r == NULL) {
2034                 return false;
2035         }
2036
2037         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2038                 talloc_free(r);
2039                 return false;
2040         }
2041
2042         pull = ndr_pull_init_blob(&blob, r, NULL);
2043         if (pull == NULL) {
2044                 talloc_free(r);
2045                 return false;
2046         }
2047
2048         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2049         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2050         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2051                 talloc_free(r);
2052                 return false;
2053         }
2054
2055         if (DEBUGLEVEL >= 10) {
2056                 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfo, r);
2057         }
2058
2059         ZERO_STRUCT(r->out);
2060         r->out.info = talloc_zero(r, union lsa_TrustedDomainInfo *);
2061         if (r->out.info == NULL) {
2062                 talloc_free(r);
2063                 return false;
2064         }
2065
2066         r->out.result = _lsa_QueryTrustedDomainInfo(p, r);
2067
2068         if (p->rng_fault_state) {
2069                 talloc_free(r);
2070                 /* Return true here, srv_pipe_hnd.c will take care */
2071                 return true;
2072         }
2073
2074         if (DEBUGLEVEL >= 10) {
2075                 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfo, r);
2076         }
2077
2078         push = ndr_push_init_ctx(r, NULL);
2079         if (push == NULL) {
2080                 talloc_free(r);
2081                 return false;
2082         }
2083
2084         ndr_err = call->ndr_push(push, NDR_OUT, r);
2085         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2086                 talloc_free(r);
2087                 return false;
2088         }
2089
2090         blob = ndr_push_blob(push);
2091         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2092                 talloc_free(r);
2093                 return false;
2094         }
2095
2096         talloc_free(r);
2097
2098         return true;
2099 }
2100
2101 static bool api_lsa_SetInformationTrustedDomain(pipes_struct *p)
2102 {
2103         const struct ndr_interface_call *call;
2104         struct ndr_pull *pull;
2105         struct ndr_push *push;
2106         enum ndr_err_code ndr_err;
2107         DATA_BLOB blob;
2108         struct lsa_SetInformationTrustedDomain *r;
2109
2110         call = &ndr_table_lsarpc.calls[NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN];
2111
2112         r = talloc(talloc_tos(), struct lsa_SetInformationTrustedDomain);
2113         if (r == NULL) {
2114                 return false;
2115         }
2116
2117         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2118                 talloc_free(r);
2119                 return false;
2120         }
2121
2122         pull = ndr_pull_init_blob(&blob, r, NULL);
2123         if (pull == NULL) {
2124                 talloc_free(r);
2125                 return false;
2126         }
2127
2128         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2129         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2130         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2131                 talloc_free(r);
2132                 return false;
2133         }
2134
2135         if (DEBUGLEVEL >= 10) {
2136                 NDR_PRINT_IN_DEBUG(lsa_SetInformationTrustedDomain, r);
2137         }
2138
2139         r->out.result = _lsa_SetInformationTrustedDomain(p, r);
2140
2141         if (p->rng_fault_state) {
2142                 talloc_free(r);
2143                 /* Return true here, srv_pipe_hnd.c will take care */
2144                 return true;
2145         }
2146
2147         if (DEBUGLEVEL >= 10) {
2148                 NDR_PRINT_OUT_DEBUG(lsa_SetInformationTrustedDomain, r);
2149         }
2150
2151         push = ndr_push_init_ctx(r, NULL);
2152         if (push == NULL) {
2153                 talloc_free(r);
2154                 return false;
2155         }
2156
2157         ndr_err = call->ndr_push(push, NDR_OUT, r);
2158         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2159                 talloc_free(r);
2160                 return false;
2161         }
2162
2163         blob = ndr_push_blob(push);
2164         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2165                 talloc_free(r);
2166                 return false;
2167         }
2168
2169         talloc_free(r);
2170
2171         return true;
2172 }
2173
2174 static bool api_lsa_OpenSecret(pipes_struct *p)
2175 {
2176         const struct ndr_interface_call *call;
2177         struct ndr_pull *pull;
2178         struct ndr_push *push;
2179         enum ndr_err_code ndr_err;
2180         DATA_BLOB blob;
2181         struct lsa_OpenSecret *r;
2182
2183         call = &ndr_table_lsarpc.calls[NDR_LSA_OPENSECRET];
2184
2185         r = talloc(talloc_tos(), struct lsa_OpenSecret);
2186         if (r == NULL) {
2187                 return false;
2188         }
2189
2190         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2191                 talloc_free(r);
2192                 return false;
2193         }
2194
2195         pull = ndr_pull_init_blob(&blob, r, NULL);
2196         if (pull == NULL) {
2197                 talloc_free(r);
2198                 return false;
2199         }
2200
2201         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2202         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2203         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2204                 talloc_free(r);
2205                 return false;
2206         }
2207
2208         if (DEBUGLEVEL >= 10) {
2209                 NDR_PRINT_IN_DEBUG(lsa_OpenSecret, r);
2210         }
2211
2212         ZERO_STRUCT(r->out);
2213         r->out.sec_handle = talloc_zero(r, struct policy_handle);
2214         if (r->out.sec_handle == NULL) {
2215                 talloc_free(r);
2216                 return false;
2217         }
2218
2219         r->out.result = _lsa_OpenSecret(p, r);
2220
2221         if (p->rng_fault_state) {
2222                 talloc_free(r);
2223                 /* Return true here, srv_pipe_hnd.c will take care */
2224                 return true;
2225         }
2226
2227         if (DEBUGLEVEL >= 10) {
2228                 NDR_PRINT_OUT_DEBUG(lsa_OpenSecret, r);
2229         }
2230
2231         push = ndr_push_init_ctx(r, NULL);
2232         if (push == NULL) {
2233                 talloc_free(r);
2234                 return false;
2235         }
2236
2237         ndr_err = call->ndr_push(push, NDR_OUT, r);
2238         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2239                 talloc_free(r);
2240                 return false;
2241         }
2242
2243         blob = ndr_push_blob(push);
2244         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2245                 talloc_free(r);
2246                 return false;
2247         }
2248
2249         talloc_free(r);
2250
2251         return true;
2252 }
2253
2254 static bool api_lsa_SetSecret(pipes_struct *p)
2255 {
2256         const struct ndr_interface_call *call;
2257         struct ndr_pull *pull;
2258         struct ndr_push *push;
2259         enum ndr_err_code ndr_err;
2260         DATA_BLOB blob;
2261         struct lsa_SetSecret *r;
2262
2263         call = &ndr_table_lsarpc.calls[NDR_LSA_SETSECRET];
2264
2265         r = talloc(talloc_tos(), struct lsa_SetSecret);
2266         if (r == NULL) {
2267                 return false;
2268         }
2269
2270         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2271                 talloc_free(r);
2272                 return false;
2273         }
2274
2275         pull = ndr_pull_init_blob(&blob, r, NULL);
2276         if (pull == NULL) {
2277                 talloc_free(r);
2278                 return false;
2279         }
2280
2281         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2282         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2283         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2284                 talloc_free(r);
2285                 return false;
2286         }
2287
2288         if (DEBUGLEVEL >= 10) {
2289                 NDR_PRINT_IN_DEBUG(lsa_SetSecret, r);
2290         }
2291
2292         r->out.result = _lsa_SetSecret(p, r);
2293
2294         if (p->rng_fault_state) {
2295                 talloc_free(r);
2296                 /* Return true here, srv_pipe_hnd.c will take care */
2297                 return true;
2298         }
2299
2300         if (DEBUGLEVEL >= 10) {
2301                 NDR_PRINT_OUT_DEBUG(lsa_SetSecret, r);
2302         }
2303
2304         push = ndr_push_init_ctx(r, NULL);
2305         if (push == NULL) {
2306                 talloc_free(r);
2307                 return false;
2308         }
2309
2310         ndr_err = call->ndr_push(push, NDR_OUT, r);
2311         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2312                 talloc_free(r);
2313                 return false;
2314         }
2315
2316         blob = ndr_push_blob(push);
2317         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2318                 talloc_free(r);
2319                 return false;
2320         }
2321
2322         talloc_free(r);
2323
2324         return true;
2325 }
2326
2327 static bool api_lsa_QuerySecret(pipes_struct *p)
2328 {
2329         const struct ndr_interface_call *call;
2330         struct ndr_pull *pull;
2331         struct ndr_push *push;
2332         enum ndr_err_code ndr_err;
2333         DATA_BLOB blob;
2334         struct lsa_QuerySecret *r;
2335
2336         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYSECRET];
2337
2338         r = talloc(talloc_tos(), struct lsa_QuerySecret);
2339         if (r == NULL) {
2340                 return false;
2341         }
2342
2343         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2344                 talloc_free(r);
2345                 return false;
2346         }
2347
2348         pull = ndr_pull_init_blob(&blob, r, NULL);
2349         if (pull == NULL) {
2350                 talloc_free(r);
2351                 return false;
2352         }
2353
2354         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2355         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2356         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2357                 talloc_free(r);
2358                 return false;
2359         }
2360
2361         if (DEBUGLEVEL >= 10) {
2362                 NDR_PRINT_IN_DEBUG(lsa_QuerySecret, r);
2363         }
2364
2365         ZERO_STRUCT(r->out);
2366         r->out.new_val = r->in.new_val;
2367         r->out.new_mtime = r->in.new_mtime;
2368         r->out.old_val = r->in.old_val;
2369         r->out.old_mtime = r->in.old_mtime;
2370         r->out.result = _lsa_QuerySecret(p, r);
2371
2372         if (p->rng_fault_state) {
2373                 talloc_free(r);
2374                 /* Return true here, srv_pipe_hnd.c will take care */
2375                 return true;
2376         }
2377
2378         if (DEBUGLEVEL >= 10) {
2379                 NDR_PRINT_OUT_DEBUG(lsa_QuerySecret, r);
2380         }
2381
2382         push = ndr_push_init_ctx(r, NULL);
2383         if (push == NULL) {
2384                 talloc_free(r);
2385                 return false;
2386         }
2387
2388         ndr_err = call->ndr_push(push, NDR_OUT, r);
2389         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2390                 talloc_free(r);
2391                 return false;
2392         }
2393
2394         blob = ndr_push_blob(push);
2395         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2396                 talloc_free(r);
2397                 return false;
2398         }
2399
2400         talloc_free(r);
2401
2402         return true;
2403 }
2404
2405 static bool api_lsa_LookupPrivValue(pipes_struct *p)
2406 {
2407         const struct ndr_interface_call *call;
2408         struct ndr_pull *pull;
2409         struct ndr_push *push;
2410         enum ndr_err_code ndr_err;
2411         DATA_BLOB blob;
2412         struct lsa_LookupPrivValue *r;
2413
2414         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPPRIVVALUE];
2415
2416         r = talloc(talloc_tos(), struct lsa_LookupPrivValue);
2417         if (r == NULL) {
2418                 return false;
2419         }
2420
2421         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2422                 talloc_free(r);
2423                 return false;
2424         }
2425
2426         pull = ndr_pull_init_blob(&blob, r, NULL);
2427         if (pull == NULL) {
2428                 talloc_free(r);
2429                 return false;
2430         }
2431
2432         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2433         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2434         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2435                 talloc_free(r);
2436                 return false;
2437         }
2438
2439         if (DEBUGLEVEL >= 10) {
2440                 NDR_PRINT_IN_DEBUG(lsa_LookupPrivValue, r);
2441         }
2442
2443         ZERO_STRUCT(r->out);
2444         r->out.luid = talloc_zero(r, struct lsa_LUID);
2445         if (r->out.luid == NULL) {
2446                 talloc_free(r);
2447                 return false;
2448         }
2449
2450         r->out.result = _lsa_LookupPrivValue(p, r);
2451
2452         if (p->rng_fault_state) {
2453                 talloc_free(r);
2454                 /* Return true here, srv_pipe_hnd.c will take care */
2455                 return true;
2456         }
2457
2458         if (DEBUGLEVEL >= 10) {
2459                 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivValue, r);
2460         }
2461
2462         push = ndr_push_init_ctx(r, NULL);
2463         if (push == NULL) {
2464                 talloc_free(r);
2465                 return false;
2466         }
2467
2468         ndr_err = call->ndr_push(push, NDR_OUT, r);
2469         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2470                 talloc_free(r);
2471                 return false;
2472         }
2473
2474         blob = ndr_push_blob(push);
2475         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2476                 talloc_free(r);
2477                 return false;
2478         }
2479
2480         talloc_free(r);
2481
2482         return true;
2483 }
2484
2485 static bool api_lsa_LookupPrivName(pipes_struct *p)
2486 {
2487         const struct ndr_interface_call *call;
2488         struct ndr_pull *pull;
2489         struct ndr_push *push;
2490         enum ndr_err_code ndr_err;
2491         DATA_BLOB blob;
2492         struct lsa_LookupPrivName *r;
2493
2494         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPPRIVNAME];
2495
2496         r = talloc(talloc_tos(), struct lsa_LookupPrivName);
2497         if (r == NULL) {
2498                 return false;
2499         }
2500
2501         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2502                 talloc_free(r);
2503                 return false;
2504         }
2505
2506         pull = ndr_pull_init_blob(&blob, r, NULL);
2507         if (pull == NULL) {
2508                 talloc_free(r);
2509                 return false;
2510         }
2511
2512         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2513         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2514         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2515                 talloc_free(r);
2516                 return false;
2517         }
2518
2519         if (DEBUGLEVEL >= 10) {
2520                 NDR_PRINT_IN_DEBUG(lsa_LookupPrivName, r);
2521         }
2522
2523         ZERO_STRUCT(r->out);
2524         r->out.name = talloc_zero(r, struct lsa_StringLarge *);
2525         if (r->out.name == NULL) {
2526                 talloc_free(r);
2527                 return false;
2528         }
2529
2530         r->out.result = _lsa_LookupPrivName(p, r);
2531
2532         if (p->rng_fault_state) {
2533                 talloc_free(r);
2534                 /* Return true here, srv_pipe_hnd.c will take care */
2535                 return true;
2536         }
2537
2538         if (DEBUGLEVEL >= 10) {
2539                 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivName, r);
2540         }
2541
2542         push = ndr_push_init_ctx(r, NULL);
2543         if (push == NULL) {
2544                 talloc_free(r);
2545                 return false;
2546         }
2547
2548         ndr_err = call->ndr_push(push, NDR_OUT, r);
2549         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2550                 talloc_free(r);
2551                 return false;
2552         }
2553
2554         blob = ndr_push_blob(push);
2555         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2556                 talloc_free(r);
2557                 return false;
2558         }
2559
2560         talloc_free(r);
2561
2562         return true;
2563 }
2564
2565 static bool api_lsa_LookupPrivDisplayName(pipes_struct *p)
2566 {
2567         const struct ndr_interface_call *call;
2568         struct ndr_pull *pull;
2569         struct ndr_push *push;
2570         enum ndr_err_code ndr_err;
2571         DATA_BLOB blob;
2572         struct lsa_LookupPrivDisplayName *r;
2573
2574         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPPRIVDISPLAYNAME];
2575
2576         r = talloc(talloc_tos(), struct lsa_LookupPrivDisplayName);
2577         if (r == NULL) {
2578                 return false;
2579         }
2580
2581         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2582                 talloc_free(r);
2583                 return false;
2584         }
2585
2586         pull = ndr_pull_init_blob(&blob, r, NULL);
2587         if (pull == NULL) {
2588                 talloc_free(r);
2589                 return false;
2590         }
2591
2592         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2593         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2594         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2595                 talloc_free(r);
2596                 return false;
2597         }
2598
2599         if (DEBUGLEVEL >= 10) {
2600                 NDR_PRINT_IN_DEBUG(lsa_LookupPrivDisplayName, r);
2601         }
2602
2603         ZERO_STRUCT(r->out);
2604         r->out.disp_name = talloc_zero(r, struct lsa_StringLarge *);
2605         if (r->out.disp_name == NULL) {
2606                 talloc_free(r);
2607                 return false;
2608         }
2609
2610         r->out.returned_language_id = talloc_zero(r, uint16_t);
2611         if (r->out.returned_language_id == NULL) {
2612                 talloc_free(r);
2613                 return false;
2614         }
2615
2616         r->out.result = _lsa_LookupPrivDisplayName(p, r);
2617
2618         if (p->rng_fault_state) {
2619                 talloc_free(r);
2620                 /* Return true here, srv_pipe_hnd.c will take care */
2621                 return true;
2622         }
2623
2624         if (DEBUGLEVEL >= 10) {
2625                 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivDisplayName, r);
2626         }
2627
2628         push = ndr_push_init_ctx(r, NULL);
2629         if (push == NULL) {
2630                 talloc_free(r);
2631                 return false;
2632         }
2633
2634         ndr_err = call->ndr_push(push, NDR_OUT, r);
2635         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2636                 talloc_free(r);
2637                 return false;
2638         }
2639
2640         blob = ndr_push_blob(push);
2641         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2642                 talloc_free(r);
2643                 return false;
2644         }
2645
2646         talloc_free(r);
2647
2648         return true;
2649 }
2650
2651 static bool api_lsa_DeleteObject(pipes_struct *p)
2652 {
2653         const struct ndr_interface_call *call;
2654         struct ndr_pull *pull;
2655         struct ndr_push *push;
2656         enum ndr_err_code ndr_err;
2657         DATA_BLOB blob;
2658         struct lsa_DeleteObject *r;
2659
2660         call = &ndr_table_lsarpc.calls[NDR_LSA_DELETEOBJECT];
2661
2662         r = talloc(talloc_tos(), struct lsa_DeleteObject);
2663         if (r == NULL) {
2664                 return false;
2665         }
2666
2667         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2668                 talloc_free(r);
2669                 return false;
2670         }
2671
2672         pull = ndr_pull_init_blob(&blob, r, NULL);
2673         if (pull == NULL) {
2674                 talloc_free(r);
2675                 return false;
2676         }
2677
2678         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2679         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2680         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2681                 talloc_free(r);
2682                 return false;
2683         }
2684
2685         if (DEBUGLEVEL >= 10) {
2686                 NDR_PRINT_IN_DEBUG(lsa_DeleteObject, r);
2687         }
2688
2689         ZERO_STRUCT(r->out);
2690         r->out.handle = r->in.handle;
2691         r->out.result = _lsa_DeleteObject(p, r);
2692
2693         if (p->rng_fault_state) {
2694                 talloc_free(r);
2695                 /* Return true here, srv_pipe_hnd.c will take care */
2696                 return true;
2697         }
2698
2699         if (DEBUGLEVEL >= 10) {
2700                 NDR_PRINT_OUT_DEBUG(lsa_DeleteObject, r);
2701         }
2702
2703         push = ndr_push_init_ctx(r, NULL);
2704         if (push == NULL) {
2705                 talloc_free(r);
2706                 return false;
2707         }
2708
2709         ndr_err = call->ndr_push(push, NDR_OUT, r);
2710         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2711                 talloc_free(r);
2712                 return false;
2713         }
2714
2715         blob = ndr_push_blob(push);
2716         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2717                 talloc_free(r);
2718                 return false;
2719         }
2720
2721         talloc_free(r);
2722
2723         return true;
2724 }
2725
2726 static bool api_lsa_EnumAccountsWithUserRight(pipes_struct *p)
2727 {
2728         const struct ndr_interface_call *call;
2729         struct ndr_pull *pull;
2730         struct ndr_push *push;
2731         enum ndr_err_code ndr_err;
2732         DATA_BLOB blob;
2733         struct lsa_EnumAccountsWithUserRight *r;
2734
2735         call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT];
2736
2737         r = talloc(talloc_tos(), struct lsa_EnumAccountsWithUserRight);
2738         if (r == NULL) {
2739                 return false;
2740         }
2741
2742         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2743                 talloc_free(r);
2744                 return false;
2745         }
2746
2747         pull = ndr_pull_init_blob(&blob, r, NULL);
2748         if (pull == NULL) {
2749                 talloc_free(r);
2750                 return false;
2751         }
2752
2753         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2754         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2755         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2756                 talloc_free(r);
2757                 return false;
2758         }
2759
2760         if (DEBUGLEVEL >= 10) {
2761                 NDR_PRINT_IN_DEBUG(lsa_EnumAccountsWithUserRight, r);
2762         }
2763
2764         ZERO_STRUCT(r->out);
2765         r->out.sids = talloc_zero(r, struct lsa_SidArray);
2766         if (r->out.sids == NULL) {
2767                 talloc_free(r);
2768                 return false;
2769         }
2770
2771         r->out.result = _lsa_EnumAccountsWithUserRight(p, r);
2772
2773         if (p->rng_fault_state) {
2774                 talloc_free(r);
2775                 /* Return true here, srv_pipe_hnd.c will take care */
2776                 return true;
2777         }
2778
2779         if (DEBUGLEVEL >= 10) {
2780                 NDR_PRINT_OUT_DEBUG(lsa_EnumAccountsWithUserRight, r);
2781         }
2782
2783         push = ndr_push_init_ctx(r, NULL);
2784         if (push == NULL) {
2785                 talloc_free(r);
2786                 return false;
2787         }
2788
2789         ndr_err = call->ndr_push(push, NDR_OUT, r);
2790         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2791                 talloc_free(r);
2792                 return false;
2793         }
2794
2795         blob = ndr_push_blob(push);
2796         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2797                 talloc_free(r);
2798                 return false;
2799         }
2800
2801         talloc_free(r);
2802
2803         return true;
2804 }
2805
2806 static bool api_lsa_EnumAccountRights(pipes_struct *p)
2807 {
2808         const struct ndr_interface_call *call;
2809         struct ndr_pull *pull;
2810         struct ndr_push *push;
2811         enum ndr_err_code ndr_err;
2812         DATA_BLOB blob;
2813         struct lsa_EnumAccountRights *r;
2814
2815         call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMACCOUNTRIGHTS];
2816
2817         r = talloc(talloc_tos(), struct lsa_EnumAccountRights);
2818         if (r == NULL) {
2819                 return false;
2820         }
2821
2822         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2823                 talloc_free(r);
2824                 return false;
2825         }
2826
2827         pull = ndr_pull_init_blob(&blob, r, NULL);
2828         if (pull == NULL) {
2829                 talloc_free(r);
2830                 return false;
2831         }
2832
2833         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2834         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2835         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2836                 talloc_free(r);
2837                 return false;
2838         }
2839
2840         if (DEBUGLEVEL >= 10) {
2841                 NDR_PRINT_IN_DEBUG(lsa_EnumAccountRights, r);
2842         }
2843
2844         ZERO_STRUCT(r->out);
2845         r->out.rights = talloc_zero(r, struct lsa_RightSet);
2846         if (r->out.rights == NULL) {
2847                 talloc_free(r);
2848                 return false;
2849         }
2850
2851         r->out.result = _lsa_EnumAccountRights(p, r);
2852
2853         if (p->rng_fault_state) {
2854                 talloc_free(r);
2855                 /* Return true here, srv_pipe_hnd.c will take care */
2856                 return true;
2857         }
2858
2859         if (DEBUGLEVEL >= 10) {
2860                 NDR_PRINT_OUT_DEBUG(lsa_EnumAccountRights, r);
2861         }
2862
2863         push = ndr_push_init_ctx(r, NULL);
2864         if (push == NULL) {
2865                 talloc_free(r);
2866                 return false;
2867         }
2868
2869         ndr_err = call->ndr_push(push, NDR_OUT, r);
2870         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2871                 talloc_free(r);
2872                 return false;
2873         }
2874
2875         blob = ndr_push_blob(push);
2876         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2877                 talloc_free(r);
2878                 return false;
2879         }
2880
2881         talloc_free(r);
2882
2883         return true;
2884 }
2885
2886 static bool api_lsa_AddAccountRights(pipes_struct *p)
2887 {
2888         const struct ndr_interface_call *call;
2889         struct ndr_pull *pull;
2890         struct ndr_push *push;
2891         enum ndr_err_code ndr_err;
2892         DATA_BLOB blob;
2893         struct lsa_AddAccountRights *r;
2894
2895         call = &ndr_table_lsarpc.calls[NDR_LSA_ADDACCOUNTRIGHTS];
2896
2897         r = talloc(talloc_tos(), struct lsa_AddAccountRights);
2898         if (r == NULL) {
2899                 return false;
2900         }
2901
2902         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2903                 talloc_free(r);
2904                 return false;
2905         }
2906
2907         pull = ndr_pull_init_blob(&blob, r, NULL);
2908         if (pull == NULL) {
2909                 talloc_free(r);
2910                 return false;
2911         }
2912
2913         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2914         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2915         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2916                 talloc_free(r);
2917                 return false;
2918         }
2919
2920         if (DEBUGLEVEL >= 10) {
2921                 NDR_PRINT_IN_DEBUG(lsa_AddAccountRights, r);
2922         }
2923
2924         r->out.result = _lsa_AddAccountRights(p, r);
2925
2926         if (p->rng_fault_state) {
2927                 talloc_free(r);
2928                 /* Return true here, srv_pipe_hnd.c will take care */
2929                 return true;
2930         }
2931
2932         if (DEBUGLEVEL >= 10) {
2933                 NDR_PRINT_OUT_DEBUG(lsa_AddAccountRights, r);
2934         }
2935
2936         push = ndr_push_init_ctx(r, NULL);
2937         if (push == NULL) {
2938                 talloc_free(r);
2939                 return false;
2940         }
2941
2942         ndr_err = call->ndr_push(push, NDR_OUT, r);
2943         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2944                 talloc_free(r);
2945                 return false;
2946         }
2947
2948         blob = ndr_push_blob(push);
2949         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2950                 talloc_free(r);
2951                 return false;
2952         }
2953
2954         talloc_free(r);
2955
2956         return true;
2957 }
2958
2959 static bool api_lsa_RemoveAccountRights(pipes_struct *p)
2960 {
2961         const struct ndr_interface_call *call;
2962         struct ndr_pull *pull;
2963         struct ndr_push *push;
2964         enum ndr_err_code ndr_err;
2965         DATA_BLOB blob;
2966         struct lsa_RemoveAccountRights *r;
2967
2968         call = &ndr_table_lsarpc.calls[NDR_LSA_REMOVEACCOUNTRIGHTS];
2969
2970         r = talloc(talloc_tos(), struct lsa_RemoveAccountRights);
2971         if (r == NULL) {
2972                 return false;
2973         }
2974
2975         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2976                 talloc_free(r);
2977                 return false;
2978         }
2979
2980         pull = ndr_pull_init_blob(&blob, r, NULL);
2981         if (pull == NULL) {
2982                 talloc_free(r);
2983                 return false;
2984         }
2985
2986         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2987         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2988         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2989                 talloc_free(r);
2990                 return false;
2991         }
2992
2993         if (DEBUGLEVEL >= 10) {
2994                 NDR_PRINT_IN_DEBUG(lsa_RemoveAccountRights, r);
2995         }
2996
2997         r->out.result = _lsa_RemoveAccountRights(p, r);
2998
2999         if (p->rng_fault_state) {
3000                 talloc_free(r);
3001                 /* Return true here, srv_pipe_hnd.c will take care */
3002                 return true;
3003         }
3004
3005         if (DEBUGLEVEL >= 10) {
3006                 NDR_PRINT_OUT_DEBUG(lsa_RemoveAccountRights, r);
3007         }
3008
3009         push = ndr_push_init_ctx(r, NULL);
3010         if (push == NULL) {
3011                 talloc_free(r);
3012                 return false;
3013         }
3014
3015         ndr_err = call->ndr_push(push, NDR_OUT, r);
3016         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3017                 talloc_free(r);
3018                 return false;
3019         }
3020
3021         blob = ndr_push_blob(push);
3022         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3023                 talloc_free(r);
3024                 return false;
3025         }
3026
3027         talloc_free(r);
3028
3029         return true;
3030 }
3031
3032 static bool api_lsa_QueryTrustedDomainInfoBySid(pipes_struct *p)
3033 {
3034         const struct ndr_interface_call *call;
3035         struct ndr_pull *pull;
3036         struct ndr_push *push;
3037         enum ndr_err_code ndr_err;
3038         DATA_BLOB blob;
3039         struct lsa_QueryTrustedDomainInfoBySid *r;
3040
3041         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID];
3042
3043         r = talloc(talloc_tos(), struct lsa_QueryTrustedDomainInfoBySid);
3044         if (r == NULL) {
3045                 return false;
3046         }
3047
3048         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3049                 talloc_free(r);
3050                 return false;
3051         }
3052
3053         pull = ndr_pull_init_blob(&blob, r, NULL);
3054         if (pull == NULL) {
3055                 talloc_free(r);
3056                 return false;
3057         }
3058
3059         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3060         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3061         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3062                 talloc_free(r);
3063                 return false;
3064         }
3065
3066         if (DEBUGLEVEL >= 10) {
3067                 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfoBySid, r);
3068         }
3069
3070         ZERO_STRUCT(r->out);
3071         r->out.info = talloc_zero(r, union lsa_TrustedDomainInfo *);
3072         if (r->out.info == NULL) {
3073                 talloc_free(r);
3074                 return false;
3075         }
3076
3077         r->out.result = _lsa_QueryTrustedDomainInfoBySid(p, r);
3078
3079         if (p->rng_fault_state) {
3080                 talloc_free(r);
3081                 /* Return true here, srv_pipe_hnd.c will take care */
3082                 return true;
3083         }
3084
3085         if (DEBUGLEVEL >= 10) {
3086                 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoBySid, r);
3087         }
3088
3089         push = ndr_push_init_ctx(r, NULL);
3090         if (push == NULL) {
3091                 talloc_free(r);
3092                 return false;
3093         }
3094
3095         ndr_err = call->ndr_push(push, NDR_OUT, r);
3096         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3097                 talloc_free(r);
3098                 return false;
3099         }
3100
3101         blob = ndr_push_blob(push);
3102         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3103                 talloc_free(r);
3104                 return false;
3105         }
3106
3107         talloc_free(r);
3108
3109         return true;
3110 }
3111
3112 static bool api_lsa_SetTrustedDomainInfo(pipes_struct *p)
3113 {
3114         const struct ndr_interface_call *call;
3115         struct ndr_pull *pull;
3116         struct ndr_push *push;
3117         enum ndr_err_code ndr_err;
3118         DATA_BLOB blob;
3119         struct lsa_SetTrustedDomainInfo *r;
3120
3121         call = &ndr_table_lsarpc.calls[NDR_LSA_SETTRUSTEDDOMAININFO];
3122
3123         r = talloc(talloc_tos(), struct lsa_SetTrustedDomainInfo);
3124         if (r == NULL) {
3125                 return false;
3126         }
3127
3128         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3129                 talloc_free(r);
3130                 return false;
3131         }
3132
3133         pull = ndr_pull_init_blob(&blob, r, NULL);
3134         if (pull == NULL) {
3135                 talloc_free(r);
3136                 return false;
3137         }
3138
3139         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3140         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3141         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3142                 talloc_free(r);
3143                 return false;
3144         }
3145
3146         if (DEBUGLEVEL >= 10) {
3147                 NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfo, r);
3148         }
3149
3150         r->out.result = _lsa_SetTrustedDomainInfo(p, r);
3151
3152         if (p->rng_fault_state) {
3153                 talloc_free(r);
3154                 /* Return true here, srv_pipe_hnd.c will take care */
3155                 return true;
3156         }
3157
3158         if (DEBUGLEVEL >= 10) {
3159                 NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfo, r);
3160         }
3161
3162         push = ndr_push_init_ctx(r, NULL);
3163         if (push == NULL) {
3164                 talloc_free(r);
3165                 return false;
3166         }
3167
3168         ndr_err = call->ndr_push(push, NDR_OUT, r);
3169         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3170                 talloc_free(r);
3171                 return false;
3172         }
3173
3174         blob = ndr_push_blob(push);
3175         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3176                 talloc_free(r);
3177                 return false;
3178         }
3179
3180         talloc_free(r);
3181
3182         return true;
3183 }
3184
3185 static bool api_lsa_DeleteTrustedDomain(pipes_struct *p)
3186 {
3187         const struct ndr_interface_call *call;
3188         struct ndr_pull *pull;
3189         struct ndr_push *push;
3190         enum ndr_err_code ndr_err;
3191         DATA_BLOB blob;
3192         struct lsa_DeleteTrustedDomain *r;
3193
3194         call = &ndr_table_lsarpc.calls[NDR_LSA_DELETETRUSTEDDOMAIN];
3195
3196         r = talloc(talloc_tos(), struct lsa_DeleteTrustedDomain);
3197         if (r == NULL) {
3198                 return false;
3199         }
3200
3201         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3202                 talloc_free(r);
3203                 return false;
3204         }
3205
3206         pull = ndr_pull_init_blob(&blob, r, NULL);
3207         if (pull == NULL) {
3208                 talloc_free(r);
3209                 return false;
3210         }
3211
3212         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3213         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3214         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3215                 talloc_free(r);
3216                 return false;
3217         }
3218
3219         if (DEBUGLEVEL >= 10) {
3220                 NDR_PRINT_IN_DEBUG(lsa_DeleteTrustedDomain, r);
3221         }
3222
3223         r->out.result = _lsa_DeleteTrustedDomain(p, r);
3224
3225         if (p->rng_fault_state) {
3226                 talloc_free(r);
3227                 /* Return true here, srv_pipe_hnd.c will take care */
3228                 return true;
3229         }
3230
3231         if (DEBUGLEVEL >= 10) {
3232                 NDR_PRINT_OUT_DEBUG(lsa_DeleteTrustedDomain, r);
3233         }
3234
3235         push = ndr_push_init_ctx(r, NULL);
3236         if (push == NULL) {
3237                 talloc_free(r);
3238                 return false;
3239         }
3240
3241         ndr_err = call->ndr_push(push, NDR_OUT, r);
3242         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3243                 talloc_free(r);
3244                 return false;
3245         }
3246
3247         blob = ndr_push_blob(push);
3248         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3249                 talloc_free(r);
3250                 return false;
3251         }
3252
3253         talloc_free(r);
3254
3255         return true;
3256 }
3257
3258 static bool api_lsa_StorePrivateData(pipes_struct *p)
3259 {
3260         const struct ndr_interface_call *call;
3261         struct ndr_pull *pull;
3262         struct ndr_push *push;
3263         enum ndr_err_code ndr_err;
3264         DATA_BLOB blob;
3265         struct lsa_StorePrivateData *r;
3266
3267         call = &ndr_table_lsarpc.calls[NDR_LSA_STOREPRIVATEDATA];
3268
3269         r = talloc(talloc_tos(), struct lsa_StorePrivateData);
3270         if (r == NULL) {
3271                 return false;
3272         }
3273
3274         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3275                 talloc_free(r);
3276                 return false;
3277         }
3278
3279         pull = ndr_pull_init_blob(&blob, r, NULL);
3280         if (pull == NULL) {
3281                 talloc_free(r);
3282                 return false;
3283         }
3284
3285         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3286         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3287         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3288                 talloc_free(r);
3289                 return false;
3290         }
3291
3292         if (DEBUGLEVEL >= 10) {
3293                 NDR_PRINT_IN_DEBUG(lsa_StorePrivateData, r);
3294         }
3295
3296         r->out.result = _lsa_StorePrivateData(p, r);
3297
3298         if (p->rng_fault_state) {
3299                 talloc_free(r);
3300                 /* Return true here, srv_pipe_hnd.c will take care */
3301                 return true;
3302         }
3303
3304         if (DEBUGLEVEL >= 10) {
3305                 NDR_PRINT_OUT_DEBUG(lsa_StorePrivateData, r);
3306         }
3307
3308         push = ndr_push_init_ctx(r, NULL);
3309         if (push == NULL) {
3310                 talloc_free(r);
3311                 return false;
3312         }
3313
3314         ndr_err = call->ndr_push(push, NDR_OUT, r);
3315         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3316                 talloc_free(r);
3317                 return false;
3318         }
3319
3320         blob = ndr_push_blob(push);
3321         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3322                 talloc_free(r);
3323                 return false;
3324         }
3325
3326         talloc_free(r);
3327
3328         return true;
3329 }
3330
3331 static bool api_lsa_RetrievePrivateData(pipes_struct *p)
3332 {
3333         const struct ndr_interface_call *call;
3334         struct ndr_pull *pull;
3335         struct ndr_push *push;
3336         enum ndr_err_code ndr_err;
3337         DATA_BLOB blob;
3338         struct lsa_RetrievePrivateData *r;
3339
3340         call = &ndr_table_lsarpc.calls[NDR_LSA_RETRIEVEPRIVATEDATA];
3341
3342         r = talloc(talloc_tos(), struct lsa_RetrievePrivateData);
3343         if (r == NULL) {
3344                 return false;
3345         }
3346
3347         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3348                 talloc_free(r);
3349                 return false;
3350         }
3351
3352         pull = ndr_pull_init_blob(&blob, r, NULL);
3353         if (pull == NULL) {
3354                 talloc_free(r);
3355                 return false;
3356         }
3357
3358         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3359         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3360         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3361                 talloc_free(r);
3362                 return false;
3363         }
3364
3365         if (DEBUGLEVEL >= 10) {
3366                 NDR_PRINT_IN_DEBUG(lsa_RetrievePrivateData, r);
3367         }
3368
3369         ZERO_STRUCT(r->out);
3370         r->out.val = r->in.val;
3371         r->out.result = _lsa_RetrievePrivateData(p, r);
3372
3373         if (p->rng_fault_state) {
3374                 talloc_free(r);
3375                 /* Return true here, srv_pipe_hnd.c will take care */
3376                 return true;
3377         }
3378
3379         if (DEBUGLEVEL >= 10) {
3380                 NDR_PRINT_OUT_DEBUG(lsa_RetrievePrivateData, r);
3381         }
3382
3383         push = ndr_push_init_ctx(r, NULL);
3384         if (push == NULL) {
3385                 talloc_free(r);
3386                 return false;
3387         }
3388
3389         ndr_err = call->ndr_push(push, NDR_OUT, r);
3390         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3391                 talloc_free(r);
3392                 return false;
3393         }
3394
3395         blob = ndr_push_blob(push);
3396         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3397                 talloc_free(r);
3398                 return false;
3399         }
3400
3401         talloc_free(r);
3402
3403         return true;
3404 }
3405
3406 static bool api_lsa_OpenPolicy2(pipes_struct *p)
3407 {
3408         const struct ndr_interface_call *call;
3409         struct ndr_pull *pull;
3410         struct ndr_push *push;
3411         enum ndr_err_code ndr_err;
3412         DATA_BLOB blob;
3413         struct lsa_OpenPolicy2 *r;
3414
3415         call = &ndr_table_lsarpc.calls[NDR_LSA_OPENPOLICY2];
3416
3417         r = talloc(talloc_tos(), struct lsa_OpenPolicy2);
3418         if (r == NULL) {
3419                 return false;
3420         }
3421
3422         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3423                 talloc_free(r);
3424                 return false;
3425         }
3426
3427         pull = ndr_pull_init_blob(&blob, r, NULL);
3428         if (pull == NULL) {
3429                 talloc_free(r);
3430                 return false;
3431         }
3432
3433         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3434         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3435         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3436                 talloc_free(r);
3437                 return false;
3438         }
3439
3440         if (DEBUGLEVEL >= 10) {
3441                 NDR_PRINT_IN_DEBUG(lsa_OpenPolicy2, r);
3442         }
3443
3444         ZERO_STRUCT(r->out);
3445         r->out.handle = talloc_zero(r, struct policy_handle);
3446         if (r->out.handle == NULL) {
3447                 talloc_free(r);
3448                 return false;
3449         }
3450
3451         r->out.result = _lsa_OpenPolicy2(p, r);
3452
3453         if (p->rng_fault_state) {
3454                 talloc_free(r);
3455                 /* Return true here, srv_pipe_hnd.c will take care */
3456                 return true;
3457         }
3458
3459         if (DEBUGLEVEL >= 10) {
3460                 NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy2, r);
3461         }
3462
3463         push = ndr_push_init_ctx(r, NULL);
3464         if (push == NULL) {
3465                 talloc_free(r);
3466                 return false;
3467         }
3468
3469         ndr_err = call->ndr_push(push, NDR_OUT, r);
3470         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3471                 talloc_free(r);
3472                 return false;
3473         }
3474
3475         blob = ndr_push_blob(push);
3476         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3477                 talloc_free(r);
3478                 return false;
3479         }
3480
3481         talloc_free(r);
3482
3483         return true;
3484 }
3485
3486 static bool api_lsa_GetUserName(pipes_struct *p)
3487 {
3488         const struct ndr_interface_call *call;
3489         struct ndr_pull *pull;
3490         struct ndr_push *push;
3491         enum ndr_err_code ndr_err;
3492         DATA_BLOB blob;
3493         struct lsa_GetUserName *r;
3494
3495         call = &ndr_table_lsarpc.calls[NDR_LSA_GETUSERNAME];
3496
3497         r = talloc(talloc_tos(), struct lsa_GetUserName);
3498         if (r == NULL) {
3499                 return false;
3500         }
3501
3502         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3503                 talloc_free(r);
3504                 return false;
3505         }
3506
3507         pull = ndr_pull_init_blob(&blob, r, NULL);
3508         if (pull == NULL) {
3509                 talloc_free(r);
3510                 return false;
3511         }
3512
3513         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3514         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3515         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3516                 talloc_free(r);
3517                 return false;
3518         }
3519
3520         if (DEBUGLEVEL >= 10) {
3521                 NDR_PRINT_IN_DEBUG(lsa_GetUserName, r);
3522         }
3523
3524         ZERO_STRUCT(r->out);
3525         r->out.account_name = r->in.account_name;
3526         r->out.authority_name = r->in.authority_name;
3527         r->out.result = _lsa_GetUserName(p, r);
3528
3529         if (p->rng_fault_state) {
3530                 talloc_free(r);
3531                 /* Return true here, srv_pipe_hnd.c will take care */
3532                 return true;
3533         }
3534
3535         if (DEBUGLEVEL >= 10) {
3536                 NDR_PRINT_OUT_DEBUG(lsa_GetUserName, r);
3537         }
3538
3539         push = ndr_push_init_ctx(r, NULL);
3540         if (push == NULL) {
3541                 talloc_free(r);
3542                 return false;
3543         }
3544
3545         ndr_err = call->ndr_push(push, NDR_OUT, r);
3546         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3547                 talloc_free(r);
3548                 return false;
3549         }
3550
3551         blob = ndr_push_blob(push);
3552         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3553                 talloc_free(r);
3554                 return false;
3555         }
3556
3557         talloc_free(r);
3558
3559         return true;
3560 }
3561
3562 static bool api_lsa_QueryInfoPolicy2(pipes_struct *p)
3563 {
3564         const struct ndr_interface_call *call;
3565         struct ndr_pull *pull;
3566         struct ndr_push *push;
3567         enum ndr_err_code ndr_err;
3568         DATA_BLOB blob;
3569         struct lsa_QueryInfoPolicy2 *r;
3570
3571         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYINFOPOLICY2];
3572
3573         r = talloc(talloc_tos(), struct lsa_QueryInfoPolicy2);
3574         if (r == NULL) {
3575                 return false;
3576         }
3577
3578         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3579                 talloc_free(r);
3580                 return false;
3581         }
3582
3583         pull = ndr_pull_init_blob(&blob, r, NULL);
3584         if (pull == NULL) {
3585                 talloc_free(r);
3586                 return false;
3587         }
3588
3589         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3590         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3591         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3592                 talloc_free(r);
3593                 return false;
3594         }
3595
3596         if (DEBUGLEVEL >= 10) {
3597                 NDR_PRINT_IN_DEBUG(lsa_QueryInfoPolicy2, r);
3598         }
3599
3600         ZERO_STRUCT(r->out);
3601         r->out.info = talloc_zero(r, union lsa_PolicyInformation *);
3602         if (r->out.info == NULL) {
3603                 talloc_free(r);
3604                 return false;
3605         }
3606
3607         r->out.result = _lsa_QueryInfoPolicy2(p, r);
3608
3609         if (p->rng_fault_state) {
3610                 talloc_free(r);
3611                 /* Return true here, srv_pipe_hnd.c will take care */
3612                 return true;
3613         }
3614
3615         if (DEBUGLEVEL >= 10) {
3616                 NDR_PRINT_OUT_DEBUG(lsa_QueryInfoPolicy2, r);
3617         }
3618
3619         push = ndr_push_init_ctx(r, NULL);
3620         if (push == NULL) {
3621                 talloc_free(r);
3622                 return false;
3623         }
3624
3625         ndr_err = call->ndr_push(push, NDR_OUT, r);
3626         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3627                 talloc_free(r);
3628                 return false;
3629         }
3630
3631         blob = ndr_push_blob(push);
3632         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3633                 talloc_free(r);
3634                 return false;
3635         }
3636
3637         talloc_free(r);
3638
3639         return true;
3640 }
3641
3642 static bool api_lsa_SetInfoPolicy2(pipes_struct *p)
3643 {
3644         const struct ndr_interface_call *call;
3645         struct ndr_pull *pull;
3646         struct ndr_push *push;
3647         enum ndr_err_code ndr_err;
3648         DATA_BLOB blob;
3649         struct lsa_SetInfoPolicy2 *r;
3650
3651         call = &ndr_table_lsarpc.calls[NDR_LSA_SETINFOPOLICY2];
3652
3653         r = talloc(talloc_tos(), struct lsa_SetInfoPolicy2);
3654         if (r == NULL) {
3655                 return false;
3656         }
3657
3658         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3659                 talloc_free(r);
3660                 return false;
3661         }
3662
3663         pull = ndr_pull_init_blob(&blob, r, NULL);
3664         if (pull == NULL) {
3665                 talloc_free(r);
3666                 return false;
3667         }
3668
3669         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3670         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3671         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3672                 talloc_free(r);
3673                 return false;
3674         }
3675
3676         if (DEBUGLEVEL >= 10) {
3677                 NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy2, r);
3678         }
3679
3680         r->out.result = _lsa_SetInfoPolicy2(p, r);
3681
3682         if (p->rng_fault_state) {
3683                 talloc_free(r);
3684                 /* Return true here, srv_pipe_hnd.c will take care */
3685                 return true;
3686         }
3687
3688         if (DEBUGLEVEL >= 10) {
3689                 NDR_PRINT_OUT_DEBUG(lsa_SetInfoPolicy2, r);
3690         }
3691
3692         push = ndr_push_init_ctx(r, NULL);
3693         if (push == NULL) {
3694                 talloc_free(r);
3695                 return false;
3696         }
3697
3698         ndr_err = call->ndr_push(push, NDR_OUT, r);
3699         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3700                 talloc_free(r);
3701                 return false;
3702         }
3703
3704         blob = ndr_push_blob(push);
3705         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3706                 talloc_free(r);
3707                 return false;
3708         }
3709
3710         talloc_free(r);
3711
3712         return true;
3713 }
3714
3715 static bool api_lsa_QueryTrustedDomainInfoByName(pipes_struct *p)
3716 {
3717         const struct ndr_interface_call *call;
3718         struct ndr_pull *pull;
3719         struct ndr_push *push;
3720         enum ndr_err_code ndr_err;
3721         DATA_BLOB blob;
3722         struct lsa_QueryTrustedDomainInfoByName *r;
3723
3724         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME];
3725
3726         r = talloc(talloc_tos(), struct lsa_QueryTrustedDomainInfoByName);
3727         if (r == NULL) {
3728                 return false;
3729         }
3730
3731         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3732                 talloc_free(r);
3733                 return false;
3734         }
3735
3736         pull = ndr_pull_init_blob(&blob, r, NULL);
3737         if (pull == NULL) {
3738                 talloc_free(r);
3739                 return false;
3740         }
3741
3742         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3743         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3744         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3745                 talloc_free(r);
3746                 return false;
3747         }
3748
3749         if (DEBUGLEVEL >= 10) {
3750                 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfoByName, r);
3751         }
3752
3753         ZERO_STRUCT(r->out);
3754         r->out.info = talloc_zero(r, union lsa_TrustedDomainInfo *);
3755         if (r->out.info == NULL) {
3756                 talloc_free(r);
3757                 return false;
3758         }
3759
3760         r->out.result = _lsa_QueryTrustedDomainInfoByName(p, r);
3761
3762         if (p->rng_fault_state) {
3763                 talloc_free(r);
3764                 /* Return true here, srv_pipe_hnd.c will take care */
3765                 return true;
3766         }
3767
3768         if (DEBUGLEVEL >= 10) {
3769                 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoByName, r);
3770         }
3771
3772         push = ndr_push_init_ctx(r, NULL);
3773         if (push == NULL) {
3774                 talloc_free(r);
3775                 return false;
3776         }
3777
3778         ndr_err = call->ndr_push(push, NDR_OUT, r);
3779         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3780                 talloc_free(r);
3781                 return false;
3782         }
3783
3784         blob = ndr_push_blob(push);
3785         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3786                 talloc_free(r);
3787                 return false;
3788         }
3789
3790         talloc_free(r);
3791
3792         return true;
3793 }
3794
3795 static bool api_lsa_SetTrustedDomainInfoByName(pipes_struct *p)
3796 {
3797         const struct ndr_interface_call *call;
3798         struct ndr_pull *pull;
3799         struct ndr_push *push;
3800         enum ndr_err_code ndr_err;
3801         DATA_BLOB blob;
3802         struct lsa_SetTrustedDomainInfoByName *r;
3803
3804         call = &ndr_table_lsarpc.calls[NDR_LSA_SETTRUSTEDDOMAININFOBYNAME];
3805
3806         r = talloc(talloc_tos(), struct lsa_SetTrustedDomainInfoByName);
3807         if (r == NULL) {
3808                 return false;
3809         }
3810
3811         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3812                 talloc_free(r);
3813                 return false;
3814         }
3815
3816         pull = ndr_pull_init_blob(&blob, r, NULL);
3817         if (pull == NULL) {
3818                 talloc_free(r);
3819                 return false;
3820         }
3821
3822         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3823         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3824         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3825                 talloc_free(r);
3826                 return false;
3827         }
3828
3829         if (DEBUGLEVEL >= 10) {
3830                 NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfoByName, r);
3831         }
3832
3833         r->out.result = _lsa_SetTrustedDomainInfoByName(p, r);
3834
3835         if (p->rng_fault_state) {
3836                 talloc_free(r);
3837                 /* Return true here, srv_pipe_hnd.c will take care */
3838                 return true;
3839         }
3840
3841         if (DEBUGLEVEL >= 10) {
3842                 NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfoByName, r);
3843         }
3844
3845         push = ndr_push_init_ctx(r, NULL);
3846         if (push == NULL) {
3847                 talloc_free(r);
3848                 return false;
3849         }
3850
3851         ndr_err = call->ndr_push(push, NDR_OUT, r);
3852         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3853                 talloc_free(r);
3854                 return false;
3855         }
3856
3857         blob = ndr_push_blob(push);
3858         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3859                 talloc_free(r);
3860                 return false;
3861         }
3862
3863         talloc_free(r);
3864
3865         return true;
3866 }
3867
3868 static bool api_lsa_EnumTrustedDomainsEx(pipes_struct *p)
3869 {
3870         const struct ndr_interface_call *call;
3871         struct ndr_pull *pull;
3872         struct ndr_push *push;
3873         enum ndr_err_code ndr_err;
3874         DATA_BLOB blob;
3875         struct lsa_EnumTrustedDomainsEx *r;
3876
3877         call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMTRUSTEDDOMAINSEX];
3878
3879         r = talloc(talloc_tos(), struct lsa_EnumTrustedDomainsEx);
3880         if (r == NULL) {
3881                 return false;
3882         }
3883
3884         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3885                 talloc_free(r);
3886                 return false;
3887         }
3888
3889         pull = ndr_pull_init_blob(&blob, r, NULL);
3890         if (pull == NULL) {
3891                 talloc_free(r);
3892                 return false;
3893         }
3894
3895         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3896         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3897         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3898                 talloc_free(r);
3899                 return false;
3900         }
3901
3902         if (DEBUGLEVEL >= 10) {
3903                 NDR_PRINT_IN_DEBUG(lsa_EnumTrustedDomainsEx, r);
3904         }
3905
3906         ZERO_STRUCT(r->out);
3907         r->out.resume_handle = r->in.resume_handle;
3908         r->out.domains = talloc_zero(r, struct lsa_DomainListEx);
3909         if (r->out.domains == NULL) {
3910                 talloc_free(r);
3911                 return false;
3912         }
3913
3914         r->out.result = _lsa_EnumTrustedDomainsEx(p, r);
3915
3916         if (p->rng_fault_state) {
3917                 talloc_free(r);
3918                 /* Return true here, srv_pipe_hnd.c will take care */
3919                 return true;
3920         }
3921
3922         if (DEBUGLEVEL >= 10) {
3923                 NDR_PRINT_OUT_DEBUG(lsa_EnumTrustedDomainsEx, r);
3924         }
3925
3926         push = ndr_push_init_ctx(r, NULL);
3927         if (push == NULL) {
3928                 talloc_free(r);
3929                 return false;
3930         }
3931
3932         ndr_err = call->ndr_push(push, NDR_OUT, r);
3933         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3934                 talloc_free(r);
3935                 return false;
3936         }
3937
3938         blob = ndr_push_blob(push);
3939         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3940                 talloc_free(r);
3941                 return false;
3942         }
3943
3944         talloc_free(r);
3945
3946         return true;
3947 }
3948
3949 static bool api_lsa_CreateTrustedDomainEx(pipes_struct *p)
3950 {
3951         const struct ndr_interface_call *call;
3952         struct ndr_pull *pull;
3953         struct ndr_push *push;
3954         enum ndr_err_code ndr_err;
3955         DATA_BLOB blob;
3956         struct lsa_CreateTrustedDomainEx *r;
3957
3958         call = &ndr_table_lsarpc.calls[NDR_LSA_CREATETRUSTEDDOMAINEX];
3959
3960         r = talloc(talloc_tos(), struct lsa_CreateTrustedDomainEx);
3961         if (r == NULL) {
3962                 return false;
3963         }
3964
3965         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3966                 talloc_free(r);
3967                 return false;
3968         }
3969
3970         pull = ndr_pull_init_blob(&blob, r, NULL);
3971         if (pull == NULL) {
3972                 talloc_free(r);
3973                 return false;
3974         }
3975
3976         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3977         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3978         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3979                 talloc_free(r);
3980                 return false;
3981         }
3982
3983         if (DEBUGLEVEL >= 10) {
3984                 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx, r);
3985         }
3986
3987         ZERO_STRUCT(r->out);
3988         r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
3989         if (r->out.trustdom_handle == NULL) {
3990                 talloc_free(r);
3991                 return false;
3992         }
3993
3994         r->out.result = _lsa_CreateTrustedDomainEx(p, r);
3995
3996         if (p->rng_fault_state) {
3997                 talloc_free(r);
3998                 /* Return true here, srv_pipe_hnd.c will take care */
3999                 return true;
4000         }
4001
4002         if (DEBUGLEVEL >= 10) {
4003                 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx, r);
4004         }
4005
4006         push = ndr_push_init_ctx(r, NULL);
4007         if (push == NULL) {
4008                 talloc_free(r);
4009                 return false;
4010         }
4011
4012         ndr_err = call->ndr_push(push, NDR_OUT, r);
4013         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4014                 talloc_free(r);
4015                 return false;
4016         }
4017
4018         blob = ndr_push_blob(push);
4019         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4020                 talloc_free(r);
4021                 return false;
4022         }
4023
4024         talloc_free(r);
4025
4026         return true;
4027 }
4028
4029 static bool api_lsa_CloseTrustedDomainEx(pipes_struct *p)
4030 {
4031         const struct ndr_interface_call *call;
4032         struct ndr_pull *pull;
4033         struct ndr_push *push;
4034         enum ndr_err_code ndr_err;
4035         DATA_BLOB blob;
4036         struct lsa_CloseTrustedDomainEx *r;
4037
4038         call = &ndr_table_lsarpc.calls[NDR_LSA_CLOSETRUSTEDDOMAINEX];
4039
4040         r = talloc(talloc_tos(), struct lsa_CloseTrustedDomainEx);
4041         if (r == NULL) {
4042                 return false;
4043         }
4044
4045         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4046                 talloc_free(r);
4047                 return false;
4048         }
4049
4050         pull = ndr_pull_init_blob(&blob, r, NULL);
4051         if (pull == NULL) {
4052                 talloc_free(r);
4053                 return false;
4054         }
4055
4056         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4057         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4058         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4059                 talloc_free(r);
4060                 return false;
4061         }
4062
4063         if (DEBUGLEVEL >= 10) {
4064                 NDR_PRINT_IN_DEBUG(lsa_CloseTrustedDomainEx, r);
4065         }
4066
4067         ZERO_STRUCT(r->out);
4068         r->out.handle = r->in.handle;
4069         r->out.result = _lsa_CloseTrustedDomainEx(p, r);
4070
4071         if (p->rng_fault_state) {
4072                 talloc_free(r);
4073                 /* Return true here, srv_pipe_hnd.c will take care */
4074                 return true;
4075         }
4076
4077         if (DEBUGLEVEL >= 10) {
4078                 NDR_PRINT_OUT_DEBUG(lsa_CloseTrustedDomainEx, r);
4079         }
4080
4081         push = ndr_push_init_ctx(r, NULL);
4082         if (push == NULL) {
4083                 talloc_free(r);
4084                 return false;
4085         }
4086
4087         ndr_err = call->ndr_push(push, NDR_OUT, r);
4088         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4089                 talloc_free(r);
4090                 return false;
4091         }
4092
4093         blob = ndr_push_blob(push);
4094         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4095                 talloc_free(r);
4096                 return false;
4097         }
4098
4099         talloc_free(r);
4100
4101         return true;
4102 }
4103
4104 static bool api_lsa_QueryDomainInformationPolicy(pipes_struct *p)
4105 {
4106         const struct ndr_interface_call *call;
4107         struct ndr_pull *pull;
4108         struct ndr_push *push;
4109         enum ndr_err_code ndr_err;
4110         DATA_BLOB blob;
4111         struct lsa_QueryDomainInformationPolicy *r;
4112
4113         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYDOMAININFORMATIONPOLICY];
4114
4115         r = talloc(talloc_tos(), struct lsa_QueryDomainInformationPolicy);
4116         if (r == NULL) {
4117                 return false;
4118         }
4119
4120         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4121                 talloc_free(r);
4122                 return false;
4123         }
4124
4125         pull = ndr_pull_init_blob(&blob, r, NULL);
4126         if (pull == NULL) {
4127                 talloc_free(r);
4128                 return false;
4129         }
4130
4131         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4132         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4133         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4134                 talloc_free(r);
4135                 return false;
4136         }
4137
4138         if (DEBUGLEVEL >= 10) {
4139                 NDR_PRINT_IN_DEBUG(lsa_QueryDomainInformationPolicy, r);
4140         }
4141
4142         ZERO_STRUCT(r->out);
4143         r->out.info = talloc_zero(r, union lsa_DomainInformationPolicy *);
4144         if (r->out.info == NULL) {
4145                 talloc_free(r);
4146                 return false;
4147         }
4148
4149         r->out.result = _lsa_QueryDomainInformationPolicy(p, r);
4150
4151         if (p->rng_fault_state) {
4152                 talloc_free(r);
4153                 /* Return true here, srv_pipe_hnd.c will take care */
4154                 return true;
4155         }
4156
4157         if (DEBUGLEVEL >= 10) {
4158                 NDR_PRINT_OUT_DEBUG(lsa_QueryDomainInformationPolicy, r);
4159         }
4160
4161         push = ndr_push_init_ctx(r, NULL);
4162         if (push == NULL) {
4163                 talloc_free(r);
4164                 return false;
4165         }
4166
4167         ndr_err = call->ndr_push(push, NDR_OUT, r);
4168         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4169                 talloc_free(r);
4170                 return false;
4171         }
4172
4173         blob = ndr_push_blob(push);
4174         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4175                 talloc_free(r);
4176                 return false;
4177         }
4178
4179         talloc_free(r);
4180
4181         return true;
4182 }
4183
4184 static bool api_lsa_SetDomainInformationPolicy(pipes_struct *p)
4185 {
4186         const struct ndr_interface_call *call;
4187         struct ndr_pull *pull;
4188         struct ndr_push *push;
4189         enum ndr_err_code ndr_err;
4190         DATA_BLOB blob;
4191         struct lsa_SetDomainInformationPolicy *r;
4192
4193         call = &ndr_table_lsarpc.calls[NDR_LSA_SETDOMAININFORMATIONPOLICY];
4194
4195         r = talloc(talloc_tos(), struct lsa_SetDomainInformationPolicy);
4196         if (r == NULL) {
4197                 return false;
4198         }
4199
4200         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4201                 talloc_free(r);
4202                 return false;
4203         }
4204
4205         pull = ndr_pull_init_blob(&blob, r, NULL);
4206         if (pull == NULL) {
4207                 talloc_free(r);
4208                 return false;
4209         }
4210
4211         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4212         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4213         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4214                 talloc_free(r);
4215                 return false;
4216         }
4217
4218         if (DEBUGLEVEL >= 10) {
4219                 NDR_PRINT_IN_DEBUG(lsa_SetDomainInformationPolicy, r);
4220         }
4221
4222         r->out.result = _lsa_SetDomainInformationPolicy(p, r);
4223
4224         if (p->rng_fault_state) {
4225                 talloc_free(r);
4226                 /* Return true here, srv_pipe_hnd.c will take care */
4227                 return true;
4228         }
4229
4230         if (DEBUGLEVEL >= 10) {
4231                 NDR_PRINT_OUT_DEBUG(lsa_SetDomainInformationPolicy, r);
4232         }
4233
4234         push = ndr_push_init_ctx(r, NULL);
4235         if (push == NULL) {
4236                 talloc_free(r);
4237                 return false;
4238         }
4239
4240         ndr_err = call->ndr_push(push, NDR_OUT, r);
4241         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4242                 talloc_free(r);
4243                 return false;
4244         }
4245
4246         blob = ndr_push_blob(push);
4247         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4248                 talloc_free(r);
4249                 return false;
4250         }
4251
4252         talloc_free(r);
4253
4254         return true;
4255 }
4256
4257 static bool api_lsa_OpenTrustedDomainByName(pipes_struct *p)
4258 {
4259         const struct ndr_interface_call *call;
4260         struct ndr_pull *pull;
4261         struct ndr_push *push;
4262         enum ndr_err_code ndr_err;
4263         DATA_BLOB blob;
4264         struct lsa_OpenTrustedDomainByName *r;
4265
4266         call = &ndr_table_lsarpc.calls[NDR_LSA_OPENTRUSTEDDOMAINBYNAME];
4267
4268         r = talloc(talloc_tos(), struct lsa_OpenTrustedDomainByName);
4269         if (r == NULL) {
4270                 return false;
4271         }
4272
4273         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4274                 talloc_free(r);
4275                 return false;
4276         }
4277
4278         pull = ndr_pull_init_blob(&blob, r, NULL);
4279         if (pull == NULL) {
4280                 talloc_free(r);
4281                 return false;
4282         }
4283
4284         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4285         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4286         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4287                 talloc_free(r);
4288                 return false;
4289         }
4290
4291         if (DEBUGLEVEL >= 10) {
4292                 NDR_PRINT_IN_DEBUG(lsa_OpenTrustedDomainByName, r);
4293         }
4294
4295         ZERO_STRUCT(r->out);
4296         r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
4297         if (r->out.trustdom_handle == NULL) {
4298                 talloc_free(r);
4299                 return false;
4300         }
4301
4302         r->out.result = _lsa_OpenTrustedDomainByName(p, r);
4303
4304         if (p->rng_fault_state) {
4305                 talloc_free(r);
4306                 /* Return true here, srv_pipe_hnd.c will take care */
4307                 return true;
4308         }
4309
4310         if (DEBUGLEVEL >= 10) {
4311                 NDR_PRINT_OUT_DEBUG(lsa_OpenTrustedDomainByName, r);
4312         }
4313
4314         push = ndr_push_init_ctx(r, NULL);
4315         if (push == NULL) {
4316                 talloc_free(r);
4317                 return false;
4318         }
4319
4320         ndr_err = call->ndr_push(push, NDR_OUT, r);
4321         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4322                 talloc_free(r);
4323                 return false;
4324         }
4325
4326         blob = ndr_push_blob(push);
4327         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4328                 talloc_free(r);
4329                 return false;
4330         }
4331
4332         talloc_free(r);
4333
4334         return true;
4335 }
4336
4337 static bool api_lsa_TestCall(pipes_struct *p)
4338 {
4339         const struct ndr_interface_call *call;
4340         struct ndr_pull *pull;
4341         struct ndr_push *push;
4342         enum ndr_err_code ndr_err;
4343         DATA_BLOB blob;
4344         struct lsa_TestCall *r;
4345
4346         call = &ndr_table_lsarpc.calls[NDR_LSA_TESTCALL];
4347
4348         r = talloc(talloc_tos(), struct lsa_TestCall);
4349         if (r == NULL) {
4350                 return false;
4351         }
4352
4353         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4354                 talloc_free(r);
4355                 return false;
4356         }
4357
4358         pull = ndr_pull_init_blob(&blob, r, NULL);
4359         if (pull == NULL) {
4360                 talloc_free(r);
4361                 return false;
4362         }
4363
4364         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4365         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4366         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4367                 talloc_free(r);
4368                 return false;
4369         }
4370
4371         if (DEBUGLEVEL >= 10) {
4372                 NDR_PRINT_IN_DEBUG(lsa_TestCall, r);
4373         }
4374
4375         r->out.result = _lsa_TestCall(p, r);
4376
4377         if (p->rng_fault_state) {
4378                 talloc_free(r);
4379                 /* Return true here, srv_pipe_hnd.c will take care */
4380                 return true;
4381         }
4382
4383         if (DEBUGLEVEL >= 10) {
4384                 NDR_PRINT_OUT_DEBUG(lsa_TestCall, r);
4385         }
4386
4387         push = ndr_push_init_ctx(r, NULL);
4388         if (push == NULL) {
4389                 talloc_free(r);
4390                 return false;
4391         }
4392
4393         ndr_err = call->ndr_push(push, NDR_OUT, r);
4394         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4395                 talloc_free(r);
4396                 return false;
4397         }
4398
4399         blob = ndr_push_blob(push);
4400         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4401                 talloc_free(r);
4402                 return false;
4403         }
4404
4405         talloc_free(r);
4406
4407         return true;
4408 }
4409
4410 static bool api_lsa_LookupSids2(pipes_struct *p)
4411 {
4412         const struct ndr_interface_call *call;
4413         struct ndr_pull *pull;
4414         struct ndr_push *push;
4415         enum ndr_err_code ndr_err;
4416         DATA_BLOB blob;
4417         struct lsa_LookupSids2 *r;
4418
4419         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPSIDS2];
4420
4421         r = talloc(talloc_tos(), struct lsa_LookupSids2);
4422         if (r == NULL) {
4423                 return false;
4424         }
4425
4426         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4427                 talloc_free(r);
4428                 return false;
4429         }
4430
4431         pull = ndr_pull_init_blob(&blob, r, NULL);
4432         if (pull == NULL) {
4433                 talloc_free(r);
4434                 return false;
4435         }
4436
4437         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4438         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4439         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4440                 talloc_free(r);
4441                 return false;
4442         }
4443
4444         if (DEBUGLEVEL >= 10) {
4445                 NDR_PRINT_IN_DEBUG(lsa_LookupSids2, r);
4446         }
4447
4448         ZERO_STRUCT(r->out);
4449         r->out.names = r->in.names;
4450         r->out.count = r->in.count;
4451         r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
4452         if (r->out.domains == NULL) {
4453                 talloc_free(r);
4454                 return false;
4455         }
4456
4457         r->out.result = _lsa_LookupSids2(p, r);
4458
4459         if (p->rng_fault_state) {
4460                 talloc_free(r);
4461                 /* Return true here, srv_pipe_hnd.c will take care */
4462                 return true;
4463         }
4464
4465         if (DEBUGLEVEL >= 10) {
4466                 NDR_PRINT_OUT_DEBUG(lsa_LookupSids2, r);
4467         }
4468
4469         push = ndr_push_init_ctx(r, NULL);
4470         if (push == NULL) {
4471                 talloc_free(r);
4472                 return false;
4473         }
4474
4475         ndr_err = call->ndr_push(push, NDR_OUT, r);
4476         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4477                 talloc_free(r);
4478                 return false;
4479         }
4480
4481         blob = ndr_push_blob(push);
4482         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4483                 talloc_free(r);
4484                 return false;
4485         }
4486
4487         talloc_free(r);
4488
4489         return true;
4490 }
4491
4492 static bool api_lsa_LookupNames2(pipes_struct *p)
4493 {
4494         const struct ndr_interface_call *call;
4495         struct ndr_pull *pull;
4496         struct ndr_push *push;
4497         enum ndr_err_code ndr_err;
4498         DATA_BLOB blob;
4499         struct lsa_LookupNames2 *r;
4500
4501         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPNAMES2];
4502
4503         r = talloc(talloc_tos(), struct lsa_LookupNames2);
4504         if (r == NULL) {
4505                 return false;
4506         }
4507
4508         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4509                 talloc_free(r);
4510                 return false;
4511         }
4512
4513         pull = ndr_pull_init_blob(&blob, r, NULL);
4514         if (pull == NULL) {
4515                 talloc_free(r);
4516                 return false;
4517         }
4518
4519         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4520         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4521         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4522                 talloc_free(r);
4523                 return false;
4524         }
4525
4526         if (DEBUGLEVEL >= 10) {
4527                 NDR_PRINT_IN_DEBUG(lsa_LookupNames2, r);
4528         }
4529
4530         ZERO_STRUCT(r->out);
4531         r->out.sids = r->in.sids;
4532         r->out.count = r->in.count;
4533         r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
4534         if (r->out.domains == NULL) {
4535                 talloc_free(r);
4536                 return false;
4537         }
4538
4539         r->out.result = _lsa_LookupNames2(p, r);
4540
4541         if (p->rng_fault_state) {
4542                 talloc_free(r);
4543                 /* Return true here, srv_pipe_hnd.c will take care */
4544                 return true;
4545         }
4546
4547         if (DEBUGLEVEL >= 10) {
4548                 NDR_PRINT_OUT_DEBUG(lsa_LookupNames2, r);
4549         }
4550
4551         push = ndr_push_init_ctx(r, NULL);
4552         if (push == NULL) {
4553                 talloc_free(r);
4554                 return false;
4555         }
4556
4557         ndr_err = call->ndr_push(push, NDR_OUT, r);
4558         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4559                 talloc_free(r);
4560                 return false;
4561         }
4562
4563         blob = ndr_push_blob(push);
4564         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4565                 talloc_free(r);
4566                 return false;
4567         }
4568
4569         talloc_free(r);
4570
4571         return true;
4572 }
4573
4574 static bool api_lsa_CreateTrustedDomainEx2(pipes_struct *p)
4575 {
4576         const struct ndr_interface_call *call;
4577         struct ndr_pull *pull;
4578         struct ndr_push *push;
4579         enum ndr_err_code ndr_err;
4580         DATA_BLOB blob;
4581         struct lsa_CreateTrustedDomainEx2 *r;
4582
4583         call = &ndr_table_lsarpc.calls[NDR_LSA_CREATETRUSTEDDOMAINEX2];
4584
4585         r = talloc(talloc_tos(), struct lsa_CreateTrustedDomainEx2);
4586         if (r == NULL) {
4587                 return false;
4588         }
4589
4590         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4591                 talloc_free(r);
4592                 return false;
4593         }
4594
4595         pull = ndr_pull_init_blob(&blob, r, NULL);
4596         if (pull == NULL) {
4597                 talloc_free(r);
4598                 return false;
4599         }
4600
4601         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4602         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4603         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4604                 talloc_free(r);
4605                 return false;
4606         }
4607
4608         if (DEBUGLEVEL >= 10) {
4609                 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx2, r);
4610         }
4611
4612         ZERO_STRUCT(r->out);
4613         r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
4614         if (r->out.trustdom_handle == NULL) {
4615                 talloc_free(r);
4616                 return false;
4617         }
4618
4619         r->out.result = _lsa_CreateTrustedDomainEx2(p, r);
4620
4621         if (p->rng_fault_state) {
4622                 talloc_free(r);
4623                 /* Return true here, srv_pipe_hnd.c will take care */
4624                 return true;
4625         }
4626
4627         if (DEBUGLEVEL >= 10) {
4628                 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx2, r);
4629         }
4630
4631         push = ndr_push_init_ctx(r, NULL);
4632         if (push == NULL) {
4633                 talloc_free(r);
4634                 return false;
4635         }
4636
4637         ndr_err = call->ndr_push(push, NDR_OUT, r);
4638         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4639                 talloc_free(r);
4640                 return false;
4641         }
4642
4643         blob = ndr_push_blob(push);
4644         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4645                 talloc_free(r);
4646                 return false;
4647         }
4648
4649         talloc_free(r);
4650
4651         return true;
4652 }
4653
4654 static bool api_lsa_CREDRWRITE(pipes_struct *p)
4655 {
4656         const struct ndr_interface_call *call;
4657         struct ndr_pull *pull;
4658         struct ndr_push *push;
4659         enum ndr_err_code ndr_err;
4660         DATA_BLOB blob;
4661         struct lsa_CREDRWRITE *r;
4662
4663         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRWRITE];
4664
4665         r = talloc(talloc_tos(), struct lsa_CREDRWRITE);
4666         if (r == NULL) {
4667                 return false;
4668         }
4669
4670         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4671                 talloc_free(r);
4672                 return false;
4673         }
4674
4675         pull = ndr_pull_init_blob(&blob, r, NULL);
4676         if (pull == NULL) {
4677                 talloc_free(r);
4678                 return false;
4679         }
4680
4681         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4682         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4683         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4684                 talloc_free(r);
4685                 return false;
4686         }
4687
4688         if (DEBUGLEVEL >= 10) {
4689                 NDR_PRINT_IN_DEBUG(lsa_CREDRWRITE, r);
4690         }
4691
4692         r->out.result = _lsa_CREDRWRITE(p, r);
4693
4694         if (p->rng_fault_state) {
4695                 talloc_free(r);
4696                 /* Return true here, srv_pipe_hnd.c will take care */
4697                 return true;
4698         }
4699
4700         if (DEBUGLEVEL >= 10) {
4701                 NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITE, r);
4702         }
4703
4704         push = ndr_push_init_ctx(r, NULL);
4705         if (push == NULL) {
4706                 talloc_free(r);
4707                 return false;
4708         }
4709
4710         ndr_err = call->ndr_push(push, NDR_OUT, r);
4711         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4712                 talloc_free(r);
4713                 return false;
4714         }
4715
4716         blob = ndr_push_blob(push);
4717         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4718                 talloc_free(r);
4719                 return false;
4720         }
4721
4722         talloc_free(r);
4723
4724         return true;
4725 }
4726
4727 static bool api_lsa_CREDRREAD(pipes_struct *p)
4728 {
4729         const struct ndr_interface_call *call;
4730         struct ndr_pull *pull;
4731         struct ndr_push *push;
4732         enum ndr_err_code ndr_err;
4733         DATA_BLOB blob;
4734         struct lsa_CREDRREAD *r;
4735
4736         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRREAD];
4737
4738         r = talloc(talloc_tos(), struct lsa_CREDRREAD);
4739         if (r == NULL) {
4740                 return false;
4741         }
4742
4743         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4744                 talloc_free(r);
4745                 return false;
4746         }
4747
4748         pull = ndr_pull_init_blob(&blob, r, NULL);
4749         if (pull == NULL) {
4750                 talloc_free(r);
4751                 return false;
4752         }
4753
4754         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4755         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4756         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4757                 talloc_free(r);
4758                 return false;
4759         }
4760
4761         if (DEBUGLEVEL >= 10) {
4762                 NDR_PRINT_IN_DEBUG(lsa_CREDRREAD, r);
4763         }
4764
4765         r->out.result = _lsa_CREDRREAD(p, r);
4766
4767         if (p->rng_fault_state) {
4768                 talloc_free(r);
4769                 /* Return true here, srv_pipe_hnd.c will take care */
4770                 return true;
4771         }
4772
4773         if (DEBUGLEVEL >= 10) {
4774                 NDR_PRINT_OUT_DEBUG(lsa_CREDRREAD, r);
4775         }
4776
4777         push = ndr_push_init_ctx(r, NULL);
4778         if (push == NULL) {
4779                 talloc_free(r);
4780                 return false;
4781         }
4782
4783         ndr_err = call->ndr_push(push, NDR_OUT, r);
4784         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4785                 talloc_free(r);
4786                 return false;
4787         }
4788
4789         blob = ndr_push_blob(push);
4790         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4791                 talloc_free(r);
4792                 return false;
4793         }
4794
4795         talloc_free(r);
4796
4797         return true;
4798 }
4799
4800 static bool api_lsa_CREDRENUMERATE(pipes_struct *p)
4801 {
4802         const struct ndr_interface_call *call;
4803         struct ndr_pull *pull;
4804         struct ndr_push *push;
4805         enum ndr_err_code ndr_err;
4806         DATA_BLOB blob;
4807         struct lsa_CREDRENUMERATE *r;
4808
4809         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRENUMERATE];
4810
4811         r = talloc(talloc_tos(), struct lsa_CREDRENUMERATE);
4812         if (r == NULL) {
4813                 return false;
4814         }
4815
4816         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4817                 talloc_free(r);
4818                 return false;
4819         }
4820
4821         pull = ndr_pull_init_blob(&blob, r, NULL);
4822         if (pull == NULL) {
4823                 talloc_free(r);
4824                 return false;
4825         }
4826
4827         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4828         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4829         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4830                 talloc_free(r);
4831                 return false;
4832         }
4833
4834         if (DEBUGLEVEL >= 10) {
4835                 NDR_PRINT_IN_DEBUG(lsa_CREDRENUMERATE, r);
4836         }
4837
4838         r->out.result = _lsa_CREDRENUMERATE(p, r);
4839
4840         if (p->rng_fault_state) {
4841                 talloc_free(r);
4842                 /* Return true here, srv_pipe_hnd.c will take care */
4843                 return true;
4844         }
4845
4846         if (DEBUGLEVEL >= 10) {
4847                 NDR_PRINT_OUT_DEBUG(lsa_CREDRENUMERATE, r);
4848         }
4849
4850         push = ndr_push_init_ctx(r, NULL);
4851         if (push == NULL) {
4852                 talloc_free(r);
4853                 return false;
4854         }
4855
4856         ndr_err = call->ndr_push(push, NDR_OUT, r);
4857         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4858                 talloc_free(r);
4859                 return false;
4860         }
4861
4862         blob = ndr_push_blob(push);
4863         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4864                 talloc_free(r);
4865                 return false;
4866         }
4867
4868         talloc_free(r);
4869
4870         return true;
4871 }
4872
4873 static bool api_lsa_CREDRWRITEDOMAINCREDENTIALS(pipes_struct *p)
4874 {
4875         const struct ndr_interface_call *call;
4876         struct ndr_pull *pull;
4877         struct ndr_push *push;
4878         enum ndr_err_code ndr_err;
4879         DATA_BLOB blob;
4880         struct lsa_CREDRWRITEDOMAINCREDENTIALS *r;
4881
4882         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRWRITEDOMAINCREDENTIALS];
4883
4884         r = talloc(talloc_tos(), struct lsa_CREDRWRITEDOMAINCREDENTIALS);
4885         if (r == NULL) {
4886                 return false;
4887         }
4888
4889         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4890                 talloc_free(r);
4891                 return false;
4892         }
4893
4894         pull = ndr_pull_init_blob(&blob, r, NULL);
4895         if (pull == NULL) {
4896                 talloc_free(r);
4897                 return false;
4898         }
4899
4900         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4901         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4902         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4903                 talloc_free(r);
4904                 return false;
4905         }
4906
4907         if (DEBUGLEVEL >= 10) {
4908                 NDR_PRINT_IN_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS, r);
4909         }
4910
4911         r->out.result = _lsa_CREDRWRITEDOMAINCREDENTIALS(p, r);
4912
4913         if (p->rng_fault_state) {
4914                 talloc_free(r);
4915                 /* Return true here, srv_pipe_hnd.c will take care */
4916                 return true;
4917         }
4918
4919         if (DEBUGLEVEL >= 10) {
4920                 NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS, r);
4921         }
4922
4923         push = ndr_push_init_ctx(r, NULL);
4924         if (push == NULL) {
4925                 talloc_free(r);
4926                 return false;
4927         }
4928
4929         ndr_err = call->ndr_push(push, NDR_OUT, r);
4930         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4931                 talloc_free(r);
4932                 return false;
4933         }
4934
4935         blob = ndr_push_blob(push);
4936         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4937                 talloc_free(r);
4938                 return false;
4939         }
4940
4941         talloc_free(r);
4942
4943         return true;
4944 }
4945
4946 static bool api_lsa_CREDRREADDOMAINCREDENTIALS(pipes_struct *p)
4947 {
4948         const struct ndr_interface_call *call;
4949         struct ndr_pull *pull;
4950         struct ndr_push *push;
4951         enum ndr_err_code ndr_err;
4952         DATA_BLOB blob;
4953         struct lsa_CREDRREADDOMAINCREDENTIALS *r;
4954
4955         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRREADDOMAINCREDENTIALS];
4956
4957         r = talloc(talloc_tos(), struct lsa_CREDRREADDOMAINCREDENTIALS);
4958         if (r == NULL) {
4959                 return false;
4960         }
4961
4962         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4963                 talloc_free(r);
4964                 return false;
4965         }
4966
4967         pull = ndr_pull_init_blob(&blob, r, NULL);
4968         if (pull == NULL) {
4969                 talloc_free(r);
4970                 return false;
4971         }
4972
4973         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4974         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4975         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4976                 talloc_free(r);
4977                 return false;
4978         }
4979
4980         if (DEBUGLEVEL >= 10) {
4981                 NDR_PRINT_IN_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS, r);
4982         }
4983
4984         r->out.result = _lsa_CREDRREADDOMAINCREDENTIALS(p, r);
4985
4986         if (p->rng_fault_state) {
4987                 talloc_free(r);
4988                 /* Return true here, srv_pipe_hnd.c will take care */
4989                 return true;
4990         }
4991
4992         if (DEBUGLEVEL >= 10) {
4993                 NDR_PRINT_OUT_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS, r);
4994         }
4995
4996         push = ndr_push_init_ctx(r, NULL);
4997         if (push == NULL) {
4998                 talloc_free(r);
4999                 return false;
5000         }
5001
5002         ndr_err = call->ndr_push(push, NDR_OUT, r);
5003         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5004                 talloc_free(r);
5005                 return false;
5006         }
5007
5008         blob = ndr_push_blob(push);
5009         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5010                 talloc_free(r);
5011                 return false;
5012         }
5013
5014         talloc_free(r);
5015
5016         return true;
5017 }
5018
5019 static bool api_lsa_CREDRDELETE(pipes_struct *p)
5020 {
5021         const struct ndr_interface_call *call;
5022         struct ndr_pull *pull;
5023         struct ndr_push *push;
5024         enum ndr_err_code ndr_err;
5025         DATA_BLOB blob;
5026         struct lsa_CREDRDELETE *r;
5027
5028         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRDELETE];
5029
5030         r = talloc(talloc_tos(), struct lsa_CREDRDELETE);
5031         if (r == NULL) {
5032                 return false;
5033         }
5034
5035         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5036                 talloc_free(r);
5037                 return false;
5038         }
5039
5040         pull = ndr_pull_init_blob(&blob, r, NULL);
5041         if (pull == NULL) {
5042                 talloc_free(r);
5043                 return false;
5044         }
5045
5046         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5047         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5048         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5049                 talloc_free(r);
5050                 return false;
5051         }
5052
5053         if (DEBUGLEVEL >= 10) {
5054                 NDR_PRINT_IN_DEBUG(lsa_CREDRDELETE, r);
5055         }
5056
5057         r->out.result = _lsa_CREDRDELETE(p, r);
5058
5059         if (p->rng_fault_state) {
5060                 talloc_free(r);
5061                 /* Return true here, srv_pipe_hnd.c will take care */
5062                 return true;
5063         }
5064
5065         if (DEBUGLEVEL >= 10) {
5066                 NDR_PRINT_OUT_DEBUG(lsa_CREDRDELETE, r);
5067         }
5068
5069         push = ndr_push_init_ctx(r, NULL);
5070         if (push == NULL) {
5071                 talloc_free(r);
5072                 return false;
5073         }
5074
5075         ndr_err = call->ndr_push(push, NDR_OUT, r);
5076         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5077                 talloc_free(r);
5078                 return false;
5079         }
5080
5081         blob = ndr_push_blob(push);
5082         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5083                 talloc_free(r);
5084                 return false;
5085         }
5086
5087         talloc_free(r);
5088
5089         return true;
5090 }
5091
5092 static bool api_lsa_CREDRGETTARGETINFO(pipes_struct *p)
5093 {
5094         const struct ndr_interface_call *call;
5095         struct ndr_pull *pull;
5096         struct ndr_push *push;
5097         enum ndr_err_code ndr_err;
5098         DATA_BLOB blob;
5099         struct lsa_CREDRGETTARGETINFO *r;
5100
5101         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRGETTARGETINFO];
5102
5103         r = talloc(talloc_tos(), struct lsa_CREDRGETTARGETINFO);
5104         if (r == NULL) {
5105                 return false;
5106         }
5107
5108         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5109                 talloc_free(r);
5110                 return false;
5111         }
5112
5113         pull = ndr_pull_init_blob(&blob, r, NULL);
5114         if (pull == NULL) {
5115                 talloc_free(r);
5116                 return false;
5117         }
5118
5119         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5120         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5121         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5122                 talloc_free(r);
5123                 return false;
5124         }
5125
5126         if (DEBUGLEVEL >= 10) {
5127                 NDR_PRINT_IN_DEBUG(lsa_CREDRGETTARGETINFO, r);
5128         }
5129
5130         r->out.result = _lsa_CREDRGETTARGETINFO(p, r);
5131
5132         if (p->rng_fault_state) {
5133                 talloc_free(r);
5134                 /* Return true here, srv_pipe_hnd.c will take care */
5135                 return true;
5136         }
5137
5138         if (DEBUGLEVEL >= 10) {
5139                 NDR_PRINT_OUT_DEBUG(lsa_CREDRGETTARGETINFO, r);
5140         }
5141
5142         push = ndr_push_init_ctx(r, NULL);
5143         if (push == NULL) {
5144                 talloc_free(r);
5145                 return false;
5146         }
5147
5148         ndr_err = call->ndr_push(push, NDR_OUT, r);
5149         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5150                 talloc_free(r);
5151                 return false;
5152         }
5153
5154         blob = ndr_push_blob(push);
5155         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5156                 talloc_free(r);
5157                 return false;
5158         }
5159
5160         talloc_free(r);
5161
5162         return true;
5163 }
5164
5165 static bool api_lsa_CREDRPROFILELOADED(pipes_struct *p)
5166 {
5167         const struct ndr_interface_call *call;
5168         struct ndr_pull *pull;
5169         struct ndr_push *push;
5170         enum ndr_err_code ndr_err;
5171         DATA_BLOB blob;
5172         struct lsa_CREDRPROFILELOADED *r;
5173
5174         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRPROFILELOADED];
5175
5176         r = talloc(talloc_tos(), struct lsa_CREDRPROFILELOADED);
5177         if (r == NULL) {
5178                 return false;
5179         }
5180
5181         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5182                 talloc_free(r);
5183                 return false;
5184         }
5185
5186         pull = ndr_pull_init_blob(&blob, r, NULL);
5187         if (pull == NULL) {
5188                 talloc_free(r);
5189                 return false;
5190         }
5191
5192         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5193         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5194         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5195                 talloc_free(r);
5196                 return false;
5197         }
5198
5199         if (DEBUGLEVEL >= 10) {
5200                 NDR_PRINT_IN_DEBUG(lsa_CREDRPROFILELOADED, r);
5201         }
5202
5203         r->out.result = _lsa_CREDRPROFILELOADED(p, r);
5204
5205         if (p->rng_fault_state) {
5206                 talloc_free(r);
5207                 /* Return true here, srv_pipe_hnd.c will take care */
5208                 return true;
5209         }
5210
5211         if (DEBUGLEVEL >= 10) {
5212                 NDR_PRINT_OUT_DEBUG(lsa_CREDRPROFILELOADED, r);
5213         }
5214
5215         push = ndr_push_init_ctx(r, NULL);
5216         if (push == NULL) {
5217                 talloc_free(r);
5218                 return false;
5219         }
5220
5221         ndr_err = call->ndr_push(push, NDR_OUT, r);
5222         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5223                 talloc_free(r);
5224                 return false;
5225         }
5226
5227         blob = ndr_push_blob(push);
5228         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5229                 talloc_free(r);
5230                 return false;
5231         }
5232
5233         talloc_free(r);
5234
5235         return true;
5236 }
5237
5238 static bool api_lsa_LookupNames3(pipes_struct *p)
5239 {
5240         const struct ndr_interface_call *call;
5241         struct ndr_pull *pull;
5242         struct ndr_push *push;
5243         enum ndr_err_code ndr_err;
5244         DATA_BLOB blob;
5245         struct lsa_LookupNames3 *r;
5246
5247         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPNAMES3];
5248
5249         r = talloc(talloc_tos(), struct lsa_LookupNames3);
5250         if (r == NULL) {
5251                 return false;
5252         }
5253
5254         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5255                 talloc_free(r);
5256                 return false;
5257         }
5258
5259         pull = ndr_pull_init_blob(&blob, r, NULL);
5260         if (pull == NULL) {
5261                 talloc_free(r);
5262                 return false;
5263         }
5264
5265         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5266         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5267         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5268                 talloc_free(r);
5269                 return false;
5270         }
5271
5272         if (DEBUGLEVEL >= 10) {
5273                 NDR_PRINT_IN_DEBUG(lsa_LookupNames3, r);
5274         }
5275
5276         ZERO_STRUCT(r->out);
5277         r->out.sids = r->in.sids;
5278         r->out.count = r->in.count;
5279         r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
5280         if (r->out.domains == NULL) {
5281                 talloc_free(r);
5282                 return false;
5283         }
5284
5285         r->out.result = _lsa_LookupNames3(p, r);
5286
5287         if (p->rng_fault_state) {
5288                 talloc_free(r);
5289                 /* Return true here, srv_pipe_hnd.c will take care */
5290                 return true;
5291         }
5292
5293         if (DEBUGLEVEL >= 10) {
5294                 NDR_PRINT_OUT_DEBUG(lsa_LookupNames3, r);
5295         }
5296
5297         push = ndr_push_init_ctx(r, NULL);
5298         if (push == NULL) {
5299                 talloc_free(r);
5300                 return false;
5301         }
5302
5303         ndr_err = call->ndr_push(push, NDR_OUT, r);
5304         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5305                 talloc_free(r);
5306                 return false;
5307         }
5308
5309         blob = ndr_push_blob(push);
5310         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5311                 talloc_free(r);
5312                 return false;
5313         }
5314
5315         talloc_free(r);
5316
5317         return true;
5318 }
5319
5320 static bool api_lsa_CREDRGETSESSIONTYPES(pipes_struct *p)
5321 {
5322         const struct ndr_interface_call *call;
5323         struct ndr_pull *pull;
5324         struct ndr_push *push;
5325         enum ndr_err_code ndr_err;
5326         DATA_BLOB blob;
5327         struct lsa_CREDRGETSESSIONTYPES *r;
5328
5329         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRGETSESSIONTYPES];
5330
5331         r = talloc(talloc_tos(), struct lsa_CREDRGETSESSIONTYPES);
5332         if (r == NULL) {
5333                 return false;
5334         }
5335
5336         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5337                 talloc_free(r);
5338                 return false;
5339         }
5340
5341         pull = ndr_pull_init_blob(&blob, r, NULL);
5342         if (pull == NULL) {
5343                 talloc_free(r);
5344                 return false;
5345         }
5346
5347         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5348         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5349         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5350                 talloc_free(r);
5351                 return false;
5352         }
5353
5354         if (DEBUGLEVEL >= 10) {
5355                 NDR_PRINT_IN_DEBUG(lsa_CREDRGETSESSIONTYPES, r);
5356         }
5357
5358         r->out.result = _lsa_CREDRGETSESSIONTYPES(p, r);
5359
5360         if (p->rng_fault_state) {
5361                 talloc_free(r);
5362                 /* Return true here, srv_pipe_hnd.c will take care */
5363                 return true;
5364         }
5365
5366         if (DEBUGLEVEL >= 10) {
5367                 NDR_PRINT_OUT_DEBUG(lsa_CREDRGETSESSIONTYPES, r);
5368         }
5369
5370         push = ndr_push_init_ctx(r, NULL);
5371         if (push == NULL) {
5372                 talloc_free(r);
5373                 return false;
5374         }
5375
5376         ndr_err = call->ndr_push(push, NDR_OUT, r);
5377         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5378                 talloc_free(r);
5379                 return false;
5380         }
5381
5382         blob = ndr_push_blob(push);
5383         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5384                 talloc_free(r);
5385                 return false;
5386         }
5387
5388         talloc_free(r);
5389
5390         return true;
5391 }
5392
5393 static bool api_lsa_LSARREGISTERAUDITEVENT(pipes_struct *p)
5394 {
5395         const struct ndr_interface_call *call;
5396         struct ndr_pull *pull;
5397         struct ndr_push *push;
5398         enum ndr_err_code ndr_err;
5399         DATA_BLOB blob;
5400         struct lsa_LSARREGISTERAUDITEVENT *r;
5401
5402         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARREGISTERAUDITEVENT];
5403
5404         r = talloc(talloc_tos(), struct lsa_LSARREGISTERAUDITEVENT);
5405         if (r == NULL) {
5406                 return false;
5407         }
5408
5409         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5410                 talloc_free(r);
5411                 return false;
5412         }
5413
5414         pull = ndr_pull_init_blob(&blob, r, NULL);
5415         if (pull == NULL) {
5416                 talloc_free(r);
5417                 return false;
5418         }
5419
5420         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5421         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5422         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5423                 talloc_free(r);
5424                 return false;
5425         }
5426
5427         if (DEBUGLEVEL >= 10) {
5428                 NDR_PRINT_IN_DEBUG(lsa_LSARREGISTERAUDITEVENT, r);
5429         }
5430
5431         r->out.result = _lsa_LSARREGISTERAUDITEVENT(p, r);
5432
5433         if (p->rng_fault_state) {
5434                 talloc_free(r);
5435                 /* Return true here, srv_pipe_hnd.c will take care */
5436                 return true;
5437         }
5438
5439         if (DEBUGLEVEL >= 10) {
5440                 NDR_PRINT_OUT_DEBUG(lsa_LSARREGISTERAUDITEVENT, r);
5441         }
5442
5443         push = ndr_push_init_ctx(r, NULL);
5444         if (push == NULL) {
5445                 talloc_free(r);
5446                 return false;
5447         }
5448
5449         ndr_err = call->ndr_push(push, NDR_OUT, r);
5450         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5451                 talloc_free(r);
5452                 return false;
5453         }
5454
5455         blob = ndr_push_blob(push);
5456         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5457                 talloc_free(r);
5458                 return false;
5459         }
5460
5461         talloc_free(r);
5462
5463         return true;
5464 }
5465
5466 static bool api_lsa_LSARGENAUDITEVENT(pipes_struct *p)
5467 {
5468         const struct ndr_interface_call *call;
5469         struct ndr_pull *pull;
5470         struct ndr_push *push;
5471         enum ndr_err_code ndr_err;
5472         DATA_BLOB blob;
5473         struct lsa_LSARGENAUDITEVENT *r;
5474
5475         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARGENAUDITEVENT];
5476
5477         r = talloc(talloc_tos(), struct lsa_LSARGENAUDITEVENT);
5478         if (r == NULL) {
5479                 return false;
5480         }
5481
5482         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5483                 talloc_free(r);
5484                 return false;
5485         }
5486
5487         pull = ndr_pull_init_blob(&blob, r, NULL);
5488         if (pull == NULL) {
5489                 talloc_free(r);
5490                 return false;
5491         }
5492
5493         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5494         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5495         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5496                 talloc_free(r);
5497                 return false;
5498         }
5499
5500         if (DEBUGLEVEL >= 10) {
5501                 NDR_PRINT_IN_DEBUG(lsa_LSARGENAUDITEVENT, r);
5502         }
5503
5504         r->out.result = _lsa_LSARGENAUDITEVENT(p, r);
5505
5506         if (p->rng_fault_state) {
5507                 talloc_free(r);
5508                 /* Return true here, srv_pipe_hnd.c will take care */
5509                 return true;
5510         }
5511
5512         if (DEBUGLEVEL >= 10) {
5513                 NDR_PRINT_OUT_DEBUG(lsa_LSARGENAUDITEVENT, r);
5514         }
5515
5516         push = ndr_push_init_ctx(r, NULL);
5517         if (push == NULL) {
5518                 talloc_free(r);
5519                 return false;
5520         }
5521
5522         ndr_err = call->ndr_push(push, NDR_OUT, r);
5523         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5524                 talloc_free(r);
5525                 return false;
5526         }
5527
5528         blob = ndr_push_blob(push);
5529         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5530                 talloc_free(r);
5531                 return false;
5532         }
5533
5534         talloc_free(r);
5535
5536         return true;
5537 }
5538
5539 static bool api_lsa_LSARUNREGISTERAUDITEVENT(pipes_struct *p)
5540 {
5541         const struct ndr_interface_call *call;
5542         struct ndr_pull *pull;
5543         struct ndr_push *push;
5544         enum ndr_err_code ndr_err;
5545         DATA_BLOB blob;
5546         struct lsa_LSARUNREGISTERAUDITEVENT *r;
5547
5548         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARUNREGISTERAUDITEVENT];
5549
5550         r = talloc(talloc_tos(), struct lsa_LSARUNREGISTERAUDITEVENT);
5551         if (r == NULL) {
5552                 return false;
5553         }
5554
5555         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5556                 talloc_free(r);
5557                 return false;
5558         }
5559
5560         pull = ndr_pull_init_blob(&blob, r, NULL);
5561         if (pull == NULL) {
5562                 talloc_free(r);
5563                 return false;
5564         }
5565
5566         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5567         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5568         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5569                 talloc_free(r);
5570                 return false;
5571         }
5572
5573         if (DEBUGLEVEL >= 10) {
5574                 NDR_PRINT_IN_DEBUG(lsa_LSARUNREGISTERAUDITEVENT, r);
5575         }
5576
5577         r->out.result = _lsa_LSARUNREGISTERAUDITEVENT(p, r);
5578
5579         if (p->rng_fault_state) {
5580                 talloc_free(r);
5581                 /* Return true here, srv_pipe_hnd.c will take care */
5582                 return true;
5583         }
5584
5585         if (DEBUGLEVEL >= 10) {
5586                 NDR_PRINT_OUT_DEBUG(lsa_LSARUNREGISTERAUDITEVENT, r);
5587         }
5588
5589         push = ndr_push_init_ctx(r, NULL);
5590         if (push == NULL) {
5591                 talloc_free(r);
5592                 return false;
5593         }
5594
5595         ndr_err = call->ndr_push(push, NDR_OUT, r);
5596         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5597                 talloc_free(r);
5598                 return false;
5599         }
5600
5601         blob = ndr_push_blob(push);
5602         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5603                 talloc_free(r);
5604                 return false;
5605         }
5606
5607         talloc_free(r);
5608
5609         return true;
5610 }
5611
5612 static bool api_lsa_lsaRQueryForestTrustInformation(pipes_struct *p)
5613 {
5614         const struct ndr_interface_call *call;
5615         struct ndr_pull *pull;
5616         struct ndr_push *push;
5617         enum ndr_err_code ndr_err;
5618         DATA_BLOB blob;
5619         struct lsa_lsaRQueryForestTrustInformation *r;
5620
5621         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION];
5622
5623         r = talloc(talloc_tos(), struct lsa_lsaRQueryForestTrustInformation);
5624         if (r == NULL) {
5625                 return false;
5626         }
5627
5628         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5629                 talloc_free(r);
5630                 return false;
5631         }
5632
5633         pull = ndr_pull_init_blob(&blob, r, NULL);
5634         if (pull == NULL) {
5635                 talloc_free(r);
5636                 return false;
5637         }
5638
5639         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5640         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5641         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5642                 talloc_free(r);
5643                 return false;
5644         }
5645
5646         if (DEBUGLEVEL >= 10) {
5647                 NDR_PRINT_IN_DEBUG(lsa_lsaRQueryForestTrustInformation, r);
5648         }
5649
5650         ZERO_STRUCT(r->out);
5651         r->out.forest_trust_info = talloc_zero(r, struct lsa_ForestTrustInformation *);
5652         if (r->out.forest_trust_info == NULL) {
5653                 talloc_free(r);
5654                 return false;
5655         }
5656
5657         r->out.result = _lsa_lsaRQueryForestTrustInformation(p, r);
5658
5659         if (p->rng_fault_state) {
5660                 talloc_free(r);
5661                 /* Return true here, srv_pipe_hnd.c will take care */
5662                 return true;
5663         }
5664
5665         if (DEBUGLEVEL >= 10) {
5666                 NDR_PRINT_OUT_DEBUG(lsa_lsaRQueryForestTrustInformation, r);
5667         }
5668
5669         push = ndr_push_init_ctx(r, NULL);
5670         if (push == NULL) {
5671                 talloc_free(r);
5672                 return false;
5673         }
5674
5675         ndr_err = call->ndr_push(push, NDR_OUT, r);
5676         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5677                 talloc_free(r);
5678                 return false;
5679         }
5680
5681         blob = ndr_push_blob(push);
5682         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5683                 talloc_free(r);
5684                 return false;
5685         }
5686
5687         talloc_free(r);
5688
5689         return true;
5690 }
5691
5692 static bool api_lsa_lsaRSetForestTrustInformation(pipes_struct *p)
5693 {
5694         const struct ndr_interface_call *call;
5695         struct ndr_pull *pull;
5696         struct ndr_push *push;
5697         enum ndr_err_code ndr_err;
5698         DATA_BLOB blob;
5699         struct lsa_lsaRSetForestTrustInformation *r;
5700
5701         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARSETFORESTTRUSTINFORMATION];
5702
5703         r = talloc(talloc_tos(), struct lsa_lsaRSetForestTrustInformation);
5704         if (r == NULL) {
5705                 return false;
5706         }
5707
5708         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5709                 talloc_free(r);
5710                 return false;
5711         }
5712
5713         pull = ndr_pull_init_blob(&blob, r, NULL);
5714         if (pull == NULL) {
5715                 talloc_free(r);
5716                 return false;
5717         }
5718
5719         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5720         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5721         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5722                 talloc_free(r);
5723                 return false;
5724         }
5725
5726         if (DEBUGLEVEL >= 10) {
5727                 NDR_PRINT_IN_DEBUG(lsa_lsaRSetForestTrustInformation, r);
5728         }
5729
5730         ZERO_STRUCT(r->out);
5731         r->out.collision_info = talloc_zero(r, struct lsa_ForestTrustCollisionInfo *);
5732         if (r->out.collision_info == NULL) {
5733                 talloc_free(r);
5734                 return false;
5735         }
5736
5737         r->out.result = _lsa_lsaRSetForestTrustInformation(p, r);
5738
5739         if (p->rng_fault_state) {
5740                 talloc_free(r);
5741                 /* Return true here, srv_pipe_hnd.c will take care */
5742                 return true;
5743         }
5744
5745         if (DEBUGLEVEL >= 10) {
5746                 NDR_PRINT_OUT_DEBUG(lsa_lsaRSetForestTrustInformation, r);
5747         }
5748
5749         push = ndr_push_init_ctx(r, NULL);
5750         if (push == NULL) {
5751                 talloc_free(r);
5752                 return false;
5753         }
5754
5755         ndr_err = call->ndr_push(push, NDR_OUT, r);
5756         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5757                 talloc_free(r);
5758                 return false;
5759         }
5760
5761         blob = ndr_push_blob(push);
5762         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5763                 talloc_free(r);
5764                 return false;
5765         }
5766
5767         talloc_free(r);
5768
5769         return true;
5770 }
5771
5772 static bool api_lsa_CREDRRENAME(pipes_struct *p)
5773 {
5774         const struct ndr_interface_call *call;
5775         struct ndr_pull *pull;
5776         struct ndr_push *push;
5777         enum ndr_err_code ndr_err;
5778         DATA_BLOB blob;
5779         struct lsa_CREDRRENAME *r;
5780
5781         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRRENAME];
5782
5783         r = talloc(talloc_tos(), struct lsa_CREDRRENAME);
5784         if (r == NULL) {
5785                 return false;
5786         }
5787
5788         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5789                 talloc_free(r);
5790                 return false;
5791         }
5792
5793         pull = ndr_pull_init_blob(&blob, r, NULL);
5794         if (pull == NULL) {
5795                 talloc_free(r);
5796                 return false;
5797         }
5798
5799         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5800         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5801         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5802                 talloc_free(r);
5803                 return false;
5804         }
5805
5806         if (DEBUGLEVEL >= 10) {
5807                 NDR_PRINT_IN_DEBUG(lsa_CREDRRENAME, r);
5808         }
5809
5810         r->out.result = _lsa_CREDRRENAME(p, r);
5811
5812         if (p->rng_fault_state) {
5813                 talloc_free(r);
5814                 /* Return true here, srv_pipe_hnd.c will take care */
5815                 return true;
5816         }
5817
5818         if (DEBUGLEVEL >= 10) {
5819                 NDR_PRINT_OUT_DEBUG(lsa_CREDRRENAME, r);
5820         }
5821
5822         push = ndr_push_init_ctx(r, NULL);
5823         if (push == NULL) {
5824                 talloc_free(r);
5825                 return false;
5826         }
5827
5828         ndr_err = call->ndr_push(push, NDR_OUT, r);
5829         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5830                 talloc_free(r);
5831                 return false;
5832         }
5833
5834         blob = ndr_push_blob(push);
5835         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5836                 talloc_free(r);
5837                 return false;
5838         }
5839
5840         talloc_free(r);
5841
5842         return true;
5843 }
5844
5845 static bool api_lsa_LookupSids3(pipes_struct *p)
5846 {
5847         const struct ndr_interface_call *call;
5848         struct ndr_pull *pull;
5849         struct ndr_push *push;
5850         enum ndr_err_code ndr_err;
5851         DATA_BLOB blob;
5852         struct lsa_LookupSids3 *r;
5853
5854         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPSIDS3];
5855
5856         r = talloc(talloc_tos(), struct lsa_LookupSids3);
5857         if (r == NULL) {
5858                 return false;
5859         }
5860
5861         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5862                 talloc_free(r);
5863                 return false;
5864         }
5865
5866         pull = ndr_pull_init_blob(&blob, r, NULL);
5867         if (pull == NULL) {
5868                 talloc_free(r);
5869                 return false;
5870         }
5871
5872         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5873         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5874         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5875                 talloc_free(r);
5876                 return false;
5877         }
5878
5879         if (DEBUGLEVEL >= 10) {
5880                 NDR_PRINT_IN_DEBUG(lsa_LookupSids3, r);
5881         }
5882
5883         ZERO_STRUCT(r->out);
5884         r->out.names = r->in.names;
5885         r->out.count = r->in.count;
5886         r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
5887         if (r->out.domains == NULL) {
5888                 talloc_free(r);
5889                 return false;
5890         }
5891
5892         r->out.result = _lsa_LookupSids3(p, r);
5893
5894         if (p->rng_fault_state) {
5895                 talloc_free(r);
5896                 /* Return true here, srv_pipe_hnd.c will take care */
5897                 return true;
5898         }
5899
5900         if (DEBUGLEVEL >= 10) {
5901                 NDR_PRINT_OUT_DEBUG(lsa_LookupSids3, r);
5902         }
5903
5904         push = ndr_push_init_ctx(r, NULL);
5905         if (push == NULL) {
5906                 talloc_free(r);
5907                 return false;
5908         }
5909
5910         ndr_err = call->ndr_push(push, NDR_OUT, r);
5911         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5912                 talloc_free(r);
5913                 return false;
5914         }
5915
5916         blob = ndr_push_blob(push);
5917         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5918                 talloc_free(r);
5919                 return false;
5920         }
5921
5922         talloc_free(r);
5923
5924         return true;
5925 }
5926
5927 static bool api_lsa_LookupNames4(pipes_struct *p)
5928 {
5929         const struct ndr_interface_call *call;
5930         struct ndr_pull *pull;
5931         struct ndr_push *push;
5932         enum ndr_err_code ndr_err;
5933         DATA_BLOB blob;
5934         struct lsa_LookupNames4 *r;
5935
5936         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPNAMES4];
5937
5938         r = talloc(talloc_tos(), struct lsa_LookupNames4);
5939         if (r == NULL) {
5940                 return false;
5941         }
5942
5943         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5944                 talloc_free(r);
5945                 return false;
5946         }
5947
5948         pull = ndr_pull_init_blob(&blob, r, NULL);
5949         if (pull == NULL) {
5950                 talloc_free(r);
5951                 return false;
5952         }
5953
5954         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5955         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5956         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5957                 talloc_free(r);
5958                 return false;
5959         }
5960
5961         if (DEBUGLEVEL >= 10) {
5962                 NDR_PRINT_IN_DEBUG(lsa_LookupNames4, r);
5963         }
5964
5965         ZERO_STRUCT(r->out);
5966         r->out.sids = r->in.sids;
5967         r->out.count = r->in.count;
5968         r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
5969         if (r->out.domains == NULL) {
5970                 talloc_free(r);
5971                 return false;
5972         }
5973
5974         r->out.result = _lsa_LookupNames4(p, r);
5975
5976         if (p->rng_fault_state) {
5977                 talloc_free(r);
5978                 /* Return true here, srv_pipe_hnd.c will take care */
5979                 return true;
5980         }
5981
5982         if (DEBUGLEVEL >= 10) {
5983                 NDR_PRINT_OUT_DEBUG(lsa_LookupNames4, r);
5984         }
5985
5986         push = ndr_push_init_ctx(r, NULL);
5987         if (push == NULL) {
5988                 talloc_free(r);
5989                 return false;
5990         }
5991
5992         ndr_err = call->ndr_push(push, NDR_OUT, r);
5993         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5994                 talloc_free(r);
5995                 return false;
5996         }
5997
5998         blob = ndr_push_blob(push);
5999         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6000                 talloc_free(r);
6001                 return false;
6002         }
6003
6004         talloc_free(r);
6005
6006         return true;
6007 }
6008
6009 static bool api_lsa_LSAROPENPOLICYSCE(pipes_struct *p)
6010 {
6011         const struct ndr_interface_call *call;
6012         struct ndr_pull *pull;
6013         struct ndr_push *push;
6014         enum ndr_err_code ndr_err;
6015         DATA_BLOB blob;
6016         struct lsa_LSAROPENPOLICYSCE *r;
6017
6018         call = &ndr_table_lsarpc.calls[NDR_LSA_LSAROPENPOLICYSCE];
6019
6020         r = talloc(talloc_tos(), struct lsa_LSAROPENPOLICYSCE);
6021         if (r == NULL) {
6022                 return false;
6023         }
6024
6025         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6026                 talloc_free(r);
6027                 return false;
6028         }
6029
6030         pull = ndr_pull_init_blob(&blob, r, NULL);
6031         if (pull == NULL) {
6032                 talloc_free(r);
6033                 return false;
6034         }
6035
6036         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6037         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6038         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6039                 talloc_free(r);
6040                 return false;
6041         }
6042
6043         if (DEBUGLEVEL >= 10) {
6044                 NDR_PRINT_IN_DEBUG(lsa_LSAROPENPOLICYSCE, r);
6045         }
6046
6047         r->out.result = _lsa_LSAROPENPOLICYSCE(p, r);
6048
6049         if (p->rng_fault_state) {
6050                 talloc_free(r);
6051                 /* Return true here, srv_pipe_hnd.c will take care */
6052                 return true;
6053         }
6054
6055         if (DEBUGLEVEL >= 10) {
6056                 NDR_PRINT_OUT_DEBUG(lsa_LSAROPENPOLICYSCE, r);
6057         }
6058
6059         push = ndr_push_init_ctx(r, NULL);
6060         if (push == NULL) {
6061                 talloc_free(r);
6062                 return false;
6063         }
6064
6065         ndr_err = call->ndr_push(push, NDR_OUT, r);
6066         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6067                 talloc_free(r);
6068                 return false;
6069         }
6070
6071         blob = ndr_push_blob(push);
6072         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6073                 talloc_free(r);
6074                 return false;
6075         }
6076
6077         talloc_free(r);
6078
6079         return true;
6080 }
6081
6082 static bool api_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(pipes_struct *p)
6083 {
6084         const struct ndr_interface_call *call;
6085         struct ndr_pull *pull;
6086         struct ndr_push *push;
6087         enum ndr_err_code ndr_err;
6088         DATA_BLOB blob;
6089         struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r;
6090
6091         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE];
6092
6093         r = talloc(talloc_tos(), struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE);
6094         if (r == NULL) {
6095                 return false;
6096         }
6097
6098         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6099                 talloc_free(r);
6100                 return false;
6101         }
6102
6103         pull = ndr_pull_init_blob(&blob, r, NULL);
6104         if (pull == NULL) {
6105                 talloc_free(r);
6106                 return false;
6107         }
6108
6109         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6110         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6111         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6112                 talloc_free(r);
6113                 return false;
6114         }
6115
6116         if (DEBUGLEVEL >= 10) {
6117                 NDR_PRINT_IN_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, r);
6118         }
6119
6120         r->out.result = _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(p, r);
6121
6122         if (p->rng_fault_state) {
6123                 talloc_free(r);
6124                 /* Return true here, srv_pipe_hnd.c will take care */
6125                 return true;
6126         }
6127
6128         if (DEBUGLEVEL >= 10) {
6129                 NDR_PRINT_OUT_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, r);
6130         }
6131
6132         push = ndr_push_init_ctx(r, NULL);
6133         if (push == NULL) {
6134                 talloc_free(r);
6135                 return false;
6136         }
6137
6138         ndr_err = call->ndr_push(push, NDR_OUT, r);
6139         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6140                 talloc_free(r);
6141                 return false;
6142         }
6143
6144         blob = ndr_push_blob(push);
6145         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6146                 talloc_free(r);
6147                 return false;
6148         }
6149
6150         talloc_free(r);
6151
6152         return true;
6153 }
6154
6155 static bool api_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(pipes_struct *p)
6156 {
6157         const struct ndr_interface_call *call;
6158         struct ndr_pull *pull;
6159         struct ndr_push *push;
6160         enum ndr_err_code ndr_err;
6161         DATA_BLOB blob;
6162         struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r;
6163
6164         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE];
6165
6166         r = talloc(talloc_tos(), struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE);
6167         if (r == NULL) {
6168                 return false;
6169         }
6170
6171         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6172                 talloc_free(r);
6173                 return false;
6174         }
6175
6176         pull = ndr_pull_init_blob(&blob, r, NULL);
6177         if (pull == NULL) {
6178                 talloc_free(r);
6179                 return false;
6180         }
6181
6182         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6183         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6184         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6185                 talloc_free(r);
6186                 return false;
6187         }
6188
6189         if (DEBUGLEVEL >= 10) {
6190                 NDR_PRINT_IN_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, r);
6191         }
6192
6193         r->out.result = _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(p, r);
6194
6195         if (p->rng_fault_state) {
6196                 talloc_free(r);
6197                 /* Return true here, srv_pipe_hnd.c will take care */
6198                 return true;
6199         }
6200
6201         if (DEBUGLEVEL >= 10) {
6202                 NDR_PRINT_OUT_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, r);
6203         }
6204
6205         push = ndr_push_init_ctx(r, NULL);
6206         if (push == NULL) {
6207                 talloc_free(r);
6208                 return false;
6209         }
6210
6211         ndr_err = call->ndr_push(push, NDR_OUT, r);
6212         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6213                 talloc_free(r);
6214                 return false;
6215         }
6216
6217         blob = ndr_push_blob(push);
6218         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6219                 talloc_free(r);
6220                 return false;
6221         }
6222
6223         talloc_free(r);
6224
6225         return true;
6226 }
6227
6228 static bool api_lsa_LSARADTREPORTSECURITYEVENT(pipes_struct *p)
6229 {
6230         const struct ndr_interface_call *call;
6231         struct ndr_pull *pull;
6232         struct ndr_push *push;
6233         enum ndr_err_code ndr_err;
6234         DATA_BLOB blob;
6235         struct lsa_LSARADTREPORTSECURITYEVENT *r;
6236
6237         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARADTREPORTSECURITYEVENT];
6238
6239         r = talloc(talloc_tos(), struct lsa_LSARADTREPORTSECURITYEVENT);
6240         if (r == NULL) {
6241                 return false;
6242         }
6243
6244         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6245                 talloc_free(r);
6246                 return false;
6247         }
6248
6249         pull = ndr_pull_init_blob(&blob, r, NULL);
6250         if (pull == NULL) {
6251                 talloc_free(r);
6252                 return false;
6253         }
6254
6255         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6256         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6257         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6258                 talloc_free(r);
6259                 return false;
6260         }
6261
6262         if (DEBUGLEVEL >= 10) {
6263                 NDR_PRINT_IN_DEBUG(lsa_LSARADTREPORTSECURITYEVENT, r);
6264         }
6265
6266         r->out.result = _lsa_LSARADTREPORTSECURITYEVENT(p, r);
6267
6268         if (p->rng_fault_state) {
6269                 talloc_free(r);
6270                 /* Return true here, srv_pipe_hnd.c will take care */
6271                 return true;
6272         }
6273
6274         if (DEBUGLEVEL >= 10) {
6275                 NDR_PRINT_OUT_DEBUG(lsa_LSARADTREPORTSECURITYEVENT, r);
6276         }
6277
6278         push = ndr_push_init_ctx(r, NULL);
6279         if (push == NULL) {
6280                 talloc_free(r);
6281                 return false;
6282         }
6283
6284         ndr_err = call->ndr_push(push, NDR_OUT, r);
6285         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6286                 talloc_free(r);
6287                 return false;
6288         }
6289
6290         blob = ndr_push_blob(push);
6291         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6292                 talloc_free(r);
6293                 return false;
6294         }
6295
6296         talloc_free(r);
6297
6298         return true;
6299 }
6300
6301
6302 /* Tables */
6303 static struct api_struct api_lsarpc_cmds[] =
6304 {
6305         {"LSA_CLOSE", NDR_LSA_CLOSE, api_lsa_Close},
6306         {"LSA_DELETE", NDR_LSA_DELETE, api_lsa_Delete},
6307         {"LSA_ENUMPRIVS", NDR_LSA_ENUMPRIVS, api_lsa_EnumPrivs},
6308         {"LSA_QUERYSECURITY", NDR_LSA_QUERYSECURITY, api_lsa_QuerySecurity},
6309         {"LSA_SETSECOBJ", NDR_LSA_SETSECOBJ, api_lsa_SetSecObj},
6310         {"LSA_CHANGEPASSWORD", NDR_LSA_CHANGEPASSWORD, api_lsa_ChangePassword},
6311         {"LSA_OPENPOLICY", NDR_LSA_OPENPOLICY, api_lsa_OpenPolicy},
6312         {"LSA_QUERYINFOPOLICY", NDR_LSA_QUERYINFOPOLICY, api_lsa_QueryInfoPolicy},
6313         {"LSA_SETINFOPOLICY", NDR_LSA_SETINFOPOLICY, api_lsa_SetInfoPolicy},
6314         {"LSA_CLEARAUDITLOG", NDR_LSA_CLEARAUDITLOG, api_lsa_ClearAuditLog},
6315         {"LSA_CREATEACCOUNT", NDR_LSA_CREATEACCOUNT, api_lsa_CreateAccount},
6316         {"LSA_ENUMACCOUNTS", NDR_LSA_ENUMACCOUNTS, api_lsa_EnumAccounts},
6317         {"LSA_CREATETRUSTEDDOMAIN", NDR_LSA_CREATETRUSTEDDOMAIN, api_lsa_CreateTrustedDomain},
6318         {"LSA_ENUMTRUSTDOM", NDR_LSA_ENUMTRUSTDOM, api_lsa_EnumTrustDom},
6319         {"LSA_LOOKUPNAMES", NDR_LSA_LOOKUPNAMES, api_lsa_LookupNames},
6320         {"LSA_LOOKUPSIDS", NDR_LSA_LOOKUPSIDS, api_lsa_LookupSids},
6321         {"LSA_CREATESECRET", NDR_LSA_CREATESECRET, api_lsa_CreateSecret},
6322         {"LSA_OPENACCOUNT", NDR_LSA_OPENACCOUNT, api_lsa_OpenAccount},
6323         {"LSA_ENUMPRIVSACCOUNT", NDR_LSA_ENUMPRIVSACCOUNT, api_lsa_EnumPrivsAccount},
6324         {"LSA_ADDPRIVILEGESTOACCOUNT", NDR_LSA_ADDPRIVILEGESTOACCOUNT, api_lsa_AddPrivilegesToAccount},
6325         {"LSA_REMOVEPRIVILEGESFROMACCOUNT", NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT, api_lsa_RemovePrivilegesFromAccount},
6326         {"LSA_GETQUOTASFORACCOUNT", NDR_LSA_GETQUOTASFORACCOUNT, api_lsa_GetQuotasForAccount},
6327         {"LSA_SETQUOTASFORACCOUNT", NDR_LSA_SETQUOTASFORACCOUNT, api_lsa_SetQuotasForAccount},
6328         {"LSA_GETSYSTEMACCESSACCOUNT", NDR_LSA_GETSYSTEMACCESSACCOUNT, api_lsa_GetSystemAccessAccount},
6329         {"LSA_SETSYSTEMACCESSACCOUNT", NDR_LSA_SETSYSTEMACCESSACCOUNT, api_lsa_SetSystemAccessAccount},
6330         {"LSA_OPENTRUSTEDDOMAIN", NDR_LSA_OPENTRUSTEDDOMAIN, api_lsa_OpenTrustedDomain},
6331         {"LSA_QUERYTRUSTEDDOMAININFO", NDR_LSA_QUERYTRUSTEDDOMAININFO, api_lsa_QueryTrustedDomainInfo},
6332         {"LSA_SETINFORMATIONTRUSTEDDOMAIN", NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN, api_lsa_SetInformationTrustedDomain},
6333         {"LSA_OPENSECRET", NDR_LSA_OPENSECRET, api_lsa_OpenSecret},
6334         {"LSA_SETSECRET", NDR_LSA_SETSECRET, api_lsa_SetSecret},
6335         {"LSA_QUERYSECRET", NDR_LSA_QUERYSECRET, api_lsa_QuerySecret},
6336         {"LSA_LOOKUPPRIVVALUE", NDR_LSA_LOOKUPPRIVVALUE, api_lsa_LookupPrivValue},
6337         {"LSA_LOOKUPPRIVNAME", NDR_LSA_LOOKUPPRIVNAME, api_lsa_LookupPrivName},
6338         {"LSA_LOOKUPPRIVDISPLAYNAME", NDR_LSA_LOOKUPPRIVDISPLAYNAME, api_lsa_LookupPrivDisplayName},
6339         {"LSA_DELETEOBJECT", NDR_LSA_DELETEOBJECT, api_lsa_DeleteObject},
6340         {"LSA_ENUMACCOUNTSWITHUSERRIGHT", NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT, api_lsa_EnumAccountsWithUserRight},
6341         {"LSA_ENUMACCOUNTRIGHTS", NDR_LSA_ENUMACCOUNTRIGHTS, api_lsa_EnumAccountRights},
6342         {"LSA_ADDACCOUNTRIGHTS", NDR_LSA_ADDACCOUNTRIGHTS, api_lsa_AddAccountRights},
6343         {"LSA_REMOVEACCOUNTRIGHTS", NDR_LSA_REMOVEACCOUNTRIGHTS, api_lsa_RemoveAccountRights},
6344         {"LSA_QUERYTRUSTEDDOMAININFOBYSID", NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID, api_lsa_QueryTrustedDomainInfoBySid},
6345         {"LSA_SETTRUSTEDDOMAININFO", NDR_LSA_SETTRUSTEDDOMAININFO, api_lsa_SetTrustedDomainInfo},
6346         {"LSA_DELETETRUSTEDDOMAIN", NDR_LSA_DELETETRUSTEDDOMAIN, api_lsa_DeleteTrustedDomain},
6347         {"LSA_STOREPRIVATEDATA", NDR_LSA_STOREPRIVATEDATA, api_lsa_StorePrivateData},
6348         {"LSA_RETRIEVEPRIVATEDATA", NDR_LSA_RETRIEVEPRIVATEDATA, api_lsa_RetrievePrivateData},
6349         {"LSA_OPENPOLICY2", NDR_LSA_OPENPOLICY2, api_lsa_OpenPolicy2},
6350         {"LSA_GETUSERNAME", NDR_LSA_GETUSERNAME, api_lsa_GetUserName},
6351         {"LSA_QUERYINFOPOLICY2", NDR_LSA_QUERYINFOPOLICY2, api_lsa_QueryInfoPolicy2},
6352         {"LSA_SETINFOPOLICY2", NDR_LSA_SETINFOPOLICY2, api_lsa_SetInfoPolicy2},
6353         {"LSA_QUERYTRUSTEDDOMAININFOBYNAME", NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME, api_lsa_QueryTrustedDomainInfoByName},
6354         {"LSA_SETTRUSTEDDOMAININFOBYNAME", NDR_LSA_SETTRUSTEDDOMAININFOBYNAME, api_lsa_SetTrustedDomainInfoByName},
6355         {"LSA_ENUMTRUSTEDDOMAINSEX", NDR_LSA_ENUMTRUSTEDDOMAINSEX, api_lsa_EnumTrustedDomainsEx},
6356         {"LSA_CREATETRUSTEDDOMAINEX", NDR_LSA_CREATETRUSTEDDOMAINEX, api_lsa_CreateTrustedDomainEx},
6357         {"LSA_CLOSETRUSTEDDOMAINEX", NDR_LSA_CLOSETRUSTEDDOMAINEX, api_lsa_CloseTrustedDomainEx},
6358         {"LSA_QUERYDOMAININFORMATIONPOLICY", NDR_LSA_QUERYDOMAININFORMATIONPOLICY, api_lsa_QueryDomainInformationPolicy},
6359         {"LSA_SETDOMAININFORMATIONPOLICY", NDR_LSA_SETDOMAININFORMATIONPOLICY, api_lsa_SetDomainInformationPolicy},
6360         {"LSA_OPENTRUSTEDDOMAINBYNAME", NDR_LSA_OPENTRUSTEDDOMAINBYNAME, api_lsa_OpenTrustedDomainByName},
6361         {"LSA_TESTCALL", NDR_LSA_TESTCALL, api_lsa_TestCall},
6362         {"LSA_LOOKUPSIDS2", NDR_LSA_LOOKUPSIDS2, api_lsa_LookupSids2},
6363         {"LSA_LOOKUPNAMES2", NDR_LSA_LOOKUPNAMES2, api_lsa_LookupNames2},
6364         {"LSA_CREATETRUSTEDDOMAINEX2", NDR_LSA_CREATETRUSTEDDOMAINEX2, api_lsa_CreateTrustedDomainEx2},
6365         {"LSA_CREDRWRITE", NDR_LSA_CREDRWRITE, api_lsa_CREDRWRITE},
6366         {"LSA_CREDRREAD", NDR_LSA_CREDRREAD, api_lsa_CREDRREAD},
6367         {"LSA_CREDRENUMERATE", NDR_LSA_CREDRENUMERATE, api_lsa_CREDRENUMERATE},
6368         {"LSA_CREDRWRITEDOMAINCREDENTIALS", NDR_LSA_CREDRWRITEDOMAINCREDENTIALS, api_lsa_CREDRWRITEDOMAINCREDENTIALS},
6369         {"LSA_CREDRREADDOMAINCREDENTIALS", NDR_LSA_CREDRREADDOMAINCREDENTIALS, api_lsa_CREDRREADDOMAINCREDENTIALS},
6370         {"LSA_CREDRDELETE", NDR_LSA_CREDRDELETE, api_lsa_CREDRDELETE},
6371         {"LSA_CREDRGETTARGETINFO", NDR_LSA_CREDRGETTARGETINFO, api_lsa_CREDRGETTARGETINFO},
6372         {"LSA_CREDRPROFILELOADED", NDR_LSA_CREDRPROFILELOADED, api_lsa_CREDRPROFILELOADED},
6373         {"LSA_LOOKUPNAMES3", NDR_LSA_LOOKUPNAMES3, api_lsa_LookupNames3},
6374         {"LSA_CREDRGETSESSIONTYPES", NDR_LSA_CREDRGETSESSIONTYPES, api_lsa_CREDRGETSESSIONTYPES},
6375         {"LSA_LSARREGISTERAUDITEVENT", NDR_LSA_LSARREGISTERAUDITEVENT, api_lsa_LSARREGISTERAUDITEVENT},
6376         {"LSA_LSARGENAUDITEVENT", NDR_LSA_LSARGENAUDITEVENT, api_lsa_LSARGENAUDITEVENT},
6377         {"LSA_LSARUNREGISTERAUDITEVENT", NDR_LSA_LSARUNREGISTERAUDITEVENT, api_lsa_LSARUNREGISTERAUDITEVENT},
6378         {"LSA_LSARQUERYFORESTTRUSTINFORMATION", NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION, api_lsa_lsaRQueryForestTrustInformation},
6379         {"LSA_LSARSETFORESTTRUSTINFORMATION", NDR_LSA_LSARSETFORESTTRUSTINFORMATION, api_lsa_lsaRSetForestTrustInformation},
6380         {"LSA_CREDRRENAME", NDR_LSA_CREDRRENAME, api_lsa_CREDRRENAME},
6381         {"LSA_LOOKUPSIDS3", NDR_LSA_LOOKUPSIDS3, api_lsa_LookupSids3},
6382         {"LSA_LOOKUPNAMES4", NDR_LSA_LOOKUPNAMES4, api_lsa_LookupNames4},
6383         {"LSA_LSAROPENPOLICYSCE", NDR_LSA_LSAROPENPOLICYSCE, api_lsa_LSAROPENPOLICYSCE},
6384         {"LSA_LSARADTREGISTERSECURITYEVENTSOURCE", NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE, api_lsa_LSARADTREGISTERSECURITYEVENTSOURCE},
6385         {"LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE", NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE, api_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE},
6386         {"LSA_LSARADTREPORTSECURITYEVENT", NDR_LSA_LSARADTREPORTSECURITYEVENT, api_lsa_LSARADTREPORTSECURITYEVENT},
6387 };
6388
6389 void lsarpc_get_pipe_fns(struct api_struct **fns, int *n_fns)
6390 {
6391         *fns = api_lsarpc_cmds;
6392         *n_fns = sizeof(api_lsarpc_cmds) / sizeof(struct api_struct);
6393 }
6394
6395 NTSTATUS rpc_lsarpc_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r)
6396 {
6397         if (cli->pipes_struct == NULL) {
6398                 return NT_STATUS_INVALID_PARAMETER;
6399         }
6400
6401         switch (opnum)
6402         {
6403                 case NDR_LSA_CLOSE: {
6404                         struct lsa_Close *r = (struct lsa_Close *)_r;
6405                         ZERO_STRUCT(r->out);
6406                         r->out.handle = r->in.handle;
6407                         r->out.result = _lsa_Close(cli->pipes_struct, r);
6408                         return NT_STATUS_OK;
6409                 }
6410
6411                 case NDR_LSA_DELETE: {
6412                         struct lsa_Delete *r = (struct lsa_Delete *)_r;
6413                         r->out.result = _lsa_Delete(cli->pipes_struct, r);
6414                         return NT_STATUS_OK;
6415                 }
6416
6417                 case NDR_LSA_ENUMPRIVS: {
6418                         struct lsa_EnumPrivs *r = (struct lsa_EnumPrivs *)_r;
6419                         ZERO_STRUCT(r->out);
6420                         r->out.resume_handle = r->in.resume_handle;
6421                         r->out.privs = talloc_zero(mem_ctx, struct lsa_PrivArray);
6422                         if (r->out.privs == NULL) {
6423                         return NT_STATUS_NO_MEMORY;
6424                         }
6425
6426                         r->out.result = _lsa_EnumPrivs(cli->pipes_struct, r);
6427                         return NT_STATUS_OK;
6428                 }
6429
6430                 case NDR_LSA_QUERYSECURITY: {
6431                         struct lsa_QuerySecurity *r = (struct lsa_QuerySecurity *)_r;
6432                         ZERO_STRUCT(r->out);
6433                         r->out.sdbuf = talloc_zero(mem_ctx, struct sec_desc_buf *);
6434                         if (r->out.sdbuf == NULL) {
6435                         return NT_STATUS_NO_MEMORY;
6436                         }
6437
6438                         r->out.result = _lsa_QuerySecurity(cli->pipes_struct, r);
6439                         return NT_STATUS_OK;
6440                 }
6441
6442                 case NDR_LSA_SETSECOBJ: {
6443                         struct lsa_SetSecObj *r = (struct lsa_SetSecObj *)_r;
6444                         r->out.result = _lsa_SetSecObj(cli->pipes_struct, r);
6445                         return NT_STATUS_OK;
6446                 }
6447
6448                 case NDR_LSA_CHANGEPASSWORD: {
6449                         struct lsa_ChangePassword *r = (struct lsa_ChangePassword *)_r;
6450                         r->out.result = _lsa_ChangePassword(cli->pipes_struct, r);
6451                         return NT_STATUS_OK;
6452                 }
6453
6454                 case NDR_LSA_OPENPOLICY: {
6455                         struct lsa_OpenPolicy *r = (struct lsa_OpenPolicy *)_r;
6456                         ZERO_STRUCT(r->out);
6457                         r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
6458                         if (r->out.handle == NULL) {
6459                         return NT_STATUS_NO_MEMORY;
6460                         }
6461
6462                         r->out.result = _lsa_OpenPolicy(cli->pipes_struct, r);
6463                         return NT_STATUS_OK;
6464                 }
6465
6466                 case NDR_LSA_QUERYINFOPOLICY: {
6467                         struct lsa_QueryInfoPolicy *r = (struct lsa_QueryInfoPolicy *)_r;
6468                         ZERO_STRUCT(r->out);
6469                         r->out.info = talloc_zero(mem_ctx, union lsa_PolicyInformation *);
6470                         if (r->out.info == NULL) {
6471                         return NT_STATUS_NO_MEMORY;
6472                         }
6473
6474                         r->out.result = _lsa_QueryInfoPolicy(cli->pipes_struct, r);
6475                         return NT_STATUS_OK;
6476                 }
6477
6478                 case NDR_LSA_SETINFOPOLICY: {
6479                         struct lsa_SetInfoPolicy *r = (struct lsa_SetInfoPolicy *)_r;
6480                         r->out.result = _lsa_SetInfoPolicy(cli->pipes_struct, r);
6481                         return NT_STATUS_OK;
6482                 }
6483
6484                 case NDR_LSA_CLEARAUDITLOG: {
6485                         struct lsa_ClearAuditLog *r = (struct lsa_ClearAuditLog *)_r;
6486                         r->out.result = _lsa_ClearAuditLog(cli->pipes_struct, r);
6487                         return NT_STATUS_OK;
6488                 }
6489
6490                 case NDR_LSA_CREATEACCOUNT: {
6491                         struct lsa_CreateAccount *r = (struct lsa_CreateAccount *)_r;
6492                         ZERO_STRUCT(r->out);
6493                         r->out.acct_handle = talloc_zero(mem_ctx, struct policy_handle);
6494                         if (r->out.acct_handle == NULL) {
6495                         return NT_STATUS_NO_MEMORY;
6496                         }
6497
6498                         r->out.result = _lsa_CreateAccount(cli->pipes_struct, r);
6499                         return NT_STATUS_OK;
6500                 }
6501
6502                 case NDR_LSA_ENUMACCOUNTS: {
6503                         struct lsa_EnumAccounts *r = (struct lsa_EnumAccounts *)_r;
6504                         ZERO_STRUCT(r->out);
6505                         r->out.resume_handle = r->in.resume_handle;
6506                         r->out.sids = talloc_zero(mem_ctx, struct lsa_SidArray);
6507                         if (r->out.sids == NULL) {
6508                         return NT_STATUS_NO_MEMORY;
6509                         }
6510
6511                         r->out.result = _lsa_EnumAccounts(cli->pipes_struct, r);
6512                         return NT_STATUS_OK;
6513                 }
6514
6515                 case NDR_LSA_CREATETRUSTEDDOMAIN: {
6516                         struct lsa_CreateTrustedDomain *r = (struct lsa_CreateTrustedDomain *)_r;
6517                         ZERO_STRUCT(r->out);
6518                         r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6519                         if (r->out.trustdom_handle == NULL) {
6520                         return NT_STATUS_NO_MEMORY;
6521                         }
6522
6523                         r->out.result = _lsa_CreateTrustedDomain(cli->pipes_struct, r);
6524                         return NT_STATUS_OK;
6525                 }
6526
6527                 case NDR_LSA_ENUMTRUSTDOM: {
6528                         struct lsa_EnumTrustDom *r = (struct lsa_EnumTrustDom *)_r;
6529                         ZERO_STRUCT(r->out);
6530                         r->out.resume_handle = r->in.resume_handle;
6531                         r->out.domains = talloc_zero(mem_ctx, struct lsa_DomainList);
6532                         if (r->out.domains == NULL) {
6533                         return NT_STATUS_NO_MEMORY;
6534                         }
6535
6536                         r->out.result = _lsa_EnumTrustDom(cli->pipes_struct, r);
6537                         return NT_STATUS_OK;
6538                 }
6539
6540                 case NDR_LSA_LOOKUPNAMES: {
6541                         struct lsa_LookupNames *r = (struct lsa_LookupNames *)_r;
6542                         ZERO_STRUCT(r->out);
6543                         r->out.sids = r->in.sids;
6544                         r->out.count = r->in.count;
6545                         r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
6546                         if (r->out.domains == NULL) {
6547                         return NT_STATUS_NO_MEMORY;
6548                         }
6549
6550                         r->out.result = _lsa_LookupNames(cli->pipes_struct, r);
6551                         return NT_STATUS_OK;
6552                 }
6553
6554                 case NDR_LSA_LOOKUPSIDS: {
6555                         struct lsa_LookupSids *r = (struct lsa_LookupSids *)_r;
6556                         ZERO_STRUCT(r->out);
6557                         r->out.names = r->in.names;
6558                         r->out.count = r->in.count;
6559                         r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
6560                         if (r->out.domains == NULL) {
6561                         return NT_STATUS_NO_MEMORY;
6562                         }
6563
6564                         r->out.result = _lsa_LookupSids(cli->pipes_struct, r);
6565                         return NT_STATUS_OK;
6566                 }
6567
6568                 case NDR_LSA_CREATESECRET: {
6569                         struct lsa_CreateSecret *r = (struct lsa_CreateSecret *)_r;
6570                         ZERO_STRUCT(r->out);
6571                         r->out.sec_handle = talloc_zero(mem_ctx, struct policy_handle);
6572                         if (r->out.sec_handle == NULL) {
6573                         return NT_STATUS_NO_MEMORY;
6574                         }
6575
6576                         r->out.result = _lsa_CreateSecret(cli->pipes_struct, r);
6577                         return NT_STATUS_OK;
6578                 }
6579
6580                 case NDR_LSA_OPENACCOUNT: {
6581                         struct lsa_OpenAccount *r = (struct lsa_OpenAccount *)_r;
6582                         ZERO_STRUCT(r->out);
6583                         r->out.acct_handle = talloc_zero(mem_ctx, struct policy_handle);
6584                         if (r->out.acct_handle == NULL) {
6585                         return NT_STATUS_NO_MEMORY;
6586                         }
6587
6588                         r->out.result = _lsa_OpenAccount(cli->pipes_struct, r);
6589                         return NT_STATUS_OK;
6590                 }
6591
6592                 case NDR_LSA_ENUMPRIVSACCOUNT: {
6593                         struct lsa_EnumPrivsAccount *r = (struct lsa_EnumPrivsAccount *)_r;
6594                         ZERO_STRUCT(r->out);
6595                         r->out.privs = talloc_zero(mem_ctx, struct lsa_PrivilegeSet *);
6596                         if (r->out.privs == NULL) {
6597                         return NT_STATUS_NO_MEMORY;
6598                         }
6599
6600                         r->out.result = _lsa_EnumPrivsAccount(cli->pipes_struct, r);
6601                         return NT_STATUS_OK;
6602                 }
6603
6604                 case NDR_LSA_ADDPRIVILEGESTOACCOUNT: {
6605                         struct lsa_AddPrivilegesToAccount *r = (struct lsa_AddPrivilegesToAccount *)_r;
6606                         r->out.result = _lsa_AddPrivilegesToAccount(cli->pipes_struct, r);
6607                         return NT_STATUS_OK;
6608                 }
6609
6610                 case NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT: {
6611                         struct lsa_RemovePrivilegesFromAccount *r = (struct lsa_RemovePrivilegesFromAccount *)_r;
6612                         r->out.result = _lsa_RemovePrivilegesFromAccount(cli->pipes_struct, r);
6613                         return NT_STATUS_OK;
6614                 }
6615
6616                 case NDR_LSA_GETQUOTASFORACCOUNT: {
6617                         struct lsa_GetQuotasForAccount *r = (struct lsa_GetQuotasForAccount *)_r;
6618                         r->out.result = _lsa_GetQuotasForAccount(cli->pipes_struct, r);
6619                         return NT_STATUS_OK;
6620                 }
6621
6622                 case NDR_LSA_SETQUOTASFORACCOUNT: {
6623                         struct lsa_SetQuotasForAccount *r = (struct lsa_SetQuotasForAccount *)_r;
6624                         r->out.result = _lsa_SetQuotasForAccount(cli->pipes_struct, r);
6625                         return NT_STATUS_OK;
6626                 }
6627
6628                 case NDR_LSA_GETSYSTEMACCESSACCOUNT: {
6629                         struct lsa_GetSystemAccessAccount *r = (struct lsa_GetSystemAccessAccount *)_r;
6630                         ZERO_STRUCT(r->out);
6631                         r->out.access_mask = talloc_zero(mem_ctx, uint32_t);
6632                         if (r->out.access_mask == NULL) {
6633                         return NT_STATUS_NO_MEMORY;
6634                         }
6635
6636                         r->out.result = _lsa_GetSystemAccessAccount(cli->pipes_struct, r);
6637                         return NT_STATUS_OK;
6638                 }
6639
6640                 case NDR_LSA_SETSYSTEMACCESSACCOUNT: {
6641                         struct lsa_SetSystemAccessAccount *r = (struct lsa_SetSystemAccessAccount *)_r;
6642                         r->out.result = _lsa_SetSystemAccessAccount(cli->pipes_struct, r);
6643                         return NT_STATUS_OK;
6644                 }
6645
6646                 case NDR_LSA_OPENTRUSTEDDOMAIN: {
6647                         struct lsa_OpenTrustedDomain *r = (struct lsa_OpenTrustedDomain *)_r;
6648                         ZERO_STRUCT(r->out);
6649                         r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6650                         if (r->out.trustdom_handle == NULL) {
6651                         return NT_STATUS_NO_MEMORY;
6652                         }
6653
6654                         r->out.result = _lsa_OpenTrustedDomain(cli->pipes_struct, r);
6655                         return NT_STATUS_OK;
6656                 }
6657
6658                 case NDR_LSA_QUERYTRUSTEDDOMAININFO: {
6659                         struct lsa_QueryTrustedDomainInfo *r = (struct lsa_QueryTrustedDomainInfo *)_r;
6660                         ZERO_STRUCT(r->out);
6661                         r->out.info = talloc_zero(mem_ctx, union lsa_TrustedDomainInfo *);
6662                         if (r->out.info == NULL) {
6663                         return NT_STATUS_NO_MEMORY;
6664                         }
6665
6666                         r->out.result = _lsa_QueryTrustedDomainInfo(cli->pipes_struct, r);
6667                         return NT_STATUS_OK;
6668                 }
6669
6670                 case NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN: {
6671                         struct lsa_SetInformationTrustedDomain *r = (struct lsa_SetInformationTrustedDomain *)_r;
6672                         r->out.result = _lsa_SetInformationTrustedDomain(cli->pipes_struct, r);
6673                         return NT_STATUS_OK;
6674                 }
6675
6676                 case NDR_LSA_OPENSECRET: {
6677                         struct lsa_OpenSecret *r = (struct lsa_OpenSecret *)_r;
6678                         ZERO_STRUCT(r->out);
6679                         r->out.sec_handle = talloc_zero(mem_ctx, struct policy_handle);
6680                         if (r->out.sec_handle == NULL) {
6681                         return NT_STATUS_NO_MEMORY;
6682                         }
6683
6684                         r->out.result = _lsa_OpenSecret(cli->pipes_struct, r);
6685                         return NT_STATUS_OK;
6686                 }
6687
6688                 case NDR_LSA_SETSECRET: {
6689                         struct lsa_SetSecret *r = (struct lsa_SetSecret *)_r;
6690                         r->out.result = _lsa_SetSecret(cli->pipes_struct, r);
6691                         return NT_STATUS_OK;
6692                 }
6693
6694                 case NDR_LSA_QUERYSECRET: {
6695                         struct lsa_QuerySecret *r = (struct lsa_QuerySecret *)_r;
6696                         ZERO_STRUCT(r->out);
6697                         r->out.new_val = r->in.new_val;
6698                         r->out.new_mtime = r->in.new_mtime;
6699                         r->out.old_val = r->in.old_val;
6700                         r->out.old_mtime = r->in.old_mtime;
6701                         r->out.result = _lsa_QuerySecret(cli->pipes_struct, r);
6702                         return NT_STATUS_OK;
6703                 }
6704
6705                 case NDR_LSA_LOOKUPPRIVVALUE: {
6706                         struct lsa_LookupPrivValue *r = (struct lsa_LookupPrivValue *)_r;
6707                         ZERO_STRUCT(r->out);
6708                         r->out.luid = talloc_zero(mem_ctx, struct lsa_LUID);
6709                         if (r->out.luid == NULL) {
6710                         return NT_STATUS_NO_MEMORY;
6711                         }
6712
6713                         r->out.result = _lsa_LookupPrivValue(cli->pipes_struct, r);
6714                         return NT_STATUS_OK;
6715                 }
6716
6717                 case NDR_LSA_LOOKUPPRIVNAME: {
6718                         struct lsa_LookupPrivName *r = (struct lsa_LookupPrivName *)_r;
6719                         ZERO_STRUCT(r->out);
6720                         r->out.name = talloc_zero(mem_ctx, struct lsa_StringLarge *);
6721                         if (r->out.name == NULL) {
6722                         return NT_STATUS_NO_MEMORY;
6723                         }
6724
6725                         r->out.result = _lsa_LookupPrivName(cli->pipes_struct, r);
6726                         return NT_STATUS_OK;
6727                 }
6728
6729                 case NDR_LSA_LOOKUPPRIVDISPLAYNAME: {
6730                         struct lsa_LookupPrivDisplayName *r = (struct lsa_LookupPrivDisplayName *)_r;
6731                         ZERO_STRUCT(r->out);
6732                         r->out.disp_name = talloc_zero(mem_ctx, struct lsa_StringLarge *);
6733                         if (r->out.disp_name == NULL) {
6734                         return NT_STATUS_NO_MEMORY;
6735                         }
6736
6737                         r->out.returned_language_id = talloc_zero(mem_ctx, uint16_t);
6738                         if (r->out.returned_language_id == NULL) {
6739                         return NT_STATUS_NO_MEMORY;
6740                         }
6741
6742                         r->out.result = _lsa_LookupPrivDisplayName(cli->pipes_struct, r);
6743                         return NT_STATUS_OK;
6744                 }
6745
6746                 case NDR_LSA_DELETEOBJECT: {
6747                         struct lsa_DeleteObject *r = (struct lsa_DeleteObject *)_r;
6748                         ZERO_STRUCT(r->out);
6749                         r->out.handle = r->in.handle;
6750                         r->out.result = _lsa_DeleteObject(cli->pipes_struct, r);
6751                         return NT_STATUS_OK;
6752                 }
6753
6754                 case NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT: {
6755                         struct lsa_EnumAccountsWithUserRight *r = (struct lsa_EnumAccountsWithUserRight *)_r;
6756                         ZERO_STRUCT(r->out);
6757                         r->out.sids = talloc_zero(mem_ctx, struct lsa_SidArray);
6758                         if (r->out.sids == NULL) {
6759                         return NT_STATUS_NO_MEMORY;
6760                         }
6761
6762                         r->out.result = _lsa_EnumAccountsWithUserRight(cli->pipes_struct, r);
6763                         return NT_STATUS_OK;
6764                 }
6765
6766                 case NDR_LSA_ENUMACCOUNTRIGHTS: {
6767                         struct lsa_EnumAccountRights *r = (struct lsa_EnumAccountRights *)_r;
6768                         ZERO_STRUCT(r->out);
6769                         r->out.rights = talloc_zero(mem_ctx, struct lsa_RightSet);
6770                         if (r->out.rights == NULL) {
6771                         return NT_STATUS_NO_MEMORY;
6772                         }
6773
6774                         r->out.result = _lsa_EnumAccountRights(cli->pipes_struct, r);
6775                         return NT_STATUS_OK;
6776                 }
6777
6778                 case NDR_LSA_ADDACCOUNTRIGHTS: {
6779                         struct lsa_AddAccountRights *r = (struct lsa_AddAccountRights *)_r;
6780                         r->out.result = _lsa_AddAccountRights(cli->pipes_struct, r);
6781                         return NT_STATUS_OK;
6782                 }
6783
6784                 case NDR_LSA_REMOVEACCOUNTRIGHTS: {
6785                         struct lsa_RemoveAccountRights *r = (struct lsa_RemoveAccountRights *)_r;
6786                         r->out.result = _lsa_RemoveAccountRights(cli->pipes_struct, r);
6787                         return NT_STATUS_OK;
6788                 }
6789
6790                 case NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID: {
6791                         struct lsa_QueryTrustedDomainInfoBySid *r = (struct lsa_QueryTrustedDomainInfoBySid *)_r;
6792                         ZERO_STRUCT(r->out);
6793                         r->out.info = talloc_zero(mem_ctx, union lsa_TrustedDomainInfo *);
6794                         if (r->out.info == NULL) {
6795                         return NT_STATUS_NO_MEMORY;
6796                         }
6797
6798                         r->out.result = _lsa_QueryTrustedDomainInfoBySid(cli->pipes_struct, r);
6799                         return NT_STATUS_OK;
6800                 }
6801
6802                 case NDR_LSA_SETTRUSTEDDOMAININFO: {
6803                         struct lsa_SetTrustedDomainInfo *r = (struct lsa_SetTrustedDomainInfo *)_r;
6804                         r->out.result = _lsa_SetTrustedDomainInfo(cli->pipes_struct, r);
6805                         return NT_STATUS_OK;
6806                 }
6807
6808                 case NDR_LSA_DELETETRUSTEDDOMAIN: {
6809                         struct lsa_DeleteTrustedDomain *r = (struct lsa_DeleteTrustedDomain *)_r;
6810                         r->out.result = _lsa_DeleteTrustedDomain(cli->pipes_struct, r);
6811                         return NT_STATUS_OK;
6812                 }
6813
6814                 case NDR_LSA_STOREPRIVATEDATA: {
6815                         struct lsa_StorePrivateData *r = (struct lsa_StorePrivateData *)_r;
6816                         r->out.result = _lsa_StorePrivateData(cli->pipes_struct, r);
6817                         return NT_STATUS_OK;
6818                 }
6819
6820                 case NDR_LSA_RETRIEVEPRIVATEDATA: {
6821                         struct lsa_RetrievePrivateData *r = (struct lsa_RetrievePrivateData *)_r;
6822                         ZERO_STRUCT(r->out);
6823                         r->out.val = r->in.val;
6824                         r->out.result = _lsa_RetrievePrivateData(cli->pipes_struct, r);
6825                         return NT_STATUS_OK;
6826                 }
6827
6828                 case NDR_LSA_OPENPOLICY2: {
6829                         struct lsa_OpenPolicy2 *r = (struct lsa_OpenPolicy2 *)_r;
6830                         ZERO_STRUCT(r->out);
6831                         r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
6832                         if (r->out.handle == NULL) {
6833                         return NT_STATUS_NO_MEMORY;
6834                         }
6835
6836                         r->out.result = _lsa_OpenPolicy2(cli->pipes_struct, r);
6837                         return NT_STATUS_OK;
6838                 }
6839
6840                 case NDR_LSA_GETUSERNAME: {
6841                         struct lsa_GetUserName *r = (struct lsa_GetUserName *)_r;
6842                         ZERO_STRUCT(r->out);
6843                         r->out.account_name = r->in.account_name;
6844                         r->out.authority_name = r->in.authority_name;
6845                         r->out.result = _lsa_GetUserName(cli->pipes_struct, r);
6846                         return NT_STATUS_OK;
6847                 }
6848
6849                 case NDR_LSA_QUERYINFOPOLICY2: {
6850                         struct lsa_QueryInfoPolicy2 *r = (struct lsa_QueryInfoPolicy2 *)_r;
6851                         ZERO_STRUCT(r->out);
6852                         r->out.info = talloc_zero(mem_ctx, union lsa_PolicyInformation *);
6853                         if (r->out.info == NULL) {
6854                         return NT_STATUS_NO_MEMORY;
6855                         }
6856
6857                         r->out.result = _lsa_QueryInfoPolicy2(cli->pipes_struct, r);
6858                         return NT_STATUS_OK;
6859                 }
6860
6861                 case NDR_LSA_SETINFOPOLICY2: {
6862                         struct lsa_SetInfoPolicy2 *r = (struct lsa_SetInfoPolicy2 *)_r;
6863                         r->out.result = _lsa_SetInfoPolicy2(cli->pipes_struct, r);
6864                         return NT_STATUS_OK;
6865                 }
6866
6867                 case NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME: {
6868                         struct lsa_QueryTrustedDomainInfoByName *r = (struct lsa_QueryTrustedDomainInfoByName *)_r;
6869                         ZERO_STRUCT(r->out);
6870                         r->out.info = talloc_zero(mem_ctx, union lsa_TrustedDomainInfo *);
6871                         if (r->out.info == NULL) {
6872                         return NT_STATUS_NO_MEMORY;
6873                         }
6874
6875                         r->out.result = _lsa_QueryTrustedDomainInfoByName(cli->pipes_struct, r);
6876                         return NT_STATUS_OK;
6877                 }
6878
6879                 case NDR_LSA_SETTRUSTEDDOMAININFOBYNAME: {
6880                         struct lsa_SetTrustedDomainInfoByName *r = (struct lsa_SetTrustedDomainInfoByName *)_r;
6881                         r->out.result = _lsa_SetTrustedDomainInfoByName(cli->pipes_struct, r);
6882                         return NT_STATUS_OK;
6883                 }
6884
6885                 case NDR_LSA_ENUMTRUSTEDDOMAINSEX: {
6886                         struct lsa_EnumTrustedDomainsEx *r = (struct lsa_EnumTrustedDomainsEx *)_r;
6887                         ZERO_STRUCT(r->out);
6888                         r->out.resume_handle = r->in.resume_handle;
6889                         r->out.domains = talloc_zero(mem_ctx, struct lsa_DomainListEx);
6890                         if (r->out.domains == NULL) {
6891                         return NT_STATUS_NO_MEMORY;
6892                         }
6893
6894                         r->out.result = _lsa_EnumTrustedDomainsEx(cli->pipes_struct, r);
6895                         return NT_STATUS_OK;
6896                 }
6897
6898                 case NDR_LSA_CREATETRUSTEDDOMAINEX: {
6899                         struct lsa_CreateTrustedDomainEx *r = (struct lsa_CreateTrustedDomainEx *)_r;
6900                         ZERO_STRUCT(r->out);
6901                         r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6902                         if (r->out.trustdom_handle == NULL) {
6903                         return NT_STATUS_NO_MEMORY;
6904                         }
6905
6906                         r->out.result = _lsa_CreateTrustedDomainEx(cli->pipes_struct, r);
6907                         return NT_STATUS_OK;
6908                 }
6909
6910                 case NDR_LSA_CLOSETRUSTEDDOMAINEX: {
6911                         struct lsa_CloseTrustedDomainEx *r = (struct lsa_CloseTrustedDomainEx *)_r;
6912                         ZERO_STRUCT(r->out);
6913                         r->out.handle = r->in.handle;
6914                         r->out.result = _lsa_CloseTrustedDomainEx(cli->pipes_struct, r);
6915                         return NT_STATUS_OK;
6916                 }
6917
6918                 case NDR_LSA_QUERYDOMAININFORMATIONPOLICY: {
6919                         struct lsa_QueryDomainInformationPolicy *r = (struct lsa_QueryDomainInformationPolicy *)_r;
6920                         ZERO_STRUCT(r->out);
6921                         r->out.info = talloc_zero(mem_ctx, union lsa_DomainInformationPolicy *);
6922                         if (r->out.info == NULL) {
6923                         return NT_STATUS_NO_MEMORY;
6924                         }
6925
6926                         r->out.result = _lsa_QueryDomainInformationPolicy(cli->pipes_struct, r);
6927                         return NT_STATUS_OK;
6928                 }
6929
6930                 case NDR_LSA_SETDOMAININFORMATIONPOLICY: {
6931                         struct lsa_SetDomainInformationPolicy *r = (struct lsa_SetDomainInformationPolicy *)_r;
6932                         r->out.result = _lsa_SetDomainInformationPolicy(cli->pipes_struct, r);
6933                         return NT_STATUS_OK;
6934                 }
6935
6936                 case NDR_LSA_OPENTRUSTEDDOMAINBYNAME: {
6937                         struct lsa_OpenTrustedDomainByName *r = (struct lsa_OpenTrustedDomainByName *)_r;
6938                         ZERO_STRUCT(r->out);
6939                         r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6940                         if (r->out.trustdom_handle == NULL) {
6941                         return NT_STATUS_NO_MEMORY;
6942                         }
6943
6944                         r->out.result = _lsa_OpenTrustedDomainByName(cli->pipes_struct, r);
6945                         return NT_STATUS_OK;
6946                 }
6947
6948                 case NDR_LSA_TESTCALL: {
6949                         struct lsa_TestCall *r = (struct lsa_TestCall *)_r;
6950                         r->out.result = _lsa_TestCall(cli->pipes_struct, r);
6951                         return NT_STATUS_OK;
6952                 }
6953
6954                 case NDR_LSA_LOOKUPSIDS2: {
6955                         struct lsa_LookupSids2 *r = (struct lsa_LookupSids2 *)_r;
6956                         ZERO_STRUCT(r->out);
6957                         r->out.names = r->in.names;
6958                         r->out.count = r->in.count;
6959                         r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
6960                         if (r->out.domains == NULL) {
6961                         return NT_STATUS_NO_MEMORY;
6962                         }
6963
6964                         r->out.result = _lsa_LookupSids2(cli->pipes_struct, r);
6965                         return NT_STATUS_OK;
6966                 }
6967
6968                 case NDR_LSA_LOOKUPNAMES2: {
6969                         struct lsa_LookupNames2 *r = (struct lsa_LookupNames2 *)_r;
6970                         ZERO_STRUCT(r->out);
6971                         r->out.sids = r->in.sids;
6972                         r->out.count = r->in.count;
6973                         r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
6974                         if (r->out.domains == NULL) {
6975                         return NT_STATUS_NO_MEMORY;
6976                         }
6977
6978                         r->out.result = _lsa_LookupNames2(cli->pipes_struct, r);
6979                         return NT_STATUS_OK;
6980                 }
6981
6982                 case NDR_LSA_CREATETRUSTEDDOMAINEX2: {
6983                         struct lsa_CreateTrustedDomainEx2 *r = (struct lsa_CreateTrustedDomainEx2 *)_r;
6984                         ZERO_STRUCT(r->out);
6985                         r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6986                         if (r->out.trustdom_handle == NULL) {
6987                         return NT_STATUS_NO_MEMORY;
6988                         }
6989
6990                         r->out.result = _lsa_CreateTrustedDomainEx2(cli->pipes_struct, r);
6991                         return NT_STATUS_OK;
6992                 }
6993
6994                 case NDR_LSA_CREDRWRITE: {
6995                         struct lsa_CREDRWRITE *r = (struct lsa_CREDRWRITE *)_r;
6996                         r->out.result = _lsa_CREDRWRITE(cli->pipes_struct, r);
6997                         return NT_STATUS_OK;
6998                 }
6999
7000                 case NDR_LSA_CREDRREAD: {
7001                         struct lsa_CREDRREAD *r = (struct lsa_CREDRREAD *)_r;
7002                         r->out.result = _lsa_CREDRREAD(cli->pipes_struct, r);
7003                         return NT_STATUS_OK;
7004                 }
7005
7006                 case NDR_LSA_CREDRENUMERATE: {
7007                         struct lsa_CREDRENUMERATE *r = (struct lsa_CREDRENUMERATE *)_r;
7008                         r->out.result = _lsa_CREDRENUMERATE(cli->pipes_struct, r);
7009                         return NT_STATUS_OK;
7010                 }
7011
7012                 case NDR_LSA_CREDRWRITEDOMAINCREDENTIALS: {
7013                         struct lsa_CREDRWRITEDOMAINCREDENTIALS *r = (struct lsa_CREDRWRITEDOMAINCREDENTIALS *)_r;
7014                         r->out.result = _lsa_CREDRWRITEDOMAINCREDENTIALS(cli->pipes_struct, r);
7015                         return NT_STATUS_OK;
7016                 }
7017
7018                 case NDR_LSA_CREDRREADDOMAINCREDENTIALS: {
7019                         struct lsa_CREDRREADDOMAINCREDENTIALS *r = (struct lsa_CREDRREADDOMAINCREDENTIALS *)_r;
7020                         r->out.result = _lsa_CREDRREADDOMAINCREDENTIALS(cli->pipes_struct, r);
7021                         return NT_STATUS_OK;
7022                 }
7023
7024                 case NDR_LSA_CREDRDELETE: {
7025                         struct lsa_CREDRDELETE *r = (struct lsa_CREDRDELETE *)_r;
7026                         r->out.result = _lsa_CREDRDELETE(cli->pipes_struct, r);
7027                         return NT_STATUS_OK;
7028                 }
7029
7030                 case NDR_LSA_CREDRGETTARGETINFO: {
7031                         struct lsa_CREDRGETTARGETINFO *r = (struct lsa_CREDRGETTARGETINFO *)_r;
7032                         r->out.result = _lsa_CREDRGETTARGETINFO(cli->pipes_struct, r);
7033                         return NT_STATUS_OK;
7034                 }
7035
7036                 case NDR_LSA_CREDRPROFILELOADED: {
7037                         struct lsa_CREDRPROFILELOADED *r = (struct lsa_CREDRPROFILELOADED *)_r;
7038                         r->out.result = _lsa_CREDRPROFILELOADED(cli->pipes_struct, r);
7039                         return NT_STATUS_OK;
7040                 }
7041
7042                 case NDR_LSA_LOOKUPNAMES3: {
7043                         struct lsa_LookupNames3 *r = (struct lsa_LookupNames3 *)_r;
7044                         ZERO_STRUCT(r->out);
7045                         r->out.sids = r->in.sids;
7046                         r->out.count = r->in.count;
7047                         r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
7048                         if (r->out.domains == NULL) {
7049                         return NT_STATUS_NO_MEMORY;
7050                         }
7051
7052                         r->out.result = _lsa_LookupNames3(cli->pipes_struct, r);
7053                         return NT_STATUS_OK;
7054                 }
7055
7056                 case NDR_LSA_CREDRGETSESSIONTYPES: {
7057                         struct lsa_CREDRGETSESSIONTYPES *r = (struct lsa_CREDRGETSESSIONTYPES *)_r;
7058                         r->out.result = _lsa_CREDRGETSESSIONTYPES(cli->pipes_struct, r);
7059                         return NT_STATUS_OK;
7060                 }
7061
7062                 case NDR_LSA_LSARREGISTERAUDITEVENT: {
7063                         struct lsa_LSARREGISTERAUDITEVENT *r = (struct lsa_LSARREGISTERAUDITEVENT *)_r;
7064                         r->out.result = _lsa_LSARREGISTERAUDITEVENT(cli->pipes_struct, r);
7065                         return NT_STATUS_OK;
7066                 }
7067
7068                 case NDR_LSA_LSARGENAUDITEVENT: {
7069                         struct lsa_LSARGENAUDITEVENT *r = (struct lsa_LSARGENAUDITEVENT *)_r;
7070                         r->out.result = _lsa_LSARGENAUDITEVENT(cli->pipes_struct, r);
7071                         return NT_STATUS_OK;
7072                 }
7073
7074                 case NDR_LSA_LSARUNREGISTERAUDITEVENT: {
7075                         struct lsa_LSARUNREGISTERAUDITEVENT *r = (struct lsa_LSARUNREGISTERAUDITEVENT *)_r;
7076                         r->out.result = _lsa_LSARUNREGISTERAUDITEVENT(cli->pipes_struct, r);
7077                         return NT_STATUS_OK;
7078                 }
7079
7080                 case NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION: {
7081                         struct lsa_lsaRQueryForestTrustInformation *r = (struct lsa_lsaRQueryForestTrustInformation *)_r;
7082                         ZERO_STRUCT(r->out);
7083                         r->out.forest_trust_info = talloc_zero(mem_ctx, struct lsa_ForestTrustInformation *);
7084                         if (r->out.forest_trust_info == NULL) {
7085                         return NT_STATUS_NO_MEMORY;
7086                         }
7087
7088                         r->out.result = _lsa_lsaRQueryForestTrustInformation(cli->pipes_struct, r);
7089                         return NT_STATUS_OK;
7090                 }
7091
7092                 case NDR_LSA_LSARSETFORESTTRUSTINFORMATION: {
7093                         struct lsa_lsaRSetForestTrustInformation *r = (struct lsa_lsaRSetForestTrustInformation *)_r;
7094                         ZERO_STRUCT(r->out);
7095                         r->out.collision_info = talloc_zero(mem_ctx, struct lsa_ForestTrustCollisionInfo *);
7096                         if (r->out.collision_info == NULL) {
7097                         return NT_STATUS_NO_MEMORY;
7098                         }
7099
7100                         r->out.result = _lsa_lsaRSetForestTrustInformation(cli->pipes_struct, r);
7101                         return NT_STATUS_OK;
7102                 }
7103
7104                 case NDR_LSA_CREDRRENAME: {
7105                         struct lsa_CREDRRENAME *r = (struct lsa_CREDRRENAME *)_r;
7106                         r->out.result = _lsa_CREDRRENAME(cli->pipes_struct, r);
7107                         return NT_STATUS_OK;
7108                 }
7109
7110                 case NDR_LSA_LOOKUPSIDS3: {
7111                         struct lsa_LookupSids3 *r = (struct lsa_LookupSids3 *)_r;
7112                         ZERO_STRUCT(r->out);
7113                         r->out.names = r->in.names;
7114                         r->out.count = r->in.count;
7115                         r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
7116                         if (r->out.domains == NULL) {
7117                         return NT_STATUS_NO_MEMORY;
7118                         }
7119
7120                         r->out.result = _lsa_LookupSids3(cli->pipes_struct, r);
7121                         return NT_STATUS_OK;
7122                 }
7123
7124                 case NDR_LSA_LOOKUPNAMES4: {
7125                         struct lsa_LookupNames4 *r = (struct lsa_LookupNames4 *)_r;
7126                         ZERO_STRUCT(r->out);
7127                         r->out.sids = r->in.sids;
7128                         r->out.count = r->in.count;
7129                         r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
7130                         if (r->out.domains == NULL) {
7131                         return NT_STATUS_NO_MEMORY;
7132                         }
7133
7134                         r->out.result = _lsa_LookupNames4(cli->pipes_struct, r);
7135                         return NT_STATUS_OK;
7136                 }
7137
7138                 case NDR_LSA_LSAROPENPOLICYSCE: {
7139                         struct lsa_LSAROPENPOLICYSCE *r = (struct lsa_LSAROPENPOLICYSCE *)_r;
7140                         r->out.result = _lsa_LSAROPENPOLICYSCE(cli->pipes_struct, r);
7141                         return NT_STATUS_OK;
7142                 }
7143
7144                 case NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE: {
7145                         struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r = (struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *)_r;
7146                         r->out.result = _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(cli->pipes_struct, r);
7147                         return NT_STATUS_OK;
7148                 }
7149
7150                 case NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE: {
7151                         struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r = (struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *)_r;
7152                         r->out.result = _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(cli->pipes_struct, r);
7153                         return NT_STATUS_OK;
7154                 }
7155
7156                 case NDR_LSA_LSARADTREPORTSECURITYEVENT: {
7157                         struct lsa_LSARADTREPORTSECURITYEVENT *r = (struct lsa_LSARADTREPORTSECURITYEVENT *)_r;
7158                         r->out.result = _lsa_LSARADTREPORTSECURITYEVENT(cli->pipes_struct, r);
7159                         return NT_STATUS_OK;
7160                 }
7161
7162                 default:
7163                         return NT_STATUS_NOT_IMPLEMENTED;
7164         }
7165 }
7166
7167 NTSTATUS rpc_lsarpc_init(void)
7168 {
7169         return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "lsarpc", "lsarpc", &ndr_table_lsarpc, api_lsarpc_cmds, sizeof(api_lsarpc_cmds) / sizeof(struct api_struct));
7170 }