source/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(NULL, 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);
  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);
  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(NULL, 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);
 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);
 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(NULL, 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);
 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);
 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(NULL, 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);
 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);
 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(NULL, 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);
 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);
 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(NULL, 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);
 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);
 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(NULL, 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);
 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);
 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(NULL, 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);
 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);
 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(NULL, 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);
 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);
 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(NULL, 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);
 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);
 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(NULL, 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);
 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);
 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(NULL, 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);
 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);
 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(NULL, 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);
 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);
 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(NULL, 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);
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);
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(NULL, 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);
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.domains = talloc_zero(r, struct lsa_RefDomainList);
1132         if (r->out.domains == NULL) {
1133                 talloc_free(r);
1134                 return false;
1135         }
1136
1137         r->out.sids = r->in.sids;
1138         r->out.count = r->in.count;
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);
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(NULL, 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);
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.domains = talloc_zero(r, struct lsa_RefDomainList);
1214         if (r->out.domains == NULL) {
1215                 talloc_free(r);
1216                 return false;
1217         }
1218
1219         r->out.names = r->in.names;
1220         r->out.count = r->in.count;
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);
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(NULL, 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);
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);
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(NULL, 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);
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);
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(NULL, 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);
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);
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(NULL, 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);
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);
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(NULL, 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);
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);
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(NULL, 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);
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);
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(NULL, 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);
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);
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(NULL, 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);
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         r->out.result = _lsa_GetSystemAccessAccount(p, r);
1827
1828         if (p->rng_fault_state) {
1829                 talloc_free(r);
1830                 /* Return true here, srv_pipe_hnd.c will take care */
1831                 return true;
1832         }
1833
1834         if (DEBUGLEVEL >= 10) {
1835                 NDR_PRINT_OUT_DEBUG(lsa_GetSystemAccessAccount, r);
1836         }
1837
1838         push = ndr_push_init_ctx(r);
1839         if (push == NULL) {
1840                 talloc_free(r);
1841                 return false;
1842         }
1843
1844         ndr_err = call->ndr_push(push, NDR_OUT, r);
1845         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1846                 talloc_free(r);
1847                 return false;
1848         }
1849
1850         blob = ndr_push_blob(push);
1851         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1852                 talloc_free(r);
1853                 return false;
1854         }
1855
1856         talloc_free(r);
1857
1858         return true;
1859 }
1860
1861 static bool api_lsa_SetSystemAccessAccount(pipes_struct *p)
1862 {
1863         const struct ndr_interface_call *call;
1864         struct ndr_pull *pull;
1865         struct ndr_push *push;
1866         enum ndr_err_code ndr_err;
1867         DATA_BLOB blob;
1868         struct lsa_SetSystemAccessAccount *r;
1869
1870         call = &ndr_table_lsarpc.calls[NDR_LSA_SETSYSTEMACCESSACCOUNT];
1871
1872         r = talloc(NULL, struct lsa_SetSystemAccessAccount);
1873         if (r == NULL) {
1874                 return false;
1875         }
1876
1877         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1878                 talloc_free(r);
1879                 return false;
1880         }
1881
1882         pull = ndr_pull_init_blob(&blob, r);
1883         if (pull == NULL) {
1884                 talloc_free(r);
1885                 return false;
1886         }
1887
1888         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1889         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1890         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1891                 talloc_free(r);
1892                 return false;
1893         }
1894
1895         if (DEBUGLEVEL >= 10) {
1896                 NDR_PRINT_IN_DEBUG(lsa_SetSystemAccessAccount, r);
1897         }
1898
1899         r->out.result = _lsa_SetSystemAccessAccount(p, r);
1900
1901         if (p->rng_fault_state) {
1902                 talloc_free(r);
1903                 /* Return true here, srv_pipe_hnd.c will take care */
1904                 return true;
1905         }
1906
1907         if (DEBUGLEVEL >= 10) {
1908                 NDR_PRINT_OUT_DEBUG(lsa_SetSystemAccessAccount, r);
1909         }
1910
1911         push = ndr_push_init_ctx(r);
1912         if (push == NULL) {
1913                 talloc_free(r);
1914                 return false;
1915         }
1916
1917         ndr_err = call->ndr_push(push, NDR_OUT, r);
1918         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1919                 talloc_free(r);
1920                 return false;
1921         }
1922
1923         blob = ndr_push_blob(push);
1924         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1925                 talloc_free(r);
1926                 return false;
1927         }
1928
1929         talloc_free(r);
1930
1931         return true;
1932 }
1933
1934 static bool api_lsa_OpenTrustedDomain(pipes_struct *p)
1935 {
1936         const struct ndr_interface_call *call;
1937         struct ndr_pull *pull;
1938         struct ndr_push *push;
1939         enum ndr_err_code ndr_err;
1940         DATA_BLOB blob;
1941         struct lsa_OpenTrustedDomain *r;
1942
1943         call = &ndr_table_lsarpc.calls[NDR_LSA_OPENTRUSTEDDOMAIN];
1944
1945         r = talloc(NULL, struct lsa_OpenTrustedDomain);
1946         if (r == NULL) {
1947                 return false;
1948         }
1949
1950         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1951                 talloc_free(r);
1952                 return false;
1953         }
1954
1955         pull = ndr_pull_init_blob(&blob, r);
1956         if (pull == NULL) {
1957                 talloc_free(r);
1958                 return false;
1959         }
1960
1961         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1962         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1963         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1964                 talloc_free(r);
1965                 return false;
1966         }
1967
1968         if (DEBUGLEVEL >= 10) {
1969                 NDR_PRINT_IN_DEBUG(lsa_OpenTrustedDomain, r);
1970         }
1971
1972         ZERO_STRUCT(r->out);
1973         r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
1974         if (r->out.trustdom_handle == NULL) {
1975                 talloc_free(r);
1976                 return false;
1977         }
1978
1979         r->out.result = _lsa_OpenTrustedDomain(p, r);
1980
1981         if (p->rng_fault_state) {
1982                 talloc_free(r);
1983                 /* Return true here, srv_pipe_hnd.c will take care */
1984                 return true;
1985         }
1986
1987         if (DEBUGLEVEL >= 10) {
1988                 NDR_PRINT_OUT_DEBUG(lsa_OpenTrustedDomain, r);
1989         }
1990
1991         push = ndr_push_init_ctx(r);
1992         if (push == NULL) {
1993                 talloc_free(r);
1994                 return false;
1995         }
1996
1997         ndr_err = call->ndr_push(push, NDR_OUT, r);
1998         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1999                 talloc_free(r);
2000                 return false;
2001         }
2002
2003         blob = ndr_push_blob(push);
2004         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2005                 talloc_free(r);
2006                 return false;
2007         }
2008
2009         talloc_free(r);
2010
2011         return true;
2012 }
2013
2014 static bool api_lsa_QueryTrustedDomainInfo(pipes_struct *p)
2015 {
2016         const struct ndr_interface_call *call;
2017         struct ndr_pull *pull;
2018         struct ndr_push *push;
2019         enum ndr_err_code ndr_err;
2020         DATA_BLOB blob;
2021         struct lsa_QueryTrustedDomainInfo *r;
2022
2023         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYTRUSTEDDOMAININFO];
2024
2025         r = talloc(NULL, struct lsa_QueryTrustedDomainInfo);
2026         if (r == NULL) {
2027                 return false;
2028         }
2029
2030         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2031                 talloc_free(r);
2032                 return false;
2033         }
2034
2035         pull = ndr_pull_init_blob(&blob, r);
2036         if (pull == NULL) {
2037                 talloc_free(r);
2038                 return false;
2039         }
2040
2041         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2042         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2043         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2044                 talloc_free(r);
2045                 return false;
2046         }
2047
2048         if (DEBUGLEVEL >= 10) {
2049                 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfo, r);
2050         }
2051
2052         ZERO_STRUCT(r->out);
2053         r->out.info = talloc_zero(r, union lsa_TrustedDomainInfo);
2054         if (r->out.info == NULL) {
2055                 talloc_free(r);
2056                 return false;
2057         }
2058
2059         r->out.result = _lsa_QueryTrustedDomainInfo(p, r);
2060
2061         if (p->rng_fault_state) {
2062                 talloc_free(r);
2063                 /* Return true here, srv_pipe_hnd.c will take care */
2064                 return true;
2065         }
2066
2067         if (DEBUGLEVEL >= 10) {
2068                 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfo, r);
2069         }
2070
2071         push = ndr_push_init_ctx(r);
2072         if (push == NULL) {
2073                 talloc_free(r);
2074                 return false;
2075         }
2076
2077         ndr_err = call->ndr_push(push, NDR_OUT, r);
2078         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2079                 talloc_free(r);
2080                 return false;
2081         }
2082
2083         blob = ndr_push_blob(push);
2084         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2085                 talloc_free(r);
2086                 return false;
2087         }
2088
2089         talloc_free(r);
2090
2091         return true;
2092 }
2093
2094 static bool api_lsa_SetInformationTrustedDomain(pipes_struct *p)
2095 {
2096         const struct ndr_interface_call *call;
2097         struct ndr_pull *pull;
2098         struct ndr_push *push;
2099         enum ndr_err_code ndr_err;
2100         DATA_BLOB blob;
2101         struct lsa_SetInformationTrustedDomain *r;
2102
2103         call = &ndr_table_lsarpc.calls[NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN];
2104
2105         r = talloc(NULL, struct lsa_SetInformationTrustedDomain);
2106         if (r == NULL) {
2107                 return false;
2108         }
2109
2110         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2111                 talloc_free(r);
2112                 return false;
2113         }
2114
2115         pull = ndr_pull_init_blob(&blob, r);
2116         if (pull == NULL) {
2117                 talloc_free(r);
2118                 return false;
2119         }
2120
2121         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2122         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2123         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2124                 talloc_free(r);
2125                 return false;
2126         }
2127
2128         if (DEBUGLEVEL >= 10) {
2129                 NDR_PRINT_IN_DEBUG(lsa_SetInformationTrustedDomain, r);
2130         }
2131
2132         r->out.result = _lsa_SetInformationTrustedDomain(p, r);
2133
2134         if (p->rng_fault_state) {
2135                 talloc_free(r);
2136                 /* Return true here, srv_pipe_hnd.c will take care */
2137                 return true;
2138         }
2139
2140         if (DEBUGLEVEL >= 10) {
2141                 NDR_PRINT_OUT_DEBUG(lsa_SetInformationTrustedDomain, r);
2142         }
2143
2144         push = ndr_push_init_ctx(r);
2145         if (push == NULL) {
2146                 talloc_free(r);
2147                 return false;
2148         }
2149
2150         ndr_err = call->ndr_push(push, NDR_OUT, r);
2151         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2152                 talloc_free(r);
2153                 return false;
2154         }
2155
2156         blob = ndr_push_blob(push);
2157         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2158                 talloc_free(r);
2159                 return false;
2160         }
2161
2162         talloc_free(r);
2163
2164         return true;
2165 }
2166
2167 static bool api_lsa_OpenSecret(pipes_struct *p)
2168 {
2169         const struct ndr_interface_call *call;
2170         struct ndr_pull *pull;
2171         struct ndr_push *push;
2172         enum ndr_err_code ndr_err;
2173         DATA_BLOB blob;
2174         struct lsa_OpenSecret *r;
2175
2176         call = &ndr_table_lsarpc.calls[NDR_LSA_OPENSECRET];
2177
2178         r = talloc(NULL, struct lsa_OpenSecret);
2179         if (r == NULL) {
2180                 return false;
2181         }
2182
2183         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2184                 talloc_free(r);
2185                 return false;
2186         }
2187
2188         pull = ndr_pull_init_blob(&blob, r);
2189         if (pull == NULL) {
2190                 talloc_free(r);
2191                 return false;
2192         }
2193
2194         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2195         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2196         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2197                 talloc_free(r);
2198                 return false;
2199         }
2200
2201         if (DEBUGLEVEL >= 10) {
2202                 NDR_PRINT_IN_DEBUG(lsa_OpenSecret, r);
2203         }
2204
2205         ZERO_STRUCT(r->out);
2206         r->out.sec_handle = talloc_zero(r, struct policy_handle);
2207         if (r->out.sec_handle == NULL) {
2208                 talloc_free(r);
2209                 return false;
2210         }
2211
2212         r->out.result = _lsa_OpenSecret(p, r);
2213
2214         if (p->rng_fault_state) {
2215                 talloc_free(r);
2216                 /* Return true here, srv_pipe_hnd.c will take care */
2217                 return true;
2218         }
2219
2220         if (DEBUGLEVEL >= 10) {
2221                 NDR_PRINT_OUT_DEBUG(lsa_OpenSecret, r);
2222         }
2223
2224         push = ndr_push_init_ctx(r);
2225         if (push == NULL) {
2226                 talloc_free(r);
2227                 return false;
2228         }
2229
2230         ndr_err = call->ndr_push(push, NDR_OUT, r);
2231         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2232                 talloc_free(r);
2233                 return false;
2234         }
2235
2236         blob = ndr_push_blob(push);
2237         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2238                 talloc_free(r);
2239                 return false;
2240         }
2241
2242         talloc_free(r);
2243
2244         return true;
2245 }
2246
2247 static bool api_lsa_SetSecret(pipes_struct *p)
2248 {
2249         const struct ndr_interface_call *call;
2250         struct ndr_pull *pull;
2251         struct ndr_push *push;
2252         enum ndr_err_code ndr_err;
2253         DATA_BLOB blob;
2254         struct lsa_SetSecret *r;
2255
2256         call = &ndr_table_lsarpc.calls[NDR_LSA_SETSECRET];
2257
2258         r = talloc(NULL, struct lsa_SetSecret);
2259         if (r == NULL) {
2260                 return false;
2261         }
2262
2263         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2264                 talloc_free(r);
2265                 return false;
2266         }
2267
2268         pull = ndr_pull_init_blob(&blob, r);
2269         if (pull == NULL) {
2270                 talloc_free(r);
2271                 return false;
2272         }
2273
2274         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2275         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2276         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2277                 talloc_free(r);
2278                 return false;
2279         }
2280
2281         if (DEBUGLEVEL >= 10) {
2282                 NDR_PRINT_IN_DEBUG(lsa_SetSecret, r);
2283         }
2284
2285         r->out.result = _lsa_SetSecret(p, r);
2286
2287         if (p->rng_fault_state) {
2288                 talloc_free(r);
2289                 /* Return true here, srv_pipe_hnd.c will take care */
2290                 return true;
2291         }
2292
2293         if (DEBUGLEVEL >= 10) {
2294                 NDR_PRINT_OUT_DEBUG(lsa_SetSecret, r);
2295         }
2296
2297         push = ndr_push_init_ctx(r);
2298         if (push == NULL) {
2299                 talloc_free(r);
2300                 return false;
2301         }
2302
2303         ndr_err = call->ndr_push(push, NDR_OUT, r);
2304         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2305                 talloc_free(r);
2306                 return false;
2307         }
2308
2309         blob = ndr_push_blob(push);
2310         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2311                 talloc_free(r);
2312                 return false;
2313         }
2314
2315         talloc_free(r);
2316
2317         return true;
2318 }
2319
2320 static bool api_lsa_QuerySecret(pipes_struct *p)
2321 {
2322         const struct ndr_interface_call *call;
2323         struct ndr_pull *pull;
2324         struct ndr_push *push;
2325         enum ndr_err_code ndr_err;
2326         DATA_BLOB blob;
2327         struct lsa_QuerySecret *r;
2328
2329         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYSECRET];
2330
2331         r = talloc(NULL, struct lsa_QuerySecret);
2332         if (r == NULL) {
2333                 return false;
2334         }
2335
2336         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2337                 talloc_free(r);
2338                 return false;
2339         }
2340
2341         pull = ndr_pull_init_blob(&blob, r);
2342         if (pull == NULL) {
2343                 talloc_free(r);
2344                 return false;
2345         }
2346
2347         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2348         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2349         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2350                 talloc_free(r);
2351                 return false;
2352         }
2353
2354         if (DEBUGLEVEL >= 10) {
2355                 NDR_PRINT_IN_DEBUG(lsa_QuerySecret, r);
2356         }
2357
2358         ZERO_STRUCT(r->out);
2359         r->out.new_val = r->in.new_val;
2360         r->out.new_mtime = r->in.new_mtime;
2361         r->out.old_val = r->in.old_val;
2362         r->out.old_mtime = r->in.old_mtime;
2363         r->out.result = _lsa_QuerySecret(p, r);
2364
2365         if (p->rng_fault_state) {
2366                 talloc_free(r);
2367                 /* Return true here, srv_pipe_hnd.c will take care */
2368                 return true;
2369         }
2370
2371         if (DEBUGLEVEL >= 10) {
2372                 NDR_PRINT_OUT_DEBUG(lsa_QuerySecret, r);
2373         }
2374
2375         push = ndr_push_init_ctx(r);
2376         if (push == NULL) {
2377                 talloc_free(r);
2378                 return false;
2379         }
2380
2381         ndr_err = call->ndr_push(push, NDR_OUT, r);
2382         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2383                 talloc_free(r);
2384                 return false;
2385         }
2386
2387         blob = ndr_push_blob(push);
2388         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2389                 talloc_free(r);
2390                 return false;
2391         }
2392
2393         talloc_free(r);
2394
2395         return true;
2396 }
2397
2398 static bool api_lsa_LookupPrivValue(pipes_struct *p)
2399 {
2400         const struct ndr_interface_call *call;
2401         struct ndr_pull *pull;
2402         struct ndr_push *push;
2403         enum ndr_err_code ndr_err;
2404         DATA_BLOB blob;
2405         struct lsa_LookupPrivValue *r;
2406
2407         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPPRIVVALUE];
2408
2409         r = talloc(NULL, struct lsa_LookupPrivValue);
2410         if (r == NULL) {
2411                 return false;
2412         }
2413
2414         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2415                 talloc_free(r);
2416                 return false;
2417         }
2418
2419         pull = ndr_pull_init_blob(&blob, r);
2420         if (pull == NULL) {
2421                 talloc_free(r);
2422                 return false;
2423         }
2424
2425         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2426         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2427         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2428                 talloc_free(r);
2429                 return false;
2430         }
2431
2432         if (DEBUGLEVEL >= 10) {
2433                 NDR_PRINT_IN_DEBUG(lsa_LookupPrivValue, r);
2434         }
2435
2436         ZERO_STRUCT(r->out);
2437         r->out.luid = talloc_zero(r, struct lsa_LUID);
2438         if (r->out.luid == NULL) {
2439                 talloc_free(r);
2440                 return false;
2441         }
2442
2443         r->out.result = _lsa_LookupPrivValue(p, r);
2444
2445         if (p->rng_fault_state) {
2446                 talloc_free(r);
2447                 /* Return true here, srv_pipe_hnd.c will take care */
2448                 return true;
2449         }
2450
2451         if (DEBUGLEVEL >= 10) {
2452                 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivValue, r);
2453         }
2454
2455         push = ndr_push_init_ctx(r);
2456         if (push == NULL) {
2457                 talloc_free(r);
2458                 return false;
2459         }
2460
2461         ndr_err = call->ndr_push(push, NDR_OUT, r);
2462         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2463                 talloc_free(r);
2464                 return false;
2465         }
2466
2467         blob = ndr_push_blob(push);
2468         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2469                 talloc_free(r);
2470                 return false;
2471         }
2472
2473         talloc_free(r);
2474
2475         return true;
2476 }
2477
2478 static bool api_lsa_LookupPrivName(pipes_struct *p)
2479 {
2480         const struct ndr_interface_call *call;
2481         struct ndr_pull *pull;
2482         struct ndr_push *push;
2483         enum ndr_err_code ndr_err;
2484         DATA_BLOB blob;
2485         struct lsa_LookupPrivName *r;
2486
2487         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPPRIVNAME];
2488
2489         r = talloc(NULL, struct lsa_LookupPrivName);
2490         if (r == NULL) {
2491                 return false;
2492         }
2493
2494         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2495                 talloc_free(r);
2496                 return false;
2497         }
2498
2499         pull = ndr_pull_init_blob(&blob, r);
2500         if (pull == NULL) {
2501                 talloc_free(r);
2502                 return false;
2503         }
2504
2505         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2506         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2507         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2508                 talloc_free(r);
2509                 return false;
2510         }
2511
2512         if (DEBUGLEVEL >= 10) {
2513                 NDR_PRINT_IN_DEBUG(lsa_LookupPrivName, r);
2514         }
2515
2516         ZERO_STRUCT(r->out);
2517         r->out.name = talloc_zero(r, struct lsa_StringLarge);
2518         if (r->out.name == NULL) {
2519                 talloc_free(r);
2520                 return false;
2521         }
2522
2523         r->out.result = _lsa_LookupPrivName(p, r);
2524
2525         if (p->rng_fault_state) {
2526                 talloc_free(r);
2527                 /* Return true here, srv_pipe_hnd.c will take care */
2528                 return true;
2529         }
2530
2531         if (DEBUGLEVEL >= 10) {
2532                 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivName, r);
2533         }
2534
2535         push = ndr_push_init_ctx(r);
2536         if (push == NULL) {
2537                 talloc_free(r);
2538                 return false;
2539         }
2540
2541         ndr_err = call->ndr_push(push, NDR_OUT, r);
2542         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2543                 talloc_free(r);
2544                 return false;
2545         }
2546
2547         blob = ndr_push_blob(push);
2548         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2549                 talloc_free(r);
2550                 return false;
2551         }
2552
2553         talloc_free(r);
2554
2555         return true;
2556 }
2557
2558 static bool api_lsa_LookupPrivDisplayName(pipes_struct *p)
2559 {
2560         const struct ndr_interface_call *call;
2561         struct ndr_pull *pull;
2562         struct ndr_push *push;
2563         enum ndr_err_code ndr_err;
2564         DATA_BLOB blob;
2565         struct lsa_LookupPrivDisplayName *r;
2566
2567         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPPRIVDISPLAYNAME];
2568
2569         r = talloc(NULL, struct lsa_LookupPrivDisplayName);
2570         if (r == NULL) {
2571                 return false;
2572         }
2573
2574         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2575                 talloc_free(r);
2576                 return false;
2577         }
2578
2579         pull = ndr_pull_init_blob(&blob, r);
2580         if (pull == NULL) {
2581                 talloc_free(r);
2582                 return false;
2583         }
2584
2585         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2586         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2587         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2588                 talloc_free(r);
2589                 return false;
2590         }
2591
2592         if (DEBUGLEVEL >= 10) {
2593                 NDR_PRINT_IN_DEBUG(lsa_LookupPrivDisplayName, r);
2594         }
2595
2596         ZERO_STRUCT(r->out);
2597         r->out.disp_name = talloc_zero(r, struct lsa_StringLarge);
2598         if (r->out.disp_name == NULL) {
2599                 talloc_free(r);
2600                 return false;
2601         }
2602
2603         r->out.language_id = r->in.language_id;
2604         r->out.result = _lsa_LookupPrivDisplayName(p, r);
2605
2606         if (p->rng_fault_state) {
2607                 talloc_free(r);
2608                 /* Return true here, srv_pipe_hnd.c will take care */
2609                 return true;
2610         }
2611
2612         if (DEBUGLEVEL >= 10) {
2613                 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivDisplayName, r);
2614         }
2615
2616         push = ndr_push_init_ctx(r);
2617         if (push == NULL) {
2618                 talloc_free(r);
2619                 return false;
2620         }
2621
2622         ndr_err = call->ndr_push(push, NDR_OUT, r);
2623         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2624                 talloc_free(r);
2625                 return false;
2626         }
2627
2628         blob = ndr_push_blob(push);
2629         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2630                 talloc_free(r);
2631                 return false;
2632         }
2633
2634         talloc_free(r);
2635
2636         return true;
2637 }
2638
2639 static bool api_lsa_DeleteObject(pipes_struct *p)
2640 {
2641         const struct ndr_interface_call *call;
2642         struct ndr_pull *pull;
2643         struct ndr_push *push;
2644         enum ndr_err_code ndr_err;
2645         DATA_BLOB blob;
2646         struct lsa_DeleteObject *r;
2647
2648         call = &ndr_table_lsarpc.calls[NDR_LSA_DELETEOBJECT];
2649
2650         r = talloc(NULL, struct lsa_DeleteObject);
2651         if (r == NULL) {
2652                 return false;
2653         }
2654
2655         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2656                 talloc_free(r);
2657                 return false;
2658         }
2659
2660         pull = ndr_pull_init_blob(&blob, r);
2661         if (pull == NULL) {
2662                 talloc_free(r);
2663                 return false;
2664         }
2665
2666         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2667         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2668         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2669                 talloc_free(r);
2670                 return false;
2671         }
2672
2673         if (DEBUGLEVEL >= 10) {
2674                 NDR_PRINT_IN_DEBUG(lsa_DeleteObject, r);
2675         }
2676
2677         r->out.result = _lsa_DeleteObject(p, r);
2678
2679         if (p->rng_fault_state) {
2680                 talloc_free(r);
2681                 /* Return true here, srv_pipe_hnd.c will take care */
2682                 return true;
2683         }
2684
2685         if (DEBUGLEVEL >= 10) {
2686                 NDR_PRINT_OUT_DEBUG(lsa_DeleteObject, r);
2687         }
2688
2689         push = ndr_push_init_ctx(r);
2690         if (push == NULL) {
2691                 talloc_free(r);
2692                 return false;
2693         }
2694
2695         ndr_err = call->ndr_push(push, NDR_OUT, r);
2696         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2697                 talloc_free(r);
2698                 return false;
2699         }
2700
2701         blob = ndr_push_blob(push);
2702         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2703                 talloc_free(r);
2704                 return false;
2705         }
2706
2707         talloc_free(r);
2708
2709         return true;
2710 }
2711
2712 static bool api_lsa_EnumAccountsWithUserRight(pipes_struct *p)
2713 {
2714         const struct ndr_interface_call *call;
2715         struct ndr_pull *pull;
2716         struct ndr_push *push;
2717         enum ndr_err_code ndr_err;
2718         DATA_BLOB blob;
2719         struct lsa_EnumAccountsWithUserRight *r;
2720
2721         call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT];
2722
2723         r = talloc(NULL, struct lsa_EnumAccountsWithUserRight);
2724         if (r == NULL) {
2725                 return false;
2726         }
2727
2728         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2729                 talloc_free(r);
2730                 return false;
2731         }
2732
2733         pull = ndr_pull_init_blob(&blob, r);
2734         if (pull == NULL) {
2735                 talloc_free(r);
2736                 return false;
2737         }
2738
2739         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2740         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2741         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2742                 talloc_free(r);
2743                 return false;
2744         }
2745
2746         if (DEBUGLEVEL >= 10) {
2747                 NDR_PRINT_IN_DEBUG(lsa_EnumAccountsWithUserRight, r);
2748         }
2749
2750         ZERO_STRUCT(r->out);
2751         r->out.sids = talloc_zero(r, struct lsa_SidArray);
2752         if (r->out.sids == NULL) {
2753                 talloc_free(r);
2754                 return false;
2755         }
2756
2757         r->out.result = _lsa_EnumAccountsWithUserRight(p, r);
2758
2759         if (p->rng_fault_state) {
2760                 talloc_free(r);
2761                 /* Return true here, srv_pipe_hnd.c will take care */
2762                 return true;
2763         }
2764
2765         if (DEBUGLEVEL >= 10) {
2766                 NDR_PRINT_OUT_DEBUG(lsa_EnumAccountsWithUserRight, r);
2767         }
2768
2769         push = ndr_push_init_ctx(r);
2770         if (push == NULL) {
2771                 talloc_free(r);
2772                 return false;
2773         }
2774
2775         ndr_err = call->ndr_push(push, NDR_OUT, r);
2776         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2777                 talloc_free(r);
2778                 return false;
2779         }
2780
2781         blob = ndr_push_blob(push);
2782         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2783                 talloc_free(r);
2784                 return false;
2785         }
2786
2787         talloc_free(r);
2788
2789         return true;
2790 }
2791
2792 static bool api_lsa_EnumAccountRights(pipes_struct *p)
2793 {
2794         const struct ndr_interface_call *call;
2795         struct ndr_pull *pull;
2796         struct ndr_push *push;
2797         enum ndr_err_code ndr_err;
2798         DATA_BLOB blob;
2799         struct lsa_EnumAccountRights *r;
2800
2801         call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMACCOUNTRIGHTS];
2802
2803         r = talloc(NULL, struct lsa_EnumAccountRights);
2804         if (r == NULL) {
2805                 return false;
2806         }
2807
2808         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2809                 talloc_free(r);
2810                 return false;
2811         }
2812
2813         pull = ndr_pull_init_blob(&blob, r);
2814         if (pull == NULL) {
2815                 talloc_free(r);
2816                 return false;
2817         }
2818
2819         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2820         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2821         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2822                 talloc_free(r);
2823                 return false;
2824         }
2825
2826         if (DEBUGLEVEL >= 10) {
2827                 NDR_PRINT_IN_DEBUG(lsa_EnumAccountRights, r);
2828         }
2829
2830         ZERO_STRUCT(r->out);
2831         r->out.rights = talloc_zero(r, struct lsa_RightSet);
2832         if (r->out.rights == NULL) {
2833                 talloc_free(r);
2834                 return false;
2835         }
2836
2837         r->out.result = _lsa_EnumAccountRights(p, r);
2838
2839         if (p->rng_fault_state) {
2840                 talloc_free(r);
2841                 /* Return true here, srv_pipe_hnd.c will take care */
2842                 return true;
2843         }
2844
2845         if (DEBUGLEVEL >= 10) {
2846                 NDR_PRINT_OUT_DEBUG(lsa_EnumAccountRights, r);
2847         }
2848
2849         push = ndr_push_init_ctx(r);
2850         if (push == NULL) {
2851                 talloc_free(r);
2852                 return false;
2853         }
2854
2855         ndr_err = call->ndr_push(push, NDR_OUT, r);
2856         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2857                 talloc_free(r);
2858                 return false;
2859         }
2860
2861         blob = ndr_push_blob(push);
2862         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2863                 talloc_free(r);
2864                 return false;
2865         }
2866
2867         talloc_free(r);
2868
2869         return true;
2870 }
2871
2872 static bool api_lsa_AddAccountRights(pipes_struct *p)
2873 {
2874         const struct ndr_interface_call *call;
2875         struct ndr_pull *pull;
2876         struct ndr_push *push;
2877         enum ndr_err_code ndr_err;
2878         DATA_BLOB blob;
2879         struct lsa_AddAccountRights *r;
2880
2881         call = &ndr_table_lsarpc.calls[NDR_LSA_ADDACCOUNTRIGHTS];
2882
2883         r = talloc(NULL, struct lsa_AddAccountRights);
2884         if (r == NULL) {
2885                 return false;
2886         }
2887
2888         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2889                 talloc_free(r);
2890                 return false;
2891         }
2892
2893         pull = ndr_pull_init_blob(&blob, r);
2894         if (pull == NULL) {
2895                 talloc_free(r);
2896                 return false;
2897         }
2898
2899         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2900         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2901         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2902                 talloc_free(r);
2903                 return false;
2904         }
2905
2906         if (DEBUGLEVEL >= 10) {
2907                 NDR_PRINT_IN_DEBUG(lsa_AddAccountRights, r);
2908         }
2909
2910         r->out.result = _lsa_AddAccountRights(p, r);
2911
2912         if (p->rng_fault_state) {
2913                 talloc_free(r);
2914                 /* Return true here, srv_pipe_hnd.c will take care */
2915                 return true;
2916         }
2917
2918         if (DEBUGLEVEL >= 10) {
2919                 NDR_PRINT_OUT_DEBUG(lsa_AddAccountRights, r);
2920         }
2921
2922         push = ndr_push_init_ctx(r);
2923         if (push == NULL) {
2924                 talloc_free(r);
2925                 return false;
2926         }
2927
2928         ndr_err = call->ndr_push(push, NDR_OUT, r);
2929         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2930                 talloc_free(r);
2931                 return false;
2932         }
2933
2934         blob = ndr_push_blob(push);
2935         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2936                 talloc_free(r);
2937                 return false;
2938         }
2939
2940         talloc_free(r);
2941
2942         return true;
2943 }
2944
2945 static bool api_lsa_RemoveAccountRights(pipes_struct *p)
2946 {
2947         const struct ndr_interface_call *call;
2948         struct ndr_pull *pull;
2949         struct ndr_push *push;
2950         enum ndr_err_code ndr_err;
2951         DATA_BLOB blob;
2952         struct lsa_RemoveAccountRights *r;
2953
2954         call = &ndr_table_lsarpc.calls[NDR_LSA_REMOVEACCOUNTRIGHTS];
2955
2956         r = talloc(NULL, struct lsa_RemoveAccountRights);
2957         if (r == NULL) {
2958                 return false;
2959         }
2960
2961         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2962                 talloc_free(r);
2963                 return false;
2964         }
2965
2966         pull = ndr_pull_init_blob(&blob, r);
2967         if (pull == NULL) {
2968                 talloc_free(r);
2969                 return false;
2970         }
2971
2972         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2973         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2974         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2975                 talloc_free(r);
2976                 return false;
2977         }
2978
2979         if (DEBUGLEVEL >= 10) {
2980                 NDR_PRINT_IN_DEBUG(lsa_RemoveAccountRights, r);
2981         }
2982
2983         r->out.result = _lsa_RemoveAccountRights(p, r);
2984
2985         if (p->rng_fault_state) {
2986                 talloc_free(r);
2987                 /* Return true here, srv_pipe_hnd.c will take care */
2988                 return true;
2989         }
2990
2991         if (DEBUGLEVEL >= 10) {
2992                 NDR_PRINT_OUT_DEBUG(lsa_RemoveAccountRights, r);
2993         }
2994
2995         push = ndr_push_init_ctx(r);
2996         if (push == NULL) {
2997                 talloc_free(r);
2998                 return false;
2999         }
3000
3001         ndr_err = call->ndr_push(push, NDR_OUT, r);
3002         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3003                 talloc_free(r);
3004                 return false;
3005         }
3006
3007         blob = ndr_push_blob(push);
3008         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3009                 talloc_free(r);
3010                 return false;
3011         }
3012
3013         talloc_free(r);
3014
3015         return true;
3016 }
3017
3018 static bool api_lsa_QueryTrustedDomainInfoBySid(pipes_struct *p)
3019 {
3020         const struct ndr_interface_call *call;
3021         struct ndr_pull *pull;
3022         struct ndr_push *push;
3023         enum ndr_err_code ndr_err;
3024         DATA_BLOB blob;
3025         struct lsa_QueryTrustedDomainInfoBySid *r;
3026
3027         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID];
3028
3029         r = talloc(NULL, struct lsa_QueryTrustedDomainInfoBySid);
3030         if (r == NULL) {
3031                 return false;
3032         }
3033
3034         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3035                 talloc_free(r);
3036                 return false;
3037         }
3038
3039         pull = ndr_pull_init_blob(&blob, r);
3040         if (pull == NULL) {
3041                 talloc_free(r);
3042                 return false;
3043         }
3044
3045         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3046         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3047         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3048                 talloc_free(r);
3049                 return false;
3050         }
3051
3052         if (DEBUGLEVEL >= 10) {
3053                 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfoBySid, r);
3054         }
3055
3056         ZERO_STRUCT(r->out);
3057         r->out.info = talloc_zero(r, union lsa_TrustedDomainInfo);
3058         if (r->out.info == NULL) {
3059                 talloc_free(r);
3060                 return false;
3061         }
3062
3063         r->out.result = _lsa_QueryTrustedDomainInfoBySid(p, r);
3064
3065         if (p->rng_fault_state) {
3066                 talloc_free(r);
3067                 /* Return true here, srv_pipe_hnd.c will take care */
3068                 return true;
3069         }
3070
3071         if (DEBUGLEVEL >= 10) {
3072                 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoBySid, r);
3073         }
3074
3075         push = ndr_push_init_ctx(r);
3076         if (push == NULL) {
3077                 talloc_free(r);
3078                 return false;
3079         }
3080
3081         ndr_err = call->ndr_push(push, NDR_OUT, r);
3082         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3083                 talloc_free(r);
3084                 return false;
3085         }
3086
3087         blob = ndr_push_blob(push);
3088         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3089                 talloc_free(r);
3090                 return false;
3091         }
3092
3093         talloc_free(r);
3094
3095         return true;
3096 }
3097
3098 static bool api_lsa_SetTrustedDomainInfo(pipes_struct *p)
3099 {
3100         const struct ndr_interface_call *call;
3101         struct ndr_pull *pull;
3102         struct ndr_push *push;
3103         enum ndr_err_code ndr_err;
3104         DATA_BLOB blob;
3105         struct lsa_SetTrustedDomainInfo *r;
3106
3107         call = &ndr_table_lsarpc.calls[NDR_LSA_SETTRUSTEDDOMAININFO];
3108
3109         r = talloc(NULL, struct lsa_SetTrustedDomainInfo);
3110         if (r == NULL) {
3111                 return false;
3112         }
3113
3114         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3115                 talloc_free(r);
3116                 return false;
3117         }
3118
3119         pull = ndr_pull_init_blob(&blob, r);
3120         if (pull == NULL) {
3121                 talloc_free(r);
3122                 return false;
3123         }
3124
3125         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3126         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3127         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3128                 talloc_free(r);
3129                 return false;
3130         }
3131
3132         if (DEBUGLEVEL >= 10) {
3133                 NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfo, r);
3134         }
3135
3136         r->out.result = _lsa_SetTrustedDomainInfo(p, r);
3137
3138         if (p->rng_fault_state) {
3139                 talloc_free(r);
3140                 /* Return true here, srv_pipe_hnd.c will take care */
3141                 return true;
3142         }
3143
3144         if (DEBUGLEVEL >= 10) {
3145                 NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfo, r);
3146         }
3147
3148         push = ndr_push_init_ctx(r);
3149         if (push == NULL) {
3150                 talloc_free(r);
3151                 return false;
3152         }
3153
3154         ndr_err = call->ndr_push(push, NDR_OUT, r);
3155         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3156                 talloc_free(r);
3157                 return false;
3158         }
3159
3160         blob = ndr_push_blob(push);
3161         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3162                 talloc_free(r);
3163                 return false;
3164         }
3165
3166         talloc_free(r);
3167
3168         return true;
3169 }
3170
3171 static bool api_lsa_DeleteTrustedDomain(pipes_struct *p)
3172 {
3173         const struct ndr_interface_call *call;
3174         struct ndr_pull *pull;
3175         struct ndr_push *push;
3176         enum ndr_err_code ndr_err;
3177         DATA_BLOB blob;
3178         struct lsa_DeleteTrustedDomain *r;
3179
3180         call = &ndr_table_lsarpc.calls[NDR_LSA_DELETETRUSTEDDOMAIN];
3181
3182         r = talloc(NULL, struct lsa_DeleteTrustedDomain);
3183         if (r == NULL) {
3184                 return false;
3185         }
3186
3187         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3188                 talloc_free(r);
3189                 return false;
3190         }
3191
3192         pull = ndr_pull_init_blob(&blob, r);
3193         if (pull == NULL) {
3194                 talloc_free(r);
3195                 return false;
3196         }
3197
3198         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3199         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3200         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3201                 talloc_free(r);
3202                 return false;
3203         }
3204
3205         if (DEBUGLEVEL >= 10) {
3206                 NDR_PRINT_IN_DEBUG(lsa_DeleteTrustedDomain, r);
3207         }
3208
3209         r->out.result = _lsa_DeleteTrustedDomain(p, r);
3210
3211         if (p->rng_fault_state) {
3212                 talloc_free(r);
3213                 /* Return true here, srv_pipe_hnd.c will take care */
3214                 return true;
3215         }
3216
3217         if (DEBUGLEVEL >= 10) {
3218                 NDR_PRINT_OUT_DEBUG(lsa_DeleteTrustedDomain, r);
3219         }
3220
3221         push = ndr_push_init_ctx(r);
3222         if (push == NULL) {
3223                 talloc_free(r);
3224                 return false;
3225         }
3226
3227         ndr_err = call->ndr_push(push, NDR_OUT, r);
3228         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3229                 talloc_free(r);
3230                 return false;
3231         }
3232
3233         blob = ndr_push_blob(push);
3234         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3235                 talloc_free(r);
3236                 return false;
3237         }
3238
3239         talloc_free(r);
3240
3241         return true;
3242 }
3243
3244 static bool api_lsa_StorePrivateData(pipes_struct *p)
3245 {
3246         const struct ndr_interface_call *call;
3247         struct ndr_pull *pull;
3248         struct ndr_push *push;
3249         enum ndr_err_code ndr_err;
3250         DATA_BLOB blob;
3251         struct lsa_StorePrivateData *r;
3252
3253         call = &ndr_table_lsarpc.calls[NDR_LSA_STOREPRIVATEDATA];
3254
3255         r = talloc(NULL, struct lsa_StorePrivateData);
3256         if (r == NULL) {
3257                 return false;
3258         }
3259
3260         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3261                 talloc_free(r);
3262                 return false;
3263         }
3264
3265         pull = ndr_pull_init_blob(&blob, r);
3266         if (pull == NULL) {
3267                 talloc_free(r);
3268                 return false;
3269         }
3270
3271         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3272         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3273         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3274                 talloc_free(r);
3275                 return false;
3276         }
3277
3278         if (DEBUGLEVEL >= 10) {
3279                 NDR_PRINT_IN_DEBUG(lsa_StorePrivateData, r);
3280         }
3281
3282         r->out.result = _lsa_StorePrivateData(p, r);
3283
3284         if (p->rng_fault_state) {
3285                 talloc_free(r);
3286                 /* Return true here, srv_pipe_hnd.c will take care */
3287                 return true;
3288         }
3289
3290         if (DEBUGLEVEL >= 10) {
3291                 NDR_PRINT_OUT_DEBUG(lsa_StorePrivateData, r);
3292         }
3293
3294         push = ndr_push_init_ctx(r);
3295         if (push == NULL) {
3296                 talloc_free(r);
3297                 return false;
3298         }
3299
3300         ndr_err = call->ndr_push(push, NDR_OUT, r);
3301         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3302                 talloc_free(r);
3303                 return false;
3304         }
3305
3306         blob = ndr_push_blob(push);
3307         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3308                 talloc_free(r);
3309                 return false;
3310         }
3311
3312         talloc_free(r);
3313
3314         return true;
3315 }
3316
3317 static bool api_lsa_RetrievePrivateData(pipes_struct *p)
3318 {
3319         const struct ndr_interface_call *call;
3320         struct ndr_pull *pull;
3321         struct ndr_push *push;
3322         enum ndr_err_code ndr_err;
3323         DATA_BLOB blob;
3324         struct lsa_RetrievePrivateData *r;
3325
3326         call = &ndr_table_lsarpc.calls[NDR_LSA_RETRIEVEPRIVATEDATA];
3327
3328         r = talloc(NULL, struct lsa_RetrievePrivateData);
3329         if (r == NULL) {
3330                 return false;
3331         }
3332
3333         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3334                 talloc_free(r);
3335                 return false;
3336         }
3337
3338         pull = ndr_pull_init_blob(&blob, r);
3339         if (pull == NULL) {
3340                 talloc_free(r);
3341                 return false;
3342         }
3343
3344         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3345         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3346         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3347                 talloc_free(r);
3348                 return false;
3349         }
3350
3351         if (DEBUGLEVEL >= 10) {
3352                 NDR_PRINT_IN_DEBUG(lsa_RetrievePrivateData, r);
3353         }
3354
3355         r->out.result = _lsa_RetrievePrivateData(p, r);
3356
3357         if (p->rng_fault_state) {
3358                 talloc_free(r);
3359                 /* Return true here, srv_pipe_hnd.c will take care */
3360                 return true;
3361         }
3362
3363         if (DEBUGLEVEL >= 10) {
3364                 NDR_PRINT_OUT_DEBUG(lsa_RetrievePrivateData, r);
3365         }
3366
3367         push = ndr_push_init_ctx(r);
3368         if (push == NULL) {
3369                 talloc_free(r);
3370                 return false;
3371         }
3372
3373         ndr_err = call->ndr_push(push, NDR_OUT, r);
3374         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3375                 talloc_free(r);
3376                 return false;
3377         }
3378
3379         blob = ndr_push_blob(push);
3380         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3381                 talloc_free(r);
3382                 return false;
3383         }
3384
3385         talloc_free(r);
3386
3387         return true;
3388 }
3389
3390 static bool api_lsa_OpenPolicy2(pipes_struct *p)
3391 {
3392         const struct ndr_interface_call *call;
3393         struct ndr_pull *pull;
3394         struct ndr_push *push;
3395         enum ndr_err_code ndr_err;
3396         DATA_BLOB blob;
3397         struct lsa_OpenPolicy2 *r;
3398
3399         call = &ndr_table_lsarpc.calls[NDR_LSA_OPENPOLICY2];
3400
3401         r = talloc(NULL, struct lsa_OpenPolicy2);
3402         if (r == NULL) {
3403                 return false;
3404         }
3405
3406         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3407                 talloc_free(r);
3408                 return false;
3409         }
3410
3411         pull = ndr_pull_init_blob(&blob, r);
3412         if (pull == NULL) {
3413                 talloc_free(r);
3414                 return false;
3415         }
3416
3417         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3418         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3419         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3420                 talloc_free(r);
3421                 return false;
3422         }
3423
3424         if (DEBUGLEVEL >= 10) {
3425                 NDR_PRINT_IN_DEBUG(lsa_OpenPolicy2, r);
3426         }
3427
3428         ZERO_STRUCT(r->out);
3429         r->out.handle = talloc_zero(r, struct policy_handle);
3430         if (r->out.handle == NULL) {
3431                 talloc_free(r);
3432                 return false;
3433         }
3434
3435         r->out.result = _lsa_OpenPolicy2(p, r);
3436
3437         if (p->rng_fault_state) {
3438                 talloc_free(r);
3439                 /* Return true here, srv_pipe_hnd.c will take care */
3440                 return true;
3441         }
3442
3443         if (DEBUGLEVEL >= 10) {
3444                 NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy2, r);
3445         }
3446
3447         push = ndr_push_init_ctx(r);
3448         if (push == NULL) {
3449                 talloc_free(r);
3450                 return false;
3451         }
3452
3453         ndr_err = call->ndr_push(push, NDR_OUT, r);
3454         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3455                 talloc_free(r);
3456                 return false;
3457         }
3458
3459         blob = ndr_push_blob(push);
3460         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3461                 talloc_free(r);
3462                 return false;
3463         }
3464
3465         talloc_free(r);
3466
3467         return true;
3468 }
3469
3470 static bool api_lsa_GetUserName(pipes_struct *p)
3471 {
3472         const struct ndr_interface_call *call;
3473         struct ndr_pull *pull;
3474         struct ndr_push *push;
3475         enum ndr_err_code ndr_err;
3476         DATA_BLOB blob;
3477         struct lsa_GetUserName *r;
3478
3479         call = &ndr_table_lsarpc.calls[NDR_LSA_GETUSERNAME];
3480
3481         r = talloc(NULL, struct lsa_GetUserName);
3482         if (r == NULL) {
3483                 return false;
3484         }
3485
3486         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3487                 talloc_free(r);
3488                 return false;
3489         }
3490
3491         pull = ndr_pull_init_blob(&blob, r);
3492         if (pull == NULL) {
3493                 talloc_free(r);
3494                 return false;
3495         }
3496
3497         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3498         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3499         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3500                 talloc_free(r);
3501                 return false;
3502         }
3503
3504         if (DEBUGLEVEL >= 10) {
3505                 NDR_PRINT_IN_DEBUG(lsa_GetUserName, r);
3506         }
3507
3508         ZERO_STRUCT(r->out);
3509         r->out.account_name = r->in.account_name;
3510         r->out.authority_name = r->in.authority_name;
3511         r->out.result = _lsa_GetUserName(p, r);
3512
3513         if (p->rng_fault_state) {
3514                 talloc_free(r);
3515                 /* Return true here, srv_pipe_hnd.c will take care */
3516                 return true;
3517         }
3518
3519         if (DEBUGLEVEL >= 10) {
3520                 NDR_PRINT_OUT_DEBUG(lsa_GetUserName, r);
3521         }
3522
3523         push = ndr_push_init_ctx(r);
3524         if (push == NULL) {
3525                 talloc_free(r);
3526                 return false;
3527         }
3528
3529         ndr_err = call->ndr_push(push, NDR_OUT, r);
3530         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3531                 talloc_free(r);
3532                 return false;
3533         }
3534
3535         blob = ndr_push_blob(push);
3536         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3537                 talloc_free(r);
3538                 return false;
3539         }
3540
3541         talloc_free(r);
3542
3543         return true;
3544 }
3545
3546 static bool api_lsa_QueryInfoPolicy2(pipes_struct *p)
3547 {
3548         const struct ndr_interface_call *call;
3549         struct ndr_pull *pull;
3550         struct ndr_push *push;
3551         enum ndr_err_code ndr_err;
3552         DATA_BLOB blob;
3553         struct lsa_QueryInfoPolicy2 *r;
3554
3555         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYINFOPOLICY2];
3556
3557         r = talloc(NULL, struct lsa_QueryInfoPolicy2);
3558         if (r == NULL) {
3559                 return false;
3560         }
3561
3562         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3563                 talloc_free(r);
3564                 return false;
3565         }
3566
3567         pull = ndr_pull_init_blob(&blob, r);
3568         if (pull == NULL) {
3569                 talloc_free(r);
3570                 return false;
3571         }
3572
3573         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3574         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3575         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3576                 talloc_free(r);
3577                 return false;
3578         }
3579
3580         if (DEBUGLEVEL >= 10) {
3581                 NDR_PRINT_IN_DEBUG(lsa_QueryInfoPolicy2, r);
3582         }
3583
3584         ZERO_STRUCT(r->out);
3585         r->out.info = talloc_zero(r, union lsa_PolicyInformation);
3586         if (r->out.info == NULL) {
3587                 talloc_free(r);
3588                 return false;
3589         }
3590
3591         r->out.result = _lsa_QueryInfoPolicy2(p, r);
3592
3593         if (p->rng_fault_state) {
3594                 talloc_free(r);
3595                 /* Return true here, srv_pipe_hnd.c will take care */
3596                 return true;
3597         }
3598
3599         if (DEBUGLEVEL >= 10) {
3600                 NDR_PRINT_OUT_DEBUG(lsa_QueryInfoPolicy2, r);
3601         }
3602
3603         push = ndr_push_init_ctx(r);
3604         if (push == NULL) {
3605                 talloc_free(r);
3606                 return false;
3607         }
3608
3609         ndr_err = call->ndr_push(push, NDR_OUT, r);
3610         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3611                 talloc_free(r);
3612                 return false;
3613         }
3614
3615         blob = ndr_push_blob(push);
3616         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3617                 talloc_free(r);
3618                 return false;
3619         }
3620
3621         talloc_free(r);
3622
3623         return true;
3624 }
3625
3626 static bool api_lsa_SetInfoPolicy2(pipes_struct *p)
3627 {
3628         const struct ndr_interface_call *call;
3629         struct ndr_pull *pull;
3630         struct ndr_push *push;
3631         enum ndr_err_code ndr_err;
3632         DATA_BLOB blob;
3633         struct lsa_SetInfoPolicy2 *r;
3634
3635         call = &ndr_table_lsarpc.calls[NDR_LSA_SETINFOPOLICY2];
3636
3637         r = talloc(NULL, struct lsa_SetInfoPolicy2);
3638         if (r == NULL) {
3639                 return false;
3640         }
3641
3642         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3643                 talloc_free(r);
3644                 return false;
3645         }
3646
3647         pull = ndr_pull_init_blob(&blob, r);
3648         if (pull == NULL) {
3649                 talloc_free(r);
3650                 return false;
3651         }
3652
3653         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3654         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3655         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3656                 talloc_free(r);
3657                 return false;
3658         }
3659
3660         if (DEBUGLEVEL >= 10) {
3661                 NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy2, r);
3662         }
3663
3664         r->out.result = _lsa_SetInfoPolicy2(p, r);
3665
3666         if (p->rng_fault_state) {
3667                 talloc_free(r);
3668                 /* Return true here, srv_pipe_hnd.c will take care */
3669                 return true;
3670         }
3671
3672         if (DEBUGLEVEL >= 10) {
3673                 NDR_PRINT_OUT_DEBUG(lsa_SetInfoPolicy2, r);
3674         }
3675
3676         push = ndr_push_init_ctx(r);
3677         if (push == NULL) {
3678                 talloc_free(r);
3679                 return false;
3680         }
3681
3682         ndr_err = call->ndr_push(push, NDR_OUT, r);
3683         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3684                 talloc_free(r);
3685                 return false;
3686         }
3687
3688         blob = ndr_push_blob(push);
3689         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3690                 talloc_free(r);
3691                 return false;
3692         }
3693
3694         talloc_free(r);
3695
3696         return true;
3697 }
3698
3699 static bool api_lsa_QueryTrustedDomainInfoByName(pipes_struct *p)
3700 {
3701         const struct ndr_interface_call *call;
3702         struct ndr_pull *pull;
3703         struct ndr_push *push;
3704         enum ndr_err_code ndr_err;
3705         DATA_BLOB blob;
3706         struct lsa_QueryTrustedDomainInfoByName *r;
3707
3708         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME];
3709
3710         r = talloc(NULL, struct lsa_QueryTrustedDomainInfoByName);
3711         if (r == NULL) {
3712                 return false;
3713         }
3714
3715         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3716                 talloc_free(r);
3717                 return false;
3718         }
3719
3720         pull = ndr_pull_init_blob(&blob, r);
3721         if (pull == NULL) {
3722                 talloc_free(r);
3723                 return false;
3724         }
3725
3726         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3727         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3728         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3729                 talloc_free(r);
3730                 return false;
3731         }
3732
3733         if (DEBUGLEVEL >= 10) {
3734                 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfoByName, r);
3735         }
3736
3737         ZERO_STRUCT(r->out);
3738         r->out.info = talloc_zero(r, union lsa_TrustedDomainInfo);
3739         if (r->out.info == NULL) {
3740                 talloc_free(r);
3741                 return false;
3742         }
3743
3744         r->out.result = _lsa_QueryTrustedDomainInfoByName(p, r);
3745
3746         if (p->rng_fault_state) {
3747                 talloc_free(r);
3748                 /* Return true here, srv_pipe_hnd.c will take care */
3749                 return true;
3750         }
3751
3752         if (DEBUGLEVEL >= 10) {
3753                 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoByName, r);
3754         }
3755
3756         push = ndr_push_init_ctx(r);
3757         if (push == NULL) {
3758                 talloc_free(r);
3759                 return false;
3760         }
3761
3762         ndr_err = call->ndr_push(push, NDR_OUT, r);
3763         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3764                 talloc_free(r);
3765                 return false;
3766         }
3767
3768         blob = ndr_push_blob(push);
3769         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3770                 talloc_free(r);
3771                 return false;
3772         }
3773
3774         talloc_free(r);
3775
3776         return true;
3777 }
3778
3779 static bool api_lsa_SetTrustedDomainInfoByName(pipes_struct *p)
3780 {
3781         const struct ndr_interface_call *call;
3782         struct ndr_pull *pull;
3783         struct ndr_push *push;
3784         enum ndr_err_code ndr_err;
3785         DATA_BLOB blob;
3786         struct lsa_SetTrustedDomainInfoByName *r;
3787
3788         call = &ndr_table_lsarpc.calls[NDR_LSA_SETTRUSTEDDOMAININFOBYNAME];
3789
3790         r = talloc(NULL, struct lsa_SetTrustedDomainInfoByName);
3791         if (r == NULL) {
3792                 return false;
3793         }
3794
3795         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3796                 talloc_free(r);
3797                 return false;
3798         }
3799
3800         pull = ndr_pull_init_blob(&blob, r);
3801         if (pull == NULL) {
3802                 talloc_free(r);
3803                 return false;
3804         }
3805
3806         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3807         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3808         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3809                 talloc_free(r);
3810                 return false;
3811         }
3812
3813         if (DEBUGLEVEL >= 10) {
3814                 NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfoByName, r);
3815         }
3816
3817         r->out.result = _lsa_SetTrustedDomainInfoByName(p, r);
3818
3819         if (p->rng_fault_state) {
3820                 talloc_free(r);
3821                 /* Return true here, srv_pipe_hnd.c will take care */
3822                 return true;
3823         }
3824
3825         if (DEBUGLEVEL >= 10) {
3826                 NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfoByName, r);
3827         }
3828
3829         push = ndr_push_init_ctx(r);
3830         if (push == NULL) {
3831                 talloc_free(r);
3832                 return false;
3833         }
3834
3835         ndr_err = call->ndr_push(push, NDR_OUT, r);
3836         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3837                 talloc_free(r);
3838                 return false;
3839         }
3840
3841         blob = ndr_push_blob(push);
3842         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3843                 talloc_free(r);
3844                 return false;
3845         }
3846
3847         talloc_free(r);
3848
3849         return true;
3850 }
3851
3852 static bool api_lsa_EnumTrustedDomainsEx(pipes_struct *p)
3853 {
3854         const struct ndr_interface_call *call;
3855         struct ndr_pull *pull;
3856         struct ndr_push *push;
3857         enum ndr_err_code ndr_err;
3858         DATA_BLOB blob;
3859         struct lsa_EnumTrustedDomainsEx *r;
3860
3861         call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMTRUSTEDDOMAINSEX];
3862
3863         r = talloc(NULL, struct lsa_EnumTrustedDomainsEx);
3864         if (r == NULL) {
3865                 return false;
3866         }
3867
3868         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3869                 talloc_free(r);
3870                 return false;
3871         }
3872
3873         pull = ndr_pull_init_blob(&blob, r);
3874         if (pull == NULL) {
3875                 talloc_free(r);
3876                 return false;
3877         }
3878
3879         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3880         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3881         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3882                 talloc_free(r);
3883                 return false;
3884         }
3885
3886         if (DEBUGLEVEL >= 10) {
3887                 NDR_PRINT_IN_DEBUG(lsa_EnumTrustedDomainsEx, r);
3888         }
3889
3890         ZERO_STRUCT(r->out);
3891         r->out.resume_handle = r->in.resume_handle;
3892         r->out.domains = talloc_zero(r, struct lsa_DomainListEx);
3893         if (r->out.domains == NULL) {
3894                 talloc_free(r);
3895                 return false;
3896         }
3897
3898         r->out.result = _lsa_EnumTrustedDomainsEx(p, r);
3899
3900         if (p->rng_fault_state) {
3901                 talloc_free(r);
3902                 /* Return true here, srv_pipe_hnd.c will take care */
3903                 return true;
3904         }
3905
3906         if (DEBUGLEVEL >= 10) {
3907                 NDR_PRINT_OUT_DEBUG(lsa_EnumTrustedDomainsEx, r);
3908         }
3909
3910         push = ndr_push_init_ctx(r);
3911         if (push == NULL) {
3912                 talloc_free(r);
3913                 return false;
3914         }
3915
3916         ndr_err = call->ndr_push(push, NDR_OUT, r);
3917         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3918                 talloc_free(r);
3919                 return false;
3920         }
3921
3922         blob = ndr_push_blob(push);
3923         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3924                 talloc_free(r);
3925                 return false;
3926         }
3927
3928         talloc_free(r);
3929
3930         return true;
3931 }
3932
3933 static bool api_lsa_CreateTrustedDomainEx(pipes_struct *p)
3934 {
3935         const struct ndr_interface_call *call;
3936         struct ndr_pull *pull;
3937         struct ndr_push *push;
3938         enum ndr_err_code ndr_err;
3939         DATA_BLOB blob;
3940         struct lsa_CreateTrustedDomainEx *r;
3941
3942         call = &ndr_table_lsarpc.calls[NDR_LSA_CREATETRUSTEDDOMAINEX];
3943
3944         r = talloc(NULL, struct lsa_CreateTrustedDomainEx);
3945         if (r == NULL) {
3946                 return false;
3947         }
3948
3949         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3950                 talloc_free(r);
3951                 return false;
3952         }
3953
3954         pull = ndr_pull_init_blob(&blob, r);
3955         if (pull == NULL) {
3956                 talloc_free(r);
3957                 return false;
3958         }
3959
3960         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3961         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3962         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3963                 talloc_free(r);
3964                 return false;
3965         }
3966
3967         if (DEBUGLEVEL >= 10) {
3968                 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx, r);
3969         }
3970
3971         r->out.result = _lsa_CreateTrustedDomainEx(p, r);
3972
3973         if (p->rng_fault_state) {
3974                 talloc_free(r);
3975                 /* Return true here, srv_pipe_hnd.c will take care */
3976                 return true;
3977         }
3978
3979         if (DEBUGLEVEL >= 10) {
3980                 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx, r);
3981         }
3982
3983         push = ndr_push_init_ctx(r);
3984         if (push == NULL) {
3985                 talloc_free(r);
3986                 return false;
3987         }
3988
3989         ndr_err = call->ndr_push(push, NDR_OUT, r);
3990         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3991                 talloc_free(r);
3992                 return false;
3993         }
3994
3995         blob = ndr_push_blob(push);
3996         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3997                 talloc_free(r);
3998                 return false;
3999         }
4000
4001         talloc_free(r);
4002
4003         return true;
4004 }
4005
4006 static bool api_lsa_CloseTrustedDomainEx(pipes_struct *p)
4007 {
4008         const struct ndr_interface_call *call;
4009         struct ndr_pull *pull;
4010         struct ndr_push *push;
4011         enum ndr_err_code ndr_err;
4012         DATA_BLOB blob;
4013         struct lsa_CloseTrustedDomainEx *r;
4014
4015         call = &ndr_table_lsarpc.calls[NDR_LSA_CLOSETRUSTEDDOMAINEX];
4016
4017         r = talloc(NULL, struct lsa_CloseTrustedDomainEx);
4018         if (r == NULL) {
4019                 return false;
4020         }
4021
4022         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4023                 talloc_free(r);
4024                 return false;
4025         }
4026
4027         pull = ndr_pull_init_blob(&blob, r);
4028         if (pull == NULL) {
4029                 talloc_free(r);
4030                 return false;
4031         }
4032
4033         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4034         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4035         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4036                 talloc_free(r);
4037                 return false;
4038         }
4039
4040         if (DEBUGLEVEL >= 10) {
4041                 NDR_PRINT_IN_DEBUG(lsa_CloseTrustedDomainEx, r);
4042         }
4043
4044         ZERO_STRUCT(r->out);
4045         r->out.handle = r->in.handle;
4046         r->out.result = _lsa_CloseTrustedDomainEx(p, r);
4047
4048         if (p->rng_fault_state) {
4049                 talloc_free(r);
4050                 /* Return true here, srv_pipe_hnd.c will take care */
4051                 return true;
4052         }
4053
4054         if (DEBUGLEVEL >= 10) {
4055                 NDR_PRINT_OUT_DEBUG(lsa_CloseTrustedDomainEx, r);
4056         }
4057
4058         push = ndr_push_init_ctx(r);
4059         if (push == NULL) {
4060                 talloc_free(r);
4061                 return false;
4062         }
4063
4064         ndr_err = call->ndr_push(push, NDR_OUT, r);
4065         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4066                 talloc_free(r);
4067                 return false;
4068         }
4069
4070         blob = ndr_push_blob(push);
4071         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4072                 talloc_free(r);
4073                 return false;
4074         }
4075
4076         talloc_free(r);
4077
4078         return true;
4079 }
4080
4081 static bool api_lsa_QueryDomainInformationPolicy(pipes_struct *p)
4082 {
4083         const struct ndr_interface_call *call;
4084         struct ndr_pull *pull;
4085         struct ndr_push *push;
4086         enum ndr_err_code ndr_err;
4087         DATA_BLOB blob;
4088         struct lsa_QueryDomainInformationPolicy *r;
4089
4090         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYDOMAININFORMATIONPOLICY];
4091
4092         r = talloc(NULL, struct lsa_QueryDomainInformationPolicy);
4093         if (r == NULL) {
4094                 return false;
4095         }
4096
4097         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4098                 talloc_free(r);
4099                 return false;
4100         }
4101
4102         pull = ndr_pull_init_blob(&blob, r);
4103         if (pull == NULL) {
4104                 talloc_free(r);
4105                 return false;
4106         }
4107
4108         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4109         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4110         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4111                 talloc_free(r);
4112                 return false;
4113         }
4114
4115         if (DEBUGLEVEL >= 10) {
4116                 NDR_PRINT_IN_DEBUG(lsa_QueryDomainInformationPolicy, r);
4117         }
4118
4119         ZERO_STRUCT(r->out);
4120         r->out.info = talloc_zero(r, union lsa_DomainInformationPolicy);
4121         if (r->out.info == NULL) {
4122                 talloc_free(r);
4123                 return false;
4124         }
4125
4126         r->out.result = _lsa_QueryDomainInformationPolicy(p, r);
4127
4128         if (p->rng_fault_state) {
4129                 talloc_free(r);
4130                 /* Return true here, srv_pipe_hnd.c will take care */
4131                 return true;
4132         }
4133
4134         if (DEBUGLEVEL >= 10) {
4135                 NDR_PRINT_OUT_DEBUG(lsa_QueryDomainInformationPolicy, r);
4136         }
4137
4138         push = ndr_push_init_ctx(r);
4139         if (push == NULL) {
4140                 talloc_free(r);
4141                 return false;
4142         }
4143
4144         ndr_err = call->ndr_push(push, NDR_OUT, r);
4145         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4146                 talloc_free(r);
4147                 return false;
4148         }
4149
4150         blob = ndr_push_blob(push);
4151         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4152                 talloc_free(r);
4153                 return false;
4154         }
4155
4156         talloc_free(r);
4157
4158         return true;
4159 }
4160
4161 static bool api_lsa_SetDomainInformationPolicy(pipes_struct *p)
4162 {
4163         const struct ndr_interface_call *call;
4164         struct ndr_pull *pull;
4165         struct ndr_push *push;
4166         enum ndr_err_code ndr_err;
4167         DATA_BLOB blob;
4168         struct lsa_SetDomainInformationPolicy *r;
4169
4170         call = &ndr_table_lsarpc.calls[NDR_LSA_SETDOMAININFORMATIONPOLICY];
4171
4172         r = talloc(NULL, struct lsa_SetDomainInformationPolicy);
4173         if (r == NULL) {
4174                 return false;
4175         }
4176
4177         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4178                 talloc_free(r);
4179                 return false;
4180         }
4181
4182         pull = ndr_pull_init_blob(&blob, r);
4183         if (pull == NULL) {
4184                 talloc_free(r);
4185                 return false;
4186         }
4187
4188         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4189         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4190         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4191                 talloc_free(r);
4192                 return false;
4193         }
4194
4195         if (DEBUGLEVEL >= 10) {
4196                 NDR_PRINT_IN_DEBUG(lsa_SetDomainInformationPolicy, r);
4197         }
4198
4199         r->out.result = _lsa_SetDomainInformationPolicy(p, r);
4200
4201         if (p->rng_fault_state) {
4202                 talloc_free(r);
4203                 /* Return true here, srv_pipe_hnd.c will take care */
4204                 return true;
4205         }
4206
4207         if (DEBUGLEVEL >= 10) {
4208                 NDR_PRINT_OUT_DEBUG(lsa_SetDomainInformationPolicy, r);
4209         }
4210
4211         push = ndr_push_init_ctx(r);
4212         if (push == NULL) {
4213                 talloc_free(r);
4214                 return false;
4215         }
4216
4217         ndr_err = call->ndr_push(push, NDR_OUT, r);
4218         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4219                 talloc_free(r);
4220                 return false;
4221         }
4222
4223         blob = ndr_push_blob(push);
4224         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4225                 talloc_free(r);
4226                 return false;
4227         }
4228
4229         talloc_free(r);
4230
4231         return true;
4232 }
4233
4234 static bool api_lsa_OpenTrustedDomainByName(pipes_struct *p)
4235 {
4236         const struct ndr_interface_call *call;
4237         struct ndr_pull *pull;
4238         struct ndr_push *push;
4239         enum ndr_err_code ndr_err;
4240         DATA_BLOB blob;
4241         struct lsa_OpenTrustedDomainByName *r;
4242
4243         call = &ndr_table_lsarpc.calls[NDR_LSA_OPENTRUSTEDDOMAINBYNAME];
4244
4245         r = talloc(NULL, struct lsa_OpenTrustedDomainByName);
4246         if (r == NULL) {
4247                 return false;
4248         }
4249
4250         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4251                 talloc_free(r);
4252                 return false;
4253         }
4254
4255         pull = ndr_pull_init_blob(&blob, r);
4256         if (pull == NULL) {
4257                 talloc_free(r);
4258                 return false;
4259         }
4260
4261         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4262         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4263         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4264                 talloc_free(r);
4265                 return false;
4266         }
4267
4268         if (DEBUGLEVEL >= 10) {
4269                 NDR_PRINT_IN_DEBUG(lsa_OpenTrustedDomainByName, r);
4270         }
4271
4272         ZERO_STRUCT(r->out);
4273         r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
4274         if (r->out.trustdom_handle == NULL) {
4275                 talloc_free(r);
4276                 return false;
4277         }
4278
4279         r->out.result = _lsa_OpenTrustedDomainByName(p, r);
4280
4281         if (p->rng_fault_state) {
4282                 talloc_free(r);
4283                 /* Return true here, srv_pipe_hnd.c will take care */
4284                 return true;
4285         }
4286
4287         if (DEBUGLEVEL >= 10) {
4288                 NDR_PRINT_OUT_DEBUG(lsa_OpenTrustedDomainByName, r);
4289         }
4290
4291         push = ndr_push_init_ctx(r);
4292         if (push == NULL) {
4293                 talloc_free(r);
4294                 return false;
4295         }
4296
4297         ndr_err = call->ndr_push(push, NDR_OUT, r);
4298         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4299                 talloc_free(r);
4300                 return false;
4301         }
4302
4303         blob = ndr_push_blob(push);
4304         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4305                 talloc_free(r);
4306                 return false;
4307         }
4308
4309         talloc_free(r);
4310
4311         return true;
4312 }
4313
4314 static bool api_lsa_TestCall(pipes_struct *p)
4315 {
4316         const struct ndr_interface_call *call;
4317         struct ndr_pull *pull;
4318         struct ndr_push *push;
4319         enum ndr_err_code ndr_err;
4320         DATA_BLOB blob;
4321         struct lsa_TestCall *r;
4322
4323         call = &ndr_table_lsarpc.calls[NDR_LSA_TESTCALL];
4324
4325         r = talloc(NULL, struct lsa_TestCall);
4326         if (r == NULL) {
4327                 return false;
4328         }
4329
4330         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4331                 talloc_free(r);
4332                 return false;
4333         }
4334
4335         pull = ndr_pull_init_blob(&blob, r);
4336         if (pull == NULL) {
4337                 talloc_free(r);
4338                 return false;
4339         }
4340
4341         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4342         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4343         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4344                 talloc_free(r);
4345                 return false;
4346         }
4347
4348         if (DEBUGLEVEL >= 10) {
4349                 NDR_PRINT_IN_DEBUG(lsa_TestCall, r);
4350         }
4351
4352         r->out.result = _lsa_TestCall(p, r);
4353
4354         if (p->rng_fault_state) {
4355                 talloc_free(r);
4356                 /* Return true here, srv_pipe_hnd.c will take care */
4357                 return true;
4358         }
4359
4360         if (DEBUGLEVEL >= 10) {
4361                 NDR_PRINT_OUT_DEBUG(lsa_TestCall, r);
4362         }
4363
4364         push = ndr_push_init_ctx(r);
4365         if (push == NULL) {
4366                 talloc_free(r);
4367                 return false;
4368         }
4369
4370         ndr_err = call->ndr_push(push, NDR_OUT, r);
4371         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4372                 talloc_free(r);
4373                 return false;
4374         }
4375
4376         blob = ndr_push_blob(push);
4377         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4378                 talloc_free(r);
4379                 return false;
4380         }
4381
4382         talloc_free(r);
4383
4384         return true;
4385 }
4386
4387 static bool api_lsa_LookupSids2(pipes_struct *p)
4388 {
4389         const struct ndr_interface_call *call;
4390         struct ndr_pull *pull;
4391         struct ndr_push *push;
4392         enum ndr_err_code ndr_err;
4393         DATA_BLOB blob;
4394         struct lsa_LookupSids2 *r;
4395
4396         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPSIDS2];
4397
4398         r = talloc(NULL, struct lsa_LookupSids2);
4399         if (r == NULL) {
4400                 return false;
4401         }
4402
4403         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4404                 talloc_free(r);
4405                 return false;
4406         }
4407
4408         pull = ndr_pull_init_blob(&blob, r);
4409         if (pull == NULL) {
4410                 talloc_free(r);
4411                 return false;
4412         }
4413
4414         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4415         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4416         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4417                 talloc_free(r);
4418                 return false;
4419         }
4420
4421         if (DEBUGLEVEL >= 10) {
4422                 NDR_PRINT_IN_DEBUG(lsa_LookupSids2, r);
4423         }
4424
4425         ZERO_STRUCT(r->out);
4426         r->out.domains = talloc_zero(r, struct lsa_RefDomainList);
4427         if (r->out.domains == NULL) {
4428                 talloc_free(r);
4429                 return false;
4430         }
4431
4432         r->out.names = r->in.names;
4433         r->out.count = r->in.count;
4434         r->out.result = _lsa_LookupSids2(p, r);
4435
4436         if (p->rng_fault_state) {
4437                 talloc_free(r);
4438                 /* Return true here, srv_pipe_hnd.c will take care */
4439                 return true;
4440         }
4441
4442         if (DEBUGLEVEL >= 10) {
4443                 NDR_PRINT_OUT_DEBUG(lsa_LookupSids2, r);
4444         }
4445
4446         push = ndr_push_init_ctx(r);
4447         if (push == NULL) {
4448                 talloc_free(r);
4449                 return false;
4450         }
4451
4452         ndr_err = call->ndr_push(push, NDR_OUT, r);
4453         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4454                 talloc_free(r);
4455                 return false;
4456         }
4457
4458         blob = ndr_push_blob(push);
4459         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4460                 talloc_free(r);
4461                 return false;
4462         }
4463
4464         talloc_free(r);
4465
4466         return true;
4467 }
4468
4469 static bool api_lsa_LookupNames2(pipes_struct *p)
4470 {
4471         const struct ndr_interface_call *call;
4472         struct ndr_pull *pull;
4473         struct ndr_push *push;
4474         enum ndr_err_code ndr_err;
4475         DATA_BLOB blob;
4476         struct lsa_LookupNames2 *r;
4477
4478         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPNAMES2];
4479
4480         r = talloc(NULL, struct lsa_LookupNames2);
4481         if (r == NULL) {
4482                 return false;
4483         }
4484
4485         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4486                 talloc_free(r);
4487                 return false;
4488         }
4489
4490         pull = ndr_pull_init_blob(&blob, r);
4491         if (pull == NULL) {
4492                 talloc_free(r);
4493                 return false;
4494         }
4495
4496         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4497         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4498         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4499                 talloc_free(r);
4500                 return false;
4501         }
4502
4503         if (DEBUGLEVEL >= 10) {
4504                 NDR_PRINT_IN_DEBUG(lsa_LookupNames2, r);
4505         }
4506
4507         ZERO_STRUCT(r->out);
4508         r->out.domains = talloc_zero(r, struct lsa_RefDomainList);
4509         if (r->out.domains == NULL) {
4510                 talloc_free(r);
4511                 return false;
4512         }
4513
4514         r->out.sids = r->in.sids;
4515         r->out.count = r->in.count;
4516         r->out.result = _lsa_LookupNames2(p, r);
4517
4518         if (p->rng_fault_state) {
4519                 talloc_free(r);
4520                 /* Return true here, srv_pipe_hnd.c will take care */
4521                 return true;
4522         }
4523
4524         if (DEBUGLEVEL >= 10) {
4525                 NDR_PRINT_OUT_DEBUG(lsa_LookupNames2, r);
4526         }
4527
4528         push = ndr_push_init_ctx(r);
4529         if (push == NULL) {
4530                 talloc_free(r);
4531                 return false;
4532         }
4533
4534         ndr_err = call->ndr_push(push, NDR_OUT, r);
4535         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4536                 talloc_free(r);
4537                 return false;
4538         }
4539
4540         blob = ndr_push_blob(push);
4541         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4542                 talloc_free(r);
4543                 return false;
4544         }
4545
4546         talloc_free(r);
4547
4548         return true;
4549 }
4550
4551 static bool api_lsa_CreateTrustedDomainEx2(pipes_struct *p)
4552 {
4553         const struct ndr_interface_call *call;
4554         struct ndr_pull *pull;
4555         struct ndr_push *push;
4556         enum ndr_err_code ndr_err;
4557         DATA_BLOB blob;
4558         struct lsa_CreateTrustedDomainEx2 *r;
4559
4560         call = &ndr_table_lsarpc.calls[NDR_LSA_CREATETRUSTEDDOMAINEX2];
4561
4562         r = talloc(NULL, struct lsa_CreateTrustedDomainEx2);
4563         if (r == NULL) {
4564                 return false;
4565         }
4566
4567         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4568                 talloc_free(r);
4569                 return false;
4570         }
4571
4572         pull = ndr_pull_init_blob(&blob, r);
4573         if (pull == NULL) {
4574                 talloc_free(r);
4575                 return false;
4576         }
4577
4578         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4579         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4580         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4581                 talloc_free(r);
4582                 return false;
4583         }
4584
4585         if (DEBUGLEVEL >= 10) {
4586                 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx2, r);
4587         }
4588
4589         r->out.result = _lsa_CreateTrustedDomainEx2(p, r);
4590
4591         if (p->rng_fault_state) {
4592                 talloc_free(r);
4593                 /* Return true here, srv_pipe_hnd.c will take care */
4594                 return true;
4595         }
4596
4597         if (DEBUGLEVEL >= 10) {
4598                 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx2, r);
4599         }
4600
4601         push = ndr_push_init_ctx(r);
4602         if (push == NULL) {
4603                 talloc_free(r);
4604                 return false;
4605         }
4606
4607         ndr_err = call->ndr_push(push, NDR_OUT, r);
4608         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4609                 talloc_free(r);
4610                 return false;
4611         }
4612
4613         blob = ndr_push_blob(push);
4614         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4615                 talloc_free(r);
4616                 return false;
4617         }
4618
4619         talloc_free(r);
4620
4621         return true;
4622 }
4623
4624 static bool api_lsa_CREDRWRITE(pipes_struct *p)
4625 {
4626         const struct ndr_interface_call *call;
4627         struct ndr_pull *pull;
4628         struct ndr_push *push;
4629         enum ndr_err_code ndr_err;
4630         DATA_BLOB blob;
4631         struct lsa_CREDRWRITE *r;
4632
4633         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRWRITE];
4634
4635         r = talloc(NULL, struct lsa_CREDRWRITE);
4636         if (r == NULL) {
4637                 return false;
4638         }
4639
4640         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4641                 talloc_free(r);
4642                 return false;
4643         }
4644
4645         pull = ndr_pull_init_blob(&blob, r);
4646         if (pull == NULL) {
4647                 talloc_free(r);
4648                 return false;
4649         }
4650
4651         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4652         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4653         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4654                 talloc_free(r);
4655                 return false;
4656         }
4657
4658         if (DEBUGLEVEL >= 10) {
4659                 NDR_PRINT_IN_DEBUG(lsa_CREDRWRITE, r);
4660         }
4661
4662         r->out.result = _lsa_CREDRWRITE(p, r);
4663
4664         if (p->rng_fault_state) {
4665                 talloc_free(r);
4666                 /* Return true here, srv_pipe_hnd.c will take care */
4667                 return true;
4668         }
4669
4670         if (DEBUGLEVEL >= 10) {
4671                 NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITE, r);
4672         }
4673
4674         push = ndr_push_init_ctx(r);
4675         if (push == NULL) {
4676                 talloc_free(r);
4677                 return false;
4678         }
4679
4680         ndr_err = call->ndr_push(push, NDR_OUT, r);
4681         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4682                 talloc_free(r);
4683                 return false;
4684         }
4685
4686         blob = ndr_push_blob(push);
4687         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4688                 talloc_free(r);
4689                 return false;
4690         }
4691
4692         talloc_free(r);
4693
4694         return true;
4695 }
4696
4697 static bool api_lsa_CREDRREAD(pipes_struct *p)
4698 {
4699         const struct ndr_interface_call *call;
4700         struct ndr_pull *pull;
4701         struct ndr_push *push;
4702         enum ndr_err_code ndr_err;
4703         DATA_BLOB blob;
4704         struct lsa_CREDRREAD *r;
4705
4706         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRREAD];
4707
4708         r = talloc(NULL, struct lsa_CREDRREAD);
4709         if (r == NULL) {
4710                 return false;
4711         }
4712
4713         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4714                 talloc_free(r);
4715                 return false;
4716         }
4717
4718         pull = ndr_pull_init_blob(&blob, r);
4719         if (pull == NULL) {
4720                 talloc_free(r);
4721                 return false;
4722         }
4723
4724         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4725         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4726         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4727                 talloc_free(r);
4728                 return false;
4729         }
4730
4731         if (DEBUGLEVEL >= 10) {
4732                 NDR_PRINT_IN_DEBUG(lsa_CREDRREAD, r);
4733         }
4734
4735         r->out.result = _lsa_CREDRREAD(p, r);
4736
4737         if (p->rng_fault_state) {
4738                 talloc_free(r);
4739                 /* Return true here, srv_pipe_hnd.c will take care */
4740                 return true;
4741         }
4742
4743         if (DEBUGLEVEL >= 10) {
4744                 NDR_PRINT_OUT_DEBUG(lsa_CREDRREAD, r);
4745         }
4746
4747         push = ndr_push_init_ctx(r);
4748         if (push == NULL) {
4749                 talloc_free(r);
4750                 return false;
4751         }
4752
4753         ndr_err = call->ndr_push(push, NDR_OUT, r);
4754         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4755                 talloc_free(r);
4756                 return false;
4757         }
4758
4759         blob = ndr_push_blob(push);
4760         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4761                 talloc_free(r);
4762                 return false;
4763         }
4764
4765         talloc_free(r);
4766
4767         return true;
4768 }
4769
4770 static bool api_lsa_CREDRENUMERATE(pipes_struct *p)
4771 {
4772         const struct ndr_interface_call *call;
4773         struct ndr_pull *pull;
4774         struct ndr_push *push;
4775         enum ndr_err_code ndr_err;
4776         DATA_BLOB blob;
4777         struct lsa_CREDRENUMERATE *r;
4778
4779         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRENUMERATE];
4780
4781         r = talloc(NULL, struct lsa_CREDRENUMERATE);
4782         if (r == NULL) {
4783                 return false;
4784         }
4785
4786         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4787                 talloc_free(r);
4788                 return false;
4789         }
4790
4791         pull = ndr_pull_init_blob(&blob, r);
4792         if (pull == NULL) {
4793                 talloc_free(r);
4794                 return false;
4795         }
4796
4797         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4798         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4799         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4800                 talloc_free(r);
4801                 return false;
4802         }
4803
4804         if (DEBUGLEVEL >= 10) {
4805                 NDR_PRINT_IN_DEBUG(lsa_CREDRENUMERATE, r);
4806         }
4807
4808         r->out.result = _lsa_CREDRENUMERATE(p, r);
4809
4810         if (p->rng_fault_state) {
4811                 talloc_free(r);
4812                 /* Return true here, srv_pipe_hnd.c will take care */
4813                 return true;
4814         }
4815
4816         if (DEBUGLEVEL >= 10) {
4817                 NDR_PRINT_OUT_DEBUG(lsa_CREDRENUMERATE, r);
4818         }
4819
4820         push = ndr_push_init_ctx(r);
4821         if (push == NULL) {
4822                 talloc_free(r);
4823                 return false;
4824         }
4825
4826         ndr_err = call->ndr_push(push, NDR_OUT, r);
4827         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4828                 talloc_free(r);
4829                 return false;
4830         }
4831
4832         blob = ndr_push_blob(push);
4833         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4834                 talloc_free(r);
4835                 return false;
4836         }
4837
4838         talloc_free(r);
4839
4840         return true;
4841 }
4842
4843 static bool api_lsa_CREDRWRITEDOMAINCREDENTIALS(pipes_struct *p)
4844 {
4845         const struct ndr_interface_call *call;
4846         struct ndr_pull *pull;
4847         struct ndr_push *push;
4848         enum ndr_err_code ndr_err;
4849         DATA_BLOB blob;
4850         struct lsa_CREDRWRITEDOMAINCREDENTIALS *r;
4851
4852         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRWRITEDOMAINCREDENTIALS];
4853
4854         r = talloc(NULL, struct lsa_CREDRWRITEDOMAINCREDENTIALS);
4855         if (r == NULL) {
4856                 return false;
4857         }
4858
4859         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4860                 talloc_free(r);
4861                 return false;
4862         }
4863
4864         pull = ndr_pull_init_blob(&blob, r);
4865         if (pull == NULL) {
4866                 talloc_free(r);
4867                 return false;
4868         }
4869
4870         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4871         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4872         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4873                 talloc_free(r);
4874                 return false;
4875         }
4876
4877         if (DEBUGLEVEL >= 10) {
4878                 NDR_PRINT_IN_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS, r);
4879         }
4880
4881         r->out.result = _lsa_CREDRWRITEDOMAINCREDENTIALS(p, r);
4882
4883         if (p->rng_fault_state) {
4884                 talloc_free(r);
4885                 /* Return true here, srv_pipe_hnd.c will take care */
4886                 return true;
4887         }
4888
4889         if (DEBUGLEVEL >= 10) {
4890                 NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS, r);
4891         }
4892
4893         push = ndr_push_init_ctx(r);
4894         if (push == NULL) {
4895                 talloc_free(r);
4896                 return false;
4897         }
4898
4899         ndr_err = call->ndr_push(push, NDR_OUT, r);
4900         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4901                 talloc_free(r);
4902                 return false;
4903         }
4904
4905         blob = ndr_push_blob(push);
4906         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4907                 talloc_free(r);
4908                 return false;
4909         }
4910
4911         talloc_free(r);
4912
4913         return true;
4914 }
4915
4916 static bool api_lsa_CREDRREADDOMAINCREDENTIALS(pipes_struct *p)
4917 {
4918         const struct ndr_interface_call *call;
4919         struct ndr_pull *pull;
4920         struct ndr_push *push;
4921         enum ndr_err_code ndr_err;
4922         DATA_BLOB blob;
4923         struct lsa_CREDRREADDOMAINCREDENTIALS *r;
4924
4925         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRREADDOMAINCREDENTIALS];
4926
4927         r = talloc(NULL, struct lsa_CREDRREADDOMAINCREDENTIALS);
4928         if (r == NULL) {
4929                 return false;
4930         }
4931
4932         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4933                 talloc_free(r);
4934                 return false;
4935         }
4936
4937         pull = ndr_pull_init_blob(&blob, r);
4938         if (pull == NULL) {
4939                 talloc_free(r);
4940                 return false;
4941         }
4942
4943         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4944         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4945         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4946                 talloc_free(r);
4947                 return false;
4948         }
4949
4950         if (DEBUGLEVEL >= 10) {
4951                 NDR_PRINT_IN_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS, r);
4952         }
4953
4954         r->out.result = _lsa_CREDRREADDOMAINCREDENTIALS(p, r);
4955
4956         if (p->rng_fault_state) {
4957                 talloc_free(r);
4958                 /* Return true here, srv_pipe_hnd.c will take care */
4959                 return true;
4960         }
4961
4962         if (DEBUGLEVEL >= 10) {
4963                 NDR_PRINT_OUT_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS, r);
4964         }
4965
4966         push = ndr_push_init_ctx(r);
4967         if (push == NULL) {
4968                 talloc_free(r);
4969                 return false;
4970         }
4971
4972         ndr_err = call->ndr_push(push, NDR_OUT, r);
4973         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4974                 talloc_free(r);
4975                 return false;
4976         }
4977
4978         blob = ndr_push_blob(push);
4979         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4980                 talloc_free(r);
4981                 return false;
4982         }
4983
4984         talloc_free(r);
4985
4986         return true;
4987 }
4988
4989 static bool api_lsa_CREDRDELETE(pipes_struct *p)
4990 {
4991         const struct ndr_interface_call *call;
4992         struct ndr_pull *pull;
4993         struct ndr_push *push;
4994         enum ndr_err_code ndr_err;
4995         DATA_BLOB blob;
4996         struct lsa_CREDRDELETE *r;
4997
4998         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRDELETE];
4999
5000         r = talloc(NULL, struct lsa_CREDRDELETE);
5001         if (r == NULL) {
5002                 return false;
5003         }
5004
5005         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5006                 talloc_free(r);
5007                 return false;
5008         }
5009
5010         pull = ndr_pull_init_blob(&blob, r);
5011         if (pull == NULL) {
5012                 talloc_free(r);
5013                 return false;
5014         }
5015
5016         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5017         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5018         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5019                 talloc_free(r);
5020                 return false;
5021         }
5022
5023         if (DEBUGLEVEL >= 10) {
5024                 NDR_PRINT_IN_DEBUG(lsa_CREDRDELETE, r);
5025         }
5026
5027         r->out.result = _lsa_CREDRDELETE(p, r);
5028
5029         if (p->rng_fault_state) {
5030                 talloc_free(r);
5031                 /* Return true here, srv_pipe_hnd.c will take care */
5032                 return true;
5033         }
5034
5035         if (DEBUGLEVEL >= 10) {
5036                 NDR_PRINT_OUT_DEBUG(lsa_CREDRDELETE, r);
5037         }
5038
5039         push = ndr_push_init_ctx(r);
5040         if (push == NULL) {
5041                 talloc_free(r);
5042                 return false;
5043         }
5044
5045         ndr_err = call->ndr_push(push, NDR_OUT, r);
5046         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5047                 talloc_free(r);
5048                 return false;
5049         }
5050
5051         blob = ndr_push_blob(push);
5052         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5053                 talloc_free(r);
5054                 return false;
5055         }
5056
5057         talloc_free(r);
5058
5059         return true;
5060 }
5061
5062 static bool api_lsa_CREDRGETTARGETINFO(pipes_struct *p)
5063 {
5064         const struct ndr_interface_call *call;
5065         struct ndr_pull *pull;
5066         struct ndr_push *push;
5067         enum ndr_err_code ndr_err;
5068         DATA_BLOB blob;
5069         struct lsa_CREDRGETTARGETINFO *r;
5070
5071         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRGETTARGETINFO];
5072
5073         r = talloc(NULL, struct lsa_CREDRGETTARGETINFO);
5074         if (r == NULL) {
5075                 return false;
5076         }
5077
5078         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5079                 talloc_free(r);
5080                 return false;
5081         }
5082
5083         pull = ndr_pull_init_blob(&blob, r);
5084         if (pull == NULL) {
5085                 talloc_free(r);
5086                 return false;
5087         }
5088
5089         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5090         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5091         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5092                 talloc_free(r);
5093                 return false;
5094         }
5095
5096         if (DEBUGLEVEL >= 10) {
5097                 NDR_PRINT_IN_DEBUG(lsa_CREDRGETTARGETINFO, r);
5098         }
5099
5100         r->out.result = _lsa_CREDRGETTARGETINFO(p, r);
5101
5102         if (p->rng_fault_state) {
5103                 talloc_free(r);
5104                 /* Return true here, srv_pipe_hnd.c will take care */
5105                 return true;
5106         }
5107
5108         if (DEBUGLEVEL >= 10) {
5109                 NDR_PRINT_OUT_DEBUG(lsa_CREDRGETTARGETINFO, r);
5110         }
5111
5112         push = ndr_push_init_ctx(r);
5113         if (push == NULL) {
5114                 talloc_free(r);
5115                 return false;
5116         }
5117
5118         ndr_err = call->ndr_push(push, NDR_OUT, r);
5119         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5120                 talloc_free(r);
5121                 return false;
5122         }
5123
5124         blob = ndr_push_blob(push);
5125         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5126                 talloc_free(r);
5127                 return false;
5128         }
5129
5130         talloc_free(r);
5131
5132         return true;
5133 }
5134
5135 static bool api_lsa_CREDRPROFILELOADED(pipes_struct *p)
5136 {
5137         const struct ndr_interface_call *call;
5138         struct ndr_pull *pull;
5139         struct ndr_push *push;
5140         enum ndr_err_code ndr_err;
5141         DATA_BLOB blob;
5142         struct lsa_CREDRPROFILELOADED *r;
5143
5144         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRPROFILELOADED];
5145
5146         r = talloc(NULL, struct lsa_CREDRPROFILELOADED);
5147         if (r == NULL) {
5148                 return false;
5149         }
5150
5151         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5152                 talloc_free(r);
5153                 return false;
5154         }
5155
5156         pull = ndr_pull_init_blob(&blob, r);
5157         if (pull == NULL) {
5158                 talloc_free(r);
5159                 return false;
5160         }
5161
5162         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5163         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5164         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5165                 talloc_free(r);
5166                 return false;
5167         }
5168
5169         if (DEBUGLEVEL >= 10) {
5170                 NDR_PRINT_IN_DEBUG(lsa_CREDRPROFILELOADED, r);
5171         }
5172
5173         r->out.result = _lsa_CREDRPROFILELOADED(p, r);
5174
5175         if (p->rng_fault_state) {
5176                 talloc_free(r);
5177                 /* Return true here, srv_pipe_hnd.c will take care */
5178                 return true;
5179         }
5180
5181         if (DEBUGLEVEL >= 10) {
5182                 NDR_PRINT_OUT_DEBUG(lsa_CREDRPROFILELOADED, r);
5183         }
5184
5185         push = ndr_push_init_ctx(r);
5186         if (push == NULL) {
5187                 talloc_free(r);
5188                 return false;
5189         }
5190
5191         ndr_err = call->ndr_push(push, NDR_OUT, r);
5192         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5193                 talloc_free(r);
5194                 return false;
5195         }
5196
5197         blob = ndr_push_blob(push);
5198         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5199                 talloc_free(r);
5200                 return false;
5201         }
5202
5203         talloc_free(r);
5204
5205         return true;
5206 }
5207
5208 static bool api_lsa_LookupNames3(pipes_struct *p)
5209 {
5210         const struct ndr_interface_call *call;
5211         struct ndr_pull *pull;
5212         struct ndr_push *push;
5213         enum ndr_err_code ndr_err;
5214         DATA_BLOB blob;
5215         struct lsa_LookupNames3 *r;
5216
5217         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPNAMES3];
5218
5219         r = talloc(NULL, struct lsa_LookupNames3);
5220         if (r == NULL) {
5221                 return false;
5222         }
5223
5224         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5225                 talloc_free(r);
5226                 return false;
5227         }
5228
5229         pull = ndr_pull_init_blob(&blob, r);
5230         if (pull == NULL) {
5231                 talloc_free(r);
5232                 return false;
5233         }
5234
5235         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5236         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5237         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5238                 talloc_free(r);
5239                 return false;
5240         }
5241
5242         if (DEBUGLEVEL >= 10) {
5243                 NDR_PRINT_IN_DEBUG(lsa_LookupNames3, r);
5244         }
5245
5246         ZERO_STRUCT(r->out);
5247         r->out.domains = talloc_zero(r, struct lsa_RefDomainList);
5248         if (r->out.domains == NULL) {
5249                 talloc_free(r);
5250                 return false;
5251         }
5252
5253         r->out.sids = r->in.sids;
5254         r->out.count = r->in.count;
5255         r->out.result = _lsa_LookupNames3(p, r);
5256
5257         if (p->rng_fault_state) {
5258                 talloc_free(r);
5259                 /* Return true here, srv_pipe_hnd.c will take care */
5260                 return true;
5261         }
5262
5263         if (DEBUGLEVEL >= 10) {
5264                 NDR_PRINT_OUT_DEBUG(lsa_LookupNames3, r);
5265         }
5266
5267         push = ndr_push_init_ctx(r);
5268         if (push == NULL) {
5269                 talloc_free(r);
5270                 return false;
5271         }
5272
5273         ndr_err = call->ndr_push(push, NDR_OUT, r);
5274         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5275                 talloc_free(r);
5276                 return false;
5277         }
5278
5279         blob = ndr_push_blob(push);
5280         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5281                 talloc_free(r);
5282                 return false;
5283         }
5284
5285         talloc_free(r);
5286
5287         return true;
5288 }
5289
5290 static bool api_lsa_CREDRGETSESSIONTYPES(pipes_struct *p)
5291 {
5292         const struct ndr_interface_call *call;
5293         struct ndr_pull *pull;
5294         struct ndr_push *push;
5295         enum ndr_err_code ndr_err;
5296         DATA_BLOB blob;
5297         struct lsa_CREDRGETSESSIONTYPES *r;
5298
5299         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRGETSESSIONTYPES];
5300
5301         r = talloc(NULL, struct lsa_CREDRGETSESSIONTYPES);
5302         if (r == NULL) {
5303                 return false;
5304         }
5305
5306         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5307                 talloc_free(r);
5308                 return false;
5309         }
5310
5311         pull = ndr_pull_init_blob(&blob, r);
5312         if (pull == NULL) {
5313                 talloc_free(r);
5314                 return false;
5315         }
5316
5317         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5318         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5319         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5320                 talloc_free(r);
5321                 return false;
5322         }
5323
5324         if (DEBUGLEVEL >= 10) {
5325                 NDR_PRINT_IN_DEBUG(lsa_CREDRGETSESSIONTYPES, r);
5326         }
5327
5328         r->out.result = _lsa_CREDRGETSESSIONTYPES(p, r);
5329
5330         if (p->rng_fault_state) {
5331                 talloc_free(r);
5332                 /* Return true here, srv_pipe_hnd.c will take care */
5333                 return true;
5334         }
5335
5336         if (DEBUGLEVEL >= 10) {
5337                 NDR_PRINT_OUT_DEBUG(lsa_CREDRGETSESSIONTYPES, r);
5338         }
5339
5340         push = ndr_push_init_ctx(r);
5341         if (push == NULL) {
5342                 talloc_free(r);
5343                 return false;
5344         }
5345
5346         ndr_err = call->ndr_push(push, NDR_OUT, r);
5347         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5348                 talloc_free(r);
5349                 return false;
5350         }
5351
5352         blob = ndr_push_blob(push);
5353         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5354                 talloc_free(r);
5355                 return false;
5356         }
5357
5358         talloc_free(r);
5359
5360         return true;
5361 }
5362
5363 static bool api_lsa_LSARREGISTERAUDITEVENT(pipes_struct *p)
5364 {
5365         const struct ndr_interface_call *call;
5366         struct ndr_pull *pull;
5367         struct ndr_push *push;
5368         enum ndr_err_code ndr_err;
5369         DATA_BLOB blob;
5370         struct lsa_LSARREGISTERAUDITEVENT *r;
5371
5372         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARREGISTERAUDITEVENT];
5373
5374         r = talloc(NULL, struct lsa_LSARREGISTERAUDITEVENT);
5375         if (r == NULL) {
5376                 return false;
5377         }
5378
5379         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5380                 talloc_free(r);
5381                 return false;
5382         }
5383
5384         pull = ndr_pull_init_blob(&blob, r);
5385         if (pull == NULL) {
5386                 talloc_free(r);
5387                 return false;
5388         }
5389
5390         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5391         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5392         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5393                 talloc_free(r);
5394                 return false;
5395         }
5396
5397         if (DEBUGLEVEL >= 10) {
5398                 NDR_PRINT_IN_DEBUG(lsa_LSARREGISTERAUDITEVENT, r);
5399         }
5400
5401         r->out.result = _lsa_LSARREGISTERAUDITEVENT(p, r);
5402
5403         if (p->rng_fault_state) {
5404                 talloc_free(r);
5405                 /* Return true here, srv_pipe_hnd.c will take care */
5406                 return true;
5407         }
5408
5409         if (DEBUGLEVEL >= 10) {
5410                 NDR_PRINT_OUT_DEBUG(lsa_LSARREGISTERAUDITEVENT, r);
5411         }
5412
5413         push = ndr_push_init_ctx(r);
5414         if (push == NULL) {
5415                 talloc_free(r);
5416                 return false;
5417         }
5418
5419         ndr_err = call->ndr_push(push, NDR_OUT, r);
5420         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5421                 talloc_free(r);
5422                 return false;
5423         }
5424
5425         blob = ndr_push_blob(push);
5426         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5427                 talloc_free(r);
5428                 return false;
5429         }
5430
5431         talloc_free(r);
5432
5433         return true;
5434 }
5435
5436 static bool api_lsa_LSARGENAUDITEVENT(pipes_struct *p)
5437 {
5438         const struct ndr_interface_call *call;
5439         struct ndr_pull *pull;
5440         struct ndr_push *push;
5441         enum ndr_err_code ndr_err;
5442         DATA_BLOB blob;
5443         struct lsa_LSARGENAUDITEVENT *r;
5444
5445         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARGENAUDITEVENT];
5446
5447         r = talloc(NULL, struct lsa_LSARGENAUDITEVENT);
5448         if (r == NULL) {
5449                 return false;
5450         }
5451
5452         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5453                 talloc_free(r);
5454                 return false;
5455         }
5456
5457         pull = ndr_pull_init_blob(&blob, r);
5458         if (pull == NULL) {
5459                 talloc_free(r);
5460                 return false;
5461         }
5462
5463         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5464         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5465         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5466                 talloc_free(r);
5467                 return false;
5468         }
5469
5470         if (DEBUGLEVEL >= 10) {
5471                 NDR_PRINT_IN_DEBUG(lsa_LSARGENAUDITEVENT, r);
5472         }
5473
5474         r->out.result = _lsa_LSARGENAUDITEVENT(p, r);
5475
5476         if (p->rng_fault_state) {
5477                 talloc_free(r);
5478                 /* Return true here, srv_pipe_hnd.c will take care */
5479                 return true;
5480         }
5481
5482         if (DEBUGLEVEL >= 10) {
5483                 NDR_PRINT_OUT_DEBUG(lsa_LSARGENAUDITEVENT, r);
5484         }
5485
5486         push = ndr_push_init_ctx(r);
5487         if (push == NULL) {
5488                 talloc_free(r);
5489                 return false;
5490         }
5491
5492         ndr_err = call->ndr_push(push, NDR_OUT, r);
5493         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5494                 talloc_free(r);
5495                 return false;
5496         }
5497
5498         blob = ndr_push_blob(push);
5499         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5500                 talloc_free(r);
5501                 return false;
5502         }
5503
5504         talloc_free(r);
5505
5506         return true;
5507 }
5508
5509 static bool api_lsa_LSARUNREGISTERAUDITEVENT(pipes_struct *p)
5510 {
5511         const struct ndr_interface_call *call;
5512         struct ndr_pull *pull;
5513         struct ndr_push *push;
5514         enum ndr_err_code ndr_err;
5515         DATA_BLOB blob;
5516         struct lsa_LSARUNREGISTERAUDITEVENT *r;
5517
5518         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARUNREGISTERAUDITEVENT];
5519
5520         r = talloc(NULL, struct lsa_LSARUNREGISTERAUDITEVENT);
5521         if (r == NULL) {
5522                 return false;
5523         }
5524
5525         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5526                 talloc_free(r);
5527                 return false;
5528         }
5529
5530         pull = ndr_pull_init_blob(&blob, r);
5531         if (pull == NULL) {
5532                 talloc_free(r);
5533                 return false;
5534         }
5535
5536         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5537         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5538         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5539                 talloc_free(r);
5540                 return false;
5541         }
5542
5543         if (DEBUGLEVEL >= 10) {
5544                 NDR_PRINT_IN_DEBUG(lsa_LSARUNREGISTERAUDITEVENT, r);
5545         }
5546
5547         r->out.result = _lsa_LSARUNREGISTERAUDITEVENT(p, r);
5548
5549         if (p->rng_fault_state) {
5550                 talloc_free(r);
5551                 /* Return true here, srv_pipe_hnd.c will take care */
5552                 return true;
5553         }
5554
5555         if (DEBUGLEVEL >= 10) {
5556                 NDR_PRINT_OUT_DEBUG(lsa_LSARUNREGISTERAUDITEVENT, r);
5557         }
5558
5559         push = ndr_push_init_ctx(r);
5560         if (push == NULL) {
5561                 talloc_free(r);
5562                 return false;
5563         }
5564
5565         ndr_err = call->ndr_push(push, NDR_OUT, r);
5566         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5567                 talloc_free(r);
5568                 return false;
5569         }
5570
5571         blob = ndr_push_blob(push);
5572         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5573                 talloc_free(r);
5574                 return false;
5575         }
5576
5577         talloc_free(r);
5578
5579         return true;
5580 }
5581
5582 static bool api_lsa_lsaRQueryForestTrustInformation(pipes_struct *p)
5583 {
5584         const struct ndr_interface_call *call;
5585         struct ndr_pull *pull;
5586         struct ndr_push *push;
5587         enum ndr_err_code ndr_err;
5588         DATA_BLOB blob;
5589         struct lsa_lsaRQueryForestTrustInformation *r;
5590
5591         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION];
5592
5593         r = talloc(NULL, struct lsa_lsaRQueryForestTrustInformation);
5594         if (r == NULL) {
5595                 return false;
5596         }
5597
5598         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5599                 talloc_free(r);
5600                 return false;
5601         }
5602
5603         pull = ndr_pull_init_blob(&blob, r);
5604         if (pull == NULL) {
5605                 talloc_free(r);
5606                 return false;
5607         }
5608
5609         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5610         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5611         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5612                 talloc_free(r);
5613                 return false;
5614         }
5615
5616         if (DEBUGLEVEL >= 10) {
5617                 NDR_PRINT_IN_DEBUG(lsa_lsaRQueryForestTrustInformation, r);
5618         }
5619
5620         ZERO_STRUCT(r->out);
5621         r->out.forest_trust_info = talloc_zero(r, struct lsa_ForestTrustInformation *);
5622         if (r->out.forest_trust_info == NULL) {
5623                 talloc_free(r);
5624                 return false;
5625         }
5626
5627         r->out.result = _lsa_lsaRQueryForestTrustInformation(p, r);
5628
5629         if (p->rng_fault_state) {
5630                 talloc_free(r);
5631                 /* Return true here, srv_pipe_hnd.c will take care */
5632                 return true;
5633         }
5634
5635         if (DEBUGLEVEL >= 10) {
5636                 NDR_PRINT_OUT_DEBUG(lsa_lsaRQueryForestTrustInformation, r);
5637         }
5638
5639         push = ndr_push_init_ctx(r);
5640         if (push == NULL) {
5641                 talloc_free(r);
5642                 return false;
5643         }
5644
5645         ndr_err = call->ndr_push(push, NDR_OUT, r);
5646         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5647                 talloc_free(r);
5648                 return false;
5649         }
5650
5651         blob = ndr_push_blob(push);
5652         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5653                 talloc_free(r);
5654                 return false;
5655         }
5656
5657         talloc_free(r);
5658
5659         return true;
5660 }
5661
5662 static bool api_lsa_LSARSETFORESTTRUSTINFORMATION(pipes_struct *p)
5663 {
5664         const struct ndr_interface_call *call;
5665         struct ndr_pull *pull;
5666         struct ndr_push *push;
5667         enum ndr_err_code ndr_err;
5668         DATA_BLOB blob;
5669         struct lsa_LSARSETFORESTTRUSTINFORMATION *r;
5670
5671         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARSETFORESTTRUSTINFORMATION];
5672
5673         r = talloc(NULL, struct lsa_LSARSETFORESTTRUSTINFORMATION);
5674         if (r == NULL) {
5675                 return false;
5676         }
5677
5678         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5679                 talloc_free(r);
5680                 return false;
5681         }
5682
5683         pull = ndr_pull_init_blob(&blob, r);
5684         if (pull == NULL) {
5685                 talloc_free(r);
5686                 return false;
5687         }
5688
5689         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5690         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5691         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5692                 talloc_free(r);
5693                 return false;
5694         }
5695
5696         if (DEBUGLEVEL >= 10) {
5697                 NDR_PRINT_IN_DEBUG(lsa_LSARSETFORESTTRUSTINFORMATION, r);
5698         }
5699
5700         r->out.result = _lsa_LSARSETFORESTTRUSTINFORMATION(p, r);
5701
5702         if (p->rng_fault_state) {
5703                 talloc_free(r);
5704                 /* Return true here, srv_pipe_hnd.c will take care */
5705                 return true;
5706         }
5707
5708         if (DEBUGLEVEL >= 10) {
5709                 NDR_PRINT_OUT_DEBUG(lsa_LSARSETFORESTTRUSTINFORMATION, r);
5710         }
5711
5712         push = ndr_push_init_ctx(r);
5713         if (push == NULL) {
5714                 talloc_free(r);
5715                 return false;
5716         }
5717
5718         ndr_err = call->ndr_push(push, NDR_OUT, r);
5719         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5720                 talloc_free(r);
5721                 return false;
5722         }
5723
5724         blob = ndr_push_blob(push);
5725         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5726                 talloc_free(r);
5727                 return false;
5728         }
5729
5730         talloc_free(r);
5731
5732         return true;
5733 }
5734
5735 static bool api_lsa_CREDRRENAME(pipes_struct *p)
5736 {
5737         const struct ndr_interface_call *call;
5738         struct ndr_pull *pull;
5739         struct ndr_push *push;
5740         enum ndr_err_code ndr_err;
5741         DATA_BLOB blob;
5742         struct lsa_CREDRRENAME *r;
5743
5744         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRRENAME];
5745
5746         r = talloc(NULL, struct lsa_CREDRRENAME);
5747         if (r == NULL) {
5748                 return false;
5749         }
5750
5751         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5752                 talloc_free(r);
5753                 return false;
5754         }
5755
5756         pull = ndr_pull_init_blob(&blob, r);
5757         if (pull == NULL) {
5758                 talloc_free(r);
5759                 return false;
5760         }
5761
5762         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5763         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5764         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5765                 talloc_free(r);
5766                 return false;
5767         }
5768
5769         if (DEBUGLEVEL >= 10) {
5770                 NDR_PRINT_IN_DEBUG(lsa_CREDRRENAME, r);
5771         }
5772
5773         r->out.result = _lsa_CREDRRENAME(p, r);
5774
5775         if (p->rng_fault_state) {
5776                 talloc_free(r);
5777                 /* Return true here, srv_pipe_hnd.c will take care */
5778                 return true;
5779         }
5780
5781         if (DEBUGLEVEL >= 10) {
5782                 NDR_PRINT_OUT_DEBUG(lsa_CREDRRENAME, r);
5783         }
5784
5785         push = ndr_push_init_ctx(r);
5786         if (push == NULL) {
5787                 talloc_free(r);
5788                 return false;
5789         }
5790
5791         ndr_err = call->ndr_push(push, NDR_OUT, r);
5792         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5793                 talloc_free(r);
5794                 return false;
5795         }
5796
5797         blob = ndr_push_blob(push);
5798         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5799                 talloc_free(r);
5800                 return false;
5801         }
5802
5803         talloc_free(r);
5804
5805         return true;
5806 }
5807
5808 static bool api_lsa_LookupSids3(pipes_struct *p)
5809 {
5810         const struct ndr_interface_call *call;
5811         struct ndr_pull *pull;
5812         struct ndr_push *push;
5813         enum ndr_err_code ndr_err;
5814         DATA_BLOB blob;
5815         struct lsa_LookupSids3 *r;
5816
5817         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPSIDS3];
5818
5819         r = talloc(NULL, struct lsa_LookupSids3);
5820         if (r == NULL) {
5821                 return false;
5822         }
5823
5824         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5825                 talloc_free(r);
5826                 return false;
5827         }
5828
5829         pull = ndr_pull_init_blob(&blob, r);
5830         if (pull == NULL) {
5831                 talloc_free(r);
5832                 return false;
5833         }
5834
5835         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5836         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5837         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5838                 talloc_free(r);
5839                 return false;
5840         }
5841
5842         if (DEBUGLEVEL >= 10) {
5843                 NDR_PRINT_IN_DEBUG(lsa_LookupSids3, r);
5844         }
5845
5846         ZERO_STRUCT(r->out);
5847         r->out.domains = talloc_zero(r, struct lsa_RefDomainList);
5848         if (r->out.domains == NULL) {
5849                 talloc_free(r);
5850                 return false;
5851         }
5852
5853         r->out.names = r->in.names;
5854         r->out.count = r->in.count;
5855         r->out.result = _lsa_LookupSids3(p, r);
5856
5857         if (p->rng_fault_state) {
5858                 talloc_free(r);
5859                 /* Return true here, srv_pipe_hnd.c will take care */
5860                 return true;
5861         }
5862
5863         if (DEBUGLEVEL >= 10) {
5864                 NDR_PRINT_OUT_DEBUG(lsa_LookupSids3, r);
5865         }
5866
5867         push = ndr_push_init_ctx(r);
5868         if (push == NULL) {
5869                 talloc_free(r);
5870                 return false;
5871         }
5872
5873         ndr_err = call->ndr_push(push, NDR_OUT, r);
5874         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5875                 talloc_free(r);
5876                 return false;
5877         }
5878
5879         blob = ndr_push_blob(push);
5880         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5881                 talloc_free(r);
5882                 return false;
5883         }
5884
5885         talloc_free(r);
5886
5887         return true;
5888 }
5889
5890 static bool api_lsa_LookupNames4(pipes_struct *p)
5891 {
5892         const struct ndr_interface_call *call;
5893         struct ndr_pull *pull;
5894         struct ndr_push *push;
5895         enum ndr_err_code ndr_err;
5896         DATA_BLOB blob;
5897         struct lsa_LookupNames4 *r;
5898
5899         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPNAMES4];
5900
5901         r = talloc(NULL, struct lsa_LookupNames4);
5902         if (r == NULL) {
5903                 return false;
5904         }
5905
5906         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5907                 talloc_free(r);
5908                 return false;
5909         }
5910
5911         pull = ndr_pull_init_blob(&blob, r);
5912         if (pull == NULL) {
5913                 talloc_free(r);
5914                 return false;
5915         }
5916
5917         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5918         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5919         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5920                 talloc_free(r);
5921                 return false;
5922         }
5923
5924         if (DEBUGLEVEL >= 10) {
5925                 NDR_PRINT_IN_DEBUG(lsa_LookupNames4, r);
5926         }
5927
5928         ZERO_STRUCT(r->out);
5929         r->out.domains = talloc_zero(r, struct lsa_RefDomainList);
5930         if (r->out.domains == NULL) {
5931                 talloc_free(r);
5932                 return false;
5933         }
5934
5935         r->out.sids = r->in.sids;
5936         r->out.count = r->in.count;
5937         r->out.result = _lsa_LookupNames4(p, r);
5938
5939         if (p->rng_fault_state) {
5940                 talloc_free(r);
5941                 /* Return true here, srv_pipe_hnd.c will take care */
5942                 return true;
5943         }
5944
5945         if (DEBUGLEVEL >= 10) {
5946                 NDR_PRINT_OUT_DEBUG(lsa_LookupNames4, r);
5947         }
5948
5949         push = ndr_push_init_ctx(r);
5950         if (push == NULL) {
5951                 talloc_free(r);
5952                 return false;
5953         }
5954
5955         ndr_err = call->ndr_push(push, NDR_OUT, r);
5956         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5957                 talloc_free(r);
5958                 return false;
5959         }
5960
5961         blob = ndr_push_blob(push);
5962         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5963                 talloc_free(r);
5964                 return false;
5965         }
5966
5967         talloc_free(r);
5968
5969         return true;
5970 }
5971
5972 static bool api_lsa_LSAROPENPOLICYSCE(pipes_struct *p)
5973 {
5974         const struct ndr_interface_call *call;
5975         struct ndr_pull *pull;
5976         struct ndr_push *push;
5977         enum ndr_err_code ndr_err;
5978         DATA_BLOB blob;
5979         struct lsa_LSAROPENPOLICYSCE *r;
5980
5981         call = &ndr_table_lsarpc.calls[NDR_LSA_LSAROPENPOLICYSCE];
5982
5983         r = talloc(NULL, struct lsa_LSAROPENPOLICYSCE);
5984         if (r == NULL) {
5985                 return false;
5986         }
5987
5988         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5989                 talloc_free(r);
5990                 return false;
5991         }
5992
5993         pull = ndr_pull_init_blob(&blob, r);
5994         if (pull == NULL) {
5995                 talloc_free(r);
5996                 return false;
5997         }
5998
5999         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6000         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6001         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6002                 talloc_free(r);
6003                 return false;
6004         }
6005
6006         if (DEBUGLEVEL >= 10) {
6007                 NDR_PRINT_IN_DEBUG(lsa_LSAROPENPOLICYSCE, r);
6008         }
6009
6010         r->out.result = _lsa_LSAROPENPOLICYSCE(p, r);
6011
6012         if (p->rng_fault_state) {
6013                 talloc_free(r);
6014                 /* Return true here, srv_pipe_hnd.c will take care */
6015                 return true;
6016         }
6017
6018         if (DEBUGLEVEL >= 10) {
6019                 NDR_PRINT_OUT_DEBUG(lsa_LSAROPENPOLICYSCE, r);
6020         }
6021
6022         push = ndr_push_init_ctx(r);
6023         if (push == NULL) {
6024                 talloc_free(r);
6025                 return false;
6026         }
6027
6028         ndr_err = call->ndr_push(push, NDR_OUT, r);
6029         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6030                 talloc_free(r);
6031                 return false;
6032         }
6033
6034         blob = ndr_push_blob(push);
6035         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6036                 talloc_free(r);
6037                 return false;
6038         }
6039
6040         talloc_free(r);
6041
6042         return true;
6043 }
6044
6045 static bool api_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(pipes_struct *p)
6046 {
6047         const struct ndr_interface_call *call;
6048         struct ndr_pull *pull;
6049         struct ndr_push *push;
6050         enum ndr_err_code ndr_err;
6051         DATA_BLOB blob;
6052         struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r;
6053
6054         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE];
6055
6056         r = talloc(NULL, struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE);
6057         if (r == NULL) {
6058                 return false;
6059         }
6060
6061         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6062                 talloc_free(r);
6063                 return false;
6064         }
6065
6066         pull = ndr_pull_init_blob(&blob, r);
6067         if (pull == NULL) {
6068                 talloc_free(r);
6069                 return false;
6070         }
6071
6072         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6073         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6074         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6075                 talloc_free(r);
6076                 return false;
6077         }
6078
6079         if (DEBUGLEVEL >= 10) {
6080                 NDR_PRINT_IN_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, r);
6081         }
6082
6083         r->out.result = _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(p, r);
6084
6085         if (p->rng_fault_state) {
6086                 talloc_free(r);
6087                 /* Return true here, srv_pipe_hnd.c will take care */
6088                 return true;
6089         }
6090
6091         if (DEBUGLEVEL >= 10) {
6092                 NDR_PRINT_OUT_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, r);
6093         }
6094
6095         push = ndr_push_init_ctx(r);
6096         if (push == NULL) {
6097                 talloc_free(r);
6098                 return false;
6099         }
6100
6101         ndr_err = call->ndr_push(push, NDR_OUT, r);
6102         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6103                 talloc_free(r);
6104                 return false;
6105         }
6106
6107         blob = ndr_push_blob(push);
6108         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6109                 talloc_free(r);
6110                 return false;
6111         }
6112
6113         talloc_free(r);
6114
6115         return true;
6116 }
6117
6118 static bool api_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(pipes_struct *p)
6119 {
6120         const struct ndr_interface_call *call;
6121         struct ndr_pull *pull;
6122         struct ndr_push *push;
6123         enum ndr_err_code ndr_err;
6124         DATA_BLOB blob;
6125         struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r;
6126
6127         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE];
6128
6129         r = talloc(NULL, struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE);
6130         if (r == NULL) {
6131                 return false;
6132         }
6133
6134         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6135                 talloc_free(r);
6136                 return false;
6137         }
6138
6139         pull = ndr_pull_init_blob(&blob, r);
6140         if (pull == NULL) {
6141                 talloc_free(r);
6142                 return false;
6143         }
6144
6145         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6146         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6147         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6148                 talloc_free(r);
6149                 return false;
6150         }
6151
6152         if (DEBUGLEVEL >= 10) {
6153                 NDR_PRINT_IN_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, r);
6154         }
6155
6156         r->out.result = _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(p, r);
6157
6158         if (p->rng_fault_state) {
6159                 talloc_free(r);
6160                 /* Return true here, srv_pipe_hnd.c will take care */
6161                 return true;
6162         }
6163
6164         if (DEBUGLEVEL >= 10) {
6165                 NDR_PRINT_OUT_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, r);
6166         }
6167
6168         push = ndr_push_init_ctx(r);
6169         if (push == NULL) {
6170                 talloc_free(r);
6171                 return false;
6172         }
6173
6174         ndr_err = call->ndr_push(push, NDR_OUT, r);
6175         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6176                 talloc_free(r);
6177                 return false;
6178         }
6179
6180         blob = ndr_push_blob(push);
6181         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6182                 talloc_free(r);
6183                 return false;
6184         }
6185
6186         talloc_free(r);
6187
6188         return true;
6189 }
6190
6191 static bool api_lsa_LSARADTREPORTSECURITYEVENT(pipes_struct *p)
6192 {
6193         const struct ndr_interface_call *call;
6194         struct ndr_pull *pull;
6195         struct ndr_push *push;
6196         enum ndr_err_code ndr_err;
6197         DATA_BLOB blob;
6198         struct lsa_LSARADTREPORTSECURITYEVENT *r;
6199
6200         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARADTREPORTSECURITYEVENT];
6201
6202         r = talloc(NULL, struct lsa_LSARADTREPORTSECURITYEVENT);
6203         if (r == NULL) {
6204                 return false;
6205         }
6206
6207         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6208                 talloc_free(r);
6209                 return false;
6210         }
6211
6212         pull = ndr_pull_init_blob(&blob, r);
6213         if (pull == NULL) {
6214                 talloc_free(r);
6215                 return false;
6216         }
6217
6218         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6219         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6220         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6221                 talloc_free(r);
6222                 return false;
6223         }
6224
6225         if (DEBUGLEVEL >= 10) {
6226                 NDR_PRINT_IN_DEBUG(lsa_LSARADTREPORTSECURITYEVENT, r);
6227         }
6228
6229         r->out.result = _lsa_LSARADTREPORTSECURITYEVENT(p, r);
6230
6231         if (p->rng_fault_state) {
6232                 talloc_free(r);
6233                 /* Return true here, srv_pipe_hnd.c will take care */
6234                 return true;
6235         }
6236
6237         if (DEBUGLEVEL >= 10) {
6238                 NDR_PRINT_OUT_DEBUG(lsa_LSARADTREPORTSECURITYEVENT, r);
6239         }
6240
6241         push = ndr_push_init_ctx(r);
6242         if (push == NULL) {
6243                 talloc_free(r);
6244                 return false;
6245         }
6246
6247         ndr_err = call->ndr_push(push, NDR_OUT, r);
6248         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6249                 talloc_free(r);
6250                 return false;
6251         }
6252
6253         blob = ndr_push_blob(push);
6254         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6255                 talloc_free(r);
6256                 return false;
6257         }
6258
6259         talloc_free(r);
6260
6261         return true;
6262 }
6263
6264
6265 /* Tables */
6266 static struct api_struct api_lsarpc_cmds[] =
6267 {
6268         {"LSA_CLOSE", NDR_LSA_CLOSE, api_lsa_Close},
6269         {"LSA_DELETE", NDR_LSA_DELETE, api_lsa_Delete},
6270         {"LSA_ENUMPRIVS", NDR_LSA_ENUMPRIVS, api_lsa_EnumPrivs},
6271         {"LSA_QUERYSECURITY", NDR_LSA_QUERYSECURITY, api_lsa_QuerySecurity},
6272         {"LSA_SETSECOBJ", NDR_LSA_SETSECOBJ, api_lsa_SetSecObj},
6273         {"LSA_CHANGEPASSWORD", NDR_LSA_CHANGEPASSWORD, api_lsa_ChangePassword},
6274         {"LSA_OPENPOLICY", NDR_LSA_OPENPOLICY, api_lsa_OpenPolicy},
6275         {"LSA_QUERYINFOPOLICY", NDR_LSA_QUERYINFOPOLICY, api_lsa_QueryInfoPolicy},
6276         {"LSA_SETINFOPOLICY", NDR_LSA_SETINFOPOLICY, api_lsa_SetInfoPolicy},
6277         {"LSA_CLEARAUDITLOG", NDR_LSA_CLEARAUDITLOG, api_lsa_ClearAuditLog},
6278         {"LSA_CREATEACCOUNT", NDR_LSA_CREATEACCOUNT, api_lsa_CreateAccount},
6279         {"LSA_ENUMACCOUNTS", NDR_LSA_ENUMACCOUNTS, api_lsa_EnumAccounts},
6280         {"LSA_CREATETRUSTEDDOMAIN", NDR_LSA_CREATETRUSTEDDOMAIN, api_lsa_CreateTrustedDomain},
6281         {"LSA_ENUMTRUSTDOM", NDR_LSA_ENUMTRUSTDOM, api_lsa_EnumTrustDom},
6282         {"LSA_LOOKUPNAMES", NDR_LSA_LOOKUPNAMES, api_lsa_LookupNames},
6283         {"LSA_LOOKUPSIDS", NDR_LSA_LOOKUPSIDS, api_lsa_LookupSids},
6284         {"LSA_CREATESECRET", NDR_LSA_CREATESECRET, api_lsa_CreateSecret},
6285         {"LSA_OPENACCOUNT", NDR_LSA_OPENACCOUNT, api_lsa_OpenAccount},
6286         {"LSA_ENUMPRIVSACCOUNT", NDR_LSA_ENUMPRIVSACCOUNT, api_lsa_EnumPrivsAccount},
6287         {"LSA_ADDPRIVILEGESTOACCOUNT", NDR_LSA_ADDPRIVILEGESTOACCOUNT, api_lsa_AddPrivilegesToAccount},
6288         {"LSA_REMOVEPRIVILEGESFROMACCOUNT", NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT, api_lsa_RemovePrivilegesFromAccount},
6289         {"LSA_GETQUOTASFORACCOUNT", NDR_LSA_GETQUOTASFORACCOUNT, api_lsa_GetQuotasForAccount},
6290         {"LSA_SETQUOTASFORACCOUNT", NDR_LSA_SETQUOTASFORACCOUNT, api_lsa_SetQuotasForAccount},
6291         {"LSA_GETSYSTEMACCESSACCOUNT", NDR_LSA_GETSYSTEMACCESSACCOUNT, api_lsa_GetSystemAccessAccount},
6292         {"LSA_SETSYSTEMACCESSACCOUNT", NDR_LSA_SETSYSTEMACCESSACCOUNT, api_lsa_SetSystemAccessAccount},
6293         {"LSA_OPENTRUSTEDDOMAIN", NDR_LSA_OPENTRUSTEDDOMAIN, api_lsa_OpenTrustedDomain},
6294         {"LSA_QUERYTRUSTEDDOMAININFO", NDR_LSA_QUERYTRUSTEDDOMAININFO, api_lsa_QueryTrustedDomainInfo},
6295         {"LSA_SETINFORMATIONTRUSTEDDOMAIN", NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN, api_lsa_SetInformationTrustedDomain},
6296         {"LSA_OPENSECRET", NDR_LSA_OPENSECRET, api_lsa_OpenSecret},
6297         {"LSA_SETSECRET", NDR_LSA_SETSECRET, api_lsa_SetSecret},
6298         {"LSA_QUERYSECRET", NDR_LSA_QUERYSECRET, api_lsa_QuerySecret},
6299         {"LSA_LOOKUPPRIVVALUE", NDR_LSA_LOOKUPPRIVVALUE, api_lsa_LookupPrivValue},
6300         {"LSA_LOOKUPPRIVNAME", NDR_LSA_LOOKUPPRIVNAME, api_lsa_LookupPrivName},
6301         {"LSA_LOOKUPPRIVDISPLAYNAME", NDR_LSA_LOOKUPPRIVDISPLAYNAME, api_lsa_LookupPrivDisplayName},
6302         {"LSA_DELETEOBJECT", NDR_LSA_DELETEOBJECT, api_lsa_DeleteObject},
6303         {"LSA_ENUMACCOUNTSWITHUSERRIGHT", NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT, api_lsa_EnumAccountsWithUserRight},
6304         {"LSA_ENUMACCOUNTRIGHTS", NDR_LSA_ENUMACCOUNTRIGHTS, api_lsa_EnumAccountRights},
6305         {"LSA_ADDACCOUNTRIGHTS", NDR_LSA_ADDACCOUNTRIGHTS, api_lsa_AddAccountRights},
6306         {"LSA_REMOVEACCOUNTRIGHTS", NDR_LSA_REMOVEACCOUNTRIGHTS, api_lsa_RemoveAccountRights},
6307         {"LSA_QUERYTRUSTEDDOMAININFOBYSID", NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID, api_lsa_QueryTrustedDomainInfoBySid},
6308         {"LSA_SETTRUSTEDDOMAININFO", NDR_LSA_SETTRUSTEDDOMAININFO, api_lsa_SetTrustedDomainInfo},
6309         {"LSA_DELETETRUSTEDDOMAIN", NDR_LSA_DELETETRUSTEDDOMAIN, api_lsa_DeleteTrustedDomain},
6310         {"LSA_STOREPRIVATEDATA", NDR_LSA_STOREPRIVATEDATA, api_lsa_StorePrivateData},
6311         {"LSA_RETRIEVEPRIVATEDATA", NDR_LSA_RETRIEVEPRIVATEDATA, api_lsa_RetrievePrivateData},
6312         {"LSA_OPENPOLICY2", NDR_LSA_OPENPOLICY2, api_lsa_OpenPolicy2},
6313         {"LSA_GETUSERNAME", NDR_LSA_GETUSERNAME, api_lsa_GetUserName},
6314         {"LSA_QUERYINFOPOLICY2", NDR_LSA_QUERYINFOPOLICY2, api_lsa_QueryInfoPolicy2},
6315         {"LSA_SETINFOPOLICY2", NDR_LSA_SETINFOPOLICY2, api_lsa_SetInfoPolicy2},
6316         {"LSA_QUERYTRUSTEDDOMAININFOBYNAME", NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME, api_lsa_QueryTrustedDomainInfoByName},
6317         {"LSA_SETTRUSTEDDOMAININFOBYNAME", NDR_LSA_SETTRUSTEDDOMAININFOBYNAME, api_lsa_SetTrustedDomainInfoByName},
6318         {"LSA_ENUMTRUSTEDDOMAINSEX", NDR_LSA_ENUMTRUSTEDDOMAINSEX, api_lsa_EnumTrustedDomainsEx},
6319         {"LSA_CREATETRUSTEDDOMAINEX", NDR_LSA_CREATETRUSTEDDOMAINEX, api_lsa_CreateTrustedDomainEx},
6320         {"LSA_CLOSETRUSTEDDOMAINEX", NDR_LSA_CLOSETRUSTEDDOMAINEX, api_lsa_CloseTrustedDomainEx},
6321         {"LSA_QUERYDOMAININFORMATIONPOLICY", NDR_LSA_QUERYDOMAININFORMATIONPOLICY, api_lsa_QueryDomainInformationPolicy},
6322         {"LSA_SETDOMAININFORMATIONPOLICY", NDR_LSA_SETDOMAININFORMATIONPOLICY, api_lsa_SetDomainInformationPolicy},
6323         {"LSA_OPENTRUSTEDDOMAINBYNAME", NDR_LSA_OPENTRUSTEDDOMAINBYNAME, api_lsa_OpenTrustedDomainByName},
6324         {"LSA_TESTCALL", NDR_LSA_TESTCALL, api_lsa_TestCall},
6325         {"LSA_LOOKUPSIDS2", NDR_LSA_LOOKUPSIDS2, api_lsa_LookupSids2},
6326         {"LSA_LOOKUPNAMES2", NDR_LSA_LOOKUPNAMES2, api_lsa_LookupNames2},
6327         {"LSA_CREATETRUSTEDDOMAINEX2", NDR_LSA_CREATETRUSTEDDOMAINEX2, api_lsa_CreateTrustedDomainEx2},
6328         {"LSA_CREDRWRITE", NDR_LSA_CREDRWRITE, api_lsa_CREDRWRITE},
6329         {"LSA_CREDRREAD", NDR_LSA_CREDRREAD, api_lsa_CREDRREAD},
6330         {"LSA_CREDRENUMERATE", NDR_LSA_CREDRENUMERATE, api_lsa_CREDRENUMERATE},
6331         {"LSA_CREDRWRITEDOMAINCREDENTIALS", NDR_LSA_CREDRWRITEDOMAINCREDENTIALS, api_lsa_CREDRWRITEDOMAINCREDENTIALS},
6332         {"LSA_CREDRREADDOMAINCREDENTIALS", NDR_LSA_CREDRREADDOMAINCREDENTIALS, api_lsa_CREDRREADDOMAINCREDENTIALS},
6333         {"LSA_CREDRDELETE", NDR_LSA_CREDRDELETE, api_lsa_CREDRDELETE},
6334         {"LSA_CREDRGETTARGETINFO", NDR_LSA_CREDRGETTARGETINFO, api_lsa_CREDRGETTARGETINFO},
6335         {"LSA_CREDRPROFILELOADED", NDR_LSA_CREDRPROFILELOADED, api_lsa_CREDRPROFILELOADED},
6336         {"LSA_LOOKUPNAMES3", NDR_LSA_LOOKUPNAMES3, api_lsa_LookupNames3},
6337         {"LSA_CREDRGETSESSIONTYPES", NDR_LSA_CREDRGETSESSIONTYPES, api_lsa_CREDRGETSESSIONTYPES},
6338         {"LSA_LSARREGISTERAUDITEVENT", NDR_LSA_LSARREGISTERAUDITEVENT, api_lsa_LSARREGISTERAUDITEVENT},
6339         {"LSA_LSARGENAUDITEVENT", NDR_LSA_LSARGENAUDITEVENT, api_lsa_LSARGENAUDITEVENT},
6340         {"LSA_LSARUNREGISTERAUDITEVENT", NDR_LSA_LSARUNREGISTERAUDITEVENT, api_lsa_LSARUNREGISTERAUDITEVENT},
6341         {"LSA_LSARQUERYFORESTTRUSTINFORMATION", NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION, api_lsa_lsaRQueryForestTrustInformation},
6342         {"LSA_LSARSETFORESTTRUSTINFORMATION", NDR_LSA_LSARSETFORESTTRUSTINFORMATION, api_lsa_LSARSETFORESTTRUSTINFORMATION},
6343         {"LSA_CREDRRENAME", NDR_LSA_CREDRRENAME, api_lsa_CREDRRENAME},
6344         {"LSA_LOOKUPSIDS3", NDR_LSA_LOOKUPSIDS3, api_lsa_LookupSids3},
6345         {"LSA_LOOKUPNAMES4", NDR_LSA_LOOKUPNAMES4, api_lsa_LookupNames4},
6346         {"LSA_LSAROPENPOLICYSCE", NDR_LSA_LSAROPENPOLICYSCE, api_lsa_LSAROPENPOLICYSCE},
6347         {"LSA_LSARADTREGISTERSECURITYEVENTSOURCE", NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE, api_lsa_LSARADTREGISTERSECURITYEVENTSOURCE},
6348         {"LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE", NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE, api_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE},
6349         {"LSA_LSARADTREPORTSECURITYEVENT", NDR_LSA_LSARADTREPORTSECURITYEVENT, api_lsa_LSARADTREPORTSECURITYEVENT},
6350 };
6351
6352 void lsarpc_get_pipe_fns(struct api_struct **fns, int *n_fns)
6353 {
6354         *fns = api_lsarpc_cmds;
6355         *n_fns = sizeof(api_lsarpc_cmds) / sizeof(struct api_struct);
6356 }
6357
6358 NTSTATUS rpc_lsarpc_init(void)
6359 {
6360         return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "lsarpc", "lsarpc", api_lsarpc_cmds, sizeof(api_lsarpc_cmds) / sizeof(struct api_struct));
6361 }