source/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 NTSTATUS rpccli_svcctl_CloseServiceHandle(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle)
  10 {
  11         struct svcctl_CloseServiceHandle r;
  12         NTSTATUS status;
  13
  14         /* In parameters */
  15         r.in.handle = handle;
  16
  17         if (DEBUGLEVEL >= 10)
  18                 NDR_PRINT_IN_DEBUG(svcctl_CloseServiceHandle, &r);
  19
  20         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_CLOSESERVICEHANDLE, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_CloseServiceHandle, (ndr_push_flags_fn_t)ndr_push_svcctl_CloseServiceHandle);
  21
  22         if (DEBUGLEVEL >= 10)
  23                 NDR_PRINT_OUT_DEBUG(svcctl_CloseServiceHandle, &r);
  24
  25         if (NT_STATUS_IS_ERR(status)) {
  26                 return status;
  27         }
  28
  29         /* Return variables */
  30         *handle = *r.out.handle;
  31
  32         /* Return result */
  33         return werror_to_ntstatus(r.out.result);
  34 }
  35
  36 NTSTATUS rpccli_svcctl_ControlService(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t control, struct SERVICE_STATUS *status)
  37 {
  38         struct svcctl_ControlService r;
  39         NTSTATUS status;
  40
  41         /* In parameters */
  42         r.in.handle = handle;
  43         r.in.control = control;
  44
  45         if (DEBUGLEVEL >= 10)
  46                 NDR_PRINT_IN_DEBUG(svcctl_ControlService, &r);
  47
  48         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_CONTROLSERVICE, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_ControlService, (ndr_push_flags_fn_t)ndr_push_svcctl_ControlService);
  49
  50         if (DEBUGLEVEL >= 10)
  51                 NDR_PRINT_OUT_DEBUG(svcctl_ControlService, &r);
  52
  53         if (NT_STATUS_IS_ERR(status)) {
  54                 return status;
  55         }
  56
  57         /* Return variables */
  58         *status = *r.out.status;
  59
  60         /* Return result */
  61         return werror_to_ntstatus(r.out.result);
  62 }
  63
  64 NTSTATUS rpccli_svcctl_DeleteService(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle)
  65 {
  66         struct svcctl_DeleteService r;
  67         NTSTATUS status;
  68
  69         /* In parameters */
  70         r.in.handle = handle;
  71
  72         if (DEBUGLEVEL >= 10)
  73                 NDR_PRINT_IN_DEBUG(svcctl_DeleteService, &r);
  74
  75         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_DELETESERVICE, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_DeleteService, (ndr_push_flags_fn_t)ndr_push_svcctl_DeleteService);
  76
  77         if (DEBUGLEVEL >= 10)
  78                 NDR_PRINT_OUT_DEBUG(svcctl_DeleteService, &r);
  79
  80         if (NT_STATUS_IS_ERR(status)) {
  81                 return status;
  82         }
  83
  84         /* Return variables */
  85
  86         /* Return result */
  87         return werror_to_ntstatus(r.out.result);
  88 }
  89
  90 NTSTATUS rpccli_svcctl_LockServiceDatabase(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct policy_handle *lock)
  91 {
  92         struct svcctl_LockServiceDatabase r;
  93         NTSTATUS status;
  94
  95         /* In parameters */
  96         r.in.handle = handle;
  97
  98         if (DEBUGLEVEL >= 10)
  99                 NDR_PRINT_IN_DEBUG(svcctl_LockServiceDatabase, &r);
 100
 101         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_LOCKSERVICEDATABASE, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_LockServiceDatabase, (ndr_push_flags_fn_t)ndr_push_svcctl_LockServiceDatabase);
 102
 103         if (DEBUGLEVEL >= 10)
 104                 NDR_PRINT_OUT_DEBUG(svcctl_LockServiceDatabase, &r);
 105
 106         if (NT_STATUS_IS_ERR(status)) {
 107                 return status;
 108         }
 109
 110         /* Return variables */
 111         *lock = *r.out.lock;
 112
 113         /* Return result */
 114         return werror_to_ntstatus(r.out.result);
 115 }
 116
 117 NTSTATUS rpccli_svcctl_QueryServiceObjectSecurity(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx)
 118 {
 119         struct svcctl_QueryServiceObjectSecurity r;
 120         NTSTATUS status;
 121
 122         /* In parameters */
 123
 124         if (DEBUGLEVEL >= 10)
 125                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceObjectSecurity, &r);
 126
 127         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_QUERYSERVICEOBJECTSECURITY, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_QueryServiceObjectSecurity, (ndr_push_flags_fn_t)ndr_push_svcctl_QueryServiceObjectSecurity);
 128
 129         if (DEBUGLEVEL >= 10)
 130                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceObjectSecurity, &r);
 131
 132         if (NT_STATUS_IS_ERR(status)) {
 133                 return status;
 134         }
 135
 136         /* Return variables */
 137
 138         /* Return result */
 139         return werror_to_ntstatus(r.out.result);
 140 }
 141
 142 NTSTATUS rpccli_svcctl_SetServiceObjectSecurity(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx)
 143 {
 144         struct svcctl_SetServiceObjectSecurity r;
 145         NTSTATUS status;
 146
 147         /* In parameters */
 148
 149         if (DEBUGLEVEL >= 10)
 150                 NDR_PRINT_IN_DEBUG(svcctl_SetServiceObjectSecurity, &r);
 151
 152         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_SETSERVICEOBJECTSECURITY, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_SetServiceObjectSecurity, (ndr_push_flags_fn_t)ndr_push_svcctl_SetServiceObjectSecurity);
 153
 154         if (DEBUGLEVEL >= 10)
 155                 NDR_PRINT_OUT_DEBUG(svcctl_SetServiceObjectSecurity, &r);
 156
 157         if (NT_STATUS_IS_ERR(status)) {
 158                 return status;
 159         }
 160
 161         /* Return variables */
 162
 163         /* Return result */
 164         return werror_to_ntstatus(r.out.result);
 165 }
 166
 167 NTSTATUS rpccli_svcctl_QueryServiceStatus(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct SERVICE_STATUS *status)
 168 {
 169         struct svcctl_QueryServiceStatus r;
 170         NTSTATUS status;
 171
 172         /* In parameters */
 173         r.in.handle = handle;
 174
 175         if (DEBUGLEVEL >= 10)
 176                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceStatus, &r);
 177
 178         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_QUERYSERVICESTATUS, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_QueryServiceStatus, (ndr_push_flags_fn_t)ndr_push_svcctl_QueryServiceStatus);
 179
 180         if (DEBUGLEVEL >= 10)
 181                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceStatus, &r);
 182
 183         if (NT_STATUS_IS_ERR(status)) {
 184                 return status;
 185         }
 186
 187         /* Return variables */
 188         *status = *r.out.status;
 189
 190         /* Return result */
 191         return werror_to_ntstatus(r.out.result);
 192 }
 193
 194 NTSTATUS rpccli_svcctl_SetServiceStatus(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx)
 195 {
 196         struct svcctl_SetServiceStatus r;
 197         NTSTATUS status;
 198
 199         /* In parameters */
 200
 201         if (DEBUGLEVEL >= 10)
 202                 NDR_PRINT_IN_DEBUG(svcctl_SetServiceStatus, &r);
 203
 204         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_SETSERVICESTATUS, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_SetServiceStatus, (ndr_push_flags_fn_t)ndr_push_svcctl_SetServiceStatus);
 205
 206         if (DEBUGLEVEL >= 10)
 207                 NDR_PRINT_OUT_DEBUG(svcctl_SetServiceStatus, &r);
 208
 209         if (NT_STATUS_IS_ERR(status)) {
 210                 return status;
 211         }
 212
 213         /* Return variables */
 214
 215         /* Return result */
 216         return werror_to_ntstatus(r.out.result);
 217 }
 218
 219 NTSTATUS rpccli_svcctl_UnlockServiceDatabase(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *lock)
 220 {
 221         struct svcctl_UnlockServiceDatabase r;
 222         NTSTATUS status;
 223
 224         /* In parameters */
 225         r.in.lock = lock;
 226
 227         if (DEBUGLEVEL >= 10)
 228                 NDR_PRINT_IN_DEBUG(svcctl_UnlockServiceDatabase, &r);
 229
 230         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_UNLOCKSERVICEDATABASE, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_UnlockServiceDatabase, (ndr_push_flags_fn_t)ndr_push_svcctl_UnlockServiceDatabase);
 231
 232         if (DEBUGLEVEL >= 10)
 233                 NDR_PRINT_OUT_DEBUG(svcctl_UnlockServiceDatabase, &r);
 234
 235         if (NT_STATUS_IS_ERR(status)) {
 236                 return status;
 237         }
 238
 239         /* Return variables */
 240         *lock = *r.out.lock;
 241
 242         /* Return result */
 243         return werror_to_ntstatus(r.out.result);
 244 }
 245
 246 NTSTATUS rpccli_svcctl_NotifyBootConfigStatus(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx)
 247 {
 248         struct svcctl_NotifyBootConfigStatus r;
 249         NTSTATUS status;
 250
 251         /* In parameters */
 252
 253         if (DEBUGLEVEL >= 10)
 254                 NDR_PRINT_IN_DEBUG(svcctl_NotifyBootConfigStatus, &r);
 255
 256         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_NOTIFYBOOTCONFIGSTATUS, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_NotifyBootConfigStatus, (ndr_push_flags_fn_t)ndr_push_svcctl_NotifyBootConfigStatus);
 257
 258         if (DEBUGLEVEL >= 10)
 259                 NDR_PRINT_OUT_DEBUG(svcctl_NotifyBootConfigStatus, &r);
 260
 261         if (NT_STATUS_IS_ERR(status)) {
 262                 return status;
 263         }
 264
 265         /* Return variables */
 266
 267         /* Return result */
 268         return werror_to_ntstatus(r.out.result);
 269 }
 270
 271 NTSTATUS rpccli_svcctl_SCSetServiceBitsW(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t bits, uint32_t bitson, uint32_t immediate)
 272 {
 273         struct svcctl_SCSetServiceBitsW r;
 274         NTSTATUS status;
 275
 276         /* In parameters */
 277         r.in.handle = handle;
 278         r.in.bits = bits;
 279         r.in.bitson = bitson;
 280         r.in.immediate = immediate;
 281
 282         if (DEBUGLEVEL >= 10)
 283                 NDR_PRINT_IN_DEBUG(svcctl_SCSetServiceBitsW, &r);
 284
 285         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_SCSETSERVICEBITSW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_SCSetServiceBitsW, (ndr_push_flags_fn_t)ndr_push_svcctl_SCSetServiceBitsW);
 286
 287         if (DEBUGLEVEL >= 10)
 288                 NDR_PRINT_OUT_DEBUG(svcctl_SCSetServiceBitsW, &r);
 289
 290         if (NT_STATUS_IS_ERR(status)) {
 291                 return status;
 292         }
 293
 294         /* Return variables */
 295
 296         /* Return result */
 297         return werror_to_ntstatus(r.out.result);
 298 }
 299
 300 NTSTATUS rpccli_svcctl_ChangeServiceConfigW(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t type, uint32_t start, uint32_t error, const char *binary_path, const char *load_order_group, uint32_t *tag_id, const char *dependencies, const char *service_start_name, const char *password, const char *display_name)
 301 {
 302         struct svcctl_ChangeServiceConfigW r;
 303         NTSTATUS status;
 304
 305         /* In parameters */
 306         r.in.handle = handle;
 307         r.in.type = type;
 308         r.in.start = start;
 309         r.in.error = error;
 310         r.in.binary_path = binary_path;
 311         r.in.load_order_group = load_order_group;
 312         r.in.dependencies = dependencies;
 313         r.in.service_start_name = service_start_name;
 314         r.in.password = password;
 315         r.in.display_name = display_name;
 316
 317         if (DEBUGLEVEL >= 10)
 318                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfigW, &r);
 319
 320         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_CHANGESERVICECONFIGW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_ChangeServiceConfigW, (ndr_push_flags_fn_t)ndr_push_svcctl_ChangeServiceConfigW);
 321
 322         if (DEBUGLEVEL >= 10)
 323                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfigW, &r);
 324
 325         if (NT_STATUS_IS_ERR(status)) {
 326                 return status;
 327         }
 328
 329         /* Return variables */
 330         *tag_id = *r.out.tag_id;
 331
 332         /* Return result */
 333         return werror_to_ntstatus(r.out.result);
 334 }
 335
 336 NTSTATUS rpccli_svcctl_CreateServiceW(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *scmanager_handle, const char *ServiceName, const char *DisplayName, uint32_t desired_access, uint32_t type, uint32_t start_type, uint32_t error_control, const char *binary_path, const char *LoadOrderGroupKey, uint32_t *TagId, uint8_t *dependencies, uint32_t dependencies_size, const char *service_start_name, uint8_t *password, uint32_t password_size, struct policy_handle *handle)
 337 {
 338         struct svcctl_CreateServiceW r;
 339         NTSTATUS status;
 340
 341         /* In parameters */
 342         r.in.scmanager_handle = scmanager_handle;
 343         r.in.ServiceName = ServiceName;
 344         r.in.DisplayName = DisplayName;
 345         r.in.desired_access = desired_access;
 346         r.in.type = type;
 347         r.in.start_type = start_type;
 348         r.in.error_control = error_control;
 349         r.in.binary_path = binary_path;
 350         r.in.LoadOrderGroupKey = LoadOrderGroupKey;
 351         r.in.TagId = TagId;
 352         r.in.dependencies = dependencies;
 353         r.in.dependencies_size = dependencies_size;
 354         r.in.service_start_name = service_start_name;
 355         r.in.password = password;
 356         r.in.password_size = password_size;
 357
 358         if (DEBUGLEVEL >= 10)
 359                 NDR_PRINT_IN_DEBUG(svcctl_CreateServiceW, &r);
 360
 361         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_CREATESERVICEW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_CreateServiceW, (ndr_push_flags_fn_t)ndr_push_svcctl_CreateServiceW);
 362
 363         if (DEBUGLEVEL >= 10)
 364                 NDR_PRINT_OUT_DEBUG(svcctl_CreateServiceW, &r);
 365
 366         if (NT_STATUS_IS_ERR(status)) {
 367                 return status;
 368         }
 369
 370         /* Return variables */
 371         *TagId = *r.out.TagId;
 372         *handle = *r.out.handle;
 373
 374         /* Return result */
 375         return werror_to_ntstatus(r.out.result);
 376 }
 377
 378 NTSTATUS rpccli_svcctl_EnumDependentServicesW(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *service, uint32_t state, struct ENUM_SERVICE_STATUS *status, uint32_t buf_size, uint32_t *bytes_needed, uint32_t *services_returned)
 379 {
 380         struct svcctl_EnumDependentServicesW r;
 381         NTSTATUS status;
 382
 383         /* In parameters */
 384         r.in.service = service;
 385         r.in.state = state;
 386         r.in.buf_size = buf_size;
 387
 388         if (DEBUGLEVEL >= 10)
 389                 NDR_PRINT_IN_DEBUG(svcctl_EnumDependentServicesW, &r);
 390
 391         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_ENUMDEPENDENTSERVICESW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_EnumDependentServicesW, (ndr_push_flags_fn_t)ndr_push_svcctl_EnumDependentServicesW);
 392
 393         if (DEBUGLEVEL >= 10)
 394                 NDR_PRINT_OUT_DEBUG(svcctl_EnumDependentServicesW, &r);
 395
 396         if (NT_STATUS_IS_ERR(status)) {
 397                 return status;
 398         }
 399
 400         /* Return variables */
 401         *status = *r.out.status;
 402         *bytes_needed = *r.out.bytes_needed;
 403         *services_returned = *r.out.services_returned;
 404
 405         /* Return result */
 406         return werror_to_ntstatus(r.out.result);
 407 }
 408
 409 NTSTATUS rpccli_svcctl_EnumServicesStatusW(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t type, uint32_t state, uint32_t buf_size, uint8_t *service, uint32_t *bytes_needed, uint32_t *services_returned, uint32_t *resume_handle)
 410 {
 411         struct svcctl_EnumServicesStatusW r;
 412         NTSTATUS status;
 413
 414         /* In parameters */
 415         r.in.handle = handle;
 416         r.in.type = type;
 417         r.in.state = state;
 418         r.in.buf_size = buf_size;
 419         r.in.resume_handle = resume_handle;
 420
 421         if (DEBUGLEVEL >= 10)
 422                 NDR_PRINT_IN_DEBUG(svcctl_EnumServicesStatusW, &r);
 423
 424         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_ENUMSERVICESSTATUSW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_EnumServicesStatusW, (ndr_push_flags_fn_t)ndr_push_svcctl_EnumServicesStatusW);
 425
 426         if (DEBUGLEVEL >= 10)
 427                 NDR_PRINT_OUT_DEBUG(svcctl_EnumServicesStatusW, &r);
 428
 429         if (NT_STATUS_IS_ERR(status)) {
 430                 return status;
 431         }
 432
 433         /* Return variables */
 434         *service = *r.out.service;
 435         *bytes_needed = *r.out.bytes_needed;
 436         *services_returned = *r.out.services_returned;
 437         *resume_handle = *r.out.resume_handle;
 438
 439         /* Return result */
 440         return werror_to_ntstatus(r.out.result);
 441 }
 442
 443 NTSTATUS rpccli_svcctl_OpenSCManagerW(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *MachineName, const char *DatabaseName, uint32_t access_mask, struct policy_handle *handle)
 444 {
 445         struct svcctl_OpenSCManagerW r;
 446         NTSTATUS status;
 447
 448         /* In parameters */
 449         r.in.MachineName = MachineName;
 450         r.in.DatabaseName = DatabaseName;
 451         r.in.access_mask = access_mask;
 452
 453         if (DEBUGLEVEL >= 10)
 454                 NDR_PRINT_IN_DEBUG(svcctl_OpenSCManagerW, &r);
 455
 456         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_OPENSCMANAGERW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_OpenSCManagerW, (ndr_push_flags_fn_t)ndr_push_svcctl_OpenSCManagerW);
 457
 458         if (DEBUGLEVEL >= 10)
 459                 NDR_PRINT_OUT_DEBUG(svcctl_OpenSCManagerW, &r);
 460
 461         if (NT_STATUS_IS_ERR(status)) {
 462                 return status;
 463         }
 464
 465         /* Return variables */
 466         *handle = *r.out.handle;
 467
 468         /* Return result */
 469         return werror_to_ntstatus(r.out.result);
 470 }
 471
 472 NTSTATUS rpccli_svcctl_OpenServiceW(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *scmanager_handle, const char *ServiceName, uint32_t access_mask, struct policy_handle *handle)
 473 {
 474         struct svcctl_OpenServiceW r;
 475         NTSTATUS status;
 476
 477         /* In parameters */
 478         r.in.scmanager_handle = scmanager_handle;
 479         r.in.ServiceName = ServiceName;
 480         r.in.access_mask = access_mask;
 481
 482         if (DEBUGLEVEL >= 10)
 483                 NDR_PRINT_IN_DEBUG(svcctl_OpenServiceW, &r);
 484
 485         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_OPENSERVICEW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_OpenServiceW, (ndr_push_flags_fn_t)ndr_push_svcctl_OpenServiceW);
 486
 487         if (DEBUGLEVEL >= 10)
 488                 NDR_PRINT_OUT_DEBUG(svcctl_OpenServiceW, &r);
 489
 490         if (NT_STATUS_IS_ERR(status)) {
 491                 return status;
 492         }
 493
 494         /* Return variables */
 495         *handle = *r.out.handle;
 496
 497         /* Return result */
 498         return werror_to_ntstatus(r.out.result);
 499 }
 500
 501 NTSTATUS rpccli_svcctl_QueryServiceConfigW(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint8_t *query, uint32_t buf_size, uint32_t *bytes_needed)
 502 {
 503         struct svcctl_QueryServiceConfigW r;
 504         NTSTATUS status;
 505
 506         /* In parameters */
 507         r.in.handle = handle;
 508         r.in.buf_size = buf_size;
 509
 510         if (DEBUGLEVEL >= 10)
 511                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfigW, &r);
 512
 513         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_QUERYSERVICECONFIGW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_QueryServiceConfigW, (ndr_push_flags_fn_t)ndr_push_svcctl_QueryServiceConfigW);
 514
 515         if (DEBUGLEVEL >= 10)
 516                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfigW, &r);
 517
 518         if (NT_STATUS_IS_ERR(status)) {
 519                 return status;
 520         }
 521
 522         /* Return variables */
 523         *query = *r.out.query;
 524         *bytes_needed = *r.out.bytes_needed;
 525
 526         /* Return result */
 527         return werror_to_ntstatus(r.out.result);
 528 }
 529
 530 NTSTATUS rpccli_svcctl_QueryServiceLockStatusW(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t buf_size, struct SERVICE_LOCK_STATUS *status, uint32_t *required_buf_size)
 531 {
 532         struct svcctl_QueryServiceLockStatusW r;
 533         NTSTATUS status;
 534
 535         /* In parameters */
 536         r.in.handle = handle;
 537         r.in.buf_size = buf_size;
 538
 539         if (DEBUGLEVEL >= 10)
 540                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceLockStatusW, &r);
 541
 542         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_QUERYSERVICELOCKSTATUSW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_QueryServiceLockStatusW, (ndr_push_flags_fn_t)ndr_push_svcctl_QueryServiceLockStatusW);
 543
 544         if (DEBUGLEVEL >= 10)
 545                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceLockStatusW, &r);
 546
 547         if (NT_STATUS_IS_ERR(status)) {
 548                 return status;
 549         }
 550
 551         /* Return variables */
 552         *status = *r.out.status;
 553         *required_buf_size = *r.out.required_buf_size;
 554
 555         /* Return result */
 556         return werror_to_ntstatus(r.out.result);
 557 }
 558
 559 NTSTATUS rpccli_svcctl_StartServiceW(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t NumArgs, const char *Arguments)
 560 {
 561         struct svcctl_StartServiceW r;
 562         NTSTATUS status;
 563
 564         /* In parameters */
 565         r.in.handle = handle;
 566         r.in.NumArgs = NumArgs;
 567         r.in.Arguments = Arguments;
 568
 569         if (DEBUGLEVEL >= 10)
 570                 NDR_PRINT_IN_DEBUG(svcctl_StartServiceW, &r);
 571
 572         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_STARTSERVICEW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_StartServiceW, (ndr_push_flags_fn_t)ndr_push_svcctl_StartServiceW);
 573
 574         if (DEBUGLEVEL >= 10)
 575                 NDR_PRINT_OUT_DEBUG(svcctl_StartServiceW, &r);
 576
 577         if (NT_STATUS_IS_ERR(status)) {
 578                 return status;
 579         }
 580
 581         /* Return variables */
 582
 583         /* Return result */
 584         return werror_to_ntstatus(r.out.result);
 585 }
 586
 587 NTSTATUS rpccli_svcctl_GetServiceDisplayNameW(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, const char *service_name, const char **display_name, uint32_t *display_name_length)
 588 {
 589         struct svcctl_GetServiceDisplayNameW r;
 590         NTSTATUS status;
 591
 592         /* In parameters */
 593         r.in.handle = handle;
 594         r.in.service_name = service_name;
 595         r.in.display_name_length = display_name_length;
 596
 597         if (DEBUGLEVEL >= 10)
 598                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceDisplayNameW, &r);
 599
 600         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_GETSERVICEDISPLAYNAMEW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_GetServiceDisplayNameW, (ndr_push_flags_fn_t)ndr_push_svcctl_GetServiceDisplayNameW);
 601
 602         if (DEBUGLEVEL >= 10)
 603                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceDisplayNameW, &r);
 604
 605         if (NT_STATUS_IS_ERR(status)) {
 606                 return status;
 607         }
 608
 609         /* Return variables */
 610         *display_name = *r.out.display_name;
 611         *display_name_length = *r.out.display_name_length;
 612
 613         /* Return result */
 614         return werror_to_ntstatus(r.out.result);
 615 }
 616
 617 NTSTATUS rpccli_svcctl_GetServiceKeyNameW(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, const char *service_name, const char **key_name, uint32_t *display_name_length)
 618 {
 619         struct svcctl_GetServiceKeyNameW r;
 620         NTSTATUS status;
 621
 622         /* In parameters */
 623         r.in.handle = handle;
 624         r.in.service_name = service_name;
 625         r.in.display_name_length = display_name_length;
 626
 627         if (DEBUGLEVEL >= 10)
 628                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceKeyNameW, &r);
 629
 630         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_GETSERVICEKEYNAMEW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_GetServiceKeyNameW, (ndr_push_flags_fn_t)ndr_push_svcctl_GetServiceKeyNameW);
 631
 632         if (DEBUGLEVEL >= 10)
 633                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceKeyNameW, &r);
 634
 635         if (NT_STATUS_IS_ERR(status)) {
 636                 return status;
 637         }
 638
 639         /* Return variables */
 640         *key_name = *r.out.key_name;
 641         *display_name_length = *r.out.display_name_length;
 642
 643         /* Return result */
 644         return werror_to_ntstatus(r.out.result);
 645 }
 646
 647 NTSTATUS rpccli_svcctl_SCSetServiceBitsA(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t bits, uint32_t bitson, uint32_t immediate)
 648 {
 649         struct svcctl_SCSetServiceBitsA r;
 650         NTSTATUS status;
 651
 652         /* In parameters */
 653         r.in.handle = handle;
 654         r.in.bits = bits;
 655         r.in.bitson = bitson;
 656         r.in.immediate = immediate;
 657
 658         if (DEBUGLEVEL >= 10)
 659                 NDR_PRINT_IN_DEBUG(svcctl_SCSetServiceBitsA, &r);
 660
 661         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_SCSETSERVICEBITSA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_SCSetServiceBitsA, (ndr_push_flags_fn_t)ndr_push_svcctl_SCSetServiceBitsA);
 662
 663         if (DEBUGLEVEL >= 10)
 664                 NDR_PRINT_OUT_DEBUG(svcctl_SCSetServiceBitsA, &r);
 665
 666         if (NT_STATUS_IS_ERR(status)) {
 667                 return status;
 668         }
 669
 670         /* Return variables */
 671
 672         /* Return result */
 673         return werror_to_ntstatus(r.out.result);
 674 }
 675
 676 NTSTATUS rpccli_svcctl_ChangeServiceConfigA(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t type, uint32_t start, uint32_t error, const char *binary_path, const char *load_order_group, uint32_t *tag_id, const char *dependencies, const char *service_start_name, const char *password, const char *display_name)
 677 {
 678         struct svcctl_ChangeServiceConfigA r;
 679         NTSTATUS status;
 680
 681         /* In parameters */
 682         r.in.handle = handle;
 683         r.in.type = type;
 684         r.in.start = start;
 685         r.in.error = error;
 686         r.in.binary_path = binary_path;
 687         r.in.load_order_group = load_order_group;
 688         r.in.dependencies = dependencies;
 689         r.in.service_start_name = service_start_name;
 690         r.in.password = password;
 691         r.in.display_name = display_name;
 692
 693         if (DEBUGLEVEL >= 10)
 694                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfigA, &r);
 695
 696         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_CHANGESERVICECONFIGA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_ChangeServiceConfigA, (ndr_push_flags_fn_t)ndr_push_svcctl_ChangeServiceConfigA);
 697
 698         if (DEBUGLEVEL >= 10)
 699                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfigA, &r);
 700
 701         if (NT_STATUS_IS_ERR(status)) {
 702                 return status;
 703         }
 704
 705         /* Return variables */
 706         *tag_id = *r.out.tag_id;
 707
 708         /* Return result */
 709         return werror_to_ntstatus(r.out.result);
 710 }
 711
 712 NTSTATUS rpccli_svcctl_CreateServiceA(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, const char *ServiceName, const char *DisplayName, uint32_t desired_access, uint32_t type, uint32_t start_type, uint32_t error_control, const char *binary_path, const char *LoadOrderGroupKey, uint32_t *TagId, const char *dependencies, const char *service_start_name, const char *password)
 713 {
 714         struct svcctl_CreateServiceA r;
 715         NTSTATUS status;
 716
 717         /* In parameters */
 718         r.in.handle = handle;
 719         r.in.ServiceName = ServiceName;
 720         r.in.DisplayName = DisplayName;
 721         r.in.desired_access = desired_access;
 722         r.in.type = type;
 723         r.in.start_type = start_type;
 724         r.in.error_control = error_control;
 725         r.in.binary_path = binary_path;
 726         r.in.LoadOrderGroupKey = LoadOrderGroupKey;
 727         r.in.dependencies = dependencies;
 728         r.in.service_start_name = service_start_name;
 729         r.in.password = password;
 730
 731         if (DEBUGLEVEL >= 10)
 732                 NDR_PRINT_IN_DEBUG(svcctl_CreateServiceA, &r);
 733
 734         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_CREATESERVICEA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_CreateServiceA, (ndr_push_flags_fn_t)ndr_push_svcctl_CreateServiceA);
 735
 736         if (DEBUGLEVEL >= 10)
 737                 NDR_PRINT_OUT_DEBUG(svcctl_CreateServiceA, &r);
 738
 739         if (NT_STATUS_IS_ERR(status)) {
 740                 return status;
 741         }
 742
 743         /* Return variables */
 744         *TagId = *r.out.TagId;
 745
 746         /* Return result */
 747         return werror_to_ntstatus(r.out.result);
 748 }
 749
 750 NTSTATUS rpccli_svcctl_EnumDependentServicesA(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *service, uint32_t state, struct ENUM_SERVICE_STATUS *status, uint32_t buf_size, uint32_t *bytes_needed, uint32_t *services_returned)
 751 {
 752         struct svcctl_EnumDependentServicesA r;
 753         NTSTATUS status;
 754
 755         /* In parameters */
 756         r.in.service = service;
 757         r.in.state = state;
 758         r.in.buf_size = buf_size;
 759
 760         if (DEBUGLEVEL >= 10)
 761                 NDR_PRINT_IN_DEBUG(svcctl_EnumDependentServicesA, &r);
 762
 763         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_ENUMDEPENDENTSERVICESA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_EnumDependentServicesA, (ndr_push_flags_fn_t)ndr_push_svcctl_EnumDependentServicesA);
 764
 765         if (DEBUGLEVEL >= 10)
 766                 NDR_PRINT_OUT_DEBUG(svcctl_EnumDependentServicesA, &r);
 767
 768         if (NT_STATUS_IS_ERR(status)) {
 769                 return status;
 770         }
 771
 772         /* Return variables */
 773         *status = *r.out.status;
 774         *bytes_needed = *r.out.bytes_needed;
 775         *services_returned = *r.out.services_returned;
 776
 777         /* Return result */
 778         return werror_to_ntstatus(r.out.result);
 779 }
 780
 781 NTSTATUS rpccli_svcctl_EnumServicesStatusA(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t type, uint32_t state, uint32_t buf_size, uint8_t *service, uint32_t *bytes_needed, uint32_t *services_returned, uint32_t *resume_handle)
 782 {
 783         struct svcctl_EnumServicesStatusA r;
 784         NTSTATUS status;
 785
 786         /* In parameters */
 787         r.in.handle = handle;
 788         r.in.type = type;
 789         r.in.state = state;
 790         r.in.buf_size = buf_size;
 791         r.in.resume_handle = resume_handle;
 792
 793         if (DEBUGLEVEL >= 10)
 794                 NDR_PRINT_IN_DEBUG(svcctl_EnumServicesStatusA, &r);
 795
 796         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_ENUMSERVICESSTATUSA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_EnumServicesStatusA, (ndr_push_flags_fn_t)ndr_push_svcctl_EnumServicesStatusA);
 797
 798         if (DEBUGLEVEL >= 10)
 799                 NDR_PRINT_OUT_DEBUG(svcctl_EnumServicesStatusA, &r);
 800
 801         if (NT_STATUS_IS_ERR(status)) {
 802                 return status;
 803         }
 804
 805         /* Return variables */
 806         *service = *r.out.service;
 807         *bytes_needed = *r.out.bytes_needed;
 808         *services_returned = *r.out.services_returned;
 809         *resume_handle = *r.out.resume_handle;
 810
 811         /* Return result */
 812         return werror_to_ntstatus(r.out.result);
 813 }
 814
 815 NTSTATUS rpccli_svcctl_OpenSCManagerA(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *MachineName, const char *DatabaseName, uint32_t access_mask, struct policy_handle *handle)
 816 {
 817         struct svcctl_OpenSCManagerA r;
 818         NTSTATUS status;
 819
 820         /* In parameters */
 821         r.in.MachineName = MachineName;
 822         r.in.DatabaseName = DatabaseName;
 823         r.in.access_mask = access_mask;
 824
 825         if (DEBUGLEVEL >= 10)
 826                 NDR_PRINT_IN_DEBUG(svcctl_OpenSCManagerA, &r);
 827
 828         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_OPENSCMANAGERA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_OpenSCManagerA, (ndr_push_flags_fn_t)ndr_push_svcctl_OpenSCManagerA);
 829
 830         if (DEBUGLEVEL >= 10)
 831                 NDR_PRINT_OUT_DEBUG(svcctl_OpenSCManagerA, &r);
 832
 833         if (NT_STATUS_IS_ERR(status)) {
 834                 return status;
 835         }
 836
 837         /* Return variables */
 838         *handle = *r.out.handle;
 839
 840         /* Return result */
 841         return werror_to_ntstatus(r.out.result);
 842 }
 843
 844 NTSTATUS rpccli_svcctl_OpenServiceA(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *scmanager_handle, const char *ServiceName, uint32_t access_mask)
 845 {
 846         struct svcctl_OpenServiceA r;
 847         NTSTATUS status;
 848
 849         /* In parameters */
 850         r.in.scmanager_handle = scmanager_handle;
 851         r.in.ServiceName = ServiceName;
 852         r.in.access_mask = access_mask;
 853
 854         if (DEBUGLEVEL >= 10)
 855                 NDR_PRINT_IN_DEBUG(svcctl_OpenServiceA, &r);
 856
 857         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_OPENSERVICEA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_OpenServiceA, (ndr_push_flags_fn_t)ndr_push_svcctl_OpenServiceA);
 858
 859         if (DEBUGLEVEL >= 10)
 860                 NDR_PRINT_OUT_DEBUG(svcctl_OpenServiceA, &r);
 861
 862         if (NT_STATUS_IS_ERR(status)) {
 863                 return status;
 864         }
 865
 866         /* Return variables */
 867
 868         /* Return result */
 869         return werror_to_ntstatus(r.out.result);
 870 }
 871
 872 NTSTATUS rpccli_svcctl_QueryServiceConfigA(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint8_t *query, uint32_t buf_size, uint32_t *bytes_needed)
 873 {
 874         struct svcctl_QueryServiceConfigA r;
 875         NTSTATUS status;
 876
 877         /* In parameters */
 878         r.in.handle = handle;
 879         r.in.buf_size = buf_size;
 880
 881         if (DEBUGLEVEL >= 10)
 882                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfigA, &r);
 883
 884         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_QUERYSERVICECONFIGA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_QueryServiceConfigA, (ndr_push_flags_fn_t)ndr_push_svcctl_QueryServiceConfigA);
 885
 886         if (DEBUGLEVEL >= 10)
 887                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfigA, &r);
 888
 889         if (NT_STATUS_IS_ERR(status)) {
 890                 return status;
 891         }
 892
 893         /* Return variables */
 894         *query = *r.out.query;
 895         *bytes_needed = *r.out.bytes_needed;
 896
 897         /* Return result */
 898         return werror_to_ntstatus(r.out.result);
 899 }
 900
 901 NTSTATUS rpccli_svcctl_QueryServiceLockStatusA(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t buf_size, struct SERVICE_LOCK_STATUS *status, uint32_t *required_buf_size)
 902 {
 903         struct svcctl_QueryServiceLockStatusA r;
 904         NTSTATUS status;
 905
 906         /* In parameters */
 907         r.in.handle = handle;
 908         r.in.buf_size = buf_size;
 909
 910         if (DEBUGLEVEL >= 10)
 911                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceLockStatusA, &r);
 912
 913         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_QUERYSERVICELOCKSTATUSA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_QueryServiceLockStatusA, (ndr_push_flags_fn_t)ndr_push_svcctl_QueryServiceLockStatusA);
 914
 915         if (DEBUGLEVEL >= 10)
 916                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceLockStatusA, &r);
 917
 918         if (NT_STATUS_IS_ERR(status)) {
 919                 return status;
 920         }
 921
 922         /* Return variables */
 923         *status = *r.out.status;
 924         *required_buf_size = *r.out.required_buf_size;
 925
 926         /* Return result */
 927         return werror_to_ntstatus(r.out.result);
 928 }
 929
 930 NTSTATUS rpccli_svcctl_StartServiceA(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t NumArgs, const char *Arguments)
 931 {
 932         struct svcctl_StartServiceA r;
 933         NTSTATUS status;
 934
 935         /* In parameters */
 936         r.in.handle = handle;
 937         r.in.NumArgs = NumArgs;
 938         r.in.Arguments = Arguments;
 939
 940         if (DEBUGLEVEL >= 10)
 941                 NDR_PRINT_IN_DEBUG(svcctl_StartServiceA, &r);
 942
 943         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_STARTSERVICEA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_StartServiceA, (ndr_push_flags_fn_t)ndr_push_svcctl_StartServiceA);
 944
 945         if (DEBUGLEVEL >= 10)
 946                 NDR_PRINT_OUT_DEBUG(svcctl_StartServiceA, &r);
 947
 948         if (NT_STATUS_IS_ERR(status)) {
 949                 return status;
 950         }
 951
 952         /* Return variables */
 953
 954         /* Return result */
 955         return werror_to_ntstatus(r.out.result);
 956 }
 957
 958 NTSTATUS rpccli_svcctl_GetServiceDisplayNameA(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, const char *service_name, const char **display_name, uint32_t *display_name_length)
 959 {
 960         struct svcctl_GetServiceDisplayNameA r;
 961         NTSTATUS status;
 962
 963         /* In parameters */
 964         r.in.handle = handle;
 965         r.in.service_name = service_name;
 966         r.in.display_name_length = display_name_length;
 967
 968         if (DEBUGLEVEL >= 10)
 969                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceDisplayNameA, &r);
 970
 971         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_GETSERVICEDISPLAYNAMEA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_GetServiceDisplayNameA, (ndr_push_flags_fn_t)ndr_push_svcctl_GetServiceDisplayNameA);
 972
 973         if (DEBUGLEVEL >= 10)
 974                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceDisplayNameA, &r);
 975
 976         if (NT_STATUS_IS_ERR(status)) {
 977                 return status;
 978         }
 979
 980         /* Return variables */
 981         *display_name = *r.out.display_name;
 982         *display_name_length = *r.out.display_name_length;
 983
 984         /* Return result */
 985         return werror_to_ntstatus(r.out.result);
 986 }
 987
 988 NTSTATUS rpccli_svcctl_GetServiceKeyNameA(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, const char *service_name, const char **key_name, uint32_t *display_name_length)
 989 {
 990         struct svcctl_GetServiceKeyNameA r;
 991         NTSTATUS status;
 992
 993         /* In parameters */
 994         r.in.handle = handle;
 995         r.in.service_name = service_name;
 996         r.in.display_name_length = display_name_length;
 997
 998         if (DEBUGLEVEL >= 10)
 999                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceKeyNameA, &r);
