librpc/gen_ndr/cli_lsa.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * client auto-generated by pidl. DO NOT MODIFY!
   4  */
   5
   6 #include "includes.h"
   7 #include "../librpc/gen_ndr/cli_lsa.h"
   8
   9 struct rpccli_lsa_Close_state {
  10         struct lsa_Close orig;
  11         struct lsa_Close tmp;
  12         TALLOC_CTX *out_mem_ctx;
  13         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
  14 };
  15
  16 static void rpccli_lsa_Close_done(struct tevent_req *subreq);
  17
  18 struct tevent_req *rpccli_lsa_Close_send(TALLOC_CTX *mem_ctx,
  19                                          struct tevent_context *ev,
  20                                          struct rpc_pipe_client *cli,
  21                                          struct policy_handle *_handle /* [in,out] [ref] */)
  22 {
  23         struct tevent_req *req;
  24         struct rpccli_lsa_Close_state *state;
  25         struct tevent_req *subreq;
  26
  27         req = tevent_req_create(mem_ctx, &state,
  28                                 struct rpccli_lsa_Close_state);
  29         if (req == NULL) {
  30                 return NULL;
  31         }
  32         state->out_mem_ctx = NULL;
  33         state->dispatch_recv = cli->dispatch_recv;
  34
  35         /* In parameters */
  36         state->orig.in.handle = _handle;
  37
  38         /* Out parameters */
  39         state->orig.out.handle = _handle;
  40
  41         /* Result */
  42         ZERO_STRUCT(state->orig.out.result);
  43
  44         state->out_mem_ctx = talloc_named_const(state, 0,
  45                              "rpccli_lsa_Close_out_memory");
  46         if (tevent_req_nomem(state->out_mem_ctx, req)) {
  47                 return tevent_req_post(req, ev);
  48         }
  49
  50         /* make a temporary copy, that we pass to the dispatch function */
  51         state->tmp = state->orig;
  52
  53         subreq = cli->dispatch_send(state, ev, cli,
  54                                     &ndr_table_lsarpc,
  55                                     NDR_LSA_CLOSE,
  56                                     &state->tmp);
  57         if (tevent_req_nomem(subreq, req)) {
  58                 return tevent_req_post(req, ev);
  59         }
  60         tevent_req_set_callback(subreq, rpccli_lsa_Close_done, req);
  61         return req;
  62 }
  63
  64 static void rpccli_lsa_Close_done(struct tevent_req *subreq)
  65 {
  66         struct tevent_req *req = tevent_req_callback_data(
  67                 subreq, struct tevent_req);
  68         struct rpccli_lsa_Close_state *state = tevent_req_data(
  69                 req, struct rpccli_lsa_Close_state);
  70         NTSTATUS status;
  71         TALLOC_CTX *mem_ctx;
  72
  73         if (state->out_mem_ctx) {
  74                 mem_ctx = state->out_mem_ctx;
  75         } else {
  76                 mem_ctx = state;
  77         }
  78
  79         status = state->dispatch_recv(subreq, mem_ctx);
  80         TALLOC_FREE(subreq);
  81         if (!NT_STATUS_IS_OK(status)) {
  82                 tevent_req_nterror(req, status);
  83                 return;
  84         }
  85
  86         /* Copy out parameters */
  87         *state->orig.out.handle = *state->tmp.out.handle;
  88
  89         /* Copy result */
  90         state->orig.out.result = state->tmp.out.result;
  91
  92         /* Reset temporary structure */
  93         ZERO_STRUCT(state->tmp);
  94
  95         tevent_req_done(req);
  96 }
  97
  98 NTSTATUS rpccli_lsa_Close_recv(struct tevent_req *req,
  99                                TALLOC_CTX *mem_ctx,
 100                                NTSTATUS *result)
 101 {
 102         struct rpccli_lsa_Close_state *state = tevent_req_data(
 103                 req, struct rpccli_lsa_Close_state);
 104         NTSTATUS status;
 105
 106         if (tevent_req_is_nterror(req, &status)) {
 107                 tevent_req_received(req);
 108                 return status;
 109         }
 110
 111         /* Steal possbile out parameters to the callers context */
 112         talloc_steal(mem_ctx, state->out_mem_ctx);
 113
 114         /* Return result */
 115         *result = state->orig.out.result;
 116
 117         tevent_req_received(req);
 118         return NT_STATUS_OK;
 119 }
 120
 121 NTSTATUS rpccli_lsa_Close(struct rpc_pipe_client *cli,
 122                           TALLOC_CTX *mem_ctx,
 123                           struct policy_handle *handle /* [in,out] [ref] */)
 124 {
 125         struct lsa_Close r;
 126         NTSTATUS status;
 127
 128         /* In parameters */
 129         r.in.handle = handle;
 130
 131         status = cli->dispatch(cli,
 132                                 mem_ctx,
 133                                 &ndr_table_lsarpc,
 134                                 NDR_LSA_CLOSE,
 135                                 &r);
 136
 137         if (!NT_STATUS_IS_OK(status)) {
 138                 return status;
 139         }
 140
 141         if (NT_STATUS_IS_ERR(status)) {
 142                 return status;
 143         }
 144
 145         /* Return variables */
 146         *handle = *r.out.handle;
 147
 148         /* Return result */
 149         return r.out.result;
 150 }
 151
 152 struct rpccli_lsa_Delete_state {
 153         struct lsa_Delete orig;
 154         struct lsa_Delete tmp;
 155         TALLOC_CTX *out_mem_ctx;
 156         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 157 };
 158
 159 static void rpccli_lsa_Delete_done(struct tevent_req *subreq);
 160
 161 struct tevent_req *rpccli_lsa_Delete_send(TALLOC_CTX *mem_ctx,
 162                                           struct tevent_context *ev,
 163                                           struct rpc_pipe_client *cli,
 164                                           struct policy_handle *_handle /* [in] [ref] */)
 165 {
 166         struct tevent_req *req;
 167         struct rpccli_lsa_Delete_state *state;
 168         struct tevent_req *subreq;
 169
 170         req = tevent_req_create(mem_ctx, &state,
 171                                 struct rpccli_lsa_Delete_state);
 172         if (req == NULL) {
 173                 return NULL;
 174         }
 175         state->out_mem_ctx = NULL;
 176         state->dispatch_recv = cli->dispatch_recv;
 177
 178         /* In parameters */
 179         state->orig.in.handle = _handle;
 180
 181         /* Out parameters */
 182
 183         /* Result */
 184         ZERO_STRUCT(state->orig.out.result);
 185
 186         /* make a temporary copy, that we pass to the dispatch function */
 187         state->tmp = state->orig;
 188
 189         subreq = cli->dispatch_send(state, ev, cli,
 190                                     &ndr_table_lsarpc,
 191                                     NDR_LSA_DELETE,
 192                                     &state->tmp);
 193         if (tevent_req_nomem(subreq, req)) {
 194                 return tevent_req_post(req, ev);
 195         }
 196         tevent_req_set_callback(subreq, rpccli_lsa_Delete_done, req);
 197         return req;
 198 }
 199
 200 static void rpccli_lsa_Delete_done(struct tevent_req *subreq)
 201 {
 202         struct tevent_req *req = tevent_req_callback_data(
 203                 subreq, struct tevent_req);
 204         struct rpccli_lsa_Delete_state *state = tevent_req_data(
 205                 req, struct rpccli_lsa_Delete_state);
 206         NTSTATUS status;
 207         TALLOC_CTX *mem_ctx;
 208
 209         if (state->out_mem_ctx) {
 210                 mem_ctx = state->out_mem_ctx;
 211         } else {
 212                 mem_ctx = state;
 213         }
 214
 215         status = state->dispatch_recv(subreq, mem_ctx);
 216         TALLOC_FREE(subreq);
 217         if (!NT_STATUS_IS_OK(status)) {
 218                 tevent_req_nterror(req, status);
 219                 return;
 220         }
 221
 222         /* Copy out parameters */
 223
 224         /* Copy result */
 225         state->orig.out.result = state->tmp.out.result;
 226
 227         /* Reset temporary structure */
 228         ZERO_STRUCT(state->tmp);
 229
 230         tevent_req_done(req);
 231 }
 232
 233 NTSTATUS rpccli_lsa_Delete_recv(struct tevent_req *req,
 234                                 TALLOC_CTX *mem_ctx,
 235                                 NTSTATUS *result)
 236 {
 237         struct rpccli_lsa_Delete_state *state = tevent_req_data(
 238                 req, struct rpccli_lsa_Delete_state);
 239         NTSTATUS status;
 240
 241         if (tevent_req_is_nterror(req, &status)) {
 242                 tevent_req_received(req);
 243                 return status;
 244         }
 245
 246         /* Steal possbile out parameters to the callers context */
 247         talloc_steal(mem_ctx, state->out_mem_ctx);
 248
 249         /* Return result */
 250         *result = state->orig.out.result;
 251
 252         tevent_req_received(req);
 253         return NT_STATUS_OK;
 254 }
 255
 256 NTSTATUS rpccli_lsa_Delete(struct rpc_pipe_client *cli,
 257                            TALLOC_CTX *mem_ctx,
 258                            struct policy_handle *handle /* [in] [ref] */)
 259 {
 260         struct lsa_Delete r;
 261         NTSTATUS status;
 262
 263         /* In parameters */
 264         r.in.handle = handle;
 265
 266         status = cli->dispatch(cli,
 267                                 mem_ctx,
 268                                 &ndr_table_lsarpc,
 269                                 NDR_LSA_DELETE,
 270                                 &r);
 271
 272         if (!NT_STATUS_IS_OK(status)) {
 273                 return status;
 274         }
 275
 276         if (NT_STATUS_IS_ERR(status)) {
 277                 return status;
 278         }
 279
 280         /* Return variables */
 281
 282         /* Return result */
 283         return r.out.result;
 284 }
 285
 286 struct rpccli_lsa_EnumPrivs_state {
 287         struct lsa_EnumPrivs orig;
 288         struct lsa_EnumPrivs tmp;
 289         TALLOC_CTX *out_mem_ctx;
 290         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 291 };
 292
 293 static void rpccli_lsa_EnumPrivs_done(struct tevent_req *subreq);
 294
 295 struct tevent_req *rpccli_lsa_EnumPrivs_send(TALLOC_CTX *mem_ctx,
 296                                              struct tevent_context *ev,
 297                                              struct rpc_pipe_client *cli,
 298                                              struct policy_handle *_handle /* [in] [ref] */,
 299                                              uint32_t *_resume_handle /* [in,out] [ref] */,
 300                                              struct lsa_PrivArray *_privs /* [out] [ref] */,
 301                                              uint32_t _max_count /* [in]  */)
 302 {
 303         struct tevent_req *req;
 304         struct rpccli_lsa_EnumPrivs_state *state;
 305         struct tevent_req *subreq;
 306
 307         req = tevent_req_create(mem_ctx, &state,
 308                                 struct rpccli_lsa_EnumPrivs_state);
 309         if (req == NULL) {
 310                 return NULL;
 311         }
 312         state->out_mem_ctx = NULL;
 313         state->dispatch_recv = cli->dispatch_recv;
 314
 315         /* In parameters */
 316         state->orig.in.handle = _handle;
 317         state->orig.in.resume_handle = _resume_handle;
 318         state->orig.in.max_count = _max_count;
 319
 320         /* Out parameters */
 321         state->orig.out.resume_handle = _resume_handle;
 322         state->orig.out.privs = _privs;
 323
 324         /* Result */
 325         ZERO_STRUCT(state->orig.out.result);
 326
 327         state->out_mem_ctx = talloc_named_const(state, 0,
 328                              "rpccli_lsa_EnumPrivs_out_memory");
 329         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 330                 return tevent_req_post(req, ev);
 331         }
 332
 333         /* make a temporary copy, that we pass to the dispatch function */
 334         state->tmp = state->orig;
 335
 336         subreq = cli->dispatch_send(state, ev, cli,
 337                                     &ndr_table_lsarpc,
 338                                     NDR_LSA_ENUMPRIVS,
 339                                     &state->tmp);
 340         if (tevent_req_nomem(subreq, req)) {
 341                 return tevent_req_post(req, ev);
 342         }
 343         tevent_req_set_callback(subreq, rpccli_lsa_EnumPrivs_done, req);
 344         return req;
 345 }
 346
 347 static void rpccli_lsa_EnumPrivs_done(struct tevent_req *subreq)
 348 {
 349         struct tevent_req *req = tevent_req_callback_data(
 350                 subreq, struct tevent_req);
 351         struct rpccli_lsa_EnumPrivs_state *state = tevent_req_data(
 352                 req, struct rpccli_lsa_EnumPrivs_state);
 353         NTSTATUS status;
 354         TALLOC_CTX *mem_ctx;
 355
 356         if (state->out_mem_ctx) {
 357                 mem_ctx = state->out_mem_ctx;
 358         } else {
 359                 mem_ctx = state;
 360         }
 361
 362         status = state->dispatch_recv(subreq, mem_ctx);
 363         TALLOC_FREE(subreq);
 364         if (!NT_STATUS_IS_OK(status)) {
 365                 tevent_req_nterror(req, status);
 366                 return;
 367         }
 368
 369         /* Copy out parameters */
 370         *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
 371         *state->orig.out.privs = *state->tmp.out.privs;
 372
 373         /* Copy result */
 374         state->orig.out.result = state->tmp.out.result;
 375
 376         /* Reset temporary structure */
 377         ZERO_STRUCT(state->tmp);
 378
 379         tevent_req_done(req);
 380 }
 381
 382 NTSTATUS rpccli_lsa_EnumPrivs_recv(struct tevent_req *req,
 383                                    TALLOC_CTX *mem_ctx,
 384                                    NTSTATUS *result)
 385 {
 386         struct rpccli_lsa_EnumPrivs_state *state = tevent_req_data(
 387                 req, struct rpccli_lsa_EnumPrivs_state);
 388         NTSTATUS status;
 389
 390         if (tevent_req_is_nterror(req, &status)) {
 391                 tevent_req_received(req);
 392                 return status;
 393         }
 394
 395         /* Steal possbile out parameters to the callers context */
 396         talloc_steal(mem_ctx, state->out_mem_ctx);
 397
 398         /* Return result */
 399         *result = state->orig.out.result;
 400
 401         tevent_req_received(req);
 402         return NT_STATUS_OK;
 403 }
 404
 405 NTSTATUS rpccli_lsa_EnumPrivs(struct rpc_pipe_client *cli,
 406                               TALLOC_CTX *mem_ctx,
 407                               struct policy_handle *handle /* [in] [ref] */,
 408                               uint32_t *resume_handle /* [in,out] [ref] */,
 409                               struct lsa_PrivArray *privs /* [out] [ref] */,
 410                               uint32_t max_count /* [in]  */)
 411 {
 412         struct lsa_EnumPrivs r;
 413         NTSTATUS status;
 414
 415         /* In parameters */
 416         r.in.handle = handle;
 417         r.in.resume_handle = resume_handle;
 418         r.in.max_count = max_count;
 419
 420         status = cli->dispatch(cli,
 421                                 mem_ctx,
 422                                 &ndr_table_lsarpc,
 423                                 NDR_LSA_ENUMPRIVS,
 424                                 &r);
 425
 426         if (!NT_STATUS_IS_OK(status)) {
 427                 return status;
 428         }
 429
 430         if (NT_STATUS_IS_ERR(status)) {
 431                 return status;
 432         }
 433
 434         /* Return variables */
 435         *resume_handle = *r.out.resume_handle;
 436         *privs = *r.out.privs;
 437
 438         /* Return result */
 439         return r.out.result;
 440 }
 441
 442 struct rpccli_lsa_QuerySecurity_state {
 443         struct lsa_QuerySecurity orig;
 444         struct lsa_QuerySecurity tmp;
 445         TALLOC_CTX *out_mem_ctx;
 446         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 447 };
 448
 449 static void rpccli_lsa_QuerySecurity_done(struct tevent_req *subreq);
 450
 451 struct tevent_req *rpccli_lsa_QuerySecurity_send(TALLOC_CTX *mem_ctx,
 452                                                  struct tevent_context *ev,
 453                                                  struct rpc_pipe_client *cli,
 454                                                  struct policy_handle *_handle /* [in] [ref] */,
 455                                                  uint32_t _sec_info /* [in]  */,
 456                                                  struct sec_desc_buf **_sdbuf /* [out] [ref] */)
 457 {
 458         struct tevent_req *req;
 459         struct rpccli_lsa_QuerySecurity_state *state;
 460         struct tevent_req *subreq;
 461
 462         req = tevent_req_create(mem_ctx, &state,
 463                                 struct rpccli_lsa_QuerySecurity_state);
 464         if (req == NULL) {
 465                 return NULL;
 466         }
 467         state->out_mem_ctx = NULL;
 468         state->dispatch_recv = cli->dispatch_recv;
 469
 470         /* In parameters */
 471         state->orig.in.handle = _handle;
 472         state->orig.in.sec_info = _sec_info;
 473
 474         /* Out parameters */
 475         state->orig.out.sdbuf = _sdbuf;
 476
 477         /* Result */
 478         ZERO_STRUCT(state->orig.out.result);
 479
 480         state->out_mem_ctx = talloc_named_const(state, 0,
 481                              "rpccli_lsa_QuerySecurity_out_memory");
 482         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 483                 return tevent_req_post(req, ev);
 484         }
 485
 486         /* make a temporary copy, that we pass to the dispatch function */
 487         state->tmp = state->orig;
 488
 489         subreq = cli->dispatch_send(state, ev, cli,
 490                                     &ndr_table_lsarpc,
 491                                     NDR_LSA_QUERYSECURITY,
 492                                     &state->tmp);
 493         if (tevent_req_nomem(subreq, req)) {
 494                 return tevent_req_post(req, ev);
 495         }
 496         tevent_req_set_callback(subreq, rpccli_lsa_QuerySecurity_done, req);
 497         return req;
 498 }
 499
 500 static void rpccli_lsa_QuerySecurity_done(struct tevent_req *subreq)
 501 {
 502         struct tevent_req *req = tevent_req_callback_data(
 503                 subreq, struct tevent_req);
 504         struct rpccli_lsa_QuerySecurity_state *state = tevent_req_data(
 505                 req, struct rpccli_lsa_QuerySecurity_state);
 506         NTSTATUS status;
 507         TALLOC_CTX *mem_ctx;
 508
 509         if (state->out_mem_ctx) {
 510                 mem_ctx = state->out_mem_ctx;
 511         } else {
 512                 mem_ctx = state;
 513         }
 514
 515         status = state->dispatch_recv(subreq, mem_ctx);
 516         TALLOC_FREE(subreq);
 517         if (!NT_STATUS_IS_OK(status)) {
 518                 tevent_req_nterror(req, status);
 519                 return;
 520         }
 521
 522         /* Copy out parameters */
 523         *state->orig.out.sdbuf = *state->tmp.out.sdbuf;
 524
 525         /* Copy result */
 526         state->orig.out.result = state->tmp.out.result;
 527
 528         /* Reset temporary structure */
 529         ZERO_STRUCT(state->tmp);
 530
 531         tevent_req_done(req);
 532 }
 533
 534 NTSTATUS rpccli_lsa_QuerySecurity_recv(struct tevent_req *req,
 535                                        TALLOC_CTX *mem_ctx,
 536                                        NTSTATUS *result)
 537 {
 538         struct rpccli_lsa_QuerySecurity_state *state = tevent_req_data(
 539                 req, struct rpccli_lsa_QuerySecurity_state);
 540         NTSTATUS status;
 541
 542         if (tevent_req_is_nterror(req, &status)) {
 543                 tevent_req_received(req);
 544                 return status;
 545         }
 546
 547         /* Steal possbile out parameters to the callers context */
 548         talloc_steal(mem_ctx, state->out_mem_ctx);
 549
 550         /* Return result */
 551         *result = state->orig.out.result;
 552
 553         tevent_req_received(req);
 554         return NT_STATUS_OK;
 555 }
 556
 557 NTSTATUS rpccli_lsa_QuerySecurity(struct rpc_pipe_client *cli,
 558                                   TALLOC_CTX *mem_ctx,
 559                                   struct policy_handle *handle /* [in] [ref] */,
 560                                   uint32_t sec_info /* [in]  */,
 561                                   struct sec_desc_buf **sdbuf /* [out] [ref] */)
 562 {
 563         struct lsa_QuerySecurity r;
 564         NTSTATUS status;
 565
 566         /* In parameters */
 567         r.in.handle = handle;
 568         r.in.sec_info = sec_info;
 569
 570         status = cli->dispatch(cli,
 571                                 mem_ctx,
 572                                 &ndr_table_lsarpc,
 573                                 NDR_LSA_QUERYSECURITY,
 574                                 &r);
 575
 576         if (!NT_STATUS_IS_OK(status)) {
 577                 return status;
 578         }
 579
 580         if (NT_STATUS_IS_ERR(status)) {
 581                 return status;
 582         }
 583
 584         /* Return variables */
 585         *sdbuf = *r.out.sdbuf;
 586
 587         /* Return result */
 588         return r.out.result;
 589 }
 590
 591 struct rpccli_lsa_SetSecObj_state {
 592         struct lsa_SetSecObj orig;
 593         struct lsa_SetSecObj tmp;
 594         TALLOC_CTX *out_mem_ctx;
 595         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 596 };
 597
 598 static void rpccli_lsa_SetSecObj_done(struct tevent_req *subreq);
 599
 600 struct tevent_req *rpccli_lsa_SetSecObj_send(TALLOC_CTX *mem_ctx,
 601                                              struct tevent_context *ev,
 602                                              struct rpc_pipe_client *cli,
 603                                              struct policy_handle *_handle /* [in] [ref] */,
 604                                              uint32_t _sec_info /* [in]  */,
 605                                              struct sec_desc_buf *_sdbuf /* [in] [ref] */)
 606 {
 607         struct tevent_req *req;
 608         struct rpccli_lsa_SetSecObj_state *state;
 609         struct tevent_req *subreq;
 610
 611         req = tevent_req_create(mem_ctx, &state,
 612                                 struct rpccli_lsa_SetSecObj_state);
 613         if (req == NULL) {
 614                 return NULL;
 615         }
 616         state->out_mem_ctx = NULL;
 617         state->dispatch_recv = cli->dispatch_recv;
 618
 619         /* In parameters */
 620         state->orig.in.handle = _handle;
 621         state->orig.in.sec_info = _sec_info;
 622         state->orig.in.sdbuf = _sdbuf;
 623
 624         /* Out parameters */
 625
 626         /* Result */
 627         ZERO_STRUCT(state->orig.out.result);
 628
 629         /* make a temporary copy, that we pass to the dispatch function */
 630         state->tmp = state->orig;
 631
 632         subreq = cli->dispatch_send(state, ev, cli,
 633                                     &ndr_table_lsarpc,
 634                                     NDR_LSA_SETSECOBJ,
 635                                     &state->tmp);
 636         if (tevent_req_nomem(subreq, req)) {
 637                 return tevent_req_post(req, ev);
 638         }
 639         tevent_req_set_callback(subreq, rpccli_lsa_SetSecObj_done, req);
 640         return req;
 641 }
 642
 643 static void rpccli_lsa_SetSecObj_done(struct tevent_req *subreq)
 644 {
 645         struct tevent_req *req = tevent_req_callback_data(
 646                 subreq, struct tevent_req);
 647         struct rpccli_lsa_SetSecObj_state *state = tevent_req_data(
 648                 req, struct rpccli_lsa_SetSecObj_state);
 649         NTSTATUS status;
 650         TALLOC_CTX *mem_ctx;
 651
 652         if (state->out_mem_ctx) {
 653                 mem_ctx = state->out_mem_ctx;
 654         } else {
 655                 mem_ctx = state;
 656         }
 657
 658         status = state->dispatch_recv(subreq, mem_ctx);
 659         TALLOC_FREE(subreq);
 660         if (!NT_STATUS_IS_OK(status)) {
 661                 tevent_req_nterror(req, status);
 662                 return;
 663         }
 664
 665         /* Copy out parameters */
 666
 667         /* Copy result */
 668         state->orig.out.result = state->tmp.out.result;
 669
 670         /* Reset temporary structure */
 671         ZERO_STRUCT(state->tmp);
 672
 673         tevent_req_done(req);
 674 }
 675
 676 NTSTATUS rpccli_lsa_SetSecObj_recv(struct tevent_req *req,
 677                                    TALLOC_CTX *mem_ctx,
 678                                    NTSTATUS *result)
 679 {
 680         struct rpccli_lsa_SetSecObj_state *state = tevent_req_data(
 681                 req, struct rpccli_lsa_SetSecObj_state);
 682         NTSTATUS status;
 683
 684         if (tevent_req_is_nterror(req, &status)) {
 685                 tevent_req_received(req);
 686                 return status;
 687         }
 688
 689         /* Steal possbile out parameters to the callers context */
 690         talloc_steal(mem_ctx, state->out_mem_ctx);
 691
 692         /* Return result */
 693         *result = state->orig.out.result;
 694
 695         tevent_req_received(req);
 696         return NT_STATUS_OK;
 697 }
 698
 699 NTSTATUS rpccli_lsa_SetSecObj(struct rpc_pipe_client *cli,
 700                               TALLOC_CTX *mem_ctx,
 701                               struct policy_handle *handle /* [in] [ref] */,
 702                               uint32_t sec_info /* [in]  */,
 703                               struct sec_desc_buf *sdbuf /* [in] [ref] */)
 704 {
 705         struct lsa_SetSecObj r;
 706         NTSTATUS status;
 707
 708         /* In parameters */
 709         r.in.handle = handle;
 710         r.in.sec_info = sec_info;
 711         r.in.sdbuf = sdbuf;
 712
 713         status = cli->dispatch(cli,
 714                                 mem_ctx,
 715                                 &ndr_table_lsarpc,
 716                                 NDR_LSA_SETSECOBJ,
 717                                 &r);
 718
 719         if (!NT_STATUS_IS_OK(status)) {
 720                 return status;
 721         }
 722
 723         if (NT_STATUS_IS_ERR(status)) {
 724                 return status;
 725         }
 726
 727         /* Return variables */
 728
 729         /* Return result */
 730         return r.out.result;
 731 }
 732
 733 struct rpccli_lsa_ChangePassword_state {
 734         struct lsa_ChangePassword orig;
 735         struct lsa_ChangePassword tmp;
 736         TALLOC_CTX *out_mem_ctx;
 737         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 738 };
 739
 740 static void rpccli_lsa_ChangePassword_done(struct tevent_req *subreq);
 741
 742 struct tevent_req *rpccli_lsa_ChangePassword_send(TALLOC_CTX *mem_ctx,
 743                                                   struct tevent_context *ev,
 744                                                   struct rpc_pipe_client *cli)
 745 {
 746         struct tevent_req *req;
 747         struct rpccli_lsa_ChangePassword_state *state;
 748         struct tevent_req *subreq;
 749
 750         req = tevent_req_create(mem_ctx, &state,
 751                                 struct rpccli_lsa_ChangePassword_state);
 752         if (req == NULL) {
 753                 return NULL;
 754         }
 755         state->out_mem_ctx = NULL;
 756         state->dispatch_recv = cli->dispatch_recv;
 757
 758         /* In parameters */
 759
 760         /* Out parameters */
 761
 762         /* Result */
 763         ZERO_STRUCT(state->orig.out.result);
 764
 765         /* make a temporary copy, that we pass to the dispatch function */
 766         state->tmp = state->orig;
 767
 768         subreq = cli->dispatch_send(state, ev, cli,
 769                                     &ndr_table_lsarpc,
 770                                     NDR_LSA_CHANGEPASSWORD,
 771                                     &state->tmp);
 772         if (tevent_req_nomem(subreq, req)) {
 773                 return tevent_req_post(req, ev);
 774         }
 775         tevent_req_set_callback(subreq, rpccli_lsa_ChangePassword_done, req);
 776         return req;
 777 }
 778
 779 static void rpccli_lsa_ChangePassword_done(struct tevent_req *subreq)
 780 {
 781         struct tevent_req *req = tevent_req_callback_data(
 782                 subreq, struct tevent_req);
 783         struct rpccli_lsa_ChangePassword_state *state = tevent_req_data(
 784                 req, struct rpccli_lsa_ChangePassword_state);
 785         NTSTATUS status;
 786         TALLOC_CTX *mem_ctx;
 787
 788         if (state->out_mem_ctx) {
 789                 mem_ctx = state->out_mem_ctx;
 790         } else {
 791                 mem_ctx = state;
 792         }
 793
 794         status = state->dispatch_recv(subreq, mem_ctx);
 795         TALLOC_FREE(subreq);
 796         if (!NT_STATUS_IS_OK(status)) {
 797                 tevent_req_nterror(req, status);
 798                 return;
 799         }
 800
 801         /* Copy out parameters */
 802
 803         /* Copy result */
 804         state->orig.out.result = state->tmp.out.result;
 805
 806         /* Reset temporary structure */
 807         ZERO_STRUCT(state->tmp);
 808
 809         tevent_req_done(req);
 810 }
 811
 812 NTSTATUS rpccli_lsa_ChangePassword_recv(struct tevent_req *req,
 813                                         TALLOC_CTX *mem_ctx,
 814                                         NTSTATUS *result)
 815 {
 816         struct rpccli_lsa_ChangePassword_state *state = tevent_req_data(
 817                 req, struct rpccli_lsa_ChangePassword_state);
 818         NTSTATUS status;
 819
 820         if (tevent_req_is_nterror(req, &status)) {
 821                 tevent_req_received(req);
 822                 return status;
 823         }
 824
 825         /* Steal possbile out parameters to the callers context */
 826         talloc_steal(mem_ctx, state->out_mem_ctx);
 827
 828         /* Return result */
 829         *result = state->orig.out.result;
 830
 831         tevent_req_received(req);
 832         return NT_STATUS_OK;
 833 }
 834
 835 NTSTATUS rpccli_lsa_ChangePassword(struct rpc_pipe_client *cli,
 836                                    TALLOC_CTX *mem_ctx)
 837 {
 838         struct lsa_ChangePassword r;
 839         NTSTATUS status;
 840
 841         /* In parameters */
 842
 843         status = cli->dispatch(cli,
 844                                 mem_ctx,
 845                                 &ndr_table_lsarpc,
 846                                 NDR_LSA_CHANGEPASSWORD,
 847                                 &r);
 848
 849         if (!NT_STATUS_IS_OK(status)) {
 850                 return status;
 851         }
 852
 853         if (NT_STATUS_IS_ERR(status)) {
 854                 return status;
 855         }
 856
 857         /* Return variables */
 858
 859         /* Return result */
 860         return r.out.result;
 861 }
 862
 863 struct rpccli_lsa_OpenPolicy_state {
 864         struct lsa_OpenPolicy orig;
 865         struct lsa_OpenPolicy tmp;
 866         TALLOC_CTX *out_mem_ctx;
 867         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 868 };
 869
 870 static void rpccli_lsa_OpenPolicy_done(struct tevent_req *subreq);
 871
 872 struct tevent_req *rpccli_lsa_OpenPolicy_send(TALLOC_CTX *mem_ctx,
 873                                               struct tevent_context *ev,
 874                                               struct rpc_pipe_client *cli,
 875                                               uint16_t *_system_name /* [in] [unique] */,
 876                                               struct lsa_ObjectAttribute *_attr /* [in] [ref] */,
 877                                               uint32_t _access_mask /* [in]  */,
 878                                               struct policy_handle *_handle /* [out] [ref] */)
 879 {
 880         struct tevent_req *req;
 881         struct rpccli_lsa_OpenPolicy_state *state;
 882         struct tevent_req *subreq;
 883
 884         req = tevent_req_create(mem_ctx, &state,
 885                                 struct rpccli_lsa_OpenPolicy_state);
 886         if (req == NULL) {
 887                 return NULL;
 888         }
 889         state->out_mem_ctx = NULL;
 890         state->dispatch_recv = cli->dispatch_recv;
 891
 892         /* In parameters */
 893         state->orig.in.system_name = _system_name;
 894         state->orig.in.attr = _attr;
 895         state->orig.in.access_mask = _access_mask;
 896
 897         /* Out parameters */
 898         state->orig.out.handle = _handle;
 899
 900         /* Result */
 901         ZERO_STRUCT(state->orig.out.result);
 902
 903         state->out_mem_ctx = talloc_named_const(state, 0,
 904                              "rpccli_lsa_OpenPolicy_out_memory");
 905         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 906                 return tevent_req_post(req, ev);
 907         }
 908
 909         /* make a temporary copy, that we pass to the dispatch function */
 910         state->tmp = state->orig;
 911
 912         subreq = cli->dispatch_send(state, ev, cli,
 913                                     &ndr_table_lsarpc,
 914                                     NDR_LSA_OPENPOLICY,
 915                                     &state->tmp);
 916         if (tevent_req_nomem(subreq, req)) {
 917                 return tevent_req_post(req, ev);
 918         }
 919         tevent_req_set_callback(subreq, rpccli_lsa_OpenPolicy_done, req);
 920         return req;
 921 }
 922
 923 static void rpccli_lsa_OpenPolicy_done(struct tevent_req *subreq)
 924 {
 925         struct tevent_req *req = tevent_req_callback_data(
 926                 subreq, struct tevent_req);
 927         struct rpccli_lsa_OpenPolicy_state *state = tevent_req_data(
 928                 req, struct rpccli_lsa_OpenPolicy_state);
 929         NTSTATUS status;
 930         TALLOC_CTX *mem_ctx;
 931
 932         if (state->out_mem_ctx) {
 933                 mem_ctx = state->out_mem_ctx;
 934         } else {
 935                 mem_ctx = state;
 936         }
 937
 938         status = state->dispatch_recv(subreq, mem_ctx);
 939         TALLOC_FREE(subreq);
 940         if (!NT_STATUS_IS_OK(status)) {
 941                 tevent_req_nterror(req, status);
 942                 return;
 943         }
 944
 945         /* Copy out parameters */
 946         *state->orig.out.handle = *state->tmp.out.handle;
 947
 948         /* Copy result */
 949         state->orig.out.result = state->tmp.out.result;
 950
 951         /* Reset temporary structure */
 952         ZERO_STRUCT(state->tmp);
 953
 954         tevent_req_done(req);
 955 }
 956
 957 NTSTATUS rpccli_lsa_OpenPolicy_recv(struct tevent_req *req,
 958                                     TALLOC_CTX *mem_ctx,
 959                                     NTSTATUS *result)
 960 {
 961         struct rpccli_lsa_OpenPolicy_state *state = tevent_req_data(
 962                 req, struct rpccli_lsa_OpenPolicy_state);
 963         NTSTATUS status;
 964
 965         if (tevent_req_is_nterror(req, &status)) {
 966                 tevent_req_received(req);
 967                 return status;
 968         }
 969
 970         /* Steal possbile out parameters to the callers context */
 971         talloc_steal(mem_ctx, state->out_mem_ctx);
 972
 973         /* Return result */
 974         *result = state->orig.out.result;
 975
 976         tevent_req_received(req);
 977         return NT_STATUS_OK;
 978 }
 979
 980 NTSTATUS rpccli_lsa_OpenPolicy(struct rpc_pipe_client *cli,
 981                                TALLOC_CTX *mem_ctx,
 982                                uint16_t *system_name /* [in] [unique] */,
 983                                struct lsa_ObjectAttribute *attr /* [in] [ref] */,
 984                                uint32_t access_mask /* [in]  */,
 985                                struct policy_handle *handle /* [out] [ref] */)
 986 {
 987         struct lsa_OpenPolicy r;
 988         NTSTATUS status;
 989
 990         /* In parameters */
 991         r.in.system_name = system_name;
 992         r.in.attr = attr;
 993         r.in.access_mask = access_mask;
 994
 995         status = cli->dispatch(cli,
 996                                 mem_ctx,
 997                                 &ndr_table_lsarpc,
 998                                 NDR_LSA_OPENPOLICY,
 999                                 &r);
1000
1001         if (!NT_STATUS_IS_OK(status)) {
1002                 return status;
1003         }
1004
1005         if (NT_STATUS_IS_ERR(status)) {
1006                 return status;
1007         }
1008
1009         /* Return variables */
1010         *handle = *r.out.handle;
1011
1012         /* Return result */
1013         return r.out.result;
1014 }
1015
1016 struct rpccli_lsa_QueryInfoPolicy_state {
1017         struct lsa_QueryInfoPolicy orig;
1018         struct lsa_QueryInfoPolicy tmp;
1019         TALLOC_CTX *out_mem_ctx;
1020         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1021 };
1022
1023 static void rpccli_lsa_QueryInfoPolicy_done(struct tevent_req *subreq);
1024
1025 struct tevent_req *rpccli_lsa_QueryInfoPolicy_send(TALLOC_CTX *mem_ctx,
1026                                                    struct tevent_context *ev,
1027                                                    struct rpc_pipe_client *cli,
1028                                                    struct policy_handle *_handle /* [in] [ref] */,
1029                                                    enum lsa_PolicyInfo _level /* [in]  */,
1030                                                    union lsa_PolicyInformation **_info /* [out] [ref,switch_is(level)] */)
1031 {
1032         struct tevent_req *req;
1033         struct rpccli_lsa_QueryInfoPolicy_state *state;
1034         struct tevent_req *subreq;
1035
1036         req = tevent_req_create(mem_ctx, &state,
1037                                 struct rpccli_lsa_QueryInfoPolicy_state);
1038         if (req == NULL) {
1039                 return NULL;
1040         }
1041         state->out_mem_ctx = NULL;
1042         state->dispatch_recv = cli->dispatch_recv;
1043
1044         /* In parameters */
1045         state->orig.in.handle = _handle;
1046         state->orig.in.level = _level;
1047
1048         /* Out parameters */
1049         state->orig.out.info = _info;
1050
1051         /* Result */
1052         ZERO_STRUCT(state->orig.out.result);
1053
1054         state->out_mem_ctx = talloc_named_const(state, 0,
1055                              "rpccli_lsa_QueryInfoPolicy_out_memory");
1056         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1057                 return tevent_req_post(req, ev);
1058         }
1059
1060         /* make a temporary copy, that we pass to the dispatch function */
1061         state->tmp = state->orig;
1062
1063         subreq = cli->dispatch_send(state, ev, cli,
1064                                     &ndr_table_lsarpc,
1065                                     NDR_LSA_QUERYINFOPOLICY,
1066                                     &state->tmp);
1067         if (tevent_req_nomem(subreq, req)) {
1068                 return tevent_req_post(req, ev);
1069         }
1070         tevent_req_set_callback(subreq, rpccli_lsa_QueryInfoPolicy_done, req);
1071         return req;
1072 }
1073
1074 static void rpccli_lsa_QueryInfoPolicy_done(struct tevent_req *subreq)
1075 {
1076         struct tevent_req *req = tevent_req_callback_data(
1077                 subreq, struct tevent_req);
1078         struct rpccli_lsa_QueryInfoPolicy_state *state = tevent_req_data(
1079                 req, struct rpccli_lsa_QueryInfoPolicy_state);
1080         NTSTATUS status;
1081         TALLOC_CTX *mem_ctx;
1082
1083         if (state->out_mem_ctx) {
1084                 mem_ctx = state->out_mem_ctx;
1085         } else {
1086                 mem_ctx = state;
1087         }
1088
1089         status = state->dispatch_recv(subreq, mem_ctx);
1090         TALLOC_FREE(subreq);
1091         if (!NT_STATUS_IS_OK(status)) {
1092                 tevent_req_nterror(req, status);
1093                 return;
1094         }
1095
1096         /* Copy out parameters */
1097         *state->orig.out.info = *state->tmp.out.info;
1098
1099         /* Copy result */
1100         state->orig.out.result = state->tmp.out.result;
1101
1102         /* Reset temporary structure */
1103         ZERO_STRUCT(state->tmp);
1104
1105         tevent_req_done(req);
1106 }
1107
1108 NTSTATUS rpccli_lsa_QueryInfoPolicy_recv(struct tevent_req *req,
1109                                          TALLOC_CTX *mem_ctx,
1110                                          NTSTATUS *result)
1111 {
1112         struct rpccli_lsa_QueryInfoPolicy_state *state = tevent_req_data(
1113                 req, struct rpccli_lsa_QueryInfoPolicy_state);
1114         NTSTATUS status;
1115
1116         if (tevent_req_is_nterror(req, &status)) {
1117                 tevent_req_received(req);
1118                 return status;
1119         }
1120
1121         /* Steal possbile out parameters to the callers context */
1122         talloc_steal(mem_ctx, state->out_mem_ctx);
1123
1124         /* Return result */
1125         *result = state->orig.out.result;
1126
1127         tevent_req_received(req);
1128         return NT_STATUS_OK;
1129 }
1130
1131 NTSTATUS rpccli_lsa_QueryInfoPolicy(struct rpc_pipe_client *cli,
1132                                     TALLOC_CTX *mem_ctx,
1133                                     struct policy_handle *handle /* [in] [ref] */,
1134                                     enum lsa_PolicyInfo level /* [in]  */,
1135                                     union lsa_PolicyInformation **info /* [out] [ref,switch_is(level)] */)
1136 {
1137         struct lsa_QueryInfoPolicy r;
1138         NTSTATUS status;
1139
1140         /* In parameters */
1141         r.in.handle = handle;
1142         r.in.level = level;
1143
1144         status = cli->dispatch(cli,
1145                                 mem_ctx,
1146                                 &ndr_table_lsarpc,
1147                                 NDR_LSA_QUERYINFOPOLICY,
1148                                 &r);
1149
1150         if (!NT_STATUS_IS_OK(status)) {
1151                 return status;
1152         }
1153
1154         if (NT_STATUS_IS_ERR(status)) {
1155                 return status;
1156         }
1157
1158         /* Return variables */
1159         *info = *r.out.info;
1160
1161         /* Return result */
1162         return r.out.result;
1163 }
1164
1165 struct rpccli_lsa_SetInfoPolicy_state {
1166         struct lsa_SetInfoPolicy orig;
1167         struct lsa_SetInfoPolicy tmp;
1168         TALLOC_CTX *out_mem_ctx;
1169         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1170 };
1171
1172 static void rpccli_lsa_SetInfoPolicy_done(struct tevent_req *subreq);
1173
1174 struct tevent_req *rpccli_lsa_SetInfoPolicy_send(TALLOC_CTX *mem_ctx,
1175                                                  struct tevent_context *ev,
1176                                                  struct rpc_pipe_client *cli,
1177                                                  struct policy_handle *_handle /* [in] [ref] */,
1178                                                  enum lsa_PolicyInfo _level /* [in]  */,
1179                                                  union lsa_PolicyInformation *_info /* [in] [ref,switch_is(level)] */)
1180 {
1181         struct tevent_req *req;
1182         struct rpccli_lsa_SetInfoPolicy_state *state;
1183         struct tevent_req *subreq;
1184
1185         req = tevent_req_create(mem_ctx, &state,
1186                                 struct rpccli_lsa_SetInfoPolicy_state);
1187         if (req == NULL) {
1188                 return NULL;
1189         }
1190         state->out_mem_ctx = NULL;
1191         state->dispatch_recv = cli->dispatch_recv;
1192
1193         /* In parameters */
1194         state->orig.in.handle = _handle;
1195         state->orig.in.level = _level;
1196         state->orig.in.info = _info;
1197
1198         /* Out parameters */
1199
1200         /* Result */
1201         ZERO_STRUCT(state->orig.out.result);
1202
1203         /* make a temporary copy, that we pass to the dispatch function */
1204         state->tmp = state->orig;
1205
1206         subreq = cli->dispatch_send(state, ev, cli,
1207                                     &ndr_table_lsarpc,
1208                                     NDR_LSA_SETINFOPOLICY,
1209                                     &state->tmp);
1210         if (tevent_req_nomem(subreq, req)) {
1211                 return tevent_req_post(req, ev);
1212         }
1213         tevent_req_set_callback(subreq, rpccli_lsa_SetInfoPolicy_done, req);
1214         return req;
1215 }
1216
1217 static void rpccli_lsa_SetInfoPolicy_done(struct tevent_req *subreq)
1218 {
1219         struct tevent_req *req = tevent_req_callback_data(
1220                 subreq, struct tevent_req);
1221         struct rpccli_lsa_SetInfoPolicy_state *state = tevent_req_data(
1222                 req, struct rpccli_lsa_SetInfoPolicy_state);
1223         NTSTATUS status;
1224         TALLOC_CTX *mem_ctx;
1225
1226         if (state->out_mem_ctx) {
1227                 mem_ctx = state->out_mem_ctx;
1228         } else {
1229                 mem_ctx = state;
1230         }
1231
1232         status = state->dispatch_recv(subreq, mem_ctx);
1233         TALLOC_FREE(subreq);
1234         if (!NT_STATUS_IS_OK(status)) {
1235                 tevent_req_nterror(req, status);
1236                 return;
1237         }
1238
1239         /* Copy out parameters */
1240
1241         /* Copy result */
1242         state->orig.out.result = state->tmp.out.result;
1243
1244         /* Reset temporary structure */
1245         ZERO_STRUCT(state->tmp);
1246
1247         tevent_req_done(req);
1248 }
1249
1250 NTSTATUS rpccli_lsa_SetInfoPolicy_recv(struct tevent_req *req,
1251                                        TALLOC_CTX *mem_ctx,
1252                                        NTSTATUS *result)
1253 {
1254         struct rpccli_lsa_SetInfoPolicy_state *state = tevent_req_data(
1255                 req, struct rpccli_lsa_SetInfoPolicy_state);
1256         NTSTATUS status;
1257
1258         if (tevent_req_is_nterror(req, &status)) {
1259                 tevent_req_received(req);
1260                 return status;
1261         }
1262
1263         /* Steal possbile out parameters to the callers context */
1264         talloc_steal(mem_ctx, state->out_mem_ctx);
1265
1266         /* Return result */
1267         *result = state->orig.out.result;
1268
1269         tevent_req_received(req);
1270         return NT_STATUS_OK;
1271 }
1272
1273 NTSTATUS rpccli_lsa_SetInfoPolicy(struct rpc_pipe_client *cli,
1274                                   TALLOC_CTX *mem_ctx,
1275                                   struct policy_handle *handle /* [in] [ref] */,
1276                                   enum lsa_PolicyInfo level /* [in]  */,
1277                                   union lsa_PolicyInformation *info /* [in] [ref,switch_is(level)] */)
1278 {
1279         struct lsa_SetInfoPolicy r;
1280         NTSTATUS status;
1281
1282         /* In parameters */
1283         r.in.handle = handle;
1284         r.in.level = level;
1285         r.in.info = info;
1286
1287         status = cli->dispatch(cli,
1288                                 mem_ctx,
1289                                 &ndr_table_lsarpc,
1290                                 NDR_LSA_SETINFOPOLICY,
1291                                 &r);
1292
1293         if (!NT_STATUS_IS_OK(status)) {
1294                 return status;
1295         }
1296
1297         if (NT_STATUS_IS_ERR(status)) {
1298                 return status;
1299         }
1300
1301         /* Return variables */
1302
1303         /* Return result */
1304         return r.out.result;
1305 }
1306
1307 struct rpccli_lsa_ClearAuditLog_state {
1308         struct lsa_ClearAuditLog orig;
1309         struct lsa_ClearAuditLog tmp;
1310         TALLOC_CTX *out_mem_ctx;
1311         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1312 };
1313
1314 static void rpccli_lsa_ClearAuditLog_done(struct tevent_req *subreq);
1315
1316 struct tevent_req *rpccli_lsa_ClearAuditLog_send(TALLOC_CTX *mem_ctx,
1317                                                  struct tevent_context *ev,
1318                                                  struct rpc_pipe_client *cli)
1319 {
1320         struct tevent_req *req;
1321         struct rpccli_lsa_ClearAuditLog_state *state;
1322         struct tevent_req *subreq;
1323
1324         req = tevent_req_create(mem_ctx, &state,
1325                                 struct rpccli_lsa_ClearAuditLog_state);
1326         if (req == NULL) {
1327                 return NULL;
1328         }
1329         state->out_mem_ctx = NULL;
1330         state->dispatch_recv = cli->dispatch_recv;
1331
1332         /* In parameters */
1333
1334         /* Out parameters */
1335
1336         /* Result */
1337         ZERO_STRUCT(state->orig.out.result);
1338
1339         /* make a temporary copy, that we pass to the dispatch function */
1340         state->tmp = state->orig;
1341
1342         subreq = cli->dispatch_send(state, ev, cli,
1343                                     &ndr_table_lsarpc,
1344                                     NDR_LSA_CLEARAUDITLOG,
1345                                     &state->tmp);
1346         if (tevent_req_nomem(subreq, req)) {
1347                 return tevent_req_post(req, ev);
1348         }
1349         tevent_req_set_callback(subreq, rpccli_lsa_ClearAuditLog_done, req);
1350         return req;
1351 }
1352
1353 static void rpccli_lsa_ClearAuditLog_done(struct tevent_req *subreq)
1354 {
1355         struct tevent_req *req = tevent_req_callback_data(
1356                 subreq, struct tevent_req);
1357         struct rpccli_lsa_ClearAuditLog_state *state = tevent_req_data(
1358                 req, struct rpccli_lsa_ClearAuditLog_state);
1359         NTSTATUS status;
1360         TALLOC_CTX *mem_ctx;
1361
1362         if (state->out_mem_ctx) {
1363                 mem_ctx = state->out_mem_ctx;
1364         } else {
1365                 mem_ctx = state;
1366         }
1367
1368         status = state->dispatch_recv(subreq, mem_ctx);
1369         TALLOC_FREE(subreq);
1370         if (!NT_STATUS_IS_OK(status)) {
1371                 tevent_req_nterror(req, status);
1372                 return;
1373         }
1374
1375         /* Copy out parameters */
1376
1377         /* Copy result */
1378         state->orig.out.result = state->tmp.out.result;
1379
1380         /* Reset temporary structure */
1381         ZERO_STRUCT(state->tmp);
1382
1383         tevent_req_done(req);
1384 }
1385
1386 NTSTATUS rpccli_lsa_ClearAuditLog_recv(struct tevent_req *req,
1387                                        TALLOC_CTX *mem_ctx,
1388                                        NTSTATUS *result)
1389 {
1390         struct rpccli_lsa_ClearAuditLog_state *state = tevent_req_data(
1391                 req, struct rpccli_lsa_ClearAuditLog_state);
1392         NTSTATUS status;
1393
1394         if (tevent_req_is_nterror(req, &status)) {
1395                 tevent_req_received(req);
1396                 return status;
1397         }
1398
1399         /* Steal possbile out parameters to the callers context */
1400         talloc_steal(mem_ctx, state->out_mem_ctx);
1401
1402         /* Return result */
1403         *result = state->orig.out.result;
1404
1405         tevent_req_received(req);
1406         return NT_STATUS_OK;
1407 }
1408
1409 NTSTATUS rpccli_lsa_ClearAuditLog(struct rpc_pipe_client *cli,
1410                                   TALLOC_CTX *mem_ctx)
1411 {
1412         struct lsa_ClearAuditLog r;
1413         NTSTATUS status;
1414
1415         /* In parameters */
1416
1417         status = cli->dispatch(cli,
1418                                 mem_ctx,
1419                                 &ndr_table_lsarpc,
1420                                 NDR_LSA_CLEARAUDITLOG,
1421                                 &r);
1422
1423         if (!NT_STATUS_IS_OK(status)) {
1424                 return status;
1425         }
1426
1427         if (NT_STATUS_IS_ERR(status)) {
1428                 return status;
1429         }
1430
1431         /* Return variables */
1432
1433         /* Return result */
1434         return r.out.result;
1435 }
1436
1437 struct rpccli_lsa_CreateAccount_state {
1438         struct lsa_CreateAccount orig;
1439         struct lsa_CreateAccount tmp;
1440         TALLOC_CTX *out_mem_ctx;
1441         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1442 };
1443
1444 static void rpccli_lsa_CreateAccount_done(struct tevent_req *subreq);
1445
1446 struct tevent_req *rpccli_lsa_CreateAccount_send(TALLOC_CTX *mem_ctx,
1447                                                  struct tevent_context *ev,
1448                                                  struct rpc_pipe_client *cli,
1449                                                  struct policy_handle *_handle /* [in] [ref] */,
1450                                                  struct dom_sid2 *_sid /* [in] [ref] */,
1451                                                  uint32_t _access_mask /* [in]  */,
1452                                                  struct policy_handle *_acct_handle /* [out] [ref] */)
1453 {
1454         struct tevent_req *req;
1455         struct rpccli_lsa_CreateAccount_state *state;
1456         struct tevent_req *subreq;
1457
1458         req = tevent_req_create(mem_ctx, &state,
1459                                 struct rpccli_lsa_CreateAccount_state);
1460         if (req == NULL) {
1461                 return NULL;
1462         }
1463         state->out_mem_ctx = NULL;
1464         state->dispatch_recv = cli->dispatch_recv;
1465
1466         /* In parameters */
1467         state->orig.in.handle = _handle;
1468         state->orig.in.sid = _sid;
1469         state->orig.in.access_mask = _access_mask;
1470
1471         /* Out parameters */
1472         state->orig.out.acct_handle = _acct_handle;
1473
1474         /* Result */
1475         ZERO_STRUCT(state->orig.out.result);
1476
1477         state->out_mem_ctx = talloc_named_const(state, 0,
1478                              "rpccli_lsa_CreateAccount_out_memory");
1479         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1480                 return tevent_req_post(req, ev);
1481         }
1482
1483         /* make a temporary copy, that we pass to the dispatch function */
1484         state->tmp = state->orig;
1485
1486         subreq = cli->dispatch_send(state, ev, cli,
1487                                     &ndr_table_lsarpc,
1488                                     NDR_LSA_CREATEACCOUNT,
1489                                     &state->tmp);
1490         if (tevent_req_nomem(subreq, req)) {
1491                 return tevent_req_post(req, ev);
1492         }
1493         tevent_req_set_callback(subreq, rpccli_lsa_CreateAccount_done, req);
1494         return req;
1495 }
1496
1497 static void rpccli_lsa_CreateAccount_done(struct tevent_req *subreq)
1498 {
1499         struct tevent_req *req = tevent_req_callback_data(
1500                 subreq, struct tevent_req);
1501         struct rpccli_lsa_CreateAccount_state *state = tevent_req_data(
1502                 req, struct rpccli_lsa_CreateAccount_state);
1503         NTSTATUS status;
1504         TALLOC_CTX *mem_ctx;
1505
1506         if (state->out_mem_ctx) {
1507                 mem_ctx = state->out_mem_ctx;
1508         } else {
1509                 mem_ctx = state;
1510         }
1511
1512         status = state->dispatch_recv(subreq, mem_ctx);
1513         TALLOC_FREE(subreq);
1514         if (!NT_STATUS_IS_OK(status)) {
1515                 tevent_req_nterror(req, status);
1516                 return;
1517         }
1518
1519         /* Copy out parameters */
1520         *state->orig.out.acct_handle = *state->tmp.out.acct_handle;
1521
1522         /* Copy result */
1523         state->orig.out.result = state->tmp.out.result;
1524
1525         /* Reset temporary structure */
1526         ZERO_STRUCT(state->tmp);
1527
1528         tevent_req_done(req);
1529 }
1530
1531 NTSTATUS rpccli_lsa_CreateAccount_recv(struct tevent_req *req,
1532                                        TALLOC_CTX *mem_ctx,
1533                                        NTSTATUS *result)
1534 {
1535         struct rpccli_lsa_CreateAccount_state *state = tevent_req_data(
1536                 req, struct rpccli_lsa_CreateAccount_state);
1537         NTSTATUS status;
1538
1539         if (tevent_req_is_nterror(req, &status)) {
1540                 tevent_req_received(req);
1541                 return status;
1542         }
1543
1544         /* Steal possbile out parameters to the callers context */
1545         talloc_steal(mem_ctx, state->out_mem_ctx);
1546
1547         /* Return result */
1548         *result = state->orig.out.result;
1549
1550         tevent_req_received(req);
1551         return NT_STATUS_OK;
1552 }
1553
1554 NTSTATUS rpccli_lsa_CreateAccount(struct rpc_pipe_client *cli,
1555                                   TALLOC_CTX *mem_ctx,
1556                                   struct policy_handle *handle /* [in] [ref] */,
1557                                   struct dom_sid2 *sid /* [in] [ref] */,
1558                                   uint32_t access_mask /* [in]  */,
1559                                   struct policy_handle *acct_handle /* [out] [ref] */)
1560 {
1561         struct lsa_CreateAccount r;
1562         NTSTATUS status;
1563
1564         /* In parameters */
1565         r.in.handle = handle;
1566         r.in.sid = sid;
1567         r.in.access_mask = access_mask;
1568
1569         status = cli->dispatch(cli,
1570                                 mem_ctx,
1571                                 &ndr_table_lsarpc,
1572                                 NDR_LSA_CREATEACCOUNT,
1573                                 &r);
1574
1575         if (!NT_STATUS_IS_OK(status)) {
1576                 return status;
1577         }
1578
1579         if (NT_STATUS_IS_ERR(status)) {
1580                 return status;
1581         }
1582
1583         /* Return variables */
1584         *acct_handle = *r.out.acct_handle;
1585
1586         /* Return result */
1587         return r.out.result;
1588 }
1589
1590 struct rpccli_lsa_EnumAccounts_state {
1591         struct lsa_EnumAccounts orig;
1592         struct lsa_EnumAccounts tmp;
1593         TALLOC_CTX *out_mem_ctx;
1594         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1595 };
1596
1597 static void rpccli_lsa_EnumAccounts_done(struct tevent_req *subreq);
1598
1599 struct tevent_req *rpccli_lsa_EnumAccounts_send(TALLOC_CTX *mem_ctx,
1600                                                 struct tevent_context *ev,
1601                                                 struct rpc_pipe_client *cli,
1602                                                 struct policy_handle *_handle /* [in] [ref] */,
1603                                                 uint32_t *_resume_handle /* [in,out] [ref] */,
1604                                                 struct lsa_SidArray *_sids /* [out] [ref] */,
1605                                                 uint32_t _num_entries /* [in] [range(0,8192)] */)
1606 {
1607         struct tevent_req *req;
1608         struct rpccli_lsa_EnumAccounts_state *state;
1609         struct tevent_req *subreq;
1610
1611         req = tevent_req_create(mem_ctx, &state,
1612                                 struct rpccli_lsa_EnumAccounts_state);
1613         if (req == NULL) {
1614                 return NULL;
1615         }
1616         state->out_mem_ctx = NULL;
1617         state->dispatch_recv = cli->dispatch_recv;
1618
1619         /* In parameters */
1620         state->orig.in.handle = _handle;
1621         state->orig.in.resume_handle = _resume_handle;
1622         state->orig.in.num_entries = _num_entries;
1623
1624         /* Out parameters */
1625         state->orig.out.resume_handle = _resume_handle;
1626         state->orig.out.sids = _sids;
1627
1628         /* Result */
1629         ZERO_STRUCT(state->orig.out.result);
1630
1631         state->out_mem_ctx = talloc_named_const(state, 0,
1632                              "rpccli_lsa_EnumAccounts_out_memory");
1633         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1634                 return tevent_req_post(req, ev);
1635         }
1636
1637         /* make a temporary copy, that we pass to the dispatch function */
1638         state->tmp = state->orig;
1639
1640         subreq = cli->dispatch_send(state, ev, cli,
1641                                     &ndr_table_lsarpc,
1642                                     NDR_LSA_ENUMACCOUNTS,
1643                                     &state->tmp);
1644         if (tevent_req_nomem(subreq, req)) {
1645                 return tevent_req_post(req, ev);
1646         }
1647         tevent_req_set_callback(subreq, rpccli_lsa_EnumAccounts_done, req);
1648         return req;
1649 }
1650
1651 static void rpccli_lsa_EnumAccounts_done(struct tevent_req *subreq)
1652 {
1653         struct tevent_req *req = tevent_req_callback_data(
1654                 subreq, struct tevent_req);
1655         struct rpccli_lsa_EnumAccounts_state *state = tevent_req_data(
1656                 req, struct rpccli_lsa_EnumAccounts_state);
1657         NTSTATUS status;
1658         TALLOC_CTX *mem_ctx;
1659
1660         if (state->out_mem_ctx) {
1661                 mem_ctx = state->out_mem_ctx;
1662         } else {
1663                 mem_ctx = state;
1664         }
1665
1666         status = state->dispatch_recv(subreq, mem_ctx);
1667         TALLOC_FREE(subreq);
1668         if (!NT_STATUS_IS_OK(status)) {
1669                 tevent_req_nterror(req, status);
1670                 return;
1671         }
1672
1673         /* Copy out parameters */
1674         *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
1675         *state->orig.out.sids = *state->tmp.out.sids;
1676
1677         /* Copy result */
1678         state->orig.out.result = state->tmp.out.result;
1679
1680         /* Reset temporary structure */
1681         ZERO_STRUCT(state->tmp);
1682
1683         tevent_req_done(req);
1684 }
1685
1686 NTSTATUS rpccli_lsa_EnumAccounts_recv(struct tevent_req *req,
1687                                       TALLOC_CTX *mem_ctx,
1688                                       NTSTATUS *result)
1689 {
1690         struct rpccli_lsa_EnumAccounts_state *state = tevent_req_data(
1691                 req, struct rpccli_lsa_EnumAccounts_state);
1692         NTSTATUS status;
1693
1694         if (tevent_req_is_nterror(req, &status)) {
1695                 tevent_req_received(req);
1696                 return status;
1697         }
1698
1699         /* Steal possbile out parameters to the callers context */
1700         talloc_steal(mem_ctx, state->out_mem_ctx);
1701
1702         /* Return result */
1703         *result = state->orig.out.result;
1704
1705         tevent_req_received(req);
1706         return NT_STATUS_OK;
1707 }
1708
1709 NTSTATUS rpccli_lsa_EnumAccounts(struct rpc_pipe_client *cli,
1710                                  TALLOC_CTX *mem_ctx,
1711                                  struct policy_handle *handle /* [in] [ref] */,
1712                                  uint32_t *resume_handle /* [in,out] [ref] */,
1713                                  struct lsa_SidArray *sids /* [out] [ref] */,
1714                                  uint32_t num_entries /* [in] [range(0,8192)] */)
1715 {
1716         struct lsa_EnumAccounts r;
1717         NTSTATUS status;
1718
1719         /* In parameters */
1720         r.in.handle = handle;
1721         r.in.resume_handle = resume_handle;
1722         r.in.num_entries = num_entries;
1723
1724         status = cli->dispatch(cli,
1725                                 mem_ctx,
1726                                 &ndr_table_lsarpc,
1727                                 NDR_LSA_ENUMACCOUNTS,
1728                                 &r);
1729
1730         if (!NT_STATUS_IS_OK(status)) {
1731                 return status;
1732         }
1733
1734         if (NT_STATUS_IS_ERR(status)) {
1735                 return status;
1736         }
1737
1738         /* Return variables */
1739         *resume_handle = *r.out.resume_handle;
1740         *sids = *r.out.sids;
1741
1742         /* Return result */
1743         return r.out.result;
1744 }
1745
1746 struct rpccli_lsa_CreateTrustedDomain_state {
1747         struct lsa_CreateTrustedDomain orig;
1748         struct lsa_CreateTrustedDomain tmp;
1749         TALLOC_CTX *out_mem_ctx;
1750         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1751 };
1752
1753 static void rpccli_lsa_CreateTrustedDomain_done(struct tevent_req *subreq);
1754
1755 struct tevent_req *rpccli_lsa_CreateTrustedDomain_send(TALLOC_CTX *mem_ctx,
1756                                                        struct tevent_context *ev,
1757                                                        struct rpc_pipe_client *cli,
1758                                                        struct policy_handle *_policy_handle /* [in] [ref] */,
1759                                                        struct lsa_DomainInfo *_info /* [in] [ref] */,
1760                                                        uint32_t _access_mask /* [in]  */,
1761                                                        struct policy_handle *_trustdom_handle /* [out] [ref] */)
1762 {
1763         struct tevent_req *req;
1764         struct rpccli_lsa_CreateTrustedDomain_state *state;
1765         struct tevent_req *subreq;
1766
1767         req = tevent_req_create(mem_ctx, &state,
1768                                 struct rpccli_lsa_CreateTrustedDomain_state);
1769         if (req == NULL) {
1770                 return NULL;
1771         }
1772         state->out_mem_ctx = NULL;
1773         state->dispatch_recv = cli->dispatch_recv;
1774
1775         /* In parameters */
1776         state->orig.in.policy_handle = _policy_handle;
1777         state->orig.in.info = _info;
1778         state->orig.in.access_mask = _access_mask;
1779
1780         /* Out parameters */
1781         state->orig.out.trustdom_handle = _trustdom_handle;
1782
1783         /* Result */
1784         ZERO_STRUCT(state->orig.out.result);
1785
1786         state->out_mem_ctx = talloc_named_const(state, 0,
1787                              "rpccli_lsa_CreateTrustedDomain_out_memory");
1788         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1789                 return tevent_req_post(req, ev);
1790         }
1791
1792         /* make a temporary copy, that we pass to the dispatch function */
1793         state->tmp = state->orig;
1794
1795         subreq = cli->dispatch_send(state, ev, cli,
1796                                     &ndr_table_lsarpc,
1797                                     NDR_LSA_CREATETRUSTEDDOMAIN,
1798                                     &state->tmp);
1799         if (tevent_req_nomem(subreq, req)) {
1800                 return tevent_req_post(req, ev);
1801         }
1802         tevent_req_set_callback(subreq, rpccli_lsa_CreateTrustedDomain_done, req);
1803         return req;
1804 }
1805
1806 static void rpccli_lsa_CreateTrustedDomain_done(struct tevent_req *subreq)
1807 {
1808         struct tevent_req *req = tevent_req_callback_data(
1809                 subreq, struct tevent_req);
1810         struct rpccli_lsa_CreateTrustedDomain_state *state = tevent_req_data(
1811                 req, struct rpccli_lsa_CreateTrustedDomain_state);
1812         NTSTATUS status;
1813         TALLOC_CTX *mem_ctx;
1814
1815         if (state->out_mem_ctx) {
1816                 mem_ctx = state->out_mem_ctx;
1817         } else {
1818                 mem_ctx = state;
1819         }
1820
1821         status = state->dispatch_recv(subreq, mem_ctx);
1822         TALLOC_FREE(subreq);
1823         if (!NT_STATUS_IS_OK(status)) {
1824                 tevent_req_nterror(req, status);
1825                 return;
1826         }
1827
1828         /* Copy out parameters */
1829         *state->orig.out.trustdom_handle = *state->tmp.out.trustdom_handle;
1830
1831         /* Copy result */
1832         state->orig.out.result = state->tmp.out.result;
1833
1834         /* Reset temporary structure */
1835         ZERO_STRUCT(state->tmp);
1836
1837         tevent_req_done(req);
1838 }
1839
1840 NTSTATUS rpccli_lsa_CreateTrustedDomain_recv(struct tevent_req *req,
1841                                              TALLOC_CTX *mem_ctx,
1842                                              NTSTATUS *result)
1843 {
1844         struct rpccli_lsa_CreateTrustedDomain_state *state = tevent_req_data(
1845                 req, struct rpccli_lsa_CreateTrustedDomain_state);
1846         NTSTATUS status;
1847
1848         if (tevent_req_is_nterror(req, &status)) {
1849                 tevent_req_received(req);
1850                 return status;
1851         }
1852
1853         /* Steal possbile out parameters to the callers context */
1854         talloc_steal(mem_ctx, state->out_mem_ctx);
1855
1856         /* Return result */
1857         *result = state->orig.out.result;
1858
1859         tevent_req_received(req);
1860         return NT_STATUS_OK;
1861 }
1862
1863 NTSTATUS rpccli_lsa_CreateTrustedDomain(struct rpc_pipe_client *cli,
1864                                         TALLOC_CTX *mem_ctx,
1865                                         struct policy_handle *policy_handle /* [in] [ref] */,
1866                                         struct lsa_DomainInfo *info /* [in] [ref] */,
1867                                         uint32_t access_mask /* [in]  */,
1868                                         struct policy_handle *trustdom_handle /* [out] [ref] */)
1869 {
1870         struct lsa_CreateTrustedDomain r;
1871         NTSTATUS status;
1872
1873         /* In parameters */
1874         r.in.policy_handle = policy_handle;
1875         r.in.info = info;
1876         r.in.access_mask = access_mask;
1877
1878         status = cli->dispatch(cli,
1879                                 mem_ctx,
1880                                 &ndr_table_lsarpc,
1881                                 NDR_LSA_CREATETRUSTEDDOMAIN,
1882                                 &r);
1883
1884         if (!NT_STATUS_IS_OK(status)) {
1885                 return status;
1886         }
1887
1888         if (NT_STATUS_IS_ERR(status)) {
1889                 return status;
1890         }
1891
1892         /* Return variables */
1893         *trustdom_handle = *r.out.trustdom_handle;
1894
1895         /* Return result */
1896         return r.out.result;
1897 }
1898
1899 struct rpccli_lsa_EnumTrustDom_state {
1900         struct lsa_EnumTrustDom orig;
1901         struct lsa_EnumTrustDom tmp;
1902         TALLOC_CTX *out_mem_ctx;
1903         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1904 };
1905
1906 static void rpccli_lsa_EnumTrustDom_done(struct tevent_req *subreq);
1907
1908 struct tevent_req *rpccli_lsa_EnumTrustDom_send(TALLOC_CTX *mem_ctx,
1909                                                 struct tevent_context *ev,
1910                                                 struct rpc_pipe_client *cli,
1911                                                 struct policy_handle *_handle /* [in] [ref] */,
1912                                                 uint32_t *_resume_handle /* [in,out] [ref] */,
1913                                                 struct lsa_DomainList *_domains /* [out] [ref] */,
1914                                                 uint32_t _max_size /* [in]  */)
1915 {
1916         struct tevent_req *req;
1917         struct rpccli_lsa_EnumTrustDom_state *state;
1918         struct tevent_req *subreq;
1919
1920         req = tevent_req_create(mem_ctx, &state,
1921                                 struct rpccli_lsa_EnumTrustDom_state);
1922         if (req == NULL) {
1923                 return NULL;
1924         }
1925         state->out_mem_ctx = NULL;
1926         state->dispatch_recv = cli->dispatch_recv;
1927
1928         /* In parameters */
1929         state->orig.in.handle = _handle;
1930         state->orig.in.resume_handle = _resume_handle;
1931         state->orig.in.max_size = _max_size;
1932
1933         /* Out parameters */
1934         state->orig.out.resume_handle = _resume_handle;
1935         state->orig.out.domains = _domains;
1936
1937         /* Result */
1938         ZERO_STRUCT(state->orig.out.result);
1939
1940         state->out_mem_ctx = talloc_named_const(state, 0,
1941                              "rpccli_lsa_EnumTrustDom_out_memory");
1942         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1943                 return tevent_req_post(req, ev);
1944         }
1945
1946         /* make a temporary copy, that we pass to the dispatch function */
1947         state->tmp = state->orig;
1948
1949         subreq = cli->dispatch_send(state, ev, cli,
1950                                     &ndr_table_lsarpc,
1951                                     NDR_LSA_ENUMTRUSTDOM,
1952                                     &state->tmp);
1953         if (tevent_req_nomem(subreq, req)) {
1954                 return tevent_req_post(req, ev);
1955         }
1956         tevent_req_set_callback(subreq, rpccli_lsa_EnumTrustDom_done, req);
1957         return req;
1958 }
1959
1960 static void rpccli_lsa_EnumTrustDom_done(struct tevent_req *subreq)
1961 {
1962         struct tevent_req *req = tevent_req_callback_data(
1963                 subreq, struct tevent_req);
1964         struct rpccli_lsa_EnumTrustDom_state *state = tevent_req_data(
1965                 req, struct rpccli_lsa_EnumTrustDom_state);
1966         NTSTATUS status;
1967         TALLOC_CTX *mem_ctx;
1968
1969         if (state->out_mem_ctx) {
1970                 mem_ctx = state->out_mem_ctx;
1971         } else {
1972                 mem_ctx = state;
1973         }
1974
1975         status = state->dispatch_recv(subreq, mem_ctx);
1976         TALLOC_FREE(subreq);
1977         if (!NT_STATUS_IS_OK(status)) {
1978                 tevent_req_nterror(req, status);
1979                 return;
1980         }
1981
1982         /* Copy out parameters */
1983         *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
1984         *state->orig.out.domains = *state->tmp.out.domains;
1985
1986         /* Copy result */
1987         state->orig.out.result = state->tmp.out.result;
1988
1989         /* Reset temporary structure */
1990         ZERO_STRUCT(state->tmp);
1991
1992         tevent_req_done(req);
1993 }
1994
1995 NTSTATUS rpccli_lsa_EnumTrustDom_recv(struct tevent_req *req,
1996                                       TALLOC_CTX *mem_ctx,
1997                                       NTSTATUS *result)
1998 {
1999         struct rpccli_lsa_EnumTrustDom_state *state = tevent_req_data(
2000                 req, struct rpccli_lsa_EnumTrustDom_state);
2001         NTSTATUS status;
2002
2003         if (tevent_req_is_nterror(req, &status)) {
2004                 tevent_req_received(req);
2005                 return status;
2006         }
2007
2008         /* Steal possbile out parameters to the callers context */
2009         talloc_steal(mem_ctx, state->out_mem_ctx);
2010
2011         /* Return result */
2012         *result = state->orig.out.result;
2013
2014         tevent_req_received(req);
2015         return NT_STATUS_OK;
2016 }
2017
2018 NTSTATUS rpccli_lsa_EnumTrustDom(struct rpc_pipe_client *cli,
2019                                  TALLOC_CTX *mem_ctx,
2020                                  struct policy_handle *handle /* [in] [ref] */,
2021                                  uint32_t *resume_handle /* [in,out] [ref] */,
2022                                  struct lsa_DomainList *domains /* [out] [ref] */,
2023                                  uint32_t max_size /* [in]  */)
2024 {
2025         struct lsa_EnumTrustDom r;
2026         NTSTATUS status;
2027
2028         /* In parameters */
2029         r.in.handle = handle;
2030         r.in.resume_handle = resume_handle;
2031         r.in.max_size = max_size;
2032
2033         status = cli->dispatch(cli,
2034                                 mem_ctx,
2035                                 &ndr_table_lsarpc,
2036                                 NDR_LSA_ENUMTRUSTDOM,
2037                                 &r);
2038
2039         if (!NT_STATUS_IS_OK(status)) {
2040                 return status;
2041         }
2042
2043         if (NT_STATUS_IS_ERR(status)) {
2044                 return status;
2045         }
2046
2047         /* Return variables */
2048         *resume_handle = *r.out.resume_handle;
2049         *domains = *r.out.domains;
2050
2051         /* Return result */
2052         return r.out.result;
2053 }
2054
2055 struct rpccli_lsa_LookupNames_state {
2056         struct lsa_LookupNames orig;
2057         struct lsa_LookupNames tmp;
2058         TALLOC_CTX *out_mem_ctx;
2059         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2060 };
2061
2062 static void rpccli_lsa_LookupNames_done(struct tevent_req *subreq);
2063
2064 struct tevent_req *rpccli_lsa_LookupNames_send(TALLOC_CTX *mem_ctx,
2065                                                struct tevent_context *ev,
2066                                                struct rpc_pipe_client *cli,
2067                                                struct policy_handle *_handle /* [in] [ref] */,
2068                                                uint32_t _num_names /* [in] [range(0,1000)] */,
2069                                                struct lsa_String *_names /* [in] [size_is(num_names)] */,
2070                                                struct lsa_RefDomainList **_domains /* [out] [ref] */,
2071                                                struct lsa_TransSidArray *_sids /* [in,out] [ref] */,
2072                                                enum lsa_LookupNamesLevel _level /* [in]  */,
2073                                                uint32_t *_count /* [in,out] [ref] */)
2074 {
2075         struct tevent_req *req;
2076         struct rpccli_lsa_LookupNames_state *state;
2077         struct tevent_req *subreq;
2078
2079         req = tevent_req_create(mem_ctx, &state,
2080                                 struct rpccli_lsa_LookupNames_state);
2081         if (req == NULL) {
2082                 return NULL;
2083         }
2084         state->out_mem_ctx = NULL;
2085         state->dispatch_recv = cli->dispatch_recv;
2086
2087         /* In parameters */
2088         state->orig.in.handle = _handle;
2089         state->orig.in.num_names = _num_names;
2090         state->orig.in.names = _names;
2091         state->orig.in.sids = _sids;
2092         state->orig.in.level = _level;
2093         state->orig.in.count = _count;
2094
2095         /* Out parameters */
2096         state->orig.out.domains = _domains;
2097         state->orig.out.sids = _sids;
2098         state->orig.out.count = _count;
2099
2100         /* Result */
2101         ZERO_STRUCT(state->orig.out.result);
2102
2103         state->out_mem_ctx = talloc_named_const(state, 0,
2104                              "rpccli_lsa_LookupNames_out_memory");
2105         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2106                 return tevent_req_post(req, ev);
2107         }
2108
2109         /* make a temporary copy, that we pass to the dispatch function */
2110         state->tmp = state->orig;
2111
2112         subreq = cli->dispatch_send(state, ev, cli,
2113                                     &ndr_table_lsarpc,
2114                                     NDR_LSA_LOOKUPNAMES,
2115                                     &state->tmp);
2116         if (tevent_req_nomem(subreq, req)) {
2117                 return tevent_req_post(req, ev);
2118         }
2119         tevent_req_set_callback(subreq, rpccli_lsa_LookupNames_done, req);
2120         return req;
2121 }
2122
2123 static void rpccli_lsa_LookupNames_done(struct tevent_req *subreq)
2124 {
2125         struct tevent_req *req = tevent_req_callback_data(
2126                 subreq, struct tevent_req);
2127         struct rpccli_lsa_LookupNames_state *state = tevent_req_data(
2128                 req, struct rpccli_lsa_LookupNames_state);
2129         NTSTATUS status;
2130         TALLOC_CTX *mem_ctx;
2131
2132         if (state->out_mem_ctx) {
2133                 mem_ctx = state->out_mem_ctx;
2134         } else {
2135                 mem_ctx = state;
2136         }
2137
2138         status = state->dispatch_recv(subreq, mem_ctx);
2139         TALLOC_FREE(subreq);
2140         if (!NT_STATUS_IS_OK(status)) {
2141                 tevent_req_nterror(req, status);
2142                 return;
2143         }
2144
2145         /* Copy out parameters */
2146         *state->orig.out.domains = *state->tmp.out.domains;
2147         *state->orig.out.sids = *state->tmp.out.sids;
2148         *state->orig.out.count = *state->tmp.out.count;
2149
2150         /* Copy result */
2151         state->orig.out.result = state->tmp.out.result;
2152
2153         /* Reset temporary structure */
2154         ZERO_STRUCT(state->tmp);
2155
2156         tevent_req_done(req);
2157 }
2158
2159 NTSTATUS rpccli_lsa_LookupNames_recv(struct tevent_req *req,
2160                                      TALLOC_CTX *mem_ctx,
2161                                      NTSTATUS *result)
2162 {
2163         struct rpccli_lsa_LookupNames_state *state = tevent_req_data(
2164                 req, struct rpccli_lsa_LookupNames_state);
2165         NTSTATUS status;
2166
2167         if (tevent_req_is_nterror(req, &status)) {
2168                 tevent_req_received(req);
2169                 return status;
2170         }
2171
2172         /* Steal possbile out parameters to the callers context */
2173         talloc_steal(mem_ctx, state->out_mem_ctx);
2174
2175         /* Return result */
2176         *result = state->orig.out.result;
2177
2178         tevent_req_received(req);
2179         return NT_STATUS_OK;
2180 }
2181
2182 NTSTATUS rpccli_lsa_LookupNames(struct rpc_pipe_client *cli,
2183                                 TALLOC_CTX *mem_ctx,
2184                                 struct policy_handle *handle /* [in] [ref] */,
2185                                 uint32_t num_names /* [in] [range(0,1000)] */,
2186                                 struct lsa_String *names /* [in] [size_is(num_names)] */,
2187                                 struct lsa_RefDomainList **domains /* [out] [ref] */,
2188                                 struct lsa_TransSidArray *sids /* [in,out] [ref] */,
2189                                 enum lsa_LookupNamesLevel level /* [in]  */,
2190                                 uint32_t *count /* [in,out] [ref] */)
2191 {
2192         struct lsa_LookupNames r;
2193         NTSTATUS status;
2194
2195         /* In parameters */
2196         r.in.handle = handle;
2197         r.in.num_names = num_names;
2198         r.in.names = names;
2199         r.in.sids = sids;
2200         r.in.level = level;
2201         r.in.count = count;
2202
2203         status = cli->dispatch(cli,
2204                                 mem_ctx,
2205                                 &ndr_table_lsarpc,
2206                                 NDR_LSA_LOOKUPNAMES,
2207                                 &r);
2208
2209         if (!NT_STATUS_IS_OK(status)) {
2210                 return status;
2211         }
2212
2213         if (NT_STATUS_IS_ERR(status)) {
2214                 return status;
2215         }
2216
2217         /* Return variables */
2218         *domains = *r.out.domains;
2219         *sids = *r.out.sids;
2220         *count = *r.out.count;
2221
2222         /* Return result */
2223         return r.out.result;
2224 }
2225
2226 struct rpccli_lsa_LookupSids_state {
2227         struct lsa_LookupSids orig;
2228         struct lsa_LookupSids tmp;
2229         TALLOC_CTX *out_mem_ctx;
2230         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2231 };
2232
2233 static void rpccli_lsa_LookupSids_done(struct tevent_req *subreq);
2234
2235 struct tevent_req *rpccli_lsa_LookupSids_send(TALLOC_CTX *mem_ctx,
2236                                               struct tevent_context *ev,
2237                                               struct rpc_pipe_client *cli,
2238                                               struct policy_handle *_handle /* [in] [ref] */,
2239                                               struct lsa_SidArray *_sids /* [in] [ref] */,
2240                                               struct lsa_RefDomainList **_domains /* [out] [ref] */,
2241                                               struct lsa_TransNameArray *_names /* [in,out] [ref] */,
2242                                               enum lsa_LookupNamesLevel _level /* [in]  */,
2243                                               uint32_t *_count /* [in,out] [ref] */)
2244 {
2245         struct tevent_req *req;
2246         struct rpccli_lsa_LookupSids_state *state;
2247         struct tevent_req *subreq;
2248
2249         req = tevent_req_create(mem_ctx, &state,
2250                                 struct rpccli_lsa_LookupSids_state);
2251         if (req == NULL) {
2252                 return NULL;
2253         }
2254         state->out_mem_ctx = NULL;
2255         state->dispatch_recv = cli->dispatch_recv;
2256
2257         /* In parameters */
2258         state->orig.in.handle = _handle;
2259         state->orig.in.sids = _sids;
2260         state->orig.in.names = _names;
2261         state->orig.in.level = _level;
2262         state->orig.in.count = _count;
2263
2264         /* Out parameters */
2265         state->orig.out.domains = _domains;
2266         state->orig.out.names = _names;
2267         state->orig.out.count = _count;
2268
2269         /* Result */
2270         ZERO_STRUCT(state->orig.out.result);
2271
2272         state->out_mem_ctx = talloc_named_const(state, 0,
2273                              "rpccli_lsa_LookupSids_out_memory");
2274         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2275                 return tevent_req_post(req, ev);
2276         }
2277
2278         /* make a temporary copy, that we pass to the dispatch function */
2279         state->tmp = state->orig;
2280
2281         subreq = cli->dispatch_send(state, ev, cli,
2282                                     &ndr_table_lsarpc,
2283                                     NDR_LSA_LOOKUPSIDS,
2284                                     &state->tmp);
2285         if (tevent_req_nomem(subreq, req)) {
2286                 return tevent_req_post(req, ev);
2287         }
2288         tevent_req_set_callback(subreq, rpccli_lsa_LookupSids_done, req);
2289         return req;
2290 }
2291
2292 static void rpccli_lsa_LookupSids_done(struct tevent_req *subreq)
2293 {
2294         struct tevent_req *req = tevent_req_callback_data(
2295                 subreq, struct tevent_req);
2296         struct rpccli_lsa_LookupSids_state *state = tevent_req_data(
2297                 req, struct rpccli_lsa_LookupSids_state);
2298         NTSTATUS status;
2299         TALLOC_CTX *mem_ctx;
2300
2301         if (state->out_mem_ctx) {
2302                 mem_ctx = state->out_mem_ctx;
2303         } else {
2304                 mem_ctx = state;
2305         }
2306
2307         status = state->dispatch_recv(subreq, mem_ctx);
2308         TALLOC_FREE(subreq);
2309         if (!NT_STATUS_IS_OK(status)) {
2310                 tevent_req_nterror(req, status);
2311                 return;
2312         }
2313
2314         /* Copy out parameters */
2315         *state->orig.out.domains = *state->tmp.out.domains;
2316         *state->orig.out.names = *state->tmp.out.names;
2317         *state->orig.out.count = *state->tmp.out.count;
2318
2319         /* Copy result */
2320         state->orig.out.result = state->tmp.out.result;
2321
2322         /* Reset temporary structure */
2323         ZERO_STRUCT(state->tmp);
2324
2325         tevent_req_done(req);
2326 }
2327
2328 NTSTATUS rpccli_lsa_LookupSids_recv(struct tevent_req *req,
2329                                     TALLOC_CTX *mem_ctx,
2330                                     NTSTATUS *result)
2331 {
2332         struct rpccli_lsa_LookupSids_state *state = tevent_req_data(
2333                 req, struct rpccli_lsa_LookupSids_state);
2334         NTSTATUS status;
2335
2336         if (tevent_req_is_nterror(req, &status)) {
2337                 tevent_req_received(req);
2338                 return status;
2339         }
2340
2341         /* Steal possbile out parameters to the callers context */
2342         talloc_steal(mem_ctx, state->out_mem_ctx);
2343
2344         /* Return result */
2345         *result = state->orig.out.result;
2346
2347         tevent_req_received(req);
2348         return NT_STATUS_OK;
2349 }
2350
2351 NTSTATUS rpccli_lsa_LookupSids(struct rpc_pipe_client *cli,
2352                                TALLOC_CTX *mem_ctx,
2353                                struct policy_handle *handle /* [in] [ref] */,
2354                                struct lsa_SidArray *sids /* [in] [ref] */,
2355                                struct lsa_RefDomainList **domains /* [out] [ref] */,
2356                                struct lsa_TransNameArray *names /* [in,out] [ref] */,
2357                                enum lsa_LookupNamesLevel level /* [in]  */,
2358                                uint32_t *count /* [in,out] [ref] */)
2359 {
2360         struct lsa_LookupSids r;
2361         NTSTATUS status;
2362
2363         /* In parameters */
2364         r.in.handle = handle;
2365         r.in.sids = sids;
2366         r.in.names = names;
2367         r.in.level = level;
2368         r.in.count = count;
2369
2370         status = cli->dispatch(cli,
2371                                 mem_ctx,
2372                                 &ndr_table_lsarpc,
2373                                 NDR_LSA_LOOKUPSIDS,
2374                                 &r);
2375
2376         if (!NT_STATUS_IS_OK(status)) {
2377                 return status;
2378         }
2379
2380         if (NT_STATUS_IS_ERR(status)) {
2381                 return status;
2382         }
2383
2384         /* Return variables */
2385         *domains = *r.out.domains;
2386         *names = *r.out.names;
2387         *count = *r.out.count;
2388
2389         /* Return result */
2390         return r.out.result;
2391 }
2392
2393 struct rpccli_lsa_CreateSecret_state {
2394         struct lsa_CreateSecret orig;
2395         struct lsa_CreateSecret tmp;
2396         TALLOC_CTX *out_mem_ctx;
2397         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2398 };
2399
2400 static void rpccli_lsa_CreateSecret_done(struct tevent_req *subreq);
2401
2402 struct tevent_req *rpccli_lsa_CreateSecret_send(TALLOC_CTX *mem_ctx,
2403                                                 struct tevent_context *ev,
2404                                                 struct rpc_pipe_client *cli,
2405                                                 struct policy_handle *_handle /* [in] [ref] */,
2406                                                 struct lsa_String _name /* [in]  */,
2407                                                 uint32_t _access_mask /* [in]  */,
2408                                                 struct policy_handle *_sec_handle /* [out] [ref] */)
2409 {
2410         struct tevent_req *req;
2411         struct rpccli_lsa_CreateSecret_state *state;
2412         struct tevent_req *subreq;
2413
2414         req = tevent_req_create(mem_ctx, &state,
2415                                 struct rpccli_lsa_CreateSecret_state);
2416         if (req == NULL) {
2417                 return NULL;
2418         }
2419         state->out_mem_ctx = NULL;
2420         state->dispatch_recv = cli->dispatch_recv;
2421
2422         /* In parameters */
2423         state->orig.in.handle = _handle;
2424         state->orig.in.name = _name;
2425         state->orig.in.access_mask = _access_mask;
2426
2427         /* Out parameters */
2428         state->orig.out.sec_handle = _sec_handle;
2429
2430         /* Result */
2431         ZERO_STRUCT(state->orig.out.result);
2432
2433         state->out_mem_ctx = talloc_named_const(state, 0,
2434                              "rpccli_lsa_CreateSecret_out_memory");
2435         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2436                 return tevent_req_post(req, ev);
2437         }
2438
2439         /* make a temporary copy, that we pass to the dispatch function */
2440         state->tmp = state->orig;
2441
2442         subreq = cli->dispatch_send(state, ev, cli,
2443                                     &ndr_table_lsarpc,
2444                                     NDR_LSA_CREATESECRET,
2445                                     &state->tmp);
2446         if (tevent_req_nomem(subreq, req)) {
2447                 return tevent_req_post(req, ev);
2448         }
2449         tevent_req_set_callback(subreq, rpccli_lsa_CreateSecret_done, req);
2450         return req;
2451 }
2452
2453 static void rpccli_lsa_CreateSecret_done(struct tevent_req *subreq)
2454 {
2455         struct tevent_req *req = tevent_req_callback_data(
2456                 subreq, struct tevent_req);
2457         struct rpccli_lsa_CreateSecret_state *state = tevent_req_data(
2458                 req, struct rpccli_lsa_CreateSecret_state);
2459         NTSTATUS status;
2460         TALLOC_CTX *mem_ctx;
2461
2462         if (state->out_mem_ctx) {
2463                 mem_ctx = state->out_mem_ctx;
2464         } else {
2465                 mem_ctx = state;
2466         }
2467
2468         status = state->dispatch_recv(subreq, mem_ctx);
2469         TALLOC_FREE(subreq);
2470         if (!NT_STATUS_IS_OK(status)) {
2471                 tevent_req_nterror(req, status);
2472                 return;
2473         }
2474
2475         /* Copy out parameters */
2476         *state->orig.out.sec_handle = *state->tmp.out.sec_handle;
2477
2478         /* Copy result */
2479         state->orig.out.result = state->tmp.out.result;
2480
2481         /* Reset temporary structure */
2482         ZERO_STRUCT(state->tmp);
2483
2484         tevent_req_done(req);
2485 }
2486
2487 NTSTATUS rpccli_lsa_CreateSecret_recv(struct tevent_req *req,
2488                                       TALLOC_CTX *mem_ctx,
2489                                       NTSTATUS *result)
2490 {
2491         struct rpccli_lsa_CreateSecret_state *state = tevent_req_data(
2492                 req, struct rpccli_lsa_CreateSecret_state);
2493         NTSTATUS status;
2494
2495         if (tevent_req_is_nterror(req, &status)) {
2496                 tevent_req_received(req);
2497                 return status;
2498         }
2499
2500         /* Steal possbile out parameters to the callers context */
2501         talloc_steal(mem_ctx, state->out_mem_ctx);
2502
2503         /* Return result */
2504         *result = state->orig.out.result;
2505
2506         tevent_req_received(req);
2507         return NT_STATUS_OK;
2508 }
2509
2510 NTSTATUS rpccli_lsa_CreateSecret(struct rpc_pipe_client *cli,
2511                                  TALLOC_CTX *mem_ctx,
2512                                  struct policy_handle *handle /* [in] [ref] */,
2513                                  struct lsa_String name /* [in]  */,
2514                                  uint32_t access_mask /* [in]  */,
2515                                  struct policy_handle *sec_handle /* [out] [ref] */)
2516 {
2517         struct lsa_CreateSecret r;
2518         NTSTATUS status;
2519
2520         /* In parameters */
2521         r.in.handle = handle;
2522         r.in.name = name;
2523         r.in.access_mask = access_mask;
2524
2525         status = cli->dispatch(cli,
2526                                 mem_ctx,
2527                                 &ndr_table_lsarpc,
2528                                 NDR_LSA_CREATESECRET,
2529                                 &r);
2530
2531         if (!NT_STATUS_IS_OK(status)) {
2532                 return status;
2533         }
2534
2535         if (NT_STATUS_IS_ERR(status)) {
2536                 return status;
2537         }
2538
2539         /* Return variables */
2540         *sec_handle = *r.out.sec_handle;
2541
2542         /* Return result */
2543         return r.out.result;
2544 }
2545
2546 struct rpccli_lsa_OpenAccount_state {
2547         struct lsa_OpenAccount orig;
2548         struct lsa_OpenAccount tmp;
2549         TALLOC_CTX *out_mem_ctx;
2550         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2551 };
2552
2553 static void rpccli_lsa_OpenAccount_done(struct tevent_req *subreq);
2554
2555 struct tevent_req *rpccli_lsa_OpenAccount_send(TALLOC_CTX *mem_ctx,
2556                                                struct tevent_context *ev,
2557                                                struct rpc_pipe_client *cli,
2558                                                struct policy_handle *_handle /* [in] [ref] */,
2559                                                struct dom_sid2 *_sid /* [in] [ref] */,
2560                                                uint32_t _access_mask /* [in]  */,
2561                                                struct policy_handle *_acct_handle /* [out] [ref] */)
2562 {
2563         struct tevent_req *req;
2564         struct rpccli_lsa_OpenAccount_state *state;
2565         struct tevent_req *subreq;
2566
2567         req = tevent_req_create(mem_ctx, &state,
2568                                 struct rpccli_lsa_OpenAccount_state);
2569         if (req == NULL) {
2570                 return NULL;
2571         }
2572         state->out_mem_ctx = NULL;
2573         state->dispatch_recv = cli->dispatch_recv;
2574
2575         /* In parameters */
2576         state->orig.in.handle = _handle;
2577         state->orig.in.sid = _sid;
2578         state->orig.in.access_mask = _access_mask;
2579
2580         /* Out parameters */
2581         state->orig.out.acct_handle = _acct_handle;
2582
2583         /* Result */
2584         ZERO_STRUCT(state->orig.out.result);
2585
2586         state->out_mem_ctx = talloc_named_const(state, 0,
2587                              "rpccli_lsa_OpenAccount_out_memory");
2588         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2589                 return tevent_req_post(req, ev);
2590         }
2591
2592         /* make a temporary copy, that we pass to the dispatch function */
2593         state->tmp = state->orig;
2594
2595         subreq = cli->dispatch_send(state, ev, cli,
2596                                     &ndr_table_lsarpc,
2597                                     NDR_LSA_OPENACCOUNT,
2598                                     &state->tmp);
2599         if (tevent_req_nomem(subreq, req)) {
2600                 return tevent_req_post(req, ev);
2601         }
2602         tevent_req_set_callback(subreq, rpccli_lsa_OpenAccount_done, req);
2603         return req;
2604 }
2605
2606 static void rpccli_lsa_OpenAccount_done(struct tevent_req *subreq)
2607 {
2608         struct tevent_req *req = tevent_req_callback_data(
2609                 subreq, struct tevent_req);
2610         struct rpccli_lsa_OpenAccount_state *state = tevent_req_data(
2611                 req, struct rpccli_lsa_OpenAccount_state);
2612         NTSTATUS status;
2613         TALLOC_CTX *mem_ctx;
2614
2615         if (state->out_mem_ctx) {
2616                 mem_ctx = state->out_mem_ctx;
2617         } else {
2618                 mem_ctx = state;
2619         }
2620
2621         status = state->dispatch_recv(subreq, mem_ctx);
2622         TALLOC_FREE(subreq);
2623         if (!NT_STATUS_IS_OK(status)) {
2624                 tevent_req_nterror(req, status);
2625                 return;
2626         }
2627
2628         /* Copy out parameters */
2629         *state->orig.out.acct_handle = *state->tmp.out.acct_handle;
2630
2631         /* Copy result */
2632         state->orig.out.result = state->tmp.out.result;
2633
2634         /* Reset temporary structure */
2635         ZERO_STRUCT(state->tmp);
2636
2637         tevent_req_done(req);
2638 }
2639
2640 NTSTATUS rpccli_lsa_OpenAccount_recv(struct tevent_req *req,
2641                                      TALLOC_CTX *mem_ctx,
2642                                      NTSTATUS *result)
2643 {
2644         struct rpccli_lsa_OpenAccount_state *state = tevent_req_data(
2645                 req, struct rpccli_lsa_OpenAccount_state);
2646         NTSTATUS status;
2647
2648         if (tevent_req_is_nterror(req, &status)) {
2649                 tevent_req_received(req);
2650                 return status;
2651         }
2652
2653         /* Steal possbile out parameters to the callers context */
2654         talloc_steal(mem_ctx, state->out_mem_ctx);
2655
2656         /* Return result */
2657         *result = state->orig.out.result;
2658
2659         tevent_req_received(req);
2660         return NT_STATUS_OK;
2661 }
2662
2663 NTSTATUS rpccli_lsa_OpenAccount(struct rpc_pipe_client *cli,
2664                                 TALLOC_CTX *mem_ctx,
2665                                 struct policy_handle *handle /* [in] [ref] */,
2666                                 struct dom_sid2 *sid /* [in] [ref] */,
2667                                 uint32_t access_mask /* [in]  */,
2668                                 struct policy_handle *acct_handle /* [out] [ref] */)
2669 {
2670         struct lsa_OpenAccount r;
2671         NTSTATUS status;
2672
2673         /* In parameters */
2674         r.in.handle = handle;
2675         r.in.sid = sid;
2676         r.in.access_mask = access_mask;
2677
2678         status = cli->dispatch(cli,
2679                                 mem_ctx,
2680                                 &ndr_table_lsarpc,
2681                                 NDR_LSA_OPENACCOUNT,
2682                                 &r);
2683
2684         if (!NT_STATUS_IS_OK(status)) {
2685                 return status;
2686         }
2687
2688         if (NT_STATUS_IS_ERR(status)) {
2689                 return status;
2690         }
2691
2692         /* Return variables */
2693         *acct_handle = *r.out.acct_handle;
2694
2695         /* Return result */
2696         return r.out.result;
2697 }
2698
2699 struct rpccli_lsa_EnumPrivsAccount_state {
2700         struct lsa_EnumPrivsAccount orig;
2701         struct lsa_EnumPrivsAccount tmp;
2702         TALLOC_CTX *out_mem_ctx;
2703         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2704 };
2705
2706 static void rpccli_lsa_EnumPrivsAccount_done(struct tevent_req *subreq);
2707
2708 struct tevent_req *rpccli_lsa_EnumPrivsAccount_send(TALLOC_CTX *mem_ctx,
2709                                                     struct tevent_context *ev,
2710                                                     struct rpc_pipe_client *cli,
2711                                                     struct policy_handle *_handle /* [in] [ref] */,
2712                                                     struct lsa_PrivilegeSet **_privs /* [out] [ref] */)
2713 {
2714         struct tevent_req *req;
2715         struct rpccli_lsa_EnumPrivsAccount_state *state;
2716         struct tevent_req *subreq;
2717
2718         req = tevent_req_create(mem_ctx, &state,
2719                                 struct rpccli_lsa_EnumPrivsAccount_state);
2720         if (req == NULL) {
2721                 return NULL;
2722         }
2723         state->out_mem_ctx = NULL;
2724         state->dispatch_recv = cli->dispatch_recv;
2725
2726         /* In parameters */
2727         state->orig.in.handle = _handle;
2728
2729         /* Out parameters */
2730         state->orig.out.privs = _privs;
2731
2732         /* Result */
2733         ZERO_STRUCT(state->orig.out.result);
2734
2735         state->out_mem_ctx = talloc_named_const(state, 0,
2736                              "rpccli_lsa_EnumPrivsAccount_out_memory");
2737         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2738                 return tevent_req_post(req, ev);
2739         }
2740
2741         /* make a temporary copy, that we pass to the dispatch function */
2742         state->tmp = state->orig;
2743
2744         subreq = cli->dispatch_send(state, ev, cli,
2745                                     &ndr_table_lsarpc,
2746                                     NDR_LSA_ENUMPRIVSACCOUNT,
2747                                     &state->tmp);
2748         if (tevent_req_nomem(subreq, req)) {
2749                 return tevent_req_post(req, ev);
2750         }
2751         tevent_req_set_callback(subreq, rpccli_lsa_EnumPrivsAccount_done, req);
2752         return req;
2753 }
2754
2755 static void rpccli_lsa_EnumPrivsAccount_done(struct tevent_req *subreq)
2756 {
2757         struct tevent_req *req = tevent_req_callback_data(
2758                 subreq, struct tevent_req);
2759         struct rpccli_lsa_EnumPrivsAccount_state *state = tevent_req_data(
2760                 req, struct rpccli_lsa_EnumPrivsAccount_state);
2761         NTSTATUS status;
2762         TALLOC_CTX *mem_ctx;
2763
2764         if (state->out_mem_ctx) {
2765                 mem_ctx = state->out_mem_ctx;
2766         } else {
2767                 mem_ctx = state;
2768         }
2769
2770         status = state->dispatch_recv(subreq, mem_ctx);
2771         TALLOC_FREE(subreq);
2772         if (!NT_STATUS_IS_OK(status)) {
2773                 tevent_req_nterror(req, status);
2774                 return;
2775         }
2776
2777         /* Copy out parameters */
2778         *state->orig.out.privs = *state->tmp.out.privs;
2779
2780         /* Copy result */
2781         state->orig.out.result = state->tmp.out.result;
2782
2783         /* Reset temporary structure */
2784         ZERO_STRUCT(state->tmp);
2785
2786         tevent_req_done(req);
2787 }
2788
2789 NTSTATUS rpccli_lsa_EnumPrivsAccount_recv(struct tevent_req *req,
2790                                           TALLOC_CTX *mem_ctx,
2791                                           NTSTATUS *result)
2792 {
2793         struct rpccli_lsa_EnumPrivsAccount_state *state = tevent_req_data(
2794                 req, struct rpccli_lsa_EnumPrivsAccount_state);
2795         NTSTATUS status;
2796
2797         if (tevent_req_is_nterror(req, &status)) {
2798                 tevent_req_received(req);
2799                 return status;
2800         }
2801
2802         /* Steal possbile out parameters to the callers context */
2803         talloc_steal(mem_ctx, state->out_mem_ctx);
2804
2805         /* Return result */
2806         *result = state->orig.out.result;
2807
2808         tevent_req_received(req);
2809         return NT_STATUS_OK;
2810 }
2811
2812 NTSTATUS rpccli_lsa_EnumPrivsAccount(struct rpc_pipe_client *cli,
2813                                      TALLOC_CTX *mem_ctx,
2814                                      struct policy_handle *handle /* [in] [ref] */,
2815                                      struct lsa_PrivilegeSet **privs /* [out] [ref] */)
2816 {
2817         struct lsa_EnumPrivsAccount r;
2818         NTSTATUS status;
2819
2820         /* In parameters */
2821         r.in.handle = handle;
2822
2823         status = cli->dispatch(cli,
2824                                 mem_ctx,
2825                                 &ndr_table_lsarpc,
2826                                 NDR_LSA_ENUMPRIVSACCOUNT,
2827                                 &r);
2828
2829         if (!NT_STATUS_IS_OK(status)) {
2830                 return status;
2831         }
2832
2833         if (NT_STATUS_IS_ERR(status)) {
2834                 return status;
2835         }
2836
2837         /* Return variables */
2838         *privs = *r.out.privs;
2839
2840         /* Return result */
2841         return r.out.result;
2842 }
2843
2844 struct rpccli_lsa_AddPrivilegesToAccount_state {
2845         struct lsa_AddPrivilegesToAccount orig;
2846         struct lsa_AddPrivilegesToAccount tmp;
2847         TALLOC_CTX *out_mem_ctx;
2848         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2849 };
2850
2851 static void rpccli_lsa_AddPrivilegesToAccount_done(struct tevent_req *subreq);
2852
2853 struct tevent_req *rpccli_lsa_AddPrivilegesToAccount_send(TALLOC_CTX *mem_ctx,
2854                                                           struct tevent_context *ev,
2855                                                           struct rpc_pipe_client *cli,
2856                                                           struct policy_handle *_handle /* [in] [ref] */,
2857                                                           struct lsa_PrivilegeSet *_privs /* [in] [ref] */)
2858 {
2859         struct tevent_req *req;
2860         struct rpccli_lsa_AddPrivilegesToAccount_state *state;
2861         struct tevent_req *subreq;
2862
2863         req = tevent_req_create(mem_ctx, &state,
2864                                 struct rpccli_lsa_AddPrivilegesToAccount_state);
2865         if (req == NULL) {
2866                 return NULL;
2867         }
2868         state->out_mem_ctx = NULL;
2869         state->dispatch_recv = cli->dispatch_recv;
2870
2871         /* In parameters */
2872         state->orig.in.handle = _handle;
2873         state->orig.in.privs = _privs;
2874
2875         /* Out parameters */
2876
2877         /* Result */
2878         ZERO_STRUCT(state->orig.out.result);
2879
2880         /* make a temporary copy, that we pass to the dispatch function */
2881         state->tmp = state->orig;
2882
2883         subreq = cli->dispatch_send(state, ev, cli,
2884                                     &ndr_table_lsarpc,
2885                                     NDR_LSA_ADDPRIVILEGESTOACCOUNT,
2886                                     &state->tmp);
2887         if (tevent_req_nomem(subreq, req)) {
2888                 return tevent_req_post(req, ev);
2889         }
2890         tevent_req_set_callback(subreq, rpccli_lsa_AddPrivilegesToAccount_done, req);
2891         return req;
2892 }
2893
2894 static void rpccli_lsa_AddPrivilegesToAccount_done(struct tevent_req *subreq)
2895 {
2896         struct tevent_req *req = tevent_req_callback_data(
2897                 subreq, struct tevent_req);
2898         struct rpccli_lsa_AddPrivilegesToAccount_state *state = tevent_req_data(
2899                 req, struct rpccli_lsa_AddPrivilegesToAccount_state);
2900         NTSTATUS status;
2901         TALLOC_CTX *mem_ctx;
2902
2903         if (state->out_mem_ctx) {
2904                 mem_ctx = state->out_mem_ctx;
2905         } else {
2906                 mem_ctx = state;
2907         }
2908
2909         status = state->dispatch_recv(subreq, mem_ctx);
2910         TALLOC_FREE(subreq);
2911         if (!NT_STATUS_IS_OK(status)) {
2912                 tevent_req_nterror(req, status);
2913                 return;
2914         }
2915
2916         /* Copy out parameters */
2917
2918         /* Copy result */
2919         state->orig.out.result = state->tmp.out.result;
2920
2921         /* Reset temporary structure */
2922         ZERO_STRUCT(state->tmp);
2923
2924         tevent_req_done(req);
2925 }
2926
2927 NTSTATUS rpccli_lsa_AddPrivilegesToAccount_recv(struct tevent_req *req,
2928                                                 TALLOC_CTX *mem_ctx,
2929                                                 NTSTATUS *result)
2930 {
2931         struct rpccli_lsa_AddPrivilegesToAccount_state *state = tevent_req_data(
2932                 req, struct rpccli_lsa_AddPrivilegesToAccount_state);
2933         NTSTATUS status;
2934
2935         if (tevent_req_is_nterror(req, &status)) {
2936                 tevent_req_received(req);
2937                 return status;
2938         }
2939
2940         /* Steal possbile out parameters to the callers context */
2941         talloc_steal(mem_ctx, state->out_mem_ctx);
2942
2943         /* Return result */
2944         *result = state->orig.out.result;
2945
2946         tevent_req_received(req);
2947         return NT_STATUS_OK;
2948 }
2949
2950 NTSTATUS rpccli_lsa_AddPrivilegesToAccount(struct rpc_pipe_client *cli,
2951                                            TALLOC_CTX *mem_ctx,
2952                                            struct policy_handle *handle /* [in] [ref] */,
2953                                            struct lsa_PrivilegeSet *privs /* [in] [ref] */)
2954 {
2955         struct lsa_AddPrivilegesToAccount r;
2956         NTSTATUS status;
2957
2958         /* In parameters */
2959         r.in.handle = handle;
2960         r.in.privs = privs;
2961
2962         status = cli->dispatch(cli,
2963                                 mem_ctx,
2964                                 &ndr_table_lsarpc,
2965                                 NDR_LSA_ADDPRIVILEGESTOACCOUNT,
2966                                 &r);
2967
2968         if (!NT_STATUS_IS_OK(status)) {
2969                 return status;
2970         }
2971
2972         if (NT_STATUS_IS_ERR(status)) {
2973                 return status;
2974         }
2975
2976         /* Return variables */
2977
2978         /* Return result */
2979         return r.out.result;
2980 }
2981
2982 struct rpccli_lsa_RemovePrivilegesFromAccount_state {
2983         struct lsa_RemovePrivilegesFromAccount orig;
2984         struct lsa_RemovePrivilegesFromAccount tmp;
2985         TALLOC_CTX *out_mem_ctx;
2986         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2987 };
2988
2989 static void rpccli_lsa_RemovePrivilegesFromAccount_done(struct tevent_req *subreq);
2990
2991 struct tevent_req *rpccli_lsa_RemovePrivilegesFromAccount_send(TALLOC_CTX *mem_ctx,
2992                                                                struct tevent_context *ev,
2993                                                                struct rpc_pipe_client *cli,
2994                                                                struct policy_handle *_handle /* [in] [ref] */,
2995                                                                uint8_t _remove_all /* [in]  */,
2996                                                                struct lsa_PrivilegeSet *_privs /* [in] [unique] */)
2997 {
2998         struct tevent_req *req;
2999         struct rpccli_lsa_RemovePrivilegesFromAccount_state *state;
3000         struct tevent_req *subreq;
3001
3002         req = tevent_req_create(mem_ctx, &state,
3003                                 struct rpccli_lsa_RemovePrivilegesFromAccount_state);
3004         if (req == NULL) {
3005                 return NULL;
3006         }
3007         state->out_mem_ctx = NULL;
3008         state->dispatch_recv = cli->dispatch_recv;
3009
3010         /* In parameters */
3011         state->orig.in.handle = _handle;
3012         state->orig.in.remove_all = _remove_all;
3013         state->orig.in.privs = _privs;
3014
3015         /* Out parameters */
3016
3017         /* Result */
3018         ZERO_STRUCT(state->orig.out.result);
3019
3020         /* make a temporary copy, that we pass to the dispatch function */
3021         state->tmp = state->orig;
3022
3023         subreq = cli->dispatch_send(state, ev, cli,
3024                                     &ndr_table_lsarpc,
3025                                     NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT,
3026                                     &state->tmp);
3027         if (tevent_req_nomem(subreq, req)) {
3028                 return tevent_req_post(req, ev);
3029         }
3030         tevent_req_set_callback(subreq, rpccli_lsa_RemovePrivilegesFromAccount_done, req);
3031         return req;
3032 }
3033
3034 static void rpccli_lsa_RemovePrivilegesFromAccount_done(struct tevent_req *subreq)
3035 {
3036         struct tevent_req *req = tevent_req_callback_data(
3037                 subreq, struct tevent_req);
3038         struct rpccli_lsa_RemovePrivilegesFromAccount_state *state = tevent_req_data(
3039                 req, struct rpccli_lsa_RemovePrivilegesFromAccount_state);
3040         NTSTATUS status;
3041         TALLOC_CTX *mem_ctx;
3042
3043         if (state->out_mem_ctx) {
3044                 mem_ctx = state->out_mem_ctx;
3045         } else {
3046                 mem_ctx = state;
3047         }
3048
3049         status = state->dispatch_recv(subreq, mem_ctx);
3050         TALLOC_FREE(subreq);
3051         if (!NT_STATUS_IS_OK(status)) {
3052                 tevent_req_nterror(req, status);
3053                 return;
3054         }
3055
3056         /* Copy out parameters */
3057
3058         /* Copy result */
3059         state->orig.out.result = state->tmp.out.result;
3060
3061         /* Reset temporary structure */
3062         ZERO_STRUCT(state->tmp);
3063
3064         tevent_req_done(req);
3065 }
3066
3067 NTSTATUS rpccli_lsa_RemovePrivilegesFromAccount_recv(struct tevent_req *req,
3068                                                      TALLOC_CTX *mem_ctx,
3069                                                      NTSTATUS *result)
3070 {
3071         struct rpccli_lsa_RemovePrivilegesFromAccount_state *state = tevent_req_data(
3072                 req, struct rpccli_lsa_RemovePrivilegesFromAccount_state);
3073         NTSTATUS status;
3074
3075         if (tevent_req_is_nterror(req, &status)) {
3076                 tevent_req_received(req);
3077                 return status;
3078         }
3079
3080         /* Steal possbile out parameters to the callers context */
3081         talloc_steal(mem_ctx, state->out_mem_ctx);
3082
3083         /* Return result */
3084         *result = state->orig.out.result;
3085
3086         tevent_req_received(req);
3087         return NT_STATUS_OK;
3088 }
3089
3090 NTSTATUS rpccli_lsa_RemovePrivilegesFromAccount(struct rpc_pipe_client *cli,
3091                                                 TALLOC_CTX *mem_ctx,
3092                                                 struct policy_handle *handle /* [in] [ref] */,
3093                                                 uint8_t remove_all /* [in]  */,
3094                                                 struct lsa_PrivilegeSet *privs /* [in] [unique] */)
3095 {
3096         struct lsa_RemovePrivilegesFromAccount r;
3097         NTSTATUS status;
3098
3099         /* In parameters */
3100         r.in.handle = handle;
3101         r.in.remove_all = remove_all;
3102         r.in.privs = privs;
3103
3104         status = cli->dispatch(cli,
3105                                 mem_ctx,
3106                                 &ndr_table_lsarpc,
3107                                 NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT,
3108                                 &r);
3109
3110         if (!NT_STATUS_IS_OK(status)) {
3111                 return status;
3112         }
3113
3114         if (NT_STATUS_IS_ERR(status)) {
3115                 return status;
3116         }
3117
3118         /* Return variables */
3119
3120         /* Return result */
3121         return r.out.result;
3122 }
3123
3124 struct rpccli_lsa_GetQuotasForAccount_state {
3125         struct lsa_GetQuotasForAccount orig;
3126         struct lsa_GetQuotasForAccount tmp;
3127         TALLOC_CTX *out_mem_ctx;
3128         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3129 };
3130
3131 static void rpccli_lsa_GetQuotasForAccount_done(struct tevent_req *subreq);
3132
3133 struct tevent_req *rpccli_lsa_GetQuotasForAccount_send(TALLOC_CTX *mem_ctx,
3134                                                        struct tevent_context *ev,
3135                                                        struct rpc_pipe_client *cli)
3136 {
3137         struct tevent_req *req;
3138         struct rpccli_lsa_GetQuotasForAccount_state *state;
3139         struct tevent_req *subreq;
3140
3141         req = tevent_req_create(mem_ctx, &state,
3142                                 struct rpccli_lsa_GetQuotasForAccount_state);
3143         if (req == NULL) {
3144                 return NULL;
3145         }
3146         state->out_mem_ctx = NULL;
3147         state->dispatch_recv = cli->dispatch_recv;
3148
3149         /* In parameters */
3150
3151         /* Out parameters */
3152
3153         /* Result */
3154         ZERO_STRUCT(state->orig.out.result);
3155
3156         /* make a temporary copy, that we pass to the dispatch function */
3157         state->tmp = state->orig;
3158
3159         subreq = cli->dispatch_send(state, ev, cli,
3160                                     &ndr_table_lsarpc,
3161                                     NDR_LSA_GETQUOTASFORACCOUNT,
3162                                     &state->tmp);
3163         if (tevent_req_nomem(subreq, req)) {
3164                 return tevent_req_post(req, ev);
3165         }
3166         tevent_req_set_callback(subreq, rpccli_lsa_GetQuotasForAccount_done, req);
3167         return req;
3168 }
3169
3170 static void rpccli_lsa_GetQuotasForAccount_done(struct tevent_req *subreq)
3171 {
3172         struct tevent_req *req = tevent_req_callback_data(
3173                 subreq, struct tevent_req);
3174         struct rpccli_lsa_GetQuotasForAccount_state *state = tevent_req_data(
3175                 req, struct rpccli_lsa_GetQuotasForAccount_state);
3176         NTSTATUS status;
3177         TALLOC_CTX *mem_ctx;
3178
3179         if (state->out_mem_ctx) {
3180                 mem_ctx = state->out_mem_ctx;
3181         } else {
3182                 mem_ctx = state;
3183         }
3184
3185         status = state->dispatch_recv(subreq, mem_ctx);
3186         TALLOC_FREE(subreq);
3187         if (!NT_STATUS_IS_OK(status)) {
3188                 tevent_req_nterror(req, status);
3189                 return;
3190         }
3191
3192         /* Copy out parameters */
3193
3194         /* Copy result */
3195         state->orig.out.result = state->tmp.out.result;
3196
3197         /* Reset temporary structure */
3198         ZERO_STRUCT(state->tmp);
3199
3200         tevent_req_done(req);
3201 }
3202
3203 NTSTATUS rpccli_lsa_GetQuotasForAccount_recv(struct tevent_req *req,
3204                                              TALLOC_CTX *mem_ctx,
3205                                              NTSTATUS *result)
3206 {
3207         struct rpccli_lsa_GetQuotasForAccount_state *state = tevent_req_data(
3208                 req, struct rpccli_lsa_GetQuotasForAccount_state);
3209         NTSTATUS status;
3210
3211         if (tevent_req_is_nterror(req, &status)) {
3212                 tevent_req_received(req);
3213                 return status;
3214         }
3215
3216         /* Steal possbile out parameters to the callers context */
3217         talloc_steal(mem_ctx, state->out_mem_ctx);
3218
3219         /* Return result */
3220         *result = state->orig.out.result;
3221
3222         tevent_req_received(req);
3223         return NT_STATUS_OK;
3224 }
3225
3226 NTSTATUS rpccli_lsa_GetQuotasForAccount(struct rpc_pipe_client *cli,
3227                                         TALLOC_CTX *mem_ctx)
3228 {
3229         struct lsa_GetQuotasForAccount r;
3230         NTSTATUS status;
3231
3232         /* In parameters */
3233
3234         status = cli->dispatch(cli,
3235                                 mem_ctx,
3236                                 &ndr_table_lsarpc,
3237                                 NDR_LSA_GETQUOTASFORACCOUNT,
3238                                 &r);
3239
3240         if (!NT_STATUS_IS_OK(status)) {
3241                 return status;
3242         }
3243
3244         if (NT_STATUS_IS_ERR(status)) {
3245                 return status;
3246         }
3247
3248         /* Return variables */
3249
3250         /* Return result */
3251         return r.out.result;
3252 }
3253
3254 struct rpccli_lsa_SetQuotasForAccount_state {
3255         struct lsa_SetQuotasForAccount orig;
3256         struct lsa_SetQuotasForAccount tmp;
3257         TALLOC_CTX *out_mem_ctx;
3258         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3259 };
3260
3261 static void rpccli_lsa_SetQuotasForAccount_done(struct tevent_req *subreq);
3262
3263 struct tevent_req *rpccli_lsa_SetQuotasForAccount_send(TALLOC_CTX *mem_ctx,
3264                                                        struct tevent_context *ev,
3265                                                        struct rpc_pipe_client *cli)
3266 {
3267         struct tevent_req *req;
3268         struct rpccli_lsa_SetQuotasForAccount_state *state;
3269         struct tevent_req *subreq;
3270
3271         req = tevent_req_create(mem_ctx, &state,
3272                                 struct rpccli_lsa_SetQuotasForAccount_state);
3273         if (req == NULL) {
3274                 return NULL;
3275         }
3276         state->out_mem_ctx = NULL;
3277         state->dispatch_recv = cli->dispatch_recv;
3278
3279         /* In parameters */
3280
3281         /* Out parameters */
3282
3283         /* Result */
3284         ZERO_STRUCT(state->orig.out.result);
3285
3286         /* make a temporary copy, that we pass to the dispatch function */
3287         state->tmp = state->orig;
3288
3289         subreq = cli->dispatch_send(state, ev, cli,
3290                                     &ndr_table_lsarpc,
3291                                     NDR_LSA_SETQUOTASFORACCOUNT,
3292                                     &state->tmp);
3293         if (tevent_req_nomem(subreq, req)) {
3294                 return tevent_req_post(req, ev);
3295         }
3296         tevent_req_set_callback(subreq, rpccli_lsa_SetQuotasForAccount_done, req);
3297         return req;
3298 }
3299
3300 static void rpccli_lsa_SetQuotasForAccount_done(struct tevent_req *subreq)
3301 {
3302         struct tevent_req *req = tevent_req_callback_data(
3303                 subreq, struct tevent_req);
3304         struct rpccli_lsa_SetQuotasForAccount_state *state = tevent_req_data(
3305                 req, struct rpccli_lsa_SetQuotasForAccount_state);
3306         NTSTATUS status;
3307         TALLOC_CTX *mem_ctx;
3308
3309         if (state->out_mem_ctx) {
3310                 mem_ctx = state->out_mem_ctx;
3311         } else {
3312                 mem_ctx = state;
3313         }
3314
3315         status = state->dispatch_recv(subreq, mem_ctx);
3316         TALLOC_FREE(subreq);
3317         if (!NT_STATUS_IS_OK(status)) {
3318                 tevent_req_nterror(req, status);
3319                 return;
3320         }
3321
3322         /* Copy out parameters */
3323
3324         /* Copy result */
3325         state->orig.out.result = state->tmp.out.result;
3326
3327         /* Reset temporary structure */
3328         ZERO_STRUCT(state->tmp);
3329
3330         tevent_req_done(req);
3331 }
3332
3333 NTSTATUS rpccli_lsa_SetQuotasForAccount_recv(struct tevent_req *req,
3334                                              TALLOC_CTX *mem_ctx,
3335                                              NTSTATUS *result)
3336 {
3337         struct rpccli_lsa_SetQuotasForAccount_state *state = tevent_req_data(
3338                 req, struct rpccli_lsa_SetQuotasForAccount_state);
3339         NTSTATUS status;
3340
3341         if (tevent_req_is_nterror(req, &status)) {
3342                 tevent_req_received(req);
3343                 return status;
3344         }
3345
3346         /* Steal possbile out parameters to the callers context */
3347         talloc_steal(mem_ctx, state->out_mem_ctx);
3348
3349         /* Return result */
3350         *result = state->orig.out.result;
3351
3352         tevent_req_received(req);
3353         return NT_STATUS_OK;
3354 }
3355
3356 NTSTATUS rpccli_lsa_SetQuotasForAccount(struct rpc_pipe_client *cli,
3357                                         TALLOC_CTX *mem_ctx)
3358 {
3359         struct lsa_SetQuotasForAccount r;
3360         NTSTATUS status;
3361
3362         /* In parameters */
3363
3364         status = cli->dispatch(cli,
3365                                 mem_ctx,
3366                                 &ndr_table_lsarpc,
3367                                 NDR_LSA_SETQUOTASFORACCOUNT,
3368                                 &r);
3369
3370         if (!NT_STATUS_IS_OK(status)) {
3371                 return status;
3372         }
3373
3374         if (NT_STATUS_IS_ERR(status)) {
3375                 return status;
3376         }
3377
3378         /* Return variables */
3379
3380         /* Return result */
3381         return r.out.result;
3382 }
3383
3384 struct rpccli_lsa_GetSystemAccessAccount_state {
3385         struct lsa_GetSystemAccessAccount orig;
3386         struct lsa_GetSystemAccessAccount tmp;
3387         TALLOC_CTX *out_mem_ctx;
3388         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3389 };
3390
3391 static void rpccli_lsa_GetSystemAccessAccount_done(struct tevent_req *subreq);
3392
3393 struct tevent_req *rpccli_lsa_GetSystemAccessAccount_send(TALLOC_CTX *mem_ctx,
3394                                                           struct tevent_context *ev,
3395                                                           struct rpc_pipe_client *cli,
3396                                                           struct policy_handle *_handle /* [in] [ref] */,
3397                                                           uint32_t *_access_mask /* [out] [ref] */)
3398 {
3399         struct tevent_req *req;
3400         struct rpccli_lsa_GetSystemAccessAccount_state *state;
3401         struct tevent_req *subreq;
3402
3403         req = tevent_req_create(mem_ctx, &state,
3404                                 struct rpccli_lsa_GetSystemAccessAccount_state);
3405         if (req == NULL) {
3406                 return NULL;
3407         }
3408         state->out_mem_ctx = NULL;
3409         state->dispatch_recv = cli->dispatch_recv;
3410
3411         /* In parameters */
3412         state->orig.in.handle = _handle;
3413
3414         /* Out parameters */
3415         state->orig.out.access_mask = _access_mask;
3416
3417         /* Result */
3418         ZERO_STRUCT(state->orig.out.result);
3419
3420         state->out_mem_ctx = talloc_named_const(state, 0,
3421                              "rpccli_lsa_GetSystemAccessAccount_out_memory");
3422         if (tevent_req_nomem(state->out_mem_ctx, req)) {
3423                 return tevent_req_post(req, ev);
3424         }
3425
3426         /* make a temporary copy, that we pass to the dispatch function */
3427         state->tmp = state->orig;
3428
3429         subreq = cli->dispatch_send(state, ev, cli,
3430                                     &ndr_table_lsarpc,
3431                                     NDR_LSA_GETSYSTEMACCESSACCOUNT,
3432                                     &state->tmp);
3433         if (tevent_req_nomem(subreq, req)) {
3434                 return tevent_req_post(req, ev);
3435         }
3436         tevent_req_set_callback(subreq, rpccli_lsa_GetSystemAccessAccount_done, req);
3437         return req;
3438 }
3439
3440 static void rpccli_lsa_GetSystemAccessAccount_done(struct tevent_req *subreq)
3441 {
3442         struct tevent_req *req = tevent_req_callback_data(
3443                 subreq, struct tevent_req);
3444         struct rpccli_lsa_GetSystemAccessAccount_state *state = tevent_req_data(
3445                 req, struct rpccli_lsa_GetSystemAccessAccount_state);
3446         NTSTATUS status;
3447         TALLOC_CTX *mem_ctx;
3448
3449         if (state->out_mem_ctx) {
3450                 mem_ctx = state->out_mem_ctx;
3451         } else {
3452                 mem_ctx = state;
3453         }
3454
3455         status = state->dispatch_recv(subreq, mem_ctx);
3456         TALLOC_FREE(subreq);
3457         if (!NT_STATUS_IS_OK(status)) {
3458                 tevent_req_nterror(req, status);
3459                 return;
3460         }
3461
3462         /* Copy out parameters */
3463         *state->orig.out.access_mask = *state->tmp.out.access_mask;
3464
3465         /* Copy result */
3466         state->orig.out.result = state->tmp.out.result;
3467
3468         /* Reset temporary structure */
3469         ZERO_STRUCT(state->tmp);
3470
3471         tevent_req_done(req);
3472 }
3473
3474 NTSTATUS rpccli_lsa_GetSystemAccessAccount_recv(struct tevent_req *req,
3475                                                 TALLOC_CTX *mem_ctx,
3476                                                 NTSTATUS *result)
3477 {
3478         struct rpccli_lsa_GetSystemAccessAccount_state *state = tevent_req_data(
3479                 req, struct rpccli_lsa_GetSystemAccessAccount_state);
3480         NTSTATUS status;
3481
3482         if (tevent_req_is_nterror(req, &status)) {
3483                 tevent_req_received(req);
3484                 return status;
3485         }
3486
3487         /* Steal possbile out parameters to the callers context */
3488         talloc_steal(mem_ctx, state->out_mem_ctx);
3489
3490         /* Return result */
3491         *result = state->orig.out.result;
3492
3493         tevent_req_received(req);
3494         return NT_STATUS_OK;
3495 }
3496
3497 NTSTATUS rpccli_lsa_GetSystemAccessAccount(struct rpc_pipe_client *cli,
3498                                            TALLOC_CTX *mem_ctx,
3499                                            struct policy_handle *handle /* [in] [ref] */,
3500                                            uint32_t *access_mask /* [out] [ref] */)
3501 {
3502         struct lsa_GetSystemAccessAccount r;
3503         NTSTATUS status;
3504
3505         /* In parameters */
3506         r.in.handle = handle;
3507
3508         status = cli->dispatch(cli,
3509                                 mem_ctx,
3510                                 &ndr_table_lsarpc,
3511                                 NDR_LSA_GETSYSTEMACCESSACCOUNT,
3512                                 &r);
3513
3514         if (!NT_STATUS_IS_OK(status)) {
3515                 return status;
3516         }
3517
3518         if (NT_STATUS_IS_ERR(status)) {
3519                 return status;
3520         }
3521
3522         /* Return variables */
3523         *access_mask = *r.out.access_mask;
3524
3525         /* Return result */
3526         return r.out.result;
3527 }
3528
3529 struct rpccli_lsa_SetSystemAccessAccount_state {
3530         struct lsa_SetSystemAccessAccount orig;
3531         struct lsa_SetSystemAccessAccount tmp;
3532         TALLOC_CTX *out_mem_ctx;
3533         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3534 };
3535
3536 static void rpccli_lsa_SetSystemAccessAccount_done(struct tevent_req *subreq);
3537
3538 struct tevent_req *rpccli_lsa_SetSystemAccessAccount_send(TALLOC_CTX *mem_ctx,
3539                                                           struct tevent_context *ev,
3540                                                           struct rpc_pipe_client *cli,
3541                                                           struct policy_handle *_handle /* [in] [ref] */,
3542                                                           uint32_t _access_mask /* [in]  */)
3543 {
3544         struct tevent_req *req;
3545         struct rpccli_lsa_SetSystemAccessAccount_state *state;
3546         struct tevent_req *subreq;
3547
3548         req = tevent_req_create(mem_ctx, &state,
3549                                 struct rpccli_lsa_SetSystemAccessAccount_state);
3550         if (req == NULL) {
3551                 return NULL;
3552         }
3553         state->out_mem_ctx = NULL;
3554         state->dispatch_recv = cli->dispatch_recv;
3555
3556         /* In parameters */
3557         state->orig.in.handle = _handle;
3558         state->orig.in.access_mask = _access_mask;
3559
3560         /* Out parameters */
3561
3562         /* Result */
3563         ZERO_STRUCT(state->orig.out.result);
3564
3565         /* make a temporary copy, that we pass to the dispatch function */
3566         state->tmp = state->orig;
3567
3568         subreq = cli->dispatch_send(state, ev, cli,
3569                                     &ndr_table_lsarpc,
3570                                     NDR_LSA_SETSYSTEMACCESSACCOUNT,
3571                                     &state->tmp);
3572         if (tevent_req_nomem(subreq, req)) {
3573                 return tevent_req_post(req, ev);
3574         }
3575         tevent_req_set_callback(subreq, rpccli_lsa_SetSystemAccessAccount_done, req);
3576         return req;
3577 }
3578
3579 static void rpccli_lsa_SetSystemAccessAccount_done(struct tevent_req *subreq)
3580 {
3581         struct tevent_req *req = tevent_req_callback_data(
3582                 subreq, struct tevent_req);
3583         struct rpccli_lsa_SetSystemAccessAccount_state *state = tevent_req_data(
3584                 req, struct rpccli_lsa_SetSystemAccessAccount_state);
3585         NTSTATUS status;
3586         TALLOC_CTX *mem_ctx;
3587
3588         if (state->out_mem_ctx) {
3589                 mem_ctx = state->out_mem_ctx;
3590         } else {
3591                 mem_ctx = state;
3592         }
3593
3594         status = state->dispatch_recv(subreq, mem_ctx);
3595         TALLOC_FREE(subreq);
3596         if (!NT_STATUS_IS_OK(status)) {
3597                 tevent_req_nterror(req, status);
3598                 return;
3599         }
3600
3601         /* Copy out parameters */
3602
3603         /* Copy result */
3604         state->orig.out.result = state->tmp.out.result;
3605
3606         /* Reset temporary structure */
3607         ZERO_STRUCT(state->tmp);
3608
3609         tevent_req_done(req);
3610 }
3611
3612 NTSTATUS rpccli_lsa_SetSystemAccessAccount_recv(struct tevent_req *req,
3613                                                 TALLOC_CTX *mem_ctx,
3614                                                 NTSTATUS *result)
3615 {
3616         struct rpccli_lsa_SetSystemAccessAccount_state *state = tevent_req_data(
3617                 req, struct rpccli_lsa_SetSystemAccessAccount_state);
3618         NTSTATUS status;
3619
3620         if (tevent_req_is_nterror(req, &status)) {
3621                 tevent_req_received(req);
3622                 return status;
3623         }
3624
3625         /* Steal possbile out parameters to the callers context */
3626         talloc_steal(mem_ctx, state->out_mem_ctx);
3627
3628         /* Return result */
3629         *result = state->orig.out.result;
3630
3631         tevent_req_received(req);
3632         return NT_STATUS_OK;
3633 }
3634
3635 NTSTATUS rpccli_lsa_SetSystemAccessAccount(struct rpc_pipe_client *cli,
3636                                            TALLOC_CTX *mem_ctx,
3637                                            struct policy_handle *handle /* [in] [ref] */,
3638                                            uint32_t access_mask /* [in]  */)
3639 {
3640         struct lsa_SetSystemAccessAccount r;
3641         NTSTATUS status;
3642
3643         /* In parameters */
3644         r.in.handle = handle;
3645         r.in.access_mask = access_mask;
3646
3647         status = cli->dispatch(cli,
3648                                 mem_ctx,
3649                                 &ndr_table_lsarpc,
3650                                 NDR_LSA_SETSYSTEMACCESSACCOUNT,
3651                                 &r);
3652
3653         if (!NT_STATUS_IS_OK(status)) {
3654                 return status;
3655         }
3656
3657         if (NT_STATUS_IS_ERR(status)) {
3658                 return status;
3659         }
3660
3661         /* Return variables */
3662
3663         /* Return result */
3664         return r.out.result;
3665 }
3666
3667 struct rpccli_lsa_OpenTrustedDomain_state {
3668         struct lsa_OpenTrustedDomain orig;
3669         struct lsa_OpenTrustedDomain tmp;
3670         TALLOC_CTX *out_mem_ctx;
3671         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3672 };
3673
3674 static void rpccli_lsa_OpenTrustedDomain_done(struct tevent_req *subreq);
3675
3676 struct tevent_req *rpccli_lsa_OpenTrustedDomain_send(TALLOC_CTX *mem_ctx,
3677                                                      struct tevent_context *ev,
3678                                                      struct rpc_pipe_client *cli,
3679                                                      struct policy_handle *_handle /* [in] [ref] */,
3680                                                      struct dom_sid2 *_sid /* [in] [ref] */,
3681                                                      uint32_t _access_mask /* [in]  */,
3682                                                      struct policy_handle *_trustdom_handle /* [out] [ref] */)
3683 {
3684         struct tevent_req *req;
3685         struct rpccli_lsa_OpenTrustedDomain_state *state;
3686         struct tevent_req *subreq;
3687
3688         req = tevent_req_create(mem_ctx, &state,
3689                                 struct rpccli_lsa_OpenTrustedDomain_state);
3690         if (req == NULL) {
3691                 return NULL;
3692         }
3693         state->out_mem_ctx = NULL;
3694         state->dispatch_recv = cli->dispatch_recv;
3695
3696         /* In parameters */
3697         state->orig.in.handle = _handle;
3698         state->orig.in.sid = _sid;
3699         state->orig.in.access_mask = _access_mask;
3700
3701         /* Out parameters */
3702         state->orig.out.trustdom_handle = _trustdom_handle;
3703
3704         /* Result */
3705         ZERO_STRUCT(state->orig.out.result);
3706
3707         state->out_mem_ctx = talloc_named_const(state, 0,
3708                              "rpccli_lsa_OpenTrustedDomain_out_memory");
3709         if (tevent_req_nomem(state->out_mem_ctx, req)) {
3710                 return tevent_req_post(req, ev);
3711         }
3712
3713         /* make a temporary copy, that we pass to the dispatch function */
3714         state->tmp = state->orig;
3715
3716         subreq = cli->dispatch_send(state, ev, cli,
3717                                     &ndr_table_lsarpc,
3718                                     NDR_LSA_OPENTRUSTEDDOMAIN,
3719                                     &state->tmp);
3720         if (tevent_req_nomem(subreq, req)) {
3721                 return tevent_req_post(req, ev);
3722         }
3723         tevent_req_set_callback(subreq, rpccli_lsa_OpenTrustedDomain_done, req);
3724         return req;
3725 }
3726
3727 static void rpccli_lsa_OpenTrustedDomain_done(struct tevent_req *subreq)
3728 {
3729         struct tevent_req *req = tevent_req_callback_data(
3730                 subreq, struct tevent_req);
3731         struct rpccli_lsa_OpenTrustedDomain_state *state = tevent_req_data(
3732                 req, struct rpccli_lsa_OpenTrustedDomain_state);
3733         NTSTATUS status;
3734         TALLOC_CTX *mem_ctx;
3735
3736         if (state->out_mem_ctx) {
3737                 mem_ctx = state->out_mem_ctx;
3738         } else {
3739                 mem_ctx = state;
3740         }
3741
3742         status = state->dispatch_recv(subreq, mem_ctx);
3743         TALLOC_FREE(subreq);
3744         if (!NT_STATUS_IS_OK(status)) {
3745                 tevent_req_nterror(req, status);
3746                 return;
3747         }
3748
3749         /* Copy out parameters */
3750         *state->orig.out.trustdom_handle = *state->tmp.out.trustdom_handle;
3751
3752         /* Copy result */
3753         state->orig.out.result = state->tmp.out.result;
3754
3755         /* Reset temporary structure */
3756         ZERO_STRUCT(state->tmp);
3757
3758         tevent_req_done(req);
3759 }
3760
3761 NTSTATUS rpccli_lsa_OpenTrustedDomain_recv(struct tevent_req *req,
3762                                            TALLOC_CTX *mem_ctx,
3763                                            NTSTATUS *result)
3764 {
3765         struct rpccli_lsa_OpenTrustedDomain_state *state = tevent_req_data(
3766                 req, struct rpccli_lsa_OpenTrustedDomain_state);
3767         NTSTATUS status;
3768
3769         if (tevent_req_is_nterror(req, &status)) {
3770                 tevent_req_received(req);
3771                 return status;
3772         }
3773
3774         /* Steal possbile out parameters to the callers context */
3775         talloc_steal(mem_ctx, state->out_mem_ctx);
3776
3777         /* Return result */
3778         *result = state->orig.out.result;
3779
3780         tevent_req_received(req);
3781         return NT_STATUS_OK;
3782 }
3783
3784 NTSTATUS rpccli_lsa_OpenTrustedDomain(struct rpc_pipe_client *cli,
3785                                       TALLOC_CTX *mem_ctx,
3786                                       struct policy_handle *handle /* [in] [ref] */,
3787                                       struct dom_sid2 *sid /* [in] [ref] */,
3788                                       uint32_t access_mask /* [in]  */,
3789                                       struct policy_handle *trustdom_handle /* [out] [ref] */)
3790 {
3791         struct lsa_OpenTrustedDomain r;
3792         NTSTATUS status;
3793
3794         /* In parameters */
3795         r.in.handle = handle;
3796         r.in.sid = sid;
3797         r.in.access_mask = access_mask;
3798
3799         status = cli->dispatch(cli,
3800                                 mem_ctx,
3801                                 &ndr_table_lsarpc,
3802                                 NDR_LSA_OPENTRUSTEDDOMAIN,
3803                                 &r);
3804
3805         if (!NT_STATUS_IS_OK(status)) {
3806                 return status;
3807         }
3808
3809         if (NT_STATUS_IS_ERR(status)) {
3810                 return status;
3811         }
3812
3813         /* Return variables */
3814         *trustdom_handle = *r.out.trustdom_handle;
3815
3816         /* Return result */
3817         return r.out.result;
3818 }
3819
3820 struct rpccli_lsa_QueryTrustedDomainInfo_state {
3821         struct lsa_QueryTrustedDomainInfo orig;
3822         struct lsa_QueryTrustedDomainInfo tmp;
3823         TALLOC_CTX *out_mem_ctx;
3824         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3825 };
3826
3827 static void rpccli_lsa_QueryTrustedDomainInfo_done(struct tevent_req *subreq);
3828
3829 struct tevent_req *rpccli_lsa_QueryTrustedDomainInfo_send(TALLOC_CTX *mem_ctx,
3830                                                           struct tevent_context *ev,
3831                                                           struct rpc_pipe_client *cli,
3832                                                           struct policy_handle *_trustdom_handle /* [in] [ref] */,
3833                                                           enum lsa_TrustDomInfoEnum _level /* [in]  */,
3834                                                           union lsa_TrustedDomainInfo **_info /* [out] [ref,switch_is(level)] */)
3835 {
3836         struct tevent_req *req;
3837         struct rpccli_lsa_QueryTrustedDomainInfo_state *state;
3838         struct tevent_req *subreq;
3839
3840         req = tevent_req_create(mem_ctx, &state,
3841                                 struct rpccli_lsa_QueryTrustedDomainInfo_state);
3842         if (req == NULL) {
3843                 return NULL;
3844         }
3845         state->out_mem_ctx = NULL;
3846         state->dispatch_recv = cli->dispatch_recv;
3847
3848         /* In parameters */
3849         state->orig.in.trustdom_handle = _trustdom_handle;
3850         state->orig.in.level = _level;
3851
3852         /* Out parameters */
3853         state->orig.out.info = _info;
3854
3855         /* Result */
3856         ZERO_STRUCT(state->orig.out.result);
3857
3858         state->out_mem_ctx = talloc_named_const(state, 0,
3859                              "rpccli_lsa_QueryTrustedDomainInfo_out_memory");
3860         if (tevent_req_nomem(state->out_mem_ctx, req)) {
3861                 return tevent_req_post(req, ev);
3862         }
3863
3864         /* make a temporary copy, that we pass to the dispatch function */
3865         state->tmp = state->orig;
3866
3867         subreq = cli->dispatch_send(state, ev, cli,
3868                                     &ndr_table_lsarpc,
3869                                     NDR_LSA_QUERYTRUSTEDDOMAININFO,
3870                                     &state->tmp);
3871         if (tevent_req_nomem(subreq, req)) {
3872                 return tevent_req_post(req, ev);
3873         }
3874         tevent_req_set_callback(subreq, rpccli_lsa_QueryTrustedDomainInfo_done, req);
3875         return req;
3876 }
3877
3878 static void rpccli_lsa_QueryTrustedDomainInfo_done(struct tevent_req *subreq)
3879 {
3880         struct tevent_req *req = tevent_req_callback_data(
3881                 subreq, struct tevent_req);
3882         struct rpccli_lsa_QueryTrustedDomainInfo_state *state = tevent_req_data(
3883                 req, struct rpccli_lsa_QueryTrustedDomainInfo_state);
3884         NTSTATUS status;
3885         TALLOC_CTX *mem_ctx;
3886
3887         if (state->out_mem_ctx) {
3888                 mem_ctx = state->out_mem_ctx;
3889         } else {
3890                 mem_ctx = state;
3891         }
3892
3893         status = state->dispatch_recv(subreq, mem_ctx);
3894         TALLOC_FREE(subreq);
3895         if (!NT_STATUS_IS_OK(status)) {
3896                 tevent_req_nterror(req, status);
3897                 return;
3898         }
3899
3900         /* Copy out parameters */
3901         *state->orig.out.info = *state->tmp.out.info;
3902
3903         /* Copy result */
3904         state->orig.out.result = state->tmp.out.result;
3905
3906         /* Reset temporary structure */
3907         ZERO_STRUCT(state->tmp);
3908
3909         tevent_req_done(req);
3910 }
3911
3912 NTSTATUS rpccli_lsa_QueryTrustedDomainInfo_recv(struct tevent_req *req,
3913                                                 TALLOC_CTX *mem_ctx,
3914                                                 NTSTATUS *result)
3915 {
3916         struct rpccli_lsa_QueryTrustedDomainInfo_state *state = tevent_req_data(
3917                 req, struct rpccli_lsa_QueryTrustedDomainInfo_state);
3918         NTSTATUS status;
3919
3920         if (tevent_req_is_nterror(req, &status)) {
3921                 tevent_req_received(req);
3922                 return status;
3923         }
3924
3925         /* Steal possbile out parameters to the callers context */
3926         talloc_steal(mem_ctx, state->out_mem_ctx);
3927
3928         /* Return result */
3929         *result = state->orig.out.result;
3930
3931         tevent_req_received(req);
3932         return NT_STATUS_OK;
3933 }
3934
3935 NTSTATUS rpccli_lsa_QueryTrustedDomainInfo(struct rpc_pipe_client *cli,
3936                                            TALLOC_CTX *mem_ctx,
3937                                            struct policy_handle *trustdom_handle /* [in] [ref] */,
3938                                            enum lsa_TrustDomInfoEnum level /* [in]  */,
3939                                            union lsa_TrustedDomainInfo **info /* [out] [ref,switch_is(level)] */)
3940 {
3941         struct lsa_QueryTrustedDomainInfo r;
3942         NTSTATUS status;
3943
3944         /* In parameters */
3945         r.in.trustdom_handle = trustdom_handle;
3946         r.in.level = level;
3947
3948         status = cli->dispatch(cli,
3949                                 mem_ctx,
3950                                 &ndr_table_lsarpc,
3951                                 NDR_LSA_QUERYTRUSTEDDOMAININFO,
3952                                 &r);
3953
3954         if (!NT_STATUS_IS_OK(status)) {
3955                 return status;
3956         }
3957
3958         if (NT_STATUS_IS_ERR(status)) {
3959                 return status;
3960         }
3961
3962         /* Return variables */
3963         *info = *r.out.info;
3964
3965         /* Return result */
3966         return r.out.result;
3967 }
3968
3969 struct rpccli_lsa_SetInformationTrustedDomain_state {
3970         struct lsa_SetInformationTrustedDomain orig;
3971         struct lsa_SetInformationTrustedDomain tmp;
3972         TALLOC_CTX *out_mem_ctx;
3973         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3974 };
3975
3976 static void rpccli_lsa_SetInformationTrustedDomain_done(struct tevent_req *subreq);
3977
3978 struct tevent_req *rpccli_lsa_SetInformationTrustedDomain_send(TALLOC_CTX *mem_ctx,
3979                                                                struct tevent_context *ev,
3980                                                                struct rpc_pipe_client *cli,
3981                                                                struct policy_handle *_trustdom_handle /* [in] [ref] */,
3982                                                                enum lsa_TrustDomInfoEnum _level /* [in]  */,
3983                                                                union lsa_TrustedDomainInfo *_info /* [in] [ref,switch_is(level)] */)
3984 {
3985         struct tevent_req *req;
3986         struct rpccli_lsa_SetInformationTrustedDomain_state *state;
3987         struct tevent_req *subreq;
3988
3989         req = tevent_req_create(mem_ctx, &state,
3990                                 struct rpccli_lsa_SetInformationTrustedDomain_state);
3991         if (req == NULL) {
3992                 return NULL;
3993         }
3994         state->out_mem_ctx = NULL;
3995         state->dispatch_recv = cli->dispatch_recv;
3996
3997         /* In parameters */
3998         state->orig.in.trustdom_handle = _trustdom_handle;
3999         state->orig.in.level = _level;
4000         state->orig.in.info = _info;
4001
4002         /* Out parameters */
4003
4004         /* Result */
4005         ZERO_STRUCT(state->orig.out.result);
4006
4007         /* make a temporary copy, that we pass to the dispatch function */
4008         state->tmp = state->orig;
4009
4010         subreq = cli->dispatch_send(state, ev, cli,
4011                                     &ndr_table_lsarpc,
4012                                     NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN,
4013                                     &state->tmp);
4014         if (tevent_req_nomem(subreq, req)) {
4015                 return tevent_req_post(req, ev);
4016         }
4017         tevent_req_set_callback(subreq, rpccli_lsa_SetInformationTrustedDomain_done, req);
4018         return req;
4019 }
4020
4021 static void rpccli_lsa_SetInformationTrustedDomain_done(struct tevent_req *subreq)
4022 {
4023         struct tevent_req *req = tevent_req_callback_data(
4024                 subreq, struct tevent_req);
4025         struct rpccli_lsa_SetInformationTrustedDomain_state *state = tevent_req_data(
4026                 req, struct rpccli_lsa_SetInformationTrustedDomain_state);
4027         NTSTATUS status;
4028         TALLOC_CTX *mem_ctx;
4029
4030         if (state->out_mem_ctx) {
4031                 mem_ctx = state->out_mem_ctx;
4032         } else {
4033                 mem_ctx = state;
4034         }
4035
4036         status = state->dispatch_recv(subreq, mem_ctx);
4037         TALLOC_FREE(subreq);
4038         if (!NT_STATUS_IS_OK(status)) {
4039                 tevent_req_nterror(req, status);
4040                 return;
4041         }
4042
4043         /* Copy out parameters */
4044
4045         /* Copy result */
4046         state->orig.out.result = state->tmp.out.result;
4047
4048         /* Reset temporary structure */
4049         ZERO_STRUCT(state->tmp);
4050
4051         tevent_req_done(req);
4052 }
4053
4054 NTSTATUS rpccli_lsa_SetInformationTrustedDomain_recv(struct tevent_req *req,
4055                                                      TALLOC_CTX *mem_ctx,
4056                                                      NTSTATUS *result)
4057 {
4058         struct rpccli_lsa_SetInformationTrustedDomain_state *state = tevent_req_data(
4059                 req, struct rpccli_lsa_SetInformationTrustedDomain_state);
4060         NTSTATUS status;
4061
4062         if (tevent_req_is_nterror(req, &status)) {
4063                 tevent_req_received(req);
4064                 return status;
4065         }
4066
4067         /* Steal possbile out parameters to the callers context */
4068         talloc_steal(mem_ctx, state->out_mem_ctx);
4069
4070         /* Return result */
4071         *result = state->orig.out.result;
4072
4073         tevent_req_received(req);
4074         return NT_STATUS_OK;
4075 }
4076
4077 NTSTATUS rpccli_lsa_SetInformationTrustedDomain(struct rpc_pipe_client *cli,
4078                                                 TALLOC_CTX *mem_ctx,
4079                                                 struct policy_handle *trustdom_handle /* [in] [ref] */,
4080                                                 enum lsa_TrustDomInfoEnum level /* [in]  */,
4081                                                 union lsa_TrustedDomainInfo *info /* [in] [ref,switch_is(level)] */)
4082 {
4083         struct lsa_SetInformationTrustedDomain r;
4084         NTSTATUS status;
4085
4086         /* In parameters */
4087         r.in.trustdom_handle = trustdom_handle;
4088         r.in.level = level;
4089         r.in.info = info;
4090
4091         status = cli->dispatch(cli,
4092                                 mem_ctx,
4093                                 &ndr_table_lsarpc,
4094                                 NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN,
4095                                 &r);
4096
4097         if (!NT_STATUS_IS_OK(status)) {
4098                 return status;
4099         }
4100
4101         if (NT_STATUS_IS_ERR(status)) {
4102                 return status;
4103         }
4104
4105         /* Return variables */
4106
4107         /* Return result */
4108         return r.out.result;
4109 }
4110
4111 struct rpccli_lsa_OpenSecret_state {
4112         struct lsa_OpenSecret orig;
4113         struct lsa_OpenSecret tmp;
4114         TALLOC_CTX *out_mem_ctx;
4115         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4116 };
4117
4118 static void rpccli_lsa_OpenSecret_done(struct tevent_req *subreq);
4119
4120 struct tevent_req *rpccli_lsa_OpenSecret_send(TALLOC_CTX *mem_ctx,
4121                                               struct tevent_context *ev,
4122                                               struct rpc_pipe_client *cli,
4123                                               struct policy_handle *_handle /* [in] [ref] */,
4124                                               struct lsa_String _name /* [in]  */,
4125                                               uint32_t _access_mask /* [in]  */,
4126                                               struct policy_handle *_sec_handle /* [out] [ref] */)
4127 {
4128         struct tevent_req *req;
4129         struct rpccli_lsa_OpenSecret_state *state;
4130         struct tevent_req *subreq;
4131
4132         req = tevent_req_create(mem_ctx, &state,
4133                                 struct rpccli_lsa_OpenSecret_state);
4134         if (req == NULL) {
4135                 return NULL;
4136         }
4137         state->out_mem_ctx = NULL;
4138         state->dispatch_recv = cli->dispatch_recv;
4139
4140         /* In parameters */
4141         state->orig.in.handle = _handle;
4142         state->orig.in.name = _name;
4143         state->orig.in.access_mask = _access_mask;
4144
4145         /* Out parameters */
4146         state->orig.out.sec_handle = _sec_handle;
4147
4148         /* Result */
4149         ZERO_STRUCT(state->orig.out.result);
4150
4151         state->out_mem_ctx = talloc_named_const(state, 0,
4152                              "rpccli_lsa_OpenSecret_out_memory");
4153         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4154                 return tevent_req_post(req, ev);
4155         }
4156
4157         /* make a temporary copy, that we pass to the dispatch function */
4158         state->tmp = state->orig;
4159
4160         subreq = cli->dispatch_send(state, ev, cli,
4161                                     &ndr_table_lsarpc,
4162                                     NDR_LSA_OPENSECRET,
4163                                     &state->tmp);
4164         if (tevent_req_nomem(subreq, req)) {
4165                 return tevent_req_post(req, ev);
4166         }
4167         tevent_req_set_callback(subreq, rpccli_lsa_OpenSecret_done, req);
4168         return req;
4169 }
4170
4171 static void rpccli_lsa_OpenSecret_done(struct tevent_req *subreq)
4172 {
4173         struct tevent_req *req = tevent_req_callback_data(
4174                 subreq, struct tevent_req);
4175         struct rpccli_lsa_OpenSecret_state *state = tevent_req_data(
4176                 req, struct rpccli_lsa_OpenSecret_state);
4177         NTSTATUS status;
4178         TALLOC_CTX *mem_ctx;
4179
4180         if (state->out_mem_ctx) {
4181                 mem_ctx = state->out_mem_ctx;
4182         } else {
4183                 mem_ctx = state;
4184         }
4185
4186         status = state->dispatch_recv(subreq, mem_ctx);
4187         TALLOC_FREE(subreq);
4188         if (!NT_STATUS_IS_OK(status)) {
4189                 tevent_req_nterror(req, status);
4190                 return;
4191         }
4192
4193         /* Copy out parameters */
4194         *state->orig.out.sec_handle = *state->tmp.out.sec_handle;
4195
4196         /* Copy result */
4197         state->orig.out.result = state->tmp.out.result;
4198
4199         /* Reset temporary structure */
4200         ZERO_STRUCT(state->tmp);
4201
4202         tevent_req_done(req);
4203 }
4204
4205 NTSTATUS rpccli_lsa_OpenSecret_recv(struct tevent_req *req,
4206                                     TALLOC_CTX *mem_ctx,
4207                                     NTSTATUS *result)
4208 {
4209         struct rpccli_lsa_OpenSecret_state *state = tevent_req_data(
4210                 req, struct rpccli_lsa_OpenSecret_state);
4211         NTSTATUS status;
4212
4213         if (tevent_req_is_nterror(req, &status)) {
4214                 tevent_req_received(req);
4215                 return status;
4216         }
4217
4218         /* Steal possbile out parameters to the callers context */
4219         talloc_steal(mem_ctx, state->out_mem_ctx);
4220
4221         /* Return result */
4222         *result = state->orig.out.result;
4223
4224         tevent_req_received(req);
4225         return NT_STATUS_OK;
4226 }
4227
4228 NTSTATUS rpccli_lsa_OpenSecret(struct rpc_pipe_client *cli,
4229                                TALLOC_CTX *mem_ctx,
4230                                struct policy_handle *handle /* [in] [ref] */,
4231                                struct lsa_String name /* [in]  */,
4232                                uint32_t access_mask /* [in]  */,
4233                                struct policy_handle *sec_handle /* [out] [ref] */)
4234 {
4235         struct lsa_OpenSecret r;
4236         NTSTATUS status;
4237
4238         /* In parameters */
4239         r.in.handle = handle;
4240         r.in.name = name;
4241         r.in.access_mask = access_mask;
4242
4243         status = cli->dispatch(cli,
4244                                 mem_ctx,
4245                                 &ndr_table_lsarpc,
4246                                 NDR_LSA_OPENSECRET,
4247                                 &r);
4248
4249         if (!NT_STATUS_IS_OK(status)) {
4250                 return status;
4251         }
4252
4253         if (NT_STATUS_IS_ERR(status)) {
4254                 return status;
4255         }
4256
4257         /* Return variables */
4258         *sec_handle = *r.out.sec_handle;
4259
4260         /* Return result */
4261         return r.out.result;
4262 }
4263
4264 struct rpccli_lsa_SetSecret_state {
4265         struct lsa_SetSecret orig;
4266         struct lsa_SetSecret tmp;
4267         TALLOC_CTX *out_mem_ctx;
4268         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4269 };
4270
4271 static void rpccli_lsa_SetSecret_done(struct tevent_req *subreq);
4272
4273 struct tevent_req *rpccli_lsa_SetSecret_send(TALLOC_CTX *mem_ctx,
4274                                              struct tevent_context *ev,
4275                                              struct rpc_pipe_client *cli,
4276                                              struct policy_handle *_sec_handle /* [in] [ref] */,
4277                                              struct lsa_DATA_BUF *_new_val /* [in] [unique] */,
4278                                              struct lsa_DATA_BUF *_old_val /* [in] [unique] */)
4279 {
4280         struct tevent_req *req;
4281         struct rpccli_lsa_SetSecret_state *state;
4282         struct tevent_req *subreq;
4283
4284         req = tevent_req_create(mem_ctx, &state,
4285                                 struct rpccli_lsa_SetSecret_state);
4286         if (req == NULL) {
4287                 return NULL;
4288         }
4289         state->out_mem_ctx = NULL;
4290         state->dispatch_recv = cli->dispatch_recv;
4291
4292         /* In parameters */
4293         state->orig.in.sec_handle = _sec_handle;
4294         state->orig.in.new_val = _new_val;
4295         state->orig.in.old_val = _old_val;
4296
4297         /* Out parameters */
4298
4299         /* Result */
4300         ZERO_STRUCT(state->orig.out.result);
4301
4302         /* make a temporary copy, that we pass to the dispatch function */
4303         state->tmp = state->orig;
4304
4305         subreq = cli->dispatch_send(state, ev, cli,
4306                                     &ndr_table_lsarpc,
4307                                     NDR_LSA_SETSECRET,
4308                                     &state->tmp);
4309         if (tevent_req_nomem(subreq, req)) {
4310                 return tevent_req_post(req, ev);
4311         }
4312         tevent_req_set_callback(subreq, rpccli_lsa_SetSecret_done, req);
4313         return req;
4314 }
4315
4316 static void rpccli_lsa_SetSecret_done(struct tevent_req *subreq)
4317 {
4318         struct tevent_req *req = tevent_req_callback_data(
4319                 subreq, struct tevent_req);
4320         struct rpccli_lsa_SetSecret_state *state = tevent_req_data(
4321                 req, struct rpccli_lsa_SetSecret_state);
4322         NTSTATUS status;
4323         TALLOC_CTX *mem_ctx;
4324
4325         if (state->out_mem_ctx) {
4326                 mem_ctx = state->out_mem_ctx;
4327         } else {
4328                 mem_ctx = state;
4329         }
4330
4331         status = state->dispatch_recv(subreq, mem_ctx);
4332         TALLOC_FREE(subreq);
4333         if (!NT_STATUS_IS_OK(status)) {
4334                 tevent_req_nterror(req, status);
4335                 return;
4336         }
4337
4338         /* Copy out parameters */
4339
4340         /* Copy result */
4341         state->orig.out.result = state->tmp.out.result;
4342
4343         /* Reset temporary structure */
4344         ZERO_STRUCT(state->tmp);
4345
4346         tevent_req_done(req);
4347 }
4348
4349 NTSTATUS rpccli_lsa_SetSecret_recv(struct tevent_req *req,
4350                                    TALLOC_CTX *mem_ctx,
4351                                    NTSTATUS *result)
4352 {
4353         struct rpccli_lsa_SetSecret_state *state = tevent_req_data(
4354                 req, struct rpccli_lsa_SetSecret_state);
4355         NTSTATUS status;
4356
4357         if (tevent_req_is_nterror(req, &status)) {
4358                 tevent_req_received(req);
4359                 return status;
4360         }
4361
4362         /* Steal possbile out parameters to the callers context */
4363         talloc_steal(mem_ctx, state->out_mem_ctx);
4364
4365         /* Return result */
4366         *result = state->orig.out.result;
4367
4368         tevent_req_received(req);
4369         return NT_STATUS_OK;
4370 }
4371
4372 NTSTATUS rpccli_lsa_SetSecret(struct rpc_pipe_client *cli,
4373                               TALLOC_CTX *mem_ctx,
4374                               struct policy_handle *sec_handle /* [in] [ref] */,
4375                               struct lsa_DATA_BUF *new_val /* [in] [unique] */,
4376                               struct lsa_DATA_BUF *old_val /* [in] [unique] */)
4377 {
4378         struct lsa_SetSecret r;
4379         NTSTATUS status;
4380
4381         /* In parameters */
4382         r.in.sec_handle = sec_handle;
4383         r.in.new_val = new_val;
4384         r.in.old_val = old_val;
4385
4386         status = cli->dispatch(cli,
4387                                 mem_ctx,
4388                                 &ndr_table_lsarpc,
4389                                 NDR_LSA_SETSECRET,
4390                                 &r);
4391
4392         if (!NT_STATUS_IS_OK(status)) {
4393                 return status;
4394         }
4395
4396         if (NT_STATUS_IS_ERR(status)) {
4397                 return status;
4398         }
4399
4400         /* Return variables */
4401
4402         /* Return result */
4403         return r.out.result;
4404 }
4405
4406 struct rpccli_lsa_QuerySecret_state {
4407         struct lsa_QuerySecret orig;
4408         struct lsa_QuerySecret tmp;
4409         TALLOC_CTX *out_mem_ctx;
4410         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4411 };
4412
4413 static void rpccli_lsa_QuerySecret_done(struct tevent_req *subreq);
4414
4415 struct tevent_req *rpccli_lsa_QuerySecret_send(TALLOC_CTX *mem_ctx,
4416                                                struct tevent_context *ev,
4417                                                struct rpc_pipe_client *cli,
4418                                                struct policy_handle *_sec_handle /* [in] [ref] */,
4419                                                struct lsa_DATA_BUF_PTR *_new_val /* [in,out] [unique] */,
4420                                                NTTIME *_new_mtime /* [in,out] [unique] */,
4421                                                struct lsa_DATA_BUF_PTR *_old_val /* [in,out] [unique] */,
4422                                                NTTIME *_old_mtime /* [in,out] [unique] */)
4423 {
4424         struct tevent_req *req;
4425         struct rpccli_lsa_QuerySecret_state *state;
4426         struct tevent_req *subreq;
4427
4428         req = tevent_req_create(mem_ctx, &state,
4429                                 struct rpccli_lsa_QuerySecret_state);
4430         if (req == NULL) {
4431                 return NULL;
4432         }
4433         state->out_mem_ctx = NULL;
4434         state->dispatch_recv = cli->dispatch_recv;
4435
4436         /* In parameters */
4437         state->orig.in.sec_handle = _sec_handle;
4438         state->orig.in.new_val = _new_val;
4439         state->orig.in.new_mtime = _new_mtime;
4440         state->orig.in.old_val = _old_val;
4441         state->orig.in.old_mtime = _old_mtime;
4442
4443         /* Out parameters */
4444         state->orig.out.new_val = _new_val;
4445         state->orig.out.new_mtime = _new_mtime;
4446         state->orig.out.old_val = _old_val;
4447         state->orig.out.old_mtime = _old_mtime;
4448
4449         /* Result */
4450         ZERO_STRUCT(state->orig.out.result);
4451
4452         state->out_mem_ctx = talloc_named_const(state, 0,
4453                              "rpccli_lsa_QuerySecret_out_memory");
4454         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4455                 return tevent_req_post(req, ev);
4456         }
4457
4458         /* make a temporary copy, that we pass to the dispatch function */
4459         state->tmp = state->orig;
4460
4461         subreq = cli->dispatch_send(state, ev, cli,
4462                                     &ndr_table_lsarpc,
4463                                     NDR_LSA_QUERYSECRET,
4464                                     &state->tmp);
4465         if (tevent_req_nomem(subreq, req)) {
4466                 return tevent_req_post(req, ev);
4467         }
4468         tevent_req_set_callback(subreq, rpccli_lsa_QuerySecret_done, req);
4469         return req;
4470 }
4471
4472 static void rpccli_lsa_QuerySecret_done(struct tevent_req *subreq)
4473 {
4474         struct tevent_req *req = tevent_req_callback_data(
4475                 subreq, struct tevent_req);
4476         struct rpccli_lsa_QuerySecret_state *state = tevent_req_data(
4477                 req, struct rpccli_lsa_QuerySecret_state);
4478         NTSTATUS status;
4479         TALLOC_CTX *mem_ctx;
4480
4481         if (state->out_mem_ctx) {
4482                 mem_ctx = state->out_mem_ctx;
4483         } else {
4484                 mem_ctx = state;
4485         }
4486
4487         status = state->dispatch_recv(subreq, mem_ctx);
4488         TALLOC_FREE(subreq);
4489         if (!NT_STATUS_IS_OK(status)) {
4490                 tevent_req_nterror(req, status);
4491                 return;
4492         }
4493
4494         /* Copy out parameters */
4495         if (state->orig.out.new_val && state->tmp.out.new_val) {
4496                 *state->orig.out.new_val = *state->tmp.out.new_val;
4497         }
4498         if (state->orig.out.new_mtime && state->tmp.out.new_mtime) {
4499                 *state->orig.out.new_mtime = *state->tmp.out.new_mtime;
4500         }
4501         if (state->orig.out.old_val && state->tmp.out.old_val) {
4502                 *state->orig.out.old_val = *state->tmp.out.old_val;
4503         }
4504         if (state->orig.out.old_mtime && state->tmp.out.old_mtime) {
4505                 *state->orig.out.old_mtime = *state->tmp.out.old_mtime;
4506         }
4507
4508         /* Copy result */
4509         state->orig.out.result = state->tmp.out.result;
4510
4511         /* Reset temporary structure */
4512         ZERO_STRUCT(state->tmp);
4513
4514         tevent_req_done(req);
4515 }
4516
4517 NTSTATUS rpccli_lsa_QuerySecret_recv(struct tevent_req *req,
4518                                      TALLOC_CTX *mem_ctx,
4519                                      NTSTATUS *result)
4520 {
4521         struct rpccli_lsa_QuerySecret_state *state = tevent_req_data(
4522                 req, struct rpccli_lsa_QuerySecret_state);
4523         NTSTATUS status;
4524
4525         if (tevent_req_is_nterror(req, &status)) {
4526                 tevent_req_received(req);
4527                 return status;
4528         }
4529
4530         /* Steal possbile out parameters to the callers context */
4531         talloc_steal(mem_ctx, state->out_mem_ctx);
4532
4533         /* Return result */
4534         *result = state->orig.out.result;
4535
4536         tevent_req_received(req);
4537         return NT_STATUS_OK;
4538 }
4539
4540 NTSTATUS rpccli_lsa_QuerySecret(struct rpc_pipe_client *cli,
4541                                 TALLOC_CTX *mem_ctx,
4542                                 struct policy_handle *sec_handle /* [in] [ref] */,
4543                                 struct lsa_DATA_BUF_PTR *new_val /* [in,out] [unique] */,
4544                                 NTTIME *new_mtime /* [in,out] [unique] */,
4545                                 struct lsa_DATA_BUF_PTR *old_val /* [in,out] [unique] */,
4546                                 NTTIME *old_mtime /* [in,out] [unique] */)
4547 {
4548         struct lsa_QuerySecret r;
4549         NTSTATUS status;
4550
4551         /* In parameters */
4552         r.in.sec_handle = sec_handle;
4553         r.in.new_val = new_val;
4554         r.in.new_mtime = new_mtime;
4555         r.in.old_val = old_val;
4556         r.in.old_mtime = old_mtime;
4557
4558         status = cli->dispatch(cli,
4559                                 mem_ctx,
4560                                 &ndr_table_lsarpc,
4561                                 NDR_LSA_QUERYSECRET,
4562                                 &r);
4563
4564         if (!NT_STATUS_IS_OK(status)) {
4565                 return status;
4566         }
4567
4568         if (NT_STATUS_IS_ERR(status)) {
4569                 return status;
4570         }
4571
4572         /* Return variables */
4573         if (new_val && r.out.new_val) {
4574                 *new_val = *r.out.new_val;
4575         }
4576         if (new_mtime && r.out.new_mtime) {
4577                 *new_mtime = *r.out.new_mtime;
4578         }
4579         if (old_val && r.out.old_val) {
4580                 *old_val = *r.out.old_val;
4581         }
4582         if (old_mtime && r.out.old_mtime) {
4583                 *old_mtime = *r.out.old_mtime;
4584         }
4585
4586         /* Return result */
4587         return r.out.result;
4588 }
4589
4590 struct rpccli_lsa_LookupPrivValue_state {
4591         struct lsa_LookupPrivValue orig;
4592         struct lsa_LookupPrivValue tmp;
4593         TALLOC_CTX *out_mem_ctx;
4594         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4595 };
4596
4597 static void rpccli_lsa_LookupPrivValue_done(struct tevent_req *subreq);
4598
4599 struct tevent_req *rpccli_lsa_LookupPrivValue_send(TALLOC_CTX *mem_ctx,
4600                                                    struct tevent_context *ev,
4601                                                    struct rpc_pipe_client *cli,
4602                                                    struct policy_handle *_handle /* [in] [ref] */,
4603                                                    struct lsa_String *_name /* [in] [ref] */,
4604                                                    struct lsa_LUID *_luid /* [out] [ref] */)
4605 {
4606         struct tevent_req *req;
4607         struct rpccli_lsa_LookupPrivValue_state *state;
4608         struct tevent_req *subreq;
4609
4610         req = tevent_req_create(mem_ctx, &state,
4611                                 struct rpccli_lsa_LookupPrivValue_state);
4612         if (req == NULL) {
4613                 return NULL;
4614         }
4615         state->out_mem_ctx = NULL;
4616         state->dispatch_recv = cli->dispatch_recv;
4617
4618         /* In parameters */
4619         state->orig.in.handle = _handle;
4620         state->orig.in.name = _name;
4621
4622         /* Out parameters */
4623         state->orig.out.luid = _luid;
4624
4625         /* Result */
4626         ZERO_STRUCT(state->orig.out.result);
4627
4628         state->out_mem_ctx = talloc_named_const(state, 0,
4629                              "rpccli_lsa_LookupPrivValue_out_memory");
4630         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4631                 return tevent_req_post(req, ev);
4632         }
4633
4634         /* make a temporary copy, that we pass to the dispatch function */
4635         state->tmp = state->orig;
4636
4637         subreq = cli->dispatch_send(state, ev, cli,
4638                                     &ndr_table_lsarpc,
4639                                     NDR_LSA_LOOKUPPRIVVALUE,
4640                                     &state->tmp);
4641         if (tevent_req_nomem(subreq, req)) {
4642                 return tevent_req_post(req, ev);
4643         }
4644         tevent_req_set_callback(subreq, rpccli_lsa_LookupPrivValue_done, req);
4645         return req;
4646 }
4647
4648 static void rpccli_lsa_LookupPrivValue_done(struct tevent_req *subreq)
4649 {
4650         struct tevent_req *req = tevent_req_callback_data(
4651                 subreq, struct tevent_req);
4652         struct rpccli_lsa_LookupPrivValue_state *state = tevent_req_data(
4653                 req, struct rpccli_lsa_LookupPrivValue_state);
4654         NTSTATUS status;
4655         TALLOC_CTX *mem_ctx;
4656
4657         if (state->out_mem_ctx) {
4658                 mem_ctx = state->out_mem_ctx;
4659         } else {
4660                 mem_ctx = state;
4661         }
4662
4663         status = state->dispatch_recv(subreq, mem_ctx);
4664         TALLOC_FREE(subreq);
4665         if (!NT_STATUS_IS_OK(status)) {
4666                 tevent_req_nterror(req, status);
4667                 return;
4668         }
4669
4670         /* Copy out parameters */
4671         *state->orig.out.luid = *state->tmp.out.luid;
4672
4673         /* Copy result */
4674         state->orig.out.result = state->tmp.out.result;
4675
4676         /* Reset temporary structure */
4677         ZERO_STRUCT(state->tmp);
4678
4679         tevent_req_done(req);
4680 }
4681
4682 NTSTATUS rpccli_lsa_LookupPrivValue_recv(struct tevent_req *req,
4683                                          TALLOC_CTX *mem_ctx,
4684                                          NTSTATUS *result)
4685 {
4686         struct rpccli_lsa_LookupPrivValue_state *state = tevent_req_data(
4687                 req, struct rpccli_lsa_LookupPrivValue_state);
4688         NTSTATUS status;
4689
4690         if (tevent_req_is_nterror(req, &status)) {
4691                 tevent_req_received(req);
4692                 return status;
4693         }
4694
4695         /* Steal possbile out parameters to the callers context */
4696         talloc_steal(mem_ctx, state->out_mem_ctx);
4697
4698         /* Return result */
4699         *result = state->orig.out.result;
4700
4701         tevent_req_received(req);
4702         return NT_STATUS_OK;
4703 }
4704
4705 NTSTATUS rpccli_lsa_LookupPrivValue(struct rpc_pipe_client *cli,
4706                                     TALLOC_CTX *mem_ctx,
4707                                     struct policy_handle *handle /* [in] [ref] */,
4708                                     struct lsa_String *name /* [in] [ref] */,
4709                                     struct lsa_LUID *luid /* [out] [ref] */)
4710 {
4711         struct lsa_LookupPrivValue r;
4712         NTSTATUS status;
4713
4714         /* In parameters */
4715         r.in.handle = handle;
4716         r.in.name = name;
4717
4718         status = cli->dispatch(cli,
4719                                 mem_ctx,
4720                                 &ndr_table_lsarpc,
4721                                 NDR_LSA_LOOKUPPRIVVALUE,
4722                                 &r);
4723
4724         if (!NT_STATUS_IS_OK(status)) {
4725                 return status;
4726         }
4727
4728         if (NT_STATUS_IS_ERR(status)) {
4729                 return status;
4730         }
4731
4732         /* Return variables */
4733         *luid = *r.out.luid;
4734
4735         /* Return result */
4736         return r.out.result;
4737 }
4738
4739 struct rpccli_lsa_LookupPrivName_state {
4740         struct lsa_LookupPrivName orig;
4741         struct lsa_LookupPrivName tmp;
4742         TALLOC_CTX *out_mem_ctx;
4743         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4744 };
4745
4746 static void rpccli_lsa_LookupPrivName_done(struct tevent_req *subreq);
4747
4748 struct tevent_req *rpccli_lsa_LookupPrivName_send(TALLOC_CTX *mem_ctx,
4749                                                   struct tevent_context *ev,
4750                                                   struct rpc_pipe_client *cli,
4751                                                   struct policy_handle *_handle /* [in] [ref] */,
4752                                                   struct lsa_LUID *_luid /* [in] [ref] */,
4753                                                   struct lsa_StringLarge **_name /* [out] [ref] */)
4754 {
4755         struct tevent_req *req;
4756         struct rpccli_lsa_LookupPrivName_state *state;
4757         struct tevent_req *subreq;
4758
4759         req = tevent_req_create(mem_ctx, &state,
4760                                 struct rpccli_lsa_LookupPrivName_state);
4761         if (req == NULL) {
4762                 return NULL;
4763         }
4764         state->out_mem_ctx = NULL;
4765         state->dispatch_recv = cli->dispatch_recv;
4766
4767         /* In parameters */
4768         state->orig.in.handle = _handle;
4769         state->orig.in.luid = _luid;
4770
4771         /* Out parameters */
4772         state->orig.out.name = _name;
4773
4774         /* Result */
4775         ZERO_STRUCT(state->orig.out.result);
4776
4777         state->out_mem_ctx = talloc_named_const(state, 0,
4778                              "rpccli_lsa_LookupPrivName_out_memory");
4779         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4780                 return tevent_req_post(req, ev);
4781         }
4782
4783         /* make a temporary copy, that we pass to the dispatch function */
4784         state->tmp = state->orig;
4785
4786         subreq = cli->dispatch_send(state, ev, cli,
4787                                     &ndr_table_lsarpc,
4788                                     NDR_LSA_LOOKUPPRIVNAME,
4789                                     &state->tmp);
4790         if (tevent_req_nomem(subreq, req)) {
4791                 return tevent_req_post(req, ev);
4792         }
4793         tevent_req_set_callback(subreq, rpccli_lsa_LookupPrivName_done, req);
4794         return req;
4795 }
4796
4797 static void rpccli_lsa_LookupPrivName_done(struct tevent_req *subreq)
4798 {
4799         struct tevent_req *req = tevent_req_callback_data(
4800                 subreq, struct tevent_req);
4801         struct rpccli_lsa_LookupPrivName_state *state = tevent_req_data(
4802                 req, struct rpccli_lsa_LookupPrivName_state);
4803         NTSTATUS status;
4804         TALLOC_CTX *mem_ctx;
4805
4806         if (state->out_mem_ctx) {
4807                 mem_ctx = state->out_mem_ctx;
4808         } else {
4809                 mem_ctx = state;
4810         }
4811
4812         status = state->dispatch_recv(subreq, mem_ctx);
4813         TALLOC_FREE(subreq);
4814         if (!NT_STATUS_IS_OK(status)) {
4815                 tevent_req_nterror(req, status);
4816                 return;
4817         }
4818
4819         /* Copy out parameters */
4820         *state->orig.out.name = *state->tmp.out.name;
4821
4822         /* Copy result */
4823         state->orig.out.result = state->tmp.out.result;
4824
4825         /* Reset temporary structure */
4826         ZERO_STRUCT(state->tmp);
4827
4828         tevent_req_done(req);
4829 }
4830
4831 NTSTATUS rpccli_lsa_LookupPrivName_recv(struct tevent_req *req,
4832                                         TALLOC_CTX *mem_ctx,
4833                                         NTSTATUS *result)
4834 {
4835         struct rpccli_lsa_LookupPrivName_state *state = tevent_req_data(
4836                 req, struct rpccli_lsa_LookupPrivName_state);
4837         NTSTATUS status;
4838
4839         if (tevent_req_is_nterror(req, &status)) {
4840                 tevent_req_received(req);
4841                 return status;
4842         }
4843
4844         /* Steal possbile out parameters to the callers context */
4845         talloc_steal(mem_ctx, state->out_mem_ctx);
4846
4847         /* Return result */
4848         *result = state->orig.out.result;
4849
4850         tevent_req_received(req);
4851         return NT_STATUS_OK;
4852 }
4853
4854 NTSTATUS rpccli_lsa_LookupPrivName(struct rpc_pipe_client *cli,
4855                                    TALLOC_CTX *mem_ctx,
4856                                    struct policy_handle *handle /* [in] [ref] */,
4857                                    struct lsa_LUID *luid /* [in] [ref] */,
4858                                    struct lsa_StringLarge **name /* [out] [ref] */)
4859 {
4860         struct lsa_LookupPrivName r;
4861         NTSTATUS status;
4862
4863         /* In parameters */
4864         r.in.handle = handle;
4865         r.in.luid = luid;
4866
4867         status = cli->dispatch(cli,
4868                                 mem_ctx,
4869                                 &ndr_table_lsarpc,
4870                                 NDR_LSA_LOOKUPPRIVNAME,
4871                                 &r);
4872
4873         if (!NT_STATUS_IS_OK(status)) {
4874                 return status;
4875         }
4876
4877         if (NT_STATUS_IS_ERR(status)) {
4878                 return status;
4879         }
4880
4881         /* Return variables */
4882         *name = *r.out.name;
4883
4884         /* Return result */
4885         return r.out.result;
4886 }
4887
4888 struct rpccli_lsa_LookupPrivDisplayName_state {
4889         struct lsa_LookupPrivDisplayName orig;
4890         struct lsa_LookupPrivDisplayName tmp;
4891         TALLOC_CTX *out_mem_ctx;
4892         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4893 };
4894
4895 static void rpccli_lsa_LookupPrivDisplayName_done(struct tevent_req *subreq);
4896
4897 struct tevent_req *rpccli_lsa_LookupPrivDisplayName_send(TALLOC_CTX *mem_ctx,
4898                                                          struct tevent_context *ev,
4899                                                          struct rpc_pipe_client *cli,
4900                                                          struct policy_handle *_handle /* [in] [ref] */,
4901                                                          struct lsa_String *_name /* [in] [ref] */,
4902                                                          uint16_t _language_id /* [in]  */,
4903                                                          uint16_t _language_id_sys /* [in]  */,
4904                                                          struct lsa_StringLarge **_disp_name /* [out] [ref] */,
4905                                                          uint16_t *_returned_language_id /* [out] [ref] */)
4906 {
4907         struct tevent_req *req;
4908         struct rpccli_lsa_LookupPrivDisplayName_state *state;
4909         struct tevent_req *subreq;
4910
4911         req = tevent_req_create(mem_ctx, &state,
4912                                 struct rpccli_lsa_LookupPrivDisplayName_state);
4913         if (req == NULL) {
4914                 return NULL;
4915         }
4916         state->out_mem_ctx = NULL;
4917         state->dispatch_recv = cli->dispatch_recv;
4918
4919         /* In parameters */
4920         state->orig.in.handle = _handle;
4921         state->orig.in.name = _name;
4922         state->orig.in.language_id = _language_id;
4923         state->orig.in.language_id_sys = _language_id_sys;
4924
4925         /* Out parameters */
4926         state->orig.out.disp_name = _disp_name;
4927         state->orig.out.returned_language_id = _returned_language_id;
4928
4929         /* Result */
4930         ZERO_STRUCT(state->orig.out.result);
4931
4932         state->out_mem_ctx = talloc_named_const(state, 0,
4933                              "rpccli_lsa_LookupPrivDisplayName_out_memory");
4934         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4935                 return tevent_req_post(req, ev);
4936         }
4937
4938         /* make a temporary copy, that we pass to the dispatch function */
4939         state->tmp = state->orig;
4940
4941         subreq = cli->dispatch_send(state, ev, cli,
4942                                     &ndr_table_lsarpc,
4943                                     NDR_LSA_LOOKUPPRIVDISPLAYNAME,
4944                                     &state->tmp);
4945         if (tevent_req_nomem(subreq, req)) {
4946                 return tevent_req_post(req, ev);
4947         }
4948         tevent_req_set_callback(subreq, rpccli_lsa_LookupPrivDisplayName_done, req);
4949         return req;
4950 }
4951
4952 static void rpccli_lsa_LookupPrivDisplayName_done(struct tevent_req *subreq)
4953 {
4954         struct tevent_req *req = tevent_req_callback_data(
4955                 subreq, struct tevent_req);
4956         struct rpccli_lsa_LookupPrivDisplayName_state *state = tevent_req_data(
4957                 req, struct rpccli_lsa_LookupPrivDisplayName_state);
4958         NTSTATUS status;
4959         TALLOC_CTX *mem_ctx;
4960
4961         if (state->out_mem_ctx) {
4962                 mem_ctx = state->out_mem_ctx;
4963         } else {
4964                 mem_ctx = state;
4965         }
4966
4967         status = state->dispatch_recv(subreq, mem_ctx);
4968         TALLOC_FREE(subreq);
4969         if (!NT_STATUS_IS_OK(status)) {
4970                 tevent_req_nterror(req, status);
4971                 return;
4972         }
4973
4974         /* Copy out parameters */
4975         *state->orig.out.disp_name = *state->tmp.out.disp_name;
4976         *state->orig.out.returned_language_id = *state->tmp.out.returned_language_id;
4977
4978         /* Copy result */
4979         state->orig.out.result = state->tmp.out.result;
4980
4981         /* Reset temporary structure */
4982         ZERO_STRUCT(state->tmp);
4983
4984         tevent_req_done(req);
4985 }
4986
4987 NTSTATUS rpccli_lsa_LookupPrivDisplayName_recv(struct tevent_req *req,
4988                                                TALLOC_CTX *mem_ctx,
4989                                                NTSTATUS *result)
4990 {
4991         struct rpccli_lsa_LookupPrivDisplayName_state *state = tevent_req_data(
4992                 req, struct rpccli_lsa_LookupPrivDisplayName_state);
4993         NTSTATUS status;
4994
4995         if (tevent_req_is_nterror(req, &status)) {
4996                 tevent_req_received(req);
4997                 return status;
4998         }
4999
5000         /* Steal possbile out parameters to the callers context */
5001         talloc_steal(mem_ctx, state->out_mem_ctx);
5002
5003         /* Return result */
5004         *result = state->orig.out.result;
5005
5006         tevent_req_received(req);
5007         return NT_STATUS_OK;
5008 }
5009
5010 NTSTATUS rpccli_lsa_LookupPrivDisplayName(struct rpc_pipe_client *cli,
5011                                           TALLOC_CTX *mem_ctx,
5012                                           struct policy_handle *handle /* [in] [ref] */,
5013                                           struct lsa_String *name /* [in] [ref] */,
5014                                           uint16_t language_id /* [in]  */,
5015                                           uint16_t language_id_sys /* [in]  */,
5016                                           struct lsa_StringLarge **disp_name /* [out] [ref] */,
5017                                           uint16_t *returned_language_id /* [out] [ref] */)
5018 {
5019         struct lsa_LookupPrivDisplayName r;
5020         NTSTATUS status;
5021
5022         /* In parameters */
5023         r.in.handle = handle;
5024         r.in.name = name;
5025         r.in.language_id = language_id;
5026         r.in.language_id_sys = language_id_sys;
5027
5028         status = cli->dispatch(cli,
5029                                 mem_ctx,
5030                                 &ndr_table_lsarpc,
5031                                 NDR_LSA_LOOKUPPRIVDISPLAYNAME,
5032                                 &r);
5033
5034         if (!NT_STATUS_IS_OK(status)) {
5035                 return status;
5036         }
5037
5038         if (NT_STATUS_IS_ERR(status)) {
5039                 return status;
5040         }
5041
5042         /* Return variables */
5043         *disp_name = *r.out.disp_name;
5044         *returned_language_id = *r.out.returned_language_id;
5045
5046         /* Return result */
5047         return r.out.result;
5048 }
5049
5050 struct rpccli_lsa_DeleteObject_state {
5051         struct lsa_DeleteObject orig;
5052         struct lsa_DeleteObject tmp;
5053         TALLOC_CTX *out_mem_ctx;
5054         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5055 };
5056
5057 static void rpccli_lsa_DeleteObject_done(struct tevent_req *subreq);
5058
5059 struct tevent_req *rpccli_lsa_DeleteObject_send(TALLOC_CTX *mem_ctx,
5060                                                 struct tevent_context *ev,
5061                                                 struct rpc_pipe_client *cli,
5062                                                 struct policy_handle *_handle /* [in,out] [ref] */)
5063 {
5064         struct tevent_req *req;
5065         struct rpccli_lsa_DeleteObject_state *state;
5066         struct tevent_req *subreq;
5067
5068         req = tevent_req_create(mem_ctx, &state,
5069                                 struct rpccli_lsa_DeleteObject_state);
5070         if (req == NULL) {
5071                 return NULL;
5072         }
5073         state->out_mem_ctx = NULL;
5074         state->dispatch_recv = cli->dispatch_recv;
5075
5076         /* In parameters */
5077         state->orig.in.handle = _handle;
5078
5079         /* Out parameters */
5080         state->orig.out.handle = _handle;
5081
5082         /* Result */
5083         ZERO_STRUCT(state->orig.out.result);
5084
5085         state->out_mem_ctx = talloc_named_const(state, 0,
5086                              "rpccli_lsa_DeleteObject_out_memory");
5087         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5088                 return tevent_req_post(req, ev);
5089         }
5090
5091         /* make a temporary copy, that we pass to the dispatch function */
5092         state->tmp = state->orig;
5093
5094         subreq = cli->dispatch_send(state, ev, cli,
5095                                     &ndr_table_lsarpc,
5096                                     NDR_LSA_DELETEOBJECT,
5097                                     &state->tmp);
5098         if (tevent_req_nomem(subreq, req)) {
5099                 return tevent_req_post(req, ev);
5100         }
5101         tevent_req_set_callback(subreq, rpccli_lsa_DeleteObject_done, req);
5102         return req;
5103 }
5104
5105 static void rpccli_lsa_DeleteObject_done(struct tevent_req *subreq)
5106 {
5107         struct tevent_req *req = tevent_req_callback_data(
5108                 subreq, struct tevent_req);
5109         struct rpccli_lsa_DeleteObject_state *state = tevent_req_data(
5110                 req, struct rpccli_lsa_DeleteObject_state);
5111         NTSTATUS status;
5112         TALLOC_CTX *mem_ctx;
5113
5114         if (state->out_mem_ctx) {
5115                 mem_ctx = state->out_mem_ctx;
5116         } else {
5117                 mem_ctx = state;
5118         }
5119
5120         status = state->dispatch_recv(subreq, mem_ctx);
5121         TALLOC_FREE(subreq);
5122         if (!NT_STATUS_IS_OK(status)) {
5123                 tevent_req_nterror(req, status);
5124                 return;
5125         }
5126
5127         /* Copy out parameters */
5128         *state->orig.out.handle = *state->tmp.out.handle;
5129
5130         /* Copy result */
5131         state->orig.out.result = state->tmp.out.result;
5132
5133         /* Reset temporary structure */
5134         ZERO_STRUCT(state->tmp);
5135
5136         tevent_req_done(req);
5137 }
5138
5139 NTSTATUS rpccli_lsa_DeleteObject_recv(struct tevent_req *req,
5140                                       TALLOC_CTX *mem_ctx,
5141                                       NTSTATUS *result)
5142 {
5143         struct rpccli_lsa_DeleteObject_state *state = tevent_req_data(
5144                 req, struct rpccli_lsa_DeleteObject_state);
5145         NTSTATUS status;
5146
5147         if (tevent_req_is_nterror(req, &status)) {
5148                 tevent_req_received(req);
5149                 return status;
5150         }
5151
5152         /* Steal possbile out parameters to the callers context */
5153         talloc_steal(mem_ctx, state->out_mem_ctx);
5154
5155         /* Return result */
5156         *result = state->orig.out.result;
5157
5158         tevent_req_received(req);
5159         return NT_STATUS_OK;
5160 }
5161
5162 NTSTATUS rpccli_lsa_DeleteObject(struct rpc_pipe_client *cli,
5163                                  TALLOC_CTX *mem_ctx,
5164                                  struct policy_handle *handle /* [in,out] [ref] */)
5165 {
5166         struct lsa_DeleteObject r;
5167         NTSTATUS status;
5168
5169         /* In parameters */
5170         r.in.handle = handle;
5171
5172         status = cli->dispatch(cli,
5173                                 mem_ctx,
5174                                 &ndr_table_lsarpc,
5175                                 NDR_LSA_DELETEOBJECT,
5176                                 &r);
5177
5178         if (!NT_STATUS_IS_OK(status)) {
5179                 return status;
5180         }
5181
5182         if (NT_STATUS_IS_ERR(status)) {
5183                 return status;
5184         }
5185
5186         /* Return variables */
5187         *handle = *r.out.handle;
5188
5189         /* Return result */
5190         return r.out.result;
5191 }
5192
5193 struct rpccli_lsa_EnumAccountsWithUserRight_state {
5194         struct lsa_EnumAccountsWithUserRight orig;
5195         struct lsa_EnumAccountsWithUserRight tmp;
5196         TALLOC_CTX *out_mem_ctx;
5197         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5198 };
5199
5200 static void rpccli_lsa_EnumAccountsWithUserRight_done(struct tevent_req *subreq);
5201
5202 struct tevent_req *rpccli_lsa_EnumAccountsWithUserRight_send(TALLOC_CTX *mem_ctx,
5203                                                              struct tevent_context *ev,
5204                                                              struct rpc_pipe_client *cli,
5205                                                              struct policy_handle *_handle /* [in] [ref] */,
5206                                                              struct lsa_String *_name /* [in] [unique] */,
5207                                                              struct lsa_SidArray *_sids /* [out] [ref] */)
5208 {
5209         struct tevent_req *req;
5210         struct rpccli_lsa_EnumAccountsWithUserRight_state *state;
5211         struct tevent_req *subreq;
5212
5213         req = tevent_req_create(mem_ctx, &state,
5214                                 struct rpccli_lsa_EnumAccountsWithUserRight_state);
5215         if (req == NULL) {
5216                 return NULL;
5217         }
5218         state->out_mem_ctx = NULL;
5219         state->dispatch_recv = cli->dispatch_recv;
5220
5221         /* In parameters */
5222         state->orig.in.handle = _handle;
5223         state->orig.in.name = _name;
5224
5225         /* Out parameters */
5226         state->orig.out.sids = _sids;
5227
5228         /* Result */
5229         ZERO_STRUCT(state->orig.out.result);
5230
5231         state->out_mem_ctx = talloc_named_const(state, 0,
5232                              "rpccli_lsa_EnumAccountsWithUserRight_out_memory");
5233         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5234                 return tevent_req_post(req, ev);
5235         }
5236
5237         /* make a temporary copy, that we pass to the dispatch function */
5238         state->tmp = state->orig;
5239
5240         subreq = cli->dispatch_send(state, ev, cli,
5241                                     &ndr_table_lsarpc,
5242                                     NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT,
5243                                     &state->tmp);
5244         if (tevent_req_nomem(subreq, req)) {
5245                 return tevent_req_post(req, ev);
5246         }
5247         tevent_req_set_callback(subreq, rpccli_lsa_EnumAccountsWithUserRight_done, req);
5248         return req;
5249 }
5250
5251 static void rpccli_lsa_EnumAccountsWithUserRight_done(struct tevent_req *subreq)
5252 {
5253         struct tevent_req *req = tevent_req_callback_data(
5254                 subreq, struct tevent_req);
5255         struct rpccli_lsa_EnumAccountsWithUserRight_state *state = tevent_req_data(
5256                 req, struct rpccli_lsa_EnumAccountsWithUserRight_state);
5257         NTSTATUS status;
5258         TALLOC_CTX *mem_ctx;
5259
5260         if (state->out_mem_ctx) {
5261                 mem_ctx = state->out_mem_ctx;
5262         } else {
5263                 mem_ctx = state;
5264         }
5265
5266         status = state->dispatch_recv(subreq, mem_ctx);
5267         TALLOC_FREE(subreq);
5268         if (!NT_STATUS_IS_OK(status)) {
5269                 tevent_req_nterror(req, status);
5270                 return;
5271         }
5272
5273         /* Copy out parameters */
5274         *state->orig.out.sids = *state->tmp.out.sids;
5275
5276         /* Copy result */
5277         state->orig.out.result = state->tmp.out.result;
5278
5279         /* Reset temporary structure */
5280         ZERO_STRUCT(state->tmp);
5281
5282         tevent_req_done(req);
5283 }
5284
5285 NTSTATUS rpccli_lsa_EnumAccountsWithUserRight_recv(struct tevent_req *req,
5286                                                    TALLOC_CTX *mem_ctx,
5287                                                    NTSTATUS *result)
5288 {
5289         struct rpccli_lsa_EnumAccountsWithUserRight_state *state = tevent_req_data(
5290                 req, struct rpccli_lsa_EnumAccountsWithUserRight_state);
5291         NTSTATUS status;
5292
5293         if (tevent_req_is_nterror(req, &status)) {
5294                 tevent_req_received(req);
5295                 return status;
5296         }
5297
5298         /* Steal possbile out parameters to the callers context */
5299         talloc_steal(mem_ctx, state->out_mem_ctx);
5300
5301         /* Return result */
5302         *result = state->orig.out.result;
5303
5304         tevent_req_received(req);
5305         return NT_STATUS_OK;
5306 }
5307
5308 NTSTATUS rpccli_lsa_EnumAccountsWithUserRight(struct rpc_pipe_client *cli,
5309                                               TALLOC_CTX *mem_ctx,
5310                                               struct policy_handle *handle /* [in] [ref] */,
5311                                               struct lsa_String *name /* [in] [unique] */,
5312                                               struct lsa_SidArray *sids /* [out] [ref] */)
5313 {
5314         struct lsa_EnumAccountsWithUserRight r;
5315         NTSTATUS status;
5316
5317         /* In parameters */
5318         r.in.handle = handle;
5319         r.in.name = name;
5320
5321         status = cli->dispatch(cli,
5322                                 mem_ctx,
5323                                 &ndr_table_lsarpc,
5324                                 NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT,
5325                                 &r);
5326
5327         if (!NT_STATUS_IS_OK(status)) {
5328                 return status;
5329         }
5330
5331         if (NT_STATUS_IS_ERR(status)) {
5332                 return status;
5333         }
5334
5335         /* Return variables */
5336         *sids = *r.out.sids;
5337
5338         /* Return result */
5339         return r.out.result;
5340 }
5341
5342 struct rpccli_lsa_EnumAccountRights_state {
5343         struct lsa_EnumAccountRights orig;
5344         struct lsa_EnumAccountRights tmp;
5345         TALLOC_CTX *out_mem_ctx;
5346         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5347 };
5348
5349 static void rpccli_lsa_EnumAccountRights_done(struct tevent_req *subreq);
5350
5351 struct tevent_req *rpccli_lsa_EnumAccountRights_send(TALLOC_CTX *mem_ctx,
5352                                                      struct tevent_context *ev,
5353                                                      struct rpc_pipe_client *cli,
5354                                                      struct policy_handle *_handle /* [in] [ref] */,
5355                                                      struct dom_sid2 *_sid /* [in] [ref] */,
5356                                                      struct lsa_RightSet *_rights /* [out] [ref] */)
5357 {
5358         struct tevent_req *req;
5359         struct rpccli_lsa_EnumAccountRights_state *state;
5360         struct tevent_req *subreq;
5361
5362         req = tevent_req_create(mem_ctx, &state,
5363                                 struct rpccli_lsa_EnumAccountRights_state);
5364         if (req == NULL) {
5365                 return NULL;
5366         }
5367         state->out_mem_ctx = NULL;
5368         state->dispatch_recv = cli->dispatch_recv;
5369
5370         /* In parameters */
5371         state->orig.in.handle = _handle;
5372         state->orig.in.sid = _sid;
5373
5374         /* Out parameters */
5375         state->orig.out.rights = _rights;
5376
5377         /* Result */
5378         ZERO_STRUCT(state->orig.out.result);
5379
5380         state->out_mem_ctx = talloc_named_const(state, 0,
5381                              "rpccli_lsa_EnumAccountRights_out_memory");
5382         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5383                 return tevent_req_post(req, ev);
5384         }
5385
5386         /* make a temporary copy, that we pass to the dispatch function */
5387         state->tmp = state->orig;
5388
5389         subreq = cli->dispatch_send(state, ev, cli,
5390                                     &ndr_table_lsarpc,
5391                                     NDR_LSA_ENUMACCOUNTRIGHTS,
5392                                     &state->tmp);
5393         if (tevent_req_nomem(subreq, req)) {
5394                 return tevent_req_post(req, ev);
5395         }
5396         tevent_req_set_callback(subreq, rpccli_lsa_EnumAccountRights_done, req);
5397         return req;
5398 }
5399
5400 static void rpccli_lsa_EnumAccountRights_done(struct tevent_req *subreq)
5401 {
5402         struct tevent_req *req = tevent_req_callback_data(
5403                 subreq, struct tevent_req);
5404         struct rpccli_lsa_EnumAccountRights_state *state = tevent_req_data(
5405                 req, struct rpccli_lsa_EnumAccountRights_state);
5406         NTSTATUS status;
5407         TALLOC_CTX *mem_ctx;
5408
5409         if (state->out_mem_ctx) {
5410                 mem_ctx = state->out_mem_ctx;
5411         } else {
5412                 mem_ctx = state;
5413         }
5414
5415         status = state->dispatch_recv(subreq, mem_ctx);
5416         TALLOC_FREE(subreq);
5417         if (!NT_STATUS_IS_OK(status)) {
5418                 tevent_req_nterror(req, status);
5419                 return;
5420         }
5421
5422         /* Copy out parameters */
5423         *state->orig.out.rights = *state->tmp.out.rights;
5424
5425         /* Copy result */
5426         state->orig.out.result = state->tmp.out.result;
5427
5428         /* Reset temporary structure */
5429         ZERO_STRUCT(state->tmp);
5430
5431         tevent_req_done(req);
5432 }
5433
5434 NTSTATUS rpccli_lsa_EnumAccountRights_recv(struct tevent_req *req,
5435                                            TALLOC_CTX *mem_ctx,
5436                                            NTSTATUS *result)
5437 {
5438         struct rpccli_lsa_EnumAccountRights_state *state = tevent_req_data(
5439                 req, struct rpccli_lsa_EnumAccountRights_state);
5440         NTSTATUS status;
5441
5442         if (tevent_req_is_nterror(req, &status)) {
5443                 tevent_req_received(req);
5444                 return status;
5445         }
5446
5447         /* Steal possbile out parameters to the callers context */
5448         talloc_steal(mem_ctx, state->out_mem_ctx);
5449
5450         /* Return result */
5451         *result = state->orig.out.result;
5452
5453         tevent_req_received(req);
5454         return NT_STATUS_OK;
5455 }
5456
5457 NTSTATUS rpccli_lsa_EnumAccountRights(struct rpc_pipe_client *cli,
5458                                       TALLOC_CTX *mem_ctx,
5459                                       struct policy_handle *handle /* [in] [ref] */,
5460                                       struct dom_sid2 *sid /* [in] [ref] */,
5461                                       struct lsa_RightSet *rights /* [out] [ref] */)
5462 {
5463         struct lsa_EnumAccountRights r;
5464         NTSTATUS status;
5465
5466         /* In parameters */
5467         r.in.handle = handle;
5468         r.in.sid = sid;
5469
5470         status = cli->dispatch(cli,
5471                                 mem_ctx,
5472                                 &ndr_table_lsarpc,
5473                                 NDR_LSA_ENUMACCOUNTRIGHTS,
5474                                 &r);
5475
5476         if (!NT_STATUS_IS_OK(status)) {
5477                 return status;
5478         }
5479
5480         if (NT_STATUS_IS_ERR(status)) {
5481                 return status;
5482         }
5483
5484         /* Return variables */
5485         *rights = *r.out.rights;
5486
5487         /* Return result */
5488         return r.out.result;
5489 }
5490
5491 struct rpccli_lsa_AddAccountRights_state {
5492         struct lsa_AddAccountRights orig;
5493         struct lsa_AddAccountRights tmp;
5494         TALLOC_CTX *out_mem_ctx;
5495         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5496 };
5497
5498 static void rpccli_lsa_AddAccountRights_done(struct tevent_req *subreq);
5499
5500 struct tevent_req *rpccli_lsa_AddAccountRights_send(TALLOC_CTX *mem_ctx,
5501                                                     struct tevent_context *ev,
5502                                                     struct rpc_pipe_client *cli,
5503                                                     struct policy_handle *_handle /* [in] [ref] */,
5504                                                     struct dom_sid2 *_sid /* [in] [ref] */,
5505                                                     struct lsa_RightSet *_rights /* [in] [ref] */)
5506 {
5507         struct tevent_req *req;
5508         struct rpccli_lsa_AddAccountRights_state *state;
5509         struct tevent_req *subreq;
5510
5511         req = tevent_req_create(mem_ctx, &state,
5512                                 struct rpccli_lsa_AddAccountRights_state);
5513         if (req == NULL) {
5514                 return NULL;
5515         }
5516         state->out_mem_ctx = NULL;
5517         state->dispatch_recv = cli->dispatch_recv;
5518
5519         /* In parameters */
5520         state->orig.in.handle = _handle;
5521         state->orig.in.sid = _sid;
5522         state->orig.in.rights = _rights;
5523
5524         /* Out parameters */
5525
5526         /* Result */
5527         ZERO_STRUCT(state->orig.out.result);
5528
5529         /* make a temporary copy, that we pass to the dispatch function */
5530         state->tmp = state->orig;
5531
5532         subreq = cli->dispatch_send(state, ev, cli,
5533                                     &ndr_table_lsarpc,
5534                                     NDR_LSA_ADDACCOUNTRIGHTS,
5535                                     &state->tmp);
5536         if (tevent_req_nomem(subreq, req)) {
5537                 return tevent_req_post(req, ev);
5538         }
5539         tevent_req_set_callback(subreq, rpccli_lsa_AddAccountRights_done, req);
5540         return req;
5541 }
5542
5543 static void rpccli_lsa_AddAccountRights_done(struct tevent_req *subreq)
5544 {
5545         struct tevent_req *req = tevent_req_callback_data(
5546                 subreq, struct tevent_req);
5547         struct rpccli_lsa_AddAccountRights_state *state = tevent_req_data(
5548                 req, struct rpccli_lsa_AddAccountRights_state);
5549         NTSTATUS status;
5550         TALLOC_CTX *mem_ctx;
5551
5552         if (state->out_mem_ctx) {
5553                 mem_ctx = state->out_mem_ctx;
5554         } else {
5555                 mem_ctx = state;
5556         }
5557
5558         status = state->dispatch_recv(subreq, mem_ctx);
5559         TALLOC_FREE(subreq);
5560         if (!NT_STATUS_IS_OK(status)) {
5561                 tevent_req_nterror(req, status);
5562                 return;
5563         }
5564
5565         /* Copy out parameters */
5566
5567         /* Copy result */
5568         state->orig.out.result = state->tmp.out.result;
5569
5570         /* Reset temporary structure */
5571         ZERO_STRUCT(state->tmp);
5572
5573         tevent_req_done(req);
5574 }
5575
5576 NTSTATUS rpccli_lsa_AddAccountRights_recv(struct tevent_req *req,
5577                                           TALLOC_CTX *mem_ctx,
5578                                           NTSTATUS *result)
5579 {
5580         struct rpccli_lsa_AddAccountRights_state *state = tevent_req_data(
5581                 req, struct rpccli_lsa_AddAccountRights_state);
5582         NTSTATUS status;
5583
5584         if (tevent_req_is_nterror(req, &status)) {
5585                 tevent_req_received(req);
5586                 return status;
5587         }
5588
5589         /* Steal possbile out parameters to the callers context */
5590         talloc_steal(mem_ctx, state->out_mem_ctx);
5591
5592         /* Return result */
5593         *result = state->orig.out.result;
5594
5595         tevent_req_received(req);
5596         return NT_STATUS_OK;
5597 }
5598
5599 NTSTATUS rpccli_lsa_AddAccountRights(struct rpc_pipe_client *cli,
5600                                      TALLOC_CTX *mem_ctx,
5601                                      struct policy_handle *handle /* [in] [ref] */,
5602                                      struct dom_sid2 *sid /* [in] [ref] */,
5603                                      struct lsa_RightSet *rights /* [in] [ref] */)
5604 {
5605         struct lsa_AddAccountRights r;
5606         NTSTATUS status;
5607
5608         /* In parameters */
5609         r.in.handle = handle;
5610         r.in.sid = sid;
5611         r.in.rights = rights;
5612
5613         status = cli->dispatch(cli,
5614                                 mem_ctx,
5615                                 &ndr_table_lsarpc,
5616                                 NDR_LSA_ADDACCOUNTRIGHTS,
5617                                 &r);
5618
5619         if (!NT_STATUS_IS_OK(status)) {
5620                 return status;
5621         }
5622
5623         if (NT_STATUS_IS_ERR(status)) {
5624                 return status;
5625         }
5626
5627         /* Return variables */
5628
5629         /* Return result */
5630         return r.out.result;
5631 }
5632
5633 struct rpccli_lsa_RemoveAccountRights_state {
5634         struct lsa_RemoveAccountRights orig;
5635         struct lsa_RemoveAccountRights tmp;
5636         TALLOC_CTX *out_mem_ctx;
5637         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5638 };
5639
5640 static void rpccli_lsa_RemoveAccountRights_done(struct tevent_req *subreq);
5641
5642 struct tevent_req *rpccli_lsa_RemoveAccountRights_send(TALLOC_CTX *mem_ctx,
5643                                                        struct tevent_context *ev,
5644                                                        struct rpc_pipe_client *cli,
5645                                                        struct policy_handle *_handle /* [in] [ref] */,
5646                                                        struct dom_sid2 *_sid /* [in] [ref] */,
5647                                                        uint8_t _remove_all /* [in]  */,
5648                                                        struct lsa_RightSet *_rights /* [in] [ref] */)
5649 {
5650         struct tevent_req *req;
5651         struct rpccli_lsa_RemoveAccountRights_state *state;
5652         struct tevent_req *subreq;
5653
5654         req = tevent_req_create(mem_ctx, &state,
5655                                 struct rpccli_lsa_RemoveAccountRights_state);
5656         if (req == NULL) {
5657                 return NULL;
5658         }
5659         state->out_mem_ctx = NULL;
5660         state->dispatch_recv = cli->dispatch_recv;
5661
5662         /* In parameters */
5663         state->orig.in.handle = _handle;
5664         state->orig.in.sid = _sid;
5665         state->orig.in.remove_all = _remove_all;
5666         state->orig.in.rights = _rights;
5667
5668         /* Out parameters */
5669
5670         /* Result */
5671         ZERO_STRUCT(state->orig.out.result);
5672
5673         /* make a temporary copy, that we pass to the dispatch function */
5674         state->tmp = state->orig;
5675
5676         subreq = cli->dispatch_send(state, ev, cli,
5677                                     &ndr_table_lsarpc,
5678                                     NDR_LSA_REMOVEACCOUNTRIGHTS,
5679                                     &state->tmp);
5680         if (tevent_req_nomem(subreq, req)) {
5681                 return tevent_req_post(req, ev);
5682         }
5683         tevent_req_set_callback(subreq, rpccli_lsa_RemoveAccountRights_done, req);
5684         return req;
5685 }
5686
5687 static void rpccli_lsa_RemoveAccountRights_done(struct tevent_req *subreq)
5688 {
5689         struct tevent_req *req = tevent_req_callback_data(
5690                 subreq, struct tevent_req);
5691         struct rpccli_lsa_RemoveAccountRights_state *state = tevent_req_data(
5692                 req, struct rpccli_lsa_RemoveAccountRights_state);
5693         NTSTATUS status;
5694         TALLOC_CTX *mem_ctx;
5695
5696         if (state->out_mem_ctx) {
5697                 mem_ctx = state->out_mem_ctx;
5698         } else {
5699                 mem_ctx = state;
5700         }
5701
5702         status = state->dispatch_recv(subreq, mem_ctx);
5703         TALLOC_FREE(subreq);
5704         if (!NT_STATUS_IS_OK(status)) {
5705                 tevent_req_nterror(req, status);
5706                 return;
5707         }
5708
5709         /* Copy out parameters */
5710
5711         /* Copy result */
5712         state->orig.out.result = state->tmp.out.result;
5713
5714         /* Reset temporary structure */
5715         ZERO_STRUCT(state->tmp);
5716
5717         tevent_req_done(req);
5718 }
5719
5720 NTSTATUS rpccli_lsa_RemoveAccountRights_recv(struct tevent_req *req,
5721                                              TALLOC_CTX *mem_ctx,
5722                                              NTSTATUS *result)
5723 {
5724         struct rpccli_lsa_RemoveAccountRights_state *state = tevent_req_data(
5725                 req, struct rpccli_lsa_RemoveAccountRights_state);
5726         NTSTATUS status;
5727
5728         if (tevent_req_is_nterror(req, &status)) {
5729                 tevent_req_received(req);
5730                 return status;
5731         }
5732
5733         /* Steal possbile out parameters to the callers context */
5734         talloc_steal(mem_ctx, state->out_mem_ctx);
5735
5736         /* Return result */
5737         *result = state->orig.out.result;
5738
5739         tevent_req_received(req);
5740         return NT_STATUS_OK;
5741 }
5742
5743 NTSTATUS rpccli_lsa_RemoveAccountRights(struct rpc_pipe_client *cli,
5744                                         TALLOC_CTX *mem_ctx,
5745                                         struct policy_handle *handle /* [in] [ref] */,
5746                                         struct dom_sid2 *sid /* [in] [ref] */,
5747                                         uint8_t remove_all /* [in]  */,
5748                                         struct lsa_RightSet *rights /* [in] [ref] */)
5749 {
5750         struct lsa_RemoveAccountRights r;
5751         NTSTATUS status;
5752
5753         /* In parameters */
5754         r.in.handle = handle;
5755         r.in.sid = sid;
5756         r.in.remove_all = remove_all;
5757         r.in.rights = rights;
5758
5759         status = cli->dispatch(cli,
5760                                 mem_ctx,
5761                                 &ndr_table_lsarpc,
5762                                 NDR_LSA_REMOVEACCOUNTRIGHTS,
5763                                 &r);
5764
5765         if (!NT_STATUS_IS_OK(status)) {
5766                 return status;
5767         }
5768
5769         if (NT_STATUS_IS_ERR(status)) {
5770                 return status;
5771         }
5772
5773         /* Return variables */
5774
5775         /* Return result */
5776         return r.out.result;
5777 }
5778
5779 struct rpccli_lsa_QueryTrustedDomainInfoBySid_state {
5780         struct lsa_QueryTrustedDomainInfoBySid orig;
5781         struct lsa_QueryTrustedDomainInfoBySid tmp;
5782         TALLOC_CTX *out_mem_ctx;
5783         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5784 };
5785
5786 static void rpccli_lsa_QueryTrustedDomainInfoBySid_done(struct tevent_req *subreq);
5787
5788 struct tevent_req *rpccli_lsa_QueryTrustedDomainInfoBySid_send(TALLOC_CTX *mem_ctx,
5789                                                                struct tevent_context *ev,
5790                                                                struct rpc_pipe_client *cli,
5791                                                                struct policy_handle *_handle /* [in] [ref] */,
5792                                                                struct dom_sid2 *_dom_sid /* [in] [ref] */,
5793                                                                enum lsa_TrustDomInfoEnum _level /* [in]  */,
5794                                                                union lsa_TrustedDomainInfo **_info /* [out] [ref,switch_is(level)] */)
5795 {
5796         struct tevent_req *req;
5797         struct rpccli_lsa_QueryTrustedDomainInfoBySid_state *state;
5798         struct tevent_req *subreq;
5799
5800         req = tevent_req_create(mem_ctx, &state,
5801                                 struct rpccli_lsa_QueryTrustedDomainInfoBySid_state);
5802         if (req == NULL) {
5803                 return NULL;
5804         }
5805         state->out_mem_ctx = NULL;
5806         state->dispatch_recv = cli->dispatch_recv;
5807
5808         /* In parameters */
5809         state->orig.in.handle = _handle;
5810         state->orig.in.dom_sid = _dom_sid;
5811         state->orig.in.level = _level;
5812
5813         /* Out parameters */
5814         state->orig.out.info = _info;
5815
5816         /* Result */
5817         ZERO_STRUCT(state->orig.out.result);
5818
5819         state->out_mem_ctx = talloc_named_const(state, 0,
5820                              "rpccli_lsa_QueryTrustedDomainInfoBySid_out_memory");
5821         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5822                 return tevent_req_post(req, ev);
5823         }
5824
5825         /* make a temporary copy, that we pass to the dispatch function */
5826         state->tmp = state->orig;
5827
5828         subreq = cli->dispatch_send(state, ev, cli,
5829                                     &ndr_table_lsarpc,
5830                                     NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID,
5831                                     &state->tmp);
5832         if (tevent_req_nomem(subreq, req)) {
5833                 return tevent_req_post(req, ev);
5834         }
5835         tevent_req_set_callback(subreq, rpccli_lsa_QueryTrustedDomainInfoBySid_done, req);
5836         return req;
5837 }
5838
5839 static void rpccli_lsa_QueryTrustedDomainInfoBySid_done(struct tevent_req *subreq)
5840 {
5841         struct tevent_req *req = tevent_req_callback_data(
5842                 subreq, struct tevent_req);
5843         struct rpccli_lsa_QueryTrustedDomainInfoBySid_state *state = tevent_req_data(
5844                 req, struct rpccli_lsa_QueryTrustedDomainInfoBySid_state);
5845         NTSTATUS status;
5846         TALLOC_CTX *mem_ctx;
5847
5848         if (state->out_mem_ctx) {
5849                 mem_ctx = state->out_mem_ctx;
5850         } else {
5851                 mem_ctx = state;
5852         }
5853
5854         status = state->dispatch_recv(subreq, mem_ctx);
5855         TALLOC_FREE(subreq);
5856         if (!NT_STATUS_IS_OK(status)) {
5857                 tevent_req_nterror(req, status);
5858                 return;
5859         }
5860
5861         /* Copy out parameters */
5862         *state->orig.out.info = *state->tmp.out.info;
5863
5864         /* Copy result */
5865         state->orig.out.result = state->tmp.out.result;
5866
5867         /* Reset temporary structure */
5868         ZERO_STRUCT(state->tmp);
5869
5870         tevent_req_done(req);
5871 }
5872
5873 NTSTATUS rpccli_lsa_QueryTrustedDomainInfoBySid_recv(struct tevent_req *req,
5874                                                      TALLOC_CTX *mem_ctx,
5875                                                      NTSTATUS *result)
5876 {
5877         struct rpccli_lsa_QueryTrustedDomainInfoBySid_state *state = tevent_req_data(
5878                 req, struct rpccli_lsa_QueryTrustedDomainInfoBySid_state);
5879         NTSTATUS status;
5880
5881         if (tevent_req_is_nterror(req, &status)) {
5882                 tevent_req_received(req);
5883                 return status;
5884         }
5885
5886         /* Steal possbile out parameters to the callers context */
5887         talloc_steal(mem_ctx, state->out_mem_ctx);
5888
5889         /* Return result */
5890         *result = state->orig.out.result;
5891
5892         tevent_req_received(req);
5893         return NT_STATUS_OK;
5894 }
5895
5896 NTSTATUS rpccli_lsa_QueryTrustedDomainInfoBySid(struct rpc_pipe_client *cli,
5897                                                 TALLOC_CTX *mem_ctx,
5898                                                 struct policy_handle *handle /* [in] [ref] */,
5899                                                 struct dom_sid2 *dom_sid /* [in] [ref] */,
5900                                                 enum lsa_TrustDomInfoEnum level /* [in]  */,
5901                                                 union lsa_TrustedDomainInfo **info /* [out] [ref,switch_is(level)] */)
5902 {
5903         struct lsa_QueryTrustedDomainInfoBySid r;
5904         NTSTATUS status;
5905
5906         /* In parameters */
5907         r.in.handle = handle;
5908         r.in.dom_sid = dom_sid;
5909         r.in.level = level;
5910
5911         status = cli->dispatch(cli,
5912                                 mem_ctx,
5913                                 &ndr_table_lsarpc,
5914                                 NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID,
5915                                 &r);
5916
5917         if (!NT_STATUS_IS_OK(status)) {
5918                 return status;
5919         }
5920
5921         if (NT_STATUS_IS_ERR(status)) {
5922                 return status;
5923         }
5924
5925         /* Return variables */
5926         *info = *r.out.info;
5927
5928         /* Return result */
5929         return r.out.result;
5930 }
5931
5932 struct rpccli_lsa_SetTrustedDomainInfo_state {
5933         struct lsa_SetTrustedDomainInfo orig;
5934         struct lsa_SetTrustedDomainInfo tmp;
5935         TALLOC_CTX *out_mem_ctx;
5936         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5937 };
5938
5939 static void rpccli_lsa_SetTrustedDomainInfo_done(struct tevent_req *subreq);
5940
5941 struct tevent_req *rpccli_lsa_SetTrustedDomainInfo_send(TALLOC_CTX *mem_ctx,
5942                                                         struct tevent_context *ev,
5943                                                         struct rpc_pipe_client *cli,
5944                                                         struct policy_handle *_handle /* [in] [ref] */,
5945                                                         struct dom_sid2 *_dom_sid /* [in] [ref] */,
5946                                                         enum lsa_TrustDomInfoEnum _level /* [in]  */,
5947                                                         union lsa_TrustedDomainInfo *_info /* [in] [ref,switch_is(level)] */)
5948 {
5949         struct tevent_req *req;
5950         struct rpccli_lsa_SetTrustedDomainInfo_state *state;
5951         struct tevent_req *subreq;
5952
5953         req = tevent_req_create(mem_ctx, &state,
5954                                 struct rpccli_lsa_SetTrustedDomainInfo_state);
5955         if (req == NULL) {
5956                 return NULL;
5957         }
5958         state->out_mem_ctx = NULL;
5959         state->dispatch_recv = cli->dispatch_recv;
5960
5961         /* In parameters */
5962         state->orig.in.handle = _handle;
5963         state->orig.in.dom_sid = _dom_sid;
5964         state->orig.in.level = _level;
5965         state->orig.in.info = _info;
5966
5967         /* Out parameters */
5968
5969         /* Result */
5970         ZERO_STRUCT(state->orig.out.result);
5971
5972         /* make a temporary copy, that we pass to the dispatch function */
5973         state->tmp = state->orig;
5974
5975         subreq = cli->dispatch_send(state, ev, cli,
5976                                     &ndr_table_lsarpc,
5977                                     NDR_LSA_SETTRUSTEDDOMAININFO,
5978                                     &state->tmp);
5979         if (tevent_req_nomem(subreq, req)) {
5980                 return tevent_req_post(req, ev);
5981         }
5982         tevent_req_set_callback(subreq, rpccli_lsa_SetTrustedDomainInfo_done, req);
5983         return req;
5984 }
5985
5986 static void rpccli_lsa_SetTrustedDomainInfo_done(struct tevent_req *subreq)
5987 {
5988         struct tevent_req *req = tevent_req_callback_data(
5989                 subreq, struct tevent_req);
5990         struct rpccli_lsa_SetTrustedDomainInfo_state *state = tevent_req_data(
5991                 req, struct rpccli_lsa_SetTrustedDomainInfo_state);
5992         NTSTATUS status;
5993         TALLOC_CTX *mem_ctx;
5994
5995         if (state->out_mem_ctx) {
5996                 mem_ctx = state->out_mem_ctx;
5997         } else {
5998                 mem_ctx = state;
5999         }
6000
6001         status = state->dispatch_recv(subreq, mem_ctx);
6002         TALLOC_FREE(subreq);
6003         if (!NT_STATUS_IS_OK(status)) {
6004                 tevent_req_nterror(req, status);
6005                 return;
6006         }
6007
6008         /* Copy out parameters */
6009
6010         /* Copy result */
6011         state->orig.out.result = state->tmp.out.result;
6012
6013         /* Reset temporary structure */
6014         ZERO_STRUCT(state->tmp);
6015
6016         tevent_req_done(req);
6017 }
6018
6019 NTSTATUS rpccli_lsa_SetTrustedDomainInfo_recv(struct tevent_req *req,
6020                                               TALLOC_CTX *mem_ctx,
6021                                               NTSTATUS *result)
6022 {
6023         struct rpccli_lsa_SetTrustedDomainInfo_state *state = tevent_req_data(
6024                 req, struct rpccli_lsa_SetTrustedDomainInfo_state);
6025         NTSTATUS status;
6026
6027         if (tevent_req_is_nterror(req, &status)) {
6028                 tevent_req_received(req);
6029                 return status;
6030         }
6031
6032         /* Steal possbile out parameters to the callers context */
6033         talloc_steal(mem_ctx, state->out_mem_ctx);
6034
6035         /* Return result */
6036         *result = state->orig.out.result;
6037
6038         tevent_req_received(req);
6039         return NT_STATUS_OK;
6040 }
6041
6042 NTSTATUS rpccli_lsa_SetTrustedDomainInfo(struct rpc_pipe_client *cli,
6043                                          TALLOC_CTX *mem_ctx,
6044                                          struct policy_handle *handle /* [in] [ref] */,
6045                                          struct dom_sid2 *dom_sid /* [in] [ref] */,
6046                                          enum lsa_TrustDomInfoEnum level /* [in]  */,
6047                                          union lsa_TrustedDomainInfo *info /* [in] [ref,switch_is(level)] */)
6048 {
6049         struct lsa_SetTrustedDomainInfo r;
6050         NTSTATUS status;
6051
6052         /* In parameters */
6053         r.in.handle = handle;
6054         r.in.dom_sid = dom_sid;
6055         r.in.level = level;
6056         r.in.info = info;
6057
6058         status = cli->dispatch(cli,
6059                                 mem_ctx,
6060                                 &ndr_table_lsarpc,
6061                                 NDR_LSA_SETTRUSTEDDOMAININFO,
6062                                 &r);
6063
6064         if (!NT_STATUS_IS_OK(status)) {
6065                 return status;
6066         }
6067
6068         if (NT_STATUS_IS_ERR(status)) {
6069                 return status;
6070         }
6071
6072         /* Return variables */
6073
6074         /* Return result */
6075         return r.out.result;
6076 }
6077
6078 struct rpccli_lsa_DeleteTrustedDomain_state {
6079         struct lsa_DeleteTrustedDomain orig;
6080         struct lsa_DeleteTrustedDomain tmp;
6081         TALLOC_CTX *out_mem_ctx;
6082         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6083 };
6084
6085 static void rpccli_lsa_DeleteTrustedDomain_done(struct tevent_req *subreq);
6086
6087 struct tevent_req *rpccli_lsa_DeleteTrustedDomain_send(TALLOC_CTX *mem_ctx,
6088                                                        struct tevent_context *ev,
6089                                                        struct rpc_pipe_client *cli,
6090                                                        struct policy_handle *_handle /* [in] [ref] */,
6091                                                        struct dom_sid2 *_dom_sid /* [in] [ref] */)
6092 {
6093         struct tevent_req *req;
6094         struct rpccli_lsa_DeleteTrustedDomain_state *state;
6095         struct tevent_req *subreq;
6096
6097         req = tevent_req_create(mem_ctx, &state,
6098                                 struct rpccli_lsa_DeleteTrustedDomain_state);
6099         if (req == NULL) {
6100                 return NULL;
6101         }
6102         state->out_mem_ctx = NULL;
6103         state->dispatch_recv = cli->dispatch_recv;
6104
6105         /* In parameters */
6106         state->orig.in.handle = _handle;
6107         state->orig.in.dom_sid = _dom_sid;
6108
6109         /* Out parameters */
6110
6111         /* Result */
6112         ZERO_STRUCT(state->orig.out.result);
6113
6114         /* make a temporary copy, that we pass to the dispatch function */
6115         state->tmp = state->orig;
6116
6117         subreq = cli->dispatch_send(state, ev, cli,
6118                                     &ndr_table_lsarpc,
6119                                     NDR_LSA_DELETETRUSTEDDOMAIN,
6120                                     &state->tmp);
6121         if (tevent_req_nomem(subreq, req)) {
6122                 return tevent_req_post(req, ev);
6123         }
6124         tevent_req_set_callback(subreq, rpccli_lsa_DeleteTrustedDomain_done, req);
6125         return req;
6126 }
6127
6128 static void rpccli_lsa_DeleteTrustedDomain_done(struct tevent_req *subreq)
6129 {
6130         struct tevent_req *req = tevent_req_callback_data(
6131                 subreq, struct tevent_req);
6132         struct rpccli_lsa_DeleteTrustedDomain_state *state = tevent_req_data(
6133                 req, struct rpccli_lsa_DeleteTrustedDomain_state);
6134         NTSTATUS status;
6135         TALLOC_CTX *mem_ctx;
6136
6137         if (state->out_mem_ctx) {
6138                 mem_ctx = state->out_mem_ctx;
6139         } else {
6140                 mem_ctx = state;
6141         }
6142
6143         status = state->dispatch_recv(subreq, mem_ctx);
6144         TALLOC_FREE(subreq);
6145         if (!NT_STATUS_IS_OK(status)) {
6146                 tevent_req_nterror(req, status);
6147                 return;
6148         }
6149
6150         /* Copy out parameters */
6151
6152         /* Copy result */
6153         state->orig.out.result = state->tmp.out.result;
6154
6155         /* Reset temporary structure */
6156         ZERO_STRUCT(state->tmp);
6157
6158         tevent_req_done(req);
6159 }
6160
6161 NTSTATUS rpccli_lsa_DeleteTrustedDomain_recv(struct tevent_req *req,
6162                                              TALLOC_CTX *mem_ctx,
6163                                              NTSTATUS *result)
6164 {
6165         struct rpccli_lsa_DeleteTrustedDomain_state *state = tevent_req_data(
6166                 req, struct rpccli_lsa_DeleteTrustedDomain_state);
6167         NTSTATUS status;
6168
6169         if (tevent_req_is_nterror(req, &status)) {
6170                 tevent_req_received(req);
6171                 return status;
6172         }
6173
6174         /* Steal possbile out parameters to the callers context */
6175         talloc_steal(mem_ctx, state->out_mem_ctx);
6176
6177         /* Return result */
6178         *result = state->orig.out.result;
6179
6180         tevent_req_received(req);
6181         return NT_STATUS_OK;
6182 }
6183
6184 NTSTATUS rpccli_lsa_DeleteTrustedDomain(struct rpc_pipe_client *cli,
6185                                         TALLOC_CTX *mem_ctx,
6186                                         struct policy_handle *handle /* [in] [ref] */,
6187                                         struct dom_sid2 *dom_sid /* [in] [ref] */)
6188 {
6189         struct lsa_DeleteTrustedDomain r;
6190         NTSTATUS status;
6191
6192         /* In parameters */
6193         r.in.handle = handle;
6194         r.in.dom_sid = dom_sid;
6195
6196         status = cli->dispatch(cli,
6197                                 mem_ctx,
6198                                 &ndr_table_lsarpc,
6199                                 NDR_LSA_DELETETRUSTEDDOMAIN,
6200                                 &r);
6201
6202         if (!NT_STATUS_IS_OK(status)) {
6203                 return status;
6204         }
6205
6206         if (NT_STATUS_IS_ERR(status)) {
6207                 return status;
6208         }
6209
6210         /* Return variables */
6211
6212         /* Return result */
6213         return r.out.result;
6214 }
6215
6216 struct rpccli_lsa_StorePrivateData_state {
6217         struct lsa_StorePrivateData orig;
6218         struct lsa_StorePrivateData tmp;
6219         TALLOC_CTX *out_mem_ctx;
6220         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6221 };
6222
6223 static void rpccli_lsa_StorePrivateData_done(struct tevent_req *subreq);
6224
6225 struct tevent_req *rpccli_lsa_StorePrivateData_send(TALLOC_CTX *mem_ctx,
6226                                                     struct tevent_context *ev,
6227                                                     struct rpc_pipe_client *cli,
6228                                                     struct policy_handle *_handle /* [in] [ref] */,
6229                                                     struct lsa_String *_name /* [in] [ref] */,
6230                                                     struct lsa_DATA_BUF *_val /* [in] [unique] */)
6231 {
6232         struct tevent_req *req;
6233         struct rpccli_lsa_StorePrivateData_state *state;
6234         struct tevent_req *subreq;
6235
6236         req = tevent_req_create(mem_ctx, &state,
6237                                 struct rpccli_lsa_StorePrivateData_state);
6238         if (req == NULL) {
6239                 return NULL;
6240         }
6241         state->out_mem_ctx = NULL;
6242         state->dispatch_recv = cli->dispatch_recv;
6243
6244         /* In parameters */
6245         state->orig.in.handle = _handle;
6246         state->orig.in.name = _name;
6247         state->orig.in.val = _val;
6248
6249         /* Out parameters */
6250
6251         /* Result */
6252         ZERO_STRUCT(state->orig.out.result);
6253
6254         /* make a temporary copy, that we pass to the dispatch function */
6255         state->tmp = state->orig;
6256
6257         subreq = cli->dispatch_send(state, ev, cli,
6258                                     &ndr_table_lsarpc,
6259                                     NDR_LSA_STOREPRIVATEDATA,
6260                                     &state->tmp);
6261         if (tevent_req_nomem(subreq, req)) {
6262                 return tevent_req_post(req, ev);
6263         }
6264         tevent_req_set_callback(subreq, rpccli_lsa_StorePrivateData_done, req);
6265         return req;
6266 }
6267
6268 static void rpccli_lsa_StorePrivateData_done(struct tevent_req *subreq)
6269 {
6270         struct tevent_req *req = tevent_req_callback_data(
6271                 subreq, struct tevent_req);
6272         struct rpccli_lsa_StorePrivateData_state *state = tevent_req_data(
6273                 req, struct rpccli_lsa_StorePrivateData_state);
6274         NTSTATUS status;
6275         TALLOC_CTX *mem_ctx;
6276
6277         if (state->out_mem_ctx) {
6278                 mem_ctx = state->out_mem_ctx;
6279         } else {
6280                 mem_ctx = state;
6281         }
6282
6283         status = state->dispatch_recv(subreq, mem_ctx);
6284         TALLOC_FREE(subreq);
6285         if (!NT_STATUS_IS_OK(status)) {
6286                 tevent_req_nterror(req, status);
6287                 return;
6288         }
6289
6290         /* Copy out parameters */
6291
6292         /* Copy result */
6293         state->orig.out.result = state->tmp.out.result;
6294
6295         /* Reset temporary structure */
6296         ZERO_STRUCT(state->tmp);
6297
6298         tevent_req_done(req);
6299 }
6300
6301 NTSTATUS rpccli_lsa_StorePrivateData_recv(struct tevent_req *req,
6302                                           TALLOC_CTX *mem_ctx,
6303                                           NTSTATUS *result)
6304 {
6305         struct rpccli_lsa_StorePrivateData_state *state = tevent_req_data(
6306                 req, struct rpccli_lsa_StorePrivateData_state);
6307         NTSTATUS status;
6308
6309         if (tevent_req_is_nterror(req, &status)) {
6310                 tevent_req_received(req);
6311                 return status;
6312         }
6313
6314         /* Steal possbile out parameters to the callers context */
6315         talloc_steal(mem_ctx, state->out_mem_ctx);
6316
6317         /* Return result */
6318         *result = state->orig.out.result;
6319
6320         tevent_req_received(req);
6321         return NT_STATUS_OK;
6322 }
6323
6324 NTSTATUS rpccli_lsa_StorePrivateData(struct rpc_pipe_client *cli,
6325                                      TALLOC_CTX *mem_ctx,
6326                                      struct policy_handle *handle /* [in] [ref] */,
6327                                      struct lsa_String *name /* [in] [ref] */,
6328                                      struct lsa_DATA_BUF *val /* [in] [unique] */)
6329 {
6330         struct lsa_StorePrivateData r;
6331         NTSTATUS status;
6332
6333         /* In parameters */
6334         r.in.handle = handle;
6335         r.in.name = name;
6336         r.in.val = val;
6337
6338         status = cli->dispatch(cli,
6339                                 mem_ctx,
6340                                 &ndr_table_lsarpc,
6341                                 NDR_LSA_STOREPRIVATEDATA,
6342                                 &r);
6343
6344         if (!NT_STATUS_IS_OK(status)) {
6345                 return status;
6346         }
6347
6348         if (NT_STATUS_IS_ERR(status)) {
6349                 return status;
6350         }
6351
6352         /* Return variables */
6353
6354         /* Return result */
6355         return r.out.result;
6356 }
6357
6358 struct rpccli_lsa_RetrievePrivateData_state {
6359         struct lsa_RetrievePrivateData orig;
6360         struct lsa_RetrievePrivateData tmp;
6361         TALLOC_CTX *out_mem_ctx;
6362         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6363 };
6364
6365 static void rpccli_lsa_RetrievePrivateData_done(struct tevent_req *subreq);
6366
6367 struct tevent_req *rpccli_lsa_RetrievePrivateData_send(TALLOC_CTX *mem_ctx,
6368                                                        struct tevent_context *ev,
6369                                                        struct rpc_pipe_client *cli,
6370                                                        struct policy_handle *_handle /* [in] [ref] */,
6371                                                        struct lsa_String *_name /* [in] [ref] */,
6372                                                        struct lsa_DATA_BUF **_val /* [in,out] [ref] */)
6373 {
6374         struct tevent_req *req;
6375         struct rpccli_lsa_RetrievePrivateData_state *state;
6376         struct tevent_req *subreq;
6377
6378         req = tevent_req_create(mem_ctx, &state,
6379                                 struct rpccli_lsa_RetrievePrivateData_state);
6380         if (req == NULL) {
6381                 return NULL;
6382         }
6383         state->out_mem_ctx = NULL;
6384         state->dispatch_recv = cli->dispatch_recv;
6385
6386         /* In parameters */
6387         state->orig.in.handle = _handle;
6388         state->orig.in.name = _name;
6389         state->orig.in.val = _val;
6390
6391         /* Out parameters */
6392         state->orig.out.val = _val;
6393
6394         /* Result */
6395         ZERO_STRUCT(state->orig.out.result);
6396
6397         state->out_mem_ctx = talloc_named_const(state, 0,
6398                              "rpccli_lsa_RetrievePrivateData_out_memory");
6399         if (tevent_req_nomem(state->out_mem_ctx, req)) {
6400                 return tevent_req_post(req, ev);
6401         }
6402
6403         /* make a temporary copy, that we pass to the dispatch function */
6404         state->tmp = state->orig;
6405
6406         subreq = cli->dispatch_send(state, ev, cli,
6407                                     &ndr_table_lsarpc,
6408                                     NDR_LSA_RETRIEVEPRIVATEDATA,
6409                                     &state->tmp);
6410         if (tevent_req_nomem(subreq, req)) {
6411                 return tevent_req_post(req, ev);
6412         }
6413         tevent_req_set_callback(subreq, rpccli_lsa_RetrievePrivateData_done, req);
6414         return req;
6415 }
6416
6417 static void rpccli_lsa_RetrievePrivateData_done(struct tevent_req *subreq)
6418 {
6419         struct tevent_req *req = tevent_req_callback_data(
6420                 subreq, struct tevent_req);
6421         struct rpccli_lsa_RetrievePrivateData_state *state = tevent_req_data(
6422                 req, struct rpccli_lsa_RetrievePrivateData_state);
6423         NTSTATUS status;
6424         TALLOC_CTX *mem_ctx;
6425
6426         if (state->out_mem_ctx) {
6427                 mem_ctx = state->out_mem_ctx;
6428         } else {
6429                 mem_ctx = state;
6430         }
6431
6432         status = state->dispatch_recv(subreq, mem_ctx);
6433         TALLOC_FREE(subreq);
6434         if (!NT_STATUS_IS_OK(status)) {
6435                 tevent_req_nterror(req, status);
6436                 return;
6437         }
6438
6439         /* Copy out parameters */
6440         *state->orig.out.val = *state->tmp.out.val;
6441
6442         /* Copy result */
6443         state->orig.out.result = state->tmp.out.result;
6444
6445         /* Reset temporary structure */
6446         ZERO_STRUCT(state->tmp);
6447
6448         tevent_req_done(req);
6449 }
6450
6451 NTSTATUS rpccli_lsa_RetrievePrivateData_recv(struct tevent_req *req,
6452                                              TALLOC_CTX *mem_ctx,
6453                                              NTSTATUS *result)
6454 {
6455         struct rpccli_lsa_RetrievePrivateData_state *state = tevent_req_data(
6456                 req, struct rpccli_lsa_RetrievePrivateData_state);
6457         NTSTATUS status;
6458
6459         if (tevent_req_is_nterror(req, &status)) {
6460                 tevent_req_received(req);
6461                 return status;
6462         }
6463
6464         /* Steal possbile out parameters to the callers context */
6465         talloc_steal(mem_ctx, state->out_mem_ctx);
6466
6467         /* Return result */
6468         *result = state->orig.out.result;
6469
6470         tevent_req_received(req);
6471         return NT_STATUS_OK;
6472 }
6473
6474 NTSTATUS rpccli_lsa_RetrievePrivateData(struct rpc_pipe_client *cli,
6475                                         TALLOC_CTX *mem_ctx,
6476                                         struct policy_handle *handle /* [in] [ref] */,
6477                                         struct lsa_String *name /* [in] [ref] */,
6478                                         struct lsa_DATA_BUF **val /* [in,out] [ref] */)
6479 {
6480         struct lsa_RetrievePrivateData r;
6481         NTSTATUS status;
6482
6483         /* In parameters */
6484         r.in.handle = handle;
6485         r.in.name = name;
6486         r.in.val = val;
6487
6488         status = cli->dispatch(cli,
6489                                 mem_ctx,
6490                                 &ndr_table_lsarpc,
6491                                 NDR_LSA_RETRIEVEPRIVATEDATA,
6492                                 &r);
6493
6494         if (!NT_STATUS_IS_OK(status)) {
6495                 return status;
6496         }
6497
6498         if (NT_STATUS_IS_ERR(status)) {
6499                 return status;
6500         }
6501
6502         /* Return variables */
6503         *val = *r.out.val;
6504
6505         /* Return result */
6506         return r.out.result;
6507 }
6508
6509 struct rpccli_lsa_OpenPolicy2_state {
6510         struct lsa_OpenPolicy2 orig;
6511         struct lsa_OpenPolicy2 tmp;
6512         TALLOC_CTX *out_mem_ctx;
6513         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6514 };
6515
6516 static void rpccli_lsa_OpenPolicy2_done(struct tevent_req *subreq);
6517
6518 struct tevent_req *rpccli_lsa_OpenPolicy2_send(TALLOC_CTX *mem_ctx,
6519                                                struct tevent_context *ev,
6520                                                struct rpc_pipe_client *cli,
6521                                                const char *_system_name /* [in] [unique,charset(UTF16)] */,
6522                                                struct lsa_ObjectAttribute *_attr /* [in] [ref] */,
6523                                                uint32_t _access_mask /* [in]  */,
6524                                                struct policy_handle *_handle /* [out] [ref] */)
6525 {
6526         struct tevent_req *req;
6527         struct rpccli_lsa_OpenPolicy2_state *state;
6528         struct tevent_req *subreq;
6529
6530         req = tevent_req_create(mem_ctx, &state,
6531                                 struct rpccli_lsa_OpenPolicy2_state);
6532         if (req == NULL) {
6533                 return NULL;
6534         }
6535         state->out_mem_ctx = NULL;
6536         state->dispatch_recv = cli->dispatch_recv;
6537
6538         /* In parameters */
6539         state->orig.in.system_name = _system_name;
6540         state->orig.in.attr = _attr;
6541         state->orig.in.access_mask = _access_mask;
6542
6543         /* Out parameters */
6544         state->orig.out.handle = _handle;
6545
6546         /* Result */
6547         ZERO_STRUCT(state->orig.out.result);
6548
6549         state->out_mem_ctx = talloc_named_const(state, 0,
6550                              "rpccli_lsa_OpenPolicy2_out_memory");
6551         if (tevent_req_nomem(state->out_mem_ctx, req)) {
6552                 return tevent_req_post(req, ev);
6553         }
6554
6555         /* make a temporary copy, that we pass to the dispatch function */
6556         state->tmp = state->orig;
6557
6558         subreq = cli->dispatch_send(state, ev, cli,
6559                                     &ndr_table_lsarpc,
6560                                     NDR_LSA_OPENPOLICY2,
6561                                     &state->tmp);
6562         if (tevent_req_nomem(subreq, req)) {
6563                 return tevent_req_post(req, ev);
6564         }
6565         tevent_req_set_callback(subreq, rpccli_lsa_OpenPolicy2_done, req);
6566         return req;
6567 }
6568
6569 static void rpccli_lsa_OpenPolicy2_done(struct tevent_req *subreq)
6570 {
6571         struct tevent_req *req = tevent_req_callback_data(
6572                 subreq, struct tevent_req);
6573         struct rpccli_lsa_OpenPolicy2_state *state = tevent_req_data(
6574                 req, struct rpccli_lsa_OpenPolicy2_state);
6575         NTSTATUS status;
6576         TALLOC_CTX *mem_ctx;
6577
6578         if (state->out_mem_ctx) {
6579                 mem_ctx = state->out_mem_ctx;
6580         } else {
6581                 mem_ctx = state;
6582         }
6583
6584         status = state->dispatch_recv(subreq, mem_ctx);
6585         TALLOC_FREE(subreq);
6586         if (!NT_STATUS_IS_OK(status)) {
6587                 tevent_req_nterror(req, status);
6588                 return;
6589         }
6590
6591         /* Copy out parameters */
6592         *state->orig.out.handle = *state->tmp.out.handle;
6593
6594         /* Copy result */
6595         state->orig.out.result = state->tmp.out.result;
6596
6597         /* Reset temporary structure */
6598         ZERO_STRUCT(state->tmp);
6599
6600         tevent_req_done(req);
6601 }
6602
6603 NTSTATUS rpccli_lsa_OpenPolicy2_recv(struct tevent_req *req,
6604                                      TALLOC_CTX *mem_ctx,
6605                                      NTSTATUS *result)
6606 {
6607         struct rpccli_lsa_OpenPolicy2_state *state = tevent_req_data(
6608                 req, struct rpccli_lsa_OpenPolicy2_state);
6609         NTSTATUS status;
6610
6611         if (tevent_req_is_nterror(req, &status)) {
6612                 tevent_req_received(req);
6613                 return status;
6614         }
6615
6616         /* Steal possbile out parameters to the callers context */
6617         talloc_steal(mem_ctx, state->out_mem_ctx);
6618
6619         /* Return result */
6620         *result = state->orig.out.result;
6621
6622         tevent_req_received(req);
6623         return NT_STATUS_OK;
6624 }
6625
6626 NTSTATUS rpccli_lsa_OpenPolicy2(struct rpc_pipe_client *cli,
6627                                 TALLOC_CTX *mem_ctx,
6628                                 const char *system_name /* [in] [unique,charset(UTF16)] */,
6629                                 struct lsa_ObjectAttribute *attr /* [in] [ref] */,
6630                                 uint32_t access_mask /* [in]  */,
6631                                 struct policy_handle *handle /* [out] [ref] */)
6632 {
6633         struct lsa_OpenPolicy2 r;
6634         NTSTATUS status;
6635
6636         /* In parameters */
6637         r.in.system_name = system_name;
6638         r.in.attr = attr;
6639         r.in.access_mask = access_mask;
6640
6641         status = cli->dispatch(cli,
6642                                 mem_ctx,
6643                                 &ndr_table_lsarpc,
6644                                 NDR_LSA_OPENPOLICY2,
6645                                 &r);
6646
6647         if (!NT_STATUS_IS_OK(status)) {
6648                 return status;
6649         }
6650
6651         if (NT_STATUS_IS_ERR(status)) {
6652                 return status;
6653         }
6654
6655         /* Return variables */
6656         *handle = *r.out.handle;
6657
6658         /* Return result */
6659         return r.out.result;
6660 }
6661
6662 struct rpccli_lsa_GetUserName_state {
6663         struct lsa_GetUserName orig;
6664         struct lsa_GetUserName tmp;
6665         TALLOC_CTX *out_mem_ctx;
6666         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6667 };
6668
6669 static void rpccli_lsa_GetUserName_done(struct tevent_req *subreq);
6670
6671 struct tevent_req *rpccli_lsa_GetUserName_send(TALLOC_CTX *mem_ctx,
6672                                                struct tevent_context *ev,
6673                                                struct rpc_pipe_client *cli,
6674                                                const char *_system_name /* [in] [unique,charset(UTF16)] */,
6675                                                struct lsa_String **_account_name /* [in,out] [ref] */,
6676                                                struct lsa_String **_authority_name /* [in,out] [unique] */)
6677 {
6678         struct tevent_req *req;
6679         struct rpccli_lsa_GetUserName_state *state;
6680         struct tevent_req *subreq;
6681
6682         req = tevent_req_create(mem_ctx, &state,
6683                                 struct rpccli_lsa_GetUserName_state);
6684         if (req == NULL) {
6685                 return NULL;
6686         }
6687         state->out_mem_ctx = NULL;
6688         state->dispatch_recv = cli->dispatch_recv;
6689
6690         /* In parameters */
6691         state->orig.in.system_name = _system_name;
6692         state->orig.in.account_name = _account_name;
6693         state->orig.in.authority_name = _authority_name;
6694
6695         /* Out parameters */
6696         state->orig.out.account_name = _account_name;
6697         state->orig.out.authority_name = _authority_name;
6698
6699         /* Result */
6700         ZERO_STRUCT(state->orig.out.result);
6701
6702         state->out_mem_ctx = talloc_named_const(state, 0,
6703                              "rpccli_lsa_GetUserName_out_memory");
6704         if (tevent_req_nomem(state->out_mem_ctx, req)) {
6705                 return tevent_req_post(req, ev);
6706         }
6707
6708         /* make a temporary copy, that we pass to the dispatch function */
6709         state->tmp = state->orig;
6710
6711         subreq = cli->dispatch_send(state, ev, cli,
6712                                     &ndr_table_lsarpc,
6713                                     NDR_LSA_GETUSERNAME,
6714                                     &state->tmp);
6715         if (tevent_req_nomem(subreq, req)) {
6716                 return tevent_req_post(req, ev);
6717         }
6718         tevent_req_set_callback(subreq, rpccli_lsa_GetUserName_done, req);
6719         return req;
6720 }
6721
6722 static void rpccli_lsa_GetUserName_done(struct tevent_req *subreq)
6723 {
6724         struct tevent_req *req = tevent_req_callback_data(
6725                 subreq, struct tevent_req);
6726         struct rpccli_lsa_GetUserName_state *state = tevent_req_data(
6727                 req, struct rpccli_lsa_GetUserName_state);
6728         NTSTATUS status;
6729         TALLOC_CTX *mem_ctx;
6730
6731         if (state->out_mem_ctx) {
6732                 mem_ctx = state->out_mem_ctx;
6733         } else {
6734                 mem_ctx = state;
6735         }
6736
6737         status = state->dispatch_recv(subreq, mem_ctx);
6738         TALLOC_FREE(subreq);
6739         if (!NT_STATUS_IS_OK(status)) {
6740                 tevent_req_nterror(req, status);
6741                 return;
6742         }
6743
6744         /* Copy out parameters */
6745         *state->orig.out.account_name = *state->tmp.out.account_name;
6746         if (state->orig.out.authority_name && state->tmp.out.authority_name) {
6747                 *state->orig.out.authority_name = *state->tmp.out.authority_name;
6748         }
6749
6750         /* Copy result */
6751         state->orig.out.result = state->tmp.out.result;
6752
6753         /* Reset temporary structure */
6754         ZERO_STRUCT(state->tmp);
6755
6756         tevent_req_done(req);
6757 }
6758
6759 NTSTATUS rpccli_lsa_GetUserName_recv(struct tevent_req *req,
6760                                      TALLOC_CTX *mem_ctx,
6761                                      NTSTATUS *result)
6762 {
6763         struct rpccli_lsa_GetUserName_state *state = tevent_req_data(
6764                 req, struct rpccli_lsa_GetUserName_state);
6765         NTSTATUS status;
6766
6767         if (tevent_req_is_nterror(req, &status)) {
6768                 tevent_req_received(req);
6769                 return status;
6770         }
6771
6772         /* Steal possbile out parameters to the callers context */
6773         talloc_steal(mem_ctx, state->out_mem_ctx);
6774
6775         /* Return result */
6776         *result = state->orig.out.result;
6777
6778         tevent_req_received(req);
6779         return NT_STATUS_OK;
6780 }
6781
6782 NTSTATUS rpccli_lsa_GetUserName(struct rpc_pipe_client *cli,
6783                                 TALLOC_CTX *mem_ctx,
6784                                 const char *system_name /* [in] [unique,charset(UTF16)] */,
6785                                 struct lsa_String **account_name /* [in,out] [ref] */,
6786                                 struct lsa_String **authority_name /* [in,out] [unique] */)
6787 {
6788         struct lsa_GetUserName r;
6789         NTSTATUS status;
6790
6791         /* In parameters */
6792         r.in.system_name = system_name;
6793         r.in.account_name = account_name;
6794         r.in.authority_name = authority_name;
6795
6796         status = cli->dispatch(cli,
6797                                 mem_ctx,
6798                                 &ndr_table_lsarpc,
6799                                 NDR_LSA_GETUSERNAME,
6800                                 &r);
6801
6802         if (!NT_STATUS_IS_OK(status)) {
6803                 return status;
6804         }
6805
6806         if (NT_STATUS_IS_ERR(status)) {
6807                 return status;
6808         }
6809
6810         /* Return variables */
6811         *account_name = *r.out.account_name;
6812         if (authority_name && r.out.authority_name) {
6813                 *authority_name = *r.out.authority_name;
6814         }
6815
6816         /* Return result */
6817         return r.out.result;
6818 }
6819
6820 struct rpccli_lsa_QueryInfoPolicy2_state {
6821         struct lsa_QueryInfoPolicy2 orig;
6822         struct lsa_QueryInfoPolicy2 tmp;
6823         TALLOC_CTX *out_mem_ctx;
6824         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6825 };
6826
6827 static void rpccli_lsa_QueryInfoPolicy2_done(struct tevent_req *subreq);
6828
6829 struct tevent_req *rpccli_lsa_QueryInfoPolicy2_send(TALLOC_CTX *mem_ctx,
6830                                                     struct tevent_context *ev,
6831                                                     struct rpc_pipe_client *cli,
6832                                                     struct policy_handle *_handle /* [in] [ref] */,
6833                                                     enum lsa_PolicyInfo _level /* [in]  */,
6834                                                     union lsa_PolicyInformation **_info /* [out] [ref,switch_is(level)] */)
6835 {
6836         struct tevent_req *req;
6837         struct rpccli_lsa_QueryInfoPolicy2_state *state;
6838         struct tevent_req *subreq;
6839
6840         req = tevent_req_create(mem_ctx, &state,
6841                                 struct rpccli_lsa_QueryInfoPolicy2_state);
6842         if (req == NULL) {
6843                 return NULL;
6844         }
6845         state->out_mem_ctx = NULL;
6846         state->dispatch_recv = cli->dispatch_recv;
6847
6848         /* In parameters */
6849         state->orig.in.handle = _handle;
6850         state->orig.in.level = _level;
6851
6852         /* Out parameters */
6853         state->orig.out.info = _info;
6854
6855         /* Result */
6856         ZERO_STRUCT(state->orig.out.result);
6857
6858         state->out_mem_ctx = talloc_named_const(state, 0,
6859                              "rpccli_lsa_QueryInfoPolicy2_out_memory");
6860         if (tevent_req_nomem(state->out_mem_ctx, req)) {
6861                 return tevent_req_post(req, ev);
6862         }
6863
6864         /* make a temporary copy, that we pass to the dispatch function */
6865         state->tmp = state->orig;
6866
6867         subreq = cli->dispatch_send(state, ev, cli,
6868                                     &ndr_table_lsarpc,
6869                                     NDR_LSA_QUERYINFOPOLICY2,
6870                                     &state->tmp);
6871         if (tevent_req_nomem(subreq, req)) {
6872                 return tevent_req_post(req, ev);
6873         }
6874         tevent_req_set_callback(subreq, rpccli_lsa_QueryInfoPolicy2_done, req);
6875         return req;
6876 }
6877
6878 static void rpccli_lsa_QueryInfoPolicy2_done(struct tevent_req *subreq)
6879 {
6880         struct tevent_req *req = tevent_req_callback_data(
6881                 subreq, struct tevent_req);
6882         struct rpccli_lsa_QueryInfoPolicy2_state *state = tevent_req_data(
6883                 req, struct rpccli_lsa_QueryInfoPolicy2_state);
6884         NTSTATUS status;
6885         TALLOC_CTX *mem_ctx;
6886
6887         if (state->out_mem_ctx) {
6888                 mem_ctx = state->out_mem_ctx;
6889         } else {
6890                 mem_ctx = state;
6891         }
6892
6893         status = state->dispatch_recv(subreq, mem_ctx);
6894         TALLOC_FREE(subreq);
6895         if (!NT_STATUS_IS_OK(status)) {
6896                 tevent_req_nterror(req, status);
6897                 return;
6898         }
6899
6900         /* Copy out parameters */
6901         *state->orig.out.info = *state->tmp.out.info;
6902
6903         /* Copy result */
6904         state->orig.out.result = state->tmp.out.result;
6905
6906         /* Reset temporary structure */
6907         ZERO_STRUCT(state->tmp);
6908
6909         tevent_req_done(req);
6910 }
6911
6912 NTSTATUS rpccli_lsa_QueryInfoPolicy2_recv(struct tevent_req *req,
6913                                           TALLOC_CTX *mem_ctx,
6914                                           NTSTATUS *result)
6915 {
6916         struct rpccli_lsa_QueryInfoPolicy2_state *state = tevent_req_data(
6917                 req, struct rpccli_lsa_QueryInfoPolicy2_state);
6918         NTSTATUS status;
6919
6920         if (tevent_req_is_nterror(req, &status)) {
6921                 tevent_req_received(req);
6922                 return status;
6923         }
6924
6925         /* Steal possbile out parameters to the callers context */
6926         talloc_steal(mem_ctx, state->out_mem_ctx);
6927
6928         /* Return result */
6929         *result = state->orig.out.result;
6930
6931         tevent_req_received(req);
6932         return NT_STATUS_OK;
6933 }
6934
6935 NTSTATUS rpccli_lsa_QueryInfoPolicy2(struct rpc_pipe_client *cli,
6936                                      TALLOC_CTX *mem_ctx,
6937                                      struct policy_handle *handle /* [in] [ref] */,
6938                                      enum lsa_PolicyInfo level /* [in]  */,
6939                                      union lsa_PolicyInformation **info /* [out] [ref,switch_is(level)] */)
6940 {
6941         struct lsa_QueryInfoPolicy2 r;
6942         NTSTATUS status;
6943
6944         /* In parameters */
6945         r.in.handle = handle;
6946         r.in.level = level;
6947
6948         status = cli->dispatch(cli,
6949                                 mem_ctx,
6950                                 &ndr_table_lsarpc,
6951                                 NDR_LSA_QUERYINFOPOLICY2,
6952                                 &r);
6953
6954         if (!NT_STATUS_IS_OK(status)) {
6955                 return status;
6956         }
6957
6958         if (NT_STATUS_IS_ERR(status)) {
6959                 return status;
6960         }
6961
6962         /* Return variables */
6963         *info = *r.out.info;
6964
6965         /* Return result */
6966         return r.out.result;
6967 }
6968
6969 struct rpccli_lsa_SetInfoPolicy2_state {
6970         struct lsa_SetInfoPolicy2 orig;
6971         struct lsa_SetInfoPolicy2 tmp;
6972         TALLOC_CTX *out_mem_ctx;
6973         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6974 };
6975
6976 static void rpccli_lsa_SetInfoPolicy2_done(struct tevent_req *subreq);
6977
6978 struct tevent_req *rpccli_lsa_SetInfoPolicy2_send(TALLOC_CTX *mem_ctx,
6979                                                   struct tevent_context *ev,
6980                                                   struct rpc_pipe_client *cli,
6981                                                   struct policy_handle *_handle /* [in] [ref] */,
6982                                                   enum lsa_PolicyInfo _level /* [in]  */,
6983                                                   union lsa_PolicyInformation *_info /* [in] [ref,switch_is(level)] */)
6984 {
6985         struct tevent_req *req;
6986         struct rpccli_lsa_SetInfoPolicy2_state *state;
6987         struct tevent_req *subreq;
6988
6989         req = tevent_req_create(mem_ctx, &state,
6990                                 struct rpccli_lsa_SetInfoPolicy2_state);
6991         if (req == NULL) {
6992                 return NULL;
6993         }
6994         state->out_mem_ctx = NULL;
6995         state->dispatch_recv = cli->dispatch_recv;
6996
6997         /* In parameters */
6998         state->orig.in.handle = _handle;
6999         state->orig.in.level = _level;
7000         state->orig.in.info = _info;
7001
7002         /* Out parameters */
7003
7004         /* Result */
7005         ZERO_STRUCT(state->orig.out.result);
7006
7007         /* make a temporary copy, that we pass to the dispatch function */
7008         state->tmp = state->orig;
7009
7010         subreq = cli->dispatch_send(state, ev, cli,
7011                                     &ndr_table_lsarpc,
7012                                     NDR_LSA_SETINFOPOLICY2,
7013                                     &state->tmp);
7014         if (tevent_req_nomem(subreq, req)) {
7015                 return tevent_req_post(req, ev);
7016         }
7017         tevent_req_set_callback(subreq, rpccli_lsa_SetInfoPolicy2_done, req);
7018         return req;
7019 }
7020
7021 static void rpccli_lsa_SetInfoPolicy2_done(struct tevent_req *subreq)
7022 {
7023         struct tevent_req *req = tevent_req_callback_data(
7024                 subreq, struct tevent_req);
7025         struct rpccli_lsa_SetInfoPolicy2_state *state = tevent_req_data(
7026                 req, struct rpccli_lsa_SetInfoPolicy2_state);
7027         NTSTATUS status;
7028         TALLOC_CTX *mem_ctx;
7029
7030         if (state->out_mem_ctx) {
7031                 mem_ctx = state->out_mem_ctx;
7032         } else {
7033                 mem_ctx = state;
7034         }
7035
7036         status = state->dispatch_recv(subreq, mem_ctx);
7037         TALLOC_FREE(subreq);
7038         if (!NT_STATUS_IS_OK(status)) {
7039                 tevent_req_nterror(req, status);
7040                 return;
7041         }
7042
7043         /* Copy out parameters */
7044
7045         /* Copy result */
7046         state->orig.out.result = state->tmp.out.result;
7047
7048         /* Reset temporary structure */
7049         ZERO_STRUCT(state->tmp);
7050
7051         tevent_req_done(req);
7052 }
7053
7054 NTSTATUS rpccli_lsa_SetInfoPolicy2_recv(struct tevent_req *req,
7055                                         TALLOC_CTX *mem_ctx,
7056                                         NTSTATUS *result)
7057 {
7058         struct rpccli_lsa_SetInfoPolicy2_state *state = tevent_req_data(
7059                 req, struct rpccli_lsa_SetInfoPolicy2_state);
7060         NTSTATUS status;
7061
7062         if (tevent_req_is_nterror(req, &status)) {
7063                 tevent_req_received(req);
7064                 return status;
7065         }
7066
7067         /* Steal possbile out parameters to the callers context */
7068         talloc_steal(mem_ctx, state->out_mem_ctx);
7069
7070         /* Return result */
7071         *result = state->orig.out.result;
7072
7073         tevent_req_received(req);
7074         return NT_STATUS_OK;
7075 }
7076
7077 NTSTATUS rpccli_lsa_SetInfoPolicy2(struct rpc_pipe_client *cli,
7078                                    TALLOC_CTX *mem_ctx,
7079                                    struct policy_handle *handle /* [in] [ref] */,
7080                                    enum lsa_PolicyInfo level /* [in]  */,
7081                                    union lsa_PolicyInformation *info /* [in] [ref,switch_is(level)] */)
7082 {
7083         struct lsa_SetInfoPolicy2 r;
7084         NTSTATUS status;
7085
7086         /* In parameters */
7087         r.in.handle = handle;
7088         r.in.level = level;
7089         r.in.info = info;
7090
7091         status = cli->dispatch(cli,
7092                                 mem_ctx,
7093                                 &ndr_table_lsarpc,
7094                                 NDR_LSA_SETINFOPOLICY2,
7095                                 &r);
7096
7097         if (!NT_STATUS_IS_OK(status)) {
7098                 return status;
7099         }
7100
7101         if (NT_STATUS_IS_ERR(status)) {
7102                 return status;
7103         }
7104
7105         /* Return variables */
7106
7107         /* Return result */
7108         return r.out.result;
7109 }
7110
7111 struct rpccli_lsa_QueryTrustedDomainInfoByName_state {
7112         struct lsa_QueryTrustedDomainInfoByName orig;
7113         struct lsa_QueryTrustedDomainInfoByName tmp;
7114         TALLOC_CTX *out_mem_ctx;
7115         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7116 };
7117
7118 static void rpccli_lsa_QueryTrustedDomainInfoByName_done(struct tevent_req *subreq);
7119
7120 struct tevent_req *rpccli_lsa_QueryTrustedDomainInfoByName_send(TALLOC_CTX *mem_ctx,
7121                                                                 struct tevent_context *ev,
7122                                                                 struct rpc_pipe_client *cli,
7123                                                                 struct policy_handle *_handle /* [in] [ref] */,
7124                                                                 struct lsa_String *_trusted_domain /* [in] [ref] */,
7125                                                                 enum lsa_TrustDomInfoEnum _level /* [in]  */,
7126                                                                 union lsa_TrustedDomainInfo **_info /* [out] [ref,switch_is(level)] */)
7127 {
7128         struct tevent_req *req;
7129         struct rpccli_lsa_QueryTrustedDomainInfoByName_state *state;
7130         struct tevent_req *subreq;
7131
7132         req = tevent_req_create(mem_ctx, &state,
7133                                 struct rpccli_lsa_QueryTrustedDomainInfoByName_state);
7134         if (req == NULL) {
7135                 return NULL;
7136         }
7137         state->out_mem_ctx = NULL;
7138         state->dispatch_recv = cli->dispatch_recv;
7139
7140         /* In parameters */
7141         state->orig.in.handle = _handle;
7142         state->orig.in.trusted_domain = _trusted_domain;
7143         state->orig.in.level = _level;
7144
7145         /* Out parameters */
7146         state->orig.out.info = _info;
7147
7148         /* Result */
7149         ZERO_STRUCT(state->orig.out.result);
7150
7151         state->out_mem_ctx = talloc_named_const(state, 0,
7152                              "rpccli_lsa_QueryTrustedDomainInfoByName_out_memory");
7153         if (tevent_req_nomem(state->out_mem_ctx, req)) {
7154                 return tevent_req_post(req, ev);
7155         }
7156
7157         /* make a temporary copy, that we pass to the dispatch function */
7158         state->tmp = state->orig;
7159
7160         subreq = cli->dispatch_send(state, ev, cli,
7161                                     &ndr_table_lsarpc,
7162                                     NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME,
7163                                     &state->tmp);
7164         if (tevent_req_nomem(subreq, req)) {
7165                 return tevent_req_post(req, ev);
7166         }
7167         tevent_req_set_callback(subreq, rpccli_lsa_QueryTrustedDomainInfoByName_done, req);
7168         return req;
7169 }
7170
7171 static void rpccli_lsa_QueryTrustedDomainInfoByName_done(struct tevent_req *subreq)
7172 {
7173         struct tevent_req *req = tevent_req_callback_data(
7174                 subreq, struct tevent_req);
7175         struct rpccli_lsa_QueryTrustedDomainInfoByName_state *state = tevent_req_data(
7176                 req, struct rpccli_lsa_QueryTrustedDomainInfoByName_state);
7177         NTSTATUS status;
7178         TALLOC_CTX *mem_ctx;
7179
7180         if (state->out_mem_ctx) {
7181                 mem_ctx = state->out_mem_ctx;
7182         } else {
7183                 mem_ctx = state;
7184         }
7185
7186         status = state->dispatch_recv(subreq, mem_ctx);
7187         TALLOC_FREE(subreq);
7188         if (!NT_STATUS_IS_OK(status)) {
7189                 tevent_req_nterror(req, status);
7190                 return;
7191         }
7192
7193         /* Copy out parameters */
7194         *state->orig.out.info = *state->tmp.out.info;
7195
7196         /* Copy result */
7197         state->orig.out.result = state->tmp.out.result;
7198
7199         /* Reset temporary structure */
7200         ZERO_STRUCT(state->tmp);
7201
7202         tevent_req_done(req);
7203 }
7204
7205 NTSTATUS rpccli_lsa_QueryTrustedDomainInfoByName_recv(struct tevent_req *req,
7206                                                       TALLOC_CTX *mem_ctx,
7207                                                       NTSTATUS *result)
7208 {
7209         struct rpccli_lsa_QueryTrustedDomainInfoByName_state *state = tevent_req_data(
7210                 req, struct rpccli_lsa_QueryTrustedDomainInfoByName_state);
7211         NTSTATUS status;
7212
7213         if (tevent_req_is_nterror(req, &status)) {
7214                 tevent_req_received(req);
7215                 return status;
7216         }
7217
7218         /* Steal possbile out parameters to the callers context */
7219         talloc_steal(mem_ctx, state->out_mem_ctx);
7220
7221         /* Return result */
7222         *result = state->orig.out.result;
7223
7224         tevent_req_received(req);
7225         return NT_STATUS_OK;
7226 }
7227
7228 NTSTATUS rpccli_lsa_QueryTrustedDomainInfoByName(struct rpc_pipe_client *cli,
7229                                                  TALLOC_CTX *mem_ctx,
7230                                                  struct policy_handle *handle /* [in] [ref] */,
7231                                                  struct lsa_String *trusted_domain /* [in] [ref] */,
7232                                                  enum lsa_TrustDomInfoEnum level /* [in]  */,
7233                                                  union lsa_TrustedDomainInfo **info /* [out] [ref,switch_is(level)] */)
7234 {
7235         struct lsa_QueryTrustedDomainInfoByName r;
7236         NTSTATUS status;
7237
7238         /* In parameters */
7239         r.in.handle = handle;
7240         r.in.trusted_domain = trusted_domain;
7241         r.in.level = level;
7242
7243         status = cli->dispatch(cli,
7244                                 mem_ctx,
7245                                 &ndr_table_lsarpc,
7246                                 NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME,
7247                                 &r);
7248
7249         if (!NT_STATUS_IS_OK(status)) {
7250                 return status;
7251         }
7252
7253         if (NT_STATUS_IS_ERR(status)) {
7254                 return status;
7255         }
7256
7257         /* Return variables */
7258         *info = *r.out.info;
7259
7260         /* Return result */
7261         return r.out.result;
7262 }
7263
7264 struct rpccli_lsa_SetTrustedDomainInfoByName_state {
7265         struct lsa_SetTrustedDomainInfoByName orig;
7266         struct lsa_SetTrustedDomainInfoByName tmp;
7267         TALLOC_CTX *out_mem_ctx;
7268         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7269 };
7270
7271 static void rpccli_lsa_SetTrustedDomainInfoByName_done(struct tevent_req *subreq);
7272
7273 struct tevent_req *rpccli_lsa_SetTrustedDomainInfoByName_send(TALLOC_CTX *mem_ctx,
7274                                                               struct tevent_context *ev,
7275                                                               struct rpc_pipe_client *cli,
7276                                                               struct policy_handle *_handle /* [in] [ref] */,
7277                                                               struct lsa_String _trusted_domain /* [in]  */,
7278                                                               enum lsa_TrustDomInfoEnum _level /* [in]  */,
7279                                                               union lsa_TrustedDomainInfo *_info /* [in] [unique,switch_is(level)] */)
7280 {
7281         struct tevent_req *req;
7282         struct rpccli_lsa_SetTrustedDomainInfoByName_state *state;
7283         struct tevent_req *subreq;
7284
7285         req = tevent_req_create(mem_ctx, &state,
7286                                 struct rpccli_lsa_SetTrustedDomainInfoByName_state);
7287         if (req == NULL) {
7288                 return NULL;
7289         }
7290         state->out_mem_ctx = NULL;
7291         state->dispatch_recv = cli->dispatch_recv;
7292
7293         /* In parameters */
7294         state->orig.in.handle = _handle;
7295         state->orig.in.trusted_domain = _trusted_domain;
7296         state->orig.in.level = _level;
7297         state->orig.in.info = _info;
7298
7299         /* Out parameters */
7300
7301         /* Result */
7302         ZERO_STRUCT(state->orig.out.result);
7303
7304         /* make a temporary copy, that we pass to the dispatch function */
7305         state->tmp = state->orig;
7306
7307         subreq = cli->dispatch_send(state, ev, cli,
7308                                     &ndr_table_lsarpc,
7309                                     NDR_LSA_SETTRUSTEDDOMAININFOBYNAME,
7310                                     &state->tmp);
7311         if (tevent_req_nomem(subreq, req)) {
7312                 return tevent_req_post(req, ev);
7313         }
7314         tevent_req_set_callback(subreq, rpccli_lsa_SetTrustedDomainInfoByName_done, req);
7315         return req;
7316 }
7317
7318 static void rpccli_lsa_SetTrustedDomainInfoByName_done(struct tevent_req *subreq)
7319 {
7320         struct tevent_req *req = tevent_req_callback_data(
7321                 subreq, struct tevent_req);
7322         struct rpccli_lsa_SetTrustedDomainInfoByName_state *state = tevent_req_data(
7323                 req, struct rpccli_lsa_SetTrustedDomainInfoByName_state);
7324         NTSTATUS status;
7325         TALLOC_CTX *mem_ctx;
7326
7327         if (state->out_mem_ctx) {
7328                 mem_ctx = state->out_mem_ctx;
7329         } else {
7330                 mem_ctx = state;
7331         }
7332
7333         status = state->dispatch_recv(subreq, mem_ctx);
7334         TALLOC_FREE(subreq);
7335         if (!NT_STATUS_IS_OK(status)) {
7336                 tevent_req_nterror(req, status);
7337                 return;
7338         }
7339
7340         /* Copy out parameters */
7341
7342         /* Copy result */
7343         state->orig.out.result = state->tmp.out.result;
7344
7345         /* Reset temporary structure */
7346         ZERO_STRUCT(state->tmp);
7347
7348         tevent_req_done(req);
7349 }
7350
7351 NTSTATUS rpccli_lsa_SetTrustedDomainInfoByName_recv(struct tevent_req *req,
7352                                                     TALLOC_CTX *mem_ctx,
7353                                                     NTSTATUS *result)
7354 {
7355         struct rpccli_lsa_SetTrustedDomainInfoByName_state *state = tevent_req_data(
7356                 req, struct rpccli_lsa_SetTrustedDomainInfoByName_state);
7357         NTSTATUS status;
7358
7359         if (tevent_req_is_nterror(req, &status)) {
7360                 tevent_req_received(req);
7361                 return status;
7362         }
7363
7364         /* Steal possbile out parameters to the callers context */
7365         talloc_steal(mem_ctx, state->out_mem_ctx);
7366
7367         /* Return result */
7368         *result = state->orig.out.result;
7369
7370         tevent_req_received(req);
7371         return NT_STATUS_OK;
7372 }
7373
7374 NTSTATUS rpccli_lsa_SetTrustedDomainInfoByName(struct rpc_pipe_client *cli,
7375                                                TALLOC_CTX *mem_ctx,
7376                                                struct policy_handle *handle /* [in] [ref] */,
7377                                                struct lsa_String trusted_domain /* [in]  */,
7378                                                enum lsa_TrustDomInfoEnum level /* [in]  */,
7379                                                union lsa_TrustedDomainInfo *info /* [in] [unique,switch_is(level)] */)
7380 {
7381         struct lsa_SetTrustedDomainInfoByName r;
7382         NTSTATUS status;
7383
7384         /* In parameters */
7385         r.in.handle = handle;
7386         r.in.trusted_domain = trusted_domain;
7387         r.in.level = level;
7388         r.in.info = info;
7389
7390         status = cli->dispatch(cli,
7391                                 mem_ctx,
7392                                 &ndr_table_lsarpc,
7393                                 NDR_LSA_SETTRUSTEDDOMAININFOBYNAME,
7394                                 &r);
7395
7396         if (!NT_STATUS_IS_OK(status)) {
7397                 return status;
7398         }
7399
7400         if (NT_STATUS_IS_ERR(status)) {
7401                 return status;
7402         }
7403
7404         /* Return variables */
7405
7406         /* Return result */
7407         return r.out.result;
7408 }
7409
7410 struct rpccli_lsa_EnumTrustedDomainsEx_state {
7411         struct lsa_EnumTrustedDomainsEx orig;
7412         struct lsa_EnumTrustedDomainsEx tmp;
7413         TALLOC_CTX *out_mem_ctx;
7414         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7415 };
7416
7417 static void rpccli_lsa_EnumTrustedDomainsEx_done(struct tevent_req *subreq);
7418
7419 struct tevent_req *rpccli_lsa_EnumTrustedDomainsEx_send(TALLOC_CTX *mem_ctx,
7420                                                         struct tevent_context *ev,
7421                                                         struct rpc_pipe_client *cli,
7422                                                         struct policy_handle *_handle /* [in] [ref] */,
7423                                                         uint32_t *_resume_handle /* [in,out] [ref] */,
7424                                                         struct lsa_DomainListEx *_domains /* [out] [ref] */,
7425                                                         uint32_t _max_size /* [in]  */)
7426 {
7427         struct tevent_req *req;
7428         struct rpccli_lsa_EnumTrustedDomainsEx_state *state;
7429         struct tevent_req *subreq;
7430
7431         req = tevent_req_create(mem_ctx, &state,
7432                                 struct rpccli_lsa_EnumTrustedDomainsEx_state);
7433         if (req == NULL) {
7434                 return NULL;
7435         }
7436         state->out_mem_ctx = NULL;
7437         state->dispatch_recv = cli->dispatch_recv;
7438
7439         /* In parameters */
7440         state->orig.in.handle = _handle;
7441         state->orig.in.resume_handle = _resume_handle;
7442         state->orig.in.max_size = _max_size;
7443
7444         /* Out parameters */
7445         state->orig.out.resume_handle = _resume_handle;
7446         state->orig.out.domains = _domains;
7447
7448         /* Result */
7449         ZERO_STRUCT(state->orig.out.result);
7450
7451         state->out_mem_ctx = talloc_named_const(state, 0,
7452                              "rpccli_lsa_EnumTrustedDomainsEx_out_memory");
7453         if (tevent_req_nomem(state->out_mem_ctx, req)) {
7454                 return tevent_req_post(req, ev);
7455         }
7456
7457         /* make a temporary copy, that we pass to the dispatch function */
7458         state->tmp = state->orig;
7459
7460         subreq = cli->dispatch_send(state, ev, cli,
7461                                     &ndr_table_lsarpc,
7462                                     NDR_LSA_ENUMTRUSTEDDOMAINSEX,
7463                                     &state->tmp);
7464         if (tevent_req_nomem(subreq, req)) {
7465                 return tevent_req_post(req, ev);
7466         }
7467         tevent_req_set_callback(subreq, rpccli_lsa_EnumTrustedDomainsEx_done, req);
7468         return req;
7469 }
7470
7471 static void rpccli_lsa_EnumTrustedDomainsEx_done(struct tevent_req *subreq)
7472 {
7473         struct tevent_req *req = tevent_req_callback_data(
7474                 subreq, struct tevent_req);
7475         struct rpccli_lsa_EnumTrustedDomainsEx_state *state = tevent_req_data(
7476                 req, struct rpccli_lsa_EnumTrustedDomainsEx_state);
7477         NTSTATUS status;
7478         TALLOC_CTX *mem_ctx;
7479
7480         if (state->out_mem_ctx) {
7481                 mem_ctx = state->out_mem_ctx;
7482         } else {
7483                 mem_ctx = state;
7484         }
7485
7486         status = state->dispatch_recv(subreq, mem_ctx);
7487         TALLOC_FREE(subreq);
7488         if (!NT_STATUS_IS_OK(status)) {
7489                 tevent_req_nterror(req, status);
7490                 return;
7491         }
7492
7493         /* Copy out parameters */
7494         *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
7495         *state->orig.out.domains = *state->tmp.out.domains;
7496
7497         /* Copy result */
7498         state->orig.out.result = state->tmp.out.result;
7499
7500         /* Reset temporary structure */
7501         ZERO_STRUCT(state->tmp);
7502
7503         tevent_req_done(req);
7504 }
7505
7506 NTSTATUS rpccli_lsa_EnumTrustedDomainsEx_recv(struct tevent_req *req,
7507                                               TALLOC_CTX *mem_ctx,
7508                                               NTSTATUS *result)
7509 {
7510         struct rpccli_lsa_EnumTrustedDomainsEx_state *state = tevent_req_data(
7511                 req, struct rpccli_lsa_EnumTrustedDomainsEx_state);
7512         NTSTATUS status;
7513
7514         if (tevent_req_is_nterror(req, &status)) {
7515                 tevent_req_received(req);
7516                 return status;
7517         }
7518
7519         /* Steal possbile out parameters to the callers context */
7520         talloc_steal(mem_ctx, state->out_mem_ctx);
7521
7522         /* Return result */
7523         *result = state->orig.out.result;
7524
7525         tevent_req_received(req);
7526         return NT_STATUS_OK;
7527 }
7528
7529 NTSTATUS rpccli_lsa_EnumTrustedDomainsEx(struct rpc_pipe_client *cli,
7530                                          TALLOC_CTX *mem_ctx,
7531                                          struct policy_handle *handle /* [in] [ref] */,
7532                                          uint32_t *resume_handle /* [in,out] [ref] */,
7533                                          struct lsa_DomainListEx *domains /* [out] [ref] */,
7534                                          uint32_t max_size /* [in]  */)
7535 {
7536         struct lsa_EnumTrustedDomainsEx r;
7537         NTSTATUS status;
7538
7539         /* In parameters */
7540         r.in.handle = handle;
7541         r.in.resume_handle = resume_handle;
7542         r.in.max_size = max_size;
7543
7544         status = cli->dispatch(cli,
7545                                 mem_ctx,
7546                                 &ndr_table_lsarpc,
7547                                 NDR_LSA_ENUMTRUSTEDDOMAINSEX,
7548                                 &r);
7549
7550         if (!NT_STATUS_IS_OK(status)) {
7551                 return status;
7552         }
7553
7554         if (NT_STATUS_IS_ERR(status)) {
7555                 return status;
7556         }
7557
7558         /* Return variables */
7559         *resume_handle = *r.out.resume_handle;
7560         *domains = *r.out.domains;
7561
7562         /* Return result */
7563         return r.out.result;
7564 }
7565
7566 struct rpccli_lsa_CreateTrustedDomainEx_state {
7567         struct lsa_CreateTrustedDomainEx orig;
7568         struct lsa_CreateTrustedDomainEx tmp;
7569         TALLOC_CTX *out_mem_ctx;
7570         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7571 };
7572
7573 static void rpccli_lsa_CreateTrustedDomainEx_done(struct tevent_req *subreq);
7574
7575 struct tevent_req *rpccli_lsa_CreateTrustedDomainEx_send(TALLOC_CTX *mem_ctx,
7576                                                          struct tevent_context *ev,
7577                                                          struct rpc_pipe_client *cli,
7578                                                          struct policy_handle *_policy_handle /* [in] [ref] */,
7579                                                          struct lsa_TrustDomainInfoInfoEx *_info /* [in] [ref] */,
7580                                                          struct lsa_TrustDomainInfoAuthInfoInternal *_auth_info /* [in] [ref] */,
7581                                                          uint32_t _access_mask /* [in]  */,
7582                                                          struct policy_handle *_trustdom_handle /* [out] [ref] */)
7583 {
7584         struct tevent_req *req;
7585         struct rpccli_lsa_CreateTrustedDomainEx_state *state;
7586         struct tevent_req *subreq;
7587
7588         req = tevent_req_create(mem_ctx, &state,
7589                                 struct rpccli_lsa_CreateTrustedDomainEx_state);
7590         if (req == NULL) {
7591                 return NULL;
7592         }
7593         state->out_mem_ctx = NULL;
7594         state->dispatch_recv = cli->dispatch_recv;
7595
7596         /* In parameters */
7597         state->orig.in.policy_handle = _policy_handle;
7598         state->orig.in.info = _info;
7599         state->orig.in.auth_info = _auth_info;
7600         state->orig.in.access_mask = _access_mask;
7601
7602         /* Out parameters */
7603         state->orig.out.trustdom_handle = _trustdom_handle;
7604
7605         /* Result */
7606         ZERO_STRUCT(state->orig.out.result);
7607
7608         state->out_mem_ctx = talloc_named_const(state, 0,
7609                              "rpccli_lsa_CreateTrustedDomainEx_out_memory");
7610         if (tevent_req_nomem(state->out_mem_ctx, req)) {
7611                 return tevent_req_post(req, ev);
7612         }
7613
7614         /* make a temporary copy, that we pass to the dispatch function */
7615         state->tmp = state->orig;
7616
7617         subreq = cli->dispatch_send(state, ev, cli,
7618                                     &ndr_table_lsarpc,
7619                                     NDR_LSA_CREATETRUSTEDDOMAINEX,
7620                                     &state->tmp);
7621         if (tevent_req_nomem(subreq, req)) {
7622                 return tevent_req_post(req, ev);
7623         }
7624         tevent_req_set_callback(subreq, rpccli_lsa_CreateTrustedDomainEx_done, req);
7625         return req;
7626 }
7627
7628 static void rpccli_lsa_CreateTrustedDomainEx_done(struct tevent_req *subreq)
7629 {
7630         struct tevent_req *req = tevent_req_callback_data(
7631                 subreq, struct tevent_req);
7632         struct rpccli_lsa_CreateTrustedDomainEx_state *state = tevent_req_data(
7633                 req, struct rpccli_lsa_CreateTrustedDomainEx_state);
7634         NTSTATUS status;
7635         TALLOC_CTX *mem_ctx;
7636
7637         if (state->out_mem_ctx) {
7638                 mem_ctx = state->out_mem_ctx;
7639         } else {
7640                 mem_ctx = state;
7641         }
7642
7643         status = state->dispatch_recv(subreq, mem_ctx);
7644         TALLOC_FREE(subreq);
7645         if (!NT_STATUS_IS_OK(status)) {
7646                 tevent_req_nterror(req, status);
7647                 return;
7648         }
7649
7650         /* Copy out parameters */
7651         *state->orig.out.trustdom_handle = *state->tmp.out.trustdom_handle;
7652
7653         /* Copy result */
7654         state->orig.out.result = state->tmp.out.result;
7655
7656         /* Reset temporary structure */
7657         ZERO_STRUCT(state->tmp);
7658
7659         tevent_req_done(req);
7660 }
7661
7662 NTSTATUS rpccli_lsa_CreateTrustedDomainEx_recv(struct tevent_req *req,
7663                                                TALLOC_CTX *mem_ctx,
7664                                                NTSTATUS *result)
7665 {
7666         struct rpccli_lsa_CreateTrustedDomainEx_state *state = tevent_req_data(
7667                 req, struct rpccli_lsa_CreateTrustedDomainEx_state);
7668         NTSTATUS status;
7669
7670         if (tevent_req_is_nterror(req, &status)) {
7671                 tevent_req_received(req);
7672                 return status;
7673         }
7674
7675         /* Steal possbile out parameters to the callers context */
7676         talloc_steal(mem_ctx, state->out_mem_ctx);
7677
7678         /* Return result */
7679         *result = state->orig.out.result;
7680
7681         tevent_req_received(req);
7682         return NT_STATUS_OK;
7683 }
7684
7685 NTSTATUS rpccli_lsa_CreateTrustedDomainEx(struct rpc_pipe_client *cli,
7686                                           TALLOC_CTX *mem_ctx,
7687                                           struct policy_handle *policy_handle /* [in] [ref] */,
7688                                           struct lsa_TrustDomainInfoInfoEx *info /* [in] [ref] */,
7689                                           struct lsa_TrustDomainInfoAuthInfoInternal *auth_info /* [in] [ref] */,
7690                                           uint32_t access_mask /* [in]  */,
7691                                           struct policy_handle *trustdom_handle /* [out] [ref] */)
7692 {
7693         struct lsa_CreateTrustedDomainEx r;
7694         NTSTATUS status;
7695
7696         /* In parameters */
7697         r.in.policy_handle = policy_handle;
7698         r.in.info = info;
7699         r.in.auth_info = auth_info;
7700         r.in.access_mask = access_mask;
7701
7702         status = cli->dispatch(cli,
7703                                 mem_ctx,
7704                                 &ndr_table_lsarpc,
7705                                 NDR_LSA_CREATETRUSTEDDOMAINEX,
7706                                 &r);
7707
7708         if (!NT_STATUS_IS_OK(status)) {
7709                 return status;
7710         }
7711
7712         if (NT_STATUS_IS_ERR(status)) {
7713                 return status;
7714         }
7715
7716         /* Return variables */
7717         *trustdom_handle = *r.out.trustdom_handle;
7718
7719         /* Return result */
7720         return r.out.result;
7721 }
7722
7723 struct rpccli_lsa_CloseTrustedDomainEx_state {
7724         struct lsa_CloseTrustedDomainEx orig;
7725         struct lsa_CloseTrustedDomainEx tmp;
7726         TALLOC_CTX *out_mem_ctx;
7727         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7728 };
7729
7730 static void rpccli_lsa_CloseTrustedDomainEx_done(struct tevent_req *subreq);
7731
7732 struct tevent_req *rpccli_lsa_CloseTrustedDomainEx_send(TALLOC_CTX *mem_ctx,
7733                                                         struct tevent_context *ev,
7734                                                         struct rpc_pipe_client *cli,
7735                                                         struct policy_handle *_handle /* [in,out] [ref] */)
7736 {
7737         struct tevent_req *req;
7738         struct rpccli_lsa_CloseTrustedDomainEx_state *state;
7739         struct tevent_req *subreq;
7740
7741         req = tevent_req_create(mem_ctx, &state,
7742                                 struct rpccli_lsa_CloseTrustedDomainEx_state);
7743         if (req == NULL) {
7744                 return NULL;
7745         }
7746         state->out_mem_ctx = NULL;
7747         state->dispatch_recv = cli->dispatch_recv;
7748
7749         /* In parameters */
7750         state->orig.in.handle = _handle;
7751
7752         /* Out parameters */
7753         state->orig.out.handle = _handle;
7754
7755         /* Result */
7756         ZERO_STRUCT(state->orig.out.result);
7757
7758         state->out_mem_ctx = talloc_named_const(state, 0,
7759                              "rpccli_lsa_CloseTrustedDomainEx_out_memory");
7760         if (tevent_req_nomem(state->out_mem_ctx, req)) {
7761                 return tevent_req_post(req, ev);
7762         }
7763
7764         /* make a temporary copy, that we pass to the dispatch function */
7765         state->tmp = state->orig;
7766
7767         subreq = cli->dispatch_send(state, ev, cli,
7768                                     &ndr_table_lsarpc,
7769                                     NDR_LSA_CLOSETRUSTEDDOMAINEX,
7770                                     &state->tmp);
7771         if (tevent_req_nomem(subreq, req)) {
7772                 return tevent_req_post(req, ev);
7773         }
7774         tevent_req_set_callback(subreq, rpccli_lsa_CloseTrustedDomainEx_done, req);
7775         return req;
7776 }
7777
7778 static void rpccli_lsa_CloseTrustedDomainEx_done(struct tevent_req *subreq)
7779 {
7780         struct tevent_req *req = tevent_req_callback_data(
7781                 subreq, struct tevent_req);
7782         struct rpccli_lsa_CloseTrustedDomainEx_state *state = tevent_req_data(
7783                 req, struct rpccli_lsa_CloseTrustedDomainEx_state);
7784         NTSTATUS status;
7785         TALLOC_CTX *mem_ctx;
7786
7787         if (state->out_mem_ctx) {
7788                 mem_ctx = state->out_mem_ctx;
7789         } else {
7790                 mem_ctx = state;
7791         }
7792
7793         status = state->dispatch_recv(subreq, mem_ctx);
7794         TALLOC_FREE(subreq);
7795         if (!NT_STATUS_IS_OK(status)) {
7796                 tevent_req_nterror(req, status);
7797                 return;
7798         }
7799
7800         /* Copy out parameters */
7801         *state->orig.out.handle = *state->tmp.out.handle;
7802
7803         /* Copy result */
7804         state->orig.out.result = state->tmp.out.result;
7805
7806         /* Reset temporary structure */
7807         ZERO_STRUCT(state->tmp);
7808
7809         tevent_req_done(req);
7810 }
7811
7812 NTSTATUS rpccli_lsa_CloseTrustedDomainEx_recv(struct tevent_req *req,
7813                                               TALLOC_CTX *mem_ctx,
7814                                               NTSTATUS *result)
7815 {
7816         struct rpccli_lsa_CloseTrustedDomainEx_state *state = tevent_req_data(
7817                 req, struct rpccli_lsa_CloseTrustedDomainEx_state);
7818         NTSTATUS status;
7819
7820         if (tevent_req_is_nterror(req, &status)) {
7821                 tevent_req_received(req);
7822                 return status;
7823         }
7824
7825         /* Steal possbile out parameters to the callers context */
7826         talloc_steal(mem_ctx, state->out_mem_ctx);
7827
7828         /* Return result */
7829         *result = state->orig.out.result;
7830
7831         tevent_req_received(req);
7832         return NT_STATUS_OK;
7833 }
7834
7835 NTSTATUS rpccli_lsa_CloseTrustedDomainEx(struct rpc_pipe_client *cli,
7836                                          TALLOC_CTX *mem_ctx,
7837                                          struct policy_handle *handle /* [in,out] [ref] */)
7838 {
7839         struct lsa_CloseTrustedDomainEx r;
7840         NTSTATUS status;
7841
7842         /* In parameters */
7843         r.in.handle = handle;
7844
7845         status = cli->dispatch(cli,
7846                                 mem_ctx,
7847                                 &ndr_table_lsarpc,
7848                                 NDR_LSA_CLOSETRUSTEDDOMAINEX,
7849                                 &r);
7850
7851         if (!NT_STATUS_IS_OK(status)) {
7852                 return status;
7853         }
7854
7855         if (NT_STATUS_IS_ERR(status)) {
7856                 return status;
7857         }
7858
7859         /* Return variables */
7860         *handle = *r.out.handle;
7861
7862         /* Return result */
7863         return r.out.result;
7864 }
7865
7866 struct rpccli_lsa_QueryDomainInformationPolicy_state {
7867         struct lsa_QueryDomainInformationPolicy orig;
7868         struct lsa_QueryDomainInformationPolicy tmp;
7869         TALLOC_CTX *out_mem_ctx;
7870         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7871 };
7872
7873 static void rpccli_lsa_QueryDomainInformationPolicy_done(struct tevent_req *subreq);
7874
7875 struct tevent_req *rpccli_lsa_QueryDomainInformationPolicy_send(TALLOC_CTX *mem_ctx,
7876                                                                 struct tevent_context *ev,
7877                                                                 struct rpc_pipe_client *cli,
7878                                                                 struct policy_handle *_handle /* [in] [ref] */,
7879                                                                 uint16_t _level /* [in]  */,
7880                                                                 union lsa_DomainInformationPolicy **_info /* [out] [ref,switch_is(level)] */)
7881 {
7882         struct tevent_req *req;
7883         struct rpccli_lsa_QueryDomainInformationPolicy_state *state;
7884         struct tevent_req *subreq;
7885
7886         req = tevent_req_create(mem_ctx, &state,
7887                                 struct rpccli_lsa_QueryDomainInformationPolicy_state);
7888         if (req == NULL) {
7889                 return NULL;
7890         }
7891         state->out_mem_ctx = NULL;
7892         state->dispatch_recv = cli->dispatch_recv;
7893
7894         /* In parameters */
7895         state->orig.in.handle = _handle;
7896         state->orig.in.level = _level;
7897
7898         /* Out parameters */
7899         state->orig.out.info = _info;
7900
7901         /* Result */
7902         ZERO_STRUCT(state->orig.out.result);
7903
7904         state->out_mem_ctx = talloc_named_const(state, 0,
7905                              "rpccli_lsa_QueryDomainInformationPolicy_out_memory");
7906         if (tevent_req_nomem(state->out_mem_ctx, req)) {
7907                 return tevent_req_post(req, ev);
7908         }
7909
7910         /* make a temporary copy, that we pass to the dispatch function */
7911         state->tmp = state->orig;
7912
7913         subreq = cli->dispatch_send(state, ev, cli,
7914                                     &ndr_table_lsarpc,
7915                                     NDR_LSA_QUERYDOMAININFORMATIONPOLICY,
7916                                     &state->tmp);
7917         if (tevent_req_nomem(subreq, req)) {
7918                 return tevent_req_post(req, ev);
7919         }
7920         tevent_req_set_callback(subreq, rpccli_lsa_QueryDomainInformationPolicy_done, req);
7921         return req;
7922 }
7923
7924 static void rpccli_lsa_QueryDomainInformationPolicy_done(struct tevent_req *subreq)
7925 {
7926         struct tevent_req *req = tevent_req_callback_data(
7927                 subreq, struct tevent_req);
7928         struct rpccli_lsa_QueryDomainInformationPolicy_state *state = tevent_req_data(
7929                 req, struct rpccli_lsa_QueryDomainInformationPolicy_state);
7930         NTSTATUS status;
7931         TALLOC_CTX *mem_ctx;
7932
7933         if (state->out_mem_ctx) {
7934                 mem_ctx = state->out_mem_ctx;
7935         } else {
7936                 mem_ctx = state;
7937         }
7938
7939         status = state->dispatch_recv(subreq, mem_ctx);
7940         TALLOC_FREE(subreq);
7941         if (!NT_STATUS_IS_OK(status)) {
7942                 tevent_req_nterror(req, status);
7943                 return;
7944         }
7945
7946         /* Copy out parameters */
7947         *state->orig.out.info = *state->tmp.out.info;
7948
7949         /* Copy result */
7950         state->orig.out.result = state->tmp.out.result;
7951
7952         /* Reset temporary structure */
7953         ZERO_STRUCT(state->tmp);
7954
7955         tevent_req_done(req);
7956 }
7957
7958 NTSTATUS rpccli_lsa_QueryDomainInformationPolicy_recv(struct tevent_req *req,
7959                                                       TALLOC_CTX *mem_ctx,
7960                                                       NTSTATUS *result)
7961 {
7962         struct rpccli_lsa_QueryDomainInformationPolicy_state *state = tevent_req_data(
7963                 req, struct rpccli_lsa_QueryDomainInformationPolicy_state);
7964         NTSTATUS status;
7965
7966         if (tevent_req_is_nterror(req, &status)) {
7967                 tevent_req_received(req);
7968                 return status;
7969         }
7970
7971         /* Steal possbile out parameters to the callers context */
7972         talloc_steal(mem_ctx, state->out_mem_ctx);
7973
7974         /* Return result */
7975         *result = state->orig.out.result;
7976
7977         tevent_req_received(req);
7978         return NT_STATUS_OK;
7979 }
7980
7981 NTSTATUS rpccli_lsa_QueryDomainInformationPolicy(struct rpc_pipe_client *cli,
7982                                                  TALLOC_CTX *mem_ctx,
7983                                                  struct policy_handle *handle /* [in] [ref] */,
7984                                                  uint16_t level /* [in]  */,
7985                                                  union lsa_DomainInformationPolicy **info /* [out] [ref,switch_is(level)] */)
7986 {
7987         struct lsa_QueryDomainInformationPolicy r;
7988         NTSTATUS status;
7989
7990         /* In parameters */
7991         r.in.handle = handle;
7992         r.in.level = level;
7993
7994         status = cli->dispatch(cli,
7995                                 mem_ctx,
7996                                 &ndr_table_lsarpc,
7997                                 NDR_LSA_QUERYDOMAININFORMATIONPOLICY,
7998                                 &r);
7999
8000         if (!NT_STATUS_IS_OK(status)) {
8001                 return status;
8002         }
8003
8004         if (NT_STATUS_IS_ERR(status)) {
8005                 return status;
8006         }
8007
8008         /* Return variables */
8009         *info = *r.out.info;
8010
8011         /* Return result */
8012         return r.out.result;
8013 }
8014
8015 struct rpccli_lsa_SetDomainInformationPolicy_state {
8016         struct lsa_SetDomainInformationPolicy orig;
8017         struct lsa_SetDomainInformationPolicy tmp;
8018         TALLOC_CTX *out_mem_ctx;
8019         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8020 };
8021
8022 static void rpccli_lsa_SetDomainInformationPolicy_done(struct tevent_req *subreq);
8023
8024 struct tevent_req *rpccli_lsa_SetDomainInformationPolicy_send(TALLOC_CTX *mem_ctx,
8025                                                               struct tevent_context *ev,
8026                                                               struct rpc_pipe_client *cli,
8027                                                               struct policy_handle *_handle /* [in] [ref] */,
8028                                                               uint16_t _level /* [in]  */,
8029                                                               union lsa_DomainInformationPolicy *_info /* [in] [unique,switch_is(level)] */)
8030 {
8031         struct tevent_req *req;
8032         struct rpccli_lsa_SetDomainInformationPolicy_state *state;
8033         struct tevent_req *subreq;
8034
8035         req = tevent_req_create(mem_ctx, &state,
8036                                 struct rpccli_lsa_SetDomainInformationPolicy_state);
8037         if (req == NULL) {
8038                 return NULL;
8039         }
8040         state->out_mem_ctx = NULL;
8041         state->dispatch_recv = cli->dispatch_recv;
8042
8043         /* In parameters */
8044         state->orig.in.handle = _handle;
8045         state->orig.in.level = _level;
8046         state->orig.in.info = _info;
8047
8048         /* Out parameters */
8049
8050         /* Result */
8051         ZERO_STRUCT(state->orig.out.result);
8052
8053         /* make a temporary copy, that we pass to the dispatch function */
8054         state->tmp = state->orig;
8055
8056         subreq = cli->dispatch_send(state, ev, cli,
8057                                     &ndr_table_lsarpc,
8058                                     NDR_LSA_SETDOMAININFORMATIONPOLICY,
8059                                     &state->tmp);
8060         if (tevent_req_nomem(subreq, req)) {
8061                 return tevent_req_post(req, ev);
8062         }
8063         tevent_req_set_callback(subreq, rpccli_lsa_SetDomainInformationPolicy_done, req);
8064         return req;
8065 }
8066
8067 static void rpccli_lsa_SetDomainInformationPolicy_done(struct tevent_req *subreq)
8068 {
8069         struct tevent_req *req = tevent_req_callback_data(
8070                 subreq, struct tevent_req);
8071         struct rpccli_lsa_SetDomainInformationPolicy_state *state = tevent_req_data(
8072                 req, struct rpccli_lsa_SetDomainInformationPolicy_state);
8073         NTSTATUS status;
8074         TALLOC_CTX *mem_ctx;
8075
8076         if (state->out_mem_ctx) {
8077                 mem_ctx = state->out_mem_ctx;
8078         } else {
8079                 mem_ctx = state;
8080         }
8081
8082         status = state->dispatch_recv(subreq, mem_ctx);
8083         TALLOC_FREE(subreq);
8084         if (!NT_STATUS_IS_OK(status)) {
8085                 tevent_req_nterror(req, status);
8086                 return;
8087         }
8088
8089         /* Copy out parameters */
8090
8091         /* Copy result */
8092         state->orig.out.result = state->tmp.out.result;
8093
8094         /* Reset temporary structure */
8095         ZERO_STRUCT(state->tmp);
8096
8097         tevent_req_done(req);
8098 }
8099
8100 NTSTATUS rpccli_lsa_SetDomainInformationPolicy_recv(struct tevent_req *req,
8101                                                     TALLOC_CTX *mem_ctx,
8102                                                     NTSTATUS *result)
8103 {
8104         struct rpccli_lsa_SetDomainInformationPolicy_state *state = tevent_req_data(
8105                 req, struct rpccli_lsa_SetDomainInformationPolicy_state);
8106         NTSTATUS status;
8107
8108         if (tevent_req_is_nterror(req, &status)) {
8109                 tevent_req_received(req);
8110                 return status;
8111         }
8112
8113         /* Steal possbile out parameters to the callers context */
8114         talloc_steal(mem_ctx, state->out_mem_ctx);
8115
8116         /* Return result */
8117         *result = state->orig.out.result;
8118
8119         tevent_req_received(req);
8120         return NT_STATUS_OK;
8121 }
8122
8123 NTSTATUS rpccli_lsa_SetDomainInformationPolicy(struct rpc_pipe_client *cli,
8124                                                TALLOC_CTX *mem_ctx,
8125                                                struct policy_handle *handle /* [in] [ref] */,
8126                                                uint16_t level /* [in]  */,
8127                                                union lsa_DomainInformationPolicy *info /* [in] [unique,switch_is(level)] */)
8128 {
8129         struct lsa_SetDomainInformationPolicy r;
8130         NTSTATUS status;
8131
8132         /* In parameters */
8133         r.in.handle = handle;
8134         r.in.level = level;
8135         r.in.info = info;
8136
8137         status = cli->dispatch(cli,
8138                                 mem_ctx,
8139                                 &ndr_table_lsarpc,
8140                                 NDR_LSA_SETDOMAININFORMATIONPOLICY,
8141                                 &r);
8142
8143         if (!NT_STATUS_IS_OK(status)) {
8144                 return status;
8145         }
8146
8147         if (NT_STATUS_IS_ERR(status)) {
8148                 return status;
8149         }
8150
8151         /* Return variables */
8152
8153         /* Return result */
8154         return r.out.result;
8155 }
8156
8157 struct rpccli_lsa_OpenTrustedDomainByName_state {
8158         struct lsa_OpenTrustedDomainByName orig;
8159         struct lsa_OpenTrustedDomainByName tmp;
8160         TALLOC_CTX *out_mem_ctx;
8161         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8162 };
8163
8164 static void rpccli_lsa_OpenTrustedDomainByName_done(struct tevent_req *subreq);
8165
8166 struct tevent_req *rpccli_lsa_OpenTrustedDomainByName_send(TALLOC_CTX *mem_ctx,
8167                                                            struct tevent_context *ev,
8168                                                            struct rpc_pipe_client *cli,
8169                                                            struct policy_handle *_handle /* [in] [ref] */,
8170                                                            struct lsa_String _name /* [in]  */,
8171                                                            uint32_t _access_mask /* [in]  */,
8172                                                            struct policy_handle *_trustdom_handle /* [out] [ref] */)
8173 {
8174         struct tevent_req *req;
8175         struct rpccli_lsa_OpenTrustedDomainByName_state *state;
8176         struct tevent_req *subreq;
8177
8178         req = tevent_req_create(mem_ctx, &state,
8179                                 struct rpccli_lsa_OpenTrustedDomainByName_state);
8180         if (req == NULL) {
8181                 return NULL;
8182         }
8183         state->out_mem_ctx = NULL;
8184         state->dispatch_recv = cli->dispatch_recv;
8185
8186         /* In parameters */
8187         state->orig.in.handle = _handle;
8188         state->orig.in.name = _name;
8189         state->orig.in.access_mask = _access_mask;
8190
8191         /* Out parameters */
8192         state->orig.out.trustdom_handle = _trustdom_handle;
8193
8194         /* Result */
8195         ZERO_STRUCT(state->orig.out.result);
8196
8197         state->out_mem_ctx = talloc_named_const(state, 0,
8198                              "rpccli_lsa_OpenTrustedDomainByName_out_memory");
8199         if (tevent_req_nomem(state->out_mem_ctx, req)) {
8200                 return tevent_req_post(req, ev);
8201         }
8202
8203         /* make a temporary copy, that we pass to the dispatch function */
8204         state->tmp = state->orig;
8205
8206         subreq = cli->dispatch_send(state, ev, cli,
8207                                     &ndr_table_lsarpc,
8208                                     NDR_LSA_OPENTRUSTEDDOMAINBYNAME,
8209                                     &state->tmp);
8210         if (tevent_req_nomem(subreq, req)) {
8211                 return tevent_req_post(req, ev);
8212         }
8213         tevent_req_set_callback(subreq, rpccli_lsa_OpenTrustedDomainByName_done, req);
8214         return req;
8215 }
8216
8217 static void rpccli_lsa_OpenTrustedDomainByName_done(struct tevent_req *subreq)
8218 {
8219         struct tevent_req *req = tevent_req_callback_data(
8220                 subreq, struct tevent_req);
8221         struct rpccli_lsa_OpenTrustedDomainByName_state *state = tevent_req_data(
8222                 req, struct rpccli_lsa_OpenTrustedDomainByName_state);
8223         NTSTATUS status;
8224         TALLOC_CTX *mem_ctx;
8225
8226         if (state->out_mem_ctx) {
8227                 mem_ctx = state->out_mem_ctx;
8228         } else {
8229                 mem_ctx = state;
8230         }
8231
8232         status = state->dispatch_recv(subreq, mem_ctx);
8233         TALLOC_FREE(subreq);
8234         if (!NT_STATUS_IS_OK(status)) {
8235                 tevent_req_nterror(req, status);
8236                 return;
8237         }
8238
8239         /* Copy out parameters */
8240         *state->orig.out.trustdom_handle = *state->tmp.out.trustdom_handle;
8241
8242         /* Copy result */
8243         state->orig.out.result = state->tmp.out.result;
8244
8245         /* Reset temporary structure */
8246         ZERO_STRUCT(state->tmp);
8247
8248         tevent_req_done(req);
8249 }
8250
8251 NTSTATUS rpccli_lsa_OpenTrustedDomainByName_recv(struct tevent_req *req,
8252                                                  TALLOC_CTX *mem_ctx,
8253                                                  NTSTATUS *result)
8254 {
8255         struct rpccli_lsa_OpenTrustedDomainByName_state *state = tevent_req_data(
8256                 req, struct rpccli_lsa_OpenTrustedDomainByName_state);
8257         NTSTATUS status;
8258
8259         if (tevent_req_is_nterror(req, &status)) {
8260                 tevent_req_received(req);
8261                 return status;
8262         }
8263
8264         /* Steal possbile out parameters to the callers context */
8265         talloc_steal(mem_ctx, state->out_mem_ctx);
8266
8267         /* Return result */
8268         *result = state->orig.out.result;
8269
8270         tevent_req_received(req);
8271         return NT_STATUS_OK;
8272 }
8273
8274 NTSTATUS rpccli_lsa_OpenTrustedDomainByName(struct rpc_pipe_client *cli,
8275                                             TALLOC_CTX *mem_ctx,
8276                                             struct policy_handle *handle /* [in] [ref] */,
8277                                             struct lsa_String name /* [in]  */,
8278                                             uint32_t access_mask /* [in]  */,
8279                                             struct policy_handle *trustdom_handle /* [out] [ref] */)
8280 {
8281         struct lsa_OpenTrustedDomainByName r;
8282         NTSTATUS status;
8283
8284         /* In parameters */
8285         r.in.handle = handle;
8286         r.in.name = name;
8287         r.in.access_mask = access_mask;
8288
8289         status = cli->dispatch(cli,
8290                                 mem_ctx,
8291                                 &ndr_table_lsarpc,
8292                                 NDR_LSA_OPENTRUSTEDDOMAINBYNAME,
8293                                 &r);
8294
8295         if (!NT_STATUS_IS_OK(status)) {
8296                 return status;
8297         }
8298
8299         if (NT_STATUS_IS_ERR(status)) {
8300                 return status;
8301         }
8302
8303         /* Return variables */
8304         *trustdom_handle = *r.out.trustdom_handle;
8305
8306         /* Return result */
8307         return r.out.result;
8308 }
8309
8310 struct rpccli_lsa_TestCall_state {
8311         struct lsa_TestCall orig;
8312         struct lsa_TestCall tmp;
8313         TALLOC_CTX *out_mem_ctx;
8314         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8315 };
8316
8317 static void rpccli_lsa_TestCall_done(struct tevent_req *subreq);
8318
8319 struct tevent_req *rpccli_lsa_TestCall_send(TALLOC_CTX *mem_ctx,
8320                                             struct tevent_context *ev,
8321                                             struct rpc_pipe_client *cli)
8322 {
8323         struct tevent_req *req;
8324         struct rpccli_lsa_TestCall_state *state;
8325         struct tevent_req *subreq;
8326
8327         req = tevent_req_create(mem_ctx, &state,
8328                                 struct rpccli_lsa_TestCall_state);
8329         if (req == NULL) {
8330                 return NULL;
8331         }
8332         state->out_mem_ctx = NULL;
8333         state->dispatch_recv = cli->dispatch_recv;
8334
8335         /* In parameters */
8336
8337         /* Out parameters */
8338
8339         /* Result */
8340         ZERO_STRUCT(state->orig.out.result);
8341
8342         /* make a temporary copy, that we pass to the dispatch function */
8343         state->tmp = state->orig;
8344
8345         subreq = cli->dispatch_send(state, ev, cli,
8346                                     &ndr_table_lsarpc,
8347                                     NDR_LSA_TESTCALL,
8348                                     &state->tmp);
8349         if (tevent_req_nomem(subreq, req)) {
8350                 return tevent_req_post(req, ev);
8351         }
8352         tevent_req_set_callback(subreq, rpccli_lsa_TestCall_done, req);
8353         return req;
8354 }
8355
8356 static void rpccli_lsa_TestCall_done(struct tevent_req *subreq)
8357 {
8358         struct tevent_req *req = tevent_req_callback_data(
8359                 subreq, struct tevent_req);
8360         struct rpccli_lsa_TestCall_state *state = tevent_req_data(
8361                 req, struct rpccli_lsa_TestCall_state);
8362         NTSTATUS status;
8363         TALLOC_CTX *mem_ctx;
8364
8365         if (state->out_mem_ctx) {
8366                 mem_ctx = state->out_mem_ctx;
8367         } else {
8368                 mem_ctx = state;
8369         }
8370
8371         status = state->dispatch_recv(subreq, mem_ctx);
8372         TALLOC_FREE(subreq);
8373         if (!NT_STATUS_IS_OK(status)) {
8374                 tevent_req_nterror(req, status);
8375                 return;
8376         }
8377
8378         /* Copy out parameters */
8379
8380         /* Copy result */
8381         state->orig.out.result = state->tmp.out.result;
8382
8383         /* Reset temporary structure */
8384         ZERO_STRUCT(state->tmp);
8385
8386         tevent_req_done(req);
8387 }
8388
8389 NTSTATUS rpccli_lsa_TestCall_recv(struct tevent_req *req,
8390                                   TALLOC_CTX *mem_ctx,
8391                                   NTSTATUS *result)
8392 {
8393         struct rpccli_lsa_TestCall_state *state = tevent_req_data(
8394                 req, struct rpccli_lsa_TestCall_state);
8395         NTSTATUS status;
8396
8397         if (tevent_req_is_nterror(req, &status)) {
8398                 tevent_req_received(req);
8399                 return status;
8400         }
8401
8402         /* Steal possbile out parameters to the callers context */
8403         talloc_steal(mem_ctx, state->out_mem_ctx);
8404
8405         /* Return result */
8406         *result = state->orig.out.result;
8407
8408         tevent_req_received(req);
8409         return NT_STATUS_OK;
8410 }
8411
8412 NTSTATUS rpccli_lsa_TestCall(struct rpc_pipe_client *cli,
8413                              TALLOC_CTX *mem_ctx)
8414 {
8415         struct lsa_TestCall r;
8416         NTSTATUS status;
8417
8418         /* In parameters */
8419
8420         status = cli->dispatch(cli,
8421                                 mem_ctx,
8422                                 &ndr_table_lsarpc,
8423                                 NDR_LSA_TESTCALL,
8424                                 &r);
8425
8426         if (!NT_STATUS_IS_OK(status)) {
8427                 return status;
8428         }
8429
8430         if (NT_STATUS_IS_ERR(status)) {
8431                 return status;
8432         }
8433
8434         /* Return variables */
8435
8436         /* Return result */
8437         return r.out.result;
8438 }
8439
8440 struct rpccli_lsa_LookupSids2_state {
8441         struct lsa_LookupSids2 orig;
8442         struct lsa_LookupSids2 tmp;
8443         TALLOC_CTX *out_mem_ctx;
8444         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8445 };
8446
8447 static void rpccli_lsa_LookupSids2_done(struct tevent_req *subreq);
8448
8449 struct tevent_req *rpccli_lsa_LookupSids2_send(TALLOC_CTX *mem_ctx,
8450                                                struct tevent_context *ev,
8451                                                struct rpc_pipe_client *cli,
8452                                                struct policy_handle *_handle /* [in] [ref] */,
8453                                                struct lsa_SidArray *_sids /* [in] [ref] */,
8454                                                struct lsa_RefDomainList **_domains /* [out] [ref] */,
8455                                                struct lsa_TransNameArray2 *_names /* [in,out] [ref] */,
8456                                                enum lsa_LookupNamesLevel _level /* [in]  */,
8457                                                uint32_t *_count /* [in,out] [ref] */,
8458                                                enum lsa_LookupOptions _lookup_options /* [in]  */,
8459                                                enum lsa_ClientRevision _client_revision /* [in]  */)
8460 {
8461         struct tevent_req *req;
8462         struct rpccli_lsa_LookupSids2_state *state;
8463         struct tevent_req *subreq;
8464
8465         req = tevent_req_create(mem_ctx, &state,
8466                                 struct rpccli_lsa_LookupSids2_state);
8467         if (req == NULL) {
8468                 return NULL;
8469         }
8470         state->out_mem_ctx = NULL;
8471         state->dispatch_recv = cli->dispatch_recv;
8472
8473         /* In parameters */
8474         state->orig.in.handle = _handle;
8475         state->orig.in.sids = _sids;
8476         state->orig.in.names = _names;
8477         state->orig.in.level = _level;
8478         state->orig.in.count = _count;
8479         state->orig.in.lookup_options = _lookup_options;
8480         state->orig.in.client_revision = _client_revision;
8481
8482         /* Out parameters */
8483         state->orig.out.domains = _domains;
8484         state->orig.out.names = _names;
8485         state->orig.out.count = _count;
8486
8487         /* Result */
8488         ZERO_STRUCT(state->orig.out.result);
8489
8490         state->out_mem_ctx = talloc_named_const(state, 0,
8491                              "rpccli_lsa_LookupSids2_out_memory");
8492         if (tevent_req_nomem(state->out_mem_ctx, req)) {
8493                 return tevent_req_post(req, ev);
8494         }
8495
8496         /* make a temporary copy, that we pass to the dispatch function */
8497         state->tmp = state->orig;
8498
8499         subreq = cli->dispatch_send(state, ev, cli,
8500                                     &ndr_table_lsarpc,
8501                                     NDR_LSA_LOOKUPSIDS2,
8502                                     &state->tmp);
8503         if (tevent_req_nomem(subreq, req)) {
8504                 return tevent_req_post(req, ev);
8505         }
8506         tevent_req_set_callback(subreq, rpccli_lsa_LookupSids2_done, req);
8507         return req;
8508 }
8509
8510 static void rpccli_lsa_LookupSids2_done(struct tevent_req *subreq)
8511 {
8512         struct tevent_req *req = tevent_req_callback_data(
8513                 subreq, struct tevent_req);
8514         struct rpccli_lsa_LookupSids2_state *state = tevent_req_data(
8515                 req, struct rpccli_lsa_LookupSids2_state);
8516         NTSTATUS status;
8517         TALLOC_CTX *mem_ctx;
8518
8519         if (state->out_mem_ctx) {
8520                 mem_ctx = state->out_mem_ctx;
8521         } else {
8522                 mem_ctx = state;
8523         }
8524
8525         status = state->dispatch_recv(subreq, mem_ctx);
8526         TALLOC_FREE(subreq);
8527         if (!NT_STATUS_IS_OK(status)) {
8528                 tevent_req_nterror(req, status);
8529                 return;
8530         }
8531
8532         /* Copy out parameters */
8533         *state->orig.out.domains = *state->tmp.out.domains;
8534         *state->orig.out.names = *state->tmp.out.names;
8535         *state->orig.out.count = *state->tmp.out.count;
8536
8537         /* Copy result */
8538         state->orig.out.result = state->tmp.out.result;
8539
8540         /* Reset temporary structure */
8541         ZERO_STRUCT(state->tmp);
8542
8543         tevent_req_done(req);
8544 }
8545
8546 NTSTATUS rpccli_lsa_LookupSids2_recv(struct tevent_req *req,
8547                                      TALLOC_CTX *mem_ctx,
8548                                      NTSTATUS *result)
8549 {
8550         struct rpccli_lsa_LookupSids2_state *state = tevent_req_data(
8551                 req, struct rpccli_lsa_LookupSids2_state);
8552         NTSTATUS status;
8553
8554         if (tevent_req_is_nterror(req, &status)) {
8555                 tevent_req_received(req);
8556                 return status;
8557         }
8558
8559         /* Steal possbile out parameters to the callers context */
8560         talloc_steal(mem_ctx, state->out_mem_ctx);
8561
8562         /* Return result */
8563         *result = state->orig.out.result;
8564
8565         tevent_req_received(req);
8566         return NT_STATUS_OK;
8567 }
8568
8569 NTSTATUS rpccli_lsa_LookupSids2(struct rpc_pipe_client *cli,
8570                                 TALLOC_CTX *mem_ctx,
8571                                 struct policy_handle *handle /* [in] [ref] */,
8572                                 struct lsa_SidArray *sids /* [in] [ref] */,
8573                                 struct lsa_RefDomainList **domains /* [out] [ref] */,
8574                                 struct lsa_TransNameArray2 *names /* [in,out] [ref] */,
8575                                 enum lsa_LookupNamesLevel level /* [in]  */,
8576                                 uint32_t *count /* [in,out] [ref] */,
8577                                 enum lsa_LookupOptions lookup_options /* [in]  */,
8578                                 enum lsa_ClientRevision client_revision /* [in]  */)
8579 {
8580         struct lsa_LookupSids2 r;
8581         NTSTATUS status;
8582
8583         /* In parameters */
8584         r.in.handle = handle;
8585         r.in.sids = sids;
8586         r.in.names = names;
8587         r.in.level = level;
8588         r.in.count = count;
8589         r.in.lookup_options = lookup_options;
8590         r.in.client_revision = client_revision;
8591
8592         status = cli->dispatch(cli,
8593                                 mem_ctx,
8594                                 &ndr_table_lsarpc,
8595                                 NDR_LSA_LOOKUPSIDS2,
8596                                 &r);
8597
8598         if (!NT_STATUS_IS_OK(status)) {
8599                 return status;
8600         }
8601
8602         if (NT_STATUS_IS_ERR(status)) {
8603                 return status;
8604         }
8605
8606         /* Return variables */
8607         *domains = *r.out.domains;
8608         *names = *r.out.names;
8609         *count = *r.out.count;
8610
8611         /* Return result */
8612         return r.out.result;
8613 }
8614
8615 struct rpccli_lsa_LookupNames2_state {
8616         struct lsa_LookupNames2 orig;
8617         struct lsa_LookupNames2 tmp;
8618         TALLOC_CTX *out_mem_ctx;
8619         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8620 };
8621
8622 static void rpccli_lsa_LookupNames2_done(struct tevent_req *subreq);
8623
8624 struct tevent_req *rpccli_lsa_LookupNames2_send(TALLOC_CTX *mem_ctx,
8625                                                 struct tevent_context *ev,
8626                                                 struct rpc_pipe_client *cli,
8627                                                 struct policy_handle *_handle /* [in] [ref] */,
8628                                                 uint32_t _num_names /* [in] [range(0,1000)] */,
8629                                                 struct lsa_String *_names /* [in] [size_is(num_names)] */,
8630                                                 struct lsa_RefDomainList **_domains /* [out] [ref] */,
8631                                                 struct lsa_TransSidArray2 *_sids /* [in,out] [ref] */,
8632                                                 enum lsa_LookupNamesLevel _level /* [in]  */,
8633                                                 uint32_t *_count /* [in,out] [ref] */,
8634                                                 enum lsa_LookupOptions _lookup_options /* [in]  */,
8635                                                 enum lsa_ClientRevision _client_revision /* [in]  */)
8636 {
8637         struct tevent_req *req;
8638         struct rpccli_lsa_LookupNames2_state *state;
8639         struct tevent_req *subreq;
8640
8641         req = tevent_req_create(mem_ctx, &state,
8642                                 struct rpccli_lsa_LookupNames2_state);
8643         if (req == NULL) {
8644                 return NULL;
8645         }
8646         state->out_mem_ctx = NULL;
8647         state->dispatch_recv = cli->dispatch_recv;
8648
8649         /* In parameters */
8650         state->orig.in.handle = _handle;
8651         state->orig.in.num_names = _num_names;
8652         state->orig.in.names = _names;
8653         state->orig.in.sids = _sids;
8654         state->orig.in.level = _level;
8655         state->orig.in.count = _count;
8656         state->orig.in.lookup_options = _lookup_options;
8657         state->orig.in.client_revision = _client_revision;
8658
8659         /* Out parameters */
8660         state->orig.out.domains = _domains;
8661         state->orig.out.sids = _sids;
8662         state->orig.out.count = _count;
8663
8664         /* Result */
8665         ZERO_STRUCT(state->orig.out.result);
8666
8667         state->out_mem_ctx = talloc_named_const(state, 0,
8668                              "rpccli_lsa_LookupNames2_out_memory");
8669         if (tevent_req_nomem(state->out_mem_ctx, req)) {
8670                 return tevent_req_post(req, ev);
8671         }
8672
8673         /* make a temporary copy, that we pass to the dispatch function */
8674         state->tmp = state->orig;
8675
8676         subreq = cli->dispatch_send(state, ev, cli,
8677                                     &ndr_table_lsarpc,
8678                                     NDR_LSA_LOOKUPNAMES2,
8679                                     &state->tmp);
8680         if (tevent_req_nomem(subreq, req)) {
8681                 return tevent_req_post(req, ev);
8682         }
8683         tevent_req_set_callback(subreq, rpccli_lsa_LookupNames2_done, req);
8684         return req;
8685 }
8686
8687 static void rpccli_lsa_LookupNames2_done(struct tevent_req *subreq)
8688 {
8689         struct tevent_req *req = tevent_req_callback_data(
8690                 subreq, struct tevent_req);
8691         struct rpccli_lsa_LookupNames2_state *state = tevent_req_data(
8692                 req, struct rpccli_lsa_LookupNames2_state);
8693         NTSTATUS status;
8694         TALLOC_CTX *mem_ctx;
8695
8696         if (state->out_mem_ctx) {
8697                 mem_ctx = state->out_mem_ctx;
8698         } else {
8699                 mem_ctx = state;
8700         }
8701
8702         status = state->dispatch_recv(subreq, mem_ctx);
8703         TALLOC_FREE(subreq);
8704         if (!NT_STATUS_IS_OK(status)) {
8705                 tevent_req_nterror(req, status);
8706                 return;
8707         }
8708
8709         /* Copy out parameters */
8710         *state->orig.out.domains = *state->tmp.out.domains;
8711         *state->orig.out.sids = *state->tmp.out.sids;
8712         *state->orig.out.count = *state->tmp.out.count;
8713
8714         /* Copy result */
8715         state->orig.out.result = state->tmp.out.result;
8716
8717         /* Reset temporary structure */
8718         ZERO_STRUCT(state->tmp);
8719
8720         tevent_req_done(req);
8721 }
8722
8723 NTSTATUS rpccli_lsa_LookupNames2_recv(struct tevent_req *req,
8724                                       TALLOC_CTX *mem_ctx,
8725                                       NTSTATUS *result)
8726 {
8727         struct rpccli_lsa_LookupNames2_state *state = tevent_req_data(
8728                 req, struct rpccli_lsa_LookupNames2_state);
8729         NTSTATUS status;
8730
8731         if (tevent_req_is_nterror(req, &status)) {
8732                 tevent_req_received(req);
8733                 return status;
8734         }
8735
8736         /* Steal possbile out parameters to the callers context */
8737         talloc_steal(mem_ctx, state->out_mem_ctx);
8738
8739         /* Return result */
8740         *result = state->orig.out.result;
8741
8742         tevent_req_received(req);
8743         return NT_STATUS_OK;
8744 }
8745
8746 NTSTATUS rpccli_lsa_LookupNames2(struct rpc_pipe_client *cli,
8747                                  TALLOC_CTX *mem_ctx,
8748                                  struct policy_handle *handle /* [in] [ref] */,
8749                                  uint32_t num_names /* [in] [range(0,1000)] */,
8750                                  struct lsa_String *names /* [in] [size_is(num_names)] */,
8751                                  struct lsa_RefDomainList **domains /* [out] [ref] */,
8752                                  struct lsa_TransSidArray2 *sids /* [in,out] [ref] */,
8753                                  enum lsa_LookupNamesLevel level /* [in]  */,
8754                                  uint32_t *count /* [in,out] [ref] */,
8755                                  enum lsa_LookupOptions lookup_options /* [in]  */,
8756                                  enum lsa_ClientRevision client_revision /* [in]  */)
8757 {
8758         struct lsa_LookupNames2 r;
8759         NTSTATUS status;
8760
8761         /* In parameters */
8762         r.in.handle = handle;
8763         r.in.num_names = num_names;
8764         r.in.names = names;
8765         r.in.sids = sids;
8766         r.in.level = level;
8767         r.in.count = count;
8768         r.in.lookup_options = lookup_options;
8769         r.in.client_revision = client_revision;
8770
8771         status = cli->dispatch(cli,
8772                                 mem_ctx,
8773                                 &ndr_table_lsarpc,
8774                                 NDR_LSA_LOOKUPNAMES2,
8775                                 &r);
8776
8777         if (!NT_STATUS_IS_OK(status)) {
8778                 return status;
8779         }
8780
8781         if (NT_STATUS_IS_ERR(status)) {
8782                 return status;
8783         }
8784
8785         /* Return variables */
8786         *domains = *r.out.domains;
8787         *sids = *r.out.sids;
8788         *count = *r.out.count;
8789
8790         /* Return result */
8791         return r.out.result;
8792 }
8793
8794 struct rpccli_lsa_CreateTrustedDomainEx2_state {
8795         struct lsa_CreateTrustedDomainEx2 orig;
8796         struct lsa_CreateTrustedDomainEx2 tmp;
8797         TALLOC_CTX *out_mem_ctx;
8798         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8799 };
8800
8801 static void rpccli_lsa_CreateTrustedDomainEx2_done(struct tevent_req *subreq);
8802
8803 struct tevent_req *rpccli_lsa_CreateTrustedDomainEx2_send(TALLOC_CTX *mem_ctx,
8804                                                           struct tevent_context *ev,
8805                                                           struct rpc_pipe_client *cli,
8806                                                           struct policy_handle *_policy_handle /* [in] [ref] */,
8807                                                           struct lsa_TrustDomainInfoInfoEx *_info /* [in] [ref] */,
8808                                                           struct lsa_TrustDomainInfoAuthInfoInternal *_auth_info /* [in] [ref] */,
8809                                                           uint32_t _access_mask /* [in]  */,
8810                                                           struct policy_handle *_trustdom_handle /* [out] [ref] */)
8811 {
8812         struct tevent_req *req;
8813         struct rpccli_lsa_CreateTrustedDomainEx2_state *state;
8814         struct tevent_req *subreq;
8815
8816         req = tevent_req_create(mem_ctx, &state,
8817                                 struct rpccli_lsa_CreateTrustedDomainEx2_state);
8818         if (req == NULL) {
8819                 return NULL;
8820         }
8821         state->out_mem_ctx = NULL;
8822         state->dispatch_recv = cli->dispatch_recv;
8823
8824         /* In parameters */
8825         state->orig.in.policy_handle = _policy_handle;
8826         state->orig.in.info = _info;
8827         state->orig.in.auth_info = _auth_info;
8828         state->orig.in.access_mask = _access_mask;
8829
8830         /* Out parameters */
8831         state->orig.out.trustdom_handle = _trustdom_handle;
8832
8833         /* Result */
8834         ZERO_STRUCT(state->orig.out.result);
8835
8836         state->out_mem_ctx = talloc_named_const(state, 0,
8837                              "rpccli_lsa_CreateTrustedDomainEx2_out_memory");
8838         if (tevent_req_nomem(state->out_mem_ctx, req)) {
8839                 return tevent_req_post(req, ev);
8840         }
8841
8842         /* make a temporary copy, that we pass to the dispatch function */
8843         state->tmp = state->orig;
8844
8845         subreq = cli->dispatch_send(state, ev, cli,
8846                                     &ndr_table_lsarpc,
8847                                     NDR_LSA_CREATETRUSTEDDOMAINEX2,
8848                                     &state->tmp);
8849         if (tevent_req_nomem(subreq, req)) {
8850                 return tevent_req_post(req, ev);
8851         }
8852         tevent_req_set_callback(subreq, rpccli_lsa_CreateTrustedDomainEx2_done, req);
8853         return req;
8854 }
8855
8856 static void rpccli_lsa_CreateTrustedDomainEx2_done(struct tevent_req *subreq)
8857 {
8858         struct tevent_req *req = tevent_req_callback_data(
8859                 subreq, struct tevent_req);
8860         struct rpccli_lsa_CreateTrustedDomainEx2_state *state = tevent_req_data(
8861                 req, struct rpccli_lsa_CreateTrustedDomainEx2_state);
8862         NTSTATUS status;
8863         TALLOC_CTX *mem_ctx;
8864
8865         if (state->out_mem_ctx) {
8866                 mem_ctx = state->out_mem_ctx;
8867         } else {
8868                 mem_ctx = state;
8869         }
8870
8871         status = state->dispatch_recv(subreq, mem_ctx);
8872         TALLOC_FREE(subreq);
8873         if (!NT_STATUS_IS_OK(status)) {
8874                 tevent_req_nterror(req, status);
8875                 return;
8876         }
8877
8878         /* Copy out parameters */
8879         *state->orig.out.trustdom_handle = *state->tmp.out.trustdom_handle;
8880
8881         /* Copy result */
8882         state->orig.out.result = state->tmp.out.result;
8883
8884         /* Reset temporary structure */
8885         ZERO_STRUCT(state->tmp);
8886
8887         tevent_req_done(req);
8888 }
8889
8890 NTSTATUS rpccli_lsa_CreateTrustedDomainEx2_recv(struct tevent_req *req,
8891                                                 TALLOC_CTX *mem_ctx,
8892                                                 NTSTATUS *result)
8893 {
8894         struct rpccli_lsa_CreateTrustedDomainEx2_state *state = tevent_req_data(
8895                 req, struct rpccli_lsa_CreateTrustedDomainEx2_state);
8896         NTSTATUS status;
8897
8898         if (tevent_req_is_nterror(req, &status)) {
8899                 tevent_req_received(req);
8900                 return status;
8901         }
8902
8903         /* Steal possbile out parameters to the callers context */
8904         talloc_steal(mem_ctx, state->out_mem_ctx);
8905
8906         /* Return result */
8907         *result = state->orig.out.result;
8908
8909         tevent_req_received(req);
8910         return NT_STATUS_OK;
8911 }
8912
8913 NTSTATUS rpccli_lsa_CreateTrustedDomainEx2(struct rpc_pipe_client *cli,
8914                                            TALLOC_CTX *mem_ctx,
8915                                            struct policy_handle *policy_handle /* [in] [ref] */,
8916                                            struct lsa_TrustDomainInfoInfoEx *info /* [in] [ref] */,
8917                                            struct lsa_TrustDomainInfoAuthInfoInternal *auth_info /* [in] [ref] */,
8918                                            uint32_t access_mask /* [in]  */,
8919                                            struct policy_handle *trustdom_handle /* [out] [ref] */)
8920 {
8921         struct lsa_CreateTrustedDomainEx2 r;
8922         NTSTATUS status;
8923
8924         /* In parameters */
8925         r.in.policy_handle = policy_handle;
8926         r.in.info = info;
8927         r.in.auth_info = auth_info;
8928         r.in.access_mask = access_mask;
8929
8930         status = cli->dispatch(cli,
8931                                 mem_ctx,
8932                                 &ndr_table_lsarpc,
8933                                 NDR_LSA_CREATETRUSTEDDOMAINEX2,
8934                                 &r);
8935
8936         if (!NT_STATUS_IS_OK(status)) {
8937                 return status;
8938         }
8939
8940         if (NT_STATUS_IS_ERR(status)) {
8941                 return status;
8942         }
8943
8944         /* Return variables */
8945         *trustdom_handle = *r.out.trustdom_handle;
8946
8947         /* Return result */
8948         return r.out.result;
8949 }
8950
8951 struct rpccli_lsa_CREDRWRITE_state {
8952         struct lsa_CREDRWRITE orig;
8953         struct lsa_CREDRWRITE tmp;
8954         TALLOC_CTX *out_mem_ctx;
8955         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8956 };
8957
8958 static void rpccli_lsa_CREDRWRITE_done(struct tevent_req *subreq);
8959
8960 struct tevent_req *rpccli_lsa_CREDRWRITE_send(TALLOC_CTX *mem_ctx,
8961                                               struct tevent_context *ev,
8962                                               struct rpc_pipe_client *cli)
8963 {
8964         struct tevent_req *req;
8965         struct rpccli_lsa_CREDRWRITE_state *state;
8966         struct tevent_req *subreq;
8967
8968         req = tevent_req_create(mem_ctx, &state,
8969                                 struct rpccli_lsa_CREDRWRITE_state);
8970         if (req == NULL) {
8971                 return NULL;
8972         }
8973         state->out_mem_ctx = NULL;
8974         state->dispatch_recv = cli->dispatch_recv;
8975
8976         /* In parameters */
8977
8978         /* Out parameters */
8979
8980         /* Result */
8981         ZERO_STRUCT(state->orig.out.result);
8982
8983         /* make a temporary copy, that we pass to the dispatch function */
8984         state->tmp = state->orig;
8985
8986         subreq = cli->dispatch_send(state, ev, cli,
8987                                     &ndr_table_lsarpc,
8988                                     NDR_LSA_CREDRWRITE,
8989                                     &state->tmp);
8990         if (tevent_req_nomem(subreq, req)) {
8991                 return tevent_req_post(req, ev);
8992         }
8993         tevent_req_set_callback(subreq, rpccli_lsa_CREDRWRITE_done, req);
8994         return req;
8995 }
8996
8997 static void rpccli_lsa_CREDRWRITE_done(struct tevent_req *subreq)
8998 {
8999         struct tevent_req *req = tevent_req_callback_data(
9000                 subreq, struct tevent_req);
9001         struct rpccli_lsa_CREDRWRITE_state *state = tevent_req_data(
9002                 req, struct rpccli_lsa_CREDRWRITE_state);
9003         NTSTATUS status;
9004         TALLOC_CTX *mem_ctx;
9005
9006         if (state->out_mem_ctx) {
9007                 mem_ctx = state->out_mem_ctx;
9008         } else {
9009                 mem_ctx = state;
9010         }
9011
9012         status = state->dispatch_recv(subreq, mem_ctx);
9013         TALLOC_FREE(subreq);
9014         if (!NT_STATUS_IS_OK(status)) {
9015                 tevent_req_nterror(req, status);
9016                 return;
9017         }
9018
9019         /* Copy out parameters */
9020
9021         /* Copy result */
9022         state->orig.out.result = state->tmp.out.result;
9023
9024         /* Reset temporary structure */
9025         ZERO_STRUCT(state->tmp);
9026
9027         tevent_req_done(req);
9028 }
9029
9030 NTSTATUS rpccli_lsa_CREDRWRITE_recv(struct tevent_req *req,
9031                                     TALLOC_CTX *mem_ctx,
9032                                     NTSTATUS *result)
9033 {
9034         struct rpccli_lsa_CREDRWRITE_state *state = tevent_req_data(
9035                 req, struct rpccli_lsa_CREDRWRITE_state);
9036         NTSTATUS status;
9037
9038         if (tevent_req_is_nterror(req, &status)) {
9039                 tevent_req_received(req);
9040                 return status;
9041         }
9042
9043         /* Steal possbile out parameters to the callers context */
9044         talloc_steal(mem_ctx, state->out_mem_ctx);
9045
9046         /* Return result */
9047         *result = state->orig.out.result;
9048
9049         tevent_req_received(req);
9050         return NT_STATUS_OK;
9051 }
9052
9053 NTSTATUS rpccli_lsa_CREDRWRITE(struct rpc_pipe_client *cli,
9054                                TALLOC_CTX *mem_ctx)
9055 {
9056         struct lsa_CREDRWRITE r;
9057         NTSTATUS status;
9058
9059         /* In parameters */
9060
9061         status = cli->dispatch(cli,
9062                                 mem_ctx,
9063                                 &ndr_table_lsarpc,
9064                                 NDR_LSA_CREDRWRITE,
9065                                 &r);
9066
9067         if (!NT_STATUS_IS_OK(status)) {
9068                 return status;
9069         }
9070
9071         if (NT_STATUS_IS_ERR(status)) {
9072                 return status;
9073         }
9074
9075         /* Return variables */
9076
9077         /* Return result */
9078         return r.out.result;
9079 }
9080
9081 struct rpccli_lsa_CREDRREAD_state {
9082         struct lsa_CREDRREAD orig;
9083         struct lsa_CREDRREAD tmp;
9084         TALLOC_CTX *out_mem_ctx;
9085         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9086 };
9087
9088 static void rpccli_lsa_CREDRREAD_done(struct tevent_req *subreq);
9089
9090 struct tevent_req *rpccli_lsa_CREDRREAD_send(TALLOC_CTX *mem_ctx,
9091                                              struct tevent_context *ev,
9092                                              struct rpc_pipe_client *cli)
9093 {
9094         struct tevent_req *req;
9095         struct rpccli_lsa_CREDRREAD_state *state;
9096         struct tevent_req *subreq;
9097
9098         req = tevent_req_create(mem_ctx, &state,
9099                                 struct rpccli_lsa_CREDRREAD_state);
9100         if (req == NULL) {
9101                 return NULL;
9102         }
9103         state->out_mem_ctx = NULL;
9104         state->dispatch_recv = cli->dispatch_recv;
9105
9106         /* In parameters */
9107
9108         /* Out parameters */
9109
9110         /* Result */
9111         ZERO_STRUCT(state->orig.out.result);
9112
9113         /* make a temporary copy, that we pass to the dispatch function */
9114         state->tmp = state->orig;
9115
9116         subreq = cli->dispatch_send(state, ev, cli,
9117                                     &ndr_table_lsarpc,
9118                                     NDR_LSA_CREDRREAD,
9119                                     &state->tmp);
9120         if (tevent_req_nomem(subreq, req)) {
9121                 return tevent_req_post(req, ev);
9122         }
9123         tevent_req_set_callback(subreq, rpccli_lsa_CREDRREAD_done, req);
9124         return req;
9125 }
9126
9127 static void rpccli_lsa_CREDRREAD_done(struct tevent_req *subreq)
9128 {
9129         struct tevent_req *req = tevent_req_callback_data(
9130                 subreq, struct tevent_req);
9131         struct rpccli_lsa_CREDRREAD_state *state = tevent_req_data(
9132                 req, struct rpccli_lsa_CREDRREAD_state);
9133         NTSTATUS status;
9134         TALLOC_CTX *mem_ctx;
9135
9136         if (state->out_mem_ctx) {
9137                 mem_ctx = state->out_mem_ctx;
9138         } else {
9139                 mem_ctx = state;
9140         }
9141
9142         status = state->dispatch_recv(subreq, mem_ctx);
9143         TALLOC_FREE(subreq);
9144         if (!NT_STATUS_IS_OK(status)) {
9145                 tevent_req_nterror(req, status);
9146                 return;
9147         }
9148
9149         /* Copy out parameters */
9150
9151         /* Copy result */
9152         state->orig.out.result = state->tmp.out.result;
9153
9154         /* Reset temporary structure */
9155         ZERO_STRUCT(state->tmp);
9156
9157         tevent_req_done(req);
9158 }
9159
9160 NTSTATUS rpccli_lsa_CREDRREAD_recv(struct tevent_req *req,
9161                                    TALLOC_CTX *mem_ctx,
9162                                    NTSTATUS *result)
9163 {
9164         struct rpccli_lsa_CREDRREAD_state *state = tevent_req_data(
9165                 req, struct rpccli_lsa_CREDRREAD_state);
9166         NTSTATUS status;
9167
9168         if (tevent_req_is_nterror(req, &status)) {
9169                 tevent_req_received(req);
9170                 return status;
9171         }
9172
9173         /* Steal possbile out parameters to the callers context */
9174         talloc_steal(mem_ctx, state->out_mem_ctx);
9175
9176         /* Return result */
9177         *result = state->orig.out.result;
9178
9179         tevent_req_received(req);
9180         return NT_STATUS_OK;
9181 }
9182
9183 NTSTATUS rpccli_lsa_CREDRREAD(struct rpc_pipe_client *cli,
9184                               TALLOC_CTX *mem_ctx)
9185 {
9186         struct lsa_CREDRREAD r;
9187         NTSTATUS status;
9188
9189         /* In parameters */
9190
9191         status = cli->dispatch(cli,
9192                                 mem_ctx,
9193                                 &ndr_table_lsarpc,
9194                                 NDR_LSA_CREDRREAD,
9195                                 &r);
9196
9197         if (!NT_STATUS_IS_OK(status)) {
9198                 return status;
9199         }
9200
9201         if (NT_STATUS_IS_ERR(status)) {
9202                 return status;
9203         }
9204
9205         /* Return variables */
9206
9207         /* Return result */
9208         return r.out.result;
9209 }
9210
9211 struct rpccli_lsa_CREDRENUMERATE_state {
9212         struct lsa_CREDRENUMERATE orig;
9213         struct lsa_CREDRENUMERATE tmp;
9214         TALLOC_CTX *out_mem_ctx;
9215         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9216 };
9217
9218 static void rpccli_lsa_CREDRENUMERATE_done(struct tevent_req *subreq);
9219
9220 struct tevent_req *rpccli_lsa_CREDRENUMERATE_send(TALLOC_CTX *mem_ctx,
9221                                                   struct tevent_context *ev,
9222                                                   struct rpc_pipe_client *cli)
9223 {
9224         struct tevent_req *req;
9225         struct rpccli_lsa_CREDRENUMERATE_state *state;
9226         struct tevent_req *subreq;
9227
9228         req = tevent_req_create(mem_ctx, &state,
9229                                 struct rpccli_lsa_CREDRENUMERATE_state);
9230         if (req == NULL) {
9231                 return NULL;
9232         }
9233         state->out_mem_ctx = NULL;
9234         state->dispatch_recv = cli->dispatch_recv;
9235
9236         /* In parameters */
9237
9238         /* Out parameters */
9239
9240         /* Result */
9241         ZERO_STRUCT(state->orig.out.result);
9242
9243         /* make a temporary copy, that we pass to the dispatch function */
9244         state->tmp = state->orig;
9245
9246         subreq = cli->dispatch_send(state, ev, cli,
9247                                     &ndr_table_lsarpc,
9248                                     NDR_LSA_CREDRENUMERATE,
9249                                     &state->tmp);
9250         if (tevent_req_nomem(subreq, req)) {
9251                 return tevent_req_post(req, ev);
9252         }
9253         tevent_req_set_callback(subreq, rpccli_lsa_CREDRENUMERATE_done, req);
9254         return req;
9255 }
9256
9257 static void rpccli_lsa_CREDRENUMERATE_done(struct tevent_req *subreq)
9258 {
9259         struct tevent_req *req = tevent_req_callback_data(
9260                 subreq, struct tevent_req);
9261         struct rpccli_lsa_CREDRENUMERATE_state *state = tevent_req_data(
9262                 req, struct rpccli_lsa_CREDRENUMERATE_state);
9263         NTSTATUS status;
9264         TALLOC_CTX *mem_ctx;
9265
9266         if (state->out_mem_ctx) {
9267                 mem_ctx = state->out_mem_ctx;
9268         } else {
9269                 mem_ctx = state;
9270         }
9271
9272         status = state->dispatch_recv(subreq, mem_ctx);
9273         TALLOC_FREE(subreq);
9274         if (!NT_STATUS_IS_OK(status)) {
9275                 tevent_req_nterror(req, status);
9276                 return;
9277         }
9278
9279         /* Copy out parameters */
9280
9281         /* Copy result */
9282         state->orig.out.result = state->tmp.out.result;
9283
9284         /* Reset temporary structure */
9285         ZERO_STRUCT(state->tmp);
9286
9287         tevent_req_done(req);
9288 }
9289
9290 NTSTATUS rpccli_lsa_CREDRENUMERATE_recv(struct tevent_req *req,
9291                                         TALLOC_CTX *mem_ctx,
9292                                         NTSTATUS *result)
9293 {
9294         struct rpccli_lsa_CREDRENUMERATE_state *state = tevent_req_data(
9295                 req, struct rpccli_lsa_CREDRENUMERATE_state);
9296         NTSTATUS status;
9297
9298         if (tevent_req_is_nterror(req, &status)) {
9299                 tevent_req_received(req);
9300                 return status;
9301         }
9302
9303         /* Steal possbile out parameters to the callers context */
9304         talloc_steal(mem_ctx, state->out_mem_ctx);
9305
9306         /* Return result */
9307         *result = state->orig.out.result;
9308
9309         tevent_req_received(req);
9310         return NT_STATUS_OK;
9311 }
9312
9313 NTSTATUS rpccli_lsa_CREDRENUMERATE(struct rpc_pipe_client *cli,
9314                                    TALLOC_CTX *mem_ctx)
9315 {
9316         struct lsa_CREDRENUMERATE r;
9317         NTSTATUS status;
9318
9319         /* In parameters */
9320
9321         status = cli->dispatch(cli,
9322                                 mem_ctx,
9323                                 &ndr_table_lsarpc,
9324                                 NDR_LSA_CREDRENUMERATE,
9325                                 &r);
9326
9327         if (!NT_STATUS_IS_OK(status)) {
9328                 return status;
9329         }
9330
9331         if (NT_STATUS_IS_ERR(status)) {
9332                 return status;
9333         }
9334
9335         /* Return variables */
9336
9337         /* Return result */
9338         return r.out.result;
9339 }
9340
9341 struct rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_state {
9342         struct lsa_CREDRWRITEDOMAINCREDENTIALS orig;
9343         struct lsa_CREDRWRITEDOMAINCREDENTIALS tmp;
9344         TALLOC_CTX *out_mem_ctx;
9345         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9346 };
9347
9348 static void rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_done(struct tevent_req *subreq);
9349
9350 struct tevent_req *rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_send(TALLOC_CTX *mem_ctx,
9351                                                                struct tevent_context *ev,
9352                                                                struct rpc_pipe_client *cli)
9353 {
9354         struct tevent_req *req;
9355         struct rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_state *state;
9356         struct tevent_req *subreq;
9357
9358         req = tevent_req_create(mem_ctx, &state,
9359                                 struct rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_state);
9360         if (req == NULL) {
9361                 return NULL;
9362         }
9363         state->out_mem_ctx = NULL;
9364         state->dispatch_recv = cli->dispatch_recv;
9365
9366         /* In parameters */
9367
9368         /* Out parameters */
9369
9370         /* Result */
9371         ZERO_STRUCT(state->orig.out.result);
9372
9373         /* make a temporary copy, that we pass to the dispatch function */
9374         state->tmp = state->orig;
9375
9376         subreq = cli->dispatch_send(state, ev, cli,
9377                                     &ndr_table_lsarpc,
9378                                     NDR_LSA_CREDRWRITEDOMAINCREDENTIALS,
9379                                     &state->tmp);
9380         if (tevent_req_nomem(subreq, req)) {
9381                 return tevent_req_post(req, ev);
9382         }
9383         tevent_req_set_callback(subreq, rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_done, req);
9384         return req;
9385 }
9386
9387 static void rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_done(struct tevent_req *subreq)
9388 {
9389         struct tevent_req *req = tevent_req_callback_data(
9390                 subreq, struct tevent_req);
9391         struct rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_state *state = tevent_req_data(
9392                 req, struct rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_state);
9393         NTSTATUS status;
9394         TALLOC_CTX *mem_ctx;
9395
9396         if (state->out_mem_ctx) {
9397                 mem_ctx = state->out_mem_ctx;
9398         } else {
9399                 mem_ctx = state;
9400         }
9401
9402         status = state->dispatch_recv(subreq, mem_ctx);
9403         TALLOC_FREE(subreq);
9404         if (!NT_STATUS_IS_OK(status)) {
9405                 tevent_req_nterror(req, status);
9406                 return;
9407         }
9408
9409         /* Copy out parameters */
9410
9411         /* Copy result */
9412         state->orig.out.result = state->tmp.out.result;
9413
9414         /* Reset temporary structure */
9415         ZERO_STRUCT(state->tmp);
9416
9417         tevent_req_done(req);
9418 }
9419
9420 NTSTATUS rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_recv(struct tevent_req *req,
9421                                                      TALLOC_CTX *mem_ctx,
9422                                                      NTSTATUS *result)
9423 {
9424         struct rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_state *state = tevent_req_data(
9425                 req, struct rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_state);
9426         NTSTATUS status;
9427
9428         if (tevent_req_is_nterror(req, &status)) {
9429                 tevent_req_received(req);
9430                 return status;
9431         }
9432
9433         /* Steal possbile out parameters to the callers context */
9434         talloc_steal(mem_ctx, state->out_mem_ctx);
9435
9436         /* Return result */
9437         *result = state->orig.out.result;
9438
9439         tevent_req_received(req);
9440         return NT_STATUS_OK;
9441 }
9442
9443 NTSTATUS rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS(struct rpc_pipe_client *cli,
9444                                                 TALLOC_CTX *mem_ctx)
9445 {
9446         struct lsa_CREDRWRITEDOMAINCREDENTIALS r;
9447         NTSTATUS status;
9448
9449         /* In parameters */
9450
9451         status = cli->dispatch(cli,
9452                                 mem_ctx,
9453                                 &ndr_table_lsarpc,
9454                                 NDR_LSA_CREDRWRITEDOMAINCREDENTIALS,
9455                                 &r);
9456
9457         if (!NT_STATUS_IS_OK(status)) {
9458                 return status;
9459         }
9460
9461         if (NT_STATUS_IS_ERR(status)) {
9462                 return status;
9463         }
9464
9465         /* Return variables */
9466
9467         /* Return result */
9468         return r.out.result;
9469 }
9470
9471 struct rpccli_lsa_CREDRREADDOMAINCREDENTIALS_state {
9472         struct lsa_CREDRREADDOMAINCREDENTIALS orig;
9473         struct lsa_CREDRREADDOMAINCREDENTIALS tmp;
9474         TALLOC_CTX *out_mem_ctx;
9475         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9476 };
9477
9478 static void rpccli_lsa_CREDRREADDOMAINCREDENTIALS_done(struct tevent_req *subreq);
9479
9480 struct tevent_req *rpccli_lsa_CREDRREADDOMAINCREDENTIALS_send(TALLOC_CTX *mem_ctx,
9481                                                               struct tevent_context *ev,
9482                                                               struct rpc_pipe_client *cli)
9483 {
9484         struct tevent_req *req;
9485         struct rpccli_lsa_CREDRREADDOMAINCREDENTIALS_state *state;
9486         struct tevent_req *subreq;
9487
9488         req = tevent_req_create(mem_ctx, &state,
9489                                 struct rpccli_lsa_CREDRREADDOMAINCREDENTIALS_state);
9490         if (req == NULL) {
9491                 return NULL;
9492         }
9493         state->out_mem_ctx = NULL;
9494         state->dispatch_recv = cli->dispatch_recv;
9495
9496         /* In parameters */
9497
9498         /* Out parameters */
9499
9500         /* Result */
9501         ZERO_STRUCT(state->orig.out.result);
9502
9503         /* make a temporary copy, that we pass to the dispatch function */
9504         state->tmp = state->orig;
9505
9506         subreq = cli->dispatch_send(state, ev, cli,
9507                                     &ndr_table_lsarpc,
9508                                     NDR_LSA_CREDRREADDOMAINCREDENTIALS,
9509                                     &state->tmp);
9510         if (tevent_req_nomem(subreq, req)) {
9511                 return tevent_req_post(req, ev);
9512         }
9513         tevent_req_set_callback(subreq, rpccli_lsa_CREDRREADDOMAINCREDENTIALS_done, req);
9514         return req;
9515 }
9516
9517 static void rpccli_lsa_CREDRREADDOMAINCREDENTIALS_done(struct tevent_req *subreq)
9518 {
9519         struct tevent_req *req = tevent_req_callback_data(
9520                 subreq, struct tevent_req);
9521         struct rpccli_lsa_CREDRREADDOMAINCREDENTIALS_state *state = tevent_req_data(
9522                 req, struct rpccli_lsa_CREDRREADDOMAINCREDENTIALS_state);
9523         NTSTATUS status;
9524         TALLOC_CTX *mem_ctx;
9525
9526         if (state->out_mem_ctx) {
9527                 mem_ctx = state->out_mem_ctx;
9528         } else {
9529                 mem_ctx = state;
9530         }
9531
9532         status = state->dispatch_recv(subreq, mem_ctx);
9533         TALLOC_FREE(subreq);
9534         if (!NT_STATUS_IS_OK(status)) {
9535                 tevent_req_nterror(req, status);
9536                 return;
9537         }
9538
9539         /* Copy out parameters */
9540
9541         /* Copy result */
9542         state->orig.out.result = state->tmp.out.result;
9543
9544         /* Reset temporary structure */
9545         ZERO_STRUCT(state->tmp);
9546
9547         tevent_req_done(req);
9548 }
9549
9550 NTSTATUS rpccli_lsa_CREDRREADDOMAINCREDENTIALS_recv(struct tevent_req *req,
9551                                                     TALLOC_CTX *mem_ctx,
9552                                                     NTSTATUS *result)
9553 {
9554         struct rpccli_lsa_CREDRREADDOMAINCREDENTIALS_state *state = tevent_req_data(
9555                 req, struct rpccli_lsa_CREDRREADDOMAINCREDENTIALS_state);
9556         NTSTATUS status;
9557
9558         if (tevent_req_is_nterror(req, &status)) {
9559                 tevent_req_received(req);
9560                 return status;
9561         }
9562
9563         /* Steal possbile out parameters to the callers context */
9564         talloc_steal(mem_ctx, state->out_mem_ctx);
9565
9566         /* Return result */
9567         *result = state->orig.out.result;
9568
9569         tevent_req_received(req);
9570         return NT_STATUS_OK;
9571 }
9572
9573 NTSTATUS rpccli_lsa_CREDRREADDOMAINCREDENTIALS(struct rpc_pipe_client *cli,
9574                                                TALLOC_CTX *mem_ctx)
9575 {
9576         struct lsa_CREDRREADDOMAINCREDENTIALS r;
9577         NTSTATUS status;
9578
9579         /* In parameters */
9580
9581         status = cli->dispatch(cli,
9582                                 mem_ctx,
9583                                 &ndr_table_lsarpc,
9584                                 NDR_LSA_CREDRREADDOMAINCREDENTIALS,
9585                                 &r);
9586
9587         if (!NT_STATUS_IS_OK(status)) {
9588                 return status;
9589         }
9590
9591         if (NT_STATUS_IS_ERR(status)) {
9592                 return status;
9593         }
9594
9595         /* Return variables */
9596
9597         /* Return result */
9598         return r.out.result;
9599 }
9600
9601 struct rpccli_lsa_CREDRDELETE_state {
9602         struct lsa_CREDRDELETE orig;
9603         struct lsa_CREDRDELETE tmp;
9604         TALLOC_CTX *out_mem_ctx;
9605         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9606 };
9607
9608 static void rpccli_lsa_CREDRDELETE_done(struct tevent_req *subreq);
9609
9610 struct tevent_req *rpccli_lsa_CREDRDELETE_send(TALLOC_CTX *mem_ctx,
9611                                                struct tevent_context *ev,
9612                                                struct rpc_pipe_client *cli)
9613 {
9614         struct tevent_req *req;
9615         struct rpccli_lsa_CREDRDELETE_state *state;
9616         struct tevent_req *subreq;
9617
9618         req = tevent_req_create(mem_ctx, &state,
9619                                 struct rpccli_lsa_CREDRDELETE_state);
9620         if (req == NULL) {
9621                 return NULL;
9622         }
9623         state->out_mem_ctx = NULL;
9624         state->dispatch_recv = cli->dispatch_recv;
9625
9626         /* In parameters */
9627
9628         /* Out parameters */
9629
9630         /* Result */
9631         ZERO_STRUCT(state->orig.out.result);
9632
9633         /* make a temporary copy, that we pass to the dispatch function */
9634         state->tmp = state->orig;
9635
9636         subreq = cli->dispatch_send(state, ev, cli,
9637                                     &ndr_table_lsarpc,
9638                                     NDR_LSA_CREDRDELETE,
9639                                     &state->tmp);
9640         if (tevent_req_nomem(subreq, req)) {
9641                 return tevent_req_post(req, ev);
9642         }
9643         tevent_req_set_callback(subreq, rpccli_lsa_CREDRDELETE_done, req);
9644         return req;
9645 }
9646
9647 static void rpccli_lsa_CREDRDELETE_done(struct tevent_req *subreq)
9648 {
9649         struct tevent_req *req = tevent_req_callback_data(
9650                 subreq, struct tevent_req);
9651         struct rpccli_lsa_CREDRDELETE_state *state = tevent_req_data(
9652                 req, struct rpccli_lsa_CREDRDELETE_state);
9653         NTSTATUS status;
9654         TALLOC_CTX *mem_ctx;
9655
9656         if (state->out_mem_ctx) {
9657                 mem_ctx = state->out_mem_ctx;
9658         } else {
9659                 mem_ctx = state;
9660         }
9661
9662         status = state->dispatch_recv(subreq, mem_ctx);
9663         TALLOC_FREE(subreq);
9664         if (!NT_STATUS_IS_OK(status)) {
9665                 tevent_req_nterror(req, status);
9666                 return;
9667         }
9668
9669         /* Copy out parameters */
9670
9671         /* Copy result */
9672         state->orig.out.result = state->tmp.out.result;
9673
9674         /* Reset temporary structure */
9675         ZERO_STRUCT(state->tmp);
9676
9677         tevent_req_done(req);
9678 }
9679
9680 NTSTATUS rpccli_lsa_CREDRDELETE_recv(struct tevent_req *req,
9681                                      TALLOC_CTX *mem_ctx,
9682                                      NTSTATUS *result)
9683 {
9684         struct rpccli_lsa_CREDRDELETE_state *state = tevent_req_data(
9685                 req, struct rpccli_lsa_CREDRDELETE_state);
9686         NTSTATUS status;
9687
9688         if (tevent_req_is_nterror(req, &status)) {
9689                 tevent_req_received(req);
9690                 return status;
9691         }
9692
9693         /* Steal possbile out parameters to the callers context */
9694         talloc_steal(mem_ctx, state->out_mem_ctx);
9695
9696         /* Return result */
9697         *result = state->orig.out.result;
9698
9699         tevent_req_received(req);
9700         return NT_STATUS_OK;
9701 }
9702
9703 NTSTATUS rpccli_lsa_CREDRDELETE(struct rpc_pipe_client *cli,
9704                                 TALLOC_CTX *mem_ctx)
9705 {
9706         struct lsa_CREDRDELETE r;
9707         NTSTATUS status;
9708
9709         /* In parameters */
9710
9711         status = cli->dispatch(cli,
9712                                 mem_ctx,
9713                                 &ndr_table_lsarpc,
9714                                 NDR_LSA_CREDRDELETE,
9715                                 &r);
9716
9717         if (!NT_STATUS_IS_OK(status)) {
9718                 return status;
9719         }
9720
9721         if (NT_STATUS_IS_ERR(status)) {
9722                 return status;
9723         }
9724
9725         /* Return variables */
9726
9727         /* Return result */
9728         return r.out.result;
9729 }
9730
9731 struct rpccli_lsa_CREDRGETTARGETINFO_state {
9732         struct lsa_CREDRGETTARGETINFO orig;
9733         struct lsa_CREDRGETTARGETINFO tmp;
9734         TALLOC_CTX *out_mem_ctx;
9735         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9736 };
9737
9738 static void rpccli_lsa_CREDRGETTARGETINFO_done(struct tevent_req *subreq);
9739
9740 struct tevent_req *rpccli_lsa_CREDRGETTARGETINFO_send(TALLOC_CTX *mem_ctx,
9741                                                       struct tevent_context *ev,
9742                                                       struct rpc_pipe_client *cli)
9743 {
9744         struct tevent_req *req;
9745         struct rpccli_lsa_CREDRGETTARGETINFO_state *state;
9746         struct tevent_req *subreq;
9747
9748         req = tevent_req_create(mem_ctx, &state,
9749                                 struct rpccli_lsa_CREDRGETTARGETINFO_state);
9750         if (req == NULL) {
9751                 return NULL;
9752         }
9753         state->out_mem_ctx = NULL;
9754         state->dispatch_recv = cli->dispatch_recv;
9755
9756         /* In parameters */
9757
9758         /* Out parameters */
9759
9760         /* Result */
9761         ZERO_STRUCT(state->orig.out.result);
9762
9763         /* make a temporary copy, that we pass to the dispatch function */
9764         state->tmp = state->orig;
9765
9766         subreq = cli->dispatch_send(state, ev, cli,
9767                                     &ndr_table_lsarpc,
9768                                     NDR_LSA_CREDRGETTARGETINFO,
9769                                     &state->tmp);
9770         if (tevent_req_nomem(subreq, req)) {
9771                 return tevent_req_post(req, ev);
9772         }
9773         tevent_req_set_callback(subreq, rpccli_lsa_CREDRGETTARGETINFO_done, req);
9774         return req;
9775 }
9776
9777 static void rpccli_lsa_CREDRGETTARGETINFO_done(struct tevent_req *subreq)
9778 {
9779         struct tevent_req *req = tevent_req_callback_data(
9780                 subreq, struct tevent_req);
9781         struct rpccli_lsa_CREDRGETTARGETINFO_state *state = tevent_req_data(
9782                 req, struct rpccli_lsa_CREDRGETTARGETINFO_state);
9783         NTSTATUS status;
9784         TALLOC_CTX *mem_ctx;
9785
9786         if (state->out_mem_ctx) {
9787                 mem_ctx = state->out_mem_ctx;
9788         } else {
9789                 mem_ctx = state;
9790         }
9791
9792         status = state->dispatch_recv(subreq, mem_ctx);
9793         TALLOC_FREE(subreq);
9794         if (!NT_STATUS_IS_OK(status)) {
9795                 tevent_req_nterror(req, status);
9796                 return;
9797         }
9798
9799         /* Copy out parameters */
9800
9801         /* Copy result */
9802         state->orig.out.result = state->tmp.out.result;
9803
9804         /* Reset temporary structure */
9805         ZERO_STRUCT(state->tmp);
9806
9807         tevent_req_done(req);
9808 }
9809
9810 NTSTATUS rpccli_lsa_CREDRGETTARGETINFO_recv(struct tevent_req *req,
9811                                             TALLOC_CTX *mem_ctx,
9812                                             NTSTATUS *result)
9813 {
9814         struct rpccli_lsa_CREDRGETTARGETINFO_state *state = tevent_req_data(
9815                 req, struct rpccli_lsa_CREDRGETTARGETINFO_state);
9816         NTSTATUS status;
9817
9818         if (tevent_req_is_nterror(req, &status)) {
9819                 tevent_req_received(req);
9820                 return status;
9821         }
9822
9823         /* Steal possbile out parameters to the callers context */
9824         talloc_steal(mem_ctx, state->out_mem_ctx);
9825
9826         /* Return result */
9827         *result = state->orig.out.result;
9828
9829         tevent_req_received(req);
9830         return NT_STATUS_OK;
9831 }
9832
9833 NTSTATUS rpccli_lsa_CREDRGETTARGETINFO(struct rpc_pipe_client *cli,
9834                                        TALLOC_CTX *mem_ctx)
9835 {
9836         struct lsa_CREDRGETTARGETINFO r;
9837         NTSTATUS status;
9838
9839         /* In parameters */
9840
9841         status = cli->dispatch(cli,
9842                                 mem_ctx,
9843                                 &ndr_table_lsarpc,
9844                                 NDR_LSA_CREDRGETTARGETINFO,
9845                                 &r);
9846
9847         if (!NT_STATUS_IS_OK(status)) {
9848                 return status;
9849         }
9850
9851         if (NT_STATUS_IS_ERR(status)) {
9852                 return status;
9853         }
9854
9855         /* Return variables */
9856
9857         /* Return result */
9858         return r.out.result;
9859 }
9860
9861 struct rpccli_lsa_CREDRPROFILELOADED_state {
9862         struct lsa_CREDRPROFILELOADED orig;
9863         struct lsa_CREDRPROFILELOADED tmp;
9864         TALLOC_CTX *out_mem_ctx;
9865         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9866 };
9867
9868 static void rpccli_lsa_CREDRPROFILELOADED_done(struct tevent_req *subreq);
9869
9870 struct tevent_req *rpccli_lsa_CREDRPROFILELOADED_send(TALLOC_CTX *mem_ctx,
9871                                                       struct tevent_context *ev,
9872                                                       struct rpc_pipe_client *cli)
9873 {
9874         struct tevent_req *req;
9875         struct rpccli_lsa_CREDRPROFILELOADED_state *state;
9876         struct tevent_req *subreq;
9877
9878         req = tevent_req_create(mem_ctx, &state,
9879                                 struct rpccli_lsa_CREDRPROFILELOADED_state);
9880         if (req == NULL) {
9881                 return NULL;
9882         }
9883         state->out_mem_ctx = NULL;
9884         state->dispatch_recv = cli->dispatch_recv;
9885
9886         /* In parameters */
9887
9888         /* Out parameters */
9889
9890         /* Result */
9891         ZERO_STRUCT(state->orig.out.result);
9892
9893         /* make a temporary copy, that we pass to the dispatch function */
9894         state->tmp = state->orig;
9895
9896         subreq = cli->dispatch_send(state, ev, cli,
9897                                     &ndr_table_lsarpc,
9898                                     NDR_LSA_CREDRPROFILELOADED,
9899                                     &state->tmp);
9900         if (tevent_req_nomem(subreq, req)) {
9901                 return tevent_req_post(req, ev);
9902         }
9903         tevent_req_set_callback(subreq, rpccli_lsa_CREDRPROFILELOADED_done, req);
9904         return req;
9905 }
9906
9907 static void rpccli_lsa_CREDRPROFILELOADED_done(struct tevent_req *subreq)
9908 {
9909         struct tevent_req *req = tevent_req_callback_data(
9910                 subreq, struct tevent_req);
9911         struct rpccli_lsa_CREDRPROFILELOADED_state *state = tevent_req_data(
9912                 req, struct rpccli_lsa_CREDRPROFILELOADED_state);
9913         NTSTATUS status;
9914         TALLOC_CTX *mem_ctx;
9915
9916         if (state->out_mem_ctx) {
9917                 mem_ctx = state->out_mem_ctx;
9918         } else {
9919                 mem_ctx = state;
9920         }
9921
9922         status = state->dispatch_recv(subreq, mem_ctx);
9923         TALLOC_FREE(subreq);
9924         if (!NT_STATUS_IS_OK(status)) {
9925                 tevent_req_nterror(req, status);
9926                 return;
9927         }
9928
9929         /* Copy out parameters */
9930
9931         /* Copy result */
9932         state->orig.out.result = state->tmp.out.result;
9933
9934         /* Reset temporary structure */
9935         ZERO_STRUCT(state->tmp);
9936
9937         tevent_req_done(req);
9938 }
9939
9940 NTSTATUS rpccli_lsa_CREDRPROFILELOADED_recv(struct tevent_req *req,
9941                                             TALLOC_CTX *mem_ctx,
9942                                             NTSTATUS *result)
9943 {
9944         struct rpccli_lsa_CREDRPROFILELOADED_state *state = tevent_req_data(
9945                 req, struct rpccli_lsa_CREDRPROFILELOADED_state);
9946         NTSTATUS status;
9947
9948         if (tevent_req_is_nterror(req, &status)) {
9949                 tevent_req_received(req);
9950                 return status;
9951         }
9952
9953         /* Steal possbile out parameters to the callers context */
9954         talloc_steal(mem_ctx, state->out_mem_ctx);
9955
9956         /* Return result */
9957         *result = state->orig.out.result;
9958
9959         tevent_req_received(req);
9960         return NT_STATUS_OK;
9961 }
9962
9963 NTSTATUS rpccli_lsa_CREDRPROFILELOADED(struct rpc_pipe_client *cli,
9964                                        TALLOC_CTX *mem_ctx)
9965 {
9966         struct lsa_CREDRPROFILELOADED r;
9967         NTSTATUS status;
9968
9969         /* In parameters */
9970
9971         status = cli->dispatch(cli,
9972                                 mem_ctx,
9973                                 &ndr_table_lsarpc,
9974                                 NDR_LSA_CREDRPROFILELOADED,
9975                                 &r);
9976
9977         if (!NT_STATUS_IS_OK(status)) {
9978                 return status;
9979         }
9980
9981         if (NT_STATUS_IS_ERR(status)) {
9982                 return status;
9983         }
9984
9985         /* Return variables */
9986
9987         /* Return result */
9988         return r.out.result;
9989 }
9990
9991 struct rpccli_lsa_LookupNames3_state {
9992         struct lsa_LookupNames3 orig;
9993         struct lsa_LookupNames3 tmp;
9994         TALLOC_CTX *out_mem_ctx;
9995         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9996 };
9997
9998 static void rpccli_lsa_LookupNames3_done(struct tevent_req *subreq);
9999
10000 struct tevent_req *rpccli_lsa_LookupNames3_send(TALLOC_CTX *mem_ctx,
10001                                                 struct tevent_context *ev,
10002                                                 struct rpc_pipe_client *cli,
10003                                                 struct policy_handle *_handle /* [in] [ref] */,
10004                                                 uint32_t _num_names /* [in] [range(0,1000)] */,
10005                                                 struct lsa_String *_names /* [in] [size_is(num_names)] */,
10006                                                 struct lsa_RefDomainList **_domains /* [out] [ref] */,
10007                                                 struct lsa_TransSidArray3 *_sids /* [in,out] [ref] */,
10008                                                 enum lsa_LookupNamesLevel _level /* [in]  */,
10009                                                 uint32_t *_count /* [in,out] [ref] */,
10010                                                 enum lsa_LookupOptions _lookup_options /* [in]  */,
10011                                                 enum lsa_ClientRevision _client_revision /* [in]  */)
10012 {
10013         struct tevent_req *req;
10014         struct rpccli_lsa_LookupNames3_state *state;
10015         struct tevent_req *subreq;
10016
10017         req = tevent_req_create(mem_ctx, &state,
10018                                 struct rpccli_lsa_LookupNames3_state);
10019         if (req == NULL) {
10020                 return NULL;
10021         }
10022         state->out_mem_ctx = NULL;
10023         state->dispatch_recv = cli->dispatch_recv;
10024
10025         /* In parameters */
10026         state->orig.in.handle = _handle;
10027         state->orig.in.num_names = _num_names;
10028         state->orig.in.names = _names;
10029         state->orig.in.sids = _sids;
10030         state->orig.in.level = _level;
10031         state->orig.in.count = _count;
10032         state->orig.in.lookup_options = _lookup_options;
10033         state->orig.in.client_revision = _client_revision;
10034
10035         /* Out parameters */
10036         state->orig.out.domains = _domains;
10037         state->orig.out.sids = _sids;
10038         state->orig.out.count = _count;
10039
10040         /* Result */
10041         ZERO_STRUCT(state->orig.out.result);
10042
10043         state->out_mem_ctx = talloc_named_const(state, 0,
10044                              "rpccli_lsa_LookupNames3_out_memory");
10045         if (tevent_req_nomem(state->out_mem_ctx, req)) {
10046                 return tevent_req_post(req, ev);
10047         }
10048
10049         /* make a temporary copy, that we pass to the dispatch function */
10050         state->tmp = state->orig;
10051
10052         subreq = cli->dispatch_send(state, ev, cli,
10053                                     &ndr_table_lsarpc,
10054                                     NDR_LSA_LOOKUPNAMES3,
10055                                     &state->tmp);
10056         if (tevent_req_nomem(subreq, req)) {
10057                 return tevent_req_post(req, ev);
10058         }
10059         tevent_req_set_callback(subreq, rpccli_lsa_LookupNames3_done, req);
10060         return req;
10061 }
10062
10063 static void rpccli_lsa_LookupNames3_done(struct tevent_req *subreq)
10064 {
10065         struct tevent_req *req = tevent_req_callback_data(
10066                 subreq, struct tevent_req);
10067         struct rpccli_lsa_LookupNames3_state *state = tevent_req_data(
10068                 req, struct rpccli_lsa_LookupNames3_state);
10069         NTSTATUS status;
10070         TALLOC_CTX *mem_ctx;
10071
10072         if (state->out_mem_ctx) {
10073                 mem_ctx = state->out_mem_ctx;
10074         } else {
10075                 mem_ctx = state;
10076         }
10077
10078         status = state->dispatch_recv(subreq, mem_ctx);
10079         TALLOC_FREE(subreq);
10080         if (!NT_STATUS_IS_OK(status)) {
10081                 tevent_req_nterror(req, status);
10082                 return;
10083         }
10084
10085         /* Copy out parameters */
10086         *state->orig.out.domains = *state->tmp.out.domains;
10087         *state->orig.out.sids = *state->tmp.out.sids;
10088         *state->orig.out.count = *state->tmp.out.count;
10089
10090         /* Copy result */
10091         state->orig.out.result = state->tmp.out.result;
10092
10093         /* Reset temporary structure */
10094         ZERO_STRUCT(state->tmp);
10095
10096         tevent_req_done(req);
10097 }
10098
10099 NTSTATUS rpccli_lsa_LookupNames3_recv(struct tevent_req *req,
10100                                       TALLOC_CTX *mem_ctx,
10101                                       NTSTATUS *result)
10102 {
10103         struct rpccli_lsa_LookupNames3_state *state = tevent_req_data(
10104                 req, struct rpccli_lsa_LookupNames3_state);
10105         NTSTATUS status;
10106
10107         if (tevent_req_is_nterror(req, &status)) {
10108                 tevent_req_received(req);
10109                 return status;
10110         }
10111
10112         /* Steal possbile out parameters to the callers context */
10113         talloc_steal(mem_ctx, state->out_mem_ctx);
10114
10115         /* Return result */
10116         *result = state->orig.out.result;
10117
10118         tevent_req_received(req);
10119         return NT_STATUS_OK;
10120 }
10121
10122 NTSTATUS rpccli_lsa_LookupNames3(struct rpc_pipe_client *cli,
10123                                  TALLOC_CTX *mem_ctx,
10124                                  struct policy_handle *handle /* [in] [ref] */,
10125                                  uint32_t num_names /* [in] [range(0,1000)] */,
10126                                  struct lsa_String *names /* [in] [size_is(num_names)] */,
10127                                  struct lsa_RefDomainList **domains /* [out] [ref] */,
10128                                  struct lsa_TransSidArray3 *sids /* [in,out] [ref] */,
10129                                  enum lsa_LookupNamesLevel level /* [in]  */,
10130                                  uint32_t *count /* [in,out] [ref] */,
10131                                  enum lsa_LookupOptions lookup_options /* [in]  */,
10132                                  enum lsa_ClientRevision client_revision /* [in]  */)
10133 {
10134         struct lsa_LookupNames3 r;
10135         NTSTATUS status;
10136
10137         /* In parameters */
10138         r.in.handle = handle;
10139         r.in.num_names = num_names;
10140         r.in.names = names;
10141         r.in.sids = sids;
10142         r.in.level = level;
10143         r.in.count = count;
10144         r.in.lookup_options = lookup_options;
10145         r.in.client_revision = client_revision;
10146
10147         status = cli->dispatch(cli,
10148                                 mem_ctx,
10149                                 &ndr_table_lsarpc,
10150                                 NDR_LSA_LOOKUPNAMES3,
10151                                 &r);
10152
10153         if (!NT_STATUS_IS_OK(status)) {
10154                 return status;
10155         }
10156
10157         if (NT_STATUS_IS_ERR(status)) {
10158                 return status;
10159         }
10160
10161         /* Return variables */
10162         *domains = *r.out.domains;
10163         *sids = *r.out.sids;
10164         *count = *r.out.count;
10165
10166         /* Return result */
10167         return r.out.result;
10168 }
10169
10170 struct rpccli_lsa_CREDRGETSESSIONTYPES_state {
10171         struct lsa_CREDRGETSESSIONTYPES orig;
10172         struct lsa_CREDRGETSESSIONTYPES tmp;
10173         TALLOC_CTX *out_mem_ctx;
10174         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10175 };
10176
10177 static void rpccli_lsa_CREDRGETSESSIONTYPES_done(struct tevent_req *subreq);
10178
10179 struct tevent_req *rpccli_lsa_CREDRGETSESSIONTYPES_send(TALLOC_CTX *mem_ctx,
10180                                                         struct tevent_context *ev,
10181                                                         struct rpc_pipe_client *cli)
10182 {
10183         struct tevent_req *req;
10184         struct rpccli_lsa_CREDRGETSESSIONTYPES_state *state;
10185         struct tevent_req *subreq;
10186
10187         req = tevent_req_create(mem_ctx, &state,
10188                                 struct rpccli_lsa_CREDRGETSESSIONTYPES_state);
10189         if (req == NULL) {
10190                 return NULL;
10191         }
10192         state->out_mem_ctx = NULL;
10193         state->dispatch_recv = cli->dispatch_recv;
10194
10195         /* In parameters */
10196
10197         /* Out parameters */
10198
10199         /* Result */
10200         ZERO_STRUCT(state->orig.out.result);
10201
10202         /* make a temporary copy, that we pass to the dispatch function */
10203         state->tmp = state->orig;
10204
10205         subreq = cli->dispatch_send(state, ev, cli,
10206                                     &ndr_table_lsarpc,
10207                                     NDR_LSA_CREDRGETSESSIONTYPES,
10208                                     &state->tmp);
10209         if (tevent_req_nomem(subreq, req)) {
10210                 return tevent_req_post(req, ev);
10211         }
10212         tevent_req_set_callback(subreq, rpccli_lsa_CREDRGETSESSIONTYPES_done, req);
10213         return req;
10214 }
10215
10216 static void rpccli_lsa_CREDRGETSESSIONTYPES_done(struct tevent_req *subreq)
10217 {
10218         struct tevent_req *req = tevent_req_callback_data(
10219                 subreq, struct tevent_req);
10220         struct rpccli_lsa_CREDRGETSESSIONTYPES_state *state = tevent_req_data(
10221                 req, struct rpccli_lsa_CREDRGETSESSIONTYPES_state);
10222         NTSTATUS status;
10223         TALLOC_CTX *mem_ctx;
10224
10225         if (state->out_mem_ctx) {
10226                 mem_ctx = state->out_mem_ctx;
10227         } else {
10228                 mem_ctx = state;
10229         }
10230
10231         status = state->dispatch_recv(subreq, mem_ctx);
10232         TALLOC_FREE(subreq);
10233         if (!NT_STATUS_IS_OK(status)) {
10234                 tevent_req_nterror(req, status);
10235                 return;
10236         }
10237
10238         /* Copy out parameters */
10239
10240         /* Copy result */
10241         state->orig.out.result = state->tmp.out.result;
10242
10243         /* Reset temporary structure */
10244         ZERO_STRUCT(state->tmp);
10245
10246         tevent_req_done(req);
10247 }
10248
10249 NTSTATUS rpccli_lsa_CREDRGETSESSIONTYPES_recv(struct tevent_req *req,
10250                                               TALLOC_CTX *mem_ctx,
10251                                               NTSTATUS *result)
10252 {
10253         struct rpccli_lsa_CREDRGETSESSIONTYPES_state *state = tevent_req_data(
10254                 req, struct rpccli_lsa_CREDRGETSESSIONTYPES_state);
10255         NTSTATUS status;
10256
10257         if (tevent_req_is_nterror(req, &status)) {
10258                 tevent_req_received(req);
10259                 return status;
10260         }
10261
10262         /* Steal possbile out parameters to the callers context */
10263         talloc_steal(mem_ctx, state->out_mem_ctx);
10264
10265         /* Return result */
10266         *result = state->orig.out.result;
10267
10268         tevent_req_received(req);
10269         return NT_STATUS_OK;
10270 }
10271
10272 NTSTATUS rpccli_lsa_CREDRGETSESSIONTYPES(struct rpc_pipe_client *cli,
10273                                          TALLOC_CTX *mem_ctx)
10274 {
10275         struct lsa_CREDRGETSESSIONTYPES r;
10276         NTSTATUS status;
10277
10278         /* In parameters */
10279
10280         status = cli->dispatch(cli,
10281                                 mem_ctx,
10282                                 &ndr_table_lsarpc,
10283                                 NDR_LSA_CREDRGETSESSIONTYPES,
10284                                 &r);
10285
10286         if (!NT_STATUS_IS_OK(status)) {
10287                 return status;
10288         }
10289
10290         if (NT_STATUS_IS_ERR(status)) {
10291                 return status;
10292         }
10293
10294         /* Return variables */
10295
10296         /* Return result */
10297         return r.out.result;
10298 }
10299
10300 struct rpccli_lsa_LSARREGISTERAUDITEVENT_state {
10301         struct lsa_LSARREGISTERAUDITEVENT orig;
10302         struct lsa_LSARREGISTERAUDITEVENT tmp;
10303         TALLOC_CTX *out_mem_ctx;
10304         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10305 };
10306
10307 static void rpccli_lsa_LSARREGISTERAUDITEVENT_done(struct tevent_req *subreq);
10308
10309 struct tevent_req *rpccli_lsa_LSARREGISTERAUDITEVENT_send(TALLOC_CTX *mem_ctx,
10310                                                           struct tevent_context *ev,
10311                                                           struct rpc_pipe_client *cli)
10312 {
10313         struct tevent_req *req;
10314         struct rpccli_lsa_LSARREGISTERAUDITEVENT_state *state;
10315         struct tevent_req *subreq;
10316
10317         req = tevent_req_create(mem_ctx, &state,
10318                                 struct rpccli_lsa_LSARREGISTERAUDITEVENT_state);
10319         if (req == NULL) {
10320                 return NULL;
10321         }
10322         state->out_mem_ctx = NULL;
10323         state->dispatch_recv = cli->dispatch_recv;
10324
10325         /* In parameters */
10326
10327         /* Out parameters */
10328
10329         /* Result */
10330         ZERO_STRUCT(state->orig.out.result);
10331
10332         /* make a temporary copy, that we pass to the dispatch function */
10333         state->tmp = state->orig;
10334
10335         subreq = cli->dispatch_send(state, ev, cli,
10336                                     &ndr_table_lsarpc,
10337                                     NDR_LSA_LSARREGISTERAUDITEVENT,
10338                                     &state->tmp);
10339         if (tevent_req_nomem(subreq, req)) {
10340                 return tevent_req_post(req, ev);
10341         }
10342         tevent_req_set_callback(subreq, rpccli_lsa_LSARREGISTERAUDITEVENT_done, req);
10343         return req;
10344 }
10345
10346 static void rpccli_lsa_LSARREGISTERAUDITEVENT_done(struct tevent_req *subreq)
10347 {
10348         struct tevent_req *req = tevent_req_callback_data(
10349                 subreq, struct tevent_req);
10350         struct rpccli_lsa_LSARREGISTERAUDITEVENT_state *state = tevent_req_data(
10351                 req, struct rpccli_lsa_LSARREGISTERAUDITEVENT_state);
10352         NTSTATUS status;
10353         TALLOC_CTX *mem_ctx;
10354
10355         if (state->out_mem_ctx) {
10356                 mem_ctx = state->out_mem_ctx;
10357         } else {
10358                 mem_ctx = state;
10359         }
10360
10361         status = state->dispatch_recv(subreq, mem_ctx);
10362         TALLOC_FREE(subreq);
10363         if (!NT_STATUS_IS_OK(status)) {
10364                 tevent_req_nterror(req, status);
10365                 return;
10366         }
10367
10368         /* Copy out parameters */
10369
10370         /* Copy result */
10371         state->orig.out.result = state->tmp.out.result;
10372
10373         /* Reset temporary structure */
10374         ZERO_STRUCT(state->tmp);
10375
10376         tevent_req_done(req);
10377 }
10378
10379 NTSTATUS rpccli_lsa_LSARREGISTERAUDITEVENT_recv(struct tevent_req *req,
10380                                                 TALLOC_CTX *mem_ctx,
10381                                                 NTSTATUS *result)
10382 {
10383         struct rpccli_lsa_LSARREGISTERAUDITEVENT_state *state = tevent_req_data(
10384                 req, struct rpccli_lsa_LSARREGISTERAUDITEVENT_state);
10385         NTSTATUS status;
10386
10387         if (tevent_req_is_nterror(req, &status)) {
10388                 tevent_req_received(req);
10389                 return status;
10390         }
10391
10392         /* Steal possbile out parameters to the callers context */
10393         talloc_steal(mem_ctx, state->out_mem_ctx);
10394
10395         /* Return result */
10396         *result = state->orig.out.result;
10397
10398         tevent_req_received(req);
10399         return NT_STATUS_OK;
10400 }
10401
10402 NTSTATUS rpccli_lsa_LSARREGISTERAUDITEVENT(struct rpc_pipe_client *cli,
10403                                            TALLOC_CTX *mem_ctx)
10404 {
10405         struct lsa_LSARREGISTERAUDITEVENT r;
10406         NTSTATUS status;
10407
10408         /* In parameters */
10409
10410         status = cli->dispatch(cli,
10411                                 mem_ctx,
10412                                 &ndr_table_lsarpc,
10413                                 NDR_LSA_LSARREGISTERAUDITEVENT,
10414                                 &r);
10415
10416         if (!NT_STATUS_IS_OK(status)) {
10417                 return status;
10418         }
10419
10420         if (NT_STATUS_IS_ERR(status)) {
10421                 return status;
10422         }
10423
10424         /* Return variables */
10425
10426         /* Return result */
10427         return r.out.result;
10428 }
10429
10430 struct rpccli_lsa_LSARGENAUDITEVENT_state {
10431         struct lsa_LSARGENAUDITEVENT orig;
10432         struct lsa_LSARGENAUDITEVENT tmp;
10433         TALLOC_CTX *out_mem_ctx;
10434         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10435 };
10436
10437 static void rpccli_lsa_LSARGENAUDITEVENT_done(struct tevent_req *subreq);
10438
10439 struct tevent_req *rpccli_lsa_LSARGENAUDITEVENT_send(TALLOC_CTX *mem_ctx,
10440                                                      struct tevent_context *ev,
10441                                                      struct rpc_pipe_client *cli)
10442 {
10443         struct tevent_req *req;
10444         struct rpccli_lsa_LSARGENAUDITEVENT_state *state;
10445         struct tevent_req *subreq;
10446
10447         req = tevent_req_create(mem_ctx, &state,
10448                                 struct rpccli_lsa_LSARGENAUDITEVENT_state);
10449         if (req == NULL) {
10450                 return NULL;
10451         }
10452         state->out_mem_ctx = NULL;
10453         state->dispatch_recv = cli->dispatch_recv;
10454
10455         /* In parameters */
10456
10457         /* Out parameters */
10458
10459         /* Result */
10460         ZERO_STRUCT(state->orig.out.result);
10461
10462         /* make a temporary copy, that we pass to the dispatch function */
10463         state->tmp = state->orig;
10464
10465         subreq = cli->dispatch_send(state, ev, cli,
10466                                     &ndr_table_lsarpc,
10467                                     NDR_LSA_LSARGENAUDITEVENT,
10468                                     &state->tmp);
10469         if (tevent_req_nomem(subreq, req)) {
10470                 return tevent_req_post(req, ev);
10471         }
10472         tevent_req_set_callback(subreq, rpccli_lsa_LSARGENAUDITEVENT_done, req);
10473         return req;
10474 }
10475
10476 static void rpccli_lsa_LSARGENAUDITEVENT_done(struct tevent_req *subreq)
10477 {
10478         struct tevent_req *req = tevent_req_callback_data(
10479                 subreq, struct tevent_req);
10480         struct rpccli_lsa_LSARGENAUDITEVENT_state *state = tevent_req_data(
10481                 req, struct rpccli_lsa_LSARGENAUDITEVENT_state);
10482         NTSTATUS status;
10483         TALLOC_CTX *mem_ctx;
10484
10485         if (state->out_mem_ctx) {
10486                 mem_ctx = state->out_mem_ctx;
10487         } else {
10488                 mem_ctx = state;
10489         }
10490
10491         status = state->dispatch_recv(subreq, mem_ctx);
10492         TALLOC_FREE(subreq);
10493         if (!NT_STATUS_IS_OK(status)) {
10494                 tevent_req_nterror(req, status);
10495                 return;
10496         }
10497
10498         /* Copy out parameters */
10499
10500         /* Copy result */
10501         state->orig.out.result = state->tmp.out.result;
10502
10503         /* Reset temporary structure */
10504         ZERO_STRUCT(state->tmp);
10505
10506         tevent_req_done(req);
10507 }
10508
10509 NTSTATUS rpccli_lsa_LSARGENAUDITEVENT_recv(struct tevent_req *req,
10510                                            TALLOC_CTX *mem_ctx,
10511                                            NTSTATUS *result)
10512 {
10513         struct rpccli_lsa_LSARGENAUDITEVENT_state *state = tevent_req_data(
10514                 req, struct rpccli_lsa_LSARGENAUDITEVENT_state);
10515         NTSTATUS status;
10516
10517         if (tevent_req_is_nterror(req, &status)) {
10518                 tevent_req_received(req);
10519                 return status;
10520         }
10521
10522         /* Steal possbile out parameters to the callers context */
10523         talloc_steal(mem_ctx, state->out_mem_ctx);
10524
10525         /* Return result */
10526         *result = state->orig.out.result;
10527
10528         tevent_req_received(req);
10529         return NT_STATUS_OK;
10530 }
10531
10532 NTSTATUS rpccli_lsa_LSARGENAUDITEVENT(struct rpc_pipe_client *cli,
10533                                       TALLOC_CTX *mem_ctx)
10534 {
10535         struct lsa_LSARGENAUDITEVENT r;
10536         NTSTATUS status;
10537
10538         /* In parameters */
10539
10540         status = cli->dispatch(cli,
10541                                 mem_ctx,
10542                                 &ndr_table_lsarpc,
10543                                 NDR_LSA_LSARGENAUDITEVENT,
10544                                 &r);
10545
10546         if (!NT_STATUS_IS_OK(status)) {
10547                 return status;
10548         }
10549
10550         if (NT_STATUS_IS_ERR(status)) {
10551                 return status;
10552         }
10553
10554         /* Return variables */
10555
10556         /* Return result */
10557         return r.out.result;
10558 }
10559
10560 struct rpccli_lsa_LSARUNREGISTERAUDITEVENT_state {
10561         struct lsa_LSARUNREGISTERAUDITEVENT orig;
10562         struct lsa_LSARUNREGISTERAUDITEVENT tmp;
10563         TALLOC_CTX *out_mem_ctx;
10564         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10565 };
10566
10567 static void rpccli_lsa_LSARUNREGISTERAUDITEVENT_done(struct tevent_req *subreq);
10568
10569 struct tevent_req *rpccli_lsa_LSARUNREGISTERAUDITEVENT_send(TALLOC_CTX *mem_ctx,
10570                                                             struct tevent_context *ev,
10571                                                             struct rpc_pipe_client *cli)
10572 {
10573         struct tevent_req *req;
10574         struct rpccli_lsa_LSARUNREGISTERAUDITEVENT_state *state;
10575         struct tevent_req *subreq;
10576
10577         req = tevent_req_create(mem_ctx, &state,
10578                                 struct rpccli_lsa_LSARUNREGISTERAUDITEVENT_state);
10579         if (req == NULL) {
10580                 return NULL;
10581         }
10582         state->out_mem_ctx = NULL;
10583         state->dispatch_recv = cli->dispatch_recv;
10584
10585         /* In parameters */
10586
10587         /* Out parameters */
10588
10589         /* Result */
10590         ZERO_STRUCT(state->orig.out.result);
10591
10592         /* make a temporary copy, that we pass to the dispatch function */
10593         state->tmp = state->orig;
10594
10595         subreq = cli->dispatch_send(state, ev, cli,
10596                                     &ndr_table_lsarpc,
10597                                     NDR_LSA_LSARUNREGISTERAUDITEVENT,
10598                                     &state->tmp);
10599         if (tevent_req_nomem(subreq, req)) {
10600                 return tevent_req_post(req, ev);
10601         }
10602         tevent_req_set_callback(subreq, rpccli_lsa_LSARUNREGISTERAUDITEVENT_done, req);
10603         return req;
10604 }
10605
10606 static void rpccli_lsa_LSARUNREGISTERAUDITEVENT_done(struct tevent_req *subreq)
10607 {
10608         struct tevent_req *req = tevent_req_callback_data(
10609                 subreq, struct tevent_req);
10610         struct rpccli_lsa_LSARUNREGISTERAUDITEVENT_state *state = tevent_req_data(
10611                 req, struct rpccli_lsa_LSARUNREGISTERAUDITEVENT_state);
10612         NTSTATUS status;
10613         TALLOC_CTX *mem_ctx;
10614
10615         if (state->out_mem_ctx) {
10616                 mem_ctx = state->out_mem_ctx;
10617         } else {
10618                 mem_ctx = state;
10619         }
10620
10621         status = state->dispatch_recv(subreq, mem_ctx);
10622         TALLOC_FREE(subreq);
10623         if (!NT_STATUS_IS_OK(status)) {
10624                 tevent_req_nterror(req, status);
10625                 return;
10626         }
10627
10628         /* Copy out parameters */
10629
10630         /* Copy result */
10631         state->orig.out.result = state->tmp.out.result;
10632
10633         /* Reset temporary structure */
10634         ZERO_STRUCT(state->tmp);
10635
10636         tevent_req_done(req);
10637 }
10638
10639 NTSTATUS rpccli_lsa_LSARUNREGISTERAUDITEVENT_recv(struct tevent_req *req,
10640                                                   TALLOC_CTX *mem_ctx,
10641                                                   NTSTATUS *result)
10642 {
10643         struct rpccli_lsa_LSARUNREGISTERAUDITEVENT_state *state = tevent_req_data(
10644                 req, struct rpccli_lsa_LSARUNREGISTERAUDITEVENT_state);
10645         NTSTATUS status;
10646
10647         if (tevent_req_is_nterror(req, &status)) {
10648                 tevent_req_received(req);
10649                 return status;
10650         }
10651
10652         /* Steal possbile out parameters to the callers context */
10653         talloc_steal(mem_ctx, state->out_mem_ctx);
10654
10655         /* Return result */
10656         *result = state->orig.out.result;
10657
10658         tevent_req_received(req);
10659         return NT_STATUS_OK;
10660 }
10661
10662 NTSTATUS rpccli_lsa_LSARUNREGISTERAUDITEVENT(struct rpc_pipe_client *cli,
10663                                              TALLOC_CTX *mem_ctx)
10664 {
10665         struct lsa_LSARUNREGISTERAUDITEVENT r;
10666         NTSTATUS status;
10667
10668         /* In parameters */
10669
10670         status = cli->dispatch(cli,
10671                                 mem_ctx,
10672                                 &ndr_table_lsarpc,
10673                                 NDR_LSA_LSARUNREGISTERAUDITEVENT,
10674                                 &r);
10675
10676         if (!NT_STATUS_IS_OK(status)) {
10677                 return status;
10678         }
10679
10680         if (NT_STATUS_IS_ERR(status)) {
10681                 return status;
10682         }
10683
10684         /* Return variables */
10685
10686         /* Return result */
10687         return r.out.result;
10688 }
10689
10690 struct rpccli_lsa_lsaRQueryForestTrustInformation_state {
10691         struct lsa_lsaRQueryForestTrustInformation orig;
10692         struct lsa_lsaRQueryForestTrustInformation tmp;
10693         TALLOC_CTX *out_mem_ctx;
10694         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10695 };
10696
10697 static void rpccli_lsa_lsaRQueryForestTrustInformation_done(struct tevent_req *subreq);
10698
10699 struct tevent_req *rpccli_lsa_lsaRQueryForestTrustInformation_send(TALLOC_CTX *mem_ctx,
10700                                                                    struct tevent_context *ev,
10701                                                                    struct rpc_pipe_client *cli,
10702                                                                    struct policy_handle *_handle /* [in] [ref] */,
10703                                                                    struct lsa_String *_trusted_domain_name /* [in] [ref] */,
10704                                                                    uint16_t _unknown /* [in]  */,
10705                                                                    struct lsa_ForestTrustInformation **_forest_trust_info /* [out] [ref] */)
10706 {
10707         struct tevent_req *req;
10708         struct rpccli_lsa_lsaRQueryForestTrustInformation_state *state;
10709         struct tevent_req *subreq;
10710
10711         req = tevent_req_create(mem_ctx, &state,
10712                                 struct rpccli_lsa_lsaRQueryForestTrustInformation_state);
10713         if (req == NULL) {
10714                 return NULL;
10715         }
10716         state->out_mem_ctx = NULL;
10717         state->dispatch_recv = cli->dispatch_recv;
10718
10719         /* In parameters */
10720         state->orig.in.handle = _handle;
10721         state->orig.in.trusted_domain_name = _trusted_domain_name;
10722         state->orig.in.unknown = _unknown;
10723
10724         /* Out parameters */
10725         state->orig.out.forest_trust_info = _forest_trust_info;
10726
10727         /* Result */
10728         ZERO_STRUCT(state->orig.out.result);
10729
10730         state->out_mem_ctx = talloc_named_const(state, 0,
10731                              "rpccli_lsa_lsaRQueryForestTrustInformation_out_memory");
10732         if (tevent_req_nomem(state->out_mem_ctx, req)) {
10733                 return tevent_req_post(req, ev);
10734         }
10735
10736         /* make a temporary copy, that we pass to the dispatch function */
10737         state->tmp = state->orig;
10738
10739         subreq = cli->dispatch_send(state, ev, cli,
10740                                     &ndr_table_lsarpc,
10741                                     NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION,
10742                                     &state->tmp);
10743         if (tevent_req_nomem(subreq, req)) {
10744                 return tevent_req_post(req, ev);
10745         }
10746         tevent_req_set_callback(subreq, rpccli_lsa_lsaRQueryForestTrustInformation_done, req);
10747         return req;
10748 }
10749
10750 static void rpccli_lsa_lsaRQueryForestTrustInformation_done(struct tevent_req *subreq)
10751 {
10752         struct tevent_req *req = tevent_req_callback_data(
10753                 subreq, struct tevent_req);
10754         struct rpccli_lsa_lsaRQueryForestTrustInformation_state *state = tevent_req_data(
10755                 req, struct rpccli_lsa_lsaRQueryForestTrustInformation_state);
10756         NTSTATUS status;
10757         TALLOC_CTX *mem_ctx;
10758
10759         if (state->out_mem_ctx) {
10760                 mem_ctx = state->out_mem_ctx;
10761         } else {
10762                 mem_ctx = state;
10763         }
10764
10765         status = state->dispatch_recv(subreq, mem_ctx);
10766         TALLOC_FREE(subreq);
10767         if (!NT_STATUS_IS_OK(status)) {
10768                 tevent_req_nterror(req, status);
10769                 return;
10770         }
10771
10772         /* Copy out parameters */
10773         *state->orig.out.forest_trust_info = *state->tmp.out.forest_trust_info;
10774
10775         /* Copy result */
10776         state->orig.out.result = state->tmp.out.result;
10777
10778         /* Reset temporary structure */
10779         ZERO_STRUCT(state->tmp);
10780
10781         tevent_req_done(req);
10782 }
10783
10784 NTSTATUS rpccli_lsa_lsaRQueryForestTrustInformation_recv(struct tevent_req *req,
10785                                                          TALLOC_CTX *mem_ctx,
10786                                                          NTSTATUS *result)
10787 {
10788         struct rpccli_lsa_lsaRQueryForestTrustInformation_state *state = tevent_req_data(
10789                 req, struct rpccli_lsa_lsaRQueryForestTrustInformation_state);
10790         NTSTATUS status;
10791
10792         if (tevent_req_is_nterror(req, &status)) {
10793                 tevent_req_received(req);
10794                 return status;
10795         }
10796
10797         /* Steal possbile out parameters to the callers context */
10798         talloc_steal(mem_ctx, state->out_mem_ctx);
10799
10800         /* Return result */
10801         *result = state->orig.out.result;
10802
10803         tevent_req_received(req);
10804         return NT_STATUS_OK;
10805 }
10806
10807 NTSTATUS rpccli_lsa_lsaRQueryForestTrustInformation(struct rpc_pipe_client *cli,
10808                                                     TALLOC_CTX *mem_ctx,
10809                                                     struct policy_handle *handle /* [in] [ref] */,
10810                                                     struct lsa_String *trusted_domain_name /* [in] [ref] */,
10811                                                     uint16_t unknown /* [in]  */,
10812                                                     struct lsa_ForestTrustInformation **forest_trust_info /* [out] [ref] */)
10813 {
10814         struct lsa_lsaRQueryForestTrustInformation r;
10815         NTSTATUS status;
10816
10817         /* In parameters */
10818         r.in.handle = handle;
10819         r.in.trusted_domain_name = trusted_domain_name;
10820         r.in.unknown = unknown;
10821
10822         status = cli->dispatch(cli,
10823                                 mem_ctx,
10824                                 &ndr_table_lsarpc,
10825                                 NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION,
10826                                 &r);
10827
10828         if (!NT_STATUS_IS_OK(status)) {
10829                 return status;
10830         }
10831
10832         if (NT_STATUS_IS_ERR(status)) {
10833                 return status;
10834         }
10835
10836         /* Return variables */
10837         *forest_trust_info = *r.out.forest_trust_info;
10838
10839         /* Return result */
10840         return r.out.result;
10841 }
10842
10843 struct rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_state {
10844         struct lsa_LSARSETFORESTTRUSTINFORMATION orig;
10845         struct lsa_LSARSETFORESTTRUSTINFORMATION tmp;
10846         TALLOC_CTX *out_mem_ctx;
10847         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10848 };
10849
10850 static void rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_done(struct tevent_req *subreq);
10851
10852 struct tevent_req *rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_send(TALLOC_CTX *mem_ctx,
10853                                                                  struct tevent_context *ev,
10854                                                                  struct rpc_pipe_client *cli)
10855 {
10856         struct tevent_req *req;
10857         struct rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_state *state;
10858         struct tevent_req *subreq;
10859
10860         req = tevent_req_create(mem_ctx, &state,
10861                                 struct rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_state);
10862         if (req == NULL) {
10863                 return NULL;
10864         }
10865         state->out_mem_ctx = NULL;
10866         state->dispatch_recv = cli->dispatch_recv;
10867
10868         /* In parameters */
10869
10870         /* Out parameters */
10871
10872         /* Result */
10873         ZERO_STRUCT(state->orig.out.result);
10874
10875         /* make a temporary copy, that we pass to the dispatch function */
10876         state->tmp = state->orig;
10877
10878         subreq = cli->dispatch_send(state, ev, cli,
10879                                     &ndr_table_lsarpc,
10880                                     NDR_LSA_LSARSETFORESTTRUSTINFORMATION,
10881                                     &state->tmp);
10882         if (tevent_req_nomem(subreq, req)) {
10883                 return tevent_req_post(req, ev);
10884         }
10885         tevent_req_set_callback(subreq, rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_done, req);
10886         return req;
10887 }
10888
10889 static void rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_done(struct tevent_req *subreq)
10890 {
10891         struct tevent_req *req = tevent_req_callback_data(
10892                 subreq, struct tevent_req);
10893         struct rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_state *state = tevent_req_data(
10894                 req, struct rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_state);
10895         NTSTATUS status;
10896         TALLOC_CTX *mem_ctx;
10897
10898         if (state->out_mem_ctx) {
10899                 mem_ctx = state->out_mem_ctx;
10900         } else {
10901                 mem_ctx = state;
10902         }
10903
10904         status = state->dispatch_recv(subreq, mem_ctx);
10905         TALLOC_FREE(subreq);
10906         if (!NT_STATUS_IS_OK(status)) {
10907                 tevent_req_nterror(req, status);
10908                 return;
10909         }
10910
10911         /* Copy out parameters */
10912
10913         /* Copy result */
10914         state->orig.out.result = state->tmp.out.result;
10915
10916         /* Reset temporary structure */
10917         ZERO_STRUCT(state->tmp);
10918
10919         tevent_req_done(req);
10920 }
10921
10922 NTSTATUS rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_recv(struct tevent_req *req,
10923                                                        TALLOC_CTX *mem_ctx,
10924                                                        NTSTATUS *result)
10925 {
10926         struct rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_state *state = tevent_req_data(
10927                 req, struct rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_state);
10928         NTSTATUS status;
10929
10930         if (tevent_req_is_nterror(req, &status)) {
10931                 tevent_req_received(req);
10932                 return status;
10933         }
10934
10935         /* Steal possbile out parameters to the callers context */
10936         talloc_steal(mem_ctx, state->out_mem_ctx);
10937
10938         /* Return result */
10939         *result = state->orig.out.result;
10940
10941         tevent_req_received(req);
10942         return NT_STATUS_OK;
10943 }
10944
10945 NTSTATUS rpccli_lsa_LSARSETFORESTTRUSTINFORMATION(struct rpc_pipe_client *cli,
10946                                                   TALLOC_CTX *mem_ctx)
10947 {
10948         struct lsa_LSARSETFORESTTRUSTINFORMATION r;
10949         NTSTATUS status;
10950
10951         /* In parameters */
10952
10953         status = cli->dispatch(cli,
10954                                 mem_ctx,
10955                                 &ndr_table_lsarpc,
10956                                 NDR_LSA_LSARSETFORESTTRUSTINFORMATION,
10957                                 &r);
10958
10959         if (!NT_STATUS_IS_OK(status)) {
10960                 return status;
10961         }
10962
10963         if (NT_STATUS_IS_ERR(status)) {
10964                 return status;
10965         }
10966
10967         /* Return variables */
10968
10969         /* Return result */
10970         return r.out.result;
10971 }
10972
10973 struct rpccli_lsa_CREDRRENAME_state {
10974         struct lsa_CREDRRENAME orig;
10975         struct lsa_CREDRRENAME tmp;
10976         TALLOC_CTX *out_mem_ctx;
10977         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10978 };
10979
10980 static void rpccli_lsa_CREDRRENAME_done(struct tevent_req *subreq);
10981
10982 struct tevent_req *rpccli_lsa_CREDRRENAME_send(TALLOC_CTX *mem_ctx,
10983                                                struct tevent_context *ev,
10984                                                struct rpc_pipe_client *cli)
10985 {
10986         struct tevent_req *req;
10987         struct rpccli_lsa_CREDRRENAME_state *state;
10988         struct tevent_req *subreq;
10989
10990         req = tevent_req_create(mem_ctx, &state,
10991                                 struct rpccli_lsa_CREDRRENAME_state);
10992         if (req == NULL) {
10993                 return NULL;
10994         }
10995         state->out_mem_ctx = NULL;
10996         state->dispatch_recv = cli->dispatch_recv;
10997
10998         /* In parameters */
10999
11000         /* Out parameters */
11001
11002         /* Result */
11003         ZERO_STRUCT(state->orig.out.result);
11004
11005         /* make a temporary copy, that we pass to the dispatch function */
11006         state->tmp = state->orig;
11007
11008         subreq = cli->dispatch_send(state, ev, cli,
11009                                     &ndr_table_lsarpc,
11010                                     NDR_LSA_CREDRRENAME,
11011                                     &state->tmp);
11012         if (tevent_req_nomem(subreq, req)) {
11013                 return tevent_req_post(req, ev);
11014         }
11015         tevent_req_set_callback(subreq, rpccli_lsa_CREDRRENAME_done, req);
11016         return req;
11017 }
11018
11019 static void rpccli_lsa_CREDRRENAME_done(struct tevent_req *subreq)
11020 {
11021         struct tevent_req *req = tevent_req_callback_data(
11022                 subreq, struct tevent_req);
11023         struct rpccli_lsa_CREDRRENAME_state *state = tevent_req_data(
11024                 req, struct rpccli_lsa_CREDRRENAME_state);
11025         NTSTATUS status;
11026         TALLOC_CTX *mem_ctx;
11027
11028         if (state->out_mem_ctx) {
11029                 mem_ctx = state->out_mem_ctx;
11030         } else {
11031                 mem_ctx = state;
11032         }
11033
11034         status = state->dispatch_recv(subreq, mem_ctx);
11035         TALLOC_FREE(subreq);
11036         if (!NT_STATUS_IS_OK(status)) {
11037                 tevent_req_nterror(req, status);
11038                 return;
11039         }
11040
11041         /* Copy out parameters */
11042
11043         /* Copy result */
11044         state->orig.out.result = state->tmp.out.result;
11045
11046         /* Reset temporary structure */
11047         ZERO_STRUCT(state->tmp);
11048
11049         tevent_req_done(req);
11050 }
11051
11052 NTSTATUS rpccli_lsa_CREDRRENAME_recv(struct tevent_req *req,
11053                                      TALLOC_CTX *mem_ctx,
11054                                      NTSTATUS *result)
11055 {
11056         struct rpccli_lsa_CREDRRENAME_state *state = tevent_req_data(
11057                 req, struct rpccli_lsa_CREDRRENAME_state);
11058         NTSTATUS status;
11059
11060         if (tevent_req_is_nterror(req, &status)) {
11061                 tevent_req_received(req);
11062                 return status;
11063         }
11064
11065         /* Steal possbile out parameters to the callers context */
11066         talloc_steal(mem_ctx, state->out_mem_ctx);
11067
11068         /* Return result */
11069         *result = state->orig.out.result;
11070
11071         tevent_req_received(req);
11072         return NT_STATUS_OK;
11073 }
11074
11075 NTSTATUS rpccli_lsa_CREDRRENAME(struct rpc_pipe_client *cli,
11076                                 TALLOC_CTX *mem_ctx)
11077 {
11078         struct lsa_CREDRRENAME r;
11079         NTSTATUS status;
11080
11081         /* In parameters */
11082
11083         status = cli->dispatch(cli,
11084                                 mem_ctx,
11085                                 &ndr_table_lsarpc,
11086                                 NDR_LSA_CREDRRENAME,
11087                                 &r);
11088
11089         if (!NT_STATUS_IS_OK(status)) {
11090                 return status;
11091         }
11092
11093         if (NT_STATUS_IS_ERR(status)) {
11094                 return status;
11095         }
11096
11097         /* Return variables */
11098
11099         /* Return result */
11100         return r.out.result;
11101 }
11102
11103 struct rpccli_lsa_LookupSids3_state {
11104         struct lsa_LookupSids3 orig;
11105         struct lsa_LookupSids3 tmp;
11106         TALLOC_CTX *out_mem_ctx;
11107         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11108 };
11109
11110 static void rpccli_lsa_LookupSids3_done(struct tevent_req *subreq);
11111
11112 struct tevent_req *rpccli_lsa_LookupSids3_send(TALLOC_CTX *mem_ctx,
11113                                                struct tevent_context *ev,
11114                                                struct rpc_pipe_client *cli,
11115                                                struct lsa_SidArray *_sids /* [in] [ref] */,
11116                                                struct lsa_RefDomainList **_domains /* [out] [ref] */,
11117                                                struct lsa_TransNameArray2 *_names /* [in,out] [ref] */,
11118                                                enum lsa_LookupNamesLevel _level /* [in]  */,
11119                                                uint32_t *_count /* [in,out] [ref] */,
11120                                                enum lsa_LookupOptions _lookup_options /* [in]  */,
11121                                                enum lsa_ClientRevision _client_revision /* [in]  */)
11122 {
11123         struct tevent_req *req;
11124         struct rpccli_lsa_LookupSids3_state *state;
11125         struct tevent_req *subreq;
11126
11127         req = tevent_req_create(mem_ctx, &state,
11128                                 struct rpccli_lsa_LookupSids3_state);
11129         if (req == NULL) {
11130                 return NULL;
11131         }
11132         state->out_mem_ctx = NULL;
11133         state->dispatch_recv = cli->dispatch_recv;
11134
11135         /* In parameters */
11136         state->orig.in.sids = _sids;
11137         state->orig.in.names = _names;
11138         state->orig.in.level = _level;
11139         state->orig.in.count = _count;
11140         state->orig.in.lookup_options = _lookup_options;
11141         state->orig.in.client_revision = _client_revision;
11142
11143         /* Out parameters */
11144         state->orig.out.domains = _domains;
11145         state->orig.out.names = _names;
11146         state->orig.out.count = _count;
11147
11148         /* Result */
11149         ZERO_STRUCT(state->orig.out.result);
11150
11151         state->out_mem_ctx = talloc_named_const(state, 0,
11152                              "rpccli_lsa_LookupSids3_out_memory");
11153         if (tevent_req_nomem(state->out_mem_ctx, req)) {
11154                 return tevent_req_post(req, ev);
11155         }
11156
11157         /* make a temporary copy, that we pass to the dispatch function */
11158         state->tmp = state->orig;
11159
11160         subreq = cli->dispatch_send(state, ev, cli,
11161                                     &ndr_table_lsarpc,
11162                                     NDR_LSA_LOOKUPSIDS3,
11163                                     &state->tmp);
11164         if (tevent_req_nomem(subreq, req)) {
11165                 return tevent_req_post(req, ev);
11166         }
11167         tevent_req_set_callback(subreq, rpccli_lsa_LookupSids3_done, req);
11168         return req;
11169 }
11170
11171 static void rpccli_lsa_LookupSids3_done(struct tevent_req *subreq)
11172 {
11173         struct tevent_req *req = tevent_req_callback_data(
11174                 subreq, struct tevent_req);
11175         struct rpccli_lsa_LookupSids3_state *state = tevent_req_data(
11176                 req, struct rpccli_lsa_LookupSids3_state);
11177         NTSTATUS status;
11178         TALLOC_CTX *mem_ctx;
11179
11180         if (state->out_mem_ctx) {
11181                 mem_ctx = state->out_mem_ctx;
11182         } else {
11183                 mem_ctx = state;
11184         }
11185
11186         status = state->dispatch_recv(subreq, mem_ctx);
11187         TALLOC_FREE(subreq);
11188         if (!NT_STATUS_IS_OK(status)) {
11189                 tevent_req_nterror(req, status);
11190                 return;
11191         }
11192
11193         /* Copy out parameters */
11194         *state->orig.out.domains = *state->tmp.out.domains;
11195         *state->orig.out.names = *state->tmp.out.names;
11196         *state->orig.out.count = *state->tmp.out.count;
11197
11198         /* Copy result */
11199         state->orig.out.result = state->tmp.out.result;
11200
11201         /* Reset temporary structure */
11202         ZERO_STRUCT(state->tmp);
11203
11204         tevent_req_done(req);
11205 }
11206
11207 NTSTATUS rpccli_lsa_LookupSids3_recv(struct tevent_req *req,
11208                                      TALLOC_CTX *mem_ctx,
11209                                      NTSTATUS *result)
11210 {
11211         struct rpccli_lsa_LookupSids3_state *state = tevent_req_data(
11212                 req, struct rpccli_lsa_LookupSids3_state);
11213         NTSTATUS status;
11214
11215         if (tevent_req_is_nterror(req, &status)) {
11216                 tevent_req_received(req);
11217                 return status;
11218         }
11219
11220         /* Steal possbile out parameters to the callers context */
11221         talloc_steal(mem_ctx, state->out_mem_ctx);
11222
11223         /* Return result */
11224         *result = state->orig.out.result;
11225
11226         tevent_req_received(req);
11227         return NT_STATUS_OK;
11228 }
11229
11230 NTSTATUS rpccli_lsa_LookupSids3(struct rpc_pipe_client *cli,
11231                                 TALLOC_CTX *mem_ctx,
11232                                 struct lsa_SidArray *sids /* [in] [ref] */,
11233                                 struct lsa_RefDomainList **domains /* [out] [ref] */,
11234                                 struct lsa_TransNameArray2 *names /* [in,out] [ref] */,
11235                                 enum lsa_LookupNamesLevel level /* [in]  */,
11236                                 uint32_t *count /* [in,out] [ref] */,
11237                                 enum lsa_LookupOptions lookup_options /* [in]  */,
11238                                 enum lsa_ClientRevision client_revision /* [in]  */)
11239 {
11240         struct lsa_LookupSids3 r;
11241         NTSTATUS status;
11242
11243         /* In parameters */
11244         r.in.sids = sids;
11245         r.in.names = names;
11246         r.in.level = level;
11247         r.in.count = count;
11248         r.in.lookup_options = lookup_options;
11249         r.in.client_revision = client_revision;
11250
11251         status = cli->dispatch(cli,
11252                                 mem_ctx,
11253                                 &ndr_table_lsarpc,
11254                                 NDR_LSA_LOOKUPSIDS3,
11255                                 &r);
11256
11257         if (!NT_STATUS_IS_OK(status)) {
11258                 return status;
11259         }
11260
11261         if (NT_STATUS_IS_ERR(status)) {
11262                 return status;
11263         }
11264
11265         /* Return variables */
11266         *domains = *r.out.domains;
11267         *names = *r.out.names;
11268         *count = *r.out.count;
11269
11270         /* Return result */
11271         return r.out.result;
11272 }
11273
11274 struct rpccli_lsa_LookupNames4_state {
11275         struct lsa_LookupNames4 orig;
11276         struct lsa_LookupNames4 tmp;
11277         TALLOC_CTX *out_mem_ctx;
11278         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11279 };
11280
11281 static void rpccli_lsa_LookupNames4_done(struct tevent_req *subreq);
11282
11283 struct tevent_req *rpccli_lsa_LookupNames4_send(TALLOC_CTX *mem_ctx,
11284                                                 struct tevent_context *ev,
11285                                                 struct rpc_pipe_client *cli,
11286                                                 uint32_t _num_names /* [in] [range(0,1000)] */,
11287                                                 struct lsa_String *_names /* [in] [size_is(num_names)] */,
11288                                                 struct lsa_RefDomainList **_domains /* [out] [ref] */,
11289                                                 struct lsa_TransSidArray3 *_sids /* [in,out] [ref] */,
11290                                                 enum lsa_LookupNamesLevel _level /* [in]  */,
11291                                                 uint32_t *_count /* [in,out] [ref] */,
11292                                                 enum lsa_LookupOptions _lookup_options /* [in]  */,
11293                                                 enum lsa_ClientRevision _client_revision /* [in]  */)
11294 {
11295         struct tevent_req *req;
11296         struct rpccli_lsa_LookupNames4_state *state;
11297         struct tevent_req *subreq;
11298
11299         req = tevent_req_create(mem_ctx, &state,
11300                                 struct rpccli_lsa_LookupNames4_state);
11301         if (req == NULL) {
11302                 return NULL;
11303         }
11304         state->out_mem_ctx = NULL;
11305         state->dispatch_recv = cli->dispatch_recv;
11306
11307         /* In parameters */
11308         state->orig.in.num_names = _num_names;
11309         state->orig.in.names = _names;
11310         state->orig.in.sids = _sids;
11311         state->orig.in.level = _level;
11312         state->orig.in.count = _count;
11313         state->orig.in.lookup_options = _lookup_options;
11314         state->orig.in.client_revision = _client_revision;
11315
11316         /* Out parameters */
11317         state->orig.out.domains = _domains;
11318         state->orig.out.sids = _sids;
11319         state->orig.out.count = _count;
11320
11321         /* Result */
11322         ZERO_STRUCT(state->orig.out.result);
11323
11324         state->out_mem_ctx = talloc_named_const(state, 0,
11325                              "rpccli_lsa_LookupNames4_out_memory");
11326         if (tevent_req_nomem(state->out_mem_ctx, req)) {
11327                 return tevent_req_post(req, ev);
11328         }
11329
11330         /* make a temporary copy, that we pass to the dispatch function */
11331         state->tmp = state->orig;
11332
11333         subreq = cli->dispatch_send(state, ev, cli,
11334                                     &ndr_table_lsarpc,
11335                                     NDR_LSA_LOOKUPNAMES4,
11336                                     &state->tmp);
11337         if (tevent_req_nomem(subreq, req)) {
11338                 return tevent_req_post(req, ev);
11339         }
11340         tevent_req_set_callback(subreq, rpccli_lsa_LookupNames4_done, req);
11341         return req;
11342 }
11343
11344 static void rpccli_lsa_LookupNames4_done(struct tevent_req *subreq)
11345 {
11346         struct tevent_req *req = tevent_req_callback_data(
11347                 subreq, struct tevent_req);
11348         struct rpccli_lsa_LookupNames4_state *state = tevent_req_data(
11349                 req, struct rpccli_lsa_LookupNames4_state);
11350         NTSTATUS status;
11351         TALLOC_CTX *mem_ctx;
11352
11353         if (state->out_mem_ctx) {
11354                 mem_ctx = state->out_mem_ctx;
11355         } else {
11356                 mem_ctx = state;
11357         }
11358
11359         status = state->dispatch_recv(subreq, mem_ctx);
11360         TALLOC_FREE(subreq);
11361         if (!NT_STATUS_IS_OK(status)) {
11362                 tevent_req_nterror(req, status);
11363                 return;
11364         }
11365
11366         /* Copy out parameters */
11367         *state->orig.out.domains = *state->tmp.out.domains;
11368         *state->orig.out.sids = *state->tmp.out.sids;
11369         *state->orig.out.count = *state->tmp.out.count;
11370
11371         /* Copy result */
11372         state->orig.out.result = state->tmp.out.result;
11373
11374         /* Reset temporary structure */
11375         ZERO_STRUCT(state->tmp);
11376
11377         tevent_req_done(req);
11378 }
11379
11380 NTSTATUS rpccli_lsa_LookupNames4_recv(struct tevent_req *req,
11381                                       TALLOC_CTX *mem_ctx,
11382                                       NTSTATUS *result)
11383 {
11384         struct rpccli_lsa_LookupNames4_state *state = tevent_req_data(
11385                 req, struct rpccli_lsa_LookupNames4_state);
11386         NTSTATUS status;
11387
11388         if (tevent_req_is_nterror(req, &status)) {
11389                 tevent_req_received(req);
11390                 return status;
11391         }
11392
11393         /* Steal possbile out parameters to the callers context */
11394         talloc_steal(mem_ctx, state->out_mem_ctx);
11395
11396         /* Return result */
11397         *result = state->orig.out.result;
11398
11399         tevent_req_received(req);
11400         return NT_STATUS_OK;
11401 }
11402
11403 NTSTATUS rpccli_lsa_LookupNames4(struct rpc_pipe_client *cli,
11404                                  TALLOC_CTX *mem_ctx,
11405                                  uint32_t num_names /* [in] [range(0,1000)] */,
11406                                  struct lsa_String *names /* [in] [size_is(num_names)] */,
11407                                  struct lsa_RefDomainList **domains /* [out] [ref] */,
11408                                  struct lsa_TransSidArray3 *sids /* [in,out] [ref] */,
11409                                  enum lsa_LookupNamesLevel level /* [in]  */,
11410                                  uint32_t *count /* [in,out] [ref] */,
11411                                  enum lsa_LookupOptions lookup_options /* [in]  */,
11412                                  enum lsa_ClientRevision client_revision /* [in]  */)
11413 {
11414         struct lsa_LookupNames4 r;
11415         NTSTATUS status;
11416
11417         /* In parameters */
11418         r.in.num_names = num_names;
11419         r.in.names = names;
11420         r.in.sids = sids;
11421         r.in.level = level;
11422         r.in.count = count;
11423         r.in.lookup_options = lookup_options;
11424         r.in.client_revision = client_revision;
11425
11426         status = cli->dispatch(cli,
11427                                 mem_ctx,
11428                                 &ndr_table_lsarpc,
11429                                 NDR_LSA_LOOKUPNAMES4,
11430                                 &r);
11431
11432         if (!NT_STATUS_IS_OK(status)) {
11433                 return status;
11434         }
11435
11436         if (NT_STATUS_IS_ERR(status)) {
11437                 return status;
11438         }
11439
11440         /* Return variables */
11441         *domains = *r.out.domains;
11442         *sids = *r.out.sids;
11443         *count = *r.out.count;
11444
11445         /* Return result */
11446         return r.out.result;
11447 }
11448
11449 struct rpccli_lsa_LSAROPENPOLICYSCE_state {
11450         struct lsa_LSAROPENPOLICYSCE orig;
11451         struct lsa_LSAROPENPOLICYSCE tmp;
11452         TALLOC_CTX *out_mem_ctx;
11453         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11454 };
11455
11456 static void rpccli_lsa_LSAROPENPOLICYSCE_done(struct tevent_req *subreq);
11457
11458 struct tevent_req *rpccli_lsa_LSAROPENPOLICYSCE_send(TALLOC_CTX *mem_ctx,
11459                                                      struct tevent_context *ev,
11460                                                      struct rpc_pipe_client *cli)
11461 {
11462         struct tevent_req *req;
11463         struct rpccli_lsa_LSAROPENPOLICYSCE_state *state;
11464         struct tevent_req *subreq;
11465
11466         req = tevent_req_create(mem_ctx, &state,
11467                                 struct rpccli_lsa_LSAROPENPOLICYSCE_state);
11468         if (req == NULL) {
11469                 return NULL;
11470         }
11471         state->out_mem_ctx = NULL;
11472         state->dispatch_recv = cli->dispatch_recv;
11473
11474         /* In parameters */
11475
11476         /* Out parameters */
11477
11478         /* Result */
11479         ZERO_STRUCT(state->orig.out.result);
11480
11481         /* make a temporary copy, that we pass to the dispatch function */
11482         state->tmp = state->orig;
11483
11484         subreq = cli->dispatch_send(state, ev, cli,
11485                                     &ndr_table_lsarpc,
11486                                     NDR_LSA_LSAROPENPOLICYSCE,
11487                                     &state->tmp);
11488         if (tevent_req_nomem(subreq, req)) {
11489                 return tevent_req_post(req, ev);
11490         }
11491         tevent_req_set_callback(subreq, rpccli_lsa_LSAROPENPOLICYSCE_done, req);
11492         return req;
11493 }
11494
11495 static void rpccli_lsa_LSAROPENPOLICYSCE_done(struct tevent_req *subreq)
11496 {
11497         struct tevent_req *req = tevent_req_callback_data(
11498                 subreq, struct tevent_req);
11499         struct rpccli_lsa_LSAROPENPOLICYSCE_state *state = tevent_req_data(
11500                 req, struct rpccli_lsa_LSAROPENPOLICYSCE_state);
11501         NTSTATUS status;
11502         TALLOC_CTX *mem_ctx;
11503
11504         if (state->out_mem_ctx) {
11505                 mem_ctx = state->out_mem_ctx;
11506         } else {
11507                 mem_ctx = state;
11508         }
11509
11510         status = state->dispatch_recv(subreq, mem_ctx);
11511         TALLOC_FREE(subreq);
11512         if (!NT_STATUS_IS_OK(status)) {
11513                 tevent_req_nterror(req, status);
11514                 return;
11515         }
11516
11517         /* Copy out parameters */
11518
11519         /* Copy result */
11520         state->orig.out.result = state->tmp.out.result;
11521
11522         /* Reset temporary structure */
11523         ZERO_STRUCT(state->tmp);
11524
11525         tevent_req_done(req);
11526 }
11527
11528 NTSTATUS rpccli_lsa_LSAROPENPOLICYSCE_recv(struct tevent_req *req,
11529                                            TALLOC_CTX *mem_ctx,
11530                                            NTSTATUS *result)
11531 {
11532         struct rpccli_lsa_LSAROPENPOLICYSCE_state *state = tevent_req_data(
11533                 req, struct rpccli_lsa_LSAROPENPOLICYSCE_state);
11534         NTSTATUS status;
11535
11536         if (tevent_req_is_nterror(req, &status)) {
11537                 tevent_req_received(req);
11538                 return status;
11539         }
11540
11541         /* Steal possbile out parameters to the callers context */
11542         talloc_steal(mem_ctx, state->out_mem_ctx);
11543
11544         /* Return result */
11545         *result = state->orig.out.result;
11546
11547         tevent_req_received(req);
11548         return NT_STATUS_OK;
11549 }
11550
11551 NTSTATUS rpccli_lsa_LSAROPENPOLICYSCE(struct rpc_pipe_client *cli,
11552                                       TALLOC_CTX *mem_ctx)
11553 {
11554         struct lsa_LSAROPENPOLICYSCE r;
11555         NTSTATUS status;
11556
11557         /* In parameters */
11558
11559         status = cli->dispatch(cli,
11560                                 mem_ctx,
11561                                 &ndr_table_lsarpc,
11562                                 NDR_LSA_LSAROPENPOLICYSCE,
11563                                 &r);
11564
11565         if (!NT_STATUS_IS_OK(status)) {
11566                 return status;
11567         }
11568
11569         if (NT_STATUS_IS_ERR(status)) {
11570                 return status;
11571         }
11572
11573         /* Return variables */
11574
11575         /* Return result */
11576         return r.out.result;
11577 }
11578
11579 struct rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_state {
11580         struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE orig;
11581         struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE tmp;
11582         TALLOC_CTX *out_mem_ctx;
11583         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11584 };
11585
11586 static void rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_done(struct tevent_req *subreq);
11587
11588 struct tevent_req *rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_send(TALLOC_CTX *mem_ctx,
11589                                                                       struct tevent_context *ev,
11590                                                                       struct rpc_pipe_client *cli)
11591 {
11592         struct tevent_req *req;
11593         struct rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_state *state;
11594         struct tevent_req *subreq;
11595
11596         req = tevent_req_create(mem_ctx, &state,
11597                                 struct rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_state);
11598         if (req == NULL) {
11599                 return NULL;
11600         }
11601         state->out_mem_ctx = NULL;
11602         state->dispatch_recv = cli->dispatch_recv;
11603
11604         /* In parameters */
11605
11606         /* Out parameters */
11607
11608         /* Result */
11609         ZERO_STRUCT(state->orig.out.result);
11610
11611         /* make a temporary copy, that we pass to the dispatch function */
11612         state->tmp = state->orig;
11613
11614         subreq = cli->dispatch_send(state, ev, cli,
11615                                     &ndr_table_lsarpc,
11616                                     NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE,
11617                                     &state->tmp);
11618         if (tevent_req_nomem(subreq, req)) {
11619                 return tevent_req_post(req, ev);
11620         }
11621         tevent_req_set_callback(subreq, rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_done, req);
11622         return req;
11623 }
11624
11625 static void rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_done(struct tevent_req *subreq)
11626 {
11627         struct tevent_req *req = tevent_req_callback_data(
11628                 subreq, struct tevent_req);
11629         struct rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_state *state = tevent_req_data(
11630                 req, struct rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_state);
11631         NTSTATUS status;
11632         TALLOC_CTX *mem_ctx;
11633
11634         if (state->out_mem_ctx) {
11635                 mem_ctx = state->out_mem_ctx;
11636         } else {
11637                 mem_ctx = state;
11638         }
11639
11640         status = state->dispatch_recv(subreq, mem_ctx);
11641         TALLOC_FREE(subreq);
11642         if (!NT_STATUS_IS_OK(status)) {
11643                 tevent_req_nterror(req, status);
11644                 return;
11645         }
11646
11647         /* Copy out parameters */
11648
11649         /* Copy result */
11650         state->orig.out.result = state->tmp.out.result;
11651
11652         /* Reset temporary structure */
11653         ZERO_STRUCT(state->tmp);
11654
11655         tevent_req_done(req);
11656 }
11657
11658 NTSTATUS rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_recv(struct tevent_req *req,
11659                                                             TALLOC_CTX *mem_ctx,
11660                                                             NTSTATUS *result)
11661 {
11662         struct rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_state *state = tevent_req_data(
11663                 req, struct rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_state);
11664         NTSTATUS status;
11665
11666         if (tevent_req_is_nterror(req, &status)) {
11667                 tevent_req_received(req);
11668                 return status;
11669         }
11670
11671         /* Steal possbile out parameters to the callers context */
11672         talloc_steal(mem_ctx, state->out_mem_ctx);
11673
11674         /* Return result */
11675         *result = state->orig.out.result;
11676
11677         tevent_req_received(req);
11678         return NT_STATUS_OK;
11679 }
11680
11681 NTSTATUS rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct rpc_pipe_client *cli,
11682                                                        TALLOC_CTX *mem_ctx)
11683 {
11684         struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE r;
11685         NTSTATUS status;
11686
11687         /* In parameters */
11688
11689         status = cli->dispatch(cli,
11690                                 mem_ctx,
11691                                 &ndr_table_lsarpc,
11692                                 NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE,
11693                                 &r);
11694
11695         if (!NT_STATUS_IS_OK(status)) {
11696                 return status;
11697         }
11698
11699         if (NT_STATUS_IS_ERR(status)) {
11700                 return status;
11701         }
11702
11703         /* Return variables */
11704
11705         /* Return result */
11706         return r.out.result;
11707 }
11708
11709 struct rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_state {
11710         struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE orig;
11711         struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE tmp;
11712         TALLOC_CTX *out_mem_ctx;
11713         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11714 };
11715
11716 static void rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_done(struct tevent_req *subreq);
11717
11718 struct tevent_req *rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_send(TALLOC_CTX *mem_ctx,
11719                                                                         struct tevent_context *ev,
11720                                                                         struct rpc_pipe_client *cli)
11721 {
11722         struct tevent_req *req;
11723         struct rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_state *state;
11724         struct tevent_req *subreq;
11725
11726         req = tevent_req_create(mem_ctx, &state,
11727                                 struct rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_state);
11728         if (req == NULL) {
11729                 return NULL;
11730         }
11731         state->out_mem_ctx = NULL;
11732         state->dispatch_recv = cli->dispatch_recv;
11733
11734         /* In parameters */
11735
11736         /* Out parameters */
11737
11738         /* Result */
11739         ZERO_STRUCT(state->orig.out.result);
11740
11741         /* make a temporary copy, that we pass to the dispatch function */
11742         state->tmp = state->orig;
11743
11744         subreq = cli->dispatch_send(state, ev, cli,
11745                                     &ndr_table_lsarpc,
11746                                     NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE,
11747                                     &state->tmp);
11748         if (tevent_req_nomem(subreq, req)) {
11749                 return tevent_req_post(req, ev);
11750         }
11751         tevent_req_set_callback(subreq, rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_done, req);
11752         return req;
11753 }
11754
11755 static void rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_done(struct tevent_req *subreq)
11756 {
11757         struct tevent_req *req = tevent_req_callback_data(
11758                 subreq, struct tevent_req);
11759         struct rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_state *state = tevent_req_data(
11760                 req, struct rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_state);
11761         NTSTATUS status;
11762         TALLOC_CTX *mem_ctx;
11763
11764         if (state->out_mem_ctx) {
11765                 mem_ctx = state->out_mem_ctx;
11766         } else {
11767                 mem_ctx = state;
11768         }
11769
11770         status = state->dispatch_recv(subreq, mem_ctx);
11771         TALLOC_FREE(subreq);
11772         if (!NT_STATUS_IS_OK(status)) {
11773                 tevent_req_nterror(req, status);
11774                 return;
11775         }
11776
11777         /* Copy out parameters */
11778
11779         /* Copy result */
11780         state->orig.out.result = state->tmp.out.result;
11781
11782         /* Reset temporary structure */
11783         ZERO_STRUCT(state->tmp);
11784
11785         tevent_req_done(req);
11786 }
11787
11788 NTSTATUS rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_recv(struct tevent_req *req,
11789                                                               TALLOC_CTX *mem_ctx,
11790                                                               NTSTATUS *result)
11791 {
11792         struct rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_state *state = tevent_req_data(
11793                 req, struct rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_state);
11794         NTSTATUS status;
11795
11796         if (tevent_req_is_nterror(req, &status)) {
11797                 tevent_req_received(req);
11798                 return status;
11799         }
11800
11801         /* Steal possbile out parameters to the callers context */
11802         talloc_steal(mem_ctx, state->out_mem_ctx);
11803
11804         /* Return result */
11805         *result = state->orig.out.result;
11806
11807         tevent_req_received(req);
11808         return NT_STATUS_OK;
11809 }
11810
11811 NTSTATUS rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct rpc_pipe_client *cli,
11812                                                          TALLOC_CTX *mem_ctx)
11813 {
11814         struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE r;
11815         NTSTATUS status;
11816
11817         /* In parameters */
11818
11819         status = cli->dispatch(cli,
11820                                 mem_ctx,
11821                                 &ndr_table_lsarpc,
11822                                 NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE,
11823                                 &r);
11824
11825         if (!NT_STATUS_IS_OK(status)) {
11826                 return status;
11827         }
11828
11829         if (NT_STATUS_IS_ERR(status)) {
11830                 return status;
11831         }
11832
11833         /* Return variables */
11834
11835         /* Return result */
11836         return r.out.result;
11837 }
11838
11839 struct rpccli_lsa_LSARADTREPORTSECURITYEVENT_state {
11840         struct lsa_LSARADTREPORTSECURITYEVENT orig;
11841         struct lsa_LSARADTREPORTSECURITYEVENT tmp;
11842         TALLOC_CTX *out_mem_ctx;
11843         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11844 };
11845
11846 static void rpccli_lsa_LSARADTREPORTSECURITYEVENT_done(struct tevent_req *subreq);
11847
11848 struct tevent_req *rpccli_lsa_LSARADTREPORTSECURITYEVENT_send(TALLOC_CTX *mem_ctx,
11849                                                               struct tevent_context *ev,
11850                                                               struct rpc_pipe_client *cli)
11851 {
11852         struct tevent_req *req;
11853         struct rpccli_lsa_LSARADTREPORTSECURITYEVENT_state *state;
11854         struct tevent_req *subreq;
11855
11856         req = tevent_req_create(mem_ctx, &state,
11857                                 struct rpccli_lsa_LSARADTREPORTSECURITYEVENT_state);
11858         if (req == NULL) {
11859                 return NULL;
11860         }
11861         state->out_mem_ctx = NULL;
11862         state->dispatch_recv = cli->dispatch_recv;
11863
11864         /* In parameters */
11865
11866         /* Out parameters */
11867
11868         /* Result */
11869         ZERO_STRUCT(state->orig.out.result);
11870
11871         /* make a temporary copy, that we pass to the dispatch function */
11872         state->tmp = state->orig;
11873
11874         subreq = cli->dispatch_send(state, ev, cli,
11875                                     &ndr_table_lsarpc,
11876                                     NDR_LSA_LSARADTREPORTSECURITYEVENT,
11877                                     &state->tmp);
11878         if (tevent_req_nomem(subreq, req)) {
11879                 return tevent_req_post(req, ev);
11880         }
11881         tevent_req_set_callback(subreq, rpccli_lsa_LSARADTREPORTSECURITYEVENT_done, req);
11882         return req;
11883 }
11884
11885 static void rpccli_lsa_LSARADTREPORTSECURITYEVENT_done(struct tevent_req *subreq)
11886 {
11887         struct tevent_req *req = tevent_req_callback_data(
11888                 subreq, struct tevent_req);
11889         struct rpccli_lsa_LSARADTREPORTSECURITYEVENT_state *state = tevent_req_data(
11890                 req, struct rpccli_lsa_LSARADTREPORTSECURITYEVENT_state);
11891         NTSTATUS status;
11892         TALLOC_CTX *mem_ctx;
11893
11894         if (state->out_mem_ctx) {
11895                 mem_ctx = state->out_mem_ctx;
11896         } else {
11897                 mem_ctx = state;
11898         }
11899
11900         status = state->dispatch_recv(subreq, mem_ctx);
11901         TALLOC_FREE(subreq);
11902         if (!NT_STATUS_IS_OK(status)) {
11903                 tevent_req_nterror(req, status);
11904                 return;
11905         }
11906
11907         /* Copy out parameters */
11908
11909         /* Copy result */
11910         state->orig.out.result = state->tmp.out.result;
11911
11912         /* Reset temporary structure */
11913         ZERO_STRUCT(state->tmp);
11914
11915         tevent_req_done(req);
11916 }
11917
11918 NTSTATUS rpccli_lsa_LSARADTREPORTSECURITYEVENT_recv(struct tevent_req *req,
11919                                                     TALLOC_CTX *mem_ctx,
11920                                                     NTSTATUS *result)
11921 {
11922         struct rpccli_lsa_LSARADTREPORTSECURITYEVENT_state *state = tevent_req_data(
11923                 req, struct rpccli_lsa_LSARADTREPORTSECURITYEVENT_state);
11924         NTSTATUS status;
11925
11926         if (tevent_req_is_nterror(req, &status)) {
11927                 tevent_req_received(req);
11928                 return status;
11929         }
11930
11931         /* Steal possbile out parameters to the callers context */
11932         talloc_steal(mem_ctx, state->out_mem_ctx);
11933
11934         /* Return result */
11935         *result = state->orig.out.result;
11936
11937         tevent_req_received(req);
11938         return NT_STATUS_OK;
11939 }
11940
11941 NTSTATUS rpccli_lsa_LSARADTREPORTSECURITYEVENT(struct rpc_pipe_client *cli,
11942                                                TALLOC_CTX *mem_ctx)
11943 {
11944         struct lsa_LSARADTREPORTSECURITYEVENT r;
11945         NTSTATUS status;
11946
11947         /* In parameters */
11948
11949         status = cli->dispatch(cli,
11950                                 mem_ctx,
11951                                 &ndr_table_lsarpc,
11952                                 NDR_LSA_LSARADTREPORTSECURITYEVENT,
11953                                 &r);
11954
11955         if (!NT_STATUS_IS_OK(status)) {
11956                 return status;
11957         }
11958
11959         if (NT_STATUS_IS_ERR(status)) {
11960                 return status;
11961         }
11962
11963         /* Return variables */
11964
11965         /* Return result */
11966         return r.out.result;
11967 }
11968