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