1000
1001         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_GETSERVICEKEYNAMEA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_GetServiceKeyNameA, (ndr_push_flags_fn_t)ndr_push_svcctl_GetServiceKeyNameA);
1002
1003         if (DEBUGLEVEL >= 10)
1004                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceKeyNameA, &r);
1005
1006         if (NT_STATUS_IS_ERR(status)) {
1007                 return status;
1008         }
1009
1010         /* Return variables */
1011         *key_name = *r.out.key_name;
1012         *display_name_length = *r.out.display_name_length;
1013
1014         /* Return result */
1015         return werror_to_ntstatus(r.out.result);
1016 }
1017
1018 NTSTATUS rpccli_svcctl_GetCurrentGroupeStateW(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx)
1019 {
1020         struct svcctl_GetCurrentGroupeStateW r;
1021         NTSTATUS status;
1022
1023         /* In parameters */
1024
1025         if (DEBUGLEVEL >= 10)
1026                 NDR_PRINT_IN_DEBUG(svcctl_GetCurrentGroupeStateW, &r);
1027
1028         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_GETCURRENTGROUPESTATEW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_GetCurrentGroupeStateW, (ndr_push_flags_fn_t)ndr_push_svcctl_GetCurrentGroupeStateW);
1029
1030         if (DEBUGLEVEL >= 10)
1031                 NDR_PRINT_OUT_DEBUG(svcctl_GetCurrentGroupeStateW, &r);
1032
1033         if (NT_STATUS_IS_ERR(status)) {
1034                 return status;
1035         }
1036
1037         /* Return variables */
1038
1039         /* Return result */
1040         return werror_to_ntstatus(r.out.result);
1041 }
1042
1043 NTSTATUS rpccli_svcctl_EnumServiceGroupW(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx)
1044 {
1045         struct svcctl_EnumServiceGroupW r;
1046         NTSTATUS status;
1047
1048         /* In parameters */
1049
1050         if (DEBUGLEVEL >= 10)
1051                 NDR_PRINT_IN_DEBUG(svcctl_EnumServiceGroupW, &r);
1052
1053         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_ENUMSERVICEGROUPW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_EnumServiceGroupW, (ndr_push_flags_fn_t)ndr_push_svcctl_EnumServiceGroupW);
1054
1055         if (DEBUGLEVEL >= 10)
1056                 NDR_PRINT_OUT_DEBUG(svcctl_EnumServiceGroupW, &r);
1057
1058         if (NT_STATUS_IS_ERR(status)) {
1059                 return status;
1060         }
1061
1062         /* Return variables */
1063
1064         /* Return result */
1065         return werror_to_ntstatus(r.out.result);
1066 }
1067
1068 NTSTATUS rpccli_svcctl_ChangeServiceConfig2A(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t info_level, uint8_t *info)
1069 {
1070         struct svcctl_ChangeServiceConfig2A r;
1071         NTSTATUS status;
1072
1073         /* In parameters */
1074         r.in.handle = handle;
1075         r.in.info_level = info_level;
1076         r.in.info = info;
1077
1078         if (DEBUGLEVEL >= 10)
1079                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfig2A, &r);
1080
1081         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_CHANGESERVICECONFIG2A, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_ChangeServiceConfig2A, (ndr_push_flags_fn_t)ndr_push_svcctl_ChangeServiceConfig2A);
1082
1083         if (DEBUGLEVEL >= 10)
1084                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfig2A, &r);
1085
1086         if (NT_STATUS_IS_ERR(status)) {
1087                 return status;
1088         }
1089
1090         /* Return variables */
1091
1092         /* Return result */
1093         return werror_to_ntstatus(r.out.result);
1094 }
1095
1096 NTSTATUS rpccli_svcctl_ChangeServiceConfig2W(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t info_level, uint8_t *info)
1097 {
1098         struct svcctl_ChangeServiceConfig2W r;
1099         NTSTATUS status;
1100
1101         /* In parameters */
1102         r.in.handle = handle;
1103         r.in.info_level = info_level;
1104         r.in.info = info;
1105
1106         if (DEBUGLEVEL >= 10)
1107                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfig2W, &r);
1108
1109         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_CHANGESERVICECONFIG2W, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_ChangeServiceConfig2W, (ndr_push_flags_fn_t)ndr_push_svcctl_ChangeServiceConfig2W);
1110
1111         if (DEBUGLEVEL >= 10)
1112                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfig2W, &r);
1113
1114         if (NT_STATUS_IS_ERR(status)) {
1115                 return status;
1116         }
1117
1118         /* Return variables */
1119
1120         /* Return result */
1121         return werror_to_ntstatus(r.out.result);
1122 }
1123
1124 NTSTATUS rpccli_svcctl_QueryServiceConfig2A(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t info_level, uint8_t *buffer, uint32_t buf_size, uint32_t *bytes_needed)
1125 {
1126         struct svcctl_QueryServiceConfig2A r;
1127         NTSTATUS status;
1128
1129         /* In parameters */
1130         r.in.handle = handle;
1131         r.in.info_level = info_level;
1132         r.in.buf_size = buf_size;
1133
1134         if (DEBUGLEVEL >= 10)
1135                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfig2A, &r);
1136
1137         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_QUERYSERVICECONFIG2A, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_QueryServiceConfig2A, (ndr_push_flags_fn_t)ndr_push_svcctl_QueryServiceConfig2A);
1138
1139         if (DEBUGLEVEL >= 10)
1140                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfig2A, &r);
1141
1142         if (NT_STATUS_IS_ERR(status)) {
1143                 return status;
1144         }
1145
1146         /* Return variables */
1147         *buffer = *r.out.buffer;
1148         *bytes_needed = *r.out.bytes_needed;
1149
1150         /* Return result */
1151         return werror_to_ntstatus(r.out.result);
1152 }
1153
1154 NTSTATUS rpccli_svcctl_QueryServiceConfig2W(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t info_level, uint8_t *buffer, uint32_t buf_size, uint32_t *bytes_needed)
1155 {
1156         struct svcctl_QueryServiceConfig2W r;
1157         NTSTATUS status;
1158
1159         /* In parameters */
1160         r.in.handle = handle;
1161         r.in.info_level = info_level;
1162         r.in.buf_size = buf_size;
1163
1164         if (DEBUGLEVEL >= 10)
1165                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfig2W, &r);
1166
1167         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_QUERYSERVICECONFIG2W, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_QueryServiceConfig2W, (ndr_push_flags_fn_t)ndr_push_svcctl_QueryServiceConfig2W);
1168
1169         if (DEBUGLEVEL >= 10)
1170                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfig2W, &r);
1171
1172         if (NT_STATUS_IS_ERR(status)) {
1173                 return status;
1174         }
1175
1176         /* Return variables */
1177         *buffer = *r.out.buffer;
1178         *bytes_needed = *r.out.bytes_needed;
1179
1180         /* Return result */
1181         return werror_to_ntstatus(r.out.result);
1182 }
1183
1184 NTSTATUS rpccli_svcctl_QueryServiceStatusEx(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t info_level, uint8_t *buffer, uint32_t buf_size, uint32_t *bytes_needed)
1185 {
1186         struct svcctl_QueryServiceStatusEx r;
1187         NTSTATUS status;
1188
1189         /* In parameters */
1190         r.in.handle = handle;
1191         r.in.info_level = info_level;
1192         r.in.buf_size = buf_size;
1193
1194         if (DEBUGLEVEL >= 10)
1195                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceStatusEx, &r);
1196
1197         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_QUERYSERVICESTATUSEX, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_QueryServiceStatusEx, (ndr_push_flags_fn_t)ndr_push_svcctl_QueryServiceStatusEx);
1198
1199         if (DEBUGLEVEL >= 10)
1200                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceStatusEx, &r);
1201
1202         if (NT_STATUS_IS_ERR(status)) {
1203                 return status;
1204         }
1205
1206         /* Return variables */
1207         *buffer = *r.out.buffer;
1208         *bytes_needed = *r.out.bytes_needed;
1209
1210         /* Return result */
1211         return werror_to_ntstatus(r.out.result);
1212 }
1213
1214 NTSTATUS rpccli_EnumServicesStatusExA(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *scmanager, uint32_t info_level, uint32_t type, uint32_t state, uint8_t *services, uint32_t buf_size, uint32_t *bytes_needed, uint32_t *service_returned, uint32_t *resume_handle, const char **group_name)
1215 {
1216         struct EnumServicesStatusExA r;
1217         NTSTATUS status;
1218
1219         /* In parameters */
1220         r.in.scmanager = scmanager;
1221         r.in.info_level = info_level;
1222         r.in.type = type;
1223         r.in.state = state;
1224         r.in.buf_size = buf_size;
1225         r.in.resume_handle = resume_handle;
1226
1227         if (DEBUGLEVEL >= 10)
1228                 NDR_PRINT_IN_DEBUG(EnumServicesStatusExA, &r);
1229
1230         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_ENUMSERVICESSTATUSEXA, &r, (ndr_pull_flags_fn_t)ndr_pull_EnumServicesStatusExA, (ndr_push_flags_fn_t)ndr_push_EnumServicesStatusExA);
1231
1232         if (DEBUGLEVEL >= 10)
1233                 NDR_PRINT_OUT_DEBUG(EnumServicesStatusExA, &r);
1234
1235         if (NT_STATUS_IS_ERR(status)) {
1236                 return status;
1237         }
1238
1239         /* Return variables */
1240         *services = *r.out.services;
1241         *bytes_needed = *r.out.bytes_needed;
1242         *service_returned = *r.out.service_returned;
1243         *resume_handle = *r.out.resume_handle;
1244         *group_name = *r.out.group_name;
1245
1246         /* Return result */
1247         return werror_to_ntstatus(r.out.result);
1248 }
1249
1250 NTSTATUS rpccli_EnumServicesStatusExW(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *scmanager, uint32_t info_level, uint32_t type, uint32_t state, uint8_t *services, uint32_t buf_size, uint32_t *bytes_needed, uint32_t *service_returned, uint32_t *resume_handle, const char **group_name)
1251 {
1252         struct EnumServicesStatusExW r;
1253         NTSTATUS status;
1254
1255         /* In parameters */
1256         r.in.scmanager = scmanager;
1257         r.in.info_level = info_level;
1258         r.in.type = type;
1259         r.in.state = state;
1260         r.in.buf_size = buf_size;
1261         r.in.resume_handle = resume_handle;
1262
1263         if (DEBUGLEVEL >= 10)
1264                 NDR_PRINT_IN_DEBUG(EnumServicesStatusExW, &r);
1265
1266         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_ENUMSERVICESSTATUSEXW, &r, (ndr_pull_flags_fn_t)ndr_pull_EnumServicesStatusExW, (ndr_push_flags_fn_t)ndr_push_EnumServicesStatusExW);
1267
1268         if (DEBUGLEVEL >= 10)
1269                 NDR_PRINT_OUT_DEBUG(EnumServicesStatusExW, &r);
1270
1271         if (NT_STATUS_IS_ERR(status)) {
1272                 return status;
1273         }
1274
1275         /* Return variables */
1276         *services = *r.out.services;
1277         *bytes_needed = *r.out.bytes_needed;
1278         *service_returned = *r.out.service_returned;
1279         *resume_handle = *r.out.resume_handle;
1280         *group_name = *r.out.group_name;
1281
1282         /* Return result */
1283         return werror_to_ntstatus(r.out.result);
1284 }
1285
1286 NTSTATUS rpccli_svcctl_SCSendTSMessage(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx)
1287 {
1288         struct svcctl_SCSendTSMessage r;
1289         NTSTATUS status;
1290
1291         /* In parameters */
1292
1293         if (DEBUGLEVEL >= 10)
1294                 NDR_PRINT_IN_DEBUG(svcctl_SCSendTSMessage, &r);
1295
1296         status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_SCSENDTSMESSAGE, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_SCSendTSMessage, (ndr_push_flags_fn_t)ndr_push_svcctl_SCSendTSMessage);
1297
1298         if (DEBUGLEVEL >= 10)
1299                 NDR_PRINT_OUT_DEBUG(svcctl_SCSendTSMessage, &r);
1300
1301         if (NT_STATUS_IS_ERR(status)) {
1302                 return status;
1303         }
1304
1305         /* Return variables */
1306
1307         /* Return result */
1308         return werror_to_ntstatus(r.out.result);
1309 }
1310