root/librpc/gen_ndr/cli_svcctl.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. rpccli_svcctl_CloseServiceHandle
  2. rpccli_svcctl_ControlService
  3. rpccli_svcctl_DeleteService
  4. rpccli_svcctl_LockServiceDatabase
  5. rpccli_svcctl_QueryServiceObjectSecurity
  6. rpccli_svcctl_SetServiceObjectSecurity
  7. rpccli_svcctl_QueryServiceStatus
  8. rpccli_svcctl_SetServiceStatus
  9. rpccli_svcctl_UnlockServiceDatabase
  10. rpccli_svcctl_NotifyBootConfigStatus
  11. rpccli_svcctl_SCSetServiceBitsW
  12. rpccli_svcctl_ChangeServiceConfigW
  13. rpccli_svcctl_CreateServiceW
  14. rpccli_svcctl_EnumDependentServicesW
  15. rpccli_svcctl_EnumServicesStatusW
  16. rpccli_svcctl_OpenSCManagerW
  17. rpccli_svcctl_OpenServiceW
  18. rpccli_svcctl_QueryServiceConfigW
  19. rpccli_svcctl_QueryServiceLockStatusW
  20. rpccli_svcctl_StartServiceW
  21. rpccli_svcctl_GetServiceDisplayNameW
  22. rpccli_svcctl_GetServiceKeyNameW
  23. rpccli_svcctl_SCSetServiceBitsA
  24. rpccli_svcctl_ChangeServiceConfigA
  25. rpccli_svcctl_CreateServiceA
  26. rpccli_svcctl_EnumDependentServicesA
  27. rpccli_svcctl_EnumServicesStatusA
  28. rpccli_svcctl_OpenSCManagerA
  29. rpccli_svcctl_OpenServiceA
  30. rpccli_svcctl_QueryServiceConfigA
  31. rpccli_svcctl_QueryServiceLockStatusA
  32. rpccli_svcctl_StartServiceA
  33. rpccli_svcctl_GetServiceDisplayNameA
  34. rpccli_svcctl_GetServiceKeyNameA
  35. rpccli_svcctl_GetCurrentGroupeStateW
  36. rpccli_svcctl_EnumServiceGroupW
  37. rpccli_svcctl_ChangeServiceConfig2A
  38. rpccli_svcctl_ChangeServiceConfig2W
  39. rpccli_svcctl_QueryServiceConfig2A
  40. rpccli_svcctl_QueryServiceConfig2W
  41. rpccli_svcctl_QueryServiceStatusEx
  42. rpccli_EnumServicesStatusExA
  43. rpccli_EnumServicesStatusExW
  44. rpccli_svcctl_SCSendTSMessage

   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 NTSTATUS rpccli_svcctl_CloseServiceHandle(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
  10                                           TALLOC_CTX *mem_ctx,
  11                                           struct policy_handle *handle /* [in,out] [ref] */,
  12                                           WERROR *werror)
  13 {
  14         struct svcctl_CloseServiceHandle r;
  15         NTSTATUS status;
  16 
  17         /* In parameters */
  18         r.in.handle = handle;
  19 
  20         if (DEBUGLEVEL >= 10) {
  21                 NDR_PRINT_IN_DEBUG(svcctl_CloseServiceHandle, &r);
  22         }
  23 
  24         status = cli->dispatch(cli,
  25                                 mem_ctx,
  26                                 &ndr_table_svcctl,
  27                                 NDR_SVCCTL_CLOSESERVICEHANDLE,
  28                                 &r);
  29 
  30         if (!NT_STATUS_IS_OK(status)) {
  31                 return status;
  32         }
  33 
  34         if (DEBUGLEVEL >= 10) {
  35                 NDR_PRINT_OUT_DEBUG(svcctl_CloseServiceHandle, &r);
  36         }
  37 
  38         if (NT_STATUS_IS_ERR(status)) {
  39                 return status;
  40         }
  41 
  42         /* Return variables */
  43         *handle = *r.out.handle;
  44 
  45         /* Return result */
  46         if (werror) {
  47                 *werror = r.out.result;
  48         }
  49 
  50         return werror_to_ntstatus(r.out.result);
  51 }
  52 
  53 NTSTATUS rpccli_svcctl_ControlService(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
  54                                       TALLOC_CTX *mem_ctx,
  55                                       struct policy_handle *handle /* [in] [ref] */,
  56                                       enum SERVICE_CONTROL control /* [in]  */,
  57                                       struct SERVICE_STATUS *service_status /* [out] [ref] */,
  58                                       WERROR *werror)
  59 {
  60         struct svcctl_ControlService r;
  61         NTSTATUS status;
  62 
  63         /* In parameters */
  64         r.in.handle = handle;
  65         r.in.control = control;
  66 
  67         if (DEBUGLEVEL >= 10) {
  68                 NDR_PRINT_IN_DEBUG(svcctl_ControlService, &r);
  69         }
  70 
  71         status = cli->dispatch(cli,
  72                                 mem_ctx,
  73                                 &ndr_table_svcctl,
  74                                 NDR_SVCCTL_CONTROLSERVICE,
  75                                 &r);
  76 
  77         if (!NT_STATUS_IS_OK(status)) {
  78                 return status;
  79         }
  80 
  81         if (DEBUGLEVEL >= 10) {
  82                 NDR_PRINT_OUT_DEBUG(svcctl_ControlService, &r);
  83         }
  84 
  85         if (NT_STATUS_IS_ERR(status)) {
  86                 return status;
  87         }
  88 
  89         /* Return variables */
  90         *service_status = *r.out.service_status;
  91 
  92         /* Return result */
  93         if (werror) {
  94                 *werror = r.out.result;
  95         }
  96 
  97         return werror_to_ntstatus(r.out.result);
  98 }
  99 
 100 NTSTATUS rpccli_svcctl_DeleteService(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 101                                      TALLOC_CTX *mem_ctx,
 102                                      struct policy_handle *handle /* [in] [ref] */,
 103                                      WERROR *werror)
 104 {
 105         struct svcctl_DeleteService r;
 106         NTSTATUS status;
 107 
 108         /* In parameters */
 109         r.in.handle = handle;
 110 
 111         if (DEBUGLEVEL >= 10) {
 112                 NDR_PRINT_IN_DEBUG(svcctl_DeleteService, &r);
 113         }
 114 
 115         status = cli->dispatch(cli,
 116                                 mem_ctx,
 117                                 &ndr_table_svcctl,
 118                                 NDR_SVCCTL_DELETESERVICE,
 119                                 &r);
 120 
 121         if (!NT_STATUS_IS_OK(status)) {
 122                 return status;
 123         }
 124 
 125         if (DEBUGLEVEL >= 10) {
 126                 NDR_PRINT_OUT_DEBUG(svcctl_DeleteService, &r);
 127         }
 128 
 129         if (NT_STATUS_IS_ERR(status)) {
 130                 return status;
 131         }
 132 
 133         /* Return variables */
 134 
 135         /* Return result */
 136         if (werror) {
 137                 *werror = r.out.result;
 138         }
 139 
 140         return werror_to_ntstatus(r.out.result);
 141 }
 142 
 143 NTSTATUS rpccli_svcctl_LockServiceDatabase(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 144                                            TALLOC_CTX *mem_ctx,
 145                                            struct policy_handle *handle /* [in] [ref] */,
 146                                            struct policy_handle *lock /* [out] [ref] */,
 147                                            WERROR *werror)
 148 {
 149         struct svcctl_LockServiceDatabase r;
 150         NTSTATUS status;
 151 
 152         /* In parameters */
 153         r.in.handle = handle;
 154 
 155         if (DEBUGLEVEL >= 10) {
 156                 NDR_PRINT_IN_DEBUG(svcctl_LockServiceDatabase, &r);
 157         }
 158 
 159         status = cli->dispatch(cli,
 160                                 mem_ctx,
 161                                 &ndr_table_svcctl,
 162                                 NDR_SVCCTL_LOCKSERVICEDATABASE,
 163                                 &r);
 164 
 165         if (!NT_STATUS_IS_OK(status)) {
 166                 return status;
 167         }
 168 
 169         if (DEBUGLEVEL >= 10) {
 170                 NDR_PRINT_OUT_DEBUG(svcctl_LockServiceDatabase, &r);
 171         }
 172 
 173         if (NT_STATUS_IS_ERR(status)) {
 174                 return status;
 175         }
 176 
 177         /* Return variables */
 178         *lock = *r.out.lock;
 179 
 180         /* Return result */
 181         if (werror) {
 182                 *werror = r.out.result;
 183         }
 184 
 185         return werror_to_ntstatus(r.out.result);
 186 }
 187 
 188 NTSTATUS rpccli_svcctl_QueryServiceObjectSecurity(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 189                                                   TALLOC_CTX *mem_ctx,
 190                                                   struct policy_handle *handle /* [in] [ref] */,
 191                                                   uint32_t security_flags /* [in]  */,
 192                                                   uint8_t *buffer /* [out] [ref,size_is(offered)] */,
 193                                                   uint32_t offered /* [in] [range(0,0x40000)] */,
 194                                                   uint32_t *needed /* [out] [ref,range(0,0x40000)] */,
 195                                                   WERROR *werror)
 196 {
 197         struct svcctl_QueryServiceObjectSecurity r;
 198         NTSTATUS status;
 199 
 200         /* In parameters */
 201         r.in.handle = handle;
 202         r.in.security_flags = security_flags;
 203         r.in.offered = offered;
 204 
 205         if (DEBUGLEVEL >= 10) {
 206                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceObjectSecurity, &r);
 207         }
 208 
 209         status = cli->dispatch(cli,
 210                                 mem_ctx,
 211                                 &ndr_table_svcctl,
 212                                 NDR_SVCCTL_QUERYSERVICEOBJECTSECURITY,
 213                                 &r);
 214 
 215         if (!NT_STATUS_IS_OK(status)) {
 216                 return status;
 217         }
 218 
 219         if (DEBUGLEVEL >= 10) {
 220                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceObjectSecurity, &r);
 221         }
 222 
 223         if (NT_STATUS_IS_ERR(status)) {
 224                 return status;
 225         }
 226 
 227         /* Return variables */
 228         memcpy(buffer, r.out.buffer, r.in.offered * sizeof(*buffer));
 229         *needed = *r.out.needed;
 230 
 231         /* Return result */
 232         if (werror) {
 233                 *werror = r.out.result;
 234         }
 235 
 236         return werror_to_ntstatus(r.out.result);
 237 }
 238 
 239 NTSTATUS rpccli_svcctl_SetServiceObjectSecurity(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 240                                                 TALLOC_CTX *mem_ctx,
 241                                                 struct policy_handle *handle /* [in] [ref] */,
 242                                                 uint32_t security_flags /* [in]  */,
 243                                                 uint8_t *buffer /* [in] [ref,size_is(offered)] */,
 244                                                 uint32_t offered /* [in]  */,
 245                                                 WERROR *werror)
 246 {
 247         struct svcctl_SetServiceObjectSecurity r;
 248         NTSTATUS status;
 249 
 250         /* In parameters */
 251         r.in.handle = handle;
 252         r.in.security_flags = security_flags;
 253         r.in.buffer = buffer;
 254         r.in.offered = offered;
 255 
 256         if (DEBUGLEVEL >= 10) {
 257                 NDR_PRINT_IN_DEBUG(svcctl_SetServiceObjectSecurity, &r);
 258         }
 259 
 260         status = cli->dispatch(cli,
 261                                 mem_ctx,
 262                                 &ndr_table_svcctl,
 263                                 NDR_SVCCTL_SETSERVICEOBJECTSECURITY,
 264                                 &r);
 265 
 266         if (!NT_STATUS_IS_OK(status)) {
 267                 return status;
 268         }
 269 
 270         if (DEBUGLEVEL >= 10) {
 271                 NDR_PRINT_OUT_DEBUG(svcctl_SetServiceObjectSecurity, &r);
 272         }
 273 
 274         if (NT_STATUS_IS_ERR(status)) {
 275                 return status;
 276         }
 277 
 278         /* Return variables */
 279 
 280         /* Return result */
 281         if (werror) {
 282                 *werror = r.out.result;
 283         }
 284 
 285         return werror_to_ntstatus(r.out.result);
 286 }
 287 
 288 NTSTATUS rpccli_svcctl_QueryServiceStatus(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 289                                           TALLOC_CTX *mem_ctx,
 290                                           struct policy_handle *handle /* [in] [ref] */,
 291                                           struct SERVICE_STATUS *service_status /* [out] [ref] */,
 292                                           WERROR *werror)
 293 {
 294         struct svcctl_QueryServiceStatus r;
 295         NTSTATUS status;
 296 
 297         /* In parameters */
 298         r.in.handle = handle;
 299 
 300         if (DEBUGLEVEL >= 10) {
 301                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceStatus, &r);
 302         }
 303 
 304         status = cli->dispatch(cli,
 305                                 mem_ctx,
 306                                 &ndr_table_svcctl,
 307                                 NDR_SVCCTL_QUERYSERVICESTATUS,
 308                                 &r);
 309 
 310         if (!NT_STATUS_IS_OK(status)) {
 311                 return status;
 312         }
 313 
 314         if (DEBUGLEVEL >= 10) {
 315                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceStatus, &r);
 316         }
 317 
 318         if (NT_STATUS_IS_ERR(status)) {
 319                 return status;
 320         }
 321 
 322         /* Return variables */
 323         *service_status = *r.out.service_status;
 324 
 325         /* Return result */
 326         if (werror) {
 327                 *werror = r.out.result;
 328         }
 329 
 330         return werror_to_ntstatus(r.out.result);
 331 }
 332 
 333 NTSTATUS rpccli_svcctl_SetServiceStatus(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 334                                         TALLOC_CTX *mem_ctx,
 335                                         WERROR *werror)
 336 {
 337         struct svcctl_SetServiceStatus r;
 338         NTSTATUS status;
 339 
 340         /* In parameters */
 341 
 342         if (DEBUGLEVEL >= 10) {
 343                 NDR_PRINT_IN_DEBUG(svcctl_SetServiceStatus, &r);
 344         }
 345 
 346         status = cli->dispatch(cli,
 347                                 mem_ctx,
 348                                 &ndr_table_svcctl,
 349                                 NDR_SVCCTL_SETSERVICESTATUS,
 350                                 &r);
 351 
 352         if (!NT_STATUS_IS_OK(status)) {
 353                 return status;
 354         }
 355 
 356         if (DEBUGLEVEL >= 10) {
 357                 NDR_PRINT_OUT_DEBUG(svcctl_SetServiceStatus, &r);
 358         }
 359 
 360         if (NT_STATUS_IS_ERR(status)) {
 361                 return status;
 362         }
 363 
 364         /* Return variables */
 365 
 366         /* Return result */
 367         if (werror) {
 368                 *werror = r.out.result;
 369         }
 370 
 371         return werror_to_ntstatus(r.out.result);
 372 }
 373 
 374 NTSTATUS rpccli_svcctl_UnlockServiceDatabase(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 375                                              TALLOC_CTX *mem_ctx,
 376                                              struct policy_handle *lock /* [in,out] [ref] */,
 377                                              WERROR *werror)
 378 {
 379         struct svcctl_UnlockServiceDatabase r;
 380         NTSTATUS status;
 381 
 382         /* In parameters */
 383         r.in.lock = lock;
 384 
 385         if (DEBUGLEVEL >= 10) {
 386                 NDR_PRINT_IN_DEBUG(svcctl_UnlockServiceDatabase, &r);
 387         }
 388 
 389         status = cli->dispatch(cli,
 390                                 mem_ctx,
 391                                 &ndr_table_svcctl,
 392                                 NDR_SVCCTL_UNLOCKSERVICEDATABASE,
 393                                 &r);
 394 
 395         if (!NT_STATUS_IS_OK(status)) {
 396                 return status;
 397         }
 398 
 399         if (DEBUGLEVEL >= 10) {
 400                 NDR_PRINT_OUT_DEBUG(svcctl_UnlockServiceDatabase, &r);
 401         }
 402 
 403         if (NT_STATUS_IS_ERR(status)) {
 404                 return status;
 405         }
 406 
 407         /* Return variables */
 408         *lock = *r.out.lock;
 409 
 410         /* Return result */
 411         if (werror) {
 412                 *werror = r.out.result;
 413         }
 414 
 415         return werror_to_ntstatus(r.out.result);
 416 }
 417 
 418 NTSTATUS rpccli_svcctl_NotifyBootConfigStatus(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 419                                               TALLOC_CTX *mem_ctx,
 420                                               WERROR *werror)
 421 {
 422         struct svcctl_NotifyBootConfigStatus r;
 423         NTSTATUS status;
 424 
 425         /* In parameters */
 426 
 427         if (DEBUGLEVEL >= 10) {
 428                 NDR_PRINT_IN_DEBUG(svcctl_NotifyBootConfigStatus, &r);
 429         }
 430 
 431         status = cli->dispatch(cli,
 432                                 mem_ctx,
 433                                 &ndr_table_svcctl,
 434                                 NDR_SVCCTL_NOTIFYBOOTCONFIGSTATUS,
 435                                 &r);
 436 
 437         if (!NT_STATUS_IS_OK(status)) {
 438                 return status;
 439         }
 440 
 441         if (DEBUGLEVEL >= 10) {
 442                 NDR_PRINT_OUT_DEBUG(svcctl_NotifyBootConfigStatus, &r);
 443         }
 444 
 445         if (NT_STATUS_IS_ERR(status)) {
 446                 return status;
 447         }
 448 
 449         /* Return variables */
 450 
 451         /* Return result */
 452         if (werror) {
 453                 *werror = r.out.result;
 454         }
 455 
 456         return werror_to_ntstatus(r.out.result);
 457 }
 458 
 459 NTSTATUS rpccli_svcctl_SCSetServiceBitsW(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 460                                          TALLOC_CTX *mem_ctx,
 461                                          struct policy_handle *handle /* [in] [ref] */,
 462                                          uint32_t bits /* [in]  */,
 463                                          uint32_t bitson /* [in]  */,
 464                                          uint32_t immediate /* [in]  */,
 465                                          WERROR *werror)
 466 {
 467         struct svcctl_SCSetServiceBitsW r;
 468         NTSTATUS status;
 469 
 470         /* In parameters */
 471         r.in.handle = handle;
 472         r.in.bits = bits;
 473         r.in.bitson = bitson;
 474         r.in.immediate = immediate;
 475 
 476         if (DEBUGLEVEL >= 10) {
 477                 NDR_PRINT_IN_DEBUG(svcctl_SCSetServiceBitsW, &r);
 478         }
 479 
 480         status = cli->dispatch(cli,
 481                                 mem_ctx,
 482                                 &ndr_table_svcctl,
 483                                 NDR_SVCCTL_SCSETSERVICEBITSW,
 484                                 &r);
 485 
 486         if (!NT_STATUS_IS_OK(status)) {
 487                 return status;
 488         }
 489 
 490         if (DEBUGLEVEL >= 10) {
 491                 NDR_PRINT_OUT_DEBUG(svcctl_SCSetServiceBitsW, &r);
 492         }
 493 
 494         if (NT_STATUS_IS_ERR(status)) {
 495                 return status;
 496         }
 497 
 498         /* Return variables */
 499 
 500         /* Return result */
 501         if (werror) {
 502                 *werror = r.out.result;
 503         }
 504 
 505         return werror_to_ntstatus(r.out.result);
 506 }
 507 
 508 NTSTATUS rpccli_svcctl_ChangeServiceConfigW(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 509                                             TALLOC_CTX *mem_ctx,
 510                                             struct policy_handle *handle /* [in] [ref] */,
 511                                             uint32_t type /* [in]  */,
 512                                             enum svcctl_StartType start_type /* [in]  */,
 513                                             enum svcctl_ErrorControl error_control /* [in]  */,
 514                                             const char *binary_path /* [in] [unique,charset(UTF16)] */,
 515                                             const char *load_order_group /* [in] [unique,charset(UTF16)] */,
 516                                             uint32_t *tag_id /* [out] [ref] */,
 517                                             const char *dependencies /* [in] [unique,charset(UTF16)] */,
 518                                             const char *service_start_name /* [in] [unique,charset(UTF16)] */,
 519                                             const char *password /* [in] [unique,charset(UTF16)] */,
 520                                             const char *display_name /* [in] [unique,charset(UTF16)] */,
 521                                             WERROR *werror)
 522 {
 523         struct svcctl_ChangeServiceConfigW r;
 524         NTSTATUS status;
 525 
 526         /* In parameters */
 527         r.in.handle = handle;
 528         r.in.type = type;
 529         r.in.start_type = start_type;
 530         r.in.error_control = error_control;
 531         r.in.binary_path = binary_path;
 532         r.in.load_order_group = load_order_group;
 533         r.in.dependencies = dependencies;
 534         r.in.service_start_name = service_start_name;
 535         r.in.password = password;
 536         r.in.display_name = display_name;
 537 
 538         if (DEBUGLEVEL >= 10) {
 539                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfigW, &r);
 540         }
 541 
 542         status = cli->dispatch(cli,
 543                                 mem_ctx,
 544                                 &ndr_table_svcctl,
 545                                 NDR_SVCCTL_CHANGESERVICECONFIGW,
 546                                 &r);
 547 
 548         if (!NT_STATUS_IS_OK(status)) {
 549                 return status;
 550         }
 551 
 552         if (DEBUGLEVEL >= 10) {
 553                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfigW, &r);
 554         }
 555 
 556         if (NT_STATUS_IS_ERR(status)) {
 557                 return status;
 558         }
 559 
 560         /* Return variables */
 561         *tag_id = *r.out.tag_id;
 562 
 563         /* Return result */
 564         if (werror) {
 565                 *werror = r.out.result;
 566         }
 567 
 568         return werror_to_ntstatus(r.out.result);
 569 }
 570 
 571 NTSTATUS rpccli_svcctl_CreateServiceW(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 572                                       TALLOC_CTX *mem_ctx,
 573                                       struct policy_handle *scmanager_handle /* [in] [ref] */,
 574                                       const char *ServiceName /* [in] [charset(UTF16)] */,
 575                                       const char *DisplayName /* [in] [unique,charset(UTF16)] */,
 576                                       uint32_t desired_access /* [in]  */,
 577                                       uint32_t type /* [in]  */,
 578                                       enum svcctl_StartType start_type /* [in]  */,
 579                                       enum svcctl_ErrorControl error_control /* [in]  */,
 580                                       const char *binary_path /* [in] [charset(UTF16)] */,
 581                                       const char *LoadOrderGroupKey /* [in] [unique,charset(UTF16)] */,
 582                                       uint32_t *TagId /* [in,out] [unique] */,
 583                                       uint8_t *dependencies /* [in] [unique,size_is(dependencies_size)] */,
 584                                       uint32_t dependencies_size /* [in]  */,
 585                                       const char *service_start_name /* [in] [unique,charset(UTF16)] */,
 586                                       uint8_t *password /* [in] [unique,size_is(password_size)] */,
 587                                       uint32_t password_size /* [in]  */,
 588                                       struct policy_handle *handle /* [out] [ref] */,
 589                                       WERROR *werror)
 590 {
 591         struct svcctl_CreateServiceW r;
 592         NTSTATUS status;
 593 
 594         /* In parameters */
 595         r.in.scmanager_handle = scmanager_handle;
 596         r.in.ServiceName = ServiceName;
 597         r.in.DisplayName = DisplayName;
 598         r.in.desired_access = desired_access;
 599         r.in.type = type;
 600         r.in.start_type = start_type;
 601         r.in.error_control = error_control;
 602         r.in.binary_path = binary_path;
 603         r.in.LoadOrderGroupKey = LoadOrderGroupKey;
 604         r.in.TagId = TagId;
 605         r.in.dependencies = dependencies;
 606         r.in.dependencies_size = dependencies_size;
 607         r.in.service_start_name = service_start_name;
 608         r.in.password = password;
 609         r.in.password_size = password_size;
 610 
 611         if (DEBUGLEVEL >= 10) {
 612                 NDR_PRINT_IN_DEBUG(svcctl_CreateServiceW, &r);
 613         }
 614 
 615         status = cli->dispatch(cli,
 616                                 mem_ctx,
 617                                 &ndr_table_svcctl,
 618                                 NDR_SVCCTL_CREATESERVICEW,
 619                                 &r);
 620 
 621         if (!NT_STATUS_IS_OK(status)) {
 622                 return status;
 623         }
 624 
 625         if (DEBUGLEVEL >= 10) {
 626                 NDR_PRINT_OUT_DEBUG(svcctl_CreateServiceW, &r);
 627         }
 628 
 629         if (NT_STATUS_IS_ERR(status)) {
 630                 return status;
 631         }
 632 
 633         /* Return variables */
 634         if (TagId && r.out.TagId) {
 635                 *TagId = *r.out.TagId;
 636         }
 637         *handle = *r.out.handle;
 638 
 639         /* Return result */
 640         if (werror) {
 641                 *werror = r.out.result;
 642         }
 643 
 644         return werror_to_ntstatus(r.out.result);
 645 }
 646 
 647 NTSTATUS rpccli_svcctl_EnumDependentServicesW(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 648                                               TALLOC_CTX *mem_ctx,
 649                                               struct policy_handle *service /* [in] [ref] */,
 650                                               enum svcctl_ServiceState state /* [in]  */,
 651                                               uint8_t *service_status /* [out] [ref,size_is(offered)] */,
 652                                               uint32_t offered /* [in] [range(0,0x40000)] */,
 653                                               uint32_t *needed /* [out] [ref,range(0,0x40000)] */,
 654                                               uint32_t *services_returned /* [out] [ref,range(0,0x40000)] */,
 655                                               WERROR *werror)
 656 {
 657         struct svcctl_EnumDependentServicesW r;
 658         NTSTATUS status;
 659 
 660         /* In parameters */
 661         r.in.service = service;
 662         r.in.state = state;
 663         r.in.offered = offered;
 664 
 665         if (DEBUGLEVEL >= 10) {
 666                 NDR_PRINT_IN_DEBUG(svcctl_EnumDependentServicesW, &r);
 667         }
 668 
 669         status = cli->dispatch(cli,
 670                                 mem_ctx,
 671                                 &ndr_table_svcctl,
 672                                 NDR_SVCCTL_ENUMDEPENDENTSERVICESW,
 673                                 &r);
 674 
 675         if (!NT_STATUS_IS_OK(status)) {
 676                 return status;
 677         }
 678 
 679         if (DEBUGLEVEL >= 10) {
 680                 NDR_PRINT_OUT_DEBUG(svcctl_EnumDependentServicesW, &r);
 681         }
 682 
 683         if (NT_STATUS_IS_ERR(status)) {
 684                 return status;
 685         }
 686 
 687         /* Return variables */
 688         memcpy(service_status, r.out.service_status, r.in.offered * sizeof(*service_status));
 689         *needed = *r.out.needed;
 690         *services_returned = *r.out.services_returned;
 691 
 692         /* Return result */
 693         if (werror) {
 694                 *werror = r.out.result;
 695         }
 696 
 697         return werror_to_ntstatus(r.out.result);
 698 }
 699 
 700 NTSTATUS rpccli_svcctl_EnumServicesStatusW(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 701                                            TALLOC_CTX *mem_ctx,
 702                                            struct policy_handle *handle /* [in] [ref] */,
 703                                            uint32_t type /* [in]  */,
 704                                            enum svcctl_ServiceState state /* [in]  */,
 705                                            uint8_t *service /* [out] [ref,size_is(offered)] */,
 706                                            uint32_t offered /* [in] [range(0,0x40000)] */,
 707                                            uint32_t *needed /* [out] [ref,range(0,0x40000)] */,
 708                                            uint32_t *services_returned /* [out] [ref,range(0,0x40000)] */,
 709                                            uint32_t *resume_handle /* [in,out] [unique] */,
 710                                            WERROR *werror)
 711 {
 712         struct svcctl_EnumServicesStatusW r;
 713         NTSTATUS status;
 714 
 715         /* In parameters */
 716         r.in.handle = handle;
 717         r.in.type = type;
 718         r.in.state = state;
 719         r.in.offered = offered;
 720         r.in.resume_handle = resume_handle;
 721 
 722         if (DEBUGLEVEL >= 10) {
 723                 NDR_PRINT_IN_DEBUG(svcctl_EnumServicesStatusW, &r);
 724         }
 725 
 726         status = cli->dispatch(cli,
 727                                 mem_ctx,
 728                                 &ndr_table_svcctl,
 729                                 NDR_SVCCTL_ENUMSERVICESSTATUSW,
 730                                 &r);
 731 
 732         if (!NT_STATUS_IS_OK(status)) {
 733                 return status;
 734         }
 735 
 736         if (DEBUGLEVEL >= 10) {
 737                 NDR_PRINT_OUT_DEBUG(svcctl_EnumServicesStatusW, &r);
 738         }
 739 
 740         if (NT_STATUS_IS_ERR(status)) {
 741                 return status;
 742         }
 743 
 744         /* Return variables */
 745         memcpy(service, r.out.service, r.in.offered * sizeof(*service));
 746         *needed = *r.out.needed;
 747         *services_returned = *r.out.services_returned;
 748         if (resume_handle && r.out.resume_handle) {
 749                 *resume_handle = *r.out.resume_handle;
 750         }
 751 
 752         /* Return result */
 753         if (werror) {
 754                 *werror = r.out.result;
 755         }
 756 
 757         return werror_to_ntstatus(r.out.result);
 758 }
 759 
 760 NTSTATUS rpccli_svcctl_OpenSCManagerW(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 761                                       TALLOC_CTX *mem_ctx,
 762                                       const char *MachineName /* [in] [unique,charset(UTF16)] */,
 763                                       const char *DatabaseName /* [in] [unique,charset(UTF16)] */,
 764                                       uint32_t access_mask /* [in]  */,
 765                                       struct policy_handle *handle /* [out] [ref] */,
 766                                       WERROR *werror)
 767 {
 768         struct svcctl_OpenSCManagerW r;
 769         NTSTATUS status;
 770 
 771         /* In parameters */
 772         r.in.MachineName = MachineName;
 773         r.in.DatabaseName = DatabaseName;
 774         r.in.access_mask = access_mask;
 775 
 776         if (DEBUGLEVEL >= 10) {
 777                 NDR_PRINT_IN_DEBUG(svcctl_OpenSCManagerW, &r);
 778         }
 779 
 780         status = cli->dispatch(cli,
 781                                 mem_ctx,
 782                                 &ndr_table_svcctl,
 783                                 NDR_SVCCTL_OPENSCMANAGERW,
 784                                 &r);
 785 
 786         if (!NT_STATUS_IS_OK(status)) {
 787                 return status;
 788         }
 789 
 790         if (DEBUGLEVEL >= 10) {
 791                 NDR_PRINT_OUT_DEBUG(svcctl_OpenSCManagerW, &r);
 792         }
 793 
 794         if (NT_STATUS_IS_ERR(status)) {
 795                 return status;
 796         }
 797 
 798         /* Return variables */
 799         *handle = *r.out.handle;
 800 
 801         /* Return result */
 802         if (werror) {
 803                 *werror = r.out.result;
 804         }
 805 
 806         return werror_to_ntstatus(r.out.result);
 807 }
 808 
 809 NTSTATUS rpccli_svcctl_OpenServiceW(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 810                                     TALLOC_CTX *mem_ctx,
 811                                     struct policy_handle *scmanager_handle /* [in] [ref] */,
 812                                     const char *ServiceName /* [in] [charset(UTF16)] */,
 813                                     uint32_t access_mask /* [in]  */,
 814                                     struct policy_handle *handle /* [out] [ref] */,
 815                                     WERROR *werror)
 816 {
 817         struct svcctl_OpenServiceW r;
 818         NTSTATUS status;
 819 
 820         /* In parameters */
 821         r.in.scmanager_handle = scmanager_handle;
 822         r.in.ServiceName = ServiceName;
 823         r.in.access_mask = access_mask;
 824 
 825         if (DEBUGLEVEL >= 10) {
 826                 NDR_PRINT_IN_DEBUG(svcctl_OpenServiceW, &r);
 827         }
 828 
 829         status = cli->dispatch(cli,
 830                                 mem_ctx,
 831                                 &ndr_table_svcctl,
 832                                 NDR_SVCCTL_OPENSERVICEW,
 833                                 &r);
 834 
 835         if (!NT_STATUS_IS_OK(status)) {
 836                 return status;
 837         }
 838 
 839         if (DEBUGLEVEL >= 10) {
 840                 NDR_PRINT_OUT_DEBUG(svcctl_OpenServiceW, &r);
 841         }
 842 
 843         if (NT_STATUS_IS_ERR(status)) {
 844                 return status;
 845         }
 846 
 847         /* Return variables */
 848         *handle = *r.out.handle;
 849 
 850         /* Return result */
 851         if (werror) {
 852                 *werror = r.out.result;
 853         }
 854 
 855         return werror_to_ntstatus(r.out.result);
 856 }
 857 
 858 NTSTATUS rpccli_svcctl_QueryServiceConfigW(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 859                                            TALLOC_CTX *mem_ctx,
 860                                            struct policy_handle *handle /* [in] [ref] */,
 861                                            struct QUERY_SERVICE_CONFIG *query /* [out] [ref] */,
 862                                            uint32_t offered /* [in] [range(0,8192)] */,
 863                                            uint32_t *needed /* [out] [ref,range(0,8192)] */,
 864                                            WERROR *werror)
 865 {
 866         struct svcctl_QueryServiceConfigW r;
 867         NTSTATUS status;
 868 
 869         /* In parameters */
 870         r.in.handle = handle;
 871         r.in.offered = offered;
 872 
 873         if (DEBUGLEVEL >= 10) {
 874                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfigW, &r);
 875         }
 876 
 877         status = cli->dispatch(cli,
 878                                 mem_ctx,
 879                                 &ndr_table_svcctl,
 880                                 NDR_SVCCTL_QUERYSERVICECONFIGW,
 881                                 &r);
 882 
 883         if (!NT_STATUS_IS_OK(status)) {
 884                 return status;
 885         }
 886 
 887         if (DEBUGLEVEL >= 10) {
 888                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfigW, &r);
 889         }
 890 
 891         if (NT_STATUS_IS_ERR(status)) {
 892                 return status;
 893         }
 894 
 895         /* Return variables */
 896         *query = *r.out.query;
 897         *needed = *r.out.needed;
 898 
 899         /* Return result */
 900         if (werror) {
 901                 *werror = r.out.result;
 902         }
 903 
 904         return werror_to_ntstatus(r.out.result);
 905 }
 906 
 907 NTSTATUS rpccli_svcctl_QueryServiceLockStatusW(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 908                                                TALLOC_CTX *mem_ctx,
 909                                                struct policy_handle *handle /* [in] [ref] */,
 910                                                uint32_t offered /* [in]  */,
 911                                                struct SERVICE_LOCK_STATUS *lock_status /* [out] [ref] */,
 912                                                uint32_t *needed /* [out] [ref] */,
 913                                                WERROR *werror)
 914 {
 915         struct svcctl_QueryServiceLockStatusW r;
 916         NTSTATUS status;
 917 
 918         /* In parameters */
 919         r.in.handle = handle;
 920         r.in.offered = offered;
 921 
 922         if (DEBUGLEVEL >= 10) {
 923                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceLockStatusW, &r);
 924         }
 925 
 926         status = cli->dispatch(cli,
 927                                 mem_ctx,
 928                                 &ndr_table_svcctl,
 929                                 NDR_SVCCTL_QUERYSERVICELOCKSTATUSW,
 930                                 &r);
 931 
 932         if (!NT_STATUS_IS_OK(status)) {
 933                 return status;
 934         }
 935 
 936         if (DEBUGLEVEL >= 10) {
 937                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceLockStatusW, &r);
 938         }
 939 
 940         if (NT_STATUS_IS_ERR(status)) {
 941                 return status;
 942         }
 943 
 944         /* Return variables */
 945         *lock_status = *r.out.lock_status;
 946         *needed = *r.out.needed;
 947 
 948         /* Return result */
 949         if (werror) {
 950                 *werror = r.out.result;
 951         }
 952 
 953         return werror_to_ntstatus(r.out.result);
 954 }
 955 
 956 NTSTATUS rpccli_svcctl_StartServiceW(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
 957                                      TALLOC_CTX *mem_ctx,
 958                                      struct policy_handle *handle /* [in] [ref] */,
 959                                      uint32_t NumArgs /* [in] [range(0,SC_MAX_ARGUMENTS)] */,
 960                                      struct svcctl_ArgumentString *Arguments /* [in] [unique,size_is(NumArgs)] */,
 961                                      WERROR *werror)
 962 {
 963         struct svcctl_StartServiceW r;
 964         NTSTATUS status;
 965 
 966         /* In parameters */
 967         r.in.handle = handle;
 968         r.in.NumArgs = NumArgs;
 969         r.in.Arguments = Arguments;
 970 
 971         if (DEBUGLEVEL >= 10) {
 972                 NDR_PRINT_IN_DEBUG(svcctl_StartServiceW, &r);
 973         }
 974 
 975         status = cli->dispatch(cli,
 976                                 mem_ctx,
 977                                 &ndr_table_svcctl,
 978                                 NDR_SVCCTL_STARTSERVICEW,
 979                                 &r);
 980 
 981         if (!NT_STATUS_IS_OK(status)) {
 982                 return status;
 983         }
 984 
 985         if (DEBUGLEVEL >= 10) {
 986                 NDR_PRINT_OUT_DEBUG(svcctl_StartServiceW, &r);
 987         }
 988 
 989         if (NT_STATUS_IS_ERR(status)) {
 990                 return status;
 991         }
 992 
 993         /* Return variables */
 994 
 995         /* Return result */
 996         if (werror) {
 997                 *werror = r.out.result;
 998         }
 999 
1000         return werror_to_ntstatus(r.out.result);
1001 }
1002 
1003 NTSTATUS rpccli_svcctl_GetServiceDisplayNameW(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1004                                               TALLOC_CTX *mem_ctx,
1005                                               struct policy_handle *handle /* [in] [ref] */,
1006                                               const char *service_name /* [in] [unique,charset(UTF16)] */,
1007                                               const char **display_name /* [out] [ref,charset(UTF16)] */,
1008                                               uint32_t *display_name_length /* [in,out] [unique] */,
1009                                               WERROR *werror)
1010 {
1011         struct svcctl_GetServiceDisplayNameW r;
1012         NTSTATUS status;
1013 
1014         /* In parameters */
1015         r.in.handle = handle;
1016         r.in.service_name = service_name;
1017         r.in.display_name_length = display_name_length;
1018 
1019         if (DEBUGLEVEL >= 10) {
1020                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceDisplayNameW, &r);
1021         }
1022 
1023         status = cli->dispatch(cli,
1024                                 mem_ctx,
1025                                 &ndr_table_svcctl,
1026                                 NDR_SVCCTL_GETSERVICEDISPLAYNAMEW,
1027                                 &r);
1028 
1029         if (!NT_STATUS_IS_OK(status)) {
1030                 return status;
1031         }
1032 
1033         if (DEBUGLEVEL >= 10) {
1034                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceDisplayNameW, &r);
1035         }
1036 
1037         if (NT_STATUS_IS_ERR(status)) {
1038                 return status;
1039         }
1040 
1041         /* Return variables */
1042         *display_name = *r.out.display_name;
1043         if (display_name_length && r.out.display_name_length) {
1044                 *display_name_length = *r.out.display_name_length;
1045         }
1046 
1047         /* Return result */
1048         if (werror) {
1049                 *werror = r.out.result;
1050         }
1051 
1052         return werror_to_ntstatus(r.out.result);
1053 }
1054 
1055 NTSTATUS rpccli_svcctl_GetServiceKeyNameW(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1056                                           TALLOC_CTX *mem_ctx,
1057                                           struct policy_handle *handle /* [in] [ref] */,
1058                                           const char *service_name /* [in] [unique,charset(UTF16)] */,
1059                                           const char **key_name /* [out] [ref,charset(UTF16)] */,
1060                                           uint32_t *display_name_length /* [in,out] [unique] */,
1061                                           WERROR *werror)
1062 {
1063         struct svcctl_GetServiceKeyNameW r;
1064         NTSTATUS status;
1065 
1066         /* In parameters */
1067         r.in.handle = handle;
1068         r.in.service_name = service_name;
1069         r.in.display_name_length = display_name_length;
1070 
1071         if (DEBUGLEVEL >= 10) {
1072                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceKeyNameW, &r);
1073         }
1074 
1075         status = cli->dispatch(cli,
1076                                 mem_ctx,
1077                                 &ndr_table_svcctl,
1078                                 NDR_SVCCTL_GETSERVICEKEYNAMEW,
1079                                 &r);
1080 
1081         if (!NT_STATUS_IS_OK(status)) {
1082                 return status;
1083         }
1084 
1085         if (DEBUGLEVEL >= 10) {
1086                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceKeyNameW, &r);
1087         }
1088 
1089         if (NT_STATUS_IS_ERR(status)) {
1090                 return status;
1091         }
1092 
1093         /* Return variables */
1094         *key_name = *r.out.key_name;
1095         if (display_name_length && r.out.display_name_length) {
1096                 *display_name_length = *r.out.display_name_length;
1097         }
1098 
1099         /* Return result */
1100         if (werror) {
1101                 *werror = r.out.result;
1102         }
1103 
1104         return werror_to_ntstatus(r.out.result);
1105 }
1106 
1107 NTSTATUS rpccli_svcctl_SCSetServiceBitsA(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1108                                          TALLOC_CTX *mem_ctx,
1109                                          struct policy_handle *handle /* [in] [ref] */,
1110                                          uint32_t bits /* [in]  */,
1111                                          uint32_t bitson /* [in]  */,
1112                                          uint32_t immediate /* [in]  */,
1113                                          WERROR *werror)
1114 {
1115         struct svcctl_SCSetServiceBitsA r;
1116         NTSTATUS status;
1117 
1118         /* In parameters */
1119         r.in.handle = handle;
1120         r.in.bits = bits;
1121         r.in.bitson = bitson;
1122         r.in.immediate = immediate;
1123 
1124         if (DEBUGLEVEL >= 10) {
1125                 NDR_PRINT_IN_DEBUG(svcctl_SCSetServiceBitsA, &r);
1126         }
1127 
1128         status = cli->dispatch(cli,
1129                                 mem_ctx,
1130                                 &ndr_table_svcctl,
1131                                 NDR_SVCCTL_SCSETSERVICEBITSA,
1132                                 &r);
1133 
1134         if (!NT_STATUS_IS_OK(status)) {
1135                 return status;
1136         }
1137 
1138         if (DEBUGLEVEL >= 10) {
1139                 NDR_PRINT_OUT_DEBUG(svcctl_SCSetServiceBitsA, &r);
1140         }
1141 
1142         if (NT_STATUS_IS_ERR(status)) {
1143                 return status;
1144         }
1145 
1146         /* Return variables */
1147 
1148         /* Return result */
1149         if (werror) {
1150                 *werror = r.out.result;
1151         }
1152 
1153         return werror_to_ntstatus(r.out.result);
1154 }
1155 
1156 NTSTATUS rpccli_svcctl_ChangeServiceConfigA(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1157                                             TALLOC_CTX *mem_ctx,
1158                                             struct policy_handle *handle /* [in] [ref] */,
1159                                             uint32_t type /* [in]  */,
1160                                             enum svcctl_StartType start_type /* [in]  */,
1161                                             enum svcctl_ErrorControl error_control /* [in]  */,
1162                                             const char *binary_path /* [in] [unique,charset(UTF16)] */,
1163                                             const char *load_order_group /* [in] [unique,charset(UTF16)] */,
1164                                             uint32_t *tag_id /* [out] [ref] */,
1165                                             const char *dependencies /* [in] [unique,charset(UTF16)] */,
1166                                             const char *service_start_name /* [in] [unique,charset(UTF16)] */,
1167                                             const char *password /* [in] [unique,charset(UTF16)] */,
1168                                             const char *display_name /* [in] [unique,charset(UTF16)] */,
1169                                             WERROR *werror)
1170 {
1171         struct svcctl_ChangeServiceConfigA r;
1172         NTSTATUS status;
1173 
1174         /* In parameters */
1175         r.in.handle = handle;
1176         r.in.type = type;
1177         r.in.start_type = start_type;
1178         r.in.error_control = error_control;
1179         r.in.binary_path = binary_path;
1180         r.in.load_order_group = load_order_group;
1181         r.in.dependencies = dependencies;
1182         r.in.service_start_name = service_start_name;
1183         r.in.password = password;
1184         r.in.display_name = display_name;
1185 
1186         if (DEBUGLEVEL >= 10) {
1187                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfigA, &r);
1188         }
1189 
1190         status = cli->dispatch(cli,
1191                                 mem_ctx,
1192                                 &ndr_table_svcctl,
1193                                 NDR_SVCCTL_CHANGESERVICECONFIGA,
1194                                 &r);
1195 
1196         if (!NT_STATUS_IS_OK(status)) {
1197                 return status;
1198         }
1199 
1200         if (DEBUGLEVEL >= 10) {
1201                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfigA, &r);
1202         }
1203 
1204         if (NT_STATUS_IS_ERR(status)) {
1205                 return status;
1206         }
1207 
1208         /* Return variables */
1209         *tag_id = *r.out.tag_id;
1210 
1211         /* Return result */
1212         if (werror) {
1213                 *werror = r.out.result;
1214         }
1215 
1216         return werror_to_ntstatus(r.out.result);
1217 }
1218 
1219 NTSTATUS rpccli_svcctl_CreateServiceA(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1220                                       TALLOC_CTX *mem_ctx,
1221                                       struct policy_handle *handle /* [in] [ref] */,
1222                                       const char *ServiceName /* [in] [unique,charset(UTF16)] */,
1223                                       const char *DisplayName /* [in] [unique,charset(UTF16)] */,
1224                                       uint32_t desired_access /* [in]  */,
1225                                       uint32_t type /* [in]  */,
1226                                       enum svcctl_StartType start_type /* [in]  */,
1227                                       enum svcctl_ErrorControl error_control /* [in]  */,
1228                                       const char *binary_path /* [in] [unique,charset(UTF16)] */,
1229                                       const char *LoadOrderGroupKey /* [in] [unique,charset(UTF16)] */,
1230                                       uint32_t *TagId /* [out] [unique] */,
1231                                       const char *dependencies /* [in] [unique,charset(UTF16)] */,
1232                                       const char *service_start_name /* [in] [unique,charset(UTF16)] */,
1233                                       const char *password /* [in] [unique,charset(UTF16)] */,
1234                                       WERROR *werror)
1235 {
1236         struct svcctl_CreateServiceA r;
1237         NTSTATUS status;
1238 
1239         /* In parameters */
1240         r.in.handle = handle;
1241         r.in.ServiceName = ServiceName;
1242         r.in.DisplayName = DisplayName;
1243         r.in.desired_access = desired_access;
1244         r.in.type = type;
1245         r.in.start_type = start_type;
1246         r.in.error_control = error_control;
1247         r.in.binary_path = binary_path;
1248         r.in.LoadOrderGroupKey = LoadOrderGroupKey;
1249         r.in.dependencies = dependencies;
1250         r.in.service_start_name = service_start_name;
1251         r.in.password = password;
1252 
1253         if (DEBUGLEVEL >= 10) {
1254                 NDR_PRINT_IN_DEBUG(svcctl_CreateServiceA, &r);
1255         }
1256 
1257         status = cli->dispatch(cli,
1258                                 mem_ctx,
1259                                 &ndr_table_svcctl,
1260                                 NDR_SVCCTL_CREATESERVICEA,
1261                                 &r);
1262 
1263         if (!NT_STATUS_IS_OK(status)) {
1264                 return status;
1265         }
1266 
1267         if (DEBUGLEVEL >= 10) {
1268                 NDR_PRINT_OUT_DEBUG(svcctl_CreateServiceA, &r);
1269         }
1270 
1271         if (NT_STATUS_IS_ERR(status)) {
1272                 return status;
1273         }
1274 
1275         /* Return variables */
1276         if (TagId && r.out.TagId) {
1277                 *TagId = *r.out.TagId;
1278         }
1279 
1280         /* Return result */
1281         if (werror) {
1282                 *werror = r.out.result;
1283         }
1284 
1285         return werror_to_ntstatus(r.out.result);
1286 }
1287 
1288 NTSTATUS rpccli_svcctl_EnumDependentServicesA(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1289                                               TALLOC_CTX *mem_ctx,
1290                                               struct policy_handle *service /* [in] [ref] */,
1291                                               enum svcctl_ServiceState state /* [in]  */,
1292                                               struct ENUM_SERVICE_STATUSA *service_status /* [out] [unique] */,
1293                                               uint32_t offered /* [in]  */,
1294                                               uint32_t *needed /* [out] [ref] */,
1295                                               uint32_t *services_returned /* [out] [ref] */,
1296                                               WERROR *werror)
1297 {
1298         struct svcctl_EnumDependentServicesA r;
1299         NTSTATUS status;
1300 
1301         /* In parameters */
1302         r.in.service = service;
1303         r.in.state = state;
1304         r.in.offered = offered;
1305 
1306         if (DEBUGLEVEL >= 10) {
1307                 NDR_PRINT_IN_DEBUG(svcctl_EnumDependentServicesA, &r);
1308         }
1309 
1310         status = cli->dispatch(cli,
1311                                 mem_ctx,
1312                                 &ndr_table_svcctl,
1313                                 NDR_SVCCTL_ENUMDEPENDENTSERVICESA,
1314                                 &r);
1315 
1316         if (!NT_STATUS_IS_OK(status)) {
1317                 return status;
1318         }
1319 
1320         if (DEBUGLEVEL >= 10) {
1321                 NDR_PRINT_OUT_DEBUG(svcctl_EnumDependentServicesA, &r);
1322         }
1323 
1324         if (NT_STATUS_IS_ERR(status)) {
1325                 return status;
1326         }
1327 
1328         /* Return variables */
1329         if (service_status && r.out.service_status) {
1330                 *service_status = *r.out.service_status;
1331         }
1332         *needed = *r.out.needed;
1333         *services_returned = *r.out.services_returned;
1334 
1335         /* Return result */
1336         if (werror) {
1337                 *werror = r.out.result;
1338         }
1339 
1340         return werror_to_ntstatus(r.out.result);
1341 }
1342 
1343 NTSTATUS rpccli_svcctl_EnumServicesStatusA(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1344                                            TALLOC_CTX *mem_ctx,
1345                                            struct policy_handle *handle /* [in] [ref] */,
1346                                            uint32_t type /* [in]  */,
1347                                            enum svcctl_ServiceState state /* [in]  */,
1348                                            uint32_t offered /* [in]  */,
1349                                            uint8_t *service /* [out] [size_is(offered)] */,
1350                                            uint32_t *needed /* [out] [ref] */,
1351                                            uint32_t *services_returned /* [out] [ref] */,
1352                                            uint32_t *resume_handle /* [in,out] [unique] */,
1353                                            WERROR *werror)
1354 {
1355         struct svcctl_EnumServicesStatusA r;
1356         NTSTATUS status;
1357 
1358         /* In parameters */
1359         r.in.handle = handle;
1360         r.in.type = type;
1361         r.in.state = state;
1362         r.in.offered = offered;
1363         r.in.resume_handle = resume_handle;
1364 
1365         if (DEBUGLEVEL >= 10) {
1366                 NDR_PRINT_IN_DEBUG(svcctl_EnumServicesStatusA, &r);
1367         }
1368 
1369         status = cli->dispatch(cli,
1370                                 mem_ctx,
1371                                 &ndr_table_svcctl,
1372                                 NDR_SVCCTL_ENUMSERVICESSTATUSA,
1373                                 &r);
1374 
1375         if (!NT_STATUS_IS_OK(status)) {
1376                 return status;
1377         }
1378 
1379         if (DEBUGLEVEL >= 10) {
1380                 NDR_PRINT_OUT_DEBUG(svcctl_EnumServicesStatusA, &r);
1381         }
1382 
1383         if (NT_STATUS_IS_ERR(status)) {
1384                 return status;
1385         }
1386 
1387         /* Return variables */
1388         memcpy(service, r.out.service, r.in.offered * sizeof(*service));
1389         *needed = *r.out.needed;
1390         *services_returned = *r.out.services_returned;
1391         if (resume_handle && r.out.resume_handle) {
1392                 *resume_handle = *r.out.resume_handle;
1393         }
1394 
1395         /* Return result */
1396         if (werror) {
1397                 *werror = r.out.result;
1398         }
1399 
1400         return werror_to_ntstatus(r.out.result);
1401 }
1402 
1403 NTSTATUS rpccli_svcctl_OpenSCManagerA(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1404                                       TALLOC_CTX *mem_ctx,
1405                                       const char *MachineName /* [in] [unique,charset(UTF16)] */,
1406                                       const char *DatabaseName /* [in] [unique,charset(UTF16)] */,
1407                                       uint32_t access_mask /* [in]  */,
1408                                       struct policy_handle *handle /* [out] [ref] */,
1409                                       WERROR *werror)
1410 {
1411         struct svcctl_OpenSCManagerA r;
1412         NTSTATUS status;
1413 
1414         /* In parameters */
1415         r.in.MachineName = MachineName;
1416         r.in.DatabaseName = DatabaseName;
1417         r.in.access_mask = access_mask;
1418 
1419         if (DEBUGLEVEL >= 10) {
1420                 NDR_PRINT_IN_DEBUG(svcctl_OpenSCManagerA, &r);
1421         }
1422 
1423         status = cli->dispatch(cli,
1424                                 mem_ctx,
1425                                 &ndr_table_svcctl,
1426                                 NDR_SVCCTL_OPENSCMANAGERA,
1427                                 &r);
1428 
1429         if (!NT_STATUS_IS_OK(status)) {
1430                 return status;
1431         }
1432 
1433         if (DEBUGLEVEL >= 10) {
1434                 NDR_PRINT_OUT_DEBUG(svcctl_OpenSCManagerA, &r);
1435         }
1436 
1437         if (NT_STATUS_IS_ERR(status)) {
1438                 return status;
1439         }
1440 
1441         /* Return variables */
1442         *handle = *r.out.handle;
1443 
1444         /* Return result */
1445         if (werror) {
1446                 *werror = r.out.result;
1447         }
1448 
1449         return werror_to_ntstatus(r.out.result);
1450 }
1451 
1452 NTSTATUS rpccli_svcctl_OpenServiceA(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1453                                     TALLOC_CTX *mem_ctx,
1454                                     struct policy_handle *scmanager_handle /* [in] [ref] */,
1455                                     const char *ServiceName /* [in] [unique,charset(UTF16)] */,
1456                                     uint32_t access_mask /* [in]  */,
1457                                     WERROR *werror)
1458 {
1459         struct svcctl_OpenServiceA r;
1460         NTSTATUS status;
1461 
1462         /* In parameters */
1463         r.in.scmanager_handle = scmanager_handle;
1464         r.in.ServiceName = ServiceName;
1465         r.in.access_mask = access_mask;
1466 
1467         if (DEBUGLEVEL >= 10) {
1468                 NDR_PRINT_IN_DEBUG(svcctl_OpenServiceA, &r);
1469         }
1470 
1471         status = cli->dispatch(cli,
1472                                 mem_ctx,
1473                                 &ndr_table_svcctl,
1474                                 NDR_SVCCTL_OPENSERVICEA,
1475                                 &r);
1476 
1477         if (!NT_STATUS_IS_OK(status)) {
1478                 return status;
1479         }
1480 
1481         if (DEBUGLEVEL >= 10) {
1482                 NDR_PRINT_OUT_DEBUG(svcctl_OpenServiceA, &r);
1483         }
1484 
1485         if (NT_STATUS_IS_ERR(status)) {
1486                 return status;
1487         }
1488 
1489         /* Return variables */
1490 
1491         /* Return result */
1492         if (werror) {
1493                 *werror = r.out.result;
1494         }
1495 
1496         return werror_to_ntstatus(r.out.result);
1497 }
1498 
1499 NTSTATUS rpccli_svcctl_QueryServiceConfigA(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1500                                            TALLOC_CTX *mem_ctx,
1501                                            struct policy_handle *handle /* [in] [ref] */,
1502                                            uint8_t *query /* [out]  */,
1503                                            uint32_t offered /* [in]  */,
1504                                            uint32_t *needed /* [out] [ref] */,
1505                                            WERROR *werror)
1506 {
1507         struct svcctl_QueryServiceConfigA r;
1508         NTSTATUS status;
1509 
1510         /* In parameters */
1511         r.in.handle = handle;
1512         r.in.offered = offered;
1513 
1514         if (DEBUGLEVEL >= 10) {
1515                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfigA, &r);
1516         }
1517 
1518         status = cli->dispatch(cli,
1519                                 mem_ctx,
1520                                 &ndr_table_svcctl,
1521                                 NDR_SVCCTL_QUERYSERVICECONFIGA,
1522                                 &r);
1523 
1524         if (!NT_STATUS_IS_OK(status)) {
1525                 return status;
1526         }
1527 
1528         if (DEBUGLEVEL >= 10) {
1529                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfigA, &r);
1530         }
1531 
1532         if (NT_STATUS_IS_ERR(status)) {
1533                 return status;
1534         }
1535 
1536         /* Return variables */
1537         memcpy(query, r.out.query, r.in.offered * sizeof(*query));
1538         *needed = *r.out.needed;
1539 
1540         /* Return result */
1541         if (werror) {
1542                 *werror = r.out.result;
1543         }
1544 
1545         return werror_to_ntstatus(r.out.result);
1546 }
1547 
1548 NTSTATUS rpccli_svcctl_QueryServiceLockStatusA(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1549                                                TALLOC_CTX *mem_ctx,
1550                                                struct policy_handle *handle /* [in] [ref] */,
1551                                                uint32_t offered /* [in]  */,
1552                                                struct SERVICE_LOCK_STATUS *lock_status /* [out] [ref] */,
1553                                                uint32_t *needed /* [out] [ref] */,
1554                                                WERROR *werror)
1555 {
1556         struct svcctl_QueryServiceLockStatusA r;
1557         NTSTATUS status;
1558 
1559         /* In parameters */
1560         r.in.handle = handle;
1561         r.in.offered = offered;
1562 
1563         if (DEBUGLEVEL >= 10) {
1564                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceLockStatusA, &r);
1565         }
1566 
1567         status = cli->dispatch(cli,
1568                                 mem_ctx,
1569                                 &ndr_table_svcctl,
1570                                 NDR_SVCCTL_QUERYSERVICELOCKSTATUSA,
1571                                 &r);
1572 
1573         if (!NT_STATUS_IS_OK(status)) {
1574                 return status;
1575         }
1576 
1577         if (DEBUGLEVEL >= 10) {
1578                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceLockStatusA, &r);
1579         }
1580 
1581         if (NT_STATUS_IS_ERR(status)) {
1582                 return status;
1583         }
1584 
1585         /* Return variables */
1586         *lock_status = *r.out.lock_status;
1587         *needed = *r.out.needed;
1588 
1589         /* Return result */
1590         if (werror) {
1591                 *werror = r.out.result;
1592         }
1593 
1594         return werror_to_ntstatus(r.out.result);
1595 }
1596 
1597 NTSTATUS rpccli_svcctl_StartServiceA(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1598                                      TALLOC_CTX *mem_ctx,
1599                                      struct policy_handle *handle /* [in] [ref] */,
1600                                      uint32_t NumArgs /* [in]  */,
1601                                      const char *Arguments /* [in] [unique,charset(UTF16)] */,
1602                                      WERROR *werror)
1603 {
1604         struct svcctl_StartServiceA r;
1605         NTSTATUS status;
1606 
1607         /* In parameters */
1608         r.in.handle = handle;
1609         r.in.NumArgs = NumArgs;
1610         r.in.Arguments = Arguments;
1611 
1612         if (DEBUGLEVEL >= 10) {
1613                 NDR_PRINT_IN_DEBUG(svcctl_StartServiceA, &r);
1614         }
1615 
1616         status = cli->dispatch(cli,
1617                                 mem_ctx,
1618                                 &ndr_table_svcctl,
1619                                 NDR_SVCCTL_STARTSERVICEA,
1620                                 &r);
1621 
1622         if (!NT_STATUS_IS_OK(status)) {
1623                 return status;
1624         }
1625 
1626         if (DEBUGLEVEL >= 10) {
1627                 NDR_PRINT_OUT_DEBUG(svcctl_StartServiceA, &r);
1628         }
1629 
1630         if (NT_STATUS_IS_ERR(status)) {
1631                 return status;
1632         }
1633 
1634         /* Return variables */
1635 
1636         /* Return result */
1637         if (werror) {
1638                 *werror = r.out.result;
1639         }
1640 
1641         return werror_to_ntstatus(r.out.result);
1642 }
1643 
1644 NTSTATUS rpccli_svcctl_GetServiceDisplayNameA(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1645                                               TALLOC_CTX *mem_ctx,
1646                                               struct policy_handle *handle /* [in] [ref] */,
1647                                               const char *service_name /* [in] [unique,charset(UTF16)] */,
1648                                               const char **display_name /* [out] [ref,charset(UTF16)] */,
1649                                               uint32_t *display_name_length /* [in,out] [unique] */,
1650                                               WERROR *werror)
1651 {
1652         struct svcctl_GetServiceDisplayNameA r;
1653         NTSTATUS status;
1654 
1655         /* In parameters */
1656         r.in.handle = handle;
1657         r.in.service_name = service_name;
1658         r.in.display_name_length = display_name_length;
1659 
1660         if (DEBUGLEVEL >= 10) {
1661                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceDisplayNameA, &r);
1662         }
1663 
1664         status = cli->dispatch(cli,
1665                                 mem_ctx,
1666                                 &ndr_table_svcctl,
1667                                 NDR_SVCCTL_GETSERVICEDISPLAYNAMEA,
1668                                 &r);
1669 
1670         if (!NT_STATUS_IS_OK(status)) {
1671                 return status;
1672         }
1673 
1674         if (DEBUGLEVEL >= 10) {
1675                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceDisplayNameA, &r);
1676         }
1677 
1678         if (NT_STATUS_IS_ERR(status)) {
1679                 return status;
1680         }
1681 
1682         /* Return variables */
1683         *display_name = *r.out.display_name;
1684         if (display_name_length && r.out.display_name_length) {
1685                 *display_name_length = *r.out.display_name_length;
1686         }
1687 
1688         /* Return result */
1689         if (werror) {
1690                 *werror = r.out.result;
1691         }
1692 
1693         return werror_to_ntstatus(r.out.result);
1694 }
1695 
1696 NTSTATUS rpccli_svcctl_GetServiceKeyNameA(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1697                                           TALLOC_CTX *mem_ctx,
1698                                           struct policy_handle *handle /* [in] [ref] */,
1699                                           const char *service_name /* [in] [unique,charset(UTF16)] */,
1700                                           const char **key_name /* [out] [ref,charset(UTF16)] */,
1701                                           uint32_t *display_name_length /* [in,out] [unique] */,
1702                                           WERROR *werror)
1703 {
1704         struct svcctl_GetServiceKeyNameA r;
1705         NTSTATUS status;
1706 
1707         /* In parameters */
1708         r.in.handle = handle;
1709         r.in.service_name = service_name;
1710         r.in.display_name_length = display_name_length;
1711 
1712         if (DEBUGLEVEL >= 10) {
1713                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceKeyNameA, &r);
1714         }
1715 
1716         status = cli->dispatch(cli,
1717                                 mem_ctx,
1718                                 &ndr_table_svcctl,
1719                                 NDR_SVCCTL_GETSERVICEKEYNAMEA,
1720                                 &r);
1721 
1722         if (!NT_STATUS_IS_OK(status)) {
1723                 return status;
1724         }
1725 
1726         if (DEBUGLEVEL >= 10) {
1727                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceKeyNameA, &r);
1728         }
1729 
1730         if (NT_STATUS_IS_ERR(status)) {
1731                 return status;
1732         }
1733 
1734         /* Return variables */
1735         *key_name = *r.out.key_name;
1736         if (display_name_length && r.out.display_name_length) {
1737                 *display_name_length = *r.out.display_name_length;
1738         }
1739 
1740         /* Return result */
1741         if (werror) {
1742                 *werror = r.out.result;
1743         }
1744 
1745         return werror_to_ntstatus(r.out.result);
1746 }
1747 
1748 NTSTATUS rpccli_svcctl_GetCurrentGroupeStateW(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1749                                               TALLOC_CTX *mem_ctx,
1750                                               WERROR *werror)
1751 {
1752         struct svcctl_GetCurrentGroupeStateW r;
1753         NTSTATUS status;
1754 
1755         /* In parameters */
1756 
1757         if (DEBUGLEVEL >= 10) {
1758                 NDR_PRINT_IN_DEBUG(svcctl_GetCurrentGroupeStateW, &r);
1759         }
1760 
1761         status = cli->dispatch(cli,
1762                                 mem_ctx,
1763                                 &ndr_table_svcctl,
1764                                 NDR_SVCCTL_GETCURRENTGROUPESTATEW,
1765                                 &r);
1766 
1767         if (!NT_STATUS_IS_OK(status)) {
1768                 return status;
1769         }
1770 
1771         if (DEBUGLEVEL >= 10) {
1772                 NDR_PRINT_OUT_DEBUG(svcctl_GetCurrentGroupeStateW, &r);
1773         }
1774 
1775         if (NT_STATUS_IS_ERR(status)) {
1776                 return status;
1777         }
1778 
1779         /* Return variables */
1780 
1781         /* Return result */
1782         if (werror) {
1783                 *werror = r.out.result;
1784         }
1785 
1786         return werror_to_ntstatus(r.out.result);
1787 }
1788 
1789 NTSTATUS rpccli_svcctl_EnumServiceGroupW(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1790                                          TALLOC_CTX *mem_ctx,
1791                                          WERROR *werror)
1792 {
1793         struct svcctl_EnumServiceGroupW r;
1794         NTSTATUS status;
1795 
1796         /* In parameters */
1797 
1798         if (DEBUGLEVEL >= 10) {
1799                 NDR_PRINT_IN_DEBUG(svcctl_EnumServiceGroupW, &r);
1800         }
1801 
1802         status = cli->dispatch(cli,
1803                                 mem_ctx,
1804                                 &ndr_table_svcctl,
1805                                 NDR_SVCCTL_ENUMSERVICEGROUPW,
1806                                 &r);
1807 
1808         if (!NT_STATUS_IS_OK(status)) {
1809                 return status;
1810         }
1811 
1812         if (DEBUGLEVEL >= 10) {
1813                 NDR_PRINT_OUT_DEBUG(svcctl_EnumServiceGroupW, &r);
1814         }
1815 
1816         if (NT_STATUS_IS_ERR(status)) {
1817                 return status;
1818         }
1819 
1820         /* Return variables */
1821 
1822         /* Return result */
1823         if (werror) {
1824                 *werror = r.out.result;
1825         }
1826 
1827         return werror_to_ntstatus(r.out.result);
1828 }
1829 
1830 NTSTATUS rpccli_svcctl_ChangeServiceConfig2A(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1831                                              TALLOC_CTX *mem_ctx,
1832                                              struct policy_handle *handle /* [in] [ref] */,
1833                                              uint32_t info_level /* [in]  */,
1834                                              uint8_t *info /* [in] [unique] */,
1835                                              WERROR *werror)
1836 {
1837         struct svcctl_ChangeServiceConfig2A r;
1838         NTSTATUS status;
1839 
1840         /* In parameters */
1841         r.in.handle = handle;
1842         r.in.info_level = info_level;
1843         r.in.info = info;
1844 
1845         if (DEBUGLEVEL >= 10) {
1846                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfig2A, &r);
1847         }
1848 
1849         status = cli->dispatch(cli,
1850                                 mem_ctx,
1851                                 &ndr_table_svcctl,
1852                                 NDR_SVCCTL_CHANGESERVICECONFIG2A,
1853                                 &r);
1854 
1855         if (!NT_STATUS_IS_OK(status)) {
1856                 return status;
1857         }
1858 
1859         if (DEBUGLEVEL >= 10) {
1860                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfig2A, &r);
1861         }
1862 
1863         if (NT_STATUS_IS_ERR(status)) {
1864                 return status;
1865         }
1866 
1867         /* Return variables */
1868 
1869         /* Return result */
1870         if (werror) {
1871                 *werror = r.out.result;
1872         }
1873 
1874         return werror_to_ntstatus(r.out.result);
1875 }
1876 
1877 NTSTATUS rpccli_svcctl_ChangeServiceConfig2W(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1878                                              TALLOC_CTX *mem_ctx,
1879                                              struct policy_handle *handle /* [in] [ref] */,
1880                                              uint32_t info_level /* [in]  */,
1881                                              uint8_t *info /* [in] [unique] */,
1882                                              WERROR *werror)
1883 {
1884         struct svcctl_ChangeServiceConfig2W r;
1885         NTSTATUS status;
1886 
1887         /* In parameters */
1888         r.in.handle = handle;
1889         r.in.info_level = info_level;
1890         r.in.info = info;
1891 
1892         if (DEBUGLEVEL >= 10) {
1893                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfig2W, &r);
1894         }
1895 
1896         status = cli->dispatch(cli,
1897                                 mem_ctx,
1898                                 &ndr_table_svcctl,
1899                                 NDR_SVCCTL_CHANGESERVICECONFIG2W,
1900                                 &r);
1901 
1902         if (!NT_STATUS_IS_OK(status)) {
1903                 return status;
1904         }
1905 
1906         if (DEBUGLEVEL >= 10) {
1907                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfig2W, &r);
1908         }
1909 
1910         if (NT_STATUS_IS_ERR(status)) {
1911                 return status;
1912         }
1913 
1914         /* Return variables */
1915 
1916         /* Return result */
1917         if (werror) {
1918                 *werror = r.out.result;
1919         }
1920 
1921         return werror_to_ntstatus(r.out.result);
1922 }
1923 
1924 NTSTATUS rpccli_svcctl_QueryServiceConfig2A(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1925                                             TALLOC_CTX *mem_ctx,
1926                                             struct policy_handle *handle /* [in] [ref] */,
1927                                             enum svcctl_ConfigLevel info_level /* [in]  */,
1928                                             uint8_t *buffer /* [out]  */,
1929                                             uint32_t offered /* [in]  */,
1930                                             uint32_t *needed /* [out] [ref] */,
1931                                             WERROR *werror)
1932 {
1933         struct svcctl_QueryServiceConfig2A r;
1934         NTSTATUS status;
1935 
1936         /* In parameters */
1937         r.in.handle = handle;
1938         r.in.info_level = info_level;
1939         r.in.offered = offered;
1940 
1941         if (DEBUGLEVEL >= 10) {
1942                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfig2A, &r);
1943         }
1944 
1945         status = cli->dispatch(cli,
1946                                 mem_ctx,
1947                                 &ndr_table_svcctl,
1948                                 NDR_SVCCTL_QUERYSERVICECONFIG2A,
1949                                 &r);
1950 
1951         if (!NT_STATUS_IS_OK(status)) {
1952                 return status;
1953         }
1954 
1955         if (DEBUGLEVEL >= 10) {
1956                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfig2A, &r);
1957         }
1958 
1959         if (NT_STATUS_IS_ERR(status)) {
1960                 return status;
1961         }
1962 
1963         /* Return variables */
1964         memcpy(buffer, r.out.buffer, r.in.offered * sizeof(*buffer));
1965         *needed = *r.out.needed;
1966 
1967         /* Return result */
1968         if (werror) {
1969                 *werror = r.out.result;
1970         }
1971 
1972         return werror_to_ntstatus(r.out.result);
1973 }
1974 
1975 NTSTATUS rpccli_svcctl_QueryServiceConfig2W(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
1976                                             TALLOC_CTX *mem_ctx,
1977                                             struct policy_handle *handle /* [in] [ref] */,
1978                                             enum svcctl_ConfigLevel info_level /* [in]  */,
1979                                             uint8_t *buffer /* [out] [ref,size_is(offered)] */,
1980                                             uint32_t offered /* [in] [range(0,8192)] */,
1981                                             uint32_t *needed /* [out] [ref,range(0,8192)] */,
1982                                             WERROR *werror)
1983 {
1984         struct svcctl_QueryServiceConfig2W r;
1985         NTSTATUS status;
1986 
1987         /* In parameters */
1988         r.in.handle = handle;
1989         r.in.info_level = info_level;
1990         r.in.offered = offered;
1991 
1992         if (DEBUGLEVEL >= 10) {
1993                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfig2W, &r);
1994         }
1995 
1996         status = cli->dispatch(cli,
1997                                 mem_ctx,
1998                                 &ndr_table_svcctl,
1999                                 NDR_SVCCTL_QUERYSERVICECONFIG2W,
2000                                 &r);
2001 
2002         if (!NT_STATUS_IS_OK(status)) {
2003                 return status;
2004         }
2005 
2006         if (DEBUGLEVEL >= 10) {
2007                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfig2W, &r);
2008         }
2009 
2010         if (NT_STATUS_IS_ERR(status)) {
2011                 return status;
2012         }
2013 
2014         /* Return variables */
2015         memcpy(buffer, r.out.buffer, r.in.offered * sizeof(*buffer));
2016         *needed = *r.out.needed;
2017 
2018         /* Return result */
2019         if (werror) {
2020                 *werror = r.out.result;
2021         }
2022 
2023         return werror_to_ntstatus(r.out.result);
2024 }
2025 
2026 NTSTATUS rpccli_svcctl_QueryServiceStatusEx(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
2027                                             TALLOC_CTX *mem_ctx,
2028                                             struct policy_handle *handle /* [in] [ref] */,
2029                                             enum svcctl_StatusLevel info_level /* [in]  */,
2030                                             uint8_t *buffer /* [out] [ref,size_is(offered)] */,
2031                                             uint32_t offered /* [in] [range(0,8192)] */,
2032                                             uint32_t *needed /* [out] [ref,range(0,8192)] */,
2033                                             WERROR *werror)
2034 {
2035         struct svcctl_QueryServiceStatusEx r;
2036         NTSTATUS status;
2037 
2038         /* In parameters */
2039         r.in.handle = handle;
2040         r.in.info_level = info_level;
2041         r.in.offered = offered;
2042 
2043         if (DEBUGLEVEL >= 10) {
2044                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceStatusEx, &r);
2045         }
2046 
2047         status = cli->dispatch(cli,
2048                                 mem_ctx,
2049                                 &ndr_table_svcctl,
2050                                 NDR_SVCCTL_QUERYSERVICESTATUSEX,
2051                                 &r);
2052 
2053         if (!NT_STATUS_IS_OK(status)) {
2054                 return status;
2055         }
2056 
2057         if (DEBUGLEVEL >= 10) {
2058                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceStatusEx, &r);
2059         }
2060 
2061         if (NT_STATUS_IS_ERR(status)) {
2062                 return status;
2063         }
2064 
2065         /* Return variables */
2066         memcpy(buffer, r.out.buffer, r.in.offered * sizeof(*buffer));
2067         *needed = *r.out.needed;
2068 
2069         /* Return result */
2070         if (werror) {
2071                 *werror = r.out.result;
2072         }
2073 
2074         return werror_to_ntstatus(r.out.result);
2075 }
2076 
2077 NTSTATUS rpccli_EnumServicesStatusExA(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
2078                                       TALLOC_CTX *mem_ctx,
2079                                       struct policy_handle *scmanager /* [in] [ref] */,
2080                                       uint32_t info_level /* [in]  */,
2081                                       uint32_t type /* [in]  */,
2082                                       enum svcctl_ServiceState state /* [in]  */,
2083                                       uint8_t *services /* [out]  */,
2084                                       uint32_t offered /* [in]  */,
2085                                       uint32_t *needed /* [out] [ref] */,
2086                                       uint32_t *service_returned /* [out] [ref] */,
2087                                       uint32_t *resume_handle /* [in,out] [unique] */,
2088                                       const char **group_name /* [out] [ref,charset(UTF16)] */,
2089                                       WERROR *werror)
2090 {
2091         struct EnumServicesStatusExA r;
2092         NTSTATUS status;
2093 
2094         /* In parameters */
2095         r.in.scmanager = scmanager;
2096         r.in.info_level = info_level;
2097         r.in.type = type;
2098         r.in.state = state;
2099         r.in.offered = offered;
2100         r.in.resume_handle = resume_handle;
2101 
2102         if (DEBUGLEVEL >= 10) {
2103                 NDR_PRINT_IN_DEBUG(EnumServicesStatusExA, &r);
2104         }
2105 
2106         status = cli->dispatch(cli,
2107                                 mem_ctx,
2108                                 &ndr_table_svcctl,
2109                                 NDR_ENUMSERVICESSTATUSEXA,
2110                                 &r);
2111 
2112         if (!NT_STATUS_IS_OK(status)) {
2113                 return status;
2114         }
2115 
2116         if (DEBUGLEVEL >= 10) {
2117                 NDR_PRINT_OUT_DEBUG(EnumServicesStatusExA, &r);
2118         }
2119 
2120         if (NT_STATUS_IS_ERR(status)) {
2121                 return status;
2122         }
2123 
2124         /* Return variables */
2125         memcpy(services, r.out.services, r.in.offered * sizeof(*services));
2126         *needed = *r.out.needed;
2127         *service_returned = *r.out.service_returned;
2128         if (resume_handle && r.out.resume_handle) {
2129                 *resume_handle = *r.out.resume_handle;
2130         }
2131         *group_name = *r.out.group_name;
2132 
2133         /* Return result */
2134         if (werror) {
2135                 *werror = r.out.result;
2136         }
2137 
2138         return werror_to_ntstatus(r.out.result);
2139 }
2140 
2141 NTSTATUS rpccli_EnumServicesStatusExW(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
2142                                       TALLOC_CTX *mem_ctx,
2143                                       struct policy_handle *scmanager /* [in] [ref] */,
2144                                       uint32_t info_level /* [in]  */,
2145                                       uint32_t type /* [in]  */,
2146                                       enum svcctl_ServiceState state /* [in]  */,
2147                                       uint8_t *services /* [out] [ref,size_is(offered)] */,
2148                                       uint32_t offered /* [in] [range(0,0x40000)] */,
2149                                       uint32_t *needed /* [out] [ref,range(0,0x40000)] */,
2150                                       uint32_t *service_returned /* [out] [ref,range(0,0x40000)] */,
2151                                       uint32_t *resume_handle /* [in,out] [unique,range(0,0x40000)] */,
2152                                       const char *group_name /* [in] [unique,charset(UTF16)] */,
2153                                       WERROR *werror)
2154 {
2155         struct EnumServicesStatusExW r;
2156         NTSTATUS status;
2157 
2158         /* In parameters */
2159         r.in.scmanager = scmanager;
2160         r.in.info_level = info_level;
2161         r.in.type = type;
2162         r.in.state = state;
2163         r.in.offered = offered;
2164         r.in.resume_handle = resume_handle;
2165         r.in.group_name = group_name;
2166 
2167         if (DEBUGLEVEL >= 10) {
2168                 NDR_PRINT_IN_DEBUG(EnumServicesStatusExW, &r);
2169         }
2170 
2171         status = cli->dispatch(cli,
2172                                 mem_ctx,
2173                                 &ndr_table_svcctl,
2174                                 NDR_ENUMSERVICESSTATUSEXW,
2175                                 &r);
2176 
2177         if (!NT_STATUS_IS_OK(status)) {
2178                 return status;
2179         }
2180 
2181         if (DEBUGLEVEL >= 10) {
2182                 NDR_PRINT_OUT_DEBUG(EnumServicesStatusExW, &r);
2183         }
2184 
2185         if (NT_STATUS_IS_ERR(status)) {
2186                 return status;
2187         }
2188 
2189         /* Return variables */
2190         memcpy(services, r.out.services, r.in.offered * sizeof(*services));
2191         *needed = *r.out.needed;
2192         *service_returned = *r.out.service_returned;
2193         if (resume_handle && r.out.resume_handle) {
2194                 *resume_handle = *r.out.resume_handle;
2195         }
2196 
2197         /* Return result */
2198         if (werror) {
2199                 *werror = r.out.result;
2200         }
2201 
2202         return werror_to_ntstatus(r.out.result);
2203 }
2204 
2205 NTSTATUS rpccli_svcctl_SCSendTSMessage(struct rpc_pipe_client *cli,
     /* [<][>][^][v][top][bottom][index][help] */
2206                                        TALLOC_CTX *mem_ctx,
2207                                        WERROR *werror)
2208 {
2209         struct svcctl_SCSendTSMessage r;
2210         NTSTATUS status;
2211 
2212         /* In parameters */
2213 
2214         if (DEBUGLEVEL >= 10) {
2215                 NDR_PRINT_IN_DEBUG(svcctl_SCSendTSMessage, &r);
2216         }
2217 
2218         status = cli->dispatch(cli,
2219                                 mem_ctx,
2220                                 &ndr_table_svcctl,
2221                                 NDR_SVCCTL_SCSENDTSMESSAGE,
2222                                 &r);
2223 
2224         if (!NT_STATUS_IS_OK(status)) {
2225                 return status;
2226         }
2227 
2228         if (DEBUGLEVEL >= 10) {
2229                 NDR_PRINT_OUT_DEBUG(svcctl_SCSendTSMessage, &r);
2230         }
2231 
2232         if (NT_STATUS_IS_ERR(status)) {
2233                 return status;
2234         }
2235 
2236         /* Return variables */
2237 
2238         /* Return result */
2239         if (werror) {
2240                 *werror = r.out.result;
2241         }
2242 
2243         return werror_to_ntstatus(r.out.result);
2244 }
2245 

/* [<][>][^][v][top][bottom][index][help] */