librpc/gen_ndr/cli_dssetup.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_dssetup.h"
   8
   9 struct rpccli_dssetup_DsRoleGetPrimaryDomainInformation_state {
  10         struct dssetup_DsRoleGetPrimaryDomainInformation orig;
  11         struct dssetup_DsRoleGetPrimaryDomainInformation 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_dssetup_DsRoleGetPrimaryDomainInformation_done(struct tevent_req *subreq);
  17
  18 struct tevent_req *rpccli_dssetup_DsRoleGetPrimaryDomainInformation_send(TALLOC_CTX *mem_ctx,
  19                                                                          struct tevent_context *ev,
  20                                                                          struct rpc_pipe_client *cli,
  21                                                                          enum dssetup_DsRoleInfoLevel _level /* [in]  */,
  22                                                                          union dssetup_DsRoleInfo *_info /* [out] [unique,switch_is(level)] */)
  23 {
  24         struct tevent_req *req;
  25         struct rpccli_dssetup_DsRoleGetPrimaryDomainInformation_state *state;
  26         struct tevent_req *subreq;
  27
  28         req = tevent_req_create(mem_ctx, &state,
  29                                 struct rpccli_dssetup_DsRoleGetPrimaryDomainInformation_state);
  30         if (req == NULL) {
  31                 return NULL;
  32         }
  33         state->out_mem_ctx = NULL;
  34         state->dispatch_recv = cli->dispatch_recv;
  35
  36         /* In parameters */
  37         state->orig.in.level = _level;
  38
  39         /* Out parameters */
  40         state->orig.out.info = _info;
  41
  42         /* Result */
  43         ZERO_STRUCT(state->orig.out.result);
  44
  45         if (DEBUGLEVEL >= 10) {
  46                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleGetPrimaryDomainInformation, &state->orig);
  47         }
  48
  49         state->out_mem_ctx = talloc_named_const(state, 0,
  50                              "rpccli_dssetup_DsRoleGetPrimaryDomainInformation_out_memory");
  51         if (tevent_req_nomem(state->out_mem_ctx, req)) {
  52                 return tevent_req_post(req, ev);
  53         }
  54
  55         /* make a temporary copy, that we pass to the dispatch function */
  56         state->tmp = state->orig;
  57
  58         subreq = cli->dispatch_send(state, ev, cli,
  59                                     &ndr_table_dssetup,
  60                                     NDR_DSSETUP_DSROLEGETPRIMARYDOMAININFORMATION,
  61                                     &state->tmp);
  62         if (tevent_req_nomem(subreq, req)) {
  63                 return tevent_req_post(req, ev);
  64         }
  65         tevent_req_set_callback(subreq, rpccli_dssetup_DsRoleGetPrimaryDomainInformation_done, req);
  66         return req;
  67 }
  68
  69 static void rpccli_dssetup_DsRoleGetPrimaryDomainInformation_done(struct tevent_req *subreq)
  70 {
  71         struct tevent_req *req = tevent_req_callback_data(
  72                 subreq, struct tevent_req);
  73         struct rpccli_dssetup_DsRoleGetPrimaryDomainInformation_state *state = tevent_req_data(
  74                 req, struct rpccli_dssetup_DsRoleGetPrimaryDomainInformation_state);
  75         NTSTATUS status;
  76         TALLOC_CTX *mem_ctx;
  77
  78         if (state->out_mem_ctx) {
  79                 mem_ctx = state->out_mem_ctx;
  80         } else {
  81                 mem_ctx = state;
  82         }
  83
  84         status = state->dispatch_recv(subreq, mem_ctx);
  85         TALLOC_FREE(subreq);
  86         if (!NT_STATUS_IS_OK(status)) {
  87                 tevent_req_nterror(req, status);
  88                 return;
  89         }
  90
  91         /* Copy out parameters */
  92         if (state->orig.out.info && state->tmp.out.info) {
  93                 *state->orig.out.info = *state->tmp.out.info;
  94         }
  95
  96         /* Copy result */
  97         state->orig.out.result = state->tmp.out.result;
  98
  99         /* Reset temporary structure */
 100         ZERO_STRUCT(state->tmp);
 101
 102         if (DEBUGLEVEL >= 10) {
 103                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleGetPrimaryDomainInformation, &state->orig);
 104         }
 105
 106         tevent_req_done(req);
 107 }
 108
 109 NTSTATUS rpccli_dssetup_DsRoleGetPrimaryDomainInformation_recv(struct tevent_req *req,
 110                                                                TALLOC_CTX *mem_ctx,
 111                                                                WERROR *result)
 112 {
 113         struct rpccli_dssetup_DsRoleGetPrimaryDomainInformation_state *state = tevent_req_data(
 114                 req, struct rpccli_dssetup_DsRoleGetPrimaryDomainInformation_state);
 115         NTSTATUS status;
 116
 117         if (tevent_req_is_nterror(req, &status)) {
 118                 tevent_req_received(req);
 119                 return status;
 120         }
 121
 122         /* Steal possbile out parameters to the callers context */
 123         talloc_steal(mem_ctx, state->out_mem_ctx);
 124
 125         /* Return result */
 126         *result = state->orig.out.result;
 127
 128         tevent_req_received(req);
 129         return NT_STATUS_OK;
 130 }
 131
 132 NTSTATUS rpccli_dssetup_DsRoleGetPrimaryDomainInformation(struct rpc_pipe_client *cli,
 133                                                           TALLOC_CTX *mem_ctx,
 134                                                           enum dssetup_DsRoleInfoLevel level /* [in]  */,
 135                                                           union dssetup_DsRoleInfo *info /* [out] [unique,switch_is(level)] */,
 136                                                           WERROR *werror)
 137 {
 138         struct dssetup_DsRoleGetPrimaryDomainInformation r;
 139         NTSTATUS status;
 140
 141         /* In parameters */
 142         r.in.level = level;
 143
 144         if (DEBUGLEVEL >= 10) {
 145                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleGetPrimaryDomainInformation, &r);
 146         }
 147
 148         status = cli->dispatch(cli,
 149                                 mem_ctx,
 150                                 &ndr_table_dssetup,
 151                                 NDR_DSSETUP_DSROLEGETPRIMARYDOMAININFORMATION,
 152                                 &r);
 153
 154         if (!NT_STATUS_IS_OK(status)) {
 155                 return status;
 156         }
 157
 158         if (DEBUGLEVEL >= 10) {
 159                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleGetPrimaryDomainInformation, &r);
 160         }
 161
 162         if (NT_STATUS_IS_ERR(status)) {
 163                 return status;
 164         }
 165
 166         /* Return variables */
 167         if (info && r.out.info) {
 168                 *info = *r.out.info;
 169         }
 170
 171         /* Return result */
 172         if (werror) {
 173                 *werror = r.out.result;
 174         }
 175
 176         return werror_to_ntstatus(r.out.result);
 177 }
 178
 179 struct rpccli_dssetup_DsRoleDnsNameToFlatName_state {
 180         struct dssetup_DsRoleDnsNameToFlatName orig;
 181         struct dssetup_DsRoleDnsNameToFlatName tmp;
 182         TALLOC_CTX *out_mem_ctx;
 183         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 184 };
 185
 186 static void rpccli_dssetup_DsRoleDnsNameToFlatName_done(struct tevent_req *subreq);
 187
 188 struct tevent_req *rpccli_dssetup_DsRoleDnsNameToFlatName_send(TALLOC_CTX *mem_ctx,
 189                                                                struct tevent_context *ev,
 190                                                                struct rpc_pipe_client *cli)
 191 {
 192         struct tevent_req *req;
 193         struct rpccli_dssetup_DsRoleDnsNameToFlatName_state *state;
 194         struct tevent_req *subreq;
 195
 196         req = tevent_req_create(mem_ctx, &state,
 197                                 struct rpccli_dssetup_DsRoleDnsNameToFlatName_state);
 198         if (req == NULL) {
 199                 return NULL;
 200         }
 201         state->out_mem_ctx = NULL;
 202         state->dispatch_recv = cli->dispatch_recv;
 203
 204         /* In parameters */
 205
 206         /* Out parameters */
 207
 208         /* Result */
 209         ZERO_STRUCT(state->orig.out.result);
 210
 211         if (DEBUGLEVEL >= 10) {
 212                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleDnsNameToFlatName, &state->orig);
 213         }
 214
 215         /* make a temporary copy, that we pass to the dispatch function */
 216         state->tmp = state->orig;
 217
 218         subreq = cli->dispatch_send(state, ev, cli,
 219                                     &ndr_table_dssetup,
 220                                     NDR_DSSETUP_DSROLEDNSNAMETOFLATNAME,
 221                                     &state->tmp);
 222         if (tevent_req_nomem(subreq, req)) {
 223                 return tevent_req_post(req, ev);
 224         }
 225         tevent_req_set_callback(subreq, rpccli_dssetup_DsRoleDnsNameToFlatName_done, req);
 226         return req;
 227 }
 228
 229 static void rpccli_dssetup_DsRoleDnsNameToFlatName_done(struct tevent_req *subreq)
 230 {
 231         struct tevent_req *req = tevent_req_callback_data(
 232                 subreq, struct tevent_req);
 233         struct rpccli_dssetup_DsRoleDnsNameToFlatName_state *state = tevent_req_data(
 234                 req, struct rpccli_dssetup_DsRoleDnsNameToFlatName_state);
 235         NTSTATUS status;
 236         TALLOC_CTX *mem_ctx;
 237
 238         if (state->out_mem_ctx) {
 239                 mem_ctx = state->out_mem_ctx;
 240         } else {
 241                 mem_ctx = state;
 242         }
 243
 244         status = state->dispatch_recv(subreq, mem_ctx);
 245         TALLOC_FREE(subreq);
 246         if (!NT_STATUS_IS_OK(status)) {
 247                 tevent_req_nterror(req, status);
 248                 return;
 249         }
 250
 251         /* Copy out parameters */
 252
 253         /* Copy result */
 254         state->orig.out.result = state->tmp.out.result;
 255
 256         /* Reset temporary structure */
 257         ZERO_STRUCT(state->tmp);
 258
 259         if (DEBUGLEVEL >= 10) {
 260                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleDnsNameToFlatName, &state->orig);
 261         }
 262
 263         tevent_req_done(req);
 264 }
 265
 266 NTSTATUS rpccli_dssetup_DsRoleDnsNameToFlatName_recv(struct tevent_req *req,
 267                                                      TALLOC_CTX *mem_ctx,
 268                                                      WERROR *result)
 269 {
 270         struct rpccli_dssetup_DsRoleDnsNameToFlatName_state *state = tevent_req_data(
 271                 req, struct rpccli_dssetup_DsRoleDnsNameToFlatName_state);
 272         NTSTATUS status;
 273
 274         if (tevent_req_is_nterror(req, &status)) {
 275                 tevent_req_received(req);
 276                 return status;
 277         }
 278
 279         /* Steal possbile out parameters to the callers context */
 280         talloc_steal(mem_ctx, state->out_mem_ctx);
 281
 282         /* Return result */
 283         *result = state->orig.out.result;
 284
 285         tevent_req_received(req);
 286         return NT_STATUS_OK;
 287 }
 288
 289 NTSTATUS rpccli_dssetup_DsRoleDnsNameToFlatName(struct rpc_pipe_client *cli,
 290                                                 TALLOC_CTX *mem_ctx,
 291                                                 WERROR *werror)
 292 {
 293         struct dssetup_DsRoleDnsNameToFlatName r;
 294         NTSTATUS status;
 295
 296         /* In parameters */
 297
 298         if (DEBUGLEVEL >= 10) {
 299                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleDnsNameToFlatName, &r);
 300         }
 301
 302         status = cli->dispatch(cli,
 303                                 mem_ctx,
 304                                 &ndr_table_dssetup,
 305                                 NDR_DSSETUP_DSROLEDNSNAMETOFLATNAME,
 306                                 &r);
 307
 308         if (!NT_STATUS_IS_OK(status)) {
 309                 return status;
 310         }
 311
 312         if (DEBUGLEVEL >= 10) {
 313                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleDnsNameToFlatName, &r);
 314         }
 315
 316         if (NT_STATUS_IS_ERR(status)) {
 317                 return status;
 318         }
 319
 320         /* Return variables */
 321
 322         /* Return result */
 323         if (werror) {
 324                 *werror = r.out.result;
 325         }
 326
 327         return werror_to_ntstatus(r.out.result);
 328 }
 329
 330 struct rpccli_dssetup_DsRoleDcAsDc_state {
 331         struct dssetup_DsRoleDcAsDc orig;
 332         struct dssetup_DsRoleDcAsDc tmp;
 333         TALLOC_CTX *out_mem_ctx;
 334         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 335 };
 336
 337 static void rpccli_dssetup_DsRoleDcAsDc_done(struct tevent_req *subreq);
 338
 339 struct tevent_req *rpccli_dssetup_DsRoleDcAsDc_send(TALLOC_CTX *mem_ctx,
 340                                                     struct tevent_context *ev,
 341                                                     struct rpc_pipe_client *cli)
 342 {
 343         struct tevent_req *req;
 344         struct rpccli_dssetup_DsRoleDcAsDc_state *state;
 345         struct tevent_req *subreq;
 346
 347         req = tevent_req_create(mem_ctx, &state,
 348                                 struct rpccli_dssetup_DsRoleDcAsDc_state);
 349         if (req == NULL) {
 350                 return NULL;
 351         }
 352         state->out_mem_ctx = NULL;
 353         state->dispatch_recv = cli->dispatch_recv;
 354
 355         /* In parameters */
 356
 357         /* Out parameters */
 358
 359         /* Result */
 360         ZERO_STRUCT(state->orig.out.result);
 361
 362         if (DEBUGLEVEL >= 10) {
 363                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleDcAsDc, &state->orig);
 364         }
 365
 366         /* make a temporary copy, that we pass to the dispatch function */
 367         state->tmp = state->orig;
 368
 369         subreq = cli->dispatch_send(state, ev, cli,
 370                                     &ndr_table_dssetup,
 371                                     NDR_DSSETUP_DSROLEDCASDC,
 372                                     &state->tmp);
 373         if (tevent_req_nomem(subreq, req)) {
 374                 return tevent_req_post(req, ev);
 375         }
 376         tevent_req_set_callback(subreq, rpccli_dssetup_DsRoleDcAsDc_done, req);
 377         return req;
 378 }
 379
 380 static void rpccli_dssetup_DsRoleDcAsDc_done(struct tevent_req *subreq)
 381 {
 382         struct tevent_req *req = tevent_req_callback_data(
 383                 subreq, struct tevent_req);
 384         struct rpccli_dssetup_DsRoleDcAsDc_state *state = tevent_req_data(
 385                 req, struct rpccli_dssetup_DsRoleDcAsDc_state);
 386         NTSTATUS status;
 387         TALLOC_CTX *mem_ctx;
 388
 389         if (state->out_mem_ctx) {
 390                 mem_ctx = state->out_mem_ctx;
 391         } else {
 392                 mem_ctx = state;
 393         }
 394
 395         status = state->dispatch_recv(subreq, mem_ctx);
 396         TALLOC_FREE(subreq);
 397         if (!NT_STATUS_IS_OK(status)) {
 398                 tevent_req_nterror(req, status);
 399                 return;
 400         }
 401
 402         /* Copy out parameters */
 403
 404         /* Copy result */
 405         state->orig.out.result = state->tmp.out.result;
 406
 407         /* Reset temporary structure */
 408         ZERO_STRUCT(state->tmp);
 409
 410         if (DEBUGLEVEL >= 10) {
 411                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleDcAsDc, &state->orig);
 412         }
 413
 414         tevent_req_done(req);
 415 }
 416
 417 NTSTATUS rpccli_dssetup_DsRoleDcAsDc_recv(struct tevent_req *req,
 418                                           TALLOC_CTX *mem_ctx,
 419                                           WERROR *result)
 420 {
 421         struct rpccli_dssetup_DsRoleDcAsDc_state *state = tevent_req_data(
 422                 req, struct rpccli_dssetup_DsRoleDcAsDc_state);
 423         NTSTATUS status;
 424
 425         if (tevent_req_is_nterror(req, &status)) {
 426                 tevent_req_received(req);
 427                 return status;
 428         }
 429
 430         /* Steal possbile out parameters to the callers context */
 431         talloc_steal(mem_ctx, state->out_mem_ctx);
 432
 433         /* Return result */
 434         *result = state->orig.out.result;
 435
 436         tevent_req_received(req);
 437         return NT_STATUS_OK;
 438 }
 439
 440 NTSTATUS rpccli_dssetup_DsRoleDcAsDc(struct rpc_pipe_client *cli,
 441                                      TALLOC_CTX *mem_ctx,
 442                                      WERROR *werror)
 443 {
 444         struct dssetup_DsRoleDcAsDc r;
 445         NTSTATUS status;
 446
 447         /* In parameters */
 448
 449         if (DEBUGLEVEL >= 10) {
 450                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleDcAsDc, &r);
 451         }
 452
 453         status = cli->dispatch(cli,
 454                                 mem_ctx,
 455                                 &ndr_table_dssetup,
 456                                 NDR_DSSETUP_DSROLEDCASDC,
 457                                 &r);
 458
 459         if (!NT_STATUS_IS_OK(status)) {
 460                 return status;
 461         }
 462
 463         if (DEBUGLEVEL >= 10) {
 464                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleDcAsDc, &r);
 465         }
 466
 467         if (NT_STATUS_IS_ERR(status)) {
 468                 return status;
 469         }
 470
 471         /* Return variables */
 472
 473         /* Return result */
 474         if (werror) {
 475                 *werror = r.out.result;
 476         }
 477
 478         return werror_to_ntstatus(r.out.result);
 479 }
 480
 481 struct rpccli_dssetup_DsRoleDcAsReplica_state {
 482         struct dssetup_DsRoleDcAsReplica orig;
 483         struct dssetup_DsRoleDcAsReplica tmp;
 484         TALLOC_CTX *out_mem_ctx;
 485         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 486 };
 487
 488 static void rpccli_dssetup_DsRoleDcAsReplica_done(struct tevent_req *subreq);
 489
 490 struct tevent_req *rpccli_dssetup_DsRoleDcAsReplica_send(TALLOC_CTX *mem_ctx,
 491                                                          struct tevent_context *ev,
 492                                                          struct rpc_pipe_client *cli)
 493 {
 494         struct tevent_req *req;
 495         struct rpccli_dssetup_DsRoleDcAsReplica_state *state;
 496         struct tevent_req *subreq;
 497
 498         req = tevent_req_create(mem_ctx, &state,
 499                                 struct rpccli_dssetup_DsRoleDcAsReplica_state);
 500         if (req == NULL) {
 501                 return NULL;
 502         }
 503         state->out_mem_ctx = NULL;
 504         state->dispatch_recv = cli->dispatch_recv;
 505
 506         /* In parameters */
 507
 508         /* Out parameters */
 509
 510         /* Result */
 511         ZERO_STRUCT(state->orig.out.result);
 512
 513         if (DEBUGLEVEL >= 10) {
 514                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleDcAsReplica, &state->orig);
 515         }
 516
 517         /* make a temporary copy, that we pass to the dispatch function */
 518         state->tmp = state->orig;
 519
 520         subreq = cli->dispatch_send(state, ev, cli,
 521                                     &ndr_table_dssetup,
 522                                     NDR_DSSETUP_DSROLEDCASREPLICA,
 523                                     &state->tmp);
 524         if (tevent_req_nomem(subreq, req)) {
 525                 return tevent_req_post(req, ev);
 526         }
 527         tevent_req_set_callback(subreq, rpccli_dssetup_DsRoleDcAsReplica_done, req);
 528         return req;
 529 }
 530
 531 static void rpccli_dssetup_DsRoleDcAsReplica_done(struct tevent_req *subreq)
 532 {
 533         struct tevent_req *req = tevent_req_callback_data(
 534                 subreq, struct tevent_req);
 535         struct rpccli_dssetup_DsRoleDcAsReplica_state *state = tevent_req_data(
 536                 req, struct rpccli_dssetup_DsRoleDcAsReplica_state);
 537         NTSTATUS status;
 538         TALLOC_CTX *mem_ctx;
 539
 540         if (state->out_mem_ctx) {
 541                 mem_ctx = state->out_mem_ctx;
 542         } else {
 543                 mem_ctx = state;
 544         }
 545
 546         status = state->dispatch_recv(subreq, mem_ctx);
 547         TALLOC_FREE(subreq);
 548         if (!NT_STATUS_IS_OK(status)) {
 549                 tevent_req_nterror(req, status);
 550                 return;
 551         }
 552
 553         /* Copy out parameters */
 554
 555         /* Copy result */
 556         state->orig.out.result = state->tmp.out.result;
 557
 558         /* Reset temporary structure */
 559         ZERO_STRUCT(state->tmp);
 560
 561         if (DEBUGLEVEL >= 10) {
 562                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleDcAsReplica, &state->orig);
 563         }
 564
 565         tevent_req_done(req);
 566 }
 567
 568 NTSTATUS rpccli_dssetup_DsRoleDcAsReplica_recv(struct tevent_req *req,
 569                                                TALLOC_CTX *mem_ctx,
 570                                                WERROR *result)
 571 {
 572         struct rpccli_dssetup_DsRoleDcAsReplica_state *state = tevent_req_data(
 573                 req, struct rpccli_dssetup_DsRoleDcAsReplica_state);
 574         NTSTATUS status;
 575
 576         if (tevent_req_is_nterror(req, &status)) {
 577                 tevent_req_received(req);
 578                 return status;
 579         }
 580
 581         /* Steal possbile out parameters to the callers context */
 582         talloc_steal(mem_ctx, state->out_mem_ctx);
 583
 584         /* Return result */
 585         *result = state->orig.out.result;
 586
 587         tevent_req_received(req);
 588         return NT_STATUS_OK;
 589 }
 590
 591 NTSTATUS rpccli_dssetup_DsRoleDcAsReplica(struct rpc_pipe_client *cli,
 592                                           TALLOC_CTX *mem_ctx,
 593                                           WERROR *werror)
 594 {
 595         struct dssetup_DsRoleDcAsReplica r;
 596         NTSTATUS status;
 597
 598         /* In parameters */
 599
 600         if (DEBUGLEVEL >= 10) {
 601                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleDcAsReplica, &r);
 602         }
 603
 604         status = cli->dispatch(cli,
 605                                 mem_ctx,
 606                                 &ndr_table_dssetup,
 607                                 NDR_DSSETUP_DSROLEDCASREPLICA,
 608                                 &r);
 609
 610         if (!NT_STATUS_IS_OK(status)) {
 611                 return status;
 612         }
 613
 614         if (DEBUGLEVEL >= 10) {
 615                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleDcAsReplica, &r);
 616         }
 617
 618         if (NT_STATUS_IS_ERR(status)) {
 619                 return status;
 620         }
 621
 622         /* Return variables */
 623
 624         /* Return result */
 625         if (werror) {
 626                 *werror = r.out.result;
 627         }
 628
 629         return werror_to_ntstatus(r.out.result);
 630 }
 631
 632 struct rpccli_dssetup_DsRoleDemoteDc_state {
 633         struct dssetup_DsRoleDemoteDc orig;
 634         struct dssetup_DsRoleDemoteDc tmp;
 635         TALLOC_CTX *out_mem_ctx;
 636         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 637 };
 638
 639 static void rpccli_dssetup_DsRoleDemoteDc_done(struct tevent_req *subreq);
 640
 641 struct tevent_req *rpccli_dssetup_DsRoleDemoteDc_send(TALLOC_CTX *mem_ctx,
 642                                                       struct tevent_context *ev,
 643                                                       struct rpc_pipe_client *cli)
 644 {
 645         struct tevent_req *req;
 646         struct rpccli_dssetup_DsRoleDemoteDc_state *state;
 647         struct tevent_req *subreq;
 648
 649         req = tevent_req_create(mem_ctx, &state,
 650                                 struct rpccli_dssetup_DsRoleDemoteDc_state);
 651         if (req == NULL) {
 652                 return NULL;
 653         }
 654         state->out_mem_ctx = NULL;
 655         state->dispatch_recv = cli->dispatch_recv;
 656
 657         /* In parameters */
 658
 659         /* Out parameters */
 660
 661         /* Result */
 662         ZERO_STRUCT(state->orig.out.result);
 663
 664         if (DEBUGLEVEL >= 10) {
 665                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleDemoteDc, &state->orig);
 666         }
 667
 668         /* make a temporary copy, that we pass to the dispatch function */
 669         state->tmp = state->orig;
 670
 671         subreq = cli->dispatch_send(state, ev, cli,
 672                                     &ndr_table_dssetup,
 673                                     NDR_DSSETUP_DSROLEDEMOTEDC,
 674                                     &state->tmp);
 675         if (tevent_req_nomem(subreq, req)) {
 676                 return tevent_req_post(req, ev);
 677         }
 678         tevent_req_set_callback(subreq, rpccli_dssetup_DsRoleDemoteDc_done, req);
 679         return req;
 680 }
 681
 682 static void rpccli_dssetup_DsRoleDemoteDc_done(struct tevent_req *subreq)
 683 {
 684         struct tevent_req *req = tevent_req_callback_data(
 685                 subreq, struct tevent_req);
 686         struct rpccli_dssetup_DsRoleDemoteDc_state *state = tevent_req_data(
 687                 req, struct rpccli_dssetup_DsRoleDemoteDc_state);
 688         NTSTATUS status;
 689         TALLOC_CTX *mem_ctx;
 690
 691         if (state->out_mem_ctx) {
 692                 mem_ctx = state->out_mem_ctx;
 693         } else {
 694                 mem_ctx = state;
 695         }
 696
 697         status = state->dispatch_recv(subreq, mem_ctx);
 698         TALLOC_FREE(subreq);
 699         if (!NT_STATUS_IS_OK(status)) {
 700                 tevent_req_nterror(req, status);
 701                 return;
 702         }
 703
 704         /* Copy out parameters */
 705
 706         /* Copy result */
 707         state->orig.out.result = state->tmp.out.result;
 708
 709         /* Reset temporary structure */
 710         ZERO_STRUCT(state->tmp);
 711
 712         if (DEBUGLEVEL >= 10) {
 713                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleDemoteDc, &state->orig);
 714         }
 715
 716         tevent_req_done(req);
 717 }
 718
 719 NTSTATUS rpccli_dssetup_DsRoleDemoteDc_recv(struct tevent_req *req,
 720                                             TALLOC_CTX *mem_ctx,
 721                                             WERROR *result)
 722 {
 723         struct rpccli_dssetup_DsRoleDemoteDc_state *state = tevent_req_data(
 724                 req, struct rpccli_dssetup_DsRoleDemoteDc_state);
 725         NTSTATUS status;
 726
 727         if (tevent_req_is_nterror(req, &status)) {
 728                 tevent_req_received(req);
 729                 return status;
 730         }
 731
 732         /* Steal possbile out parameters to the callers context */
 733         talloc_steal(mem_ctx, state->out_mem_ctx);
 734
 735         /* Return result */
 736         *result = state->orig.out.result;
 737
 738         tevent_req_received(req);
 739         return NT_STATUS_OK;
 740 }
 741
 742 NTSTATUS rpccli_dssetup_DsRoleDemoteDc(struct rpc_pipe_client *cli,
 743                                        TALLOC_CTX *mem_ctx,
 744                                        WERROR *werror)
 745 {
 746         struct dssetup_DsRoleDemoteDc r;
 747         NTSTATUS status;
 748
 749         /* In parameters */
 750
 751         if (DEBUGLEVEL >= 10) {
 752                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleDemoteDc, &r);
 753         }
 754
 755         status = cli->dispatch(cli,
 756                                 mem_ctx,
 757                                 &ndr_table_dssetup,
 758                                 NDR_DSSETUP_DSROLEDEMOTEDC,
 759                                 &r);
 760
 761         if (!NT_STATUS_IS_OK(status)) {
 762                 return status;
 763         }
 764
 765         if (DEBUGLEVEL >= 10) {
 766                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleDemoteDc, &r);
 767         }
 768
 769         if (NT_STATUS_IS_ERR(status)) {
 770                 return status;
 771         }
 772
 773         /* Return variables */
 774
 775         /* Return result */
 776         if (werror) {
 777                 *werror = r.out.result;
 778         }
 779
 780         return werror_to_ntstatus(r.out.result);
 781 }
 782
 783 struct rpccli_dssetup_DsRoleGetDcOperationProgress_state {
 784         struct dssetup_DsRoleGetDcOperationProgress orig;
 785         struct dssetup_DsRoleGetDcOperationProgress tmp;
 786         TALLOC_CTX *out_mem_ctx;
 787         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 788 };
 789
 790 static void rpccli_dssetup_DsRoleGetDcOperationProgress_done(struct tevent_req *subreq);
 791
 792 struct tevent_req *rpccli_dssetup_DsRoleGetDcOperationProgress_send(TALLOC_CTX *mem_ctx,
 793                                                                     struct tevent_context *ev,
 794                                                                     struct rpc_pipe_client *cli)
 795 {
 796         struct tevent_req *req;
 797         struct rpccli_dssetup_DsRoleGetDcOperationProgress_state *state;
 798         struct tevent_req *subreq;
 799
 800         req = tevent_req_create(mem_ctx, &state,
 801                                 struct rpccli_dssetup_DsRoleGetDcOperationProgress_state);
 802         if (req == NULL) {
 803                 return NULL;
 804         }
 805         state->out_mem_ctx = NULL;
 806         state->dispatch_recv = cli->dispatch_recv;
 807
 808         /* In parameters */
 809
 810         /* Out parameters */
 811
 812         /* Result */
 813         ZERO_STRUCT(state->orig.out.result);
 814
 815         if (DEBUGLEVEL >= 10) {
 816                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleGetDcOperationProgress, &state->orig);
 817         }
 818
 819         /* make a temporary copy, that we pass to the dispatch function */
 820         state->tmp = state->orig;
 821
 822         subreq = cli->dispatch_send(state, ev, cli,
 823                                     &ndr_table_dssetup,
 824                                     NDR_DSSETUP_DSROLEGETDCOPERATIONPROGRESS,
 825                                     &state->tmp);
 826         if (tevent_req_nomem(subreq, req)) {
 827                 return tevent_req_post(req, ev);
 828         }
 829         tevent_req_set_callback(subreq, rpccli_dssetup_DsRoleGetDcOperationProgress_done, req);
 830         return req;
 831 }
 832
 833 static void rpccli_dssetup_DsRoleGetDcOperationProgress_done(struct tevent_req *subreq)
 834 {
 835         struct tevent_req *req = tevent_req_callback_data(
 836                 subreq, struct tevent_req);
 837         struct rpccli_dssetup_DsRoleGetDcOperationProgress_state *state = tevent_req_data(
 838                 req, struct rpccli_dssetup_DsRoleGetDcOperationProgress_state);
 839         NTSTATUS status;
 840         TALLOC_CTX *mem_ctx;
 841
 842         if (state->out_mem_ctx) {
 843                 mem_ctx = state->out_mem_ctx;
 844         } else {
 845                 mem_ctx = state;
 846         }
 847
 848         status = state->dispatch_recv(subreq, mem_ctx);
 849         TALLOC_FREE(subreq);
 850         if (!NT_STATUS_IS_OK(status)) {
 851                 tevent_req_nterror(req, status);
 852                 return;
 853         }
 854
 855         /* Copy out parameters */
 856
 857         /* Copy result */
 858         state->orig.out.result = state->tmp.out.result;
 859
 860         /* Reset temporary structure */
 861         ZERO_STRUCT(state->tmp);
 862
 863         if (DEBUGLEVEL >= 10) {
 864                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleGetDcOperationProgress, &state->orig);
 865         }
 866
 867         tevent_req_done(req);
 868 }
 869
 870 NTSTATUS rpccli_dssetup_DsRoleGetDcOperationProgress_recv(struct tevent_req *req,
 871                                                           TALLOC_CTX *mem_ctx,
 872                                                           WERROR *result)
 873 {
 874         struct rpccli_dssetup_DsRoleGetDcOperationProgress_state *state = tevent_req_data(
 875                 req, struct rpccli_dssetup_DsRoleGetDcOperationProgress_state);
 876         NTSTATUS status;
 877
 878         if (tevent_req_is_nterror(req, &status)) {
 879                 tevent_req_received(req);
 880                 return status;
 881         }
 882
 883         /* Steal possbile out parameters to the callers context */
 884         talloc_steal(mem_ctx, state->out_mem_ctx);
 885
 886         /* Return result */
 887         *result = state->orig.out.result;
 888
 889         tevent_req_received(req);
 890         return NT_STATUS_OK;
 891 }
 892
 893 NTSTATUS rpccli_dssetup_DsRoleGetDcOperationProgress(struct rpc_pipe_client *cli,
 894                                                      TALLOC_CTX *mem_ctx,
 895                                                      WERROR *werror)
 896 {
 897         struct dssetup_DsRoleGetDcOperationProgress r;
 898         NTSTATUS status;
 899
 900         /* In parameters */
 901
 902         if (DEBUGLEVEL >= 10) {
 903                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleGetDcOperationProgress, &r);
 904         }
 905
 906         status = cli->dispatch(cli,
 907                                 mem_ctx,
 908                                 &ndr_table_dssetup,
 909                                 NDR_DSSETUP_DSROLEGETDCOPERATIONPROGRESS,
 910                                 &r);
 911
 912         if (!NT_STATUS_IS_OK(status)) {
 913                 return status;
 914         }
 915
 916         if (DEBUGLEVEL >= 10) {
 917                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleGetDcOperationProgress, &r);
 918         }
 919
 920         if (NT_STATUS_IS_ERR(status)) {
 921                 return status;
 922         }
 923
 924         /* Return variables */
 925
 926         /* Return result */
 927         if (werror) {
 928                 *werror = r.out.result;
 929         }
 930
 931         return werror_to_ntstatus(r.out.result);
 932 }
 933
 934 struct rpccli_dssetup_DsRoleGetDcOperationResults_state {
 935         struct dssetup_DsRoleGetDcOperationResults orig;
 936         struct dssetup_DsRoleGetDcOperationResults tmp;
 937         TALLOC_CTX *out_mem_ctx;
 938         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 939 };
 940
 941 static void rpccli_dssetup_DsRoleGetDcOperationResults_done(struct tevent_req *subreq);
 942
 943 struct tevent_req *rpccli_dssetup_DsRoleGetDcOperationResults_send(TALLOC_CTX *mem_ctx,
 944                                                                    struct tevent_context *ev,
 945                                                                    struct rpc_pipe_client *cli)
 946 {
 947         struct tevent_req *req;
 948         struct rpccli_dssetup_DsRoleGetDcOperationResults_state *state;
 949         struct tevent_req *subreq;
 950
 951         req = tevent_req_create(mem_ctx, &state,
 952                                 struct rpccli_dssetup_DsRoleGetDcOperationResults_state);
 953         if (req == NULL) {
 954                 return NULL;
 955         }
 956         state->out_mem_ctx = NULL;
 957         state->dispatch_recv = cli->dispatch_recv;
 958
 959         /* In parameters */
 960
 961         /* Out parameters */
 962
 963         /* Result */
 964         ZERO_STRUCT(state->orig.out.result);
 965
 966         if (DEBUGLEVEL >= 10) {
 967                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleGetDcOperationResults, &state->orig);
 968         }
 969
 970         /* make a temporary copy, that we pass to the dispatch function */
 971         state->tmp = state->orig;
 972
 973         subreq = cli->dispatch_send(state, ev, cli,
 974                                     &ndr_table_dssetup,
 975                                     NDR_DSSETUP_DSROLEGETDCOPERATIONRESULTS,
 976                                     &state->tmp);
 977         if (tevent_req_nomem(subreq, req)) {
 978                 return tevent_req_post(req, ev);
 979         }
 980         tevent_req_set_callback(subreq, rpccli_dssetup_DsRoleGetDcOperationResults_done, req);
 981         return req;
 982 }
 983
 984 static void rpccli_dssetup_DsRoleGetDcOperationResults_done(struct tevent_req *subreq)
 985 {
 986         struct tevent_req *req = tevent_req_callback_data(
 987                 subreq, struct tevent_req);
 988         struct rpccli_dssetup_DsRoleGetDcOperationResults_state *state = tevent_req_data(
 989                 req, struct rpccli_dssetup_DsRoleGetDcOperationResults_state);
 990         NTSTATUS status;
 991         TALLOC_CTX *mem_ctx;
 992
 993         if (state->out_mem_ctx) {
 994                 mem_ctx = state->out_mem_ctx;
 995         } else {
 996                 mem_ctx = state;
 997         }
 998
 999         status = state->dispatch_recv(subreq, mem_ctx);
1000         TALLOC_FREE(subreq);
1001         if (!NT_STATUS_IS_OK(status)) {
1002                 tevent_req_nterror(req, status);
1003                 return;
1004         }
1005
1006         /* Copy out parameters */
1007
1008         /* Copy result */
1009         state->orig.out.result = state->tmp.out.result;
1010
1011         /* Reset temporary structure */
1012         ZERO_STRUCT(state->tmp);
1013
1014         if (DEBUGLEVEL >= 10) {
1015                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleGetDcOperationResults, &state->orig);
1016         }
1017
1018         tevent_req_done(req);
1019 }
1020
1021 NTSTATUS rpccli_dssetup_DsRoleGetDcOperationResults_recv(struct tevent_req *req,
1022                                                          TALLOC_CTX *mem_ctx,
1023                                                          WERROR *result)
1024 {
1025         struct rpccli_dssetup_DsRoleGetDcOperationResults_state *state = tevent_req_data(
1026                 req, struct rpccli_dssetup_DsRoleGetDcOperationResults_state);
1027         NTSTATUS status;
1028
1029         if (tevent_req_is_nterror(req, &status)) {
1030                 tevent_req_received(req);
1031                 return status;
1032         }
1033
1034         /* Steal possbile out parameters to the callers context */
1035         talloc_steal(mem_ctx, state->out_mem_ctx);
1036
1037         /* Return result */
1038         *result = state->orig.out.result;
1039
1040         tevent_req_received(req);
1041         return NT_STATUS_OK;
1042 }
1043
1044 NTSTATUS rpccli_dssetup_DsRoleGetDcOperationResults(struct rpc_pipe_client *cli,
1045                                                     TALLOC_CTX *mem_ctx,
1046                                                     WERROR *werror)
1047 {
1048         struct dssetup_DsRoleGetDcOperationResults r;
1049         NTSTATUS status;
1050
1051         /* In parameters */
1052
1053         if (DEBUGLEVEL >= 10) {
1054                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleGetDcOperationResults, &r);
1055         }
1056
1057         status = cli->dispatch(cli,
1058                                 mem_ctx,
1059                                 &ndr_table_dssetup,
1060                                 NDR_DSSETUP_DSROLEGETDCOPERATIONRESULTS,
1061                                 &r);
1062
1063         if (!NT_STATUS_IS_OK(status)) {
1064                 return status;
1065         }
1066
1067         if (DEBUGLEVEL >= 10) {
1068                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleGetDcOperationResults, &r);
1069         }
1070
1071         if (NT_STATUS_IS_ERR(status)) {
1072                 return status;
1073         }
1074
1075         /* Return variables */
1076
1077         /* Return result */
1078         if (werror) {
1079                 *werror = r.out.result;
1080         }
1081
1082         return werror_to_ntstatus(r.out.result);
1083 }
1084
1085 struct rpccli_dssetup_DsRoleCancel_state {
1086         struct dssetup_DsRoleCancel orig;
1087         struct dssetup_DsRoleCancel tmp;
1088         TALLOC_CTX *out_mem_ctx;
1089         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1090 };
1091
1092 static void rpccli_dssetup_DsRoleCancel_done(struct tevent_req *subreq);
1093
1094 struct tevent_req *rpccli_dssetup_DsRoleCancel_send(TALLOC_CTX *mem_ctx,
1095                                                     struct tevent_context *ev,
1096                                                     struct rpc_pipe_client *cli)
1097 {
1098         struct tevent_req *req;
1099         struct rpccli_dssetup_DsRoleCancel_state *state;
1100         struct tevent_req *subreq;
1101
1102         req = tevent_req_create(mem_ctx, &state,
1103                                 struct rpccli_dssetup_DsRoleCancel_state);
1104         if (req == NULL) {
1105                 return NULL;
1106         }
1107         state->out_mem_ctx = NULL;
1108         state->dispatch_recv = cli->dispatch_recv;
1109
1110         /* In parameters */
1111
1112         /* Out parameters */
1113
1114         /* Result */
1115         ZERO_STRUCT(state->orig.out.result);
1116
1117         if (DEBUGLEVEL >= 10) {
1118                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleCancel, &state->orig);
1119         }
1120
1121         /* make a temporary copy, that we pass to the dispatch function */
1122         state->tmp = state->orig;
1123
1124         subreq = cli->dispatch_send(state, ev, cli,
1125                                     &ndr_table_dssetup,
1126                                     NDR_DSSETUP_DSROLECANCEL,
1127                                     &state->tmp);
1128         if (tevent_req_nomem(subreq, req)) {
1129                 return tevent_req_post(req, ev);
1130         }
1131         tevent_req_set_callback(subreq, rpccli_dssetup_DsRoleCancel_done, req);
1132         return req;
1133 }
1134
1135 static void rpccli_dssetup_DsRoleCancel_done(struct tevent_req *subreq)
1136 {
1137         struct tevent_req *req = tevent_req_callback_data(
1138                 subreq, struct tevent_req);
1139         struct rpccli_dssetup_DsRoleCancel_state *state = tevent_req_data(
1140                 req, struct rpccli_dssetup_DsRoleCancel_state);
1141         NTSTATUS status;
1142         TALLOC_CTX *mem_ctx;
1143
1144         if (state->out_mem_ctx) {
1145                 mem_ctx = state->out_mem_ctx;
1146         } else {
1147                 mem_ctx = state;
1148         }
1149
1150         status = state->dispatch_recv(subreq, mem_ctx);
1151         TALLOC_FREE(subreq);
1152         if (!NT_STATUS_IS_OK(status)) {
1153                 tevent_req_nterror(req, status);
1154                 return;
1155         }
1156
1157         /* Copy out parameters */
1158
1159         /* Copy result */
1160         state->orig.out.result = state->tmp.out.result;
1161
1162         /* Reset temporary structure */
1163         ZERO_STRUCT(state->tmp);
1164
1165         if (DEBUGLEVEL >= 10) {
1166                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleCancel, &state->orig);
1167         }
1168
1169         tevent_req_done(req);
1170 }
1171
1172 NTSTATUS rpccli_dssetup_DsRoleCancel_recv(struct tevent_req *req,
1173                                           TALLOC_CTX *mem_ctx,
1174                                           WERROR *result)
1175 {
1176         struct rpccli_dssetup_DsRoleCancel_state *state = tevent_req_data(
1177                 req, struct rpccli_dssetup_DsRoleCancel_state);
1178         NTSTATUS status;
1179
1180         if (tevent_req_is_nterror(req, &status)) {
1181                 tevent_req_received(req);
1182                 return status;
1183         }
1184
1185         /* Steal possbile out parameters to the callers context */
1186         talloc_steal(mem_ctx, state->out_mem_ctx);
1187
1188         /* Return result */
1189         *result = state->orig.out.result;
1190
1191         tevent_req_received(req);
1192         return NT_STATUS_OK;
1193 }
1194
1195 NTSTATUS rpccli_dssetup_DsRoleCancel(struct rpc_pipe_client *cli,
1196                                      TALLOC_CTX *mem_ctx,
1197                                      WERROR *werror)
1198 {
1199         struct dssetup_DsRoleCancel r;
1200         NTSTATUS status;
1201
1202         /* In parameters */
1203
1204         if (DEBUGLEVEL >= 10) {
1205                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleCancel, &r);
1206         }
1207
1208         status = cli->dispatch(cli,
1209                                 mem_ctx,
1210                                 &ndr_table_dssetup,
1211                                 NDR_DSSETUP_DSROLECANCEL,
1212                                 &r);
1213
1214         if (!NT_STATUS_IS_OK(status)) {
1215                 return status;
1216         }
1217
1218         if (DEBUGLEVEL >= 10) {
1219                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleCancel, &r);
1220         }
1221
1222         if (NT_STATUS_IS_ERR(status)) {
1223                 return status;
1224         }
1225
1226         /* Return variables */
1227
1228         /* Return result */
1229         if (werror) {
1230                 *werror = r.out.result;
1231         }
1232
1233         return werror_to_ntstatus(r.out.result);
1234 }
1235
1236 struct rpccli_dssetup_DsRoleServerSaveStateForUpgrade_state {
1237         struct dssetup_DsRoleServerSaveStateForUpgrade orig;
1238         struct dssetup_DsRoleServerSaveStateForUpgrade tmp;
1239         TALLOC_CTX *out_mem_ctx;
1240         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1241 };
1242
1243 static void rpccli_dssetup_DsRoleServerSaveStateForUpgrade_done(struct tevent_req *subreq);
1244
1245 struct tevent_req *rpccli_dssetup_DsRoleServerSaveStateForUpgrade_send(TALLOC_CTX *mem_ctx,
1246                                                                        struct tevent_context *ev,
1247                                                                        struct rpc_pipe_client *cli)
1248 {
1249         struct tevent_req *req;
1250         struct rpccli_dssetup_DsRoleServerSaveStateForUpgrade_state *state;
1251         struct tevent_req *subreq;
1252
1253         req = tevent_req_create(mem_ctx, &state,
1254                                 struct rpccli_dssetup_DsRoleServerSaveStateForUpgrade_state);
1255         if (req == NULL) {
1256                 return NULL;
1257         }
1258         state->out_mem_ctx = NULL;
1259         state->dispatch_recv = cli->dispatch_recv;
1260
1261         /* In parameters */
1262
1263         /* Out parameters */
1264
1265         /* Result */
1266         ZERO_STRUCT(state->orig.out.result);
1267
1268         if (DEBUGLEVEL >= 10) {
1269                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleServerSaveStateForUpgrade, &state->orig);
1270         }
1271
1272         /* make a temporary copy, that we pass to the dispatch function */
1273         state->tmp = state->orig;
1274
1275         subreq = cli->dispatch_send(state, ev, cli,
1276                                     &ndr_table_dssetup,
1277                                     NDR_DSSETUP_DSROLESERVERSAVESTATEFORUPGRADE,
1278                                     &state->tmp);
1279         if (tevent_req_nomem(subreq, req)) {
1280                 return tevent_req_post(req, ev);
1281         }
1282         tevent_req_set_callback(subreq, rpccli_dssetup_DsRoleServerSaveStateForUpgrade_done, req);
1283         return req;
1284 }
1285
1286 static void rpccli_dssetup_DsRoleServerSaveStateForUpgrade_done(struct tevent_req *subreq)
1287 {
1288         struct tevent_req *req = tevent_req_callback_data(
1289                 subreq, struct tevent_req);
1290         struct rpccli_dssetup_DsRoleServerSaveStateForUpgrade_state *state = tevent_req_data(
1291                 req, struct rpccli_dssetup_DsRoleServerSaveStateForUpgrade_state);
1292         NTSTATUS status;
1293         TALLOC_CTX *mem_ctx;
1294
1295         if (state->out_mem_ctx) {
1296                 mem_ctx = state->out_mem_ctx;
1297         } else {
1298                 mem_ctx = state;
1299         }
1300
1301         status = state->dispatch_recv(subreq, mem_ctx);
1302         TALLOC_FREE(subreq);
1303         if (!NT_STATUS_IS_OK(status)) {
1304                 tevent_req_nterror(req, status);
1305                 return;
1306         }
1307
1308         /* Copy out parameters */
1309
1310         /* Copy result */
1311         state->orig.out.result = state->tmp.out.result;
1312
1313         /* Reset temporary structure */
1314         ZERO_STRUCT(state->tmp);
1315
1316         if (DEBUGLEVEL >= 10) {
1317                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleServerSaveStateForUpgrade, &state->orig);
1318         }
1319
1320         tevent_req_done(req);
1321 }
1322
1323 NTSTATUS rpccli_dssetup_DsRoleServerSaveStateForUpgrade_recv(struct tevent_req *req,
1324                                                              TALLOC_CTX *mem_ctx,
1325                                                              WERROR *result)
1326 {
1327         struct rpccli_dssetup_DsRoleServerSaveStateForUpgrade_state *state = tevent_req_data(
1328                 req, struct rpccli_dssetup_DsRoleServerSaveStateForUpgrade_state);
1329         NTSTATUS status;
1330
1331         if (tevent_req_is_nterror(req, &status)) {
1332                 tevent_req_received(req);
1333                 return status;
1334         }
1335
1336         /* Steal possbile out parameters to the callers context */
1337         talloc_steal(mem_ctx, state->out_mem_ctx);
1338
1339         /* Return result */
1340         *result = state->orig.out.result;
1341
1342         tevent_req_received(req);
1343         return NT_STATUS_OK;
1344 }
1345
1346 NTSTATUS rpccli_dssetup_DsRoleServerSaveStateForUpgrade(struct rpc_pipe_client *cli,
1347                                                         TALLOC_CTX *mem_ctx,
1348                                                         WERROR *werror)
1349 {
1350         struct dssetup_DsRoleServerSaveStateForUpgrade r;
1351         NTSTATUS status;
1352
1353         /* In parameters */
1354
1355         if (DEBUGLEVEL >= 10) {
1356                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleServerSaveStateForUpgrade, &r);
1357         }
1358
1359         status = cli->dispatch(cli,
1360                                 mem_ctx,
1361                                 &ndr_table_dssetup,
1362                                 NDR_DSSETUP_DSROLESERVERSAVESTATEFORUPGRADE,
1363                                 &r);
1364
1365         if (!NT_STATUS_IS_OK(status)) {
1366                 return status;
1367         }
1368
1369         if (DEBUGLEVEL >= 10) {
1370                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleServerSaveStateForUpgrade, &r);
1371         }
1372
1373         if (NT_STATUS_IS_ERR(status)) {
1374                 return status;
1375         }
1376
1377         /* Return variables */
1378
1379         /* Return result */
1380         if (werror) {
1381                 *werror = r.out.result;
1382         }
1383
1384         return werror_to_ntstatus(r.out.result);
1385 }
1386
1387 struct rpccli_dssetup_DsRoleUpgradeDownlevelServer_state {
1388         struct dssetup_DsRoleUpgradeDownlevelServer orig;
1389         struct dssetup_DsRoleUpgradeDownlevelServer tmp;
1390         TALLOC_CTX *out_mem_ctx;
1391         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1392 };
1393
1394 static void rpccli_dssetup_DsRoleUpgradeDownlevelServer_done(struct tevent_req *subreq);
1395
1396 struct tevent_req *rpccli_dssetup_DsRoleUpgradeDownlevelServer_send(TALLOC_CTX *mem_ctx,
1397                                                                     struct tevent_context *ev,
1398                                                                     struct rpc_pipe_client *cli)
1399 {
1400         struct tevent_req *req;
1401         struct rpccli_dssetup_DsRoleUpgradeDownlevelServer_state *state;
1402         struct tevent_req *subreq;
1403
1404         req = tevent_req_create(mem_ctx, &state,
1405                                 struct rpccli_dssetup_DsRoleUpgradeDownlevelServer_state);
1406         if (req == NULL) {
1407                 return NULL;
1408         }
1409         state->out_mem_ctx = NULL;
1410         state->dispatch_recv = cli->dispatch_recv;
1411
1412         /* In parameters */
1413
1414         /* Out parameters */
1415
1416         /* Result */
1417         ZERO_STRUCT(state->orig.out.result);
1418
1419         if (DEBUGLEVEL >= 10) {
1420                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleUpgradeDownlevelServer, &state->orig);
1421         }
1422
1423         /* make a temporary copy, that we pass to the dispatch function */
1424         state->tmp = state->orig;
1425
1426         subreq = cli->dispatch_send(state, ev, cli,
1427                                     &ndr_table_dssetup,
1428                                     NDR_DSSETUP_DSROLEUPGRADEDOWNLEVELSERVER,
1429                                     &state->tmp);
1430         if (tevent_req_nomem(subreq, req)) {
1431                 return tevent_req_post(req, ev);
1432         }
1433         tevent_req_set_callback(subreq, rpccli_dssetup_DsRoleUpgradeDownlevelServer_done, req);
1434         return req;
1435 }
1436
1437 static void rpccli_dssetup_DsRoleUpgradeDownlevelServer_done(struct tevent_req *subreq)
1438 {
1439         struct tevent_req *req = tevent_req_callback_data(
1440                 subreq, struct tevent_req);
1441         struct rpccli_dssetup_DsRoleUpgradeDownlevelServer_state *state = tevent_req_data(
1442                 req, struct rpccli_dssetup_DsRoleUpgradeDownlevelServer_state);
1443         NTSTATUS status;
1444         TALLOC_CTX *mem_ctx;
1445
1446         if (state->out_mem_ctx) {
1447                 mem_ctx = state->out_mem_ctx;
1448         } else {
1449                 mem_ctx = state;
1450         }
1451
1452         status = state->dispatch_recv(subreq, mem_ctx);
1453         TALLOC_FREE(subreq);
1454         if (!NT_STATUS_IS_OK(status)) {
1455                 tevent_req_nterror(req, status);
1456                 return;
1457         }
1458
1459         /* Copy out parameters */
1460
1461         /* Copy result */
1462         state->orig.out.result = state->tmp.out.result;
1463
1464         /* Reset temporary structure */
1465         ZERO_STRUCT(state->tmp);
1466
1467         if (DEBUGLEVEL >= 10) {
1468                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleUpgradeDownlevelServer, &state->orig);
1469         }
1470
1471         tevent_req_done(req);
1472 }
1473
1474 NTSTATUS rpccli_dssetup_DsRoleUpgradeDownlevelServer_recv(struct tevent_req *req,
1475                                                           TALLOC_CTX *mem_ctx,
1476                                                           WERROR *result)
1477 {
1478         struct rpccli_dssetup_DsRoleUpgradeDownlevelServer_state *state = tevent_req_data(
1479                 req, struct rpccli_dssetup_DsRoleUpgradeDownlevelServer_state);
1480         NTSTATUS status;
1481
1482         if (tevent_req_is_nterror(req, &status)) {
1483                 tevent_req_received(req);
1484                 return status;
1485         }
1486
1487         /* Steal possbile out parameters to the callers context */
1488         talloc_steal(mem_ctx, state->out_mem_ctx);
1489
1490         /* Return result */
1491         *result = state->orig.out.result;
1492
1493         tevent_req_received(req);
1494         return NT_STATUS_OK;
1495 }
1496
1497 NTSTATUS rpccli_dssetup_DsRoleUpgradeDownlevelServer(struct rpc_pipe_client *cli,
1498                                                      TALLOC_CTX *mem_ctx,
1499                                                      WERROR *werror)
1500 {
1501         struct dssetup_DsRoleUpgradeDownlevelServer r;
1502         NTSTATUS status;
1503
1504         /* In parameters */
1505
1506         if (DEBUGLEVEL >= 10) {
1507                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleUpgradeDownlevelServer, &r);
1508         }
1509
1510         status = cli->dispatch(cli,
1511                                 mem_ctx,
1512                                 &ndr_table_dssetup,
1513                                 NDR_DSSETUP_DSROLEUPGRADEDOWNLEVELSERVER,
1514                                 &r);
1515
1516         if (!NT_STATUS_IS_OK(status)) {
1517                 return status;
1518         }
1519
1520         if (DEBUGLEVEL >= 10) {
1521                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleUpgradeDownlevelServer, &r);
1522         }
1523
1524         if (NT_STATUS_IS_ERR(status)) {
1525                 return status;
1526         }
1527
1528         /* Return variables */
1529
1530         /* Return result */
1531         if (werror) {
1532                 *werror = r.out.result;
1533         }
1534
1535         return werror_to_ntstatus(r.out.result);
1536 }
1537
1538 struct rpccli_dssetup_DsRoleAbortDownlevelServerUpgrade_state {
1539         struct dssetup_DsRoleAbortDownlevelServerUpgrade orig;
1540         struct dssetup_DsRoleAbortDownlevelServerUpgrade tmp;
1541         TALLOC_CTX *out_mem_ctx;
1542         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1543 };
1544
1545 static void rpccli_dssetup_DsRoleAbortDownlevelServerUpgrade_done(struct tevent_req *subreq);
1546
1547 struct tevent_req *rpccli_dssetup_DsRoleAbortDownlevelServerUpgrade_send(TALLOC_CTX *mem_ctx,
1548                                                                          struct tevent_context *ev,
1549                                                                          struct rpc_pipe_client *cli)
1550 {
1551         struct tevent_req *req;
1552         struct rpccli_dssetup_DsRoleAbortDownlevelServerUpgrade_state *state;
1553         struct tevent_req *subreq;
1554
1555         req = tevent_req_create(mem_ctx, &state,
1556                                 struct rpccli_dssetup_DsRoleAbortDownlevelServerUpgrade_state);
1557         if (req == NULL) {
1558                 return NULL;
1559         }
1560         state->out_mem_ctx = NULL;
1561         state->dispatch_recv = cli->dispatch_recv;
1562
1563         /* In parameters */
1564
1565         /* Out parameters */
1566
1567         /* Result */
1568         ZERO_STRUCT(state->orig.out.result);
1569
1570         if (DEBUGLEVEL >= 10) {
1571                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleAbortDownlevelServerUpgrade, &state->orig);
1572         }
1573
1574         /* make a temporary copy, that we pass to the dispatch function */
1575         state->tmp = state->orig;
1576
1577         subreq = cli->dispatch_send(state, ev, cli,
1578                                     &ndr_table_dssetup,
1579                                     NDR_DSSETUP_DSROLEABORTDOWNLEVELSERVERUPGRADE,
1580                                     &state->tmp);
1581         if (tevent_req_nomem(subreq, req)) {
1582                 return tevent_req_post(req, ev);
1583         }
1584         tevent_req_set_callback(subreq, rpccli_dssetup_DsRoleAbortDownlevelServerUpgrade_done, req);
1585         return req;
1586 }
1587
1588 static void rpccli_dssetup_DsRoleAbortDownlevelServerUpgrade_done(struct tevent_req *subreq)
1589 {
1590         struct tevent_req *req = tevent_req_callback_data(
1591                 subreq, struct tevent_req);
1592         struct rpccli_dssetup_DsRoleAbortDownlevelServerUpgrade_state *state = tevent_req_data(
1593                 req, struct rpccli_dssetup_DsRoleAbortDownlevelServerUpgrade_state);
1594         NTSTATUS status;
1595         TALLOC_CTX *mem_ctx;
1596
1597         if (state->out_mem_ctx) {
1598                 mem_ctx = state->out_mem_ctx;
1599         } else {
1600                 mem_ctx = state;
1601         }
1602
1603         status = state->dispatch_recv(subreq, mem_ctx);
1604         TALLOC_FREE(subreq);
1605         if (!NT_STATUS_IS_OK(status)) {
1606                 tevent_req_nterror(req, status);
1607                 return;
1608         }
1609
1610         /* Copy out parameters */
1611
1612         /* Copy result */
1613         state->orig.out.result = state->tmp.out.result;
1614
1615         /* Reset temporary structure */
1616         ZERO_STRUCT(state->tmp);
1617
1618         if (DEBUGLEVEL >= 10) {
1619                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleAbortDownlevelServerUpgrade, &state->orig);
1620         }
1621
1622         tevent_req_done(req);
1623 }
1624
1625 NTSTATUS rpccli_dssetup_DsRoleAbortDownlevelServerUpgrade_recv(struct tevent_req *req,
1626                                                                TALLOC_CTX *mem_ctx,
1627                                                                WERROR *result)
1628 {
1629         struct rpccli_dssetup_DsRoleAbortDownlevelServerUpgrade_state *state = tevent_req_data(
1630                 req, struct rpccli_dssetup_DsRoleAbortDownlevelServerUpgrade_state);
1631         NTSTATUS status;
1632
1633         if (tevent_req_is_nterror(req, &status)) {
1634                 tevent_req_received(req);
1635                 return status;
1636         }
1637
1638         /* Steal possbile out parameters to the callers context */
1639         talloc_steal(mem_ctx, state->out_mem_ctx);
1640
1641         /* Return result */
1642         *result = state->orig.out.result;
1643
1644         tevent_req_received(req);
1645         return NT_STATUS_OK;
1646 }
1647
1648 NTSTATUS rpccli_dssetup_DsRoleAbortDownlevelServerUpgrade(struct rpc_pipe_client *cli,
1649                                                           TALLOC_CTX *mem_ctx,
1650                                                           WERROR *werror)
1651 {
1652         struct dssetup_DsRoleAbortDownlevelServerUpgrade r;
1653         NTSTATUS status;
1654
1655         /* In parameters */
1656
1657         if (DEBUGLEVEL >= 10) {
1658                 NDR_PRINT_IN_DEBUG(dssetup_DsRoleAbortDownlevelServerUpgrade, &r);
1659         }
1660
1661         status = cli->dispatch(cli,
1662                                 mem_ctx,
1663                                 &ndr_table_dssetup,
1664                                 NDR_DSSETUP_DSROLEABORTDOWNLEVELSERVERUPGRADE,
1665                                 &r);
1666
1667         if (!NT_STATUS_IS_OK(status)) {
1668                 return status;
1669         }
1670
1671         if (DEBUGLEVEL >= 10) {
1672                 NDR_PRINT_OUT_DEBUG(dssetup_DsRoleAbortDownlevelServerUpgrade, &r);
1673         }
1674
1675         if (NT_STATUS_IS_ERR(status)) {
1676                 return status;
1677         }
1678
1679         /* Return variables */
1680
1681         /* Return result */
1682         if (werror) {
1683                 *werror = r.out.result;
1684         }
1685
1686         return werror_to_ntstatus(r.out.result);
1687 }
1688