source/librpc/gen_ndr/srv_lsa.c

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