librpc/gen_ndr/cli_svcctl.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_svcctl.h"
   8
   9 struct rpccli_svcctl_CloseServiceHandle_state {
  10         struct svcctl_CloseServiceHandle orig;
  11         struct svcctl_CloseServiceHandle 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_svcctl_CloseServiceHandle_done(struct tevent_req *subreq);
  17
  18 struct tevent_req *rpccli_svcctl_CloseServiceHandle_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_svcctl_CloseServiceHandle_state *state;
  25         struct tevent_req *subreq;
  26
  27         req = tevent_req_create(mem_ctx, &state,
  28                                 struct rpccli_svcctl_CloseServiceHandle_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         if (DEBUGLEVEL >= 10) {
  45                 NDR_PRINT_IN_DEBUG(svcctl_CloseServiceHandle, &state->orig);
  46         }
  47
  48         state->out_mem_ctx = talloc_named_const(state, 0,
  49                              "rpccli_svcctl_CloseServiceHandle_out_memory");
  50         if (tevent_req_nomem(state->out_mem_ctx, req)) {
  51                 return tevent_req_post(req, ev);
  52         }
  53
  54         /* make a temporary copy, that we pass to the dispatch function */
  55         state->tmp = state->orig;
  56
  57         subreq = cli->dispatch_send(state, ev, cli,
  58                                     &ndr_table_svcctl,
  59                                     NDR_SVCCTL_CLOSESERVICEHANDLE,
  60                                     &state->tmp);
  61         if (tevent_req_nomem(subreq, req)) {
  62                 return tevent_req_post(req, ev);
  63         }
  64         tevent_req_set_callback(subreq, rpccli_svcctl_CloseServiceHandle_done, req);
  65         return req;
  66 }
  67
  68 static void rpccli_svcctl_CloseServiceHandle_done(struct tevent_req *subreq)
  69 {
  70         struct tevent_req *req = tevent_req_callback_data(
  71                 subreq, struct tevent_req);
  72         struct rpccli_svcctl_CloseServiceHandle_state *state = tevent_req_data(
  73                 req, struct rpccli_svcctl_CloseServiceHandle_state);
  74         NTSTATUS status;
  75         TALLOC_CTX *mem_ctx;
  76
  77         if (state->out_mem_ctx) {
  78                 mem_ctx = state->out_mem_ctx;
  79         } else {
  80                 mem_ctx = state;
  81         }
  82
  83         status = state->dispatch_recv(subreq, mem_ctx);
  84         TALLOC_FREE(subreq);
  85         if (!NT_STATUS_IS_OK(status)) {
  86                 tevent_req_nterror(req, status);
  87                 return;
  88         }
  89
  90         /* Copy out parameters */
  91         *state->orig.out.handle = *state->tmp.out.handle;
  92
  93         /* Copy result */
  94         state->orig.out.result = state->tmp.out.result;
  95
  96         /* Reset temporary structure */
  97         ZERO_STRUCT(state->tmp);
  98
  99         if (DEBUGLEVEL >= 10) {
 100                 NDR_PRINT_OUT_DEBUG(svcctl_CloseServiceHandle, &state->orig);
 101         }
 102
 103         tevent_req_done(req);
 104 }
 105
 106 NTSTATUS rpccli_svcctl_CloseServiceHandle_recv(struct tevent_req *req,
 107                                                TALLOC_CTX *mem_ctx,
 108                                                WERROR *result)
 109 {
 110         struct rpccli_svcctl_CloseServiceHandle_state *state = tevent_req_data(
 111                 req, struct rpccli_svcctl_CloseServiceHandle_state);
 112         NTSTATUS status;
 113
 114         if (tevent_req_is_nterror(req, &status)) {
 115                 tevent_req_received(req);
 116                 return status;
 117         }
 118
 119         /* Steal possbile out parameters to the callers context */
 120         talloc_steal(mem_ctx, state->out_mem_ctx);
 121
 122         /* Return result */
 123         *result = state->orig.out.result;
 124
 125         tevent_req_received(req);
 126         return NT_STATUS_OK;
 127 }
 128
 129 NTSTATUS rpccli_svcctl_CloseServiceHandle(struct rpc_pipe_client *cli,
 130                                           TALLOC_CTX *mem_ctx,
 131                                           struct policy_handle *handle /* [in,out] [ref] */,
 132                                           WERROR *werror)
 133 {
 134         struct svcctl_CloseServiceHandle r;
 135         NTSTATUS status;
 136
 137         /* In parameters */
 138         r.in.handle = handle;
 139
 140         if (DEBUGLEVEL >= 10) {
 141                 NDR_PRINT_IN_DEBUG(svcctl_CloseServiceHandle, &r);
 142         }
 143
 144         status = cli->dispatch(cli,
 145                                 mem_ctx,
 146                                 &ndr_table_svcctl,
 147                                 NDR_SVCCTL_CLOSESERVICEHANDLE,
 148                                 &r);
 149
 150         if (!NT_STATUS_IS_OK(status)) {
 151                 return status;
 152         }
 153
 154         if (DEBUGLEVEL >= 10) {
 155                 NDR_PRINT_OUT_DEBUG(svcctl_CloseServiceHandle, &r);
 156         }
 157
 158         if (NT_STATUS_IS_ERR(status)) {
 159                 return status;
 160         }
 161
 162         /* Return variables */
 163         *handle = *r.out.handle;
 164
 165         /* Return result */
 166         if (werror) {
 167                 *werror = r.out.result;
 168         }
 169
 170         return werror_to_ntstatus(r.out.result);
 171 }
 172
 173 struct rpccli_svcctl_ControlService_state {
 174         struct svcctl_ControlService orig;
 175         struct svcctl_ControlService tmp;
 176         TALLOC_CTX *out_mem_ctx;
 177         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 178 };
 179
 180 static void rpccli_svcctl_ControlService_done(struct tevent_req *subreq);
 181
 182 struct tevent_req *rpccli_svcctl_ControlService_send(TALLOC_CTX *mem_ctx,
 183                                                      struct tevent_context *ev,
 184                                                      struct rpc_pipe_client *cli,
 185                                                      struct policy_handle *_handle /* [in] [ref] */,
 186                                                      enum SERVICE_CONTROL _control /* [in]  */,
 187                                                      struct SERVICE_STATUS *_service_status /* [out] [ref] */)
 188 {
 189         struct tevent_req *req;
 190         struct rpccli_svcctl_ControlService_state *state;
 191         struct tevent_req *subreq;
 192
 193         req = tevent_req_create(mem_ctx, &state,
 194                                 struct rpccli_svcctl_ControlService_state);
 195         if (req == NULL) {
 196                 return NULL;
 197         }
 198         state->out_mem_ctx = NULL;
 199         state->dispatch_recv = cli->dispatch_recv;
 200
 201         /* In parameters */
 202         state->orig.in.handle = _handle;
 203         state->orig.in.control = _control;
 204
 205         /* Out parameters */
 206         state->orig.out.service_status = _service_status;
 207
 208         /* Result */
 209         ZERO_STRUCT(state->orig.out.result);
 210
 211         if (DEBUGLEVEL >= 10) {
 212                 NDR_PRINT_IN_DEBUG(svcctl_ControlService, &state->orig);
 213         }
 214
 215         state->out_mem_ctx = talloc_named_const(state, 0,
 216                              "rpccli_svcctl_ControlService_out_memory");
 217         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 218                 return tevent_req_post(req, ev);
 219         }
 220
 221         /* make a temporary copy, that we pass to the dispatch function */
 222         state->tmp = state->orig;
 223
 224         subreq = cli->dispatch_send(state, ev, cli,
 225                                     &ndr_table_svcctl,
 226                                     NDR_SVCCTL_CONTROLSERVICE,
 227                                     &state->tmp);
 228         if (tevent_req_nomem(subreq, req)) {
 229                 return tevent_req_post(req, ev);
 230         }
 231         tevent_req_set_callback(subreq, rpccli_svcctl_ControlService_done, req);
 232         return req;
 233 }
 234
 235 static void rpccli_svcctl_ControlService_done(struct tevent_req *subreq)
 236 {
 237         struct tevent_req *req = tevent_req_callback_data(
 238                 subreq, struct tevent_req);
 239         struct rpccli_svcctl_ControlService_state *state = tevent_req_data(
 240                 req, struct rpccli_svcctl_ControlService_state);
 241         NTSTATUS status;
 242         TALLOC_CTX *mem_ctx;
 243
 244         if (state->out_mem_ctx) {
 245                 mem_ctx = state->out_mem_ctx;
 246         } else {
 247                 mem_ctx = state;
 248         }
 249
 250         status = state->dispatch_recv(subreq, mem_ctx);
 251         TALLOC_FREE(subreq);
 252         if (!NT_STATUS_IS_OK(status)) {
 253                 tevent_req_nterror(req, status);
 254                 return;
 255         }
 256
 257         /* Copy out parameters */
 258         *state->orig.out.service_status = *state->tmp.out.service_status;
 259
 260         /* Copy result */
 261         state->orig.out.result = state->tmp.out.result;
 262
 263         /* Reset temporary structure */
 264         ZERO_STRUCT(state->tmp);
 265
 266         if (DEBUGLEVEL >= 10) {
 267                 NDR_PRINT_OUT_DEBUG(svcctl_ControlService, &state->orig);
 268         }
 269
 270         tevent_req_done(req);
 271 }
 272
 273 NTSTATUS rpccli_svcctl_ControlService_recv(struct tevent_req *req,
 274                                            TALLOC_CTX *mem_ctx,
 275                                            WERROR *result)
 276 {
 277         struct rpccli_svcctl_ControlService_state *state = tevent_req_data(
 278                 req, struct rpccli_svcctl_ControlService_state);
 279         NTSTATUS status;
 280
 281         if (tevent_req_is_nterror(req, &status)) {
 282                 tevent_req_received(req);
 283                 return status;
 284         }
 285
 286         /* Steal possbile out parameters to the callers context */
 287         talloc_steal(mem_ctx, state->out_mem_ctx);
 288
 289         /* Return result */
 290         *result = state->orig.out.result;
 291
 292         tevent_req_received(req);
 293         return NT_STATUS_OK;
 294 }
 295
 296 NTSTATUS rpccli_svcctl_ControlService(struct rpc_pipe_client *cli,
 297                                       TALLOC_CTX *mem_ctx,
 298                                       struct policy_handle *handle /* [in] [ref] */,
 299                                       enum SERVICE_CONTROL control /* [in]  */,
 300                                       struct SERVICE_STATUS *service_status /* [out] [ref] */,
 301                                       WERROR *werror)
 302 {
 303         struct svcctl_ControlService r;
 304         NTSTATUS status;
 305
 306         /* In parameters */
 307         r.in.handle = handle;
 308         r.in.control = control;
 309
 310         if (DEBUGLEVEL >= 10) {
 311                 NDR_PRINT_IN_DEBUG(svcctl_ControlService, &r);
 312         }
 313
 314         status = cli->dispatch(cli,
 315                                 mem_ctx,
 316                                 &ndr_table_svcctl,
 317                                 NDR_SVCCTL_CONTROLSERVICE,
 318                                 &r);
 319
 320         if (!NT_STATUS_IS_OK(status)) {
 321                 return status;
 322         }
 323
 324         if (DEBUGLEVEL >= 10) {
 325                 NDR_PRINT_OUT_DEBUG(svcctl_ControlService, &r);
 326         }
 327
 328         if (NT_STATUS_IS_ERR(status)) {
 329                 return status;
 330         }
 331
 332         /* Return variables */
 333         *service_status = *r.out.service_status;
 334
 335         /* Return result */
 336         if (werror) {
 337                 *werror = r.out.result;
 338         }
 339
 340         return werror_to_ntstatus(r.out.result);
 341 }
 342
 343 struct rpccli_svcctl_DeleteService_state {
 344         struct svcctl_DeleteService orig;
 345         struct svcctl_DeleteService tmp;
 346         TALLOC_CTX *out_mem_ctx;
 347         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 348 };
 349
 350 static void rpccli_svcctl_DeleteService_done(struct tevent_req *subreq);
 351
 352 struct tevent_req *rpccli_svcctl_DeleteService_send(TALLOC_CTX *mem_ctx,
 353                                                     struct tevent_context *ev,
 354                                                     struct rpc_pipe_client *cli,
 355                                                     struct policy_handle *_handle /* [in] [ref] */)
 356 {
 357         struct tevent_req *req;
 358         struct rpccli_svcctl_DeleteService_state *state;
 359         struct tevent_req *subreq;
 360
 361         req = tevent_req_create(mem_ctx, &state,
 362                                 struct rpccli_svcctl_DeleteService_state);
 363         if (req == NULL) {
 364                 return NULL;
 365         }
 366         state->out_mem_ctx = NULL;
 367         state->dispatch_recv = cli->dispatch_recv;
 368
 369         /* In parameters */
 370         state->orig.in.handle = _handle;
 371
 372         /* Out parameters */
 373
 374         /* Result */
 375         ZERO_STRUCT(state->orig.out.result);
 376
 377         if (DEBUGLEVEL >= 10) {
 378                 NDR_PRINT_IN_DEBUG(svcctl_DeleteService, &state->orig);
 379         }
 380
 381         /* make a temporary copy, that we pass to the dispatch function */
 382         state->tmp = state->orig;
 383
 384         subreq = cli->dispatch_send(state, ev, cli,
 385                                     &ndr_table_svcctl,
 386                                     NDR_SVCCTL_DELETESERVICE,
 387                                     &state->tmp);
 388         if (tevent_req_nomem(subreq, req)) {
 389                 return tevent_req_post(req, ev);
 390         }
 391         tevent_req_set_callback(subreq, rpccli_svcctl_DeleteService_done, req);
 392         return req;
 393 }
 394
 395 static void rpccli_svcctl_DeleteService_done(struct tevent_req *subreq)
 396 {
 397         struct tevent_req *req = tevent_req_callback_data(
 398                 subreq, struct tevent_req);
 399         struct rpccli_svcctl_DeleteService_state *state = tevent_req_data(
 400                 req, struct rpccli_svcctl_DeleteService_state);
 401         NTSTATUS status;
 402         TALLOC_CTX *mem_ctx;
 403
 404         if (state->out_mem_ctx) {
 405                 mem_ctx = state->out_mem_ctx;
 406         } else {
 407                 mem_ctx = state;
 408         }
 409
 410         status = state->dispatch_recv(subreq, mem_ctx);
 411         TALLOC_FREE(subreq);
 412         if (!NT_STATUS_IS_OK(status)) {
 413                 tevent_req_nterror(req, status);
 414                 return;
 415         }
 416
 417         /* Copy out parameters */
 418
 419         /* Copy result */
 420         state->orig.out.result = state->tmp.out.result;
 421
 422         /* Reset temporary structure */
 423         ZERO_STRUCT(state->tmp);
 424
 425         if (DEBUGLEVEL >= 10) {
 426                 NDR_PRINT_OUT_DEBUG(svcctl_DeleteService, &state->orig);
 427         }
 428
 429         tevent_req_done(req);
 430 }
 431
 432 NTSTATUS rpccli_svcctl_DeleteService_recv(struct tevent_req *req,
 433                                           TALLOC_CTX *mem_ctx,
 434                                           WERROR *result)
 435 {
 436         struct rpccli_svcctl_DeleteService_state *state = tevent_req_data(
 437                 req, struct rpccli_svcctl_DeleteService_state);
 438         NTSTATUS status;
 439
 440         if (tevent_req_is_nterror(req, &status)) {
 441                 tevent_req_received(req);
 442                 return status;
 443         }
 444
 445         /* Steal possbile out parameters to the callers context */
 446         talloc_steal(mem_ctx, state->out_mem_ctx);
 447
 448         /* Return result */
 449         *result = state->orig.out.result;
 450
 451         tevent_req_received(req);
 452         return NT_STATUS_OK;
 453 }
 454
 455 NTSTATUS rpccli_svcctl_DeleteService(struct rpc_pipe_client *cli,
 456                                      TALLOC_CTX *mem_ctx,
 457                                      struct policy_handle *handle /* [in] [ref] */,
 458                                      WERROR *werror)
 459 {
 460         struct svcctl_DeleteService r;
 461         NTSTATUS status;
 462
 463         /* In parameters */
 464         r.in.handle = handle;
 465
 466         if (DEBUGLEVEL >= 10) {
 467                 NDR_PRINT_IN_DEBUG(svcctl_DeleteService, &r);
 468         }
 469
 470         status = cli->dispatch(cli,
 471                                 mem_ctx,
 472                                 &ndr_table_svcctl,
 473                                 NDR_SVCCTL_DELETESERVICE,
 474                                 &r);
 475
 476         if (!NT_STATUS_IS_OK(status)) {
 477                 return status;
 478         }
 479
 480         if (DEBUGLEVEL >= 10) {
 481                 NDR_PRINT_OUT_DEBUG(svcctl_DeleteService, &r);
 482         }
 483
 484         if (NT_STATUS_IS_ERR(status)) {
 485                 return status;
 486         }
 487
 488         /* Return variables */
 489
 490         /* Return result */
 491         if (werror) {
 492                 *werror = r.out.result;
 493         }
 494
 495         return werror_to_ntstatus(r.out.result);
 496 }
 497
 498 struct rpccli_svcctl_LockServiceDatabase_state {
 499         struct svcctl_LockServiceDatabase orig;
 500         struct svcctl_LockServiceDatabase tmp;
 501         TALLOC_CTX *out_mem_ctx;
 502         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 503 };
 504
 505 static void rpccli_svcctl_LockServiceDatabase_done(struct tevent_req *subreq);
 506
 507 struct tevent_req *rpccli_svcctl_LockServiceDatabase_send(TALLOC_CTX *mem_ctx,
 508                                                           struct tevent_context *ev,
 509                                                           struct rpc_pipe_client *cli,
 510                                                           struct policy_handle *_handle /* [in] [ref] */,
 511                                                           struct policy_handle *_lock /* [out] [ref] */)
 512 {
 513         struct tevent_req *req;
 514         struct rpccli_svcctl_LockServiceDatabase_state *state;
 515         struct tevent_req *subreq;
 516
 517         req = tevent_req_create(mem_ctx, &state,
 518                                 struct rpccli_svcctl_LockServiceDatabase_state);
 519         if (req == NULL) {
 520                 return NULL;
 521         }
 522         state->out_mem_ctx = NULL;
 523         state->dispatch_recv = cli->dispatch_recv;
 524
 525         /* In parameters */
 526         state->orig.in.handle = _handle;
 527
 528         /* Out parameters */
 529         state->orig.out.lock = _lock;
 530
 531         /* Result */
 532         ZERO_STRUCT(state->orig.out.result);
 533
 534         if (DEBUGLEVEL >= 10) {
 535                 NDR_PRINT_IN_DEBUG(svcctl_LockServiceDatabase, &state->orig);
 536         }
 537
 538         state->out_mem_ctx = talloc_named_const(state, 0,
 539                              "rpccli_svcctl_LockServiceDatabase_out_memory");
 540         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 541                 return tevent_req_post(req, ev);
 542         }
 543
 544         /* make a temporary copy, that we pass to the dispatch function */
 545         state->tmp = state->orig;
 546
 547         subreq = cli->dispatch_send(state, ev, cli,
 548                                     &ndr_table_svcctl,
 549                                     NDR_SVCCTL_LOCKSERVICEDATABASE,
 550                                     &state->tmp);
 551         if (tevent_req_nomem(subreq, req)) {
 552                 return tevent_req_post(req, ev);
 553         }
 554         tevent_req_set_callback(subreq, rpccli_svcctl_LockServiceDatabase_done, req);
 555         return req;
 556 }
 557
 558 static void rpccli_svcctl_LockServiceDatabase_done(struct tevent_req *subreq)
 559 {
 560         struct tevent_req *req = tevent_req_callback_data(
 561                 subreq, struct tevent_req);
 562         struct rpccli_svcctl_LockServiceDatabase_state *state = tevent_req_data(
 563                 req, struct rpccli_svcctl_LockServiceDatabase_state);
 564         NTSTATUS status;
 565         TALLOC_CTX *mem_ctx;
 566
 567         if (state->out_mem_ctx) {
 568                 mem_ctx = state->out_mem_ctx;
 569         } else {
 570                 mem_ctx = state;
 571         }
 572
 573         status = state->dispatch_recv(subreq, mem_ctx);
 574         TALLOC_FREE(subreq);
 575         if (!NT_STATUS_IS_OK(status)) {
 576                 tevent_req_nterror(req, status);
 577                 return;
 578         }
 579
 580         /* Copy out parameters */
 581         *state->orig.out.lock = *state->tmp.out.lock;
 582
 583         /* Copy result */
 584         state->orig.out.result = state->tmp.out.result;
 585
 586         /* Reset temporary structure */
 587         ZERO_STRUCT(state->tmp);
 588
 589         if (DEBUGLEVEL >= 10) {
 590                 NDR_PRINT_OUT_DEBUG(svcctl_LockServiceDatabase, &state->orig);
 591         }
 592
 593         tevent_req_done(req);
 594 }
 595
 596 NTSTATUS rpccli_svcctl_LockServiceDatabase_recv(struct tevent_req *req,
 597                                                 TALLOC_CTX *mem_ctx,
 598                                                 WERROR *result)
 599 {
 600         struct rpccli_svcctl_LockServiceDatabase_state *state = tevent_req_data(
 601                 req, struct rpccli_svcctl_LockServiceDatabase_state);
 602         NTSTATUS status;
 603
 604         if (tevent_req_is_nterror(req, &status)) {
 605                 tevent_req_received(req);
 606                 return status;
 607         }
 608
 609         /* Steal possbile out parameters to the callers context */
 610         talloc_steal(mem_ctx, state->out_mem_ctx);
 611
 612         /* Return result */
 613         *result = state->orig.out.result;
 614
 615         tevent_req_received(req);
 616         return NT_STATUS_OK;
 617 }
 618
 619 NTSTATUS rpccli_svcctl_LockServiceDatabase(struct rpc_pipe_client *cli,
 620                                            TALLOC_CTX *mem_ctx,
 621                                            struct policy_handle *handle /* [in] [ref] */,
 622                                            struct policy_handle *lock /* [out] [ref] */,
 623                                            WERROR *werror)
 624 {
 625         struct svcctl_LockServiceDatabase r;
 626         NTSTATUS status;
 627
 628         /* In parameters */
 629         r.in.handle = handle;
 630
 631         if (DEBUGLEVEL >= 10) {
 632                 NDR_PRINT_IN_DEBUG(svcctl_LockServiceDatabase, &r);
 633         }
 634
 635         status = cli->dispatch(cli,
 636                                 mem_ctx,
 637                                 &ndr_table_svcctl,
 638                                 NDR_SVCCTL_LOCKSERVICEDATABASE,
 639                                 &r);
 640
 641         if (!NT_STATUS_IS_OK(status)) {
 642                 return status;
 643         }
 644
 645         if (DEBUGLEVEL >= 10) {
 646                 NDR_PRINT_OUT_DEBUG(svcctl_LockServiceDatabase, &r);
 647         }
 648
 649         if (NT_STATUS_IS_ERR(status)) {
 650                 return status;
 651         }
 652
 653         /* Return variables */
 654         *lock = *r.out.lock;
 655
 656         /* Return result */
 657         if (werror) {
 658                 *werror = r.out.result;
 659         }
 660
 661         return werror_to_ntstatus(r.out.result);
 662 }
 663
 664 struct rpccli_svcctl_QueryServiceObjectSecurity_state {
 665         struct svcctl_QueryServiceObjectSecurity orig;
 666         struct svcctl_QueryServiceObjectSecurity tmp;
 667         TALLOC_CTX *out_mem_ctx;
 668         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 669 };
 670
 671 static void rpccli_svcctl_QueryServiceObjectSecurity_done(struct tevent_req *subreq);
 672
 673 struct tevent_req *rpccli_svcctl_QueryServiceObjectSecurity_send(TALLOC_CTX *mem_ctx,
 674                                                                  struct tevent_context *ev,
 675                                                                  struct rpc_pipe_client *cli,
 676                                                                  struct policy_handle *_handle /* [in] [ref] */,
 677                                                                  uint32_t _security_flags /* [in]  */,
 678                                                                  uint8_t *_buffer /* [out] [ref,size_is(offered)] */,
 679                                                                  uint32_t _offered /* [in] [range(0,0x40000)] */,
 680                                                                  uint32_t *_needed /* [out] [ref,range(0,0x40000)] */)
 681 {
 682         struct tevent_req *req;
 683         struct rpccli_svcctl_QueryServiceObjectSecurity_state *state;
 684         struct tevent_req *subreq;
 685
 686         req = tevent_req_create(mem_ctx, &state,
 687                                 struct rpccli_svcctl_QueryServiceObjectSecurity_state);
 688         if (req == NULL) {
 689                 return NULL;
 690         }
 691         state->out_mem_ctx = NULL;
 692         state->dispatch_recv = cli->dispatch_recv;
 693
 694         /* In parameters */
 695         state->orig.in.handle = _handle;
 696         state->orig.in.security_flags = _security_flags;
 697         state->orig.in.offered = _offered;
 698
 699         /* Out parameters */
 700         state->orig.out.buffer = _buffer;
 701         state->orig.out.needed = _needed;
 702
 703         /* Result */
 704         ZERO_STRUCT(state->orig.out.result);
 705
 706         if (DEBUGLEVEL >= 10) {
 707                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceObjectSecurity, &state->orig);
 708         }
 709
 710         state->out_mem_ctx = talloc_named_const(state, 0,
 711                              "rpccli_svcctl_QueryServiceObjectSecurity_out_memory");
 712         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 713                 return tevent_req_post(req, ev);
 714         }
 715
 716         /* make a temporary copy, that we pass to the dispatch function */
 717         state->tmp = state->orig;
 718
 719         subreq = cli->dispatch_send(state, ev, cli,
 720                                     &ndr_table_svcctl,
 721                                     NDR_SVCCTL_QUERYSERVICEOBJECTSECURITY,
 722                                     &state->tmp);
 723         if (tevent_req_nomem(subreq, req)) {
 724                 return tevent_req_post(req, ev);
 725         }
 726         tevent_req_set_callback(subreq, rpccli_svcctl_QueryServiceObjectSecurity_done, req);
 727         return req;
 728 }
 729
 730 static void rpccli_svcctl_QueryServiceObjectSecurity_done(struct tevent_req *subreq)
 731 {
 732         struct tevent_req *req = tevent_req_callback_data(
 733                 subreq, struct tevent_req);
 734         struct rpccli_svcctl_QueryServiceObjectSecurity_state *state = tevent_req_data(
 735                 req, struct rpccli_svcctl_QueryServiceObjectSecurity_state);
 736         NTSTATUS status;
 737         TALLOC_CTX *mem_ctx;
 738
 739         if (state->out_mem_ctx) {
 740                 mem_ctx = state->out_mem_ctx;
 741         } else {
 742                 mem_ctx = state;
 743         }
 744
 745         status = state->dispatch_recv(subreq, mem_ctx);
 746         TALLOC_FREE(subreq);
 747         if (!NT_STATUS_IS_OK(status)) {
 748                 tevent_req_nterror(req, status);
 749                 return;
 750         }
 751
 752         /* Copy out parameters */
 753         memcpy(state->orig.out.buffer, state->tmp.out.buffer, state->tmp.in.offered * sizeof(*state->orig.out.buffer));
 754         *state->orig.out.needed = *state->tmp.out.needed;
 755
 756         /* Copy result */
 757         state->orig.out.result = state->tmp.out.result;
 758
 759         /* Reset temporary structure */
 760         ZERO_STRUCT(state->tmp);
 761
 762         if (DEBUGLEVEL >= 10) {
 763                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceObjectSecurity, &state->orig);
 764         }
 765
 766         tevent_req_done(req);
 767 }
 768
 769 NTSTATUS rpccli_svcctl_QueryServiceObjectSecurity_recv(struct tevent_req *req,
 770                                                        TALLOC_CTX *mem_ctx,
 771                                                        WERROR *result)
 772 {
 773         struct rpccli_svcctl_QueryServiceObjectSecurity_state *state = tevent_req_data(
 774                 req, struct rpccli_svcctl_QueryServiceObjectSecurity_state);
 775         NTSTATUS status;
 776
 777         if (tevent_req_is_nterror(req, &status)) {
 778                 tevent_req_received(req);
 779                 return status;
 780         }
 781
 782         /* Steal possbile out parameters to the callers context */
 783         talloc_steal(mem_ctx, state->out_mem_ctx);
 784
 785         /* Return result */
 786         *result = state->orig.out.result;
 787
 788         tevent_req_received(req);
 789         return NT_STATUS_OK;
 790 }
 791
 792 NTSTATUS rpccli_svcctl_QueryServiceObjectSecurity(struct rpc_pipe_client *cli,
 793                                                   TALLOC_CTX *mem_ctx,
 794                                                   struct policy_handle *handle /* [in] [ref] */,
 795                                                   uint32_t security_flags /* [in]  */,
 796                                                   uint8_t *buffer /* [out] [ref,size_is(offered)] */,
 797                                                   uint32_t offered /* [in] [range(0,0x40000)] */,
 798                                                   uint32_t *needed /* [out] [ref,range(0,0x40000)] */,
 799                                                   WERROR *werror)
 800 {
 801         struct svcctl_QueryServiceObjectSecurity r;
 802         NTSTATUS status;
 803
 804         /* In parameters */
 805         r.in.handle = handle;
 806         r.in.security_flags = security_flags;
 807         r.in.offered = offered;
 808
 809         if (DEBUGLEVEL >= 10) {
 810                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceObjectSecurity, &r);
 811         }
 812
 813         status = cli->dispatch(cli,
 814                                 mem_ctx,
 815                                 &ndr_table_svcctl,
 816                                 NDR_SVCCTL_QUERYSERVICEOBJECTSECURITY,
 817                                 &r);
 818
 819         if (!NT_STATUS_IS_OK(status)) {
 820                 return status;
 821         }
 822
 823         if (DEBUGLEVEL >= 10) {
 824                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceObjectSecurity, &r);
 825         }
 826
 827         if (NT_STATUS_IS_ERR(status)) {
 828                 return status;
 829         }
 830
 831         /* Return variables */
 832         memcpy(buffer, r.out.buffer, r.in.offered * sizeof(*buffer));
 833         *needed = *r.out.needed;
 834
 835         /* Return result */
 836         if (werror) {
 837                 *werror = r.out.result;
 838         }
 839
 840         return werror_to_ntstatus(r.out.result);
 841 }
 842
 843 struct rpccli_svcctl_SetServiceObjectSecurity_state {
 844         struct svcctl_SetServiceObjectSecurity orig;
 845         struct svcctl_SetServiceObjectSecurity tmp;
 846         TALLOC_CTX *out_mem_ctx;
 847         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 848 };
 849
 850 static void rpccli_svcctl_SetServiceObjectSecurity_done(struct tevent_req *subreq);
 851
 852 struct tevent_req *rpccli_svcctl_SetServiceObjectSecurity_send(TALLOC_CTX *mem_ctx,
 853                                                                struct tevent_context *ev,
 854                                                                struct rpc_pipe_client *cli,
 855                                                                struct policy_handle *_handle /* [in] [ref] */,
 856                                                                uint32_t _security_flags /* [in]  */,
 857                                                                uint8_t *_buffer /* [in] [ref,size_is(offered)] */,
 858                                                                uint32_t _offered /* [in]  */)
 859 {
 860         struct tevent_req *req;
 861         struct rpccli_svcctl_SetServiceObjectSecurity_state *state;
 862         struct tevent_req *subreq;
 863
 864         req = tevent_req_create(mem_ctx, &state,
 865                                 struct rpccli_svcctl_SetServiceObjectSecurity_state);
 866         if (req == NULL) {
 867                 return NULL;
 868         }
 869         state->out_mem_ctx = NULL;
 870         state->dispatch_recv = cli->dispatch_recv;
 871
 872         /* In parameters */
 873         state->orig.in.handle = _handle;
 874         state->orig.in.security_flags = _security_flags;
 875         state->orig.in.buffer = _buffer;
 876         state->orig.in.offered = _offered;
 877
 878         /* Out parameters */
 879
 880         /* Result */
 881         ZERO_STRUCT(state->orig.out.result);
 882
 883         if (DEBUGLEVEL >= 10) {
 884                 NDR_PRINT_IN_DEBUG(svcctl_SetServiceObjectSecurity, &state->orig);
 885         }
 886
 887         /* make a temporary copy, that we pass to the dispatch function */
 888         state->tmp = state->orig;
 889
 890         subreq = cli->dispatch_send(state, ev, cli,
 891                                     &ndr_table_svcctl,
 892                                     NDR_SVCCTL_SETSERVICEOBJECTSECURITY,
 893                                     &state->tmp);
 894         if (tevent_req_nomem(subreq, req)) {
 895                 return tevent_req_post(req, ev);
 896         }
 897         tevent_req_set_callback(subreq, rpccli_svcctl_SetServiceObjectSecurity_done, req);
 898         return req;
 899 }
 900
 901 static void rpccli_svcctl_SetServiceObjectSecurity_done(struct tevent_req *subreq)
 902 {
 903         struct tevent_req *req = tevent_req_callback_data(
 904                 subreq, struct tevent_req);
 905         struct rpccli_svcctl_SetServiceObjectSecurity_state *state = tevent_req_data(
 906                 req, struct rpccli_svcctl_SetServiceObjectSecurity_state);
 907         NTSTATUS status;
 908         TALLOC_CTX *mem_ctx;
 909
 910         if (state->out_mem_ctx) {
 911                 mem_ctx = state->out_mem_ctx;
 912         } else {
 913                 mem_ctx = state;
 914         }
 915
 916         status = state->dispatch_recv(subreq, mem_ctx);
 917         TALLOC_FREE(subreq);
 918         if (!NT_STATUS_IS_OK(status)) {
 919                 tevent_req_nterror(req, status);
 920                 return;
 921         }
 922
 923         /* Copy out parameters */
 924
 925         /* Copy result */
 926         state->orig.out.result = state->tmp.out.result;
 927
 928         /* Reset temporary structure */
 929         ZERO_STRUCT(state->tmp);
 930
 931         if (DEBUGLEVEL >= 10) {
 932                 NDR_PRINT_OUT_DEBUG(svcctl_SetServiceObjectSecurity, &state->orig);
 933         }
 934
 935         tevent_req_done(req);
 936 }
 937
 938 NTSTATUS rpccli_svcctl_SetServiceObjectSecurity_recv(struct tevent_req *req,
 939                                                      TALLOC_CTX *mem_ctx,
 940                                                      WERROR *result)
 941 {
 942         struct rpccli_svcctl_SetServiceObjectSecurity_state *state = tevent_req_data(
 943                 req, struct rpccli_svcctl_SetServiceObjectSecurity_state);
 944         NTSTATUS status;
 945
 946         if (tevent_req_is_nterror(req, &status)) {
 947                 tevent_req_received(req);
 948                 return status;
 949         }
 950
 951         /* Steal possbile out parameters to the callers context */
 952         talloc_steal(mem_ctx, state->out_mem_ctx);
 953
 954         /* Return result */
 955         *result = state->orig.out.result;
 956
 957         tevent_req_received(req);
 958         return NT_STATUS_OK;
 959 }
 960
 961 NTSTATUS rpccli_svcctl_SetServiceObjectSecurity(struct rpc_pipe_client *cli,
 962                                                 TALLOC_CTX *mem_ctx,
 963                                                 struct policy_handle *handle /* [in] [ref] */,
 964                                                 uint32_t security_flags /* [in]  */,
 965                                                 uint8_t *buffer /* [in] [ref,size_is(offered)] */,
 966                                                 uint32_t offered /* [in]  */,
 967                                                 WERROR *werror)
 968 {
 969         struct svcctl_SetServiceObjectSecurity r;
 970         NTSTATUS status;
 971
 972         /* In parameters */
 973         r.in.handle = handle;
 974         r.in.security_flags = security_flags;
 975         r.in.buffer = buffer;
 976         r.in.offered = offered;
 977
 978         if (DEBUGLEVEL >= 10) {
 979                 NDR_PRINT_IN_DEBUG(svcctl_SetServiceObjectSecurity, &r);
 980         }
 981
 982         status = cli->dispatch(cli,
 983                                 mem_ctx,
 984                                 &ndr_table_svcctl,
 985                                 NDR_SVCCTL_SETSERVICEOBJECTSECURITY,
 986                                 &r);
 987
 988         if (!NT_STATUS_IS_OK(status)) {
 989                 return status;
 990         }
 991
 992         if (DEBUGLEVEL >= 10) {
 993                 NDR_PRINT_OUT_DEBUG(svcctl_SetServiceObjectSecurity, &r);
 994         }
 995
 996         if (NT_STATUS_IS_ERR(status)) {
 997                 return status;
 998         }
 999
1000         /* Return variables */
1001
1002         /* Return result */
1003         if (werror) {
1004                 *werror = r.out.result;
1005         }
1006
1007         return werror_to_ntstatus(r.out.result);
1008 }
1009
1010 struct rpccli_svcctl_QueryServiceStatus_state {
1011         struct svcctl_QueryServiceStatus orig;
1012         struct svcctl_QueryServiceStatus tmp;
1013         TALLOC_CTX *out_mem_ctx;
1014         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1015 };
1016
1017 static void rpccli_svcctl_QueryServiceStatus_done(struct tevent_req *subreq);
1018
1019 struct tevent_req *rpccli_svcctl_QueryServiceStatus_send(TALLOC_CTX *mem_ctx,
1020                                                          struct tevent_context *ev,
1021                                                          struct rpc_pipe_client *cli,
1022                                                          struct policy_handle *_handle /* [in] [ref] */,
1023                                                          struct SERVICE_STATUS *_service_status /* [out] [ref] */)
1024 {
1025         struct tevent_req *req;
1026         struct rpccli_svcctl_QueryServiceStatus_state *state;
1027         struct tevent_req *subreq;
1028
1029         req = tevent_req_create(mem_ctx, &state,
1030                                 struct rpccli_svcctl_QueryServiceStatus_state);
1031         if (req == NULL) {
1032                 return NULL;
1033         }
1034         state->out_mem_ctx = NULL;
1035         state->dispatch_recv = cli->dispatch_recv;
1036
1037         /* In parameters */
1038         state->orig.in.handle = _handle;
1039
1040         /* Out parameters */
1041         state->orig.out.service_status = _service_status;
1042
1043         /* Result */
1044         ZERO_STRUCT(state->orig.out.result);
1045
1046         if (DEBUGLEVEL >= 10) {
1047                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceStatus, &state->orig);
1048         }
1049
1050         state->out_mem_ctx = talloc_named_const(state, 0,
1051                              "rpccli_svcctl_QueryServiceStatus_out_memory");
1052         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1053                 return tevent_req_post(req, ev);
1054         }
1055
1056         /* make a temporary copy, that we pass to the dispatch function */
1057         state->tmp = state->orig;
1058
1059         subreq = cli->dispatch_send(state, ev, cli,
1060                                     &ndr_table_svcctl,
1061                                     NDR_SVCCTL_QUERYSERVICESTATUS,
1062                                     &state->tmp);
1063         if (tevent_req_nomem(subreq, req)) {
1064                 return tevent_req_post(req, ev);
1065         }
1066         tevent_req_set_callback(subreq, rpccli_svcctl_QueryServiceStatus_done, req);
1067         return req;
1068 }
1069
1070 static void rpccli_svcctl_QueryServiceStatus_done(struct tevent_req *subreq)
1071 {
1072         struct tevent_req *req = tevent_req_callback_data(
1073                 subreq, struct tevent_req);
1074         struct rpccli_svcctl_QueryServiceStatus_state *state = tevent_req_data(
1075                 req, struct rpccli_svcctl_QueryServiceStatus_state);
1076         NTSTATUS status;
1077         TALLOC_CTX *mem_ctx;
1078
1079         if (state->out_mem_ctx) {
1080                 mem_ctx = state->out_mem_ctx;
1081         } else {
1082                 mem_ctx = state;
1083         }
1084
1085         status = state->dispatch_recv(subreq, mem_ctx);
1086         TALLOC_FREE(subreq);
1087         if (!NT_STATUS_IS_OK(status)) {
1088                 tevent_req_nterror(req, status);
1089                 return;
1090         }
1091
1092         /* Copy out parameters */
1093         *state->orig.out.service_status = *state->tmp.out.service_status;
1094
1095         /* Copy result */
1096         state->orig.out.result = state->tmp.out.result;
1097
1098         /* Reset temporary structure */
1099         ZERO_STRUCT(state->tmp);
1100
1101         if (DEBUGLEVEL >= 10) {
1102                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceStatus, &state->orig);
1103         }
1104
1105         tevent_req_done(req);
1106 }
1107
1108 NTSTATUS rpccli_svcctl_QueryServiceStatus_recv(struct tevent_req *req,
1109                                                TALLOC_CTX *mem_ctx,
1110                                                WERROR *result)
1111 {
1112         struct rpccli_svcctl_QueryServiceStatus_state *state = tevent_req_data(
1113                 req, struct rpccli_svcctl_QueryServiceStatus_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_svcctl_QueryServiceStatus(struct rpc_pipe_client *cli,
1132                                           TALLOC_CTX *mem_ctx,
1133                                           struct policy_handle *handle /* [in] [ref] */,
1134                                           struct SERVICE_STATUS *service_status /* [out] [ref] */,
1135                                           WERROR *werror)
1136 {
1137         struct svcctl_QueryServiceStatus r;
1138         NTSTATUS status;
1139
1140         /* In parameters */
1141         r.in.handle = handle;
1142
1143         if (DEBUGLEVEL >= 10) {
1144                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceStatus, &r);
1145         }
1146
1147         status = cli->dispatch(cli,
1148                                 mem_ctx,
1149                                 &ndr_table_svcctl,
1150                                 NDR_SVCCTL_QUERYSERVICESTATUS,
1151                                 &r);
1152
1153         if (!NT_STATUS_IS_OK(status)) {
1154                 return status;
1155         }
1156
1157         if (DEBUGLEVEL >= 10) {
1158                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceStatus, &r);
1159         }
1160
1161         if (NT_STATUS_IS_ERR(status)) {
1162                 return status;
1163         }
1164
1165         /* Return variables */
1166         *service_status = *r.out.service_status;
1167
1168         /* Return result */
1169         if (werror) {
1170                 *werror = r.out.result;
1171         }
1172
1173         return werror_to_ntstatus(r.out.result);
1174 }
1175
1176 struct rpccli_svcctl_SetServiceStatus_state {
1177         struct svcctl_SetServiceStatus orig;
1178         struct svcctl_SetServiceStatus tmp;
1179         TALLOC_CTX *out_mem_ctx;
1180         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1181 };
1182
1183 static void rpccli_svcctl_SetServiceStatus_done(struct tevent_req *subreq);
1184
1185 struct tevent_req *rpccli_svcctl_SetServiceStatus_send(TALLOC_CTX *mem_ctx,
1186                                                        struct tevent_context *ev,
1187                                                        struct rpc_pipe_client *cli)
1188 {
1189         struct tevent_req *req;
1190         struct rpccli_svcctl_SetServiceStatus_state *state;
1191         struct tevent_req *subreq;
1192
1193         req = tevent_req_create(mem_ctx, &state,
1194                                 struct rpccli_svcctl_SetServiceStatus_state);
1195         if (req == NULL) {
1196                 return NULL;
1197         }
1198         state->out_mem_ctx = NULL;
1199         state->dispatch_recv = cli->dispatch_recv;
1200
1201         /* In parameters */
1202
1203         /* Out parameters */
1204
1205         /* Result */
1206         ZERO_STRUCT(state->orig.out.result);
1207
1208         if (DEBUGLEVEL >= 10) {
1209                 NDR_PRINT_IN_DEBUG(svcctl_SetServiceStatus, &state->orig);
1210         }
1211
1212         /* make a temporary copy, that we pass to the dispatch function */
1213         state->tmp = state->orig;
1214
1215         subreq = cli->dispatch_send(state, ev, cli,
1216                                     &ndr_table_svcctl,
1217                                     NDR_SVCCTL_SETSERVICESTATUS,
1218                                     &state->tmp);
1219         if (tevent_req_nomem(subreq, req)) {
1220                 return tevent_req_post(req, ev);
1221         }
1222         tevent_req_set_callback(subreq, rpccli_svcctl_SetServiceStatus_done, req);
1223         return req;
1224 }
1225
1226 static void rpccli_svcctl_SetServiceStatus_done(struct tevent_req *subreq)
1227 {
1228         struct tevent_req *req = tevent_req_callback_data(
1229                 subreq, struct tevent_req);
1230         struct rpccli_svcctl_SetServiceStatus_state *state = tevent_req_data(
1231                 req, struct rpccli_svcctl_SetServiceStatus_state);
1232         NTSTATUS status;
1233         TALLOC_CTX *mem_ctx;
1234
1235         if (state->out_mem_ctx) {
1236                 mem_ctx = state->out_mem_ctx;
1237         } else {
1238                 mem_ctx = state;
1239         }
1240
1241         status = state->dispatch_recv(subreq, mem_ctx);
1242         TALLOC_FREE(subreq);
1243         if (!NT_STATUS_IS_OK(status)) {
1244                 tevent_req_nterror(req, status);
1245                 return;
1246         }
1247
1248         /* Copy out parameters */
1249
1250         /* Copy result */
1251         state->orig.out.result = state->tmp.out.result;
1252
1253         /* Reset temporary structure */
1254         ZERO_STRUCT(state->tmp);
1255
1256         if (DEBUGLEVEL >= 10) {
1257                 NDR_PRINT_OUT_DEBUG(svcctl_SetServiceStatus, &state->orig);
1258         }
1259
1260         tevent_req_done(req);
1261 }
1262
1263 NTSTATUS rpccli_svcctl_SetServiceStatus_recv(struct tevent_req *req,
1264                                              TALLOC_CTX *mem_ctx,
1265                                              WERROR *result)
1266 {
1267         struct rpccli_svcctl_SetServiceStatus_state *state = tevent_req_data(
1268                 req, struct rpccli_svcctl_SetServiceStatus_state);
1269         NTSTATUS status;
1270
1271         if (tevent_req_is_nterror(req, &status)) {
1272                 tevent_req_received(req);
1273                 return status;
1274         }
1275
1276         /* Steal possbile out parameters to the callers context */
1277         talloc_steal(mem_ctx, state->out_mem_ctx);
1278
1279         /* Return result */
1280         *result = state->orig.out.result;
1281
1282         tevent_req_received(req);
1283         return NT_STATUS_OK;
1284 }
1285
1286 NTSTATUS rpccli_svcctl_SetServiceStatus(struct rpc_pipe_client *cli,
1287                                         TALLOC_CTX *mem_ctx,
1288                                         WERROR *werror)
1289 {
1290         struct svcctl_SetServiceStatus r;
1291         NTSTATUS status;
1292
1293         /* In parameters */
1294
1295         if (DEBUGLEVEL >= 10) {
1296                 NDR_PRINT_IN_DEBUG(svcctl_SetServiceStatus, &r);
1297         }
1298
1299         status = cli->dispatch(cli,
1300                                 mem_ctx,
1301                                 &ndr_table_svcctl,
1302                                 NDR_SVCCTL_SETSERVICESTATUS,
1303                                 &r);
1304
1305         if (!NT_STATUS_IS_OK(status)) {
1306                 return status;
1307         }
1308
1309         if (DEBUGLEVEL >= 10) {
1310                 NDR_PRINT_OUT_DEBUG(svcctl_SetServiceStatus, &r);
1311         }
1312
1313         if (NT_STATUS_IS_ERR(status)) {
1314                 return status;
1315         }
1316
1317         /* Return variables */
1318
1319         /* Return result */
1320         if (werror) {
1321                 *werror = r.out.result;
1322         }
1323
1324         return werror_to_ntstatus(r.out.result);
1325 }
1326
1327 struct rpccli_svcctl_UnlockServiceDatabase_state {
1328         struct svcctl_UnlockServiceDatabase orig;
1329         struct svcctl_UnlockServiceDatabase tmp;
1330         TALLOC_CTX *out_mem_ctx;
1331         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1332 };
1333
1334 static void rpccli_svcctl_UnlockServiceDatabase_done(struct tevent_req *subreq);
1335
1336 struct tevent_req *rpccli_svcctl_UnlockServiceDatabase_send(TALLOC_CTX *mem_ctx,
1337                                                             struct tevent_context *ev,
1338                                                             struct rpc_pipe_client *cli,
1339                                                             struct policy_handle *_lock /* [in,out] [ref] */)
1340 {
1341         struct tevent_req *req;
1342         struct rpccli_svcctl_UnlockServiceDatabase_state *state;
1343         struct tevent_req *subreq;
1344
1345         req = tevent_req_create(mem_ctx, &state,
1346                                 struct rpccli_svcctl_UnlockServiceDatabase_state);
1347         if (req == NULL) {
1348                 return NULL;
1349         }
1350         state->out_mem_ctx = NULL;
1351         state->dispatch_recv = cli->dispatch_recv;
1352
1353         /* In parameters */
1354         state->orig.in.lock = _lock;
1355
1356         /* Out parameters */
1357         state->orig.out.lock = _lock;
1358
1359         /* Result */
1360         ZERO_STRUCT(state->orig.out.result);
1361
1362         if (DEBUGLEVEL >= 10) {
1363                 NDR_PRINT_IN_DEBUG(svcctl_UnlockServiceDatabase, &state->orig);
1364         }
1365
1366         state->out_mem_ctx = talloc_named_const(state, 0,
1367                              "rpccli_svcctl_UnlockServiceDatabase_out_memory");
1368         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1369                 return tevent_req_post(req, ev);
1370         }
1371
1372         /* make a temporary copy, that we pass to the dispatch function */
1373         state->tmp = state->orig;
1374
1375         subreq = cli->dispatch_send(state, ev, cli,
1376                                     &ndr_table_svcctl,
1377                                     NDR_SVCCTL_UNLOCKSERVICEDATABASE,
1378                                     &state->tmp);
1379         if (tevent_req_nomem(subreq, req)) {
1380                 return tevent_req_post(req, ev);
1381         }
1382         tevent_req_set_callback(subreq, rpccli_svcctl_UnlockServiceDatabase_done, req);
1383         return req;
1384 }
1385
1386 static void rpccli_svcctl_UnlockServiceDatabase_done(struct tevent_req *subreq)
1387 {
1388         struct tevent_req *req = tevent_req_callback_data(
1389                 subreq, struct tevent_req);
1390         struct rpccli_svcctl_UnlockServiceDatabase_state *state = tevent_req_data(
1391                 req, struct rpccli_svcctl_UnlockServiceDatabase_state);
1392         NTSTATUS status;
1393         TALLOC_CTX *mem_ctx;
1394
1395         if (state->out_mem_ctx) {
1396                 mem_ctx = state->out_mem_ctx;
1397         } else {
1398                 mem_ctx = state;
1399         }
1400
1401         status = state->dispatch_recv(subreq, mem_ctx);
1402         TALLOC_FREE(subreq);
1403         if (!NT_STATUS_IS_OK(status)) {
1404                 tevent_req_nterror(req, status);
1405                 return;
1406         }
1407
1408         /* Copy out parameters */
1409         *state->orig.out.lock = *state->tmp.out.lock;
1410
1411         /* Copy result */
1412         state->orig.out.result = state->tmp.out.result;
1413
1414         /* Reset temporary structure */
1415         ZERO_STRUCT(state->tmp);
1416
1417         if (DEBUGLEVEL >= 10) {
1418                 NDR_PRINT_OUT_DEBUG(svcctl_UnlockServiceDatabase, &state->orig);
1419         }
1420
1421         tevent_req_done(req);
1422 }
1423
1424 NTSTATUS rpccli_svcctl_UnlockServiceDatabase_recv(struct tevent_req *req,
1425                                                   TALLOC_CTX *mem_ctx,
1426                                                   WERROR *result)
1427 {
1428         struct rpccli_svcctl_UnlockServiceDatabase_state *state = tevent_req_data(
1429                 req, struct rpccli_svcctl_UnlockServiceDatabase_state);
1430         NTSTATUS status;
1431
1432         if (tevent_req_is_nterror(req, &status)) {
1433                 tevent_req_received(req);
1434                 return status;
1435         }
1436
1437         /* Steal possbile out parameters to the callers context */
1438         talloc_steal(mem_ctx, state->out_mem_ctx);
1439
1440         /* Return result */
1441         *result = state->orig.out.result;
1442
1443         tevent_req_received(req);
1444         return NT_STATUS_OK;
1445 }
1446
1447 NTSTATUS rpccli_svcctl_UnlockServiceDatabase(struct rpc_pipe_client *cli,
1448                                              TALLOC_CTX *mem_ctx,
1449                                              struct policy_handle *lock /* [in,out] [ref] */,
1450                                              WERROR *werror)
1451 {
1452         struct svcctl_UnlockServiceDatabase r;
1453         NTSTATUS status;
1454
1455         /* In parameters */
1456         r.in.lock = lock;
1457
1458         if (DEBUGLEVEL >= 10) {
1459                 NDR_PRINT_IN_DEBUG(svcctl_UnlockServiceDatabase, &r);
1460         }
1461
1462         status = cli->dispatch(cli,
1463                                 mem_ctx,
1464                                 &ndr_table_svcctl,
1465                                 NDR_SVCCTL_UNLOCKSERVICEDATABASE,
1466                                 &r);
1467
1468         if (!NT_STATUS_IS_OK(status)) {
1469                 return status;
1470         }
1471
1472         if (DEBUGLEVEL >= 10) {
1473                 NDR_PRINT_OUT_DEBUG(svcctl_UnlockServiceDatabase, &r);
1474         }
1475
1476         if (NT_STATUS_IS_ERR(status)) {
1477                 return status;
1478         }
1479
1480         /* Return variables */
1481         *lock = *r.out.lock;
1482
1483         /* Return result */
1484         if (werror) {
1485                 *werror = r.out.result;
1486         }
1487
1488         return werror_to_ntstatus(r.out.result);
1489 }
1490
1491 struct rpccli_svcctl_NotifyBootConfigStatus_state {
1492         struct svcctl_NotifyBootConfigStatus orig;
1493         struct svcctl_NotifyBootConfigStatus tmp;
1494         TALLOC_CTX *out_mem_ctx;
1495         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1496 };
1497
1498 static void rpccli_svcctl_NotifyBootConfigStatus_done(struct tevent_req *subreq);
1499
1500 struct tevent_req *rpccli_svcctl_NotifyBootConfigStatus_send(TALLOC_CTX *mem_ctx,
1501                                                              struct tevent_context *ev,
1502                                                              struct rpc_pipe_client *cli)
1503 {
1504         struct tevent_req *req;
1505         struct rpccli_svcctl_NotifyBootConfigStatus_state *state;
1506         struct tevent_req *subreq;
1507
1508         req = tevent_req_create(mem_ctx, &state,
1509                                 struct rpccli_svcctl_NotifyBootConfigStatus_state);
1510         if (req == NULL) {
1511                 return NULL;
1512         }
1513         state->out_mem_ctx = NULL;
1514         state->dispatch_recv = cli->dispatch_recv;
1515
1516         /* In parameters */
1517
1518         /* Out parameters */
1519
1520         /* Result */
1521         ZERO_STRUCT(state->orig.out.result);
1522
1523         if (DEBUGLEVEL >= 10) {
1524                 NDR_PRINT_IN_DEBUG(svcctl_NotifyBootConfigStatus, &state->orig);
1525         }
1526
1527         /* make a temporary copy, that we pass to the dispatch function */
1528         state->tmp = state->orig;
1529
1530         subreq = cli->dispatch_send(state, ev, cli,
1531                                     &ndr_table_svcctl,
1532                                     NDR_SVCCTL_NOTIFYBOOTCONFIGSTATUS,
1533                                     &state->tmp);
1534         if (tevent_req_nomem(subreq, req)) {
1535                 return tevent_req_post(req, ev);
1536         }
1537         tevent_req_set_callback(subreq, rpccli_svcctl_NotifyBootConfigStatus_done, req);
1538         return req;
1539 }
1540
1541 static void rpccli_svcctl_NotifyBootConfigStatus_done(struct tevent_req *subreq)
1542 {
1543         struct tevent_req *req = tevent_req_callback_data(
1544                 subreq, struct tevent_req);
1545         struct rpccli_svcctl_NotifyBootConfigStatus_state *state = tevent_req_data(
1546                 req, struct rpccli_svcctl_NotifyBootConfigStatus_state);
1547         NTSTATUS status;
1548         TALLOC_CTX *mem_ctx;
1549
1550         if (state->out_mem_ctx) {
1551                 mem_ctx = state->out_mem_ctx;
1552         } else {
1553                 mem_ctx = state;
1554         }
1555
1556         status = state->dispatch_recv(subreq, mem_ctx);
1557         TALLOC_FREE(subreq);
1558         if (!NT_STATUS_IS_OK(status)) {
1559                 tevent_req_nterror(req, status);
1560                 return;
1561         }
1562
1563         /* Copy out parameters */
1564
1565         /* Copy result */
1566         state->orig.out.result = state->tmp.out.result;
1567
1568         /* Reset temporary structure */
1569         ZERO_STRUCT(state->tmp);
1570
1571         if (DEBUGLEVEL >= 10) {
1572                 NDR_PRINT_OUT_DEBUG(svcctl_NotifyBootConfigStatus, &state->orig);
1573         }
1574
1575         tevent_req_done(req);
1576 }
1577
1578 NTSTATUS rpccli_svcctl_NotifyBootConfigStatus_recv(struct tevent_req *req,
1579                                                    TALLOC_CTX *mem_ctx,
1580                                                    WERROR *result)
1581 {
1582         struct rpccli_svcctl_NotifyBootConfigStatus_state *state = tevent_req_data(
1583                 req, struct rpccli_svcctl_NotifyBootConfigStatus_state);
1584         NTSTATUS status;
1585
1586         if (tevent_req_is_nterror(req, &status)) {
1587                 tevent_req_received(req);
1588                 return status;
1589         }
1590
1591         /* Steal possbile out parameters to the callers context */
1592         talloc_steal(mem_ctx, state->out_mem_ctx);
1593
1594         /* Return result */
1595         *result = state->orig.out.result;
1596
1597         tevent_req_received(req);
1598         return NT_STATUS_OK;
1599 }
1600
1601 NTSTATUS rpccli_svcctl_NotifyBootConfigStatus(struct rpc_pipe_client *cli,
1602                                               TALLOC_CTX *mem_ctx,
1603                                               WERROR *werror)
1604 {
1605         struct svcctl_NotifyBootConfigStatus r;
1606         NTSTATUS status;
1607
1608         /* In parameters */
1609
1610         if (DEBUGLEVEL >= 10) {
1611                 NDR_PRINT_IN_DEBUG(svcctl_NotifyBootConfigStatus, &r);
1612         }
1613
1614         status = cli->dispatch(cli,
1615                                 mem_ctx,
1616                                 &ndr_table_svcctl,
1617                                 NDR_SVCCTL_NOTIFYBOOTCONFIGSTATUS,
1618                                 &r);
1619
1620         if (!NT_STATUS_IS_OK(status)) {
1621                 return status;
1622         }
1623
1624         if (DEBUGLEVEL >= 10) {
1625                 NDR_PRINT_OUT_DEBUG(svcctl_NotifyBootConfigStatus, &r);
1626         }
1627
1628         if (NT_STATUS_IS_ERR(status)) {
1629                 return status;
1630         }
1631
1632         /* Return variables */
1633
1634         /* Return result */
1635         if (werror) {
1636                 *werror = r.out.result;
1637         }
1638
1639         return werror_to_ntstatus(r.out.result);
1640 }
1641
1642 struct rpccli_svcctl_SCSetServiceBitsW_state {
1643         struct svcctl_SCSetServiceBitsW orig;
1644         struct svcctl_SCSetServiceBitsW tmp;
1645         TALLOC_CTX *out_mem_ctx;
1646         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1647 };
1648
1649 static void rpccli_svcctl_SCSetServiceBitsW_done(struct tevent_req *subreq);
1650
1651 struct tevent_req *rpccli_svcctl_SCSetServiceBitsW_send(TALLOC_CTX *mem_ctx,
1652                                                         struct tevent_context *ev,
1653                                                         struct rpc_pipe_client *cli,
1654                                                         struct policy_handle *_handle /* [in] [ref] */,
1655                                                         uint32_t _bits /* [in]  */,
1656                                                         uint32_t _bitson /* [in]  */,
1657                                                         uint32_t _immediate /* [in]  */)
1658 {
1659         struct tevent_req *req;
1660         struct rpccli_svcctl_SCSetServiceBitsW_state *state;
1661         struct tevent_req *subreq;
1662
1663         req = tevent_req_create(mem_ctx, &state,
1664                                 struct rpccli_svcctl_SCSetServiceBitsW_state);
1665         if (req == NULL) {
1666                 return NULL;
1667         }
1668         state->out_mem_ctx = NULL;
1669         state->dispatch_recv = cli->dispatch_recv;
1670
1671         /* In parameters */
1672         state->orig.in.handle = _handle;
1673         state->orig.in.bits = _bits;
1674         state->orig.in.bitson = _bitson;
1675         state->orig.in.immediate = _immediate;
1676
1677         /* Out parameters */
1678
1679         /* Result */
1680         ZERO_STRUCT(state->orig.out.result);
1681
1682         if (DEBUGLEVEL >= 10) {
1683                 NDR_PRINT_IN_DEBUG(svcctl_SCSetServiceBitsW, &state->orig);
1684         }
1685
1686         /* make a temporary copy, that we pass to the dispatch function */
1687         state->tmp = state->orig;
1688
1689         subreq = cli->dispatch_send(state, ev, cli,
1690                                     &ndr_table_svcctl,
1691                                     NDR_SVCCTL_SCSETSERVICEBITSW,
1692                                     &state->tmp);
1693         if (tevent_req_nomem(subreq, req)) {
1694                 return tevent_req_post(req, ev);
1695         }
1696         tevent_req_set_callback(subreq, rpccli_svcctl_SCSetServiceBitsW_done, req);
1697         return req;
1698 }
1699
1700 static void rpccli_svcctl_SCSetServiceBitsW_done(struct tevent_req *subreq)
1701 {
1702         struct tevent_req *req = tevent_req_callback_data(
1703                 subreq, struct tevent_req);
1704         struct rpccli_svcctl_SCSetServiceBitsW_state *state = tevent_req_data(
1705                 req, struct rpccli_svcctl_SCSetServiceBitsW_state);
1706         NTSTATUS status;
1707         TALLOC_CTX *mem_ctx;
1708
1709         if (state->out_mem_ctx) {
1710                 mem_ctx = state->out_mem_ctx;
1711         } else {
1712                 mem_ctx = state;
1713         }
1714
1715         status = state->dispatch_recv(subreq, mem_ctx);
1716         TALLOC_FREE(subreq);
1717         if (!NT_STATUS_IS_OK(status)) {
1718                 tevent_req_nterror(req, status);
1719                 return;
1720         }
1721
1722         /* Copy out parameters */
1723
1724         /* Copy result */
1725         state->orig.out.result = state->tmp.out.result;
1726
1727         /* Reset temporary structure */
1728         ZERO_STRUCT(state->tmp);
1729
1730         if (DEBUGLEVEL >= 10) {
1731                 NDR_PRINT_OUT_DEBUG(svcctl_SCSetServiceBitsW, &state->orig);
1732         }
1733
1734         tevent_req_done(req);
1735 }
1736
1737 NTSTATUS rpccli_svcctl_SCSetServiceBitsW_recv(struct tevent_req *req,
1738                                               TALLOC_CTX *mem_ctx,
1739                                               WERROR *result)
1740 {
1741         struct rpccli_svcctl_SCSetServiceBitsW_state *state = tevent_req_data(
1742                 req, struct rpccli_svcctl_SCSetServiceBitsW_state);
1743         NTSTATUS status;
1744
1745         if (tevent_req_is_nterror(req, &status)) {
1746                 tevent_req_received(req);
1747                 return status;
1748         }
1749
1750         /* Steal possbile out parameters to the callers context */
1751         talloc_steal(mem_ctx, state->out_mem_ctx);
1752
1753         /* Return result */
1754         *result = state->orig.out.result;
1755
1756         tevent_req_received(req);
1757         return NT_STATUS_OK;
1758 }
1759
1760 NTSTATUS rpccli_svcctl_SCSetServiceBitsW(struct rpc_pipe_client *cli,
1761                                          TALLOC_CTX *mem_ctx,
1762                                          struct policy_handle *handle /* [in] [ref] */,
1763                                          uint32_t bits /* [in]  */,
1764                                          uint32_t bitson /* [in]  */,
1765                                          uint32_t immediate /* [in]  */,
1766                                          WERROR *werror)
1767 {
1768         struct svcctl_SCSetServiceBitsW r;
1769         NTSTATUS status;
1770
1771         /* In parameters */
1772         r.in.handle = handle;
1773         r.in.bits = bits;
1774         r.in.bitson = bitson;
1775         r.in.immediate = immediate;
1776
1777         if (DEBUGLEVEL >= 10) {
1778                 NDR_PRINT_IN_DEBUG(svcctl_SCSetServiceBitsW, &r);
1779         }
1780
1781         status = cli->dispatch(cli,
1782                                 mem_ctx,
1783                                 &ndr_table_svcctl,
1784                                 NDR_SVCCTL_SCSETSERVICEBITSW,
1785                                 &r);
1786
1787         if (!NT_STATUS_IS_OK(status)) {
1788                 return status;
1789         }
1790
1791         if (DEBUGLEVEL >= 10) {
1792                 NDR_PRINT_OUT_DEBUG(svcctl_SCSetServiceBitsW, &r);
1793         }
1794
1795         if (NT_STATUS_IS_ERR(status)) {
1796                 return status;
1797         }
1798
1799         /* Return variables */
1800
1801         /* Return result */
1802         if (werror) {
1803                 *werror = r.out.result;
1804         }
1805
1806         return werror_to_ntstatus(r.out.result);
1807 }
1808
1809 struct rpccli_svcctl_ChangeServiceConfigW_state {
1810         struct svcctl_ChangeServiceConfigW orig;
1811         struct svcctl_ChangeServiceConfigW tmp;
1812         TALLOC_CTX *out_mem_ctx;
1813         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1814 };
1815
1816 static void rpccli_svcctl_ChangeServiceConfigW_done(struct tevent_req *subreq);
1817
1818 struct tevent_req *rpccli_svcctl_ChangeServiceConfigW_send(TALLOC_CTX *mem_ctx,
1819                                                            struct tevent_context *ev,
1820                                                            struct rpc_pipe_client *cli,
1821                                                            struct policy_handle *_handle /* [in] [ref] */,
1822                                                            uint32_t _type /* [in]  */,
1823                                                            enum svcctl_StartType _start_type /* [in]  */,
1824                                                            enum svcctl_ErrorControl _error_control /* [in]  */,
1825                                                            const char *_binary_path /* [in] [unique,charset(UTF16)] */,
1826                                                            const char *_load_order_group /* [in] [unique,charset(UTF16)] */,
1827                                                            uint32_t *_tag_id /* [out] [ref] */,
1828                                                            const char *_dependencies /* [in] [unique,charset(UTF16)] */,
1829                                                            const char *_service_start_name /* [in] [unique,charset(UTF16)] */,
1830                                                            const char *_password /* [in] [unique,charset(UTF16)] */,
1831                                                            const char *_display_name /* [in] [unique,charset(UTF16)] */)
1832 {
1833         struct tevent_req *req;
1834         struct rpccli_svcctl_ChangeServiceConfigW_state *state;
1835         struct tevent_req *subreq;
1836
1837         req = tevent_req_create(mem_ctx, &state,
1838                                 struct rpccli_svcctl_ChangeServiceConfigW_state);
1839         if (req == NULL) {
1840                 return NULL;
1841         }
1842         state->out_mem_ctx = NULL;
1843         state->dispatch_recv = cli->dispatch_recv;
1844
1845         /* In parameters */
1846         state->orig.in.handle = _handle;
1847         state->orig.in.type = _type;
1848         state->orig.in.start_type = _start_type;
1849         state->orig.in.error_control = _error_control;
1850         state->orig.in.binary_path = _binary_path;
1851         state->orig.in.load_order_group = _load_order_group;
1852         state->orig.in.dependencies = _dependencies;
1853         state->orig.in.service_start_name = _service_start_name;
1854         state->orig.in.password = _password;
1855         state->orig.in.display_name = _display_name;
1856
1857         /* Out parameters */
1858         state->orig.out.tag_id = _tag_id;
1859
1860         /* Result */
1861         ZERO_STRUCT(state->orig.out.result);
1862
1863         if (DEBUGLEVEL >= 10) {
1864                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfigW, &state->orig);
1865         }
1866
1867         state->out_mem_ctx = talloc_named_const(state, 0,
1868                              "rpccli_svcctl_ChangeServiceConfigW_out_memory");
1869         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1870                 return tevent_req_post(req, ev);
1871         }
1872
1873         /* make a temporary copy, that we pass to the dispatch function */
1874         state->tmp = state->orig;
1875
1876         subreq = cli->dispatch_send(state, ev, cli,
1877                                     &ndr_table_svcctl,
1878                                     NDR_SVCCTL_CHANGESERVICECONFIGW,
1879                                     &state->tmp);
1880         if (tevent_req_nomem(subreq, req)) {
1881                 return tevent_req_post(req, ev);
1882         }
1883         tevent_req_set_callback(subreq, rpccli_svcctl_ChangeServiceConfigW_done, req);
1884         return req;
1885 }
1886
1887 static void rpccli_svcctl_ChangeServiceConfigW_done(struct tevent_req *subreq)
1888 {
1889         struct tevent_req *req = tevent_req_callback_data(
1890                 subreq, struct tevent_req);
1891         struct rpccli_svcctl_ChangeServiceConfigW_state *state = tevent_req_data(
1892                 req, struct rpccli_svcctl_ChangeServiceConfigW_state);
1893         NTSTATUS status;
1894         TALLOC_CTX *mem_ctx;
1895
1896         if (state->out_mem_ctx) {
1897                 mem_ctx = state->out_mem_ctx;
1898         } else {
1899                 mem_ctx = state;
1900         }
1901
1902         status = state->dispatch_recv(subreq, mem_ctx);
1903         TALLOC_FREE(subreq);
1904         if (!NT_STATUS_IS_OK(status)) {
1905                 tevent_req_nterror(req, status);
1906                 return;
1907         }
1908
1909         /* Copy out parameters */
1910         *state->orig.out.tag_id = *state->tmp.out.tag_id;
1911
1912         /* Copy result */
1913         state->orig.out.result = state->tmp.out.result;
1914
1915         /* Reset temporary structure */
1916         ZERO_STRUCT(state->tmp);
1917
1918         if (DEBUGLEVEL >= 10) {
1919                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfigW, &state->orig);
1920         }
1921
1922         tevent_req_done(req);
1923 }
1924
1925 NTSTATUS rpccli_svcctl_ChangeServiceConfigW_recv(struct tevent_req *req,
1926                                                  TALLOC_CTX *mem_ctx,
1927                                                  WERROR *result)
1928 {
1929         struct rpccli_svcctl_ChangeServiceConfigW_state *state = tevent_req_data(
1930                 req, struct rpccli_svcctl_ChangeServiceConfigW_state);
1931         NTSTATUS status;
1932
1933         if (tevent_req_is_nterror(req, &status)) {
1934                 tevent_req_received(req);
1935                 return status;
1936         }
1937
1938         /* Steal possbile out parameters to the callers context */
1939         talloc_steal(mem_ctx, state->out_mem_ctx);
1940
1941         /* Return result */
1942         *result = state->orig.out.result;
1943
1944         tevent_req_received(req);
1945         return NT_STATUS_OK;
1946 }
1947
1948 NTSTATUS rpccli_svcctl_ChangeServiceConfigW(struct rpc_pipe_client *cli,
1949                                             TALLOC_CTX *mem_ctx,
1950                                             struct policy_handle *handle /* [in] [ref] */,
1951                                             uint32_t type /* [in]  */,
1952                                             enum svcctl_StartType start_type /* [in]  */,
1953                                             enum svcctl_ErrorControl error_control /* [in]  */,
1954                                             const char *binary_path /* [in] [unique,charset(UTF16)] */,
1955                                             const char *load_order_group /* [in] [unique,charset(UTF16)] */,
1956                                             uint32_t *tag_id /* [out] [ref] */,
1957                                             const char *dependencies /* [in] [unique,charset(UTF16)] */,
1958                                             const char *service_start_name /* [in] [unique,charset(UTF16)] */,
1959                                             const char *password /* [in] [unique,charset(UTF16)] */,
1960                                             const char *display_name /* [in] [unique,charset(UTF16)] */,
1961                                             WERROR *werror)
1962 {
1963         struct svcctl_ChangeServiceConfigW r;
1964         NTSTATUS status;
1965
1966         /* In parameters */
1967         r.in.handle = handle;
1968         r.in.type = type;
1969         r.in.start_type = start_type;
1970         r.in.error_control = error_control;
1971         r.in.binary_path = binary_path;
1972         r.in.load_order_group = load_order_group;
1973         r.in.dependencies = dependencies;
1974         r.in.service_start_name = service_start_name;
1975         r.in.password = password;
1976         r.in.display_name = display_name;
1977
1978         if (DEBUGLEVEL >= 10) {
1979                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfigW, &r);
1980         }
1981
1982         status = cli->dispatch(cli,
1983                                 mem_ctx,
1984                                 &ndr_table_svcctl,
1985                                 NDR_SVCCTL_CHANGESERVICECONFIGW,
1986                                 &r);
1987
1988         if (!NT_STATUS_IS_OK(status)) {
1989                 return status;
1990         }
1991
1992         if (DEBUGLEVEL >= 10) {
1993                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfigW, &r);
1994         }
1995
1996         if (NT_STATUS_IS_ERR(status)) {
1997                 return status;
1998         }
1999
2000         /* Return variables */
2001         *tag_id = *r.out.tag_id;
2002
2003         /* Return result */
2004         if (werror) {
2005                 *werror = r.out.result;
2006         }
2007
2008         return werror_to_ntstatus(r.out.result);
2009 }
2010
2011 struct rpccli_svcctl_CreateServiceW_state {
2012         struct svcctl_CreateServiceW orig;
2013         struct svcctl_CreateServiceW tmp;
2014         TALLOC_CTX *out_mem_ctx;
2015         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2016 };
2017
2018 static void rpccli_svcctl_CreateServiceW_done(struct tevent_req *subreq);
2019
2020 struct tevent_req *rpccli_svcctl_CreateServiceW_send(TALLOC_CTX *mem_ctx,
2021                                                      struct tevent_context *ev,
2022                                                      struct rpc_pipe_client *cli,
2023                                                      struct policy_handle *_scmanager_handle /* [in] [ref] */,
2024                                                      const char *_ServiceName /* [in] [charset(UTF16)] */,
2025                                                      const char *_DisplayName /* [in] [unique,charset(UTF16)] */,
2026                                                      uint32_t _desired_access /* [in]  */,
2027                                                      uint32_t _type /* [in]  */,
2028                                                      enum svcctl_StartType _start_type /* [in]  */,
2029                                                      enum svcctl_ErrorControl _error_control /* [in]  */,
2030                                                      const char *_binary_path /* [in] [charset(UTF16)] */,
2031                                                      const char *_LoadOrderGroupKey /* [in] [unique,charset(UTF16)] */,
2032                                                      uint32_t *_TagId /* [in,out] [unique] */,
2033                                                      uint8_t *_dependencies /* [in] [unique,size_is(dependencies_size)] */,
2034                                                      uint32_t _dependencies_size /* [in]  */,
2035                                                      const char *_service_start_name /* [in] [unique,charset(UTF16)] */,
2036                                                      uint8_t *_password /* [in] [unique,size_is(password_size)] */,
2037                                                      uint32_t _password_size /* [in]  */,
2038                                                      struct policy_handle *_handle /* [out] [ref] */)
2039 {
2040         struct tevent_req *req;
2041         struct rpccli_svcctl_CreateServiceW_state *state;
2042         struct tevent_req *subreq;
2043
2044         req = tevent_req_create(mem_ctx, &state,
2045                                 struct rpccli_svcctl_CreateServiceW_state);
2046         if (req == NULL) {
2047                 return NULL;
2048         }
2049         state->out_mem_ctx = NULL;
2050         state->dispatch_recv = cli->dispatch_recv;
2051
2052         /* In parameters */
2053         state->orig.in.scmanager_handle = _scmanager_handle;
2054         state->orig.in.ServiceName = _ServiceName;
2055         state->orig.in.DisplayName = _DisplayName;
2056         state->orig.in.desired_access = _desired_access;
2057         state->orig.in.type = _type;
2058         state->orig.in.start_type = _start_type;
2059         state->orig.in.error_control = _error_control;
2060         state->orig.in.binary_path = _binary_path;
2061         state->orig.in.LoadOrderGroupKey = _LoadOrderGroupKey;
2062         state->orig.in.TagId = _TagId;
2063         state->orig.in.dependencies = _dependencies;
2064         state->orig.in.dependencies_size = _dependencies_size;
2065         state->orig.in.service_start_name = _service_start_name;
2066         state->orig.in.password = _password;
2067         state->orig.in.password_size = _password_size;
2068
2069         /* Out parameters */
2070         state->orig.out.TagId = _TagId;
2071         state->orig.out.handle = _handle;
2072
2073         /* Result */
2074         ZERO_STRUCT(state->orig.out.result);
2075
2076         if (DEBUGLEVEL >= 10) {
2077                 NDR_PRINT_IN_DEBUG(svcctl_CreateServiceW, &state->orig);
2078         }
2079
2080         state->out_mem_ctx = talloc_named_const(state, 0,
2081                              "rpccli_svcctl_CreateServiceW_out_memory");
2082         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2083                 return tevent_req_post(req, ev);
2084         }
2085
2086         /* make a temporary copy, that we pass to the dispatch function */
2087         state->tmp = state->orig;
2088
2089         subreq = cli->dispatch_send(state, ev, cli,
2090                                     &ndr_table_svcctl,
2091                                     NDR_SVCCTL_CREATESERVICEW,
2092                                     &state->tmp);
2093         if (tevent_req_nomem(subreq, req)) {
2094                 return tevent_req_post(req, ev);
2095         }
2096         tevent_req_set_callback(subreq, rpccli_svcctl_CreateServiceW_done, req);
2097         return req;
2098 }
2099
2100 static void rpccli_svcctl_CreateServiceW_done(struct tevent_req *subreq)
2101 {
2102         struct tevent_req *req = tevent_req_callback_data(
2103                 subreq, struct tevent_req);
2104         struct rpccli_svcctl_CreateServiceW_state *state = tevent_req_data(
2105                 req, struct rpccli_svcctl_CreateServiceW_state);
2106         NTSTATUS status;
2107         TALLOC_CTX *mem_ctx;
2108
2109         if (state->out_mem_ctx) {
2110                 mem_ctx = state->out_mem_ctx;
2111         } else {
2112                 mem_ctx = state;
2113         }
2114
2115         status = state->dispatch_recv(subreq, mem_ctx);
2116         TALLOC_FREE(subreq);
2117         if (!NT_STATUS_IS_OK(status)) {
2118                 tevent_req_nterror(req, status);
2119                 return;
2120         }
2121
2122         /* Copy out parameters */
2123         if (state->orig.out.TagId && state->tmp.out.TagId) {
2124                 *state->orig.out.TagId = *state->tmp.out.TagId;
2125         }
2126         *state->orig.out.handle = *state->tmp.out.handle;
2127
2128         /* Copy result */
2129         state->orig.out.result = state->tmp.out.result;
2130
2131         /* Reset temporary structure */
2132         ZERO_STRUCT(state->tmp);
2133
2134         if (DEBUGLEVEL >= 10) {
2135                 NDR_PRINT_OUT_DEBUG(svcctl_CreateServiceW, &state->orig);
2136         }
2137
2138         tevent_req_done(req);
2139 }
2140
2141 NTSTATUS rpccli_svcctl_CreateServiceW_recv(struct tevent_req *req,
2142                                            TALLOC_CTX *mem_ctx,
2143                                            WERROR *result)
2144 {
2145         struct rpccli_svcctl_CreateServiceW_state *state = tevent_req_data(
2146                 req, struct rpccli_svcctl_CreateServiceW_state);
2147         NTSTATUS status;
2148
2149         if (tevent_req_is_nterror(req, &status)) {
2150                 tevent_req_received(req);
2151                 return status;
2152         }
2153
2154         /* Steal possbile out parameters to the callers context */
2155         talloc_steal(mem_ctx, state->out_mem_ctx);
2156
2157         /* Return result */
2158         *result = state->orig.out.result;
2159
2160         tevent_req_received(req);
2161         return NT_STATUS_OK;
2162 }
2163
2164 NTSTATUS rpccli_svcctl_CreateServiceW(struct rpc_pipe_client *cli,
2165                                       TALLOC_CTX *mem_ctx,
2166                                       struct policy_handle *scmanager_handle /* [in] [ref] */,
2167                                       const char *ServiceName /* [in] [charset(UTF16)] */,
2168                                       const char *DisplayName /* [in] [unique,charset(UTF16)] */,
2169                                       uint32_t desired_access /* [in]  */,
2170                                       uint32_t type /* [in]  */,
2171                                       enum svcctl_StartType start_type /* [in]  */,
2172                                       enum svcctl_ErrorControl error_control /* [in]  */,
2173                                       const char *binary_path /* [in] [charset(UTF16)] */,
2174                                       const char *LoadOrderGroupKey /* [in] [unique,charset(UTF16)] */,
2175                                       uint32_t *TagId /* [in,out] [unique] */,
2176                                       uint8_t *dependencies /* [in] [unique,size_is(dependencies_size)] */,
2177                                       uint32_t dependencies_size /* [in]  */,
2178                                       const char *service_start_name /* [in] [unique,charset(UTF16)] */,
2179                                       uint8_t *password /* [in] [unique,size_is(password_size)] */,
2180                                       uint32_t password_size /* [in]  */,
2181                                       struct policy_handle *handle /* [out] [ref] */,
2182                                       WERROR *werror)
2183 {
2184         struct svcctl_CreateServiceW r;
2185         NTSTATUS status;
2186
2187         /* In parameters */
2188         r.in.scmanager_handle = scmanager_handle;
2189         r.in.ServiceName = ServiceName;
2190         r.in.DisplayName = DisplayName;
2191         r.in.desired_access = desired_access;
2192         r.in.type = type;
2193         r.in.start_type = start_type;
2194         r.in.error_control = error_control;
2195         r.in.binary_path = binary_path;
2196         r.in.LoadOrderGroupKey = LoadOrderGroupKey;
2197         r.in.TagId = TagId;
2198         r.in.dependencies = dependencies;
2199         r.in.dependencies_size = dependencies_size;
2200         r.in.service_start_name = service_start_name;
2201         r.in.password = password;
2202         r.in.password_size = password_size;
2203
2204         if (DEBUGLEVEL >= 10) {
2205                 NDR_PRINT_IN_DEBUG(svcctl_CreateServiceW, &r);
2206         }
2207
2208         status = cli->dispatch(cli,
2209                                 mem_ctx,
2210                                 &ndr_table_svcctl,
2211                                 NDR_SVCCTL_CREATESERVICEW,
2212                                 &r);
2213
2214         if (!NT_STATUS_IS_OK(status)) {
2215                 return status;
2216         }
2217
2218         if (DEBUGLEVEL >= 10) {
2219                 NDR_PRINT_OUT_DEBUG(svcctl_CreateServiceW, &r);
2220         }
2221
2222         if (NT_STATUS_IS_ERR(status)) {
2223                 return status;
2224         }
2225
2226         /* Return variables */
2227         if (TagId && r.out.TagId) {
2228                 *TagId = *r.out.TagId;
2229         }
2230         *handle = *r.out.handle;
2231
2232         /* Return result */
2233         if (werror) {
2234                 *werror = r.out.result;
2235         }
2236
2237         return werror_to_ntstatus(r.out.result);
2238 }
2239
2240 struct rpccli_svcctl_EnumDependentServicesW_state {
2241         struct svcctl_EnumDependentServicesW orig;
2242         struct svcctl_EnumDependentServicesW tmp;
2243         TALLOC_CTX *out_mem_ctx;
2244         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2245 };
2246
2247 static void rpccli_svcctl_EnumDependentServicesW_done(struct tevent_req *subreq);
2248
2249 struct tevent_req *rpccli_svcctl_EnumDependentServicesW_send(TALLOC_CTX *mem_ctx,
2250                                                              struct tevent_context *ev,
2251                                                              struct rpc_pipe_client *cli,
2252                                                              struct policy_handle *_service /* [in] [ref] */,
2253                                                              enum svcctl_ServiceState _state /* [in]  */,
2254                                                              uint8_t *_service_status /* [out] [ref,size_is(offered)] */,
2255                                                              uint32_t _offered /* [in] [range(0,0x40000)] */,
2256                                                              uint32_t *_needed /* [out] [ref,range(0,0x40000)] */,
2257                                                              uint32_t *_services_returned /* [out] [ref,range(0,0x40000)] */)
2258 {
2259         struct tevent_req *req;
2260         struct rpccli_svcctl_EnumDependentServicesW_state *state;
2261         struct tevent_req *subreq;
2262
2263         req = tevent_req_create(mem_ctx, &state,
2264                                 struct rpccli_svcctl_EnumDependentServicesW_state);
2265         if (req == NULL) {
2266                 return NULL;
2267         }
2268         state->out_mem_ctx = NULL;
2269         state->dispatch_recv = cli->dispatch_recv;
2270
2271         /* In parameters */
2272         state->orig.in.service = _service;
2273         state->orig.in.state = _state;
2274         state->orig.in.offered = _offered;
2275
2276         /* Out parameters */
2277         state->orig.out.service_status = _service_status;
2278         state->orig.out.needed = _needed;
2279         state->orig.out.services_returned = _services_returned;
2280
2281         /* Result */
2282         ZERO_STRUCT(state->orig.out.result);
2283
2284         if (DEBUGLEVEL >= 10) {
2285                 NDR_PRINT_IN_DEBUG(svcctl_EnumDependentServicesW, &state->orig);
2286         }
2287
2288         state->out_mem_ctx = talloc_named_const(state, 0,
2289                              "rpccli_svcctl_EnumDependentServicesW_out_memory");
2290         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2291                 return tevent_req_post(req, ev);
2292         }
2293
2294         /* make a temporary copy, that we pass to the dispatch function */
2295         state->tmp = state->orig;
2296
2297         subreq = cli->dispatch_send(state, ev, cli,
2298                                     &ndr_table_svcctl,
2299                                     NDR_SVCCTL_ENUMDEPENDENTSERVICESW,
2300                                     &state->tmp);
2301         if (tevent_req_nomem(subreq, req)) {
2302                 return tevent_req_post(req, ev);
2303         }
2304         tevent_req_set_callback(subreq, rpccli_svcctl_EnumDependentServicesW_done, req);
2305         return req;
2306 }
2307
2308 static void rpccli_svcctl_EnumDependentServicesW_done(struct tevent_req *subreq)
2309 {
2310         struct tevent_req *req = tevent_req_callback_data(
2311                 subreq, struct tevent_req);
2312         struct rpccli_svcctl_EnumDependentServicesW_state *state = tevent_req_data(
2313                 req, struct rpccli_svcctl_EnumDependentServicesW_state);
2314         NTSTATUS status;
2315         TALLOC_CTX *mem_ctx;
2316
2317         if (state->out_mem_ctx) {
2318                 mem_ctx = state->out_mem_ctx;
2319         } else {
2320                 mem_ctx = state;
2321         }
2322
2323         status = state->dispatch_recv(subreq, mem_ctx);
2324         TALLOC_FREE(subreq);
2325         if (!NT_STATUS_IS_OK(status)) {
2326                 tevent_req_nterror(req, status);
2327                 return;
2328         }
2329
2330         /* Copy out parameters */
2331         memcpy(state->orig.out.service_status, state->tmp.out.service_status, state->tmp.in.offered * sizeof(*state->orig.out.service_status));
2332         *state->orig.out.needed = *state->tmp.out.needed;
2333         *state->orig.out.services_returned = *state->tmp.out.services_returned;
2334
2335         /* Copy result */
2336         state->orig.out.result = state->tmp.out.result;
2337
2338         /* Reset temporary structure */
2339         ZERO_STRUCT(state->tmp);
2340
2341         if (DEBUGLEVEL >= 10) {
2342                 NDR_PRINT_OUT_DEBUG(svcctl_EnumDependentServicesW, &state->orig);
2343         }
2344
2345         tevent_req_done(req);
2346 }
2347
2348 NTSTATUS rpccli_svcctl_EnumDependentServicesW_recv(struct tevent_req *req,
2349                                                    TALLOC_CTX *mem_ctx,
2350                                                    WERROR *result)
2351 {
2352         struct rpccli_svcctl_EnumDependentServicesW_state *state = tevent_req_data(
2353                 req, struct rpccli_svcctl_EnumDependentServicesW_state);
2354         NTSTATUS status;
2355
2356         if (tevent_req_is_nterror(req, &status)) {
2357                 tevent_req_received(req);
2358                 return status;
2359         }
2360
2361         /* Steal possbile out parameters to the callers context */
2362         talloc_steal(mem_ctx, state->out_mem_ctx);
2363
2364         /* Return result */
2365         *result = state->orig.out.result;
2366
2367         tevent_req_received(req);
2368         return NT_STATUS_OK;
2369 }
2370
2371 NTSTATUS rpccli_svcctl_EnumDependentServicesW(struct rpc_pipe_client *cli,
2372                                               TALLOC_CTX *mem_ctx,
2373                                               struct policy_handle *service /* [in] [ref] */,
2374                                               enum svcctl_ServiceState state /* [in]  */,
2375                                               uint8_t *service_status /* [out] [ref,size_is(offered)] */,
2376                                               uint32_t offered /* [in] [range(0,0x40000)] */,
2377                                               uint32_t *needed /* [out] [ref,range(0,0x40000)] */,
2378                                               uint32_t *services_returned /* [out] [ref,range(0,0x40000)] */,
2379                                               WERROR *werror)
2380 {
2381         struct svcctl_EnumDependentServicesW r;
2382         NTSTATUS status;
2383
2384         /* In parameters */
2385         r.in.service = service;
2386         r.in.state = state;
2387         r.in.offered = offered;
2388
2389         if (DEBUGLEVEL >= 10) {
2390                 NDR_PRINT_IN_DEBUG(svcctl_EnumDependentServicesW, &r);
2391         }
2392
2393         status = cli->dispatch(cli,
2394                                 mem_ctx,
2395                                 &ndr_table_svcctl,
2396                                 NDR_SVCCTL_ENUMDEPENDENTSERVICESW,
2397                                 &r);
2398
2399         if (!NT_STATUS_IS_OK(status)) {
2400                 return status;
2401         }
2402
2403         if (DEBUGLEVEL >= 10) {
2404                 NDR_PRINT_OUT_DEBUG(svcctl_EnumDependentServicesW, &r);
2405         }
2406
2407         if (NT_STATUS_IS_ERR(status)) {
2408                 return status;
2409         }
2410
2411         /* Return variables */
2412         memcpy(service_status, r.out.service_status, r.in.offered * sizeof(*service_status));
2413         *needed = *r.out.needed;
2414         *services_returned = *r.out.services_returned;
2415
2416         /* Return result */
2417         if (werror) {
2418                 *werror = r.out.result;
2419         }
2420
2421         return werror_to_ntstatus(r.out.result);
2422 }
2423
2424 struct rpccli_svcctl_EnumServicesStatusW_state {
2425         struct svcctl_EnumServicesStatusW orig;
2426         struct svcctl_EnumServicesStatusW tmp;
2427         TALLOC_CTX *out_mem_ctx;
2428         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2429 };
2430
2431 static void rpccli_svcctl_EnumServicesStatusW_done(struct tevent_req *subreq);
2432
2433 struct tevent_req *rpccli_svcctl_EnumServicesStatusW_send(TALLOC_CTX *mem_ctx,
2434                                                           struct tevent_context *ev,
2435                                                           struct rpc_pipe_client *cli,
2436                                                           struct policy_handle *_handle /* [in] [ref] */,
2437                                                           uint32_t _type /* [in]  */,
2438                                                           enum svcctl_ServiceState _state /* [in]  */,
2439                                                           uint8_t *_service /* [out] [ref,size_is(offered)] */,
2440                                                           uint32_t _offered /* [in] [range(0,0x40000)] */,
2441                                                           uint32_t *_needed /* [out] [ref,range(0,0x40000)] */,
2442                                                           uint32_t *_services_returned /* [out] [ref,range(0,0x40000)] */,
2443                                                           uint32_t *_resume_handle /* [in,out] [unique] */)
2444 {
2445         struct tevent_req *req;
2446         struct rpccli_svcctl_EnumServicesStatusW_state *state;
2447         struct tevent_req *subreq;
2448
2449         req = tevent_req_create(mem_ctx, &state,
2450                                 struct rpccli_svcctl_EnumServicesStatusW_state);
2451         if (req == NULL) {
2452                 return NULL;
2453         }
2454         state->out_mem_ctx = NULL;
2455         state->dispatch_recv = cli->dispatch_recv;
2456
2457         /* In parameters */
2458         state->orig.in.handle = _handle;
2459         state->orig.in.type = _type;
2460         state->orig.in.state = _state;
2461         state->orig.in.offered = _offered;
2462         state->orig.in.resume_handle = _resume_handle;
2463
2464         /* Out parameters */
2465         state->orig.out.service = _service;
2466         state->orig.out.needed = _needed;
2467         state->orig.out.services_returned = _services_returned;
2468         state->orig.out.resume_handle = _resume_handle;
2469
2470         /* Result */
2471         ZERO_STRUCT(state->orig.out.result);
2472
2473         if (DEBUGLEVEL >= 10) {
2474                 NDR_PRINT_IN_DEBUG(svcctl_EnumServicesStatusW, &state->orig);
2475         }
2476
2477         state->out_mem_ctx = talloc_named_const(state, 0,
2478                              "rpccli_svcctl_EnumServicesStatusW_out_memory");
2479         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2480                 return tevent_req_post(req, ev);
2481         }
2482
2483         /* make a temporary copy, that we pass to the dispatch function */
2484         state->tmp = state->orig;
2485
2486         subreq = cli->dispatch_send(state, ev, cli,
2487                                     &ndr_table_svcctl,
2488                                     NDR_SVCCTL_ENUMSERVICESSTATUSW,
2489                                     &state->tmp);
2490         if (tevent_req_nomem(subreq, req)) {
2491                 return tevent_req_post(req, ev);
2492         }
2493         tevent_req_set_callback(subreq, rpccli_svcctl_EnumServicesStatusW_done, req);
2494         return req;
2495 }
2496
2497 static void rpccli_svcctl_EnumServicesStatusW_done(struct tevent_req *subreq)
2498 {
2499         struct tevent_req *req = tevent_req_callback_data(
2500                 subreq, struct tevent_req);
2501         struct rpccli_svcctl_EnumServicesStatusW_state *state = tevent_req_data(
2502                 req, struct rpccli_svcctl_EnumServicesStatusW_state);
2503         NTSTATUS status;
2504         TALLOC_CTX *mem_ctx;
2505
2506         if (state->out_mem_ctx) {
2507                 mem_ctx = state->out_mem_ctx;
2508         } else {
2509                 mem_ctx = state;
2510         }
2511
2512         status = state->dispatch_recv(subreq, mem_ctx);
2513         TALLOC_FREE(subreq);
2514         if (!NT_STATUS_IS_OK(status)) {
2515                 tevent_req_nterror(req, status);
2516                 return;
2517         }
2518
2519         /* Copy out parameters */
2520         memcpy(state->orig.out.service, state->tmp.out.service, state->tmp.in.offered * sizeof(*state->orig.out.service));
2521         *state->orig.out.needed = *state->tmp.out.needed;
2522         *state->orig.out.services_returned = *state->tmp.out.services_returned;
2523         if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
2524                 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
2525         }
2526
2527         /* Copy result */
2528         state->orig.out.result = state->tmp.out.result;
2529
2530         /* Reset temporary structure */
2531         ZERO_STRUCT(state->tmp);
2532
2533         if (DEBUGLEVEL >= 10) {
2534                 NDR_PRINT_OUT_DEBUG(svcctl_EnumServicesStatusW, &state->orig);
2535         }
2536
2537         tevent_req_done(req);
2538 }
2539
2540 NTSTATUS rpccli_svcctl_EnumServicesStatusW_recv(struct tevent_req *req,
2541                                                 TALLOC_CTX *mem_ctx,
2542                                                 WERROR *result)
2543 {
2544         struct rpccli_svcctl_EnumServicesStatusW_state *state = tevent_req_data(
2545                 req, struct rpccli_svcctl_EnumServicesStatusW_state);
2546         NTSTATUS status;
2547
2548         if (tevent_req_is_nterror(req, &status)) {
2549                 tevent_req_received(req);
2550                 return status;
2551         }
2552
2553         /* Steal possbile out parameters to the callers context */
2554         talloc_steal(mem_ctx, state->out_mem_ctx);
2555
2556         /* Return result */
2557         *result = state->orig.out.result;
2558
2559         tevent_req_received(req);
2560         return NT_STATUS_OK;
2561 }
2562
2563 NTSTATUS rpccli_svcctl_EnumServicesStatusW(struct rpc_pipe_client *cli,
2564                                            TALLOC_CTX *mem_ctx,
2565                                            struct policy_handle *handle /* [in] [ref] */,
2566                                            uint32_t type /* [in]  */,
2567                                            enum svcctl_ServiceState state /* [in]  */,
2568                                            uint8_t *service /* [out] [ref,size_is(offered)] */,
2569                                            uint32_t offered /* [in] [range(0,0x40000)] */,
2570                                            uint32_t *needed /* [out] [ref,range(0,0x40000)] */,
2571                                            uint32_t *services_returned /* [out] [ref,range(0,0x40000)] */,
2572                                            uint32_t *resume_handle /* [in,out] [unique] */,
2573                                            WERROR *werror)
2574 {
2575         struct svcctl_EnumServicesStatusW r;
2576         NTSTATUS status;
2577
2578         /* In parameters */
2579         r.in.handle = handle;
2580         r.in.type = type;
2581         r.in.state = state;
2582         r.in.offered = offered;
2583         r.in.resume_handle = resume_handle;
2584
2585         if (DEBUGLEVEL >= 10) {
2586                 NDR_PRINT_IN_DEBUG(svcctl_EnumServicesStatusW, &r);
2587         }
2588
2589         status = cli->dispatch(cli,
2590                                 mem_ctx,
2591                                 &ndr_table_svcctl,
2592                                 NDR_SVCCTL_ENUMSERVICESSTATUSW,
2593                                 &r);
2594
2595         if (!NT_STATUS_IS_OK(status)) {
2596                 return status;
2597         }
2598
2599         if (DEBUGLEVEL >= 10) {
2600                 NDR_PRINT_OUT_DEBUG(svcctl_EnumServicesStatusW, &r);
2601         }
2602
2603         if (NT_STATUS_IS_ERR(status)) {
2604                 return status;
2605         }
2606
2607         /* Return variables */
2608         memcpy(service, r.out.service, r.in.offered * sizeof(*service));
2609         *needed = *r.out.needed;
2610         *services_returned = *r.out.services_returned;
2611         if (resume_handle && r.out.resume_handle) {
2612                 *resume_handle = *r.out.resume_handle;
2613         }
2614
2615         /* Return result */
2616         if (werror) {
2617                 *werror = r.out.result;
2618         }
2619
2620         return werror_to_ntstatus(r.out.result);
2621 }
2622
2623 struct rpccli_svcctl_OpenSCManagerW_state {
2624         struct svcctl_OpenSCManagerW orig;
2625         struct svcctl_OpenSCManagerW tmp;
2626         TALLOC_CTX *out_mem_ctx;
2627         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2628 };
2629
2630 static void rpccli_svcctl_OpenSCManagerW_done(struct tevent_req *subreq);
2631
2632 struct tevent_req *rpccli_svcctl_OpenSCManagerW_send(TALLOC_CTX *mem_ctx,
2633                                                      struct tevent_context *ev,
2634                                                      struct rpc_pipe_client *cli,
2635                                                      const char *_MachineName /* [in] [unique,charset(UTF16)] */,
2636                                                      const char *_DatabaseName /* [in] [unique,charset(UTF16)] */,
2637                                                      uint32_t _access_mask /* [in]  */,
2638                                                      struct policy_handle *_handle /* [out] [ref] */)
2639 {
2640         struct tevent_req *req;
2641         struct rpccli_svcctl_OpenSCManagerW_state *state;
2642         struct tevent_req *subreq;
2643
2644         req = tevent_req_create(mem_ctx, &state,
2645                                 struct rpccli_svcctl_OpenSCManagerW_state);
2646         if (req == NULL) {
2647                 return NULL;
2648         }
2649         state->out_mem_ctx = NULL;
2650         state->dispatch_recv = cli->dispatch_recv;
2651
2652         /* In parameters */
2653         state->orig.in.MachineName = _MachineName;
2654         state->orig.in.DatabaseName = _DatabaseName;
2655         state->orig.in.access_mask = _access_mask;
2656
2657         /* Out parameters */
2658         state->orig.out.handle = _handle;
2659
2660         /* Result */
2661         ZERO_STRUCT(state->orig.out.result);
2662
2663         if (DEBUGLEVEL >= 10) {
2664                 NDR_PRINT_IN_DEBUG(svcctl_OpenSCManagerW, &state->orig);
2665         }
2666
2667         state->out_mem_ctx = talloc_named_const(state, 0,
2668                              "rpccli_svcctl_OpenSCManagerW_out_memory");
2669         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2670                 return tevent_req_post(req, ev);
2671         }
2672
2673         /* make a temporary copy, that we pass to the dispatch function */
2674         state->tmp = state->orig;
2675
2676         subreq = cli->dispatch_send(state, ev, cli,
2677                                     &ndr_table_svcctl,
2678                                     NDR_SVCCTL_OPENSCMANAGERW,
2679                                     &state->tmp);
2680         if (tevent_req_nomem(subreq, req)) {
2681                 return tevent_req_post(req, ev);
2682         }
2683         tevent_req_set_callback(subreq, rpccli_svcctl_OpenSCManagerW_done, req);
2684         return req;
2685 }
2686
2687 static void rpccli_svcctl_OpenSCManagerW_done(struct tevent_req *subreq)
2688 {
2689         struct tevent_req *req = tevent_req_callback_data(
2690                 subreq, struct tevent_req);
2691         struct rpccli_svcctl_OpenSCManagerW_state *state = tevent_req_data(
2692                 req, struct rpccli_svcctl_OpenSCManagerW_state);
2693         NTSTATUS status;
2694         TALLOC_CTX *mem_ctx;
2695
2696         if (state->out_mem_ctx) {
2697                 mem_ctx = state->out_mem_ctx;
2698         } else {
2699                 mem_ctx = state;
2700         }
2701
2702         status = state->dispatch_recv(subreq, mem_ctx);
2703         TALLOC_FREE(subreq);
2704         if (!NT_STATUS_IS_OK(status)) {
2705                 tevent_req_nterror(req, status);
2706                 return;
2707         }
2708
2709         /* Copy out parameters */
2710         *state->orig.out.handle = *state->tmp.out.handle;
2711
2712         /* Copy result */
2713         state->orig.out.result = state->tmp.out.result;
2714
2715         /* Reset temporary structure */
2716         ZERO_STRUCT(state->tmp);
2717
2718         if (DEBUGLEVEL >= 10) {
2719                 NDR_PRINT_OUT_DEBUG(svcctl_OpenSCManagerW, &state->orig);
2720         }
2721
2722         tevent_req_done(req);
2723 }
2724
2725 NTSTATUS rpccli_svcctl_OpenSCManagerW_recv(struct tevent_req *req,
2726                                            TALLOC_CTX *mem_ctx,
2727                                            WERROR *result)
2728 {
2729         struct rpccli_svcctl_OpenSCManagerW_state *state = tevent_req_data(
2730                 req, struct rpccli_svcctl_OpenSCManagerW_state);
2731         NTSTATUS status;
2732
2733         if (tevent_req_is_nterror(req, &status)) {
2734                 tevent_req_received(req);
2735                 return status;
2736         }
2737
2738         /* Steal possbile out parameters to the callers context */
2739         talloc_steal(mem_ctx, state->out_mem_ctx);
2740
2741         /* Return result */
2742         *result = state->orig.out.result;
2743
2744         tevent_req_received(req);
2745         return NT_STATUS_OK;
2746 }
2747
2748 NTSTATUS rpccli_svcctl_OpenSCManagerW(struct rpc_pipe_client *cli,
2749                                       TALLOC_CTX *mem_ctx,
2750                                       const char *MachineName /* [in] [unique,charset(UTF16)] */,
2751                                       const char *DatabaseName /* [in] [unique,charset(UTF16)] */,
2752                                       uint32_t access_mask /* [in]  */,
2753                                       struct policy_handle *handle /* [out] [ref] */,
2754                                       WERROR *werror)
2755 {
2756         struct svcctl_OpenSCManagerW r;
2757         NTSTATUS status;
2758
2759         /* In parameters */
2760         r.in.MachineName = MachineName;
2761         r.in.DatabaseName = DatabaseName;
2762         r.in.access_mask = access_mask;
2763
2764         if (DEBUGLEVEL >= 10) {
2765                 NDR_PRINT_IN_DEBUG(svcctl_OpenSCManagerW, &r);
2766         }
2767
2768         status = cli->dispatch(cli,
2769                                 mem_ctx,
2770                                 &ndr_table_svcctl,
2771                                 NDR_SVCCTL_OPENSCMANAGERW,
2772                                 &r);
2773
2774         if (!NT_STATUS_IS_OK(status)) {
2775                 return status;
2776         }
2777
2778         if (DEBUGLEVEL >= 10) {
2779                 NDR_PRINT_OUT_DEBUG(svcctl_OpenSCManagerW, &r);
2780         }
2781
2782         if (NT_STATUS_IS_ERR(status)) {
2783                 return status;
2784         }
2785
2786         /* Return variables */
2787         *handle = *r.out.handle;
2788
2789         /* Return result */
2790         if (werror) {
2791                 *werror = r.out.result;
2792         }
2793
2794         return werror_to_ntstatus(r.out.result);
2795 }
2796
2797 struct rpccli_svcctl_OpenServiceW_state {
2798         struct svcctl_OpenServiceW orig;
2799         struct svcctl_OpenServiceW tmp;
2800         TALLOC_CTX *out_mem_ctx;
2801         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2802 };
2803
2804 static void rpccli_svcctl_OpenServiceW_done(struct tevent_req *subreq);
2805
2806 struct tevent_req *rpccli_svcctl_OpenServiceW_send(TALLOC_CTX *mem_ctx,
2807                                                    struct tevent_context *ev,
2808                                                    struct rpc_pipe_client *cli,
2809                                                    struct policy_handle *_scmanager_handle /* [in] [ref] */,
2810                                                    const char *_ServiceName /* [in] [charset(UTF16)] */,
2811                                                    uint32_t _access_mask /* [in]  */,
2812                                                    struct policy_handle *_handle /* [out] [ref] */)
2813 {
2814         struct tevent_req *req;
2815         struct rpccli_svcctl_OpenServiceW_state *state;
2816         struct tevent_req *subreq;
2817
2818         req = tevent_req_create(mem_ctx, &state,
2819                                 struct rpccli_svcctl_OpenServiceW_state);
2820         if (req == NULL) {
2821                 return NULL;
2822         }
2823         state->out_mem_ctx = NULL;
2824         state->dispatch_recv = cli->dispatch_recv;
2825
2826         /* In parameters */
2827         state->orig.in.scmanager_handle = _scmanager_handle;
2828         state->orig.in.ServiceName = _ServiceName;
2829         state->orig.in.access_mask = _access_mask;
2830
2831         /* Out parameters */
2832         state->orig.out.handle = _handle;
2833
2834         /* Result */
2835         ZERO_STRUCT(state->orig.out.result);
2836
2837         if (DEBUGLEVEL >= 10) {
2838                 NDR_PRINT_IN_DEBUG(svcctl_OpenServiceW, &state->orig);
2839         }
2840
2841         state->out_mem_ctx = talloc_named_const(state, 0,
2842                              "rpccli_svcctl_OpenServiceW_out_memory");
2843         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2844                 return tevent_req_post(req, ev);
2845         }
2846
2847         /* make a temporary copy, that we pass to the dispatch function */
2848         state->tmp = state->orig;
2849
2850         subreq = cli->dispatch_send(state, ev, cli,
2851                                     &ndr_table_svcctl,
2852                                     NDR_SVCCTL_OPENSERVICEW,
2853                                     &state->tmp);
2854         if (tevent_req_nomem(subreq, req)) {
2855                 return tevent_req_post(req, ev);
2856         }
2857         tevent_req_set_callback(subreq, rpccli_svcctl_OpenServiceW_done, req);
2858         return req;
2859 }
2860
2861 static void rpccli_svcctl_OpenServiceW_done(struct tevent_req *subreq)
2862 {
2863         struct tevent_req *req = tevent_req_callback_data(
2864                 subreq, struct tevent_req);
2865         struct rpccli_svcctl_OpenServiceW_state *state = tevent_req_data(
2866                 req, struct rpccli_svcctl_OpenServiceW_state);
2867         NTSTATUS status;
2868         TALLOC_CTX *mem_ctx;
2869
2870         if (state->out_mem_ctx) {
2871                 mem_ctx = state->out_mem_ctx;
2872         } else {
2873                 mem_ctx = state;
2874         }
2875
2876         status = state->dispatch_recv(subreq, mem_ctx);
2877         TALLOC_FREE(subreq);
2878         if (!NT_STATUS_IS_OK(status)) {
2879                 tevent_req_nterror(req, status);
2880                 return;
2881         }
2882
2883         /* Copy out parameters */
2884         *state->orig.out.handle = *state->tmp.out.handle;
2885
2886         /* Copy result */
2887         state->orig.out.result = state->tmp.out.result;
2888
2889         /* Reset temporary structure */
2890         ZERO_STRUCT(state->tmp);
2891
2892         if (DEBUGLEVEL >= 10) {
2893                 NDR_PRINT_OUT_DEBUG(svcctl_OpenServiceW, &state->orig);
2894         }
2895
2896         tevent_req_done(req);
2897 }
2898
2899 NTSTATUS rpccli_svcctl_OpenServiceW_recv(struct tevent_req *req,
2900                                          TALLOC_CTX *mem_ctx,
2901                                          WERROR *result)
2902 {
2903         struct rpccli_svcctl_OpenServiceW_state *state = tevent_req_data(
2904                 req, struct rpccli_svcctl_OpenServiceW_state);
2905         NTSTATUS status;
2906
2907         if (tevent_req_is_nterror(req, &status)) {
2908                 tevent_req_received(req);
2909                 return status;
2910         }
2911
2912         /* Steal possbile out parameters to the callers context */
2913         talloc_steal(mem_ctx, state->out_mem_ctx);
2914
2915         /* Return result */
2916         *result = state->orig.out.result;
2917
2918         tevent_req_received(req);
2919         return NT_STATUS_OK;
2920 }
2921
2922 NTSTATUS rpccli_svcctl_OpenServiceW(struct rpc_pipe_client *cli,
2923                                     TALLOC_CTX *mem_ctx,
2924                                     struct policy_handle *scmanager_handle /* [in] [ref] */,
2925                                     const char *ServiceName /* [in] [charset(UTF16)] */,
2926                                     uint32_t access_mask /* [in]  */,
2927                                     struct policy_handle *handle /* [out] [ref] */,
2928                                     WERROR *werror)
2929 {
2930         struct svcctl_OpenServiceW r;
2931         NTSTATUS status;
2932
2933         /* In parameters */
2934         r.in.scmanager_handle = scmanager_handle;
2935         r.in.ServiceName = ServiceName;
2936         r.in.access_mask = access_mask;
2937
2938         if (DEBUGLEVEL >= 10) {
2939                 NDR_PRINT_IN_DEBUG(svcctl_OpenServiceW, &r);
2940         }
2941
2942         status = cli->dispatch(cli,
2943                                 mem_ctx,
2944                                 &ndr_table_svcctl,
2945                                 NDR_SVCCTL_OPENSERVICEW,
2946                                 &r);
2947
2948         if (!NT_STATUS_IS_OK(status)) {
2949                 return status;
2950         }
2951
2952         if (DEBUGLEVEL >= 10) {
2953                 NDR_PRINT_OUT_DEBUG(svcctl_OpenServiceW, &r);
2954         }
2955
2956         if (NT_STATUS_IS_ERR(status)) {
2957                 return status;
2958         }
2959
2960         /* Return variables */
2961         *handle = *r.out.handle;
2962
2963         /* Return result */
2964         if (werror) {
2965                 *werror = r.out.result;
2966         }
2967
2968         return werror_to_ntstatus(r.out.result);
2969 }
2970
2971 struct rpccli_svcctl_QueryServiceConfigW_state {
2972         struct svcctl_QueryServiceConfigW orig;
2973         struct svcctl_QueryServiceConfigW tmp;
2974         TALLOC_CTX *out_mem_ctx;
2975         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2976 };
2977
2978 static void rpccli_svcctl_QueryServiceConfigW_done(struct tevent_req *subreq);
2979
2980 struct tevent_req *rpccli_svcctl_QueryServiceConfigW_send(TALLOC_CTX *mem_ctx,
2981                                                           struct tevent_context *ev,
2982                                                           struct rpc_pipe_client *cli,
2983                                                           struct policy_handle *_handle /* [in] [ref] */,
2984                                                           struct QUERY_SERVICE_CONFIG *_query /* [out] [ref] */,
2985                                                           uint32_t _offered /* [in] [range(0,8192)] */,
2986                                                           uint32_t *_needed /* [out] [ref,range(0,8192)] */)
2987 {
2988         struct tevent_req *req;
2989         struct rpccli_svcctl_QueryServiceConfigW_state *state;
2990         struct tevent_req *subreq;
2991
2992         req = tevent_req_create(mem_ctx, &state,
2993                                 struct rpccli_svcctl_QueryServiceConfigW_state);
2994         if (req == NULL) {
2995                 return NULL;
2996         }
2997         state->out_mem_ctx = NULL;
2998         state->dispatch_recv = cli->dispatch_recv;
2999
3000         /* In parameters */
3001         state->orig.in.handle = _handle;
3002         state->orig.in.offered = _offered;
3003
3004         /* Out parameters */
3005         state->orig.out.query = _query;
3006         state->orig.out.needed = _needed;
3007
3008         /* Result */
3009         ZERO_STRUCT(state->orig.out.result);
3010
3011         if (DEBUGLEVEL >= 10) {
3012                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfigW, &state->orig);
3013         }
3014
3015         state->out_mem_ctx = talloc_named_const(state, 0,
3016                              "rpccli_svcctl_QueryServiceConfigW_out_memory");
3017         if (tevent_req_nomem(state->out_mem_ctx, req)) {
3018                 return tevent_req_post(req, ev);
3019         }
3020
3021         /* make a temporary copy, that we pass to the dispatch function */
3022         state->tmp = state->orig;
3023
3024         subreq = cli->dispatch_send(state, ev, cli,
3025                                     &ndr_table_svcctl,
3026                                     NDR_SVCCTL_QUERYSERVICECONFIGW,
3027                                     &state->tmp);
3028         if (tevent_req_nomem(subreq, req)) {
3029                 return tevent_req_post(req, ev);
3030         }
3031         tevent_req_set_callback(subreq, rpccli_svcctl_QueryServiceConfigW_done, req);
3032         return req;
3033 }
3034
3035 static void rpccli_svcctl_QueryServiceConfigW_done(struct tevent_req *subreq)
3036 {
3037         struct tevent_req *req = tevent_req_callback_data(
3038                 subreq, struct tevent_req);
3039         struct rpccli_svcctl_QueryServiceConfigW_state *state = tevent_req_data(
3040                 req, struct rpccli_svcctl_QueryServiceConfigW_state);
3041         NTSTATUS status;
3042         TALLOC_CTX *mem_ctx;
3043
3044         if (state->out_mem_ctx) {
3045                 mem_ctx = state->out_mem_ctx;
3046         } else {
3047                 mem_ctx = state;
3048         }
3049
3050         status = state->dispatch_recv(subreq, mem_ctx);
3051         TALLOC_FREE(subreq);
3052         if (!NT_STATUS_IS_OK(status)) {
3053                 tevent_req_nterror(req, status);
3054                 return;
3055         }
3056
3057         /* Copy out parameters */
3058         *state->orig.out.query = *state->tmp.out.query;
3059         *state->orig.out.needed = *state->tmp.out.needed;
3060
3061         /* Copy result */
3062         state->orig.out.result = state->tmp.out.result;
3063
3064         /* Reset temporary structure */
3065         ZERO_STRUCT(state->tmp);
3066
3067         if (DEBUGLEVEL >= 10) {
3068                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfigW, &state->orig);
3069         }
3070
3071         tevent_req_done(req);
3072 }
3073
3074 NTSTATUS rpccli_svcctl_QueryServiceConfigW_recv(struct tevent_req *req,
3075                                                 TALLOC_CTX *mem_ctx,
3076                                                 WERROR *result)
3077 {
3078         struct rpccli_svcctl_QueryServiceConfigW_state *state = tevent_req_data(
3079                 req, struct rpccli_svcctl_QueryServiceConfigW_state);
3080         NTSTATUS status;
3081
3082         if (tevent_req_is_nterror(req, &status)) {
3083                 tevent_req_received(req);
3084                 return status;
3085         }
3086
3087         /* Steal possbile out parameters to the callers context */
3088         talloc_steal(mem_ctx, state->out_mem_ctx);
3089
3090         /* Return result */
3091         *result = state->orig.out.result;
3092
3093         tevent_req_received(req);
3094         return NT_STATUS_OK;
3095 }
3096
3097 NTSTATUS rpccli_svcctl_QueryServiceConfigW(struct rpc_pipe_client *cli,
3098                                            TALLOC_CTX *mem_ctx,
3099                                            struct policy_handle *handle /* [in] [ref] */,
3100                                            struct QUERY_SERVICE_CONFIG *query /* [out] [ref] */,
3101                                            uint32_t offered /* [in] [range(0,8192)] */,
3102                                            uint32_t *needed /* [out] [ref,range(0,8192)] */,
3103                                            WERROR *werror)
3104 {
3105         struct svcctl_QueryServiceConfigW r;
3106         NTSTATUS status;
3107
3108         /* In parameters */
3109         r.in.handle = handle;
3110         r.in.offered = offered;
3111
3112         if (DEBUGLEVEL >= 10) {
3113                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfigW, &r);
3114         }
3115
3116         status = cli->dispatch(cli,
3117                                 mem_ctx,
3118                                 &ndr_table_svcctl,
3119                                 NDR_SVCCTL_QUERYSERVICECONFIGW,
3120                                 &r);
3121
3122         if (!NT_STATUS_IS_OK(status)) {
3123                 return status;
3124         }
3125
3126         if (DEBUGLEVEL >= 10) {
3127                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfigW, &r);
3128         }
3129
3130         if (NT_STATUS_IS_ERR(status)) {
3131                 return status;
3132         }
3133
3134         /* Return variables */
3135         *query = *r.out.query;
3136         *needed = *r.out.needed;
3137
3138         /* Return result */
3139         if (werror) {
3140                 *werror = r.out.result;
3141         }
3142
3143         return werror_to_ntstatus(r.out.result);
3144 }
3145
3146 struct rpccli_svcctl_QueryServiceLockStatusW_state {
3147         struct svcctl_QueryServiceLockStatusW orig;
3148         struct svcctl_QueryServiceLockStatusW tmp;
3149         TALLOC_CTX *out_mem_ctx;
3150         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3151 };
3152
3153 static void rpccli_svcctl_QueryServiceLockStatusW_done(struct tevent_req *subreq);
3154
3155 struct tevent_req *rpccli_svcctl_QueryServiceLockStatusW_send(TALLOC_CTX *mem_ctx,
3156                                                               struct tevent_context *ev,
3157                                                               struct rpc_pipe_client *cli,
3158                                                               struct policy_handle *_handle /* [in] [ref] */,
3159                                                               uint32_t _offered /* [in]  */,
3160                                                               struct SERVICE_LOCK_STATUS *_lock_status /* [out] [ref] */,
3161                                                               uint32_t *_needed /* [out] [ref] */)
3162 {
3163         struct tevent_req *req;
3164         struct rpccli_svcctl_QueryServiceLockStatusW_state *state;
3165         struct tevent_req *subreq;
3166
3167         req = tevent_req_create(mem_ctx, &state,
3168                                 struct rpccli_svcctl_QueryServiceLockStatusW_state);
3169         if (req == NULL) {
3170                 return NULL;
3171         }
3172         state->out_mem_ctx = NULL;
3173         state->dispatch_recv = cli->dispatch_recv;
3174
3175         /* In parameters */
3176         state->orig.in.handle = _handle;
3177         state->orig.in.offered = _offered;
3178
3179         /* Out parameters */
3180         state->orig.out.lock_status = _lock_status;
3181         state->orig.out.needed = _needed;
3182
3183         /* Result */
3184         ZERO_STRUCT(state->orig.out.result);
3185
3186         if (DEBUGLEVEL >= 10) {
3187                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceLockStatusW, &state->orig);
3188         }
3189
3190         state->out_mem_ctx = talloc_named_const(state, 0,
3191                              "rpccli_svcctl_QueryServiceLockStatusW_out_memory");
3192         if (tevent_req_nomem(state->out_mem_ctx, req)) {
3193                 return tevent_req_post(req, ev);
3194         }
3195
3196         /* make a temporary copy, that we pass to the dispatch function */
3197         state->tmp = state->orig;
3198
3199         subreq = cli->dispatch_send(state, ev, cli,
3200                                     &ndr_table_svcctl,
3201                                     NDR_SVCCTL_QUERYSERVICELOCKSTATUSW,
3202                                     &state->tmp);
3203         if (tevent_req_nomem(subreq, req)) {
3204                 return tevent_req_post(req, ev);
3205         }
3206         tevent_req_set_callback(subreq, rpccli_svcctl_QueryServiceLockStatusW_done, req);
3207         return req;
3208 }
3209
3210 static void rpccli_svcctl_QueryServiceLockStatusW_done(struct tevent_req *subreq)
3211 {
3212         struct tevent_req *req = tevent_req_callback_data(
3213                 subreq, struct tevent_req);
3214         struct rpccli_svcctl_QueryServiceLockStatusW_state *state = tevent_req_data(
3215                 req, struct rpccli_svcctl_QueryServiceLockStatusW_state);
3216         NTSTATUS status;
3217         TALLOC_CTX *mem_ctx;
3218
3219         if (state->out_mem_ctx) {
3220                 mem_ctx = state->out_mem_ctx;
3221         } else {
3222                 mem_ctx = state;
3223         }
3224
3225         status = state->dispatch_recv(subreq, mem_ctx);
3226         TALLOC_FREE(subreq);
3227         if (!NT_STATUS_IS_OK(status)) {
3228                 tevent_req_nterror(req, status);
3229                 return;
3230         }
3231
3232         /* Copy out parameters */
3233         *state->orig.out.lock_status = *state->tmp.out.lock_status;
3234         *state->orig.out.needed = *state->tmp.out.needed;
3235
3236         /* Copy result */
3237         state->orig.out.result = state->tmp.out.result;
3238
3239         /* Reset temporary structure */
3240         ZERO_STRUCT(state->tmp);
3241
3242         if (DEBUGLEVEL >= 10) {
3243                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceLockStatusW, &state->orig);
3244         }
3245
3246         tevent_req_done(req);
3247 }
3248
3249 NTSTATUS rpccli_svcctl_QueryServiceLockStatusW_recv(struct tevent_req *req,
3250                                                     TALLOC_CTX *mem_ctx,
3251                                                     WERROR *result)
3252 {
3253         struct rpccli_svcctl_QueryServiceLockStatusW_state *state = tevent_req_data(
3254                 req, struct rpccli_svcctl_QueryServiceLockStatusW_state);
3255         NTSTATUS status;
3256
3257         if (tevent_req_is_nterror(req, &status)) {
3258                 tevent_req_received(req);
3259                 return status;
3260         }
3261
3262         /* Steal possbile out parameters to the callers context */
3263         talloc_steal(mem_ctx, state->out_mem_ctx);
3264
3265         /* Return result */
3266         *result = state->orig.out.result;
3267
3268         tevent_req_received(req);
3269         return NT_STATUS_OK;
3270 }
3271
3272 NTSTATUS rpccli_svcctl_QueryServiceLockStatusW(struct rpc_pipe_client *cli,
3273                                                TALLOC_CTX *mem_ctx,
3274                                                struct policy_handle *handle /* [in] [ref] */,
3275                                                uint32_t offered /* [in]  */,
3276                                                struct SERVICE_LOCK_STATUS *lock_status /* [out] [ref] */,
3277                                                uint32_t *needed /* [out] [ref] */,
3278                                                WERROR *werror)
3279 {
3280         struct svcctl_QueryServiceLockStatusW r;
3281         NTSTATUS status;
3282
3283         /* In parameters */
3284         r.in.handle = handle;
3285         r.in.offered = offered;
3286
3287         if (DEBUGLEVEL >= 10) {
3288                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceLockStatusW, &r);
3289         }
3290
3291         status = cli->dispatch(cli,
3292                                 mem_ctx,
3293                                 &ndr_table_svcctl,
3294                                 NDR_SVCCTL_QUERYSERVICELOCKSTATUSW,
3295                                 &r);
3296
3297         if (!NT_STATUS_IS_OK(status)) {
3298                 return status;
3299         }
3300
3301         if (DEBUGLEVEL >= 10) {
3302                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceLockStatusW, &r);
3303         }
3304
3305         if (NT_STATUS_IS_ERR(status)) {
3306                 return status;
3307         }
3308
3309         /* Return variables */
3310         *lock_status = *r.out.lock_status;
3311         *needed = *r.out.needed;
3312
3313         /* Return result */
3314         if (werror) {
3315                 *werror = r.out.result;
3316         }
3317
3318         return werror_to_ntstatus(r.out.result);
3319 }
3320
3321 struct rpccli_svcctl_StartServiceW_state {
3322         struct svcctl_StartServiceW orig;
3323         struct svcctl_StartServiceW tmp;
3324         TALLOC_CTX *out_mem_ctx;
3325         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3326 };
3327
3328 static void rpccli_svcctl_StartServiceW_done(struct tevent_req *subreq);
3329
3330 struct tevent_req *rpccli_svcctl_StartServiceW_send(TALLOC_CTX *mem_ctx,
3331                                                     struct tevent_context *ev,
3332                                                     struct rpc_pipe_client *cli,
3333                                                     struct policy_handle *_handle /* [in] [ref] */,
3334                                                     uint32_t _NumArgs /* [in] [range(0,SC_MAX_ARGUMENTS)] */,
3335                                                     struct svcctl_ArgumentString *_Arguments /* [in] [unique,size_is(NumArgs)] */)
3336 {
3337         struct tevent_req *req;
3338         struct rpccli_svcctl_StartServiceW_state *state;
3339         struct tevent_req *subreq;
3340
3341         req = tevent_req_create(mem_ctx, &state,
3342                                 struct rpccli_svcctl_StartServiceW_state);
3343         if (req == NULL) {
3344                 return NULL;
3345         }
3346         state->out_mem_ctx = NULL;
3347         state->dispatch_recv = cli->dispatch_recv;
3348
3349         /* In parameters */
3350         state->orig.in.handle = _handle;
3351         state->orig.in.NumArgs = _NumArgs;
3352         state->orig.in.Arguments = _Arguments;
3353
3354         /* Out parameters */
3355
3356         /* Result */
3357         ZERO_STRUCT(state->orig.out.result);
3358
3359         if (DEBUGLEVEL >= 10) {
3360                 NDR_PRINT_IN_DEBUG(svcctl_StartServiceW, &state->orig);
3361         }
3362
3363         /* make a temporary copy, that we pass to the dispatch function */
3364         state->tmp = state->orig;
3365
3366         subreq = cli->dispatch_send(state, ev, cli,
3367                                     &ndr_table_svcctl,
3368                                     NDR_SVCCTL_STARTSERVICEW,
3369                                     &state->tmp);
3370         if (tevent_req_nomem(subreq, req)) {
3371                 return tevent_req_post(req, ev);
3372         }
3373         tevent_req_set_callback(subreq, rpccli_svcctl_StartServiceW_done, req);
3374         return req;
3375 }
3376
3377 static void rpccli_svcctl_StartServiceW_done(struct tevent_req *subreq)
3378 {
3379         struct tevent_req *req = tevent_req_callback_data(
3380                 subreq, struct tevent_req);
3381         struct rpccli_svcctl_StartServiceW_state *state = tevent_req_data(
3382                 req, struct rpccli_svcctl_StartServiceW_state);
3383         NTSTATUS status;
3384         TALLOC_CTX *mem_ctx;
3385
3386         if (state->out_mem_ctx) {
3387                 mem_ctx = state->out_mem_ctx;
3388         } else {
3389                 mem_ctx = state;
3390         }
3391
3392         status = state->dispatch_recv(subreq, mem_ctx);
3393         TALLOC_FREE(subreq);
3394         if (!NT_STATUS_IS_OK(status)) {
3395                 tevent_req_nterror(req, status);
3396                 return;
3397         }
3398
3399         /* Copy out parameters */
3400
3401         /* Copy result */
3402         state->orig.out.result = state->tmp.out.result;
3403
3404         /* Reset temporary structure */
3405         ZERO_STRUCT(state->tmp);
3406
3407         if (DEBUGLEVEL >= 10) {
3408                 NDR_PRINT_OUT_DEBUG(svcctl_StartServiceW, &state->orig);
3409         }
3410
3411         tevent_req_done(req);
3412 }
3413
3414 NTSTATUS rpccli_svcctl_StartServiceW_recv(struct tevent_req *req,
3415                                           TALLOC_CTX *mem_ctx,
3416                                           WERROR *result)
3417 {
3418         struct rpccli_svcctl_StartServiceW_state *state = tevent_req_data(
3419                 req, struct rpccli_svcctl_StartServiceW_state);
3420         NTSTATUS status;
3421
3422         if (tevent_req_is_nterror(req, &status)) {
3423                 tevent_req_received(req);
3424                 return status;
3425         }
3426
3427         /* Steal possbile out parameters to the callers context */
3428         talloc_steal(mem_ctx, state->out_mem_ctx);
3429
3430         /* Return result */
3431         *result = state->orig.out.result;
3432
3433         tevent_req_received(req);
3434         return NT_STATUS_OK;
3435 }
3436
3437 NTSTATUS rpccli_svcctl_StartServiceW(struct rpc_pipe_client *cli,
3438                                      TALLOC_CTX *mem_ctx,
3439                                      struct policy_handle *handle /* [in] [ref] */,
3440                                      uint32_t NumArgs /* [in] [range(0,SC_MAX_ARGUMENTS)] */,
3441                                      struct svcctl_ArgumentString *Arguments /* [in] [unique,size_is(NumArgs)] */,
3442                                      WERROR *werror)
3443 {
3444         struct svcctl_StartServiceW r;
3445         NTSTATUS status;
3446
3447         /* In parameters */
3448         r.in.handle = handle;
3449         r.in.NumArgs = NumArgs;
3450         r.in.Arguments = Arguments;
3451
3452         if (DEBUGLEVEL >= 10) {
3453                 NDR_PRINT_IN_DEBUG(svcctl_StartServiceW, &r);
3454         }
3455
3456         status = cli->dispatch(cli,
3457                                 mem_ctx,
3458                                 &ndr_table_svcctl,
3459                                 NDR_SVCCTL_STARTSERVICEW,
3460                                 &r);
3461
3462         if (!NT_STATUS_IS_OK(status)) {
3463                 return status;
3464         }
3465
3466         if (DEBUGLEVEL >= 10) {
3467                 NDR_PRINT_OUT_DEBUG(svcctl_StartServiceW, &r);
3468         }
3469
3470         if (NT_STATUS_IS_ERR(status)) {
3471                 return status;
3472         }
3473
3474         /* Return variables */
3475
3476         /* Return result */
3477         if (werror) {
3478                 *werror = r.out.result;
3479         }
3480
3481         return werror_to_ntstatus(r.out.result);
3482 }
3483
3484 struct rpccli_svcctl_GetServiceDisplayNameW_state {
3485         struct svcctl_GetServiceDisplayNameW orig;
3486         struct svcctl_GetServiceDisplayNameW tmp;
3487         TALLOC_CTX *out_mem_ctx;
3488         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3489 };
3490
3491 static void rpccli_svcctl_GetServiceDisplayNameW_done(struct tevent_req *subreq);
3492
3493 struct tevent_req *rpccli_svcctl_GetServiceDisplayNameW_send(TALLOC_CTX *mem_ctx,
3494                                                              struct tevent_context *ev,
3495                                                              struct rpc_pipe_client *cli,
3496                                                              struct policy_handle *_handle /* [in] [ref] */,
3497                                                              const char *_service_name /* [in] [unique,charset(UTF16)] */,
3498                                                              const char **_display_name /* [out] [ref,charset(UTF16)] */,
3499                                                              uint32_t *_display_name_length /* [in,out] [unique] */)
3500 {
3501         struct tevent_req *req;
3502         struct rpccli_svcctl_GetServiceDisplayNameW_state *state;
3503         struct tevent_req *subreq;
3504
3505         req = tevent_req_create(mem_ctx, &state,
3506                                 struct rpccli_svcctl_GetServiceDisplayNameW_state);
3507         if (req == NULL) {
3508                 return NULL;
3509         }
3510         state->out_mem_ctx = NULL;
3511         state->dispatch_recv = cli->dispatch_recv;
3512
3513         /* In parameters */
3514         state->orig.in.handle = _handle;
3515         state->orig.in.service_name = _service_name;
3516         state->orig.in.display_name_length = _display_name_length;
3517
3518         /* Out parameters */
3519         state->orig.out.display_name = _display_name;
3520         state->orig.out.display_name_length = _display_name_length;
3521
3522         /* Result */
3523         ZERO_STRUCT(state->orig.out.result);
3524
3525         if (DEBUGLEVEL >= 10) {
3526                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceDisplayNameW, &state->orig);
3527         }
3528
3529         state->out_mem_ctx = talloc_named_const(state, 0,
3530                              "rpccli_svcctl_GetServiceDisplayNameW_out_memory");
3531         if (tevent_req_nomem(state->out_mem_ctx, req)) {
3532                 return tevent_req_post(req, ev);
3533         }
3534
3535         /* make a temporary copy, that we pass to the dispatch function */
3536         state->tmp = state->orig;
3537
3538         subreq = cli->dispatch_send(state, ev, cli,
3539                                     &ndr_table_svcctl,
3540                                     NDR_SVCCTL_GETSERVICEDISPLAYNAMEW,
3541                                     &state->tmp);
3542         if (tevent_req_nomem(subreq, req)) {
3543                 return tevent_req_post(req, ev);
3544         }
3545         tevent_req_set_callback(subreq, rpccli_svcctl_GetServiceDisplayNameW_done, req);
3546         return req;
3547 }
3548
3549 static void rpccli_svcctl_GetServiceDisplayNameW_done(struct tevent_req *subreq)
3550 {
3551         struct tevent_req *req = tevent_req_callback_data(
3552                 subreq, struct tevent_req);
3553         struct rpccli_svcctl_GetServiceDisplayNameW_state *state = tevent_req_data(
3554                 req, struct rpccli_svcctl_GetServiceDisplayNameW_state);
3555         NTSTATUS status;
3556         TALLOC_CTX *mem_ctx;
3557
3558         if (state->out_mem_ctx) {
3559                 mem_ctx = state->out_mem_ctx;
3560         } else {
3561                 mem_ctx = state;
3562         }
3563
3564         status = state->dispatch_recv(subreq, mem_ctx);
3565         TALLOC_FREE(subreq);
3566         if (!NT_STATUS_IS_OK(status)) {
3567                 tevent_req_nterror(req, status);
3568                 return;
3569         }
3570
3571         /* Copy out parameters */
3572         *state->orig.out.display_name = *state->tmp.out.display_name;
3573         if (state->orig.out.display_name_length && state->tmp.out.display_name_length) {
3574                 *state->orig.out.display_name_length = *state->tmp.out.display_name_length;
3575         }
3576
3577         /* Copy result */
3578         state->orig.out.result = state->tmp.out.result;
3579
3580         /* Reset temporary structure */
3581         ZERO_STRUCT(state->tmp);
3582
3583         if (DEBUGLEVEL >= 10) {
3584                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceDisplayNameW, &state->orig);
3585         }
3586
3587         tevent_req_done(req);
3588 }
3589
3590 NTSTATUS rpccli_svcctl_GetServiceDisplayNameW_recv(struct tevent_req *req,
3591                                                    TALLOC_CTX *mem_ctx,
3592                                                    WERROR *result)
3593 {
3594         struct rpccli_svcctl_GetServiceDisplayNameW_state *state = tevent_req_data(
3595                 req, struct rpccli_svcctl_GetServiceDisplayNameW_state);
3596         NTSTATUS status;
3597
3598         if (tevent_req_is_nterror(req, &status)) {
3599                 tevent_req_received(req);
3600                 return status;
3601         }
3602
3603         /* Steal possbile out parameters to the callers context */
3604         talloc_steal(mem_ctx, state->out_mem_ctx);
3605
3606         /* Return result */
3607         *result = state->orig.out.result;
3608
3609         tevent_req_received(req);
3610         return NT_STATUS_OK;
3611 }
3612
3613 NTSTATUS rpccli_svcctl_GetServiceDisplayNameW(struct rpc_pipe_client *cli,
3614                                               TALLOC_CTX *mem_ctx,
3615                                               struct policy_handle *handle /* [in] [ref] */,
3616                                               const char *service_name /* [in] [unique,charset(UTF16)] */,
3617                                               const char **display_name /* [out] [ref,charset(UTF16)] */,
3618                                               uint32_t *display_name_length /* [in,out] [unique] */,
3619                                               WERROR *werror)
3620 {
3621         struct svcctl_GetServiceDisplayNameW r;
3622         NTSTATUS status;
3623
3624         /* In parameters */
3625         r.in.handle = handle;
3626         r.in.service_name = service_name;
3627         r.in.display_name_length = display_name_length;
3628
3629         if (DEBUGLEVEL >= 10) {
3630                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceDisplayNameW, &r);
3631         }
3632
3633         status = cli->dispatch(cli,
3634                                 mem_ctx,
3635                                 &ndr_table_svcctl,
3636                                 NDR_SVCCTL_GETSERVICEDISPLAYNAMEW,
3637                                 &r);
3638
3639         if (!NT_STATUS_IS_OK(status)) {
3640                 return status;
3641         }
3642
3643         if (DEBUGLEVEL >= 10) {
3644                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceDisplayNameW, &r);
3645         }
3646
3647         if (NT_STATUS_IS_ERR(status)) {
3648                 return status;
3649         }
3650
3651         /* Return variables */
3652         *display_name = *r.out.display_name;
3653         if (display_name_length && r.out.display_name_length) {
3654                 *display_name_length = *r.out.display_name_length;
3655         }
3656
3657         /* Return result */
3658         if (werror) {
3659                 *werror = r.out.result;
3660         }
3661
3662         return werror_to_ntstatus(r.out.result);
3663 }
3664
3665 struct rpccli_svcctl_GetServiceKeyNameW_state {
3666         struct svcctl_GetServiceKeyNameW orig;
3667         struct svcctl_GetServiceKeyNameW tmp;
3668         TALLOC_CTX *out_mem_ctx;
3669         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3670 };
3671
3672 static void rpccli_svcctl_GetServiceKeyNameW_done(struct tevent_req *subreq);
3673
3674 struct tevent_req *rpccli_svcctl_GetServiceKeyNameW_send(TALLOC_CTX *mem_ctx,
3675                                                          struct tevent_context *ev,
3676                                                          struct rpc_pipe_client *cli,
3677                                                          struct policy_handle *_handle /* [in] [ref] */,
3678                                                          const char *_service_name /* [in] [unique,charset(UTF16)] */,
3679                                                          const char **_key_name /* [out] [ref,charset(UTF16)] */,
3680                                                          uint32_t *_display_name_length /* [in,out] [unique] */)
3681 {
3682         struct tevent_req *req;
3683         struct rpccli_svcctl_GetServiceKeyNameW_state *state;
3684         struct tevent_req *subreq;
3685
3686         req = tevent_req_create(mem_ctx, &state,
3687                                 struct rpccli_svcctl_GetServiceKeyNameW_state);
3688         if (req == NULL) {
3689                 return NULL;
3690         }
3691         state->out_mem_ctx = NULL;
3692         state->dispatch_recv = cli->dispatch_recv;
3693
3694         /* In parameters */
3695         state->orig.in.handle = _handle;
3696         state->orig.in.service_name = _service_name;
3697         state->orig.in.display_name_length = _display_name_length;
3698
3699         /* Out parameters */
3700         state->orig.out.key_name = _key_name;
3701         state->orig.out.display_name_length = _display_name_length;
3702
3703         /* Result */
3704         ZERO_STRUCT(state->orig.out.result);
3705
3706         if (DEBUGLEVEL >= 10) {
3707                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceKeyNameW, &state->orig);
3708         }
3709
3710         state->out_mem_ctx = talloc_named_const(state, 0,
3711                              "rpccli_svcctl_GetServiceKeyNameW_out_memory");
3712         if (tevent_req_nomem(state->out_mem_ctx, req)) {
3713                 return tevent_req_post(req, ev);
3714         }
3715
3716         /* make a temporary copy, that we pass to the dispatch function */
3717         state->tmp = state->orig;
3718
3719         subreq = cli->dispatch_send(state, ev, cli,
3720                                     &ndr_table_svcctl,
3721                                     NDR_SVCCTL_GETSERVICEKEYNAMEW,
3722                                     &state->tmp);
3723         if (tevent_req_nomem(subreq, req)) {
3724                 return tevent_req_post(req, ev);
3725         }
3726         tevent_req_set_callback(subreq, rpccli_svcctl_GetServiceKeyNameW_done, req);
3727         return req;
3728 }
3729
3730 static void rpccli_svcctl_GetServiceKeyNameW_done(struct tevent_req *subreq)
3731 {
3732         struct tevent_req *req = tevent_req_callback_data(
3733                 subreq, struct tevent_req);
3734         struct rpccli_svcctl_GetServiceKeyNameW_state *state = tevent_req_data(
3735                 req, struct rpccli_svcctl_GetServiceKeyNameW_state);
3736         NTSTATUS status;
3737         TALLOC_CTX *mem_ctx;
3738
3739         if (state->out_mem_ctx) {
3740                 mem_ctx = state->out_mem_ctx;
3741         } else {
3742                 mem_ctx = state;
3743         }
3744
3745         status = state->dispatch_recv(subreq, mem_ctx);
3746         TALLOC_FREE(subreq);
3747         if (!NT_STATUS_IS_OK(status)) {
3748                 tevent_req_nterror(req, status);
3749                 return;
3750         }
3751
3752         /* Copy out parameters */
3753         *state->orig.out.key_name = *state->tmp.out.key_name;
3754         if (state->orig.out.display_name_length && state->tmp.out.display_name_length) {
3755                 *state->orig.out.display_name_length = *state->tmp.out.display_name_length;
3756         }
3757
3758         /* Copy result */
3759         state->orig.out.result = state->tmp.out.result;
3760
3761         /* Reset temporary structure */
3762         ZERO_STRUCT(state->tmp);
3763
3764         if (DEBUGLEVEL >= 10) {
3765                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceKeyNameW, &state->orig);
3766         }
3767
3768         tevent_req_done(req);
3769 }
3770
3771 NTSTATUS rpccli_svcctl_GetServiceKeyNameW_recv(struct tevent_req *req,
3772                                                TALLOC_CTX *mem_ctx,
3773                                                WERROR *result)
3774 {
3775         struct rpccli_svcctl_GetServiceKeyNameW_state *state = tevent_req_data(
3776                 req, struct rpccli_svcctl_GetServiceKeyNameW_state);
3777         NTSTATUS status;
3778
3779         if (tevent_req_is_nterror(req, &status)) {
3780                 tevent_req_received(req);
3781                 return status;
3782         }
3783
3784         /* Steal possbile out parameters to the callers context */
3785         talloc_steal(mem_ctx, state->out_mem_ctx);
3786
3787         /* Return result */
3788         *result = state->orig.out.result;
3789
3790         tevent_req_received(req);
3791         return NT_STATUS_OK;
3792 }
3793
3794 NTSTATUS rpccli_svcctl_GetServiceKeyNameW(struct rpc_pipe_client *cli,
3795                                           TALLOC_CTX *mem_ctx,
3796                                           struct policy_handle *handle /* [in] [ref] */,
3797                                           const char *service_name /* [in] [unique,charset(UTF16)] */,
3798                                           const char **key_name /* [out] [ref,charset(UTF16)] */,
3799                                           uint32_t *display_name_length /* [in,out] [unique] */,
3800                                           WERROR *werror)
3801 {
3802         struct svcctl_GetServiceKeyNameW r;
3803         NTSTATUS status;
3804
3805         /* In parameters */
3806         r.in.handle = handle;
3807         r.in.service_name = service_name;
3808         r.in.display_name_length = display_name_length;
3809
3810         if (DEBUGLEVEL >= 10) {
3811                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceKeyNameW, &r);
3812         }
3813
3814         status = cli->dispatch(cli,
3815                                 mem_ctx,
3816                                 &ndr_table_svcctl,
3817                                 NDR_SVCCTL_GETSERVICEKEYNAMEW,
3818                                 &r);
3819
3820         if (!NT_STATUS_IS_OK(status)) {
3821                 return status;
3822         }
3823
3824         if (DEBUGLEVEL >= 10) {
3825                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceKeyNameW, &r);
3826         }
3827
3828         if (NT_STATUS_IS_ERR(status)) {
3829                 return status;
3830         }
3831
3832         /* Return variables */
3833         *key_name = *r.out.key_name;
3834         if (display_name_length && r.out.display_name_length) {
3835                 *display_name_length = *r.out.display_name_length;
3836         }
3837
3838         /* Return result */
3839         if (werror) {
3840                 *werror = r.out.result;
3841         }
3842
3843         return werror_to_ntstatus(r.out.result);
3844 }
3845
3846 struct rpccli_svcctl_SCSetServiceBitsA_state {
3847         struct svcctl_SCSetServiceBitsA orig;
3848         struct svcctl_SCSetServiceBitsA tmp;
3849         TALLOC_CTX *out_mem_ctx;
3850         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3851 };
3852
3853 static void rpccli_svcctl_SCSetServiceBitsA_done(struct tevent_req *subreq);
3854
3855 struct tevent_req *rpccli_svcctl_SCSetServiceBitsA_send(TALLOC_CTX *mem_ctx,
3856                                                         struct tevent_context *ev,
3857                                                         struct rpc_pipe_client *cli,
3858                                                         struct policy_handle *_handle /* [in] [ref] */,
3859                                                         uint32_t _bits /* [in]  */,
3860                                                         uint32_t _bitson /* [in]  */,
3861                                                         uint32_t _immediate /* [in]  */)
3862 {
3863         struct tevent_req *req;
3864         struct rpccli_svcctl_SCSetServiceBitsA_state *state;
3865         struct tevent_req *subreq;
3866
3867         req = tevent_req_create(mem_ctx, &state,
3868                                 struct rpccli_svcctl_SCSetServiceBitsA_state);
3869         if (req == NULL) {
3870                 return NULL;
3871         }
3872         state->out_mem_ctx = NULL;
3873         state->dispatch_recv = cli->dispatch_recv;
3874
3875         /* In parameters */
3876         state->orig.in.handle = _handle;
3877         state->orig.in.bits = _bits;
3878         state->orig.in.bitson = _bitson;
3879         state->orig.in.immediate = _immediate;
3880
3881         /* Out parameters */
3882
3883         /* Result */
3884         ZERO_STRUCT(state->orig.out.result);
3885
3886         if (DEBUGLEVEL >= 10) {
3887                 NDR_PRINT_IN_DEBUG(svcctl_SCSetServiceBitsA, &state->orig);
3888         }
3889
3890         /* make a temporary copy, that we pass to the dispatch function */
3891         state->tmp = state->orig;
3892
3893         subreq = cli->dispatch_send(state, ev, cli,
3894                                     &ndr_table_svcctl,
3895                                     NDR_SVCCTL_SCSETSERVICEBITSA,
3896                                     &state->tmp);
3897         if (tevent_req_nomem(subreq, req)) {
3898                 return tevent_req_post(req, ev);
3899         }
3900         tevent_req_set_callback(subreq, rpccli_svcctl_SCSetServiceBitsA_done, req);
3901         return req;
3902 }
3903
3904 static void rpccli_svcctl_SCSetServiceBitsA_done(struct tevent_req *subreq)
3905 {
3906         struct tevent_req *req = tevent_req_callback_data(
3907                 subreq, struct tevent_req);
3908         struct rpccli_svcctl_SCSetServiceBitsA_state *state = tevent_req_data(
3909                 req, struct rpccli_svcctl_SCSetServiceBitsA_state);
3910         NTSTATUS status;
3911         TALLOC_CTX *mem_ctx;
3912
3913         if (state->out_mem_ctx) {
3914                 mem_ctx = state->out_mem_ctx;
3915         } else {
3916                 mem_ctx = state;
3917         }
3918
3919         status = state->dispatch_recv(subreq, mem_ctx);
3920         TALLOC_FREE(subreq);
3921         if (!NT_STATUS_IS_OK(status)) {
3922                 tevent_req_nterror(req, status);
3923                 return;
3924         }
3925
3926         /* Copy out parameters */
3927
3928         /* Copy result */
3929         state->orig.out.result = state->tmp.out.result;
3930
3931         /* Reset temporary structure */
3932         ZERO_STRUCT(state->tmp);
3933
3934         if (DEBUGLEVEL >= 10) {
3935                 NDR_PRINT_OUT_DEBUG(svcctl_SCSetServiceBitsA, &state->orig);
3936         }
3937
3938         tevent_req_done(req);
3939 }
3940
3941 NTSTATUS rpccli_svcctl_SCSetServiceBitsA_recv(struct tevent_req *req,
3942                                               TALLOC_CTX *mem_ctx,
3943                                               WERROR *result)
3944 {
3945         struct rpccli_svcctl_SCSetServiceBitsA_state *state = tevent_req_data(
3946                 req, struct rpccli_svcctl_SCSetServiceBitsA_state);
3947         NTSTATUS status;
3948
3949         if (tevent_req_is_nterror(req, &status)) {
3950                 tevent_req_received(req);
3951                 return status;
3952         }
3953
3954         /* Steal possbile out parameters to the callers context */
3955         talloc_steal(mem_ctx, state->out_mem_ctx);
3956
3957         /* Return result */
3958         *result = state->orig.out.result;
3959
3960         tevent_req_received(req);
3961         return NT_STATUS_OK;
3962 }
3963
3964 NTSTATUS rpccli_svcctl_SCSetServiceBitsA(struct rpc_pipe_client *cli,
3965                                          TALLOC_CTX *mem_ctx,
3966                                          struct policy_handle *handle /* [in] [ref] */,
3967                                          uint32_t bits /* [in]  */,
3968                                          uint32_t bitson /* [in]  */,
3969                                          uint32_t immediate /* [in]  */,
3970                                          WERROR *werror)
3971 {
3972         struct svcctl_SCSetServiceBitsA r;
3973         NTSTATUS status;
3974
3975         /* In parameters */
3976         r.in.handle = handle;
3977         r.in.bits = bits;
3978         r.in.bitson = bitson;
3979         r.in.immediate = immediate;
3980
3981         if (DEBUGLEVEL >= 10) {
3982                 NDR_PRINT_IN_DEBUG(svcctl_SCSetServiceBitsA, &r);
3983         }
3984
3985         status = cli->dispatch(cli,
3986                                 mem_ctx,
3987                                 &ndr_table_svcctl,
3988                                 NDR_SVCCTL_SCSETSERVICEBITSA,
3989                                 &r);
3990
3991         if (!NT_STATUS_IS_OK(status)) {
3992                 return status;
3993         }
3994
3995         if (DEBUGLEVEL >= 10) {
3996                 NDR_PRINT_OUT_DEBUG(svcctl_SCSetServiceBitsA, &r);
3997         }
3998
3999         if (NT_STATUS_IS_ERR(status)) {
4000                 return status;
4001         }
4002
4003         /* Return variables */
4004
4005         /* Return result */
4006         if (werror) {
4007                 *werror = r.out.result;
4008         }
4009
4010         return werror_to_ntstatus(r.out.result);
4011 }
4012
4013 struct rpccli_svcctl_ChangeServiceConfigA_state {
4014         struct svcctl_ChangeServiceConfigA orig;
4015         struct svcctl_ChangeServiceConfigA tmp;
4016         TALLOC_CTX *out_mem_ctx;
4017         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4018 };
4019
4020 static void rpccli_svcctl_ChangeServiceConfigA_done(struct tevent_req *subreq);
4021
4022 struct tevent_req *rpccli_svcctl_ChangeServiceConfigA_send(TALLOC_CTX *mem_ctx,
4023                                                            struct tevent_context *ev,
4024                                                            struct rpc_pipe_client *cli,
4025                                                            struct policy_handle *_handle /* [in] [ref] */,
4026                                                            uint32_t _type /* [in]  */,
4027                                                            enum svcctl_StartType _start_type /* [in]  */,
4028                                                            enum svcctl_ErrorControl _error_control /* [in]  */,
4029                                                            const char *_binary_path /* [in] [unique,charset(UTF16)] */,
4030                                                            const char *_load_order_group /* [in] [unique,charset(UTF16)] */,
4031                                                            uint32_t *_tag_id /* [out] [ref] */,
4032                                                            const char *_dependencies /* [in] [unique,charset(UTF16)] */,
4033                                                            const char *_service_start_name /* [in] [unique,charset(UTF16)] */,
4034                                                            const char *_password /* [in] [unique,charset(UTF16)] */,
4035                                                            const char *_display_name /* [in] [unique,charset(UTF16)] */)
4036 {
4037         struct tevent_req *req;
4038         struct rpccli_svcctl_ChangeServiceConfigA_state *state;
4039         struct tevent_req *subreq;
4040
4041         req = tevent_req_create(mem_ctx, &state,
4042                                 struct rpccli_svcctl_ChangeServiceConfigA_state);
4043         if (req == NULL) {
4044                 return NULL;
4045         }
4046         state->out_mem_ctx = NULL;
4047         state->dispatch_recv = cli->dispatch_recv;
4048
4049         /* In parameters */
4050         state->orig.in.handle = _handle;
4051         state->orig.in.type = _type;
4052         state->orig.in.start_type = _start_type;
4053         state->orig.in.error_control = _error_control;
4054         state->orig.in.binary_path = _binary_path;
4055         state->orig.in.load_order_group = _load_order_group;
4056         state->orig.in.dependencies = _dependencies;
4057         state->orig.in.service_start_name = _service_start_name;
4058         state->orig.in.password = _password;
4059         state->orig.in.display_name = _display_name;
4060
4061         /* Out parameters */
4062         state->orig.out.tag_id = _tag_id;
4063
4064         /* Result */
4065         ZERO_STRUCT(state->orig.out.result);
4066
4067         if (DEBUGLEVEL >= 10) {
4068                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfigA, &state->orig);
4069         }
4070
4071         state->out_mem_ctx = talloc_named_const(state, 0,
4072                              "rpccli_svcctl_ChangeServiceConfigA_out_memory");
4073         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4074                 return tevent_req_post(req, ev);
4075         }
4076
4077         /* make a temporary copy, that we pass to the dispatch function */
4078         state->tmp = state->orig;
4079
4080         subreq = cli->dispatch_send(state, ev, cli,
4081                                     &ndr_table_svcctl,
4082                                     NDR_SVCCTL_CHANGESERVICECONFIGA,
4083                                     &state->tmp);
4084         if (tevent_req_nomem(subreq, req)) {
4085                 return tevent_req_post(req, ev);
4086         }
4087         tevent_req_set_callback(subreq, rpccli_svcctl_ChangeServiceConfigA_done, req);
4088         return req;
4089 }
4090
4091 static void rpccli_svcctl_ChangeServiceConfigA_done(struct tevent_req *subreq)
4092 {
4093         struct tevent_req *req = tevent_req_callback_data(
4094                 subreq, struct tevent_req);
4095         struct rpccli_svcctl_ChangeServiceConfigA_state *state = tevent_req_data(
4096                 req, struct rpccli_svcctl_ChangeServiceConfigA_state);
4097         NTSTATUS status;
4098         TALLOC_CTX *mem_ctx;
4099
4100         if (state->out_mem_ctx) {
4101                 mem_ctx = state->out_mem_ctx;
4102         } else {
4103                 mem_ctx = state;
4104         }
4105
4106         status = state->dispatch_recv(subreq, mem_ctx);
4107         TALLOC_FREE(subreq);
4108         if (!NT_STATUS_IS_OK(status)) {
4109                 tevent_req_nterror(req, status);
4110                 return;
4111         }
4112
4113         /* Copy out parameters */
4114         *state->orig.out.tag_id = *state->tmp.out.tag_id;
4115
4116         /* Copy result */
4117         state->orig.out.result = state->tmp.out.result;
4118
4119         /* Reset temporary structure */
4120         ZERO_STRUCT(state->tmp);
4121
4122         if (DEBUGLEVEL >= 10) {
4123                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfigA, &state->orig);
4124         }
4125
4126         tevent_req_done(req);
4127 }
4128
4129 NTSTATUS rpccli_svcctl_ChangeServiceConfigA_recv(struct tevent_req *req,
4130                                                  TALLOC_CTX *mem_ctx,
4131                                                  WERROR *result)
4132 {
4133         struct rpccli_svcctl_ChangeServiceConfigA_state *state = tevent_req_data(
4134                 req, struct rpccli_svcctl_ChangeServiceConfigA_state);
4135         NTSTATUS status;
4136
4137         if (tevent_req_is_nterror(req, &status)) {
4138                 tevent_req_received(req);
4139                 return status;
4140         }
4141
4142         /* Steal possbile out parameters to the callers context */
4143         talloc_steal(mem_ctx, state->out_mem_ctx);
4144
4145         /* Return result */
4146         *result = state->orig.out.result;
4147
4148         tevent_req_received(req);
4149         return NT_STATUS_OK;
4150 }
4151
4152 NTSTATUS rpccli_svcctl_ChangeServiceConfigA(struct rpc_pipe_client *cli,
4153                                             TALLOC_CTX *mem_ctx,
4154                                             struct policy_handle *handle /* [in] [ref] */,
4155                                             uint32_t type /* [in]  */,
4156                                             enum svcctl_StartType start_type /* [in]  */,
4157                                             enum svcctl_ErrorControl error_control /* [in]  */,
4158                                             const char *binary_path /* [in] [unique,charset(UTF16)] */,
4159                                             const char *load_order_group /* [in] [unique,charset(UTF16)] */,
4160                                             uint32_t *tag_id /* [out] [ref] */,
4161                                             const char *dependencies /* [in] [unique,charset(UTF16)] */,
4162                                             const char *service_start_name /* [in] [unique,charset(UTF16)] */,
4163                                             const char *password /* [in] [unique,charset(UTF16)] */,
4164                                             const char *display_name /* [in] [unique,charset(UTF16)] */,
4165                                             WERROR *werror)
4166 {
4167         struct svcctl_ChangeServiceConfigA r;
4168         NTSTATUS status;
4169
4170         /* In parameters */
4171         r.in.handle = handle;
4172         r.in.type = type;
4173         r.in.start_type = start_type;
4174         r.in.error_control = error_control;
4175         r.in.binary_path = binary_path;
4176         r.in.load_order_group = load_order_group;
4177         r.in.dependencies = dependencies;
4178         r.in.service_start_name = service_start_name;
4179         r.in.password = password;
4180         r.in.display_name = display_name;
4181
4182         if (DEBUGLEVEL >= 10) {
4183                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfigA, &r);
4184         }
4185
4186         status = cli->dispatch(cli,
4187                                 mem_ctx,
4188                                 &ndr_table_svcctl,
4189                                 NDR_SVCCTL_CHANGESERVICECONFIGA,
4190                                 &r);
4191
4192         if (!NT_STATUS_IS_OK(status)) {
4193                 return status;
4194         }
4195
4196         if (DEBUGLEVEL >= 10) {
4197                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfigA, &r);
4198         }
4199
4200         if (NT_STATUS_IS_ERR(status)) {
4201                 return status;
4202         }
4203
4204         /* Return variables */
4205         *tag_id = *r.out.tag_id;
4206
4207         /* Return result */
4208         if (werror) {
4209                 *werror = r.out.result;
4210         }
4211
4212         return werror_to_ntstatus(r.out.result);
4213 }
4214
4215 struct rpccli_svcctl_CreateServiceA_state {
4216         struct svcctl_CreateServiceA orig;
4217         struct svcctl_CreateServiceA tmp;
4218         TALLOC_CTX *out_mem_ctx;
4219         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4220 };
4221
4222 static void rpccli_svcctl_CreateServiceA_done(struct tevent_req *subreq);
4223
4224 struct tevent_req *rpccli_svcctl_CreateServiceA_send(TALLOC_CTX *mem_ctx,
4225                                                      struct tevent_context *ev,
4226                                                      struct rpc_pipe_client *cli,
4227                                                      struct policy_handle *_handle /* [in] [ref] */,
4228                                                      const char *_ServiceName /* [in] [unique,charset(UTF16)] */,
4229                                                      const char *_DisplayName /* [in] [unique,charset(UTF16)] */,
4230                                                      uint32_t _desired_access /* [in]  */,
4231                                                      uint32_t _type /* [in]  */,
4232                                                      enum svcctl_StartType _start_type /* [in]  */,
4233                                                      enum svcctl_ErrorControl _error_control /* [in]  */,
4234                                                      const char *_binary_path /* [in] [unique,charset(UTF16)] */,
4235                                                      const char *_LoadOrderGroupKey /* [in] [unique,charset(UTF16)] */,
4236                                                      uint32_t *_TagId /* [out] [unique] */,
4237                                                      const char *_dependencies /* [in] [unique,charset(UTF16)] */,
4238                                                      const char *_service_start_name /* [in] [unique,charset(UTF16)] */,
4239                                                      const char *_password /* [in] [unique,charset(UTF16)] */)
4240 {
4241         struct tevent_req *req;
4242         struct rpccli_svcctl_CreateServiceA_state *state;
4243         struct tevent_req *subreq;
4244
4245         req = tevent_req_create(mem_ctx, &state,
4246                                 struct rpccli_svcctl_CreateServiceA_state);
4247         if (req == NULL) {
4248                 return NULL;
4249         }
4250         state->out_mem_ctx = NULL;
4251         state->dispatch_recv = cli->dispatch_recv;
4252
4253         /* In parameters */
4254         state->orig.in.handle = _handle;
4255         state->orig.in.ServiceName = _ServiceName;
4256         state->orig.in.DisplayName = _DisplayName;
4257         state->orig.in.desired_access = _desired_access;
4258         state->orig.in.type = _type;
4259         state->orig.in.start_type = _start_type;
4260         state->orig.in.error_control = _error_control;
4261         state->orig.in.binary_path = _binary_path;
4262         state->orig.in.LoadOrderGroupKey = _LoadOrderGroupKey;
4263         state->orig.in.dependencies = _dependencies;
4264         state->orig.in.service_start_name = _service_start_name;
4265         state->orig.in.password = _password;
4266
4267         /* Out parameters */
4268         state->orig.out.TagId = _TagId;
4269
4270         /* Result */
4271         ZERO_STRUCT(state->orig.out.result);
4272
4273         if (DEBUGLEVEL >= 10) {
4274                 NDR_PRINT_IN_DEBUG(svcctl_CreateServiceA, &state->orig);
4275         }
4276
4277         state->out_mem_ctx = talloc_named_const(state, 0,
4278                              "rpccli_svcctl_CreateServiceA_out_memory");
4279         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4280                 return tevent_req_post(req, ev);
4281         }
4282
4283         /* make a temporary copy, that we pass to the dispatch function */
4284         state->tmp = state->orig;
4285
4286         subreq = cli->dispatch_send(state, ev, cli,
4287                                     &ndr_table_svcctl,
4288                                     NDR_SVCCTL_CREATESERVICEA,
4289                                     &state->tmp);
4290         if (tevent_req_nomem(subreq, req)) {
4291                 return tevent_req_post(req, ev);
4292         }
4293         tevent_req_set_callback(subreq, rpccli_svcctl_CreateServiceA_done, req);
4294         return req;
4295 }
4296
4297 static void rpccli_svcctl_CreateServiceA_done(struct tevent_req *subreq)
4298 {
4299         struct tevent_req *req = tevent_req_callback_data(
4300                 subreq, struct tevent_req);
4301         struct rpccli_svcctl_CreateServiceA_state *state = tevent_req_data(
4302                 req, struct rpccli_svcctl_CreateServiceA_state);
4303         NTSTATUS status;
4304         TALLOC_CTX *mem_ctx;
4305
4306         if (state->out_mem_ctx) {
4307                 mem_ctx = state->out_mem_ctx;
4308         } else {
4309                 mem_ctx = state;
4310         }
4311
4312         status = state->dispatch_recv(subreq, mem_ctx);
4313         TALLOC_FREE(subreq);
4314         if (!NT_STATUS_IS_OK(status)) {
4315                 tevent_req_nterror(req, status);
4316                 return;
4317         }
4318
4319         /* Copy out parameters */
4320         if (state->orig.out.TagId && state->tmp.out.TagId) {
4321                 *state->orig.out.TagId = *state->tmp.out.TagId;
4322         }
4323
4324         /* Copy result */
4325         state->orig.out.result = state->tmp.out.result;
4326
4327         /* Reset temporary structure */
4328         ZERO_STRUCT(state->tmp);
4329
4330         if (DEBUGLEVEL >= 10) {
4331                 NDR_PRINT_OUT_DEBUG(svcctl_CreateServiceA, &state->orig);
4332         }
4333
4334         tevent_req_done(req);
4335 }
4336
4337 NTSTATUS rpccli_svcctl_CreateServiceA_recv(struct tevent_req *req,
4338                                            TALLOC_CTX *mem_ctx,
4339                                            WERROR *result)
4340 {
4341         struct rpccli_svcctl_CreateServiceA_state *state = tevent_req_data(
4342                 req, struct rpccli_svcctl_CreateServiceA_state);
4343         NTSTATUS status;
4344
4345         if (tevent_req_is_nterror(req, &status)) {
4346                 tevent_req_received(req);
4347                 return status;
4348         }
4349
4350         /* Steal possbile out parameters to the callers context */
4351         talloc_steal(mem_ctx, state->out_mem_ctx);
4352
4353         /* Return result */
4354         *result = state->orig.out.result;
4355
4356         tevent_req_received(req);
4357         return NT_STATUS_OK;
4358 }
4359
4360 NTSTATUS rpccli_svcctl_CreateServiceA(struct rpc_pipe_client *cli,
4361                                       TALLOC_CTX *mem_ctx,
4362                                       struct policy_handle *handle /* [in] [ref] */,
4363                                       const char *ServiceName /* [in] [unique,charset(UTF16)] */,
4364                                       const char *DisplayName /* [in] [unique,charset(UTF16)] */,
4365                                       uint32_t desired_access /* [in]  */,
4366                                       uint32_t type /* [in]  */,
4367                                       enum svcctl_StartType start_type /* [in]  */,
4368                                       enum svcctl_ErrorControl error_control /* [in]  */,
4369                                       const char *binary_path /* [in] [unique,charset(UTF16)] */,
4370                                       const char *LoadOrderGroupKey /* [in] [unique,charset(UTF16)] */,
4371                                       uint32_t *TagId /* [out] [unique] */,
4372                                       const char *dependencies /* [in] [unique,charset(UTF16)] */,
4373                                       const char *service_start_name /* [in] [unique,charset(UTF16)] */,
4374                                       const char *password /* [in] [unique,charset(UTF16)] */,
4375                                       WERROR *werror)
4376 {
4377         struct svcctl_CreateServiceA r;
4378         NTSTATUS status;
4379
4380         /* In parameters */
4381         r.in.handle = handle;
4382         r.in.ServiceName = ServiceName;
4383         r.in.DisplayName = DisplayName;
4384         r.in.desired_access = desired_access;
4385         r.in.type = type;
4386         r.in.start_type = start_type;
4387         r.in.error_control = error_control;
4388         r.in.binary_path = binary_path;
4389         r.in.LoadOrderGroupKey = LoadOrderGroupKey;
4390         r.in.dependencies = dependencies;
4391         r.in.service_start_name = service_start_name;
4392         r.in.password = password;
4393
4394         if (DEBUGLEVEL >= 10) {
4395                 NDR_PRINT_IN_DEBUG(svcctl_CreateServiceA, &r);
4396         }
4397
4398         status = cli->dispatch(cli,
4399                                 mem_ctx,
4400                                 &ndr_table_svcctl,
4401                                 NDR_SVCCTL_CREATESERVICEA,
4402                                 &r);
4403
4404         if (!NT_STATUS_IS_OK(status)) {
4405                 return status;
4406         }
4407
4408         if (DEBUGLEVEL >= 10) {
4409                 NDR_PRINT_OUT_DEBUG(svcctl_CreateServiceA, &r);
4410         }
4411
4412         if (NT_STATUS_IS_ERR(status)) {
4413                 return status;
4414         }
4415
4416         /* Return variables */
4417         if (TagId && r.out.TagId) {
4418                 *TagId = *r.out.TagId;
4419         }
4420
4421         /* Return result */
4422         if (werror) {
4423                 *werror = r.out.result;
4424         }
4425
4426         return werror_to_ntstatus(r.out.result);
4427 }
4428
4429 struct rpccli_svcctl_EnumDependentServicesA_state {
4430         struct svcctl_EnumDependentServicesA orig;
4431         struct svcctl_EnumDependentServicesA tmp;
4432         TALLOC_CTX *out_mem_ctx;
4433         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4434 };
4435
4436 static void rpccli_svcctl_EnumDependentServicesA_done(struct tevent_req *subreq);
4437
4438 struct tevent_req *rpccli_svcctl_EnumDependentServicesA_send(TALLOC_CTX *mem_ctx,
4439                                                              struct tevent_context *ev,
4440                                                              struct rpc_pipe_client *cli,
4441                                                              struct policy_handle *_service /* [in] [ref] */,
4442                                                              enum svcctl_ServiceState _state /* [in]  */,
4443                                                              struct ENUM_SERVICE_STATUSA *_service_status /* [out] [unique] */,
4444                                                              uint32_t _offered /* [in]  */,
4445                                                              uint32_t *_needed /* [out] [ref] */,
4446                                                              uint32_t *_services_returned /* [out] [ref] */)
4447 {
4448         struct tevent_req *req;
4449         struct rpccli_svcctl_EnumDependentServicesA_state *state;
4450         struct tevent_req *subreq;
4451
4452         req = tevent_req_create(mem_ctx, &state,
4453                                 struct rpccli_svcctl_EnumDependentServicesA_state);
4454         if (req == NULL) {
4455                 return NULL;
4456         }
4457         state->out_mem_ctx = NULL;
4458         state->dispatch_recv = cli->dispatch_recv;
4459
4460         /* In parameters */
4461         state->orig.in.service = _service;
4462         state->orig.in.state = _state;
4463         state->orig.in.offered = _offered;
4464
4465         /* Out parameters */
4466         state->orig.out.service_status = _service_status;
4467         state->orig.out.needed = _needed;
4468         state->orig.out.services_returned = _services_returned;
4469
4470         /* Result */
4471         ZERO_STRUCT(state->orig.out.result);
4472
4473         if (DEBUGLEVEL >= 10) {
4474                 NDR_PRINT_IN_DEBUG(svcctl_EnumDependentServicesA, &state->orig);
4475         }
4476
4477         state->out_mem_ctx = talloc_named_const(state, 0,
4478                              "rpccli_svcctl_EnumDependentServicesA_out_memory");
4479         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4480                 return tevent_req_post(req, ev);
4481         }
4482
4483         /* make a temporary copy, that we pass to the dispatch function */
4484         state->tmp = state->orig;
4485
4486         subreq = cli->dispatch_send(state, ev, cli,
4487                                     &ndr_table_svcctl,
4488                                     NDR_SVCCTL_ENUMDEPENDENTSERVICESA,
4489                                     &state->tmp);
4490         if (tevent_req_nomem(subreq, req)) {
4491                 return tevent_req_post(req, ev);
4492         }
4493         tevent_req_set_callback(subreq, rpccli_svcctl_EnumDependentServicesA_done, req);
4494         return req;
4495 }
4496
4497 static void rpccli_svcctl_EnumDependentServicesA_done(struct tevent_req *subreq)
4498 {
4499         struct tevent_req *req = tevent_req_callback_data(
4500                 subreq, struct tevent_req);
4501         struct rpccli_svcctl_EnumDependentServicesA_state *state = tevent_req_data(
4502                 req, struct rpccli_svcctl_EnumDependentServicesA_state);
4503         NTSTATUS status;
4504         TALLOC_CTX *mem_ctx;
4505
4506         if (state->out_mem_ctx) {
4507                 mem_ctx = state->out_mem_ctx;
4508         } else {
4509                 mem_ctx = state;
4510         }
4511
4512         status = state->dispatch_recv(subreq, mem_ctx);
4513         TALLOC_FREE(subreq);
4514         if (!NT_STATUS_IS_OK(status)) {
4515                 tevent_req_nterror(req, status);
4516                 return;
4517         }
4518
4519         /* Copy out parameters */
4520         if (state->orig.out.service_status && state->tmp.out.service_status) {
4521                 *state->orig.out.service_status = *state->tmp.out.service_status;
4522         }
4523         *state->orig.out.needed = *state->tmp.out.needed;
4524         *state->orig.out.services_returned = *state->tmp.out.services_returned;
4525
4526         /* Copy result */
4527         state->orig.out.result = state->tmp.out.result;
4528
4529         /* Reset temporary structure */
4530         ZERO_STRUCT(state->tmp);
4531
4532         if (DEBUGLEVEL >= 10) {
4533                 NDR_PRINT_OUT_DEBUG(svcctl_EnumDependentServicesA, &state->orig);
4534         }
4535
4536         tevent_req_done(req);
4537 }
4538
4539 NTSTATUS rpccli_svcctl_EnumDependentServicesA_recv(struct tevent_req *req,
4540                                                    TALLOC_CTX *mem_ctx,
4541                                                    WERROR *result)
4542 {
4543         struct rpccli_svcctl_EnumDependentServicesA_state *state = tevent_req_data(
4544                 req, struct rpccli_svcctl_EnumDependentServicesA_state);
4545         NTSTATUS status;
4546
4547         if (tevent_req_is_nterror(req, &status)) {
4548                 tevent_req_received(req);
4549                 return status;
4550         }
4551
4552         /* Steal possbile out parameters to the callers context */
4553         talloc_steal(mem_ctx, state->out_mem_ctx);
4554
4555         /* Return result */
4556         *result = state->orig.out.result;
4557
4558         tevent_req_received(req);
4559         return NT_STATUS_OK;
4560 }
4561
4562 NTSTATUS rpccli_svcctl_EnumDependentServicesA(struct rpc_pipe_client *cli,
4563                                               TALLOC_CTX *mem_ctx,
4564                                               struct policy_handle *service /* [in] [ref] */,
4565                                               enum svcctl_ServiceState state /* [in]  */,
4566                                               struct ENUM_SERVICE_STATUSA *service_status /* [out] [unique] */,
4567                                               uint32_t offered /* [in]  */,
4568                                               uint32_t *needed /* [out] [ref] */,
4569                                               uint32_t *services_returned /* [out] [ref] */,
4570                                               WERROR *werror)
4571 {
4572         struct svcctl_EnumDependentServicesA r;
4573         NTSTATUS status;
4574
4575         /* In parameters */
4576         r.in.service = service;
4577         r.in.state = state;
4578         r.in.offered = offered;
4579
4580         if (DEBUGLEVEL >= 10) {
4581                 NDR_PRINT_IN_DEBUG(svcctl_EnumDependentServicesA, &r);
4582         }
4583
4584         status = cli->dispatch(cli,
4585                                 mem_ctx,
4586                                 &ndr_table_svcctl,
4587                                 NDR_SVCCTL_ENUMDEPENDENTSERVICESA,
4588                                 &r);
4589
4590         if (!NT_STATUS_IS_OK(status)) {
4591                 return status;
4592         }
4593
4594         if (DEBUGLEVEL >= 10) {
4595                 NDR_PRINT_OUT_DEBUG(svcctl_EnumDependentServicesA, &r);
4596         }
4597
4598         if (NT_STATUS_IS_ERR(status)) {
4599                 return status;
4600         }
4601
4602         /* Return variables */
4603         if (service_status && r.out.service_status) {
4604                 *service_status = *r.out.service_status;
4605         }
4606         *needed = *r.out.needed;
4607         *services_returned = *r.out.services_returned;
4608
4609         /* Return result */
4610         if (werror) {
4611                 *werror = r.out.result;
4612         }
4613
4614         return werror_to_ntstatus(r.out.result);
4615 }
4616
4617 struct rpccli_svcctl_EnumServicesStatusA_state {
4618         struct svcctl_EnumServicesStatusA orig;
4619         struct svcctl_EnumServicesStatusA tmp;
4620         TALLOC_CTX *out_mem_ctx;
4621         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4622 };
4623
4624 static void rpccli_svcctl_EnumServicesStatusA_done(struct tevent_req *subreq);
4625
4626 struct tevent_req *rpccli_svcctl_EnumServicesStatusA_send(TALLOC_CTX *mem_ctx,
4627                                                           struct tevent_context *ev,
4628                                                           struct rpc_pipe_client *cli,
4629                                                           struct policy_handle *_handle /* [in] [ref] */,
4630                                                           uint32_t _type /* [in]  */,
4631                                                           enum svcctl_ServiceState _state /* [in]  */,
4632                                                           uint32_t _offered /* [in]  */,
4633                                                           uint8_t *_service /* [out] [size_is(offered)] */,
4634                                                           uint32_t *_needed /* [out] [ref] */,
4635                                                           uint32_t *_services_returned /* [out] [ref] */,
4636                                                           uint32_t *_resume_handle /* [in,out] [unique] */)
4637 {
4638         struct tevent_req *req;
4639         struct rpccli_svcctl_EnumServicesStatusA_state *state;
4640         struct tevent_req *subreq;
4641
4642         req = tevent_req_create(mem_ctx, &state,
4643                                 struct rpccli_svcctl_EnumServicesStatusA_state);
4644         if (req == NULL) {
4645                 return NULL;
4646         }
4647         state->out_mem_ctx = NULL;
4648         state->dispatch_recv = cli->dispatch_recv;
4649
4650         /* In parameters */
4651         state->orig.in.handle = _handle;
4652         state->orig.in.type = _type;
4653         state->orig.in.state = _state;
4654         state->orig.in.offered = _offered;
4655         state->orig.in.resume_handle = _resume_handle;
4656
4657         /* Out parameters */
4658         state->orig.out.service = _service;
4659         state->orig.out.needed = _needed;
4660         state->orig.out.services_returned = _services_returned;
4661         state->orig.out.resume_handle = _resume_handle;
4662
4663         /* Result */
4664         ZERO_STRUCT(state->orig.out.result);
4665
4666         if (DEBUGLEVEL >= 10) {
4667                 NDR_PRINT_IN_DEBUG(svcctl_EnumServicesStatusA, &state->orig);
4668         }
4669
4670         state->out_mem_ctx = talloc_named_const(state, 0,
4671                              "rpccli_svcctl_EnumServicesStatusA_out_memory");
4672         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4673                 return tevent_req_post(req, ev);
4674         }
4675
4676         /* make a temporary copy, that we pass to the dispatch function */
4677         state->tmp = state->orig;
4678
4679         subreq = cli->dispatch_send(state, ev, cli,
4680                                     &ndr_table_svcctl,
4681                                     NDR_SVCCTL_ENUMSERVICESSTATUSA,
4682                                     &state->tmp);
4683         if (tevent_req_nomem(subreq, req)) {
4684                 return tevent_req_post(req, ev);
4685         }
4686         tevent_req_set_callback(subreq, rpccli_svcctl_EnumServicesStatusA_done, req);
4687         return req;
4688 }
4689
4690 static void rpccli_svcctl_EnumServicesStatusA_done(struct tevent_req *subreq)
4691 {
4692         struct tevent_req *req = tevent_req_callback_data(
4693                 subreq, struct tevent_req);
4694         struct rpccli_svcctl_EnumServicesStatusA_state *state = tevent_req_data(
4695                 req, struct rpccli_svcctl_EnumServicesStatusA_state);
4696         NTSTATUS status;
4697         TALLOC_CTX *mem_ctx;
4698
4699         if (state->out_mem_ctx) {
4700                 mem_ctx = state->out_mem_ctx;
4701         } else {
4702                 mem_ctx = state;
4703         }
4704
4705         status = state->dispatch_recv(subreq, mem_ctx);
4706         TALLOC_FREE(subreq);
4707         if (!NT_STATUS_IS_OK(status)) {
4708                 tevent_req_nterror(req, status);
4709                 return;
4710         }
4711
4712         /* Copy out parameters */
4713         memcpy(state->orig.out.service, state->tmp.out.service, state->tmp.in.offered * sizeof(*state->orig.out.service));
4714         *state->orig.out.needed = *state->tmp.out.needed;
4715         *state->orig.out.services_returned = *state->tmp.out.services_returned;
4716         if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
4717                 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
4718         }
4719
4720         /* Copy result */
4721         state->orig.out.result = state->tmp.out.result;
4722
4723         /* Reset temporary structure */
4724         ZERO_STRUCT(state->tmp);
4725
4726         if (DEBUGLEVEL >= 10) {
4727                 NDR_PRINT_OUT_DEBUG(svcctl_EnumServicesStatusA, &state->orig);
4728         }
4729
4730         tevent_req_done(req);
4731 }
4732
4733 NTSTATUS rpccli_svcctl_EnumServicesStatusA_recv(struct tevent_req *req,
4734                                                 TALLOC_CTX *mem_ctx,
4735                                                 WERROR *result)
4736 {
4737         struct rpccli_svcctl_EnumServicesStatusA_state *state = tevent_req_data(
4738                 req, struct rpccli_svcctl_EnumServicesStatusA_state);
4739         NTSTATUS status;
4740
4741         if (tevent_req_is_nterror(req, &status)) {
4742                 tevent_req_received(req);
4743                 return status;
4744         }
4745
4746         /* Steal possbile out parameters to the callers context */
4747         talloc_steal(mem_ctx, state->out_mem_ctx);
4748
4749         /* Return result */
4750         *result = state->orig.out.result;
4751
4752         tevent_req_received(req);
4753         return NT_STATUS_OK;
4754 }
4755
4756 NTSTATUS rpccli_svcctl_EnumServicesStatusA(struct rpc_pipe_client *cli,
4757                                            TALLOC_CTX *mem_ctx,
4758                                            struct policy_handle *handle /* [in] [ref] */,
4759                                            uint32_t type /* [in]  */,
4760                                            enum svcctl_ServiceState state /* [in]  */,
4761                                            uint32_t offered /* [in]  */,
4762                                            uint8_t *service /* [out] [size_is(offered)] */,
4763                                            uint32_t *needed /* [out] [ref] */,
4764                                            uint32_t *services_returned /* [out] [ref] */,
4765                                            uint32_t *resume_handle /* [in,out] [unique] */,
4766                                            WERROR *werror)
4767 {
4768         struct svcctl_EnumServicesStatusA r;
4769         NTSTATUS status;
4770
4771         /* In parameters */
4772         r.in.handle = handle;
4773         r.in.type = type;
4774         r.in.state = state;
4775         r.in.offered = offered;
4776         r.in.resume_handle = resume_handle;
4777
4778         if (DEBUGLEVEL >= 10) {
4779                 NDR_PRINT_IN_DEBUG(svcctl_EnumServicesStatusA, &r);
4780         }
4781
4782         status = cli->dispatch(cli,
4783                                 mem_ctx,
4784                                 &ndr_table_svcctl,
4785                                 NDR_SVCCTL_ENUMSERVICESSTATUSA,
4786                                 &r);
4787
4788         if (!NT_STATUS_IS_OK(status)) {
4789                 return status;
4790         }
4791
4792         if (DEBUGLEVEL >= 10) {
4793                 NDR_PRINT_OUT_DEBUG(svcctl_EnumServicesStatusA, &r);
4794         }
4795
4796         if (NT_STATUS_IS_ERR(status)) {
4797                 return status;
4798         }
4799
4800         /* Return variables */
4801         memcpy(service, r.out.service, r.in.offered * sizeof(*service));
4802         *needed = *r.out.needed;
4803         *services_returned = *r.out.services_returned;
4804         if (resume_handle && r.out.resume_handle) {
4805                 *resume_handle = *r.out.resume_handle;
4806         }
4807
4808         /* Return result */
4809         if (werror) {
4810                 *werror = r.out.result;
4811         }
4812
4813         return werror_to_ntstatus(r.out.result);
4814 }
4815
4816 struct rpccli_svcctl_OpenSCManagerA_state {
4817         struct svcctl_OpenSCManagerA orig;
4818         struct svcctl_OpenSCManagerA tmp;
4819         TALLOC_CTX *out_mem_ctx;
4820         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4821 };
4822
4823 static void rpccli_svcctl_OpenSCManagerA_done(struct tevent_req *subreq);
4824
4825 struct tevent_req *rpccli_svcctl_OpenSCManagerA_send(TALLOC_CTX *mem_ctx,
4826                                                      struct tevent_context *ev,
4827                                                      struct rpc_pipe_client *cli,
4828                                                      const char *_MachineName /* [in] [unique,charset(UTF16)] */,
4829                                                      const char *_DatabaseName /* [in] [unique,charset(UTF16)] */,
4830                                                      uint32_t _access_mask /* [in]  */,
4831                                                      struct policy_handle *_handle /* [out] [ref] */)
4832 {
4833         struct tevent_req *req;
4834         struct rpccli_svcctl_OpenSCManagerA_state *state;
4835         struct tevent_req *subreq;
4836
4837         req = tevent_req_create(mem_ctx, &state,
4838                                 struct rpccli_svcctl_OpenSCManagerA_state);
4839         if (req == NULL) {
4840                 return NULL;
4841         }
4842         state->out_mem_ctx = NULL;
4843         state->dispatch_recv = cli->dispatch_recv;
4844
4845         /* In parameters */
4846         state->orig.in.MachineName = _MachineName;
4847         state->orig.in.DatabaseName = _DatabaseName;
4848         state->orig.in.access_mask = _access_mask;
4849
4850         /* Out parameters */
4851         state->orig.out.handle = _handle;
4852
4853         /* Result */
4854         ZERO_STRUCT(state->orig.out.result);
4855
4856         if (DEBUGLEVEL >= 10) {
4857                 NDR_PRINT_IN_DEBUG(svcctl_OpenSCManagerA, &state->orig);
4858         }
4859
4860         state->out_mem_ctx = talloc_named_const(state, 0,
4861                              "rpccli_svcctl_OpenSCManagerA_out_memory");
4862         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4863                 return tevent_req_post(req, ev);
4864         }
4865
4866         /* make a temporary copy, that we pass to the dispatch function */
4867         state->tmp = state->orig;
4868
4869         subreq = cli->dispatch_send(state, ev, cli,
4870                                     &ndr_table_svcctl,
4871                                     NDR_SVCCTL_OPENSCMANAGERA,
4872                                     &state->tmp);
4873         if (tevent_req_nomem(subreq, req)) {
4874                 return tevent_req_post(req, ev);
4875         }
4876         tevent_req_set_callback(subreq, rpccli_svcctl_OpenSCManagerA_done, req);
4877         return req;
4878 }
4879
4880 static void rpccli_svcctl_OpenSCManagerA_done(struct tevent_req *subreq)
4881 {
4882         struct tevent_req *req = tevent_req_callback_data(
4883                 subreq, struct tevent_req);
4884         struct rpccli_svcctl_OpenSCManagerA_state *state = tevent_req_data(
4885                 req, struct rpccli_svcctl_OpenSCManagerA_state);
4886         NTSTATUS status;
4887         TALLOC_CTX *mem_ctx;
4888
4889         if (state->out_mem_ctx) {
4890                 mem_ctx = state->out_mem_ctx;
4891         } else {
4892                 mem_ctx = state;
4893         }
4894
4895         status = state->dispatch_recv(subreq, mem_ctx);
4896         TALLOC_FREE(subreq);
4897         if (!NT_STATUS_IS_OK(status)) {
4898                 tevent_req_nterror(req, status);
4899                 return;
4900         }
4901
4902         /* Copy out parameters */
4903         *state->orig.out.handle = *state->tmp.out.handle;
4904
4905         /* Copy result */
4906         state->orig.out.result = state->tmp.out.result;
4907
4908         /* Reset temporary structure */
4909         ZERO_STRUCT(state->tmp);
4910
4911         if (DEBUGLEVEL >= 10) {
4912                 NDR_PRINT_OUT_DEBUG(svcctl_OpenSCManagerA, &state->orig);
4913         }
4914
4915         tevent_req_done(req);
4916 }
4917
4918 NTSTATUS rpccli_svcctl_OpenSCManagerA_recv(struct tevent_req *req,
4919                                            TALLOC_CTX *mem_ctx,
4920                                            WERROR *result)
4921 {
4922         struct rpccli_svcctl_OpenSCManagerA_state *state = tevent_req_data(
4923                 req, struct rpccli_svcctl_OpenSCManagerA_state);
4924         NTSTATUS status;
4925
4926         if (tevent_req_is_nterror(req, &status)) {
4927                 tevent_req_received(req);
4928                 return status;
4929         }
4930
4931         /* Steal possbile out parameters to the callers context */
4932         talloc_steal(mem_ctx, state->out_mem_ctx);
4933
4934         /* Return result */
4935         *result = state->orig.out.result;
4936
4937         tevent_req_received(req);
4938         return NT_STATUS_OK;
4939 }
4940
4941 NTSTATUS rpccli_svcctl_OpenSCManagerA(struct rpc_pipe_client *cli,
4942                                       TALLOC_CTX *mem_ctx,
4943                                       const char *MachineName /* [in] [unique,charset(UTF16)] */,
4944                                       const char *DatabaseName /* [in] [unique,charset(UTF16)] */,
4945                                       uint32_t access_mask /* [in]  */,
4946                                       struct policy_handle *handle /* [out] [ref] */,
4947                                       WERROR *werror)
4948 {
4949         struct svcctl_OpenSCManagerA r;
4950         NTSTATUS status;
4951
4952         /* In parameters */
4953         r.in.MachineName = MachineName;
4954         r.in.DatabaseName = DatabaseName;
4955         r.in.access_mask = access_mask;
4956
4957         if (DEBUGLEVEL >= 10) {
4958                 NDR_PRINT_IN_DEBUG(svcctl_OpenSCManagerA, &r);
4959         }
4960
4961         status = cli->dispatch(cli,
4962                                 mem_ctx,
4963                                 &ndr_table_svcctl,
4964                                 NDR_SVCCTL_OPENSCMANAGERA,
4965                                 &r);
4966
4967         if (!NT_STATUS_IS_OK(status)) {
4968                 return status;
4969         }
4970
4971         if (DEBUGLEVEL >= 10) {
4972                 NDR_PRINT_OUT_DEBUG(svcctl_OpenSCManagerA, &r);
4973         }
4974
4975         if (NT_STATUS_IS_ERR(status)) {
4976                 return status;
4977         }
4978
4979         /* Return variables */
4980         *handle = *r.out.handle;
4981
4982         /* Return result */
4983         if (werror) {
4984                 *werror = r.out.result;
4985         }
4986
4987         return werror_to_ntstatus(r.out.result);
4988 }
4989
4990 struct rpccli_svcctl_OpenServiceA_state {
4991         struct svcctl_OpenServiceA orig;
4992         struct svcctl_OpenServiceA tmp;
4993         TALLOC_CTX *out_mem_ctx;
4994         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4995 };
4996
4997 static void rpccli_svcctl_OpenServiceA_done(struct tevent_req *subreq);
4998
4999 struct tevent_req *rpccli_svcctl_OpenServiceA_send(TALLOC_CTX *mem_ctx,
5000                                                    struct tevent_context *ev,
5001                                                    struct rpc_pipe_client *cli,
5002                                                    struct policy_handle *_scmanager_handle /* [in] [ref] */,
5003                                                    const char *_ServiceName /* [in] [unique,charset(UTF16)] */,
5004                                                    uint32_t _access_mask /* [in]  */)
5005 {
5006         struct tevent_req *req;
5007         struct rpccli_svcctl_OpenServiceA_state *state;
5008         struct tevent_req *subreq;
5009
5010         req = tevent_req_create(mem_ctx, &state,
5011                                 struct rpccli_svcctl_OpenServiceA_state);
5012         if (req == NULL) {
5013                 return NULL;
5014         }
5015         state->out_mem_ctx = NULL;
5016         state->dispatch_recv = cli->dispatch_recv;
5017
5018         /* In parameters */
5019         state->orig.in.scmanager_handle = _scmanager_handle;
5020         state->orig.in.ServiceName = _ServiceName;
5021         state->orig.in.access_mask = _access_mask;
5022
5023         /* Out parameters */
5024
5025         /* Result */
5026         ZERO_STRUCT(state->orig.out.result);
5027
5028         if (DEBUGLEVEL >= 10) {
5029                 NDR_PRINT_IN_DEBUG(svcctl_OpenServiceA, &state->orig);
5030         }
5031
5032         /* make a temporary copy, that we pass to the dispatch function */
5033         state->tmp = state->orig;
5034
5035         subreq = cli->dispatch_send(state, ev, cli,
5036                                     &ndr_table_svcctl,
5037                                     NDR_SVCCTL_OPENSERVICEA,
5038                                     &state->tmp);
5039         if (tevent_req_nomem(subreq, req)) {
5040                 return tevent_req_post(req, ev);
5041         }
5042         tevent_req_set_callback(subreq, rpccli_svcctl_OpenServiceA_done, req);
5043         return req;
5044 }
5045
5046 static void rpccli_svcctl_OpenServiceA_done(struct tevent_req *subreq)
5047 {
5048         struct tevent_req *req = tevent_req_callback_data(
5049                 subreq, struct tevent_req);
5050         struct rpccli_svcctl_OpenServiceA_state *state = tevent_req_data(
5051                 req, struct rpccli_svcctl_OpenServiceA_state);
5052         NTSTATUS status;
5053         TALLOC_CTX *mem_ctx;
5054
5055         if (state->out_mem_ctx) {
5056                 mem_ctx = state->out_mem_ctx;
5057         } else {
5058                 mem_ctx = state;
5059         }
5060
5061         status = state->dispatch_recv(subreq, mem_ctx);
5062         TALLOC_FREE(subreq);
5063         if (!NT_STATUS_IS_OK(status)) {
5064                 tevent_req_nterror(req, status);
5065                 return;
5066         }
5067
5068         /* Copy out parameters */
5069
5070         /* Copy result */
5071         state->orig.out.result = state->tmp.out.result;
5072
5073         /* Reset temporary structure */
5074         ZERO_STRUCT(state->tmp);
5075
5076         if (DEBUGLEVEL >= 10) {
5077                 NDR_PRINT_OUT_DEBUG(svcctl_OpenServiceA, &state->orig);
5078         }
5079
5080         tevent_req_done(req);
5081 }
5082
5083 NTSTATUS rpccli_svcctl_OpenServiceA_recv(struct tevent_req *req,
5084                                          TALLOC_CTX *mem_ctx,
5085                                          WERROR *result)
5086 {
5087         struct rpccli_svcctl_OpenServiceA_state *state = tevent_req_data(
5088                 req, struct rpccli_svcctl_OpenServiceA_state);
5089         NTSTATUS status;
5090
5091         if (tevent_req_is_nterror(req, &status)) {
5092                 tevent_req_received(req);
5093                 return status;
5094         }
5095
5096         /* Steal possbile out parameters to the callers context */
5097         talloc_steal(mem_ctx, state->out_mem_ctx);
5098
5099         /* Return result */
5100         *result = state->orig.out.result;
5101
5102         tevent_req_received(req);
5103         return NT_STATUS_OK;
5104 }
5105
5106 NTSTATUS rpccli_svcctl_OpenServiceA(struct rpc_pipe_client *cli,
5107                                     TALLOC_CTX *mem_ctx,
5108                                     struct policy_handle *scmanager_handle /* [in] [ref] */,
5109                                     const char *ServiceName /* [in] [unique,charset(UTF16)] */,
5110                                     uint32_t access_mask /* [in]  */,
5111                                     WERROR *werror)
5112 {
5113         struct svcctl_OpenServiceA r;
5114         NTSTATUS status;
5115
5116         /* In parameters */
5117         r.in.scmanager_handle = scmanager_handle;
5118         r.in.ServiceName = ServiceName;
5119         r.in.access_mask = access_mask;
5120
5121         if (DEBUGLEVEL >= 10) {
5122                 NDR_PRINT_IN_DEBUG(svcctl_OpenServiceA, &r);
5123         }
5124
5125         status = cli->dispatch(cli,
5126                                 mem_ctx,
5127                                 &ndr_table_svcctl,
5128                                 NDR_SVCCTL_OPENSERVICEA,
5129                                 &r);
5130
5131         if (!NT_STATUS_IS_OK(status)) {
5132                 return status;
5133         }
5134
5135         if (DEBUGLEVEL >= 10) {
5136                 NDR_PRINT_OUT_DEBUG(svcctl_OpenServiceA, &r);
5137         }
5138
5139         if (NT_STATUS_IS_ERR(status)) {
5140                 return status;
5141         }
5142
5143         /* Return variables */
5144
5145         /* Return result */
5146         if (werror) {
5147                 *werror = r.out.result;
5148         }
5149
5150         return werror_to_ntstatus(r.out.result);
5151 }
5152
5153 struct rpccli_svcctl_QueryServiceConfigA_state {
5154         struct svcctl_QueryServiceConfigA orig;
5155         struct svcctl_QueryServiceConfigA tmp;
5156         TALLOC_CTX *out_mem_ctx;
5157         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5158 };
5159
5160 static void rpccli_svcctl_QueryServiceConfigA_done(struct tevent_req *subreq);
5161
5162 struct tevent_req *rpccli_svcctl_QueryServiceConfigA_send(TALLOC_CTX *mem_ctx,
5163                                                           struct tevent_context *ev,
5164                                                           struct rpc_pipe_client *cli,
5165                                                           struct policy_handle *_handle /* [in] [ref] */,
5166                                                           uint8_t *_query /* [out]  */,
5167                                                           uint32_t _offered /* [in]  */,
5168                                                           uint32_t *_needed /* [out] [ref] */)
5169 {
5170         struct tevent_req *req;
5171         struct rpccli_svcctl_QueryServiceConfigA_state *state;
5172         struct tevent_req *subreq;
5173
5174         req = tevent_req_create(mem_ctx, &state,
5175                                 struct rpccli_svcctl_QueryServiceConfigA_state);
5176         if (req == NULL) {
5177                 return NULL;
5178         }
5179         state->out_mem_ctx = NULL;
5180         state->dispatch_recv = cli->dispatch_recv;
5181
5182         /* In parameters */
5183         state->orig.in.handle = _handle;
5184         state->orig.in.offered = _offered;
5185
5186         /* Out parameters */
5187         state->orig.out.query = _query;
5188         state->orig.out.needed = _needed;
5189
5190         /* Result */
5191         ZERO_STRUCT(state->orig.out.result);
5192
5193         if (DEBUGLEVEL >= 10) {
5194                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfigA, &state->orig);
5195         }
5196
5197         state->out_mem_ctx = talloc_named_const(state, 0,
5198                              "rpccli_svcctl_QueryServiceConfigA_out_memory");
5199         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5200                 return tevent_req_post(req, ev);
5201         }
5202
5203         /* make a temporary copy, that we pass to the dispatch function */
5204         state->tmp = state->orig;
5205
5206         subreq = cli->dispatch_send(state, ev, cli,
5207                                     &ndr_table_svcctl,
5208                                     NDR_SVCCTL_QUERYSERVICECONFIGA,
5209                                     &state->tmp);
5210         if (tevent_req_nomem(subreq, req)) {
5211                 return tevent_req_post(req, ev);
5212         }
5213         tevent_req_set_callback(subreq, rpccli_svcctl_QueryServiceConfigA_done, req);
5214         return req;
5215 }
5216
5217 static void rpccli_svcctl_QueryServiceConfigA_done(struct tevent_req *subreq)
5218 {
5219         struct tevent_req *req = tevent_req_callback_data(
5220                 subreq, struct tevent_req);
5221         struct rpccli_svcctl_QueryServiceConfigA_state *state = tevent_req_data(
5222                 req, struct rpccli_svcctl_QueryServiceConfigA_state);
5223         NTSTATUS status;
5224         TALLOC_CTX *mem_ctx;
5225
5226         if (state->out_mem_ctx) {
5227                 mem_ctx = state->out_mem_ctx;
5228         } else {
5229                 mem_ctx = state;
5230         }
5231
5232         status = state->dispatch_recv(subreq, mem_ctx);
5233         TALLOC_FREE(subreq);
5234         if (!NT_STATUS_IS_OK(status)) {
5235                 tevent_req_nterror(req, status);
5236                 return;
5237         }
5238
5239         /* Copy out parameters */
5240         memcpy(state->orig.out.query, state->tmp.out.query, state->tmp.in.offered * sizeof(*state->orig.out.query));
5241         *state->orig.out.needed = *state->tmp.out.needed;
5242
5243         /* Copy result */
5244         state->orig.out.result = state->tmp.out.result;
5245
5246         /* Reset temporary structure */
5247         ZERO_STRUCT(state->tmp);
5248
5249         if (DEBUGLEVEL >= 10) {
5250                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfigA, &state->orig);
5251         }
5252
5253         tevent_req_done(req);
5254 }
5255
5256 NTSTATUS rpccli_svcctl_QueryServiceConfigA_recv(struct tevent_req *req,
5257                                                 TALLOC_CTX *mem_ctx,
5258                                                 WERROR *result)
5259 {
5260         struct rpccli_svcctl_QueryServiceConfigA_state *state = tevent_req_data(
5261                 req, struct rpccli_svcctl_QueryServiceConfigA_state);
5262         NTSTATUS status;
5263
5264         if (tevent_req_is_nterror(req, &status)) {
5265                 tevent_req_received(req);
5266                 return status;
5267         }
5268
5269         /* Steal possbile out parameters to the callers context */
5270         talloc_steal(mem_ctx, state->out_mem_ctx);
5271
5272         /* Return result */
5273         *result = state->orig.out.result;
5274
5275         tevent_req_received(req);
5276         return NT_STATUS_OK;
5277 }
5278
5279 NTSTATUS rpccli_svcctl_QueryServiceConfigA(struct rpc_pipe_client *cli,
5280                                            TALLOC_CTX *mem_ctx,
5281                                            struct policy_handle *handle /* [in] [ref] */,
5282                                            uint8_t *query /* [out]  */,
5283                                            uint32_t offered /* [in]  */,
5284                                            uint32_t *needed /* [out] [ref] */,
5285                                            WERROR *werror)
5286 {
5287         struct svcctl_QueryServiceConfigA r;
5288         NTSTATUS status;
5289
5290         /* In parameters */
5291         r.in.handle = handle;
5292         r.in.offered = offered;
5293
5294         if (DEBUGLEVEL >= 10) {
5295                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfigA, &r);
5296         }
5297
5298         status = cli->dispatch(cli,
5299                                 mem_ctx,
5300                                 &ndr_table_svcctl,
5301                                 NDR_SVCCTL_QUERYSERVICECONFIGA,
5302                                 &r);
5303
5304         if (!NT_STATUS_IS_OK(status)) {
5305                 return status;
5306         }
5307
5308         if (DEBUGLEVEL >= 10) {
5309                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfigA, &r);
5310         }
5311
5312         if (NT_STATUS_IS_ERR(status)) {
5313                 return status;
5314         }
5315
5316         /* Return variables */
5317         memcpy(query, r.out.query, r.in.offered * sizeof(*query));
5318         *needed = *r.out.needed;
5319
5320         /* Return result */
5321         if (werror) {
5322                 *werror = r.out.result;
5323         }
5324
5325         return werror_to_ntstatus(r.out.result);
5326 }
5327
5328 struct rpccli_svcctl_QueryServiceLockStatusA_state {
5329         struct svcctl_QueryServiceLockStatusA orig;
5330         struct svcctl_QueryServiceLockStatusA tmp;
5331         TALLOC_CTX *out_mem_ctx;
5332         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5333 };
5334
5335 static void rpccli_svcctl_QueryServiceLockStatusA_done(struct tevent_req *subreq);
5336
5337 struct tevent_req *rpccli_svcctl_QueryServiceLockStatusA_send(TALLOC_CTX *mem_ctx,
5338                                                               struct tevent_context *ev,
5339                                                               struct rpc_pipe_client *cli,
5340                                                               struct policy_handle *_handle /* [in] [ref] */,
5341                                                               uint32_t _offered /* [in]  */,
5342                                                               struct SERVICE_LOCK_STATUS *_lock_status /* [out] [ref] */,
5343                                                               uint32_t *_needed /* [out] [ref] */)
5344 {
5345         struct tevent_req *req;
5346         struct rpccli_svcctl_QueryServiceLockStatusA_state *state;
5347         struct tevent_req *subreq;
5348
5349         req = tevent_req_create(mem_ctx, &state,
5350                                 struct rpccli_svcctl_QueryServiceLockStatusA_state);
5351         if (req == NULL) {
5352                 return NULL;
5353         }
5354         state->out_mem_ctx = NULL;
5355         state->dispatch_recv = cli->dispatch_recv;
5356
5357         /* In parameters */
5358         state->orig.in.handle = _handle;
5359         state->orig.in.offered = _offered;
5360
5361         /* Out parameters */
5362         state->orig.out.lock_status = _lock_status;
5363         state->orig.out.needed = _needed;
5364
5365         /* Result */
5366         ZERO_STRUCT(state->orig.out.result);
5367
5368         if (DEBUGLEVEL >= 10) {
5369                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceLockStatusA, &state->orig);
5370         }
5371
5372         state->out_mem_ctx = talloc_named_const(state, 0,
5373                              "rpccli_svcctl_QueryServiceLockStatusA_out_memory");
5374         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5375                 return tevent_req_post(req, ev);
5376         }
5377
5378         /* make a temporary copy, that we pass to the dispatch function */
5379         state->tmp = state->orig;
5380
5381         subreq = cli->dispatch_send(state, ev, cli,
5382                                     &ndr_table_svcctl,
5383                                     NDR_SVCCTL_QUERYSERVICELOCKSTATUSA,
5384                                     &state->tmp);
5385         if (tevent_req_nomem(subreq, req)) {
5386                 return tevent_req_post(req, ev);
5387         }
5388         tevent_req_set_callback(subreq, rpccli_svcctl_QueryServiceLockStatusA_done, req);
5389         return req;
5390 }
5391
5392 static void rpccli_svcctl_QueryServiceLockStatusA_done(struct tevent_req *subreq)
5393 {
5394         struct tevent_req *req = tevent_req_callback_data(
5395                 subreq, struct tevent_req);
5396         struct rpccli_svcctl_QueryServiceLockStatusA_state *state = tevent_req_data(
5397                 req, struct rpccli_svcctl_QueryServiceLockStatusA_state);
5398         NTSTATUS status;
5399         TALLOC_CTX *mem_ctx;
5400
5401         if (state->out_mem_ctx) {
5402                 mem_ctx = state->out_mem_ctx;
5403         } else {
5404                 mem_ctx = state;
5405         }
5406
5407         status = state->dispatch_recv(subreq, mem_ctx);
5408         TALLOC_FREE(subreq);
5409         if (!NT_STATUS_IS_OK(status)) {
5410                 tevent_req_nterror(req, status);
5411                 return;
5412         }
5413
5414         /* Copy out parameters */
5415         *state->orig.out.lock_status = *state->tmp.out.lock_status;
5416         *state->orig.out.needed = *state->tmp.out.needed;
5417
5418         /* Copy result */
5419         state->orig.out.result = state->tmp.out.result;
5420
5421         /* Reset temporary structure */
5422         ZERO_STRUCT(state->tmp);
5423
5424         if (DEBUGLEVEL >= 10) {
5425                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceLockStatusA, &state->orig);
5426         }
5427
5428         tevent_req_done(req);
5429 }
5430
5431 NTSTATUS rpccli_svcctl_QueryServiceLockStatusA_recv(struct tevent_req *req,
5432                                                     TALLOC_CTX *mem_ctx,
5433                                                     WERROR *result)
5434 {
5435         struct rpccli_svcctl_QueryServiceLockStatusA_state *state = tevent_req_data(
5436                 req, struct rpccli_svcctl_QueryServiceLockStatusA_state);
5437         NTSTATUS status;
5438
5439         if (tevent_req_is_nterror(req, &status)) {
5440                 tevent_req_received(req);
5441                 return status;
5442         }
5443
5444         /* Steal possbile out parameters to the callers context */
5445         talloc_steal(mem_ctx, state->out_mem_ctx);
5446
5447         /* Return result */
5448         *result = state->orig.out.result;
5449
5450         tevent_req_received(req);
5451         return NT_STATUS_OK;
5452 }
5453
5454 NTSTATUS rpccli_svcctl_QueryServiceLockStatusA(struct rpc_pipe_client *cli,
5455                                                TALLOC_CTX *mem_ctx,
5456                                                struct policy_handle *handle /* [in] [ref] */,
5457                                                uint32_t offered /* [in]  */,
5458                                                struct SERVICE_LOCK_STATUS *lock_status /* [out] [ref] */,
5459                                                uint32_t *needed /* [out] [ref] */,
5460                                                WERROR *werror)
5461 {
5462         struct svcctl_QueryServiceLockStatusA r;
5463         NTSTATUS status;
5464
5465         /* In parameters */
5466         r.in.handle = handle;
5467         r.in.offered = offered;
5468
5469         if (DEBUGLEVEL >= 10) {
5470                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceLockStatusA, &r);
5471         }
5472
5473         status = cli->dispatch(cli,
5474                                 mem_ctx,
5475                                 &ndr_table_svcctl,
5476                                 NDR_SVCCTL_QUERYSERVICELOCKSTATUSA,
5477                                 &r);
5478
5479         if (!NT_STATUS_IS_OK(status)) {
5480                 return status;
5481         }
5482
5483         if (DEBUGLEVEL >= 10) {
5484                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceLockStatusA, &r);
5485         }
5486
5487         if (NT_STATUS_IS_ERR(status)) {
5488                 return status;
5489         }
5490
5491         /* Return variables */
5492         *lock_status = *r.out.lock_status;
5493         *needed = *r.out.needed;
5494
5495         /* Return result */
5496         if (werror) {
5497                 *werror = r.out.result;
5498         }
5499
5500         return werror_to_ntstatus(r.out.result);
5501 }
5502
5503 struct rpccli_svcctl_StartServiceA_state {
5504         struct svcctl_StartServiceA orig;
5505         struct svcctl_StartServiceA tmp;
5506         TALLOC_CTX *out_mem_ctx;
5507         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5508 };
5509
5510 static void rpccli_svcctl_StartServiceA_done(struct tevent_req *subreq);
5511
5512 struct tevent_req *rpccli_svcctl_StartServiceA_send(TALLOC_CTX *mem_ctx,
5513                                                     struct tevent_context *ev,
5514                                                     struct rpc_pipe_client *cli,
5515                                                     struct policy_handle *_handle /* [in] [ref] */,
5516                                                     uint32_t _NumArgs /* [in]  */,
5517                                                     const char *_Arguments /* [in] [unique,charset(UTF16)] */)
5518 {
5519         struct tevent_req *req;
5520         struct rpccli_svcctl_StartServiceA_state *state;
5521         struct tevent_req *subreq;
5522
5523         req = tevent_req_create(mem_ctx, &state,
5524                                 struct rpccli_svcctl_StartServiceA_state);
5525         if (req == NULL) {
5526                 return NULL;
5527         }
5528         state->out_mem_ctx = NULL;
5529         state->dispatch_recv = cli->dispatch_recv;
5530
5531         /* In parameters */
5532         state->orig.in.handle = _handle;
5533         state->orig.in.NumArgs = _NumArgs;
5534         state->orig.in.Arguments = _Arguments;
5535
5536         /* Out parameters */
5537
5538         /* Result */
5539         ZERO_STRUCT(state->orig.out.result);
5540
5541         if (DEBUGLEVEL >= 10) {
5542                 NDR_PRINT_IN_DEBUG(svcctl_StartServiceA, &state->orig);
5543         }
5544
5545         /* make a temporary copy, that we pass to the dispatch function */
5546         state->tmp = state->orig;
5547
5548         subreq = cli->dispatch_send(state, ev, cli,
5549                                     &ndr_table_svcctl,
5550                                     NDR_SVCCTL_STARTSERVICEA,
5551                                     &state->tmp);
5552         if (tevent_req_nomem(subreq, req)) {
5553                 return tevent_req_post(req, ev);
5554         }
5555         tevent_req_set_callback(subreq, rpccli_svcctl_StartServiceA_done, req);
5556         return req;
5557 }
5558
5559 static void rpccli_svcctl_StartServiceA_done(struct tevent_req *subreq)
5560 {
5561         struct tevent_req *req = tevent_req_callback_data(
5562                 subreq, struct tevent_req);
5563         struct rpccli_svcctl_StartServiceA_state *state = tevent_req_data(
5564                 req, struct rpccli_svcctl_StartServiceA_state);
5565         NTSTATUS status;
5566         TALLOC_CTX *mem_ctx;
5567
5568         if (state->out_mem_ctx) {
5569                 mem_ctx = state->out_mem_ctx;
5570         } else {
5571                 mem_ctx = state;
5572         }
5573
5574         status = state->dispatch_recv(subreq, mem_ctx);
5575         TALLOC_FREE(subreq);
5576         if (!NT_STATUS_IS_OK(status)) {
5577                 tevent_req_nterror(req, status);
5578                 return;
5579         }
5580
5581         /* Copy out parameters */
5582
5583         /* Copy result */
5584         state->orig.out.result = state->tmp.out.result;
5585
5586         /* Reset temporary structure */
5587         ZERO_STRUCT(state->tmp);
5588
5589         if (DEBUGLEVEL >= 10) {
5590                 NDR_PRINT_OUT_DEBUG(svcctl_StartServiceA, &state->orig);
5591         }
5592
5593         tevent_req_done(req);
5594 }
5595
5596 NTSTATUS rpccli_svcctl_StartServiceA_recv(struct tevent_req *req,
5597                                           TALLOC_CTX *mem_ctx,
5598                                           WERROR *result)
5599 {
5600         struct rpccli_svcctl_StartServiceA_state *state = tevent_req_data(
5601                 req, struct rpccli_svcctl_StartServiceA_state);
5602         NTSTATUS status;
5603
5604         if (tevent_req_is_nterror(req, &status)) {
5605                 tevent_req_received(req);
5606                 return status;
5607         }
5608
5609         /* Steal possbile out parameters to the callers context */
5610         talloc_steal(mem_ctx, state->out_mem_ctx);
5611
5612         /* Return result */
5613         *result = state->orig.out.result;
5614
5615         tevent_req_received(req);
5616         return NT_STATUS_OK;
5617 }
5618
5619 NTSTATUS rpccli_svcctl_StartServiceA(struct rpc_pipe_client *cli,
5620                                      TALLOC_CTX *mem_ctx,
5621                                      struct policy_handle *handle /* [in] [ref] */,
5622                                      uint32_t NumArgs /* [in]  */,
5623                                      const char *Arguments /* [in] [unique,charset(UTF16)] */,
5624                                      WERROR *werror)
5625 {
5626         struct svcctl_StartServiceA r;
5627         NTSTATUS status;
5628
5629         /* In parameters */
5630         r.in.handle = handle;
5631         r.in.NumArgs = NumArgs;
5632         r.in.Arguments = Arguments;
5633
5634         if (DEBUGLEVEL >= 10) {
5635                 NDR_PRINT_IN_DEBUG(svcctl_StartServiceA, &r);
5636         }
5637
5638         status = cli->dispatch(cli,
5639                                 mem_ctx,
5640                                 &ndr_table_svcctl,
5641                                 NDR_SVCCTL_STARTSERVICEA,
5642                                 &r);
5643
5644         if (!NT_STATUS_IS_OK(status)) {
5645                 return status;
5646         }
5647
5648         if (DEBUGLEVEL >= 10) {
5649                 NDR_PRINT_OUT_DEBUG(svcctl_StartServiceA, &r);
5650         }
5651
5652         if (NT_STATUS_IS_ERR(status)) {
5653                 return status;
5654         }
5655
5656         /* Return variables */
5657
5658         /* Return result */
5659         if (werror) {
5660                 *werror = r.out.result;
5661         }
5662
5663         return werror_to_ntstatus(r.out.result);
5664 }
5665
5666 struct rpccli_svcctl_GetServiceDisplayNameA_state {
5667         struct svcctl_GetServiceDisplayNameA orig;
5668         struct svcctl_GetServiceDisplayNameA tmp;
5669         TALLOC_CTX *out_mem_ctx;
5670         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5671 };
5672
5673 static void rpccli_svcctl_GetServiceDisplayNameA_done(struct tevent_req *subreq);
5674
5675 struct tevent_req *rpccli_svcctl_GetServiceDisplayNameA_send(TALLOC_CTX *mem_ctx,
5676                                                              struct tevent_context *ev,
5677                                                              struct rpc_pipe_client *cli,
5678                                                              struct policy_handle *_handle /* [in] [ref] */,
5679                                                              const char *_service_name /* [in] [unique,charset(UTF16)] */,
5680                                                              const char **_display_name /* [out] [ref,charset(UTF16)] */,
5681                                                              uint32_t *_display_name_length /* [in,out] [unique] */)
5682 {
5683         struct tevent_req *req;
5684         struct rpccli_svcctl_GetServiceDisplayNameA_state *state;
5685         struct tevent_req *subreq;
5686
5687         req = tevent_req_create(mem_ctx, &state,
5688                                 struct rpccli_svcctl_GetServiceDisplayNameA_state);
5689         if (req == NULL) {
5690                 return NULL;
5691         }
5692         state->out_mem_ctx = NULL;
5693         state->dispatch_recv = cli->dispatch_recv;
5694
5695         /* In parameters */
5696         state->orig.in.handle = _handle;
5697         state->orig.in.service_name = _service_name;
5698         state->orig.in.display_name_length = _display_name_length;
5699
5700         /* Out parameters */
5701         state->orig.out.display_name = _display_name;
5702         state->orig.out.display_name_length = _display_name_length;
5703
5704         /* Result */
5705         ZERO_STRUCT(state->orig.out.result);
5706
5707         if (DEBUGLEVEL >= 10) {
5708                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceDisplayNameA, &state->orig);
5709         }
5710
5711         state->out_mem_ctx = talloc_named_const(state, 0,
5712                              "rpccli_svcctl_GetServiceDisplayNameA_out_memory");
5713         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5714                 return tevent_req_post(req, ev);
5715         }
5716
5717         /* make a temporary copy, that we pass to the dispatch function */
5718         state->tmp = state->orig;
5719
5720         subreq = cli->dispatch_send(state, ev, cli,
5721                                     &ndr_table_svcctl,
5722                                     NDR_SVCCTL_GETSERVICEDISPLAYNAMEA,
5723                                     &state->tmp);
5724         if (tevent_req_nomem(subreq, req)) {
5725                 return tevent_req_post(req, ev);
5726         }
5727         tevent_req_set_callback(subreq, rpccli_svcctl_GetServiceDisplayNameA_done, req);
5728         return req;
5729 }
5730
5731 static void rpccli_svcctl_GetServiceDisplayNameA_done(struct tevent_req *subreq)
5732 {
5733         struct tevent_req *req = tevent_req_callback_data(
5734                 subreq, struct tevent_req);
5735         struct rpccli_svcctl_GetServiceDisplayNameA_state *state = tevent_req_data(
5736                 req, struct rpccli_svcctl_GetServiceDisplayNameA_state);
5737         NTSTATUS status;
5738         TALLOC_CTX *mem_ctx;
5739
5740         if (state->out_mem_ctx) {
5741                 mem_ctx = state->out_mem_ctx;
5742         } else {
5743                 mem_ctx = state;
5744         }
5745
5746         status = state->dispatch_recv(subreq, mem_ctx);
5747         TALLOC_FREE(subreq);
5748         if (!NT_STATUS_IS_OK(status)) {
5749                 tevent_req_nterror(req, status);
5750                 return;
5751         }
5752
5753         /* Copy out parameters */
5754         *state->orig.out.display_name = *state->tmp.out.display_name;
5755         if (state->orig.out.display_name_length && state->tmp.out.display_name_length) {
5756                 *state->orig.out.display_name_length = *state->tmp.out.display_name_length;
5757         }
5758
5759         /* Copy result */
5760         state->orig.out.result = state->tmp.out.result;
5761
5762         /* Reset temporary structure */
5763         ZERO_STRUCT(state->tmp);
5764
5765         if (DEBUGLEVEL >= 10) {
5766                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceDisplayNameA, &state->orig);
5767         }
5768
5769         tevent_req_done(req);
5770 }
5771
5772 NTSTATUS rpccli_svcctl_GetServiceDisplayNameA_recv(struct tevent_req *req,
5773                                                    TALLOC_CTX *mem_ctx,
5774                                                    WERROR *result)
5775 {
5776         struct rpccli_svcctl_GetServiceDisplayNameA_state *state = tevent_req_data(
5777                 req, struct rpccli_svcctl_GetServiceDisplayNameA_state);
5778         NTSTATUS status;
5779
5780         if (tevent_req_is_nterror(req, &status)) {
5781                 tevent_req_received(req);
5782                 return status;
5783         }
5784
5785         /* Steal possbile out parameters to the callers context */
5786         talloc_steal(mem_ctx, state->out_mem_ctx);
5787
5788         /* Return result */
5789         *result = state->orig.out.result;
5790
5791         tevent_req_received(req);
5792         return NT_STATUS_OK;
5793 }
5794
5795 NTSTATUS rpccli_svcctl_GetServiceDisplayNameA(struct rpc_pipe_client *cli,
5796                                               TALLOC_CTX *mem_ctx,
5797                                               struct policy_handle *handle /* [in] [ref] */,
5798                                               const char *service_name /* [in] [unique,charset(UTF16)] */,
5799                                               const char **display_name /* [out] [ref,charset(UTF16)] */,
5800                                               uint32_t *display_name_length /* [in,out] [unique] */,
5801                                               WERROR *werror)
5802 {
5803         struct svcctl_GetServiceDisplayNameA r;
5804         NTSTATUS status;
5805
5806         /* In parameters */
5807         r.in.handle = handle;
5808         r.in.service_name = service_name;
5809         r.in.display_name_length = display_name_length;
5810
5811         if (DEBUGLEVEL >= 10) {
5812                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceDisplayNameA, &r);
5813         }
5814
5815         status = cli->dispatch(cli,
5816                                 mem_ctx,
5817                                 &ndr_table_svcctl,
5818                                 NDR_SVCCTL_GETSERVICEDISPLAYNAMEA,
5819                                 &r);
5820
5821         if (!NT_STATUS_IS_OK(status)) {
5822                 return status;
5823         }
5824
5825         if (DEBUGLEVEL >= 10) {
5826                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceDisplayNameA, &r);
5827         }
5828
5829         if (NT_STATUS_IS_ERR(status)) {
5830                 return status;
5831         }
5832
5833         /* Return variables */
5834         *display_name = *r.out.display_name;
5835         if (display_name_length && r.out.display_name_length) {
5836                 *display_name_length = *r.out.display_name_length;
5837         }
5838
5839         /* Return result */
5840         if (werror) {
5841                 *werror = r.out.result;
5842         }
5843
5844         return werror_to_ntstatus(r.out.result);
5845 }
5846
5847 struct rpccli_svcctl_GetServiceKeyNameA_state {
5848         struct svcctl_GetServiceKeyNameA orig;
5849         struct svcctl_GetServiceKeyNameA tmp;
5850         TALLOC_CTX *out_mem_ctx;
5851         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5852 };
5853
5854 static void rpccli_svcctl_GetServiceKeyNameA_done(struct tevent_req *subreq);
5855
5856 struct tevent_req *rpccli_svcctl_GetServiceKeyNameA_send(TALLOC_CTX *mem_ctx,
5857                                                          struct tevent_context *ev,
5858                                                          struct rpc_pipe_client *cli,
5859                                                          struct policy_handle *_handle /* [in] [ref] */,
5860                                                          const char *_service_name /* [in] [unique,charset(UTF16)] */,
5861                                                          const char **_key_name /* [out] [ref,charset(UTF16)] */,
5862                                                          uint32_t *_display_name_length /* [in,out] [unique] */)
5863 {
5864         struct tevent_req *req;
5865         struct rpccli_svcctl_GetServiceKeyNameA_state *state;
5866         struct tevent_req *subreq;
5867
5868         req = tevent_req_create(mem_ctx, &state,
5869                                 struct rpccli_svcctl_GetServiceKeyNameA_state);
5870         if (req == NULL) {
5871                 return NULL;
5872         }
5873         state->out_mem_ctx = NULL;
5874         state->dispatch_recv = cli->dispatch_recv;
5875
5876         /* In parameters */
5877         state->orig.in.handle = _handle;
5878         state->orig.in.service_name = _service_name;
5879         state->orig.in.display_name_length = _display_name_length;
5880
5881         /* Out parameters */
5882         state->orig.out.key_name = _key_name;
5883         state->orig.out.display_name_length = _display_name_length;
5884
5885         /* Result */
5886         ZERO_STRUCT(state->orig.out.result);
5887
5888         if (DEBUGLEVEL >= 10) {
5889                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceKeyNameA, &state->orig);
5890         }
5891
5892         state->out_mem_ctx = talloc_named_const(state, 0,
5893                              "rpccli_svcctl_GetServiceKeyNameA_out_memory");
5894         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5895                 return tevent_req_post(req, ev);
5896         }
5897
5898         /* make a temporary copy, that we pass to the dispatch function */
5899         state->tmp = state->orig;
5900
5901         subreq = cli->dispatch_send(state, ev, cli,
5902                                     &ndr_table_svcctl,
5903                                     NDR_SVCCTL_GETSERVICEKEYNAMEA,
5904                                     &state->tmp);
5905         if (tevent_req_nomem(subreq, req)) {
5906                 return tevent_req_post(req, ev);
5907         }
5908         tevent_req_set_callback(subreq, rpccli_svcctl_GetServiceKeyNameA_done, req);
5909         return req;
5910 }
5911
5912 static void rpccli_svcctl_GetServiceKeyNameA_done(struct tevent_req *subreq)
5913 {
5914         struct tevent_req *req = tevent_req_callback_data(
5915                 subreq, struct tevent_req);
5916         struct rpccli_svcctl_GetServiceKeyNameA_state *state = tevent_req_data(
5917                 req, struct rpccli_svcctl_GetServiceKeyNameA_state);
5918         NTSTATUS status;
5919         TALLOC_CTX *mem_ctx;
5920
5921         if (state->out_mem_ctx) {
5922                 mem_ctx = state->out_mem_ctx;
5923         } else {
5924                 mem_ctx = state;
5925         }
5926
5927         status = state->dispatch_recv(subreq, mem_ctx);
5928         TALLOC_FREE(subreq);
5929         if (!NT_STATUS_IS_OK(status)) {
5930                 tevent_req_nterror(req, status);
5931                 return;
5932         }
5933
5934         /* Copy out parameters */
5935         *state->orig.out.key_name = *state->tmp.out.key_name;
5936         if (state->orig.out.display_name_length && state->tmp.out.display_name_length) {
5937                 *state->orig.out.display_name_length = *state->tmp.out.display_name_length;
5938         }
5939
5940         /* Copy result */
5941         state->orig.out.result = state->tmp.out.result;
5942
5943         /* Reset temporary structure */
5944         ZERO_STRUCT(state->tmp);
5945
5946         if (DEBUGLEVEL >= 10) {
5947                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceKeyNameA, &state->orig);
5948         }
5949
5950         tevent_req_done(req);
5951 }
5952
5953 NTSTATUS rpccli_svcctl_GetServiceKeyNameA_recv(struct tevent_req *req,
5954                                                TALLOC_CTX *mem_ctx,
5955                                                WERROR *result)
5956 {
5957         struct rpccli_svcctl_GetServiceKeyNameA_state *state = tevent_req_data(
5958                 req, struct rpccli_svcctl_GetServiceKeyNameA_state);
5959         NTSTATUS status;
5960
5961         if (tevent_req_is_nterror(req, &status)) {
5962                 tevent_req_received(req);
5963                 return status;
5964         }
5965
5966         /* Steal possbile out parameters to the callers context */
5967         talloc_steal(mem_ctx, state->out_mem_ctx);
5968
5969         /* Return result */
5970         *result = state->orig.out.result;
5971
5972         tevent_req_received(req);
5973         return NT_STATUS_OK;
5974 }
5975
5976 NTSTATUS rpccli_svcctl_GetServiceKeyNameA(struct rpc_pipe_client *cli,
5977                                           TALLOC_CTX *mem_ctx,
5978                                           struct policy_handle *handle /* [in] [ref] */,
5979                                           const char *service_name /* [in] [unique,charset(UTF16)] */,
5980                                           const char **key_name /* [out] [ref,charset(UTF16)] */,
5981                                           uint32_t *display_name_length /* [in,out] [unique] */,
5982                                           WERROR *werror)
5983 {
5984         struct svcctl_GetServiceKeyNameA r;
5985         NTSTATUS status;
5986
5987         /* In parameters */
5988         r.in.handle = handle;
5989         r.in.service_name = service_name;
5990         r.in.display_name_length = display_name_length;
5991
5992         if (DEBUGLEVEL >= 10) {
5993                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceKeyNameA, &r);
5994         }
5995
5996         status = cli->dispatch(cli,
5997                                 mem_ctx,
5998                                 &ndr_table_svcctl,
5999                                 NDR_SVCCTL_GETSERVICEKEYNAMEA,
6000                                 &r);
6001
6002         if (!NT_STATUS_IS_OK(status)) {
6003                 return status;
6004         }
6005
6006         if (DEBUGLEVEL >= 10) {
6007                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceKeyNameA, &r);
6008         }
6009
6010         if (NT_STATUS_IS_ERR(status)) {
6011                 return status;
6012         }
6013
6014         /* Return variables */
6015         *key_name = *r.out.key_name;
6016         if (display_name_length && r.out.display_name_length) {
6017                 *display_name_length = *r.out.display_name_length;
6018         }
6019
6020         /* Return result */
6021         if (werror) {
6022                 *werror = r.out.result;
6023         }
6024
6025         return werror_to_ntstatus(r.out.result);
6026 }
6027
6028 struct rpccli_svcctl_GetCurrentGroupeStateW_state {
6029         struct svcctl_GetCurrentGroupeStateW orig;
6030         struct svcctl_GetCurrentGroupeStateW tmp;
6031         TALLOC_CTX *out_mem_ctx;
6032         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6033 };
6034
6035 static void rpccli_svcctl_GetCurrentGroupeStateW_done(struct tevent_req *subreq);
6036
6037 struct tevent_req *rpccli_svcctl_GetCurrentGroupeStateW_send(TALLOC_CTX *mem_ctx,
6038                                                              struct tevent_context *ev,
6039                                                              struct rpc_pipe_client *cli)
6040 {
6041         struct tevent_req *req;
6042         struct rpccli_svcctl_GetCurrentGroupeStateW_state *state;
6043         struct tevent_req *subreq;
6044
6045         req = tevent_req_create(mem_ctx, &state,
6046                                 struct rpccli_svcctl_GetCurrentGroupeStateW_state);
6047         if (req == NULL) {
6048                 return NULL;
6049         }
6050         state->out_mem_ctx = NULL;
6051         state->dispatch_recv = cli->dispatch_recv;
6052
6053         /* In parameters */
6054
6055         /* Out parameters */
6056
6057         /* Result */
6058         ZERO_STRUCT(state->orig.out.result);
6059
6060         if (DEBUGLEVEL >= 10) {
6061                 NDR_PRINT_IN_DEBUG(svcctl_GetCurrentGroupeStateW, &state->orig);
6062         }
6063
6064         /* make a temporary copy, that we pass to the dispatch function */
6065         state->tmp = state->orig;
6066
6067         subreq = cli->dispatch_send(state, ev, cli,
6068                                     &ndr_table_svcctl,
6069                                     NDR_SVCCTL_GETCURRENTGROUPESTATEW,
6070                                     &state->tmp);
6071         if (tevent_req_nomem(subreq, req)) {
6072                 return tevent_req_post(req, ev);
6073         }
6074         tevent_req_set_callback(subreq, rpccli_svcctl_GetCurrentGroupeStateW_done, req);
6075         return req;
6076 }
6077
6078 static void rpccli_svcctl_GetCurrentGroupeStateW_done(struct tevent_req *subreq)
6079 {
6080         struct tevent_req *req = tevent_req_callback_data(
6081                 subreq, struct tevent_req);
6082         struct rpccli_svcctl_GetCurrentGroupeStateW_state *state = tevent_req_data(
6083                 req, struct rpccli_svcctl_GetCurrentGroupeStateW_state);
6084         NTSTATUS status;
6085         TALLOC_CTX *mem_ctx;
6086
6087         if (state->out_mem_ctx) {
6088                 mem_ctx = state->out_mem_ctx;
6089         } else {
6090                 mem_ctx = state;
6091         }
6092
6093         status = state->dispatch_recv(subreq, mem_ctx);
6094         TALLOC_FREE(subreq);
6095         if (!NT_STATUS_IS_OK(status)) {
6096                 tevent_req_nterror(req, status);
6097                 return;
6098         }
6099
6100         /* Copy out parameters */
6101
6102         /* Copy result */
6103         state->orig.out.result = state->tmp.out.result;
6104
6105         /* Reset temporary structure */
6106         ZERO_STRUCT(state->tmp);
6107
6108         if (DEBUGLEVEL >= 10) {
6109                 NDR_PRINT_OUT_DEBUG(svcctl_GetCurrentGroupeStateW, &state->orig);
6110         }
6111
6112         tevent_req_done(req);
6113 }
6114
6115 NTSTATUS rpccli_svcctl_GetCurrentGroupeStateW_recv(struct tevent_req *req,
6116                                                    TALLOC_CTX *mem_ctx,
6117                                                    WERROR *result)
6118 {
6119         struct rpccli_svcctl_GetCurrentGroupeStateW_state *state = tevent_req_data(
6120                 req, struct rpccli_svcctl_GetCurrentGroupeStateW_state);
6121         NTSTATUS status;
6122
6123         if (tevent_req_is_nterror(req, &status)) {
6124                 tevent_req_received(req);
6125                 return status;
6126         }
6127
6128         /* Steal possbile out parameters to the callers context */
6129         talloc_steal(mem_ctx, state->out_mem_ctx);
6130
6131         /* Return result */
6132         *result = state->orig.out.result;
6133
6134         tevent_req_received(req);
6135         return NT_STATUS_OK;
6136 }
6137
6138 NTSTATUS rpccli_svcctl_GetCurrentGroupeStateW(struct rpc_pipe_client *cli,
6139                                               TALLOC_CTX *mem_ctx,
6140                                               WERROR *werror)
6141 {
6142         struct svcctl_GetCurrentGroupeStateW r;
6143         NTSTATUS status;
6144
6145         /* In parameters */
6146
6147         if (DEBUGLEVEL >= 10) {
6148                 NDR_PRINT_IN_DEBUG(svcctl_GetCurrentGroupeStateW, &r);
6149         }
6150
6151         status = cli->dispatch(cli,
6152                                 mem_ctx,
6153                                 &ndr_table_svcctl,
6154                                 NDR_SVCCTL_GETCURRENTGROUPESTATEW,
6155                                 &r);
6156
6157         if (!NT_STATUS_IS_OK(status)) {
6158                 return status;
6159         }
6160
6161         if (DEBUGLEVEL >= 10) {
6162                 NDR_PRINT_OUT_DEBUG(svcctl_GetCurrentGroupeStateW, &r);
6163         }
6164
6165         if (NT_STATUS_IS_ERR(status)) {
6166                 return status;
6167         }
6168
6169         /* Return variables */
6170
6171         /* Return result */
6172         if (werror) {
6173                 *werror = r.out.result;
6174         }
6175
6176         return werror_to_ntstatus(r.out.result);
6177 }
6178
6179 struct rpccli_svcctl_EnumServiceGroupW_state {
6180         struct svcctl_EnumServiceGroupW orig;
6181         struct svcctl_EnumServiceGroupW tmp;
6182         TALLOC_CTX *out_mem_ctx;
6183         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6184 };
6185
6186 static void rpccli_svcctl_EnumServiceGroupW_done(struct tevent_req *subreq);
6187
6188 struct tevent_req *rpccli_svcctl_EnumServiceGroupW_send(TALLOC_CTX *mem_ctx,
6189                                                         struct tevent_context *ev,
6190                                                         struct rpc_pipe_client *cli)
6191 {
6192         struct tevent_req *req;
6193         struct rpccli_svcctl_EnumServiceGroupW_state *state;
6194         struct tevent_req *subreq;
6195
6196         req = tevent_req_create(mem_ctx, &state,
6197                                 struct rpccli_svcctl_EnumServiceGroupW_state);
6198         if (req == NULL) {
6199                 return NULL;
6200         }
6201         state->out_mem_ctx = NULL;
6202         state->dispatch_recv = cli->dispatch_recv;
6203
6204         /* In parameters */
6205
6206         /* Out parameters */
6207
6208         /* Result */
6209         ZERO_STRUCT(state->orig.out.result);
6210
6211         if (DEBUGLEVEL >= 10) {
6212                 NDR_PRINT_IN_DEBUG(svcctl_EnumServiceGroupW, &state->orig);
6213         }
6214
6215         /* make a temporary copy, that we pass to the dispatch function */
6216         state->tmp = state->orig;
6217
6218         subreq = cli->dispatch_send(state, ev, cli,
6219                                     &ndr_table_svcctl,
6220                                     NDR_SVCCTL_ENUMSERVICEGROUPW,
6221                                     &state->tmp);
6222         if (tevent_req_nomem(subreq, req)) {
6223                 return tevent_req_post(req, ev);
6224         }
6225         tevent_req_set_callback(subreq, rpccli_svcctl_EnumServiceGroupW_done, req);
6226         return req;
6227 }
6228
6229 static void rpccli_svcctl_EnumServiceGroupW_done(struct tevent_req *subreq)
6230 {
6231         struct tevent_req *req = tevent_req_callback_data(
6232                 subreq, struct tevent_req);
6233         struct rpccli_svcctl_EnumServiceGroupW_state *state = tevent_req_data(
6234                 req, struct rpccli_svcctl_EnumServiceGroupW_state);
6235         NTSTATUS status;
6236         TALLOC_CTX *mem_ctx;
6237
6238         if (state->out_mem_ctx) {
6239                 mem_ctx = state->out_mem_ctx;
6240         } else {
6241                 mem_ctx = state;
6242         }
6243
6244         status = state->dispatch_recv(subreq, mem_ctx);
6245         TALLOC_FREE(subreq);
6246         if (!NT_STATUS_IS_OK(status)) {
6247                 tevent_req_nterror(req, status);
6248                 return;
6249         }
6250
6251         /* Copy out parameters */
6252
6253         /* Copy result */
6254         state->orig.out.result = state->tmp.out.result;
6255
6256         /* Reset temporary structure */
6257         ZERO_STRUCT(state->tmp);
6258
6259         if (DEBUGLEVEL >= 10) {
6260                 NDR_PRINT_OUT_DEBUG(svcctl_EnumServiceGroupW, &state->orig);
6261         }
6262
6263         tevent_req_done(req);
6264 }
6265
6266 NTSTATUS rpccli_svcctl_EnumServiceGroupW_recv(struct tevent_req *req,
6267                                               TALLOC_CTX *mem_ctx,
6268                                               WERROR *result)
6269 {
6270         struct rpccli_svcctl_EnumServiceGroupW_state *state = tevent_req_data(
6271                 req, struct rpccli_svcctl_EnumServiceGroupW_state);
6272         NTSTATUS status;
6273
6274         if (tevent_req_is_nterror(req, &status)) {
6275                 tevent_req_received(req);
6276                 return status;
6277         }
6278
6279         /* Steal possbile out parameters to the callers context */
6280         talloc_steal(mem_ctx, state->out_mem_ctx);
6281
6282         /* Return result */
6283         *result = state->orig.out.result;
6284
6285         tevent_req_received(req);
6286         return NT_STATUS_OK;
6287 }
6288
6289 NTSTATUS rpccli_svcctl_EnumServiceGroupW(struct rpc_pipe_client *cli,
6290                                          TALLOC_CTX *mem_ctx,
6291                                          WERROR *werror)
6292 {
6293         struct svcctl_EnumServiceGroupW r;
6294         NTSTATUS status;
6295
6296         /* In parameters */
6297
6298         if (DEBUGLEVEL >= 10) {
6299                 NDR_PRINT_IN_DEBUG(svcctl_EnumServiceGroupW, &r);
6300         }
6301
6302         status = cli->dispatch(cli,
6303                                 mem_ctx,
6304                                 &ndr_table_svcctl,
6305                                 NDR_SVCCTL_ENUMSERVICEGROUPW,
6306                                 &r);
6307
6308         if (!NT_STATUS_IS_OK(status)) {
6309                 return status;
6310         }
6311
6312         if (DEBUGLEVEL >= 10) {
6313                 NDR_PRINT_OUT_DEBUG(svcctl_EnumServiceGroupW, &r);
6314         }
6315
6316         if (NT_STATUS_IS_ERR(status)) {
6317                 return status;
6318         }
6319
6320         /* Return variables */
6321
6322         /* Return result */
6323         if (werror) {
6324                 *werror = r.out.result;
6325         }
6326
6327         return werror_to_ntstatus(r.out.result);
6328 }
6329
6330 struct rpccli_svcctl_ChangeServiceConfig2A_state {
6331         struct svcctl_ChangeServiceConfig2A orig;
6332         struct svcctl_ChangeServiceConfig2A tmp;
6333         TALLOC_CTX *out_mem_ctx;
6334         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6335 };
6336
6337 static void rpccli_svcctl_ChangeServiceConfig2A_done(struct tevent_req *subreq);
6338
6339 struct tevent_req *rpccli_svcctl_ChangeServiceConfig2A_send(TALLOC_CTX *mem_ctx,
6340                                                             struct tevent_context *ev,
6341                                                             struct rpc_pipe_client *cli,
6342                                                             struct policy_handle *_handle /* [in] [ref] */,
6343                                                             uint32_t _info_level /* [in]  */,
6344                                                             uint8_t *_info /* [in] [unique] */)
6345 {
6346         struct tevent_req *req;
6347         struct rpccli_svcctl_ChangeServiceConfig2A_state *state;
6348         struct tevent_req *subreq;
6349
6350         req = tevent_req_create(mem_ctx, &state,
6351                                 struct rpccli_svcctl_ChangeServiceConfig2A_state);
6352         if (req == NULL) {
6353                 return NULL;
6354         }
6355         state->out_mem_ctx = NULL;
6356         state->dispatch_recv = cli->dispatch_recv;
6357
6358         /* In parameters */
6359         state->orig.in.handle = _handle;
6360         state->orig.in.info_level = _info_level;
6361         state->orig.in.info = _info;
6362
6363         /* Out parameters */
6364
6365         /* Result */
6366         ZERO_STRUCT(state->orig.out.result);
6367
6368         if (DEBUGLEVEL >= 10) {
6369                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfig2A, &state->orig);
6370         }
6371
6372         /* make a temporary copy, that we pass to the dispatch function */
6373         state->tmp = state->orig;
6374
6375         subreq = cli->dispatch_send(state, ev, cli,
6376                                     &ndr_table_svcctl,
6377                                     NDR_SVCCTL_CHANGESERVICECONFIG2A,
6378                                     &state->tmp);
6379         if (tevent_req_nomem(subreq, req)) {
6380                 return tevent_req_post(req, ev);
6381         }
6382         tevent_req_set_callback(subreq, rpccli_svcctl_ChangeServiceConfig2A_done, req);
6383         return req;
6384 }
6385
6386 static void rpccli_svcctl_ChangeServiceConfig2A_done(struct tevent_req *subreq)
6387 {
6388         struct tevent_req *req = tevent_req_callback_data(
6389                 subreq, struct tevent_req);
6390         struct rpccli_svcctl_ChangeServiceConfig2A_state *state = tevent_req_data(
6391                 req, struct rpccli_svcctl_ChangeServiceConfig2A_state);
6392         NTSTATUS status;
6393         TALLOC_CTX *mem_ctx;
6394
6395         if (state->out_mem_ctx) {
6396                 mem_ctx = state->out_mem_ctx;
6397         } else {
6398                 mem_ctx = state;
6399         }
6400
6401         status = state->dispatch_recv(subreq, mem_ctx);
6402         TALLOC_FREE(subreq);
6403         if (!NT_STATUS_IS_OK(status)) {
6404                 tevent_req_nterror(req, status);
6405                 return;
6406         }
6407
6408         /* Copy out parameters */
6409
6410         /* Copy result */
6411         state->orig.out.result = state->tmp.out.result;
6412
6413         /* Reset temporary structure */
6414         ZERO_STRUCT(state->tmp);
6415
6416         if (DEBUGLEVEL >= 10) {
6417                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfig2A, &state->orig);
6418         }
6419
6420         tevent_req_done(req);
6421 }
6422
6423 NTSTATUS rpccli_svcctl_ChangeServiceConfig2A_recv(struct tevent_req *req,
6424                                                   TALLOC_CTX *mem_ctx,
6425                                                   WERROR *result)
6426 {
6427         struct rpccli_svcctl_ChangeServiceConfig2A_state *state = tevent_req_data(
6428                 req, struct rpccli_svcctl_ChangeServiceConfig2A_state);
6429         NTSTATUS status;
6430
6431         if (tevent_req_is_nterror(req, &status)) {
6432                 tevent_req_received(req);
6433                 return status;
6434         }
6435
6436         /* Steal possbile out parameters to the callers context */
6437         talloc_steal(mem_ctx, state->out_mem_ctx);
6438
6439         /* Return result */
6440         *result = state->orig.out.result;
6441
6442         tevent_req_received(req);
6443         return NT_STATUS_OK;
6444 }
6445
6446 NTSTATUS rpccli_svcctl_ChangeServiceConfig2A(struct rpc_pipe_client *cli,
6447                                              TALLOC_CTX *mem_ctx,
6448                                              struct policy_handle *handle /* [in] [ref] */,
6449                                              uint32_t info_level /* [in]  */,
6450                                              uint8_t *info /* [in] [unique] */,
6451                                              WERROR *werror)
6452 {
6453         struct svcctl_ChangeServiceConfig2A r;
6454         NTSTATUS status;
6455
6456         /* In parameters */
6457         r.in.handle = handle;
6458         r.in.info_level = info_level;
6459         r.in.info = info;
6460
6461         if (DEBUGLEVEL >= 10) {
6462                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfig2A, &r);
6463         }
6464
6465         status = cli->dispatch(cli,
6466                                 mem_ctx,
6467                                 &ndr_table_svcctl,
6468                                 NDR_SVCCTL_CHANGESERVICECONFIG2A,
6469                                 &r);
6470
6471         if (!NT_STATUS_IS_OK(status)) {
6472                 return status;
6473         }
6474
6475         if (DEBUGLEVEL >= 10) {
6476                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfig2A, &r);
6477         }
6478
6479         if (NT_STATUS_IS_ERR(status)) {
6480                 return status;
6481         }
6482
6483         /* Return variables */
6484
6485         /* Return result */
6486         if (werror) {
6487                 *werror = r.out.result;
6488         }
6489
6490         return werror_to_ntstatus(r.out.result);
6491 }
6492
6493 struct rpccli_svcctl_ChangeServiceConfig2W_state {
6494         struct svcctl_ChangeServiceConfig2W orig;
6495         struct svcctl_ChangeServiceConfig2W tmp;
6496         TALLOC_CTX *out_mem_ctx;
6497         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6498 };
6499
6500 static void rpccli_svcctl_ChangeServiceConfig2W_done(struct tevent_req *subreq);
6501
6502 struct tevent_req *rpccli_svcctl_ChangeServiceConfig2W_send(TALLOC_CTX *mem_ctx,
6503                                                             struct tevent_context *ev,
6504                                                             struct rpc_pipe_client *cli,
6505                                                             struct policy_handle *_handle /* [in] [ref] */,
6506                                                             uint32_t _info_level /* [in]  */,
6507                                                             uint8_t *_info /* [in] [unique] */)
6508 {
6509         struct tevent_req *req;
6510         struct rpccli_svcctl_ChangeServiceConfig2W_state *state;
6511         struct tevent_req *subreq;
6512
6513         req = tevent_req_create(mem_ctx, &state,
6514                                 struct rpccli_svcctl_ChangeServiceConfig2W_state);
6515         if (req == NULL) {
6516                 return NULL;
6517         }
6518         state->out_mem_ctx = NULL;
6519         state->dispatch_recv = cli->dispatch_recv;
6520
6521         /* In parameters */
6522         state->orig.in.handle = _handle;
6523         state->orig.in.info_level = _info_level;
6524         state->orig.in.info = _info;
6525
6526         /* Out parameters */
6527
6528         /* Result */
6529         ZERO_STRUCT(state->orig.out.result);
6530
6531         if (DEBUGLEVEL >= 10) {
6532                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfig2W, &state->orig);
6533         }
6534
6535         /* make a temporary copy, that we pass to the dispatch function */
6536         state->tmp = state->orig;
6537
6538         subreq = cli->dispatch_send(state, ev, cli,
6539                                     &ndr_table_svcctl,
6540                                     NDR_SVCCTL_CHANGESERVICECONFIG2W,
6541                                     &state->tmp);
6542         if (tevent_req_nomem(subreq, req)) {
6543                 return tevent_req_post(req, ev);
6544         }
6545         tevent_req_set_callback(subreq, rpccli_svcctl_ChangeServiceConfig2W_done, req);
6546         return req;
6547 }
6548
6549 static void rpccli_svcctl_ChangeServiceConfig2W_done(struct tevent_req *subreq)
6550 {
6551         struct tevent_req *req = tevent_req_callback_data(
6552                 subreq, struct tevent_req);
6553         struct rpccli_svcctl_ChangeServiceConfig2W_state *state = tevent_req_data(
6554                 req, struct rpccli_svcctl_ChangeServiceConfig2W_state);
6555         NTSTATUS status;
6556         TALLOC_CTX *mem_ctx;
6557
6558         if (state->out_mem_ctx) {
6559                 mem_ctx = state->out_mem_ctx;
6560         } else {
6561                 mem_ctx = state;
6562         }
6563
6564         status = state->dispatch_recv(subreq, mem_ctx);
6565         TALLOC_FREE(subreq);
6566         if (!NT_STATUS_IS_OK(status)) {
6567                 tevent_req_nterror(req, status);
6568                 return;
6569         }
6570
6571         /* Copy out parameters */
6572
6573         /* Copy result */
6574         state->orig.out.result = state->tmp.out.result;
6575
6576         /* Reset temporary structure */
6577         ZERO_STRUCT(state->tmp);
6578
6579         if (DEBUGLEVEL >= 10) {
6580                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfig2W, &state->orig);
6581         }
6582
6583         tevent_req_done(req);
6584 }
6585
6586 NTSTATUS rpccli_svcctl_ChangeServiceConfig2W_recv(struct tevent_req *req,
6587                                                   TALLOC_CTX *mem_ctx,
6588                                                   WERROR *result)
6589 {
6590         struct rpccli_svcctl_ChangeServiceConfig2W_state *state = tevent_req_data(
6591                 req, struct rpccli_svcctl_ChangeServiceConfig2W_state);
6592         NTSTATUS status;
6593
6594         if (tevent_req_is_nterror(req, &status)) {
6595                 tevent_req_received(req);
6596                 return status;
6597         }
6598
6599         /* Steal possbile out parameters to the callers context */
6600         talloc_steal(mem_ctx, state->out_mem_ctx);
6601
6602         /* Return result */
6603         *result = state->orig.out.result;
6604
6605         tevent_req_received(req);
6606         return NT_STATUS_OK;
6607 }
6608
6609 NTSTATUS rpccli_svcctl_ChangeServiceConfig2W(struct rpc_pipe_client *cli,
6610                                              TALLOC_CTX *mem_ctx,
6611                                              struct policy_handle *handle /* [in] [ref] */,
6612                                              uint32_t info_level /* [in]  */,
6613                                              uint8_t *info /* [in] [unique] */,
6614                                              WERROR *werror)
6615 {
6616         struct svcctl_ChangeServiceConfig2W r;
6617         NTSTATUS status;
6618
6619         /* In parameters */
6620         r.in.handle = handle;
6621         r.in.info_level = info_level;
6622         r.in.info = info;
6623
6624         if (DEBUGLEVEL >= 10) {
6625                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfig2W, &r);
6626         }
6627
6628         status = cli->dispatch(cli,
6629                                 mem_ctx,
6630                                 &ndr_table_svcctl,
6631                                 NDR_SVCCTL_CHANGESERVICECONFIG2W,
6632                                 &r);
6633
6634         if (!NT_STATUS_IS_OK(status)) {
6635                 return status;
6636         }
6637
6638         if (DEBUGLEVEL >= 10) {
6639                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfig2W, &r);
6640         }
6641
6642         if (NT_STATUS_IS_ERR(status)) {
6643                 return status;
6644         }
6645
6646         /* Return variables */
6647
6648         /* Return result */
6649         if (werror) {
6650                 *werror = r.out.result;
6651         }
6652
6653         return werror_to_ntstatus(r.out.result);
6654 }
6655
6656 struct rpccli_svcctl_QueryServiceConfig2A_state {
6657         struct svcctl_QueryServiceConfig2A orig;
6658         struct svcctl_QueryServiceConfig2A tmp;
6659         TALLOC_CTX *out_mem_ctx;
6660         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6661 };
6662
6663 static void rpccli_svcctl_QueryServiceConfig2A_done(struct tevent_req *subreq);
6664
6665 struct tevent_req *rpccli_svcctl_QueryServiceConfig2A_send(TALLOC_CTX *mem_ctx,
6666                                                            struct tevent_context *ev,
6667                                                            struct rpc_pipe_client *cli,
6668                                                            struct policy_handle *_handle /* [in] [ref] */,
6669                                                            enum svcctl_ConfigLevel _info_level /* [in]  */,
6670                                                            uint8_t *_buffer /* [out]  */,
6671                                                            uint32_t _offered /* [in]  */,
6672                                                            uint32_t *_needed /* [out] [ref] */)
6673 {
6674         struct tevent_req *req;
6675         struct rpccli_svcctl_QueryServiceConfig2A_state *state;
6676         struct tevent_req *subreq;
6677
6678         req = tevent_req_create(mem_ctx, &state,
6679                                 struct rpccli_svcctl_QueryServiceConfig2A_state);
6680         if (req == NULL) {
6681                 return NULL;
6682         }
6683         state->out_mem_ctx = NULL;
6684         state->dispatch_recv = cli->dispatch_recv;
6685
6686         /* In parameters */
6687         state->orig.in.handle = _handle;
6688         state->orig.in.info_level = _info_level;
6689         state->orig.in.offered = _offered;
6690
6691         /* Out parameters */
6692         state->orig.out.buffer = _buffer;
6693         state->orig.out.needed = _needed;
6694
6695         /* Result */
6696         ZERO_STRUCT(state->orig.out.result);
6697
6698         if (DEBUGLEVEL >= 10) {
6699                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfig2A, &state->orig);
6700         }
6701
6702         state->out_mem_ctx = talloc_named_const(state, 0,
6703                              "rpccli_svcctl_QueryServiceConfig2A_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_svcctl,
6713                                     NDR_SVCCTL_QUERYSERVICECONFIG2A,
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_svcctl_QueryServiceConfig2A_done, req);
6719         return req;
6720 }
6721
6722 static void rpccli_svcctl_QueryServiceConfig2A_done(struct tevent_req *subreq)
6723 {
6724         struct tevent_req *req = tevent_req_callback_data(
6725                 subreq, struct tevent_req);
6726         struct rpccli_svcctl_QueryServiceConfig2A_state *state = tevent_req_data(
6727                 req, struct rpccli_svcctl_QueryServiceConfig2A_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         memcpy(state->orig.out.buffer, state->tmp.out.buffer, state->tmp.in.offered * sizeof(*state->orig.out.buffer));
6746         *state->orig.out.needed = *state->tmp.out.needed;
6747
6748         /* Copy result */
6749         state->orig.out.result = state->tmp.out.result;
6750
6751         /* Reset temporary structure */
6752         ZERO_STRUCT(state->tmp);
6753
6754         if (DEBUGLEVEL >= 10) {
6755                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfig2A, &state->orig);
6756         }
6757
6758         tevent_req_done(req);
6759 }
6760
6761 NTSTATUS rpccli_svcctl_QueryServiceConfig2A_recv(struct tevent_req *req,
6762                                                  TALLOC_CTX *mem_ctx,
6763                                                  WERROR *result)
6764 {
6765         struct rpccli_svcctl_QueryServiceConfig2A_state *state = tevent_req_data(
6766                 req, struct rpccli_svcctl_QueryServiceConfig2A_state);
6767         NTSTATUS status;
6768
6769         if (tevent_req_is_nterror(req, &status)) {
6770                 tevent_req_received(req);
6771                 return status;
6772         }
6773
6774         /* Steal possbile out parameters to the callers context */
6775         talloc_steal(mem_ctx, state->out_mem_ctx);
6776
6777         /* Return result */
6778         *result = state->orig.out.result;
6779
6780         tevent_req_received(req);
6781         return NT_STATUS_OK;
6782 }
6783
6784 NTSTATUS rpccli_svcctl_QueryServiceConfig2A(struct rpc_pipe_client *cli,
6785                                             TALLOC_CTX *mem_ctx,
6786                                             struct policy_handle *handle /* [in] [ref] */,
6787                                             enum svcctl_ConfigLevel info_level /* [in]  */,
6788                                             uint8_t *buffer /* [out]  */,
6789                                             uint32_t offered /* [in]  */,
6790                                             uint32_t *needed /* [out] [ref] */,
6791                                             WERROR *werror)
6792 {
6793         struct svcctl_QueryServiceConfig2A r;
6794         NTSTATUS status;
6795
6796         /* In parameters */
6797         r.in.handle = handle;
6798         r.in.info_level = info_level;
6799         r.in.offered = offered;
6800
6801         if (DEBUGLEVEL >= 10) {
6802                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfig2A, &r);
6803         }
6804
6805         status = cli->dispatch(cli,
6806                                 mem_ctx,
6807                                 &ndr_table_svcctl,
6808                                 NDR_SVCCTL_QUERYSERVICECONFIG2A,
6809                                 &r);
6810
6811         if (!NT_STATUS_IS_OK(status)) {
6812                 return status;
6813         }
6814
6815         if (DEBUGLEVEL >= 10) {
6816                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfig2A, &r);
6817         }
6818
6819         if (NT_STATUS_IS_ERR(status)) {
6820                 return status;
6821         }
6822
6823         /* Return variables */
6824         memcpy(buffer, r.out.buffer, r.in.offered * sizeof(*buffer));
6825         *needed = *r.out.needed;
6826
6827         /* Return result */
6828         if (werror) {
6829                 *werror = r.out.result;
6830         }
6831
6832         return werror_to_ntstatus(r.out.result);
6833 }
6834
6835 struct rpccli_svcctl_QueryServiceConfig2W_state {
6836         struct svcctl_QueryServiceConfig2W orig;
6837         struct svcctl_QueryServiceConfig2W tmp;
6838         TALLOC_CTX *out_mem_ctx;
6839         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6840 };
6841
6842 static void rpccli_svcctl_QueryServiceConfig2W_done(struct tevent_req *subreq);
6843
6844 struct tevent_req *rpccli_svcctl_QueryServiceConfig2W_send(TALLOC_CTX *mem_ctx,
6845                                                            struct tevent_context *ev,
6846                                                            struct rpc_pipe_client *cli,
6847                                                            struct policy_handle *_handle /* [in] [ref] */,
6848                                                            enum svcctl_ConfigLevel _info_level /* [in]  */,
6849                                                            uint8_t *_buffer /* [out] [ref,size_is(offered)] */,
6850                                                            uint32_t _offered /* [in] [range(0,8192)] */,
6851                                                            uint32_t *_needed /* [out] [ref,range(0,8192)] */)
6852 {
6853         struct tevent_req *req;
6854         struct rpccli_svcctl_QueryServiceConfig2W_state *state;
6855         struct tevent_req *subreq;
6856
6857         req = tevent_req_create(mem_ctx, &state,
6858                                 struct rpccli_svcctl_QueryServiceConfig2W_state);
6859         if (req == NULL) {
6860                 return NULL;
6861         }
6862         state->out_mem_ctx = NULL;
6863         state->dispatch_recv = cli->dispatch_recv;
6864
6865         /* In parameters */
6866         state->orig.in.handle = _handle;
6867         state->orig.in.info_level = _info_level;
6868         state->orig.in.offered = _offered;
6869
6870         /* Out parameters */
6871         state->orig.out.buffer = _buffer;
6872         state->orig.out.needed = _needed;
6873
6874         /* Result */
6875         ZERO_STRUCT(state->orig.out.result);
6876
6877         if (DEBUGLEVEL >= 10) {
6878                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfig2W, &state->orig);
6879         }
6880
6881         state->out_mem_ctx = talloc_named_const(state, 0,
6882                              "rpccli_svcctl_QueryServiceConfig2W_out_memory");
6883         if (tevent_req_nomem(state->out_mem_ctx, req)) {
6884                 return tevent_req_post(req, ev);
6885         }
6886
6887         /* make a temporary copy, that we pass to the dispatch function */
6888         state->tmp = state->orig;
6889
6890         subreq = cli->dispatch_send(state, ev, cli,
6891                                     &ndr_table_svcctl,
6892                                     NDR_SVCCTL_QUERYSERVICECONFIG2W,
6893                                     &state->tmp);
6894         if (tevent_req_nomem(subreq, req)) {
6895                 return tevent_req_post(req, ev);
6896         }
6897         tevent_req_set_callback(subreq, rpccli_svcctl_QueryServiceConfig2W_done, req);
6898         return req;
6899 }
6900
6901 static void rpccli_svcctl_QueryServiceConfig2W_done(struct tevent_req *subreq)
6902 {
6903         struct tevent_req *req = tevent_req_callback_data(
6904                 subreq, struct tevent_req);
6905         struct rpccli_svcctl_QueryServiceConfig2W_state *state = tevent_req_data(
6906                 req, struct rpccli_svcctl_QueryServiceConfig2W_state);
6907         NTSTATUS status;
6908         TALLOC_CTX *mem_ctx;
6909
6910         if (state->out_mem_ctx) {
6911                 mem_ctx = state->out_mem_ctx;
6912         } else {
6913                 mem_ctx = state;
6914         }
6915
6916         status = state->dispatch_recv(subreq, mem_ctx);
6917         TALLOC_FREE(subreq);
6918         if (!NT_STATUS_IS_OK(status)) {
6919                 tevent_req_nterror(req, status);
6920                 return;
6921         }
6922
6923         /* Copy out parameters */
6924         memcpy(state->orig.out.buffer, state->tmp.out.buffer, state->tmp.in.offered * sizeof(*state->orig.out.buffer));
6925         *state->orig.out.needed = *state->tmp.out.needed;
6926
6927         /* Copy result */
6928         state->orig.out.result = state->tmp.out.result;
6929
6930         /* Reset temporary structure */
6931         ZERO_STRUCT(state->tmp);
6932
6933         if (DEBUGLEVEL >= 10) {
6934                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfig2W, &state->orig);
6935         }
6936
6937         tevent_req_done(req);
6938 }
6939
6940 NTSTATUS rpccli_svcctl_QueryServiceConfig2W_recv(struct tevent_req *req,
6941                                                  TALLOC_CTX *mem_ctx,
6942                                                  WERROR *result)
6943 {
6944         struct rpccli_svcctl_QueryServiceConfig2W_state *state = tevent_req_data(
6945                 req, struct rpccli_svcctl_QueryServiceConfig2W_state);
6946         NTSTATUS status;
6947
6948         if (tevent_req_is_nterror(req, &status)) {
6949                 tevent_req_received(req);
6950                 return status;
6951         }
6952
6953         /* Steal possbile out parameters to the callers context */
6954         talloc_steal(mem_ctx, state->out_mem_ctx);
6955
6956         /* Return result */
6957         *result = state->orig.out.result;
6958
6959         tevent_req_received(req);
6960         return NT_STATUS_OK;
6961 }
6962
6963 NTSTATUS rpccli_svcctl_QueryServiceConfig2W(struct rpc_pipe_client *cli,
6964                                             TALLOC_CTX *mem_ctx,
6965                                             struct policy_handle *handle /* [in] [ref] */,
6966                                             enum svcctl_ConfigLevel info_level /* [in]  */,
6967                                             uint8_t *buffer /* [out] [ref,size_is(offered)] */,
6968                                             uint32_t offered /* [in] [range(0,8192)] */,
6969                                             uint32_t *needed /* [out] [ref,range(0,8192)] */,
6970                                             WERROR *werror)
6971 {
6972         struct svcctl_QueryServiceConfig2W r;
6973         NTSTATUS status;
6974
6975         /* In parameters */
6976         r.in.handle = handle;
6977         r.in.info_level = info_level;
6978         r.in.offered = offered;
6979
6980         if (DEBUGLEVEL >= 10) {
6981                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfig2W, &r);
6982         }
6983
6984         status = cli->dispatch(cli,
6985                                 mem_ctx,
6986                                 &ndr_table_svcctl,
6987                                 NDR_SVCCTL_QUERYSERVICECONFIG2W,
6988                                 &r);
6989
6990         if (!NT_STATUS_IS_OK(status)) {
6991                 return status;
6992         }
6993
6994         if (DEBUGLEVEL >= 10) {
6995                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfig2W, &r);
6996         }
6997
6998         if (NT_STATUS_IS_ERR(status)) {
6999                 return status;
7000         }
7001
7002         /* Return variables */
7003         memcpy(buffer, r.out.buffer, r.in.offered * sizeof(*buffer));
7004         *needed = *r.out.needed;
7005
7006         /* Return result */
7007         if (werror) {
7008                 *werror = r.out.result;
7009         }
7010
7011         return werror_to_ntstatus(r.out.result);
7012 }
7013
7014 struct rpccli_svcctl_QueryServiceStatusEx_state {
7015         struct svcctl_QueryServiceStatusEx orig;
7016         struct svcctl_QueryServiceStatusEx tmp;
7017         TALLOC_CTX *out_mem_ctx;
7018         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7019 };
7020
7021 static void rpccli_svcctl_QueryServiceStatusEx_done(struct tevent_req *subreq);
7022
7023 struct tevent_req *rpccli_svcctl_QueryServiceStatusEx_send(TALLOC_CTX *mem_ctx,
7024                                                            struct tevent_context *ev,
7025                                                            struct rpc_pipe_client *cli,
7026                                                            struct policy_handle *_handle /* [in] [ref] */,
7027                                                            enum svcctl_StatusLevel _info_level /* [in]  */,
7028                                                            uint8_t *_buffer /* [out] [ref,size_is(offered)] */,
7029                                                            uint32_t _offered /* [in] [range(0,8192)] */,
7030                                                            uint32_t *_needed /* [out] [ref,range(0,8192)] */)
7031 {
7032         struct tevent_req *req;
7033         struct rpccli_svcctl_QueryServiceStatusEx_state *state;
7034         struct tevent_req *subreq;
7035
7036         req = tevent_req_create(mem_ctx, &state,
7037                                 struct rpccli_svcctl_QueryServiceStatusEx_state);
7038         if (req == NULL) {
7039                 return NULL;
7040         }
7041         state->out_mem_ctx = NULL;
7042         state->dispatch_recv = cli->dispatch_recv;
7043
7044         /* In parameters */
7045         state->orig.in.handle = _handle;
7046         state->orig.in.info_level = _info_level;
7047         state->orig.in.offered = _offered;
7048
7049         /* Out parameters */
7050         state->orig.out.buffer = _buffer;
7051         state->orig.out.needed = _needed;
7052
7053         /* Result */
7054         ZERO_STRUCT(state->orig.out.result);
7055
7056         if (DEBUGLEVEL >= 10) {
7057                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceStatusEx, &state->orig);
7058         }
7059
7060         state->out_mem_ctx = talloc_named_const(state, 0,
7061                              "rpccli_svcctl_QueryServiceStatusEx_out_memory");
7062         if (tevent_req_nomem(state->out_mem_ctx, req)) {
7063                 return tevent_req_post(req, ev);
7064         }
7065
7066         /* make a temporary copy, that we pass to the dispatch function */
7067         state->tmp = state->orig;
7068
7069         subreq = cli->dispatch_send(state, ev, cli,
7070                                     &ndr_table_svcctl,
7071                                     NDR_SVCCTL_QUERYSERVICESTATUSEX,
7072                                     &state->tmp);
7073         if (tevent_req_nomem(subreq, req)) {
7074                 return tevent_req_post(req, ev);
7075         }
7076         tevent_req_set_callback(subreq, rpccli_svcctl_QueryServiceStatusEx_done, req);
7077         return req;
7078 }
7079
7080 static void rpccli_svcctl_QueryServiceStatusEx_done(struct tevent_req *subreq)
7081 {
7082         struct tevent_req *req = tevent_req_callback_data(
7083                 subreq, struct tevent_req);
7084         struct rpccli_svcctl_QueryServiceStatusEx_state *state = tevent_req_data(
7085                 req, struct rpccli_svcctl_QueryServiceStatusEx_state);
7086         NTSTATUS status;
7087         TALLOC_CTX *mem_ctx;
7088
7089         if (state->out_mem_ctx) {
7090                 mem_ctx = state->out_mem_ctx;
7091         } else {
7092                 mem_ctx = state;
7093         }
7094
7095         status = state->dispatch_recv(subreq, mem_ctx);
7096         TALLOC_FREE(subreq);
7097         if (!NT_STATUS_IS_OK(status)) {
7098                 tevent_req_nterror(req, status);
7099                 return;
7100         }
7101
7102         /* Copy out parameters */
7103         memcpy(state->orig.out.buffer, state->tmp.out.buffer, state->tmp.in.offered * sizeof(*state->orig.out.buffer));
7104         *state->orig.out.needed = *state->tmp.out.needed;
7105
7106         /* Copy result */
7107         state->orig.out.result = state->tmp.out.result;
7108
7109         /* Reset temporary structure */
7110         ZERO_STRUCT(state->tmp);
7111
7112         if (DEBUGLEVEL >= 10) {
7113                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceStatusEx, &state->orig);
7114         }
7115
7116         tevent_req_done(req);
7117 }
7118
7119 NTSTATUS rpccli_svcctl_QueryServiceStatusEx_recv(struct tevent_req *req,
7120                                                  TALLOC_CTX *mem_ctx,
7121                                                  WERROR *result)
7122 {
7123         struct rpccli_svcctl_QueryServiceStatusEx_state *state = tevent_req_data(
7124                 req, struct rpccli_svcctl_QueryServiceStatusEx_state);
7125         NTSTATUS status;
7126
7127         if (tevent_req_is_nterror(req, &status)) {
7128                 tevent_req_received(req);
7129                 return status;
7130         }
7131
7132         /* Steal possbile out parameters to the callers context */
7133         talloc_steal(mem_ctx, state->out_mem_ctx);
7134
7135         /* Return result */
7136         *result = state->orig.out.result;
7137
7138         tevent_req_received(req);
7139         return NT_STATUS_OK;
7140 }
7141
7142 NTSTATUS rpccli_svcctl_QueryServiceStatusEx(struct rpc_pipe_client *cli,
7143                                             TALLOC_CTX *mem_ctx,
7144                                             struct policy_handle *handle /* [in] [ref] */,
7145                                             enum svcctl_StatusLevel info_level /* [in]  */,
7146                                             uint8_t *buffer /* [out] [ref,size_is(offered)] */,
7147                                             uint32_t offered /* [in] [range(0,8192)] */,
7148                                             uint32_t *needed /* [out] [ref,range(0,8192)] */,
7149                                             WERROR *werror)
7150 {
7151         struct svcctl_QueryServiceStatusEx r;
7152         NTSTATUS status;
7153
7154         /* In parameters */
7155         r.in.handle = handle;
7156         r.in.info_level = info_level;
7157         r.in.offered = offered;
7158
7159         if (DEBUGLEVEL >= 10) {
7160                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceStatusEx, &r);
7161         }
7162
7163         status = cli->dispatch(cli,
7164                                 mem_ctx,
7165                                 &ndr_table_svcctl,
7166                                 NDR_SVCCTL_QUERYSERVICESTATUSEX,
7167                                 &r);
7168
7169         if (!NT_STATUS_IS_OK(status)) {
7170                 return status;
7171         }
7172
7173         if (DEBUGLEVEL >= 10) {
7174                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceStatusEx, &r);
7175         }
7176
7177         if (NT_STATUS_IS_ERR(status)) {
7178                 return status;
7179         }
7180
7181         /* Return variables */
7182         memcpy(buffer, r.out.buffer, r.in.offered * sizeof(*buffer));
7183         *needed = *r.out.needed;
7184
7185         /* Return result */
7186         if (werror) {
7187                 *werror = r.out.result;
7188         }
7189
7190         return werror_to_ntstatus(r.out.result);
7191 }
7192
7193 struct rpccli_EnumServicesStatusExA_state {
7194         struct EnumServicesStatusExA orig;
7195         struct EnumServicesStatusExA tmp;
7196         TALLOC_CTX *out_mem_ctx;
7197         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7198 };
7199
7200 static void rpccli_EnumServicesStatusExA_done(struct tevent_req *subreq);
7201
7202 struct tevent_req *rpccli_EnumServicesStatusExA_send(TALLOC_CTX *mem_ctx,
7203                                                      struct tevent_context *ev,
7204                                                      struct rpc_pipe_client *cli,
7205                                                      struct policy_handle *_scmanager /* [in] [ref] */,
7206                                                      uint32_t _info_level /* [in]  */,
7207                                                      uint32_t _type /* [in]  */,
7208                                                      enum svcctl_ServiceState _state /* [in]  */,
7209                                                      uint8_t *_services /* [out]  */,
7210                                                      uint32_t _offered /* [in]  */,
7211                                                      uint32_t *_needed /* [out] [ref] */,
7212                                                      uint32_t *_service_returned /* [out] [ref] */,
7213                                                      uint32_t *_resume_handle /* [in,out] [unique] */,
7214                                                      const char **_group_name /* [out] [ref,charset(UTF16)] */)
7215 {
7216         struct tevent_req *req;
7217         struct rpccli_EnumServicesStatusExA_state *state;
7218         struct tevent_req *subreq;
7219
7220         req = tevent_req_create(mem_ctx, &state,
7221                                 struct rpccli_EnumServicesStatusExA_state);
7222         if (req == NULL) {
7223                 return NULL;
7224         }
7225         state->out_mem_ctx = NULL;
7226         state->dispatch_recv = cli->dispatch_recv;
7227
7228         /* In parameters */
7229         state->orig.in.scmanager = _scmanager;
7230         state->orig.in.info_level = _info_level;
7231         state->orig.in.type = _type;
7232         state->orig.in.state = _state;
7233         state->orig.in.offered = _offered;
7234         state->orig.in.resume_handle = _resume_handle;
7235
7236         /* Out parameters */
7237         state->orig.out.services = _services;
7238         state->orig.out.needed = _needed;
7239         state->orig.out.service_returned = _service_returned;
7240         state->orig.out.resume_handle = _resume_handle;
7241         state->orig.out.group_name = _group_name;
7242
7243         /* Result */
7244         ZERO_STRUCT(state->orig.out.result);
7245
7246         if (DEBUGLEVEL >= 10) {
7247                 NDR_PRINT_IN_DEBUG(EnumServicesStatusExA, &state->orig);
7248         }
7249
7250         state->out_mem_ctx = talloc_named_const(state, 0,
7251                              "rpccli_EnumServicesStatusExA_out_memory");
7252         if (tevent_req_nomem(state->out_mem_ctx, req)) {
7253                 return tevent_req_post(req, ev);
7254         }
7255
7256         /* make a temporary copy, that we pass to the dispatch function */
7257         state->tmp = state->orig;
7258
7259         subreq = cli->dispatch_send(state, ev, cli,
7260                                     &ndr_table_svcctl,
7261                                     NDR_ENUMSERVICESSTATUSEXA,
7262                                     &state->tmp);
7263         if (tevent_req_nomem(subreq, req)) {
7264                 return tevent_req_post(req, ev);
7265         }
7266         tevent_req_set_callback(subreq, rpccli_EnumServicesStatusExA_done, req);
7267         return req;
7268 }
7269
7270 static void rpccli_EnumServicesStatusExA_done(struct tevent_req *subreq)
7271 {
7272         struct tevent_req *req = tevent_req_callback_data(
7273                 subreq, struct tevent_req);
7274         struct rpccli_EnumServicesStatusExA_state *state = tevent_req_data(
7275                 req, struct rpccli_EnumServicesStatusExA_state);
7276         NTSTATUS status;
7277         TALLOC_CTX *mem_ctx;
7278
7279         if (state->out_mem_ctx) {
7280                 mem_ctx = state->out_mem_ctx;
7281         } else {
7282                 mem_ctx = state;
7283         }
7284
7285         status = state->dispatch_recv(subreq, mem_ctx);
7286         TALLOC_FREE(subreq);
7287         if (!NT_STATUS_IS_OK(status)) {
7288                 tevent_req_nterror(req, status);
7289                 return;
7290         }
7291
7292         /* Copy out parameters */
7293         memcpy(state->orig.out.services, state->tmp.out.services, state->tmp.in.offered * sizeof(*state->orig.out.services));
7294         *state->orig.out.needed = *state->tmp.out.needed;
7295         *state->orig.out.service_returned = *state->tmp.out.service_returned;
7296         if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
7297                 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
7298         }
7299         *state->orig.out.group_name = *state->tmp.out.group_name;
7300
7301         /* Copy result */
7302         state->orig.out.result = state->tmp.out.result;
7303
7304         /* Reset temporary structure */
7305         ZERO_STRUCT(state->tmp);
7306
7307         if (DEBUGLEVEL >= 10) {
7308                 NDR_PRINT_OUT_DEBUG(EnumServicesStatusExA, &state->orig);
7309         }
7310
7311         tevent_req_done(req);
7312 }
7313
7314 NTSTATUS rpccli_EnumServicesStatusExA_recv(struct tevent_req *req,
7315                                            TALLOC_CTX *mem_ctx,
7316                                            WERROR *result)
7317 {
7318         struct rpccli_EnumServicesStatusExA_state *state = tevent_req_data(
7319                 req, struct rpccli_EnumServicesStatusExA_state);
7320         NTSTATUS status;
7321
7322         if (tevent_req_is_nterror(req, &status)) {
7323                 tevent_req_received(req);
7324                 return status;
7325         }
7326
7327         /* Steal possbile out parameters to the callers context */
7328         talloc_steal(mem_ctx, state->out_mem_ctx);
7329
7330         /* Return result */
7331         *result = state->orig.out.result;
7332
7333         tevent_req_received(req);
7334         return NT_STATUS_OK;
7335 }
7336
7337 NTSTATUS rpccli_EnumServicesStatusExA(struct rpc_pipe_client *cli,
7338                                       TALLOC_CTX *mem_ctx,
7339                                       struct policy_handle *scmanager /* [in] [ref] */,
7340                                       uint32_t info_level /* [in]  */,
7341                                       uint32_t type /* [in]  */,
7342                                       enum svcctl_ServiceState state /* [in]  */,
7343                                       uint8_t *services /* [out]  */,
7344                                       uint32_t offered /* [in]  */,
7345                                       uint32_t *needed /* [out] [ref] */,
7346                                       uint32_t *service_returned /* [out] [ref] */,
7347                                       uint32_t *resume_handle /* [in,out] [unique] */,
7348                                       const char **group_name /* [out] [ref,charset(UTF16)] */,
7349                                       WERROR *werror)
7350 {
7351         struct EnumServicesStatusExA r;
7352         NTSTATUS status;
7353
7354         /* In parameters */
7355         r.in.scmanager = scmanager;
7356         r.in.info_level = info_level;
7357         r.in.type = type;
7358         r.in.state = state;
7359         r.in.offered = offered;
7360         r.in.resume_handle = resume_handle;
7361
7362         if (DEBUGLEVEL >= 10) {
7363                 NDR_PRINT_IN_DEBUG(EnumServicesStatusExA, &r);
7364         }
7365
7366         status = cli->dispatch(cli,
7367                                 mem_ctx,
7368                                 &ndr_table_svcctl,
7369                                 NDR_ENUMSERVICESSTATUSEXA,
7370                                 &r);
7371
7372         if (!NT_STATUS_IS_OK(status)) {
7373                 return status;
7374         }
7375
7376         if (DEBUGLEVEL >= 10) {
7377                 NDR_PRINT_OUT_DEBUG(EnumServicesStatusExA, &r);
7378         }
7379
7380         if (NT_STATUS_IS_ERR(status)) {
7381                 return status;
7382         }
7383
7384         /* Return variables */
7385         memcpy(services, r.out.services, r.in.offered * sizeof(*services));
7386         *needed = *r.out.needed;
7387         *service_returned = *r.out.service_returned;
7388         if (resume_handle && r.out.resume_handle) {
7389                 *resume_handle = *r.out.resume_handle;
7390         }
7391         *group_name = *r.out.group_name;
7392
7393         /* Return result */
7394         if (werror) {
7395                 *werror = r.out.result;
7396         }
7397
7398         return werror_to_ntstatus(r.out.result);
7399 }
7400
7401 struct rpccli_EnumServicesStatusExW_state {
7402         struct EnumServicesStatusExW orig;
7403         struct EnumServicesStatusExW tmp;
7404         TALLOC_CTX *out_mem_ctx;
7405         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7406 };
7407
7408 static void rpccli_EnumServicesStatusExW_done(struct tevent_req *subreq);
7409
7410 struct tevent_req *rpccli_EnumServicesStatusExW_send(TALLOC_CTX *mem_ctx,
7411                                                      struct tevent_context *ev,
7412                                                      struct rpc_pipe_client *cli,
7413                                                      struct policy_handle *_scmanager /* [in] [ref] */,
7414                                                      uint32_t _info_level /* [in]  */,
7415                                                      uint32_t _type /* [in]  */,
7416                                                      enum svcctl_ServiceState _state /* [in]  */,
7417                                                      uint8_t *_services /* [out] [ref,size_is(offered)] */,
7418                                                      uint32_t _offered /* [in] [range(0,0x40000)] */,
7419                                                      uint32_t *_needed /* [out] [ref,range(0,0x40000)] */,
7420                                                      uint32_t *_service_returned /* [out] [ref,range(0,0x40000)] */,
7421                                                      uint32_t *_resume_handle /* [in,out] [unique,range(0,0x40000)] */,
7422                                                      const char *_group_name /* [in] [unique,charset(UTF16)] */)
7423 {
7424         struct tevent_req *req;
7425         struct rpccli_EnumServicesStatusExW_state *state;
7426         struct tevent_req *subreq;
7427
7428         req = tevent_req_create(mem_ctx, &state,
7429                                 struct rpccli_EnumServicesStatusExW_state);
7430         if (req == NULL) {
7431                 return NULL;
7432         }
7433         state->out_mem_ctx = NULL;
7434         state->dispatch_recv = cli->dispatch_recv;
7435
7436         /* In parameters */
7437         state->orig.in.scmanager = _scmanager;
7438         state->orig.in.info_level = _info_level;
7439         state->orig.in.type = _type;
7440         state->orig.in.state = _state;
7441         state->orig.in.offered = _offered;
7442         state->orig.in.resume_handle = _resume_handle;
7443         state->orig.in.group_name = _group_name;
7444
7445         /* Out parameters */
7446         state->orig.out.services = _services;
7447         state->orig.out.needed = _needed;
7448         state->orig.out.service_returned = _service_returned;
7449         state->orig.out.resume_handle = _resume_handle;
7450
7451         /* Result */
7452         ZERO_STRUCT(state->orig.out.result);
7453
7454         if (DEBUGLEVEL >= 10) {
7455                 NDR_PRINT_IN_DEBUG(EnumServicesStatusExW, &state->orig);
7456         }
7457
7458         state->out_mem_ctx = talloc_named_const(state, 0,
7459                              "rpccli_EnumServicesStatusExW_out_memory");
7460         if (tevent_req_nomem(state->out_mem_ctx, req)) {
7461                 return tevent_req_post(req, ev);
7462         }
7463
7464         /* make a temporary copy, that we pass to the dispatch function */
7465         state->tmp = state->orig;
7466
7467         subreq = cli->dispatch_send(state, ev, cli,
7468                                     &ndr_table_svcctl,
7469                                     NDR_ENUMSERVICESSTATUSEXW,
7470                                     &state->tmp);
7471         if (tevent_req_nomem(subreq, req)) {
7472                 return tevent_req_post(req, ev);
7473         }
7474         tevent_req_set_callback(subreq, rpccli_EnumServicesStatusExW_done, req);
7475         return req;
7476 }
7477
7478 static void rpccli_EnumServicesStatusExW_done(struct tevent_req *subreq)
7479 {
7480         struct tevent_req *req = tevent_req_callback_data(
7481                 subreq, struct tevent_req);
7482         struct rpccli_EnumServicesStatusExW_state *state = tevent_req_data(
7483                 req, struct rpccli_EnumServicesStatusExW_state);
7484         NTSTATUS status;
7485         TALLOC_CTX *mem_ctx;
7486
7487         if (state->out_mem_ctx) {
7488                 mem_ctx = state->out_mem_ctx;
7489         } else {
7490                 mem_ctx = state;
7491         }
7492
7493         status = state->dispatch_recv(subreq, mem_ctx);
7494         TALLOC_FREE(subreq);
7495         if (!NT_STATUS_IS_OK(status)) {
7496                 tevent_req_nterror(req, status);
7497                 return;
7498         }
7499
7500         /* Copy out parameters */
7501         memcpy(state->orig.out.services, state->tmp.out.services, state->tmp.in.offered * sizeof(*state->orig.out.services));
7502         *state->orig.out.needed = *state->tmp.out.needed;
7503         *state->orig.out.service_returned = *state->tmp.out.service_returned;
7504         if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
7505                 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
7506         }
7507
7508         /* Copy result */
7509         state->orig.out.result = state->tmp.out.result;
7510
7511         /* Reset temporary structure */
7512         ZERO_STRUCT(state->tmp);
7513
7514         if (DEBUGLEVEL >= 10) {
7515                 NDR_PRINT_OUT_DEBUG(EnumServicesStatusExW, &state->orig);
7516         }
7517
7518         tevent_req_done(req);
7519 }
7520
7521 NTSTATUS rpccli_EnumServicesStatusExW_recv(struct tevent_req *req,
7522                                            TALLOC_CTX *mem_ctx,
7523                                            WERROR *result)
7524 {
7525         struct rpccli_EnumServicesStatusExW_state *state = tevent_req_data(
7526                 req, struct rpccli_EnumServicesStatusExW_state);
7527         NTSTATUS status;
7528
7529         if (tevent_req_is_nterror(req, &status)) {
7530                 tevent_req_received(req);
7531                 return status;
7532         }
7533
7534         /* Steal possbile out parameters to the callers context */
7535         talloc_steal(mem_ctx, state->out_mem_ctx);
7536
7537         /* Return result */
7538         *result = state->orig.out.result;
7539
7540         tevent_req_received(req);
7541         return NT_STATUS_OK;
7542 }
7543
7544 NTSTATUS rpccli_EnumServicesStatusExW(struct rpc_pipe_client *cli,
7545                                       TALLOC_CTX *mem_ctx,
7546                                       struct policy_handle *scmanager /* [in] [ref] */,
7547                                       uint32_t info_level /* [in]  */,
7548                                       uint32_t type /* [in]  */,
7549                                       enum svcctl_ServiceState state /* [in]  */,
7550                                       uint8_t *services /* [out] [ref,size_is(offered)] */,
7551                                       uint32_t offered /* [in] [range(0,0x40000)] */,
7552                                       uint32_t *needed /* [out] [ref,range(0,0x40000)] */,
7553                                       uint32_t *service_returned /* [out] [ref,range(0,0x40000)] */,
7554                                       uint32_t *resume_handle /* [in,out] [unique,range(0,0x40000)] */,
7555                                       const char *group_name /* [in] [unique,charset(UTF16)] */,
7556                                       WERROR *werror)
7557 {
7558         struct EnumServicesStatusExW r;
7559         NTSTATUS status;
7560
7561         /* In parameters */
7562         r.in.scmanager = scmanager;
7563         r.in.info_level = info_level;
7564         r.in.type = type;
7565         r.in.state = state;
7566         r.in.offered = offered;
7567         r.in.resume_handle = resume_handle;
7568         r.in.group_name = group_name;
7569
7570         if (DEBUGLEVEL >= 10) {
7571                 NDR_PRINT_IN_DEBUG(EnumServicesStatusExW, &r);
7572         }
7573
7574         status = cli->dispatch(cli,
7575                                 mem_ctx,
7576                                 &ndr_table_svcctl,
7577                                 NDR_ENUMSERVICESSTATUSEXW,
7578                                 &r);
7579
7580         if (!NT_STATUS_IS_OK(status)) {
7581                 return status;
7582         }
7583
7584         if (DEBUGLEVEL >= 10) {
7585                 NDR_PRINT_OUT_DEBUG(EnumServicesStatusExW, &r);
7586         }
7587
7588         if (NT_STATUS_IS_ERR(status)) {
7589                 return status;
7590         }
7591
7592         /* Return variables */
7593         memcpy(services, r.out.services, r.in.offered * sizeof(*services));
7594         *needed = *r.out.needed;
7595         *service_returned = *r.out.service_returned;
7596         if (resume_handle && r.out.resume_handle) {
7597                 *resume_handle = *r.out.resume_handle;
7598         }
7599
7600         /* Return result */
7601         if (werror) {
7602                 *werror = r.out.result;
7603         }
7604
7605         return werror_to_ntstatus(r.out.result);
7606 }
7607
7608 struct rpccli_svcctl_SCSendTSMessage_state {
7609         struct svcctl_SCSendTSMessage orig;
7610         struct svcctl_SCSendTSMessage tmp;
7611         TALLOC_CTX *out_mem_ctx;
7612         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7613 };
7614
7615 static void rpccli_svcctl_SCSendTSMessage_done(struct tevent_req *subreq);
7616
7617 struct tevent_req *rpccli_svcctl_SCSendTSMessage_send(TALLOC_CTX *mem_ctx,
7618                                                       struct tevent_context *ev,
7619                                                       struct rpc_pipe_client *cli)
7620 {
7621         struct tevent_req *req;
7622         struct rpccli_svcctl_SCSendTSMessage_state *state;
7623         struct tevent_req *subreq;
7624
7625         req = tevent_req_create(mem_ctx, &state,
7626                                 struct rpccli_svcctl_SCSendTSMessage_state);
7627         if (req == NULL) {
7628                 return NULL;
7629         }
7630         state->out_mem_ctx = NULL;
7631         state->dispatch_recv = cli->dispatch_recv;
7632
7633         /* In parameters */
7634
7635         /* Out parameters */
7636
7637         /* Result */
7638         ZERO_STRUCT(state->orig.out.result);
7639
7640         if (DEBUGLEVEL >= 10) {
7641                 NDR_PRINT_IN_DEBUG(svcctl_SCSendTSMessage, &state->orig);
7642         }
7643
7644         /* make a temporary copy, that we pass to the dispatch function */
7645         state->tmp = state->orig;
7646
7647         subreq = cli->dispatch_send(state, ev, cli,
7648                                     &ndr_table_svcctl,
7649                                     NDR_SVCCTL_SCSENDTSMESSAGE,
7650                                     &state->tmp);
7651         if (tevent_req_nomem(subreq, req)) {
7652                 return tevent_req_post(req, ev);
7653         }
7654         tevent_req_set_callback(subreq, rpccli_svcctl_SCSendTSMessage_done, req);
7655         return req;
7656 }
7657
7658 static void rpccli_svcctl_SCSendTSMessage_done(struct tevent_req *subreq)
7659 {
7660         struct tevent_req *req = tevent_req_callback_data(
7661                 subreq, struct tevent_req);
7662         struct rpccli_svcctl_SCSendTSMessage_state *state = tevent_req_data(
7663                 req, struct rpccli_svcctl_SCSendTSMessage_state);
7664         NTSTATUS status;
7665         TALLOC_CTX *mem_ctx;
7666
7667         if (state->out_mem_ctx) {
7668                 mem_ctx = state->out_mem_ctx;
7669         } else {
7670                 mem_ctx = state;
7671         }
7672
7673         status = state->dispatch_recv(subreq, mem_ctx);
7674         TALLOC_FREE(subreq);
7675         if (!NT_STATUS_IS_OK(status)) {
7676                 tevent_req_nterror(req, status);
7677                 return;
7678         }
7679
7680         /* Copy out parameters */
7681
7682         /* Copy result */
7683         state->orig.out.result = state->tmp.out.result;
7684
7685         /* Reset temporary structure */
7686         ZERO_STRUCT(state->tmp);
7687
7688         if (DEBUGLEVEL >= 10) {
7689                 NDR_PRINT_OUT_DEBUG(svcctl_SCSendTSMessage, &state->orig);
7690         }
7691
7692         tevent_req_done(req);
7693 }
7694
7695 NTSTATUS rpccli_svcctl_SCSendTSMessage_recv(struct tevent_req *req,
7696                                             TALLOC_CTX *mem_ctx,
7697                                             WERROR *result)
7698 {
7699         struct rpccli_svcctl_SCSendTSMessage_state *state = tevent_req_data(
7700                 req, struct rpccli_svcctl_SCSendTSMessage_state);
7701         NTSTATUS status;
7702
7703         if (tevent_req_is_nterror(req, &status)) {
7704                 tevent_req_received(req);
7705                 return status;
7706         }
7707
7708         /* Steal possbile out parameters to the callers context */
7709         talloc_steal(mem_ctx, state->out_mem_ctx);
7710
7711         /* Return result */
7712         *result = state->orig.out.result;
7713
7714         tevent_req_received(req);
7715         return NT_STATUS_OK;
7716 }
7717
7718 NTSTATUS rpccli_svcctl_SCSendTSMessage(struct rpc_pipe_client *cli,
7719                                        TALLOC_CTX *mem_ctx,
7720                                        WERROR *werror)
7721 {
7722         struct svcctl_SCSendTSMessage r;
7723         NTSTATUS status;
7724
7725         /* In parameters */
7726
7727         if (DEBUGLEVEL >= 10) {
7728                 NDR_PRINT_IN_DEBUG(svcctl_SCSendTSMessage, &r);
7729         }
7730
7731         status = cli->dispatch(cli,
7732                                 mem_ctx,
7733                                 &ndr_table_svcctl,
7734                                 NDR_SVCCTL_SCSENDTSMESSAGE,
7735                                 &r);
7736
7737         if (!NT_STATUS_IS_OK(status)) {
7738                 return status;
7739         }
7740
7741         if (DEBUGLEVEL >= 10) {
7742                 NDR_PRINT_OUT_DEBUG(svcctl_SCSendTSMessage, &r);
7743         }
7744
7745         if (NT_STATUS_IS_ERR(status)) {
7746                 return status;
7747         }
7748
7749         /* Return variables */
7750
7751         /* Return result */
7752         if (werror) {
7753                 *werror = r.out.result;
7754         }
7755
7756         return werror_to_ntstatus(r.out.result);
7757 }
7758