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 ( !NT_STATUS_IS_OK(status) ) {
  23                 return status;
  24         }
  25
  26         if (DEBUGLEVEL >= 10)
  27                 NDR_PRINT_OUT_DEBUG(svcctl_CloseServiceHandle, &r);
  28
  29         if (NT_STATUS_IS_ERR(status)) {
  30                 return status;
  31         }
  32
  33         /* Return variables */
  34         *handle = *r.out.handle;
  35
  36         /* Return result */
  37         return werror_to_ntstatus(r.out.result);
  38 }
  39
  40 NTSTATUS rpccli_svcctl_ControlService(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t control, struct SERVICE_STATUS *status)
  41 {
  42         struct svcctl_ControlService r;
  43         NTSTATUS status;
  44
  45         /* In parameters */
  46         r.in.handle = handle;
  47         r.in.control = control;
  48
  49         if (DEBUGLEVEL >= 10)
  50                 NDR_PRINT_IN_DEBUG(svcctl_ControlService, &r);
  51
  52         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);
  53
  54         if ( !NT_STATUS_IS_OK(status) ) {
  55                 return status;
  56         }
  57
  58         if (DEBUGLEVEL >= 10)
  59                 NDR_PRINT_OUT_DEBUG(svcctl_ControlService, &r);
  60
  61         if (NT_STATUS_IS_ERR(status)) {
  62                 return status;
  63         }
  64
  65         /* Return variables */
  66         *status = *r.out.status;
  67
  68         /* Return result */
  69         return werror_to_ntstatus(r.out.result);
  70 }
  71
  72 NTSTATUS rpccli_svcctl_DeleteService(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle)
  73 {
  74         struct svcctl_DeleteService r;
  75         NTSTATUS status;
  76
  77         /* In parameters */
  78         r.in.handle = handle;
  79
  80         if (DEBUGLEVEL >= 10)
  81                 NDR_PRINT_IN_DEBUG(svcctl_DeleteService, &r);
  82
  83         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);
  84
  85         if ( !NT_STATUS_IS_OK(status) ) {
  86                 return status;
  87         }
  88
  89         if (DEBUGLEVEL >= 10)
  90                 NDR_PRINT_OUT_DEBUG(svcctl_DeleteService, &r);
  91
  92         if (NT_STATUS_IS_ERR(status)) {
  93                 return status;
  94         }
  95
  96         /* Return variables */
  97
  98         /* Return result */
  99         return werror_to_ntstatus(r.out.result);
 100 }
 101
 102 NTSTATUS rpccli_svcctl_LockServiceDatabase(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct policy_handle *lock)
 103 {
 104         struct svcctl_LockServiceDatabase r;
 105         NTSTATUS status;
 106
 107         /* In parameters */
 108         r.in.handle = handle;
 109
 110         if (DEBUGLEVEL >= 10)
 111                 NDR_PRINT_IN_DEBUG(svcctl_LockServiceDatabase, &r);
 112
 113         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);
 114
 115         if ( !NT_STATUS_IS_OK(status) ) {
 116                 return status;
 117         }
 118
 119         if (DEBUGLEVEL >= 10)
 120                 NDR_PRINT_OUT_DEBUG(svcctl_LockServiceDatabase, &r);
 121
 122         if (NT_STATUS_IS_ERR(status)) {
 123                 return status;
 124         }
 125
 126         /* Return variables */
 127         *lock = *r.out.lock;
 128
 129         /* Return result */
 130         return werror_to_ntstatus(r.out.result);
 131 }
 132
 133 NTSTATUS rpccli_svcctl_QueryServiceObjectSecurity(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx)
 134 {
 135         struct svcctl_QueryServiceObjectSecurity r;
 136         NTSTATUS status;
 137
 138         /* In parameters */
 139
 140         if (DEBUGLEVEL >= 10)
 141                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceObjectSecurity, &r);
 142
 143         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);
 144
 145         if ( !NT_STATUS_IS_OK(status) ) {
 146                 return status;
 147         }
 148
 149         if (DEBUGLEVEL >= 10)
 150                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceObjectSecurity, &r);
 151
 152         if (NT_STATUS_IS_ERR(status)) {
 153                 return status;
 154         }
 155
 156         /* Return variables */
 157
 158         /* Return result */
 159         return werror_to_ntstatus(r.out.result);
 160 }
 161
 162 NTSTATUS rpccli_svcctl_SetServiceObjectSecurity(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx)
 163 {
 164         struct svcctl_SetServiceObjectSecurity r;
 165         NTSTATUS status;
 166
 167         /* In parameters */
 168
 169         if (DEBUGLEVEL >= 10)
 170                 NDR_PRINT_IN_DEBUG(svcctl_SetServiceObjectSecurity, &r);
 171
 172         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);
 173
 174         if ( !NT_STATUS_IS_OK(status) ) {
 175                 return status;
 176         }
 177
 178         if (DEBUGLEVEL >= 10)
 179                 NDR_PRINT_OUT_DEBUG(svcctl_SetServiceObjectSecurity, &r);
 180
 181         if (NT_STATUS_IS_ERR(status)) {
 182                 return status;
 183         }
 184
 185         /* Return variables */
 186
 187         /* Return result */
 188         return werror_to_ntstatus(r.out.result);
 189 }
 190
 191 NTSTATUS rpccli_svcctl_QueryServiceStatus(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct SERVICE_STATUS *status)
 192 {
 193         struct svcctl_QueryServiceStatus r;
 194         NTSTATUS status;
 195
 196         /* In parameters */
 197         r.in.handle = handle;
 198
 199         if (DEBUGLEVEL >= 10)
 200                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceStatus, &r);
 201
 202         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);
 203
 204         if ( !NT_STATUS_IS_OK(status) ) {
 205                 return status;
 206         }
 207
 208         if (DEBUGLEVEL >= 10)
 209                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceStatus, &r);
 210
 211         if (NT_STATUS_IS_ERR(status)) {
 212                 return status;
 213         }
 214
 215         /* Return variables */
 216         *status = *r.out.status;
 217
 218         /* Return result */
 219         return werror_to_ntstatus(r.out.result);
 220 }
 221
 222 NTSTATUS rpccli_svcctl_SetServiceStatus(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx)
 223 {
 224         struct svcctl_SetServiceStatus r;
 225         NTSTATUS status;
 226
 227         /* In parameters */
 228
 229         if (DEBUGLEVEL >= 10)
 230                 NDR_PRINT_IN_DEBUG(svcctl_SetServiceStatus, &r);
 231
 232         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);
 233
 234         if ( !NT_STATUS_IS_OK(status) ) {
 235                 return status;
 236         }
 237
 238         if (DEBUGLEVEL >= 10)
 239                 NDR_PRINT_OUT_DEBUG(svcctl_SetServiceStatus, &r);
 240
 241         if (NT_STATUS_IS_ERR(status)) {
 242                 return status;
 243         }
 244
 245         /* Return variables */
 246
 247         /* Return result */
 248         return werror_to_ntstatus(r.out.result);
 249 }
 250
 251 NTSTATUS rpccli_svcctl_UnlockServiceDatabase(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *lock)
 252 {
 253         struct svcctl_UnlockServiceDatabase r;
 254         NTSTATUS status;
 255
 256         /* In parameters */
 257         r.in.lock = lock;
 258
 259         if (DEBUGLEVEL >= 10)
 260                 NDR_PRINT_IN_DEBUG(svcctl_UnlockServiceDatabase, &r);
 261
 262         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);
 263
 264         if ( !NT_STATUS_IS_OK(status) ) {
 265                 return status;
 266         }
 267
 268         if (DEBUGLEVEL >= 10)
 269                 NDR_PRINT_OUT_DEBUG(svcctl_UnlockServiceDatabase, &r);
 270
 271         if (NT_STATUS_IS_ERR(status)) {
 272                 return status;
 273         }
 274
 275         /* Return variables */
 276         *lock = *r.out.lock;
 277
 278         /* Return result */
 279         return werror_to_ntstatus(r.out.result);
 280 }
 281
 282 NTSTATUS rpccli_svcctl_NotifyBootConfigStatus(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx)
 283 {
 284         struct svcctl_NotifyBootConfigStatus r;
 285         NTSTATUS status;
 286
 287         /* In parameters */
 288
 289         if (DEBUGLEVEL >= 10)
 290                 NDR_PRINT_IN_DEBUG(svcctl_NotifyBootConfigStatus, &r);
 291
 292         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);
 293
 294         if ( !NT_STATUS_IS_OK(status) ) {
 295                 return status;
 296         }
 297
 298         if (DEBUGLEVEL >= 10)
 299                 NDR_PRINT_OUT_DEBUG(svcctl_NotifyBootConfigStatus, &r);
 300
 301         if (NT_STATUS_IS_ERR(status)) {
 302                 return status;
 303         }
 304
 305         /* Return variables */
 306
 307         /* Return result */
 308         return werror_to_ntstatus(r.out.result);
 309 }
 310
 311 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)
 312 {
 313         struct svcctl_SCSetServiceBitsW r;
 314         NTSTATUS status;
 315
 316         /* In parameters */
 317         r.in.handle = handle;
 318         r.in.bits = bits;
 319         r.in.bitson = bitson;
 320         r.in.immediate = immediate;
 321
 322         if (DEBUGLEVEL >= 10)
 323                 NDR_PRINT_IN_DEBUG(svcctl_SCSetServiceBitsW, &r);
 324
 325         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);
 326
 327         if ( !NT_STATUS_IS_OK(status) ) {
 328                 return status;
 329         }
 330
 331         if (DEBUGLEVEL >= 10)
 332                 NDR_PRINT_OUT_DEBUG(svcctl_SCSetServiceBitsW, &r);
 333
 334         if (NT_STATUS_IS_ERR(status)) {
 335                 return status;
 336         }
 337
 338         /* Return variables */
 339
 340         /* Return result */
 341         return werror_to_ntstatus(r.out.result);
 342 }
 343
 344 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)
 345 {
 346         struct svcctl_ChangeServiceConfigW r;
 347         NTSTATUS status;
 348
 349         /* In parameters */
 350         r.in.handle = handle;
 351         r.in.type = type;
 352         r.in.start = start;
 353         r.in.error = error;
 354         r.in.binary_path = binary_path;
 355         r.in.load_order_group = load_order_group;
 356         r.in.dependencies = dependencies;
 357         r.in.service_start_name = service_start_name;
 358         r.in.password = password;
 359         r.in.display_name = display_name;
 360
 361         if (DEBUGLEVEL >= 10)
 362                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfigW, &r);
 363
 364         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);
 365
 366         if ( !NT_STATUS_IS_OK(status) ) {
 367                 return status;
 368         }
 369
 370         if (DEBUGLEVEL >= 10)
 371                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfigW, &r);
 372
 373         if (NT_STATUS_IS_ERR(status)) {
 374                 return status;
 375         }
 376
 377         /* Return variables */
 378         *tag_id = *r.out.tag_id;
 379
 380         /* Return result */
 381         return werror_to_ntstatus(r.out.result);
 382 }
 383
 384 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)
 385 {
 386         struct svcctl_CreateServiceW r;
 387         NTSTATUS status;
 388
 389         /* In parameters */
 390         r.in.scmanager_handle = scmanager_handle;
 391         r.in.ServiceName = ServiceName;
 392         r.in.DisplayName = DisplayName;
 393         r.in.desired_access = desired_access;
 394         r.in.type = type;
 395         r.in.start_type = start_type;
 396         r.in.error_control = error_control;
 397         r.in.binary_path = binary_path;
 398         r.in.LoadOrderGroupKey = LoadOrderGroupKey;
 399         r.in.TagId = TagId;
 400         r.in.dependencies = dependencies;
 401         r.in.dependencies_size = dependencies_size;
 402         r.in.service_start_name = service_start_name;
 403         r.in.password = password;
 404         r.in.password_size = password_size;
 405
 406         if (DEBUGLEVEL >= 10)
 407                 NDR_PRINT_IN_DEBUG(svcctl_CreateServiceW, &r);
 408
 409         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);
 410
 411         if ( !NT_STATUS_IS_OK(status) ) {
 412                 return status;
 413         }
 414
 415         if (DEBUGLEVEL >= 10)
 416                 NDR_PRINT_OUT_DEBUG(svcctl_CreateServiceW, &r);
 417
 418         if (NT_STATUS_IS_ERR(status)) {
 419                 return status;
 420         }
 421
 422         /* Return variables */
 423         if ( TagId ) {
 424                 *TagId = *r.out.TagId;
 425         }
 426         *handle = *r.out.handle;
 427
 428         /* Return result */
 429         return werror_to_ntstatus(r.out.result);
 430 }
 431
 432 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)
 433 {
 434         struct svcctl_EnumDependentServicesW r;
 435         NTSTATUS status;
 436
 437         /* In parameters */
 438         r.in.service = service;
 439         r.in.state = state;
 440         r.in.buf_size = buf_size;
 441
 442         if (DEBUGLEVEL >= 10)
 443                 NDR_PRINT_IN_DEBUG(svcctl_EnumDependentServicesW, &r);
 444
 445         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);
 446
 447         if ( !NT_STATUS_IS_OK(status) ) {
 448                 return status;
 449         }
 450
 451         if (DEBUGLEVEL >= 10)
 452                 NDR_PRINT_OUT_DEBUG(svcctl_EnumDependentServicesW, &r);
 453
 454         if (NT_STATUS_IS_ERR(status)) {
 455                 return status;
 456         }
 457
 458         /* Return variables */
 459         if ( status ) {
 460                 *status = *r.out.status;
 461         }
 462         *bytes_needed = *r.out.bytes_needed;
 463         *services_returned = *r.out.services_returned;
 464
 465         /* Return result */
 466         return werror_to_ntstatus(r.out.result);
 467 }
 468
 469 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)
 470 {
 471         struct svcctl_EnumServicesStatusW r;
 472         NTSTATUS status;
 473
 474         /* In parameters */
 475         r.in.handle = handle;
 476         r.in.type = type;
 477         r.in.state = state;
 478         r.in.buf_size = buf_size;
 479         r.in.resume_handle = resume_handle;
 480
 481         if (DEBUGLEVEL >= 10)
 482                 NDR_PRINT_IN_DEBUG(svcctl_EnumServicesStatusW, &r);
 483
 484         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);
 485
 486         if ( !NT_STATUS_IS_OK(status) ) {
 487                 return status;
 488         }
 489
 490         if (DEBUGLEVEL >= 10)
 491                 NDR_PRINT_OUT_DEBUG(svcctl_EnumServicesStatusW, &r);
 492
 493         if (NT_STATUS_IS_ERR(status)) {
 494                 return status;
 495         }
 496
 497         /* Return variables */
 498         *service = *r.out.service;
 499         *bytes_needed = *r.out.bytes_needed;
 500         *services_returned = *r.out.services_returned;
 501         if ( resume_handle ) {
 502                 *resume_handle = *r.out.resume_handle;
 503         }
 504
 505         /* Return result */
 506         return werror_to_ntstatus(r.out.result);
 507 }
 508
 509 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)
 510 {
 511         struct svcctl_OpenSCManagerW r;
 512         NTSTATUS status;
 513
 514         /* In parameters */
 515         r.in.MachineName = MachineName;
 516         r.in.DatabaseName = DatabaseName;
 517         r.in.access_mask = access_mask;
 518
 519         if (DEBUGLEVEL >= 10)
 520                 NDR_PRINT_IN_DEBUG(svcctl_OpenSCManagerW, &r);
 521
 522         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);
 523
 524         if ( !NT_STATUS_IS_OK(status) ) {
 525                 return status;
 526         }
 527
 528         if (DEBUGLEVEL >= 10)
 529                 NDR_PRINT_OUT_DEBUG(svcctl_OpenSCManagerW, &r);
 530
 531         if (NT_STATUS_IS_ERR(status)) {
 532                 return status;
 533         }
 534
 535         /* Return variables */
 536         *handle = *r.out.handle;
 537
 538         /* Return result */
 539         return werror_to_ntstatus(r.out.result);
 540 }
 541
 542 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)
 543 {
 544         struct svcctl_OpenServiceW r;
 545         NTSTATUS status;
 546
 547         /* In parameters */
 548         r.in.scmanager_handle = scmanager_handle;
 549         r.in.ServiceName = ServiceName;
 550         r.in.access_mask = access_mask;
 551
 552         if (DEBUGLEVEL >= 10)
 553                 NDR_PRINT_IN_DEBUG(svcctl_OpenServiceW, &r);
 554
 555         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);
 556
 557         if ( !NT_STATUS_IS_OK(status) ) {
 558                 return status;
 559         }
 560
 561         if (DEBUGLEVEL >= 10)
 562                 NDR_PRINT_OUT_DEBUG(svcctl_OpenServiceW, &r);
 563
 564         if (NT_STATUS_IS_ERR(status)) {
 565                 return status;
 566         }
 567
 568         /* Return variables */
 569         *handle = *r.out.handle;
 570
 571         /* Return result */
 572         return werror_to_ntstatus(r.out.result);
 573 }
 574
 575 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)
 576 {
 577         struct svcctl_QueryServiceConfigW r;
 578         NTSTATUS status;
 579
 580         /* In parameters */
 581         r.in.handle = handle;
 582         r.in.buf_size = buf_size;
 583
 584         if (DEBUGLEVEL >= 10)
 585                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfigW, &r);
 586
 587         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);
 588
 589         if ( !NT_STATUS_IS_OK(status) ) {
 590                 return status;
 591         }
 592
 593         if (DEBUGLEVEL >= 10)
 594                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfigW, &r);
 595
 596         if (NT_STATUS_IS_ERR(status)) {
 597                 return status;
 598         }
 599
 600         /* Return variables */
 601         *query = *r.out.query;
 602         *bytes_needed = *r.out.bytes_needed;
 603
 604         /* Return result */
 605         return werror_to_ntstatus(r.out.result);
 606 }
 607
 608 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)
 609 {
 610         struct svcctl_QueryServiceLockStatusW r;
 611         NTSTATUS status;
 612
 613         /* In parameters */
 614         r.in.handle = handle;
 615         r.in.buf_size = buf_size;
 616
 617         if (DEBUGLEVEL >= 10)
 618                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceLockStatusW, &r);
 619
 620         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);
 621
 622         if ( !NT_STATUS_IS_OK(status) ) {
 623                 return status;
 624         }
 625
 626         if (DEBUGLEVEL >= 10)
 627                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceLockStatusW, &r);
 628
 629         if (NT_STATUS_IS_ERR(status)) {
 630                 return status;
 631         }
 632
 633         /* Return variables */
 634         *status = *r.out.status;
 635         *required_buf_size = *r.out.required_buf_size;
 636
 637         /* Return result */
 638         return werror_to_ntstatus(r.out.result);
 639 }
 640
 641 NTSTATUS rpccli_svcctl_StartServiceW(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t NumArgs, const char *Arguments)
 642 {
 643         struct svcctl_StartServiceW r;
 644         NTSTATUS status;
 645
 646         /* In parameters */
 647         r.in.handle = handle;
 648         r.in.NumArgs = NumArgs;
 649         r.in.Arguments = Arguments;
 650
 651         if (DEBUGLEVEL >= 10)
 652                 NDR_PRINT_IN_DEBUG(svcctl_StartServiceW, &r);
 653
 654         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);
 655
 656         if ( !NT_STATUS_IS_OK(status) ) {
 657                 return status;
 658         }
 659
 660         if (DEBUGLEVEL >= 10)
 661                 NDR_PRINT_OUT_DEBUG(svcctl_StartServiceW, &r);
 662
 663         if (NT_STATUS_IS_ERR(status)) {
 664                 return status;
 665         }
 666
 667         /* Return variables */
 668
 669         /* Return result */
 670         return werror_to_ntstatus(r.out.result);
 671 }
 672
 673 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)
 674 {
 675         struct svcctl_GetServiceDisplayNameW r;
 676         NTSTATUS status;
 677
 678         /* In parameters */
 679         r.in.handle = handle;
 680         r.in.service_name = service_name;
 681         r.in.display_name_length = display_name_length;
 682
 683         if (DEBUGLEVEL >= 10)
 684                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceDisplayNameW, &r);
 685
 686         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);
 687
 688         if ( !NT_STATUS_IS_OK(status) ) {
 689                 return status;
 690         }
 691
 692         if (DEBUGLEVEL >= 10)
 693                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceDisplayNameW, &r);
 694
 695         if (NT_STATUS_IS_ERR(status)) {
 696                 return status;
 697         }
 698
 699         /* Return variables */
 700         *display_name = *r.out.display_name;
 701         if ( display_name_length ) {
 702                 *display_name_length = *r.out.display_name_length;
 703         }
 704
 705         /* Return result */
 706         return werror_to_ntstatus(r.out.result);
 707 }
 708
 709 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)
 710 {
 711         struct svcctl_GetServiceKeyNameW r;
 712         NTSTATUS status;
 713
 714         /* In parameters */
 715         r.in.handle = handle;
 716         r.in.service_name = service_name;
 717         r.in.display_name_length = display_name_length;
 718
 719         if (DEBUGLEVEL >= 10)
 720                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceKeyNameW, &r);
 721
 722         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);
 723
 724         if ( !NT_STATUS_IS_OK(status) ) {
 725                 return status;
 726         }
 727
 728         if (DEBUGLEVEL >= 10)
 729                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceKeyNameW, &r);
 730
 731         if (NT_STATUS_IS_ERR(status)) {
 732                 return status;
 733         }
 734
 735         /* Return variables */
 736         *key_name = *r.out.key_name;
 737         if ( display_name_length ) {
 738                 *display_name_length = *r.out.display_name_length;
 739         }
 740
 741         /* Return result */
 742         return werror_to_ntstatus(r.out.result);
 743 }
 744
 745 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)
 746 {
 747         struct svcctl_SCSetServiceBitsA r;
 748         NTSTATUS status;
 749
 750         /* In parameters */
 751         r.in.handle = handle;
 752         r.in.bits = bits;
 753         r.in.bitson = bitson;
 754         r.in.immediate = immediate;
 755
 756         if (DEBUGLEVEL >= 10)
 757                 NDR_PRINT_IN_DEBUG(svcctl_SCSetServiceBitsA, &r);
 758
 759         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);
 760
 761         if ( !NT_STATUS_IS_OK(status) ) {
 762                 return status;
 763         }
 764
 765         if (DEBUGLEVEL >= 10)
 766                 NDR_PRINT_OUT_DEBUG(svcctl_SCSetServiceBitsA, &r);
 767
 768         if (NT_STATUS_IS_ERR(status)) {
 769                 return status;
 770         }
 771
 772         /* Return variables */
 773
 774         /* Return result */
 775         return werror_to_ntstatus(r.out.result);
 776 }
 777
 778 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)
 779 {
 780         struct svcctl_ChangeServiceConfigA r;
 781         NTSTATUS status;
 782
 783         /* In parameters */
 784         r.in.handle = handle;
 785         r.in.type = type;
 786         r.in.start = start;
 787         r.in.error = error;
 788         r.in.binary_path = binary_path;
 789         r.in.load_order_group = load_order_group;
 790         r.in.dependencies = dependencies;
 791         r.in.service_start_name = service_start_name;
 792         r.in.password = password;
 793         r.in.display_name = display_name;
 794
 795         if (DEBUGLEVEL >= 10)
 796                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfigA, &r);
 797
 798         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);
 799
 800         if ( !NT_STATUS_IS_OK(status) ) {
 801                 return status;
 802         }
 803
 804         if (DEBUGLEVEL >= 10)
 805                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfigA, &r);
 806
 807         if (NT_STATUS_IS_ERR(status)) {
 808                 return status;
 809         }
 810
 811         /* Return variables */
 812         *tag_id = *r.out.tag_id;
 813
 814         /* Return result */
 815         return werror_to_ntstatus(r.out.result);
 816 }
 817
 818 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)
 819 {
 820         struct svcctl_CreateServiceA r;
 821         NTSTATUS status;
 822
 823         /* In parameters */
 824         r.in.handle = handle;
 825         r.in.ServiceName = ServiceName;
 826         r.in.DisplayName = DisplayName;
 827         r.in.desired_access = desired_access;
 828         r.in.type = type;
 829         r.in.start_type = start_type;
 830         r.in.error_control = error_control;
 831         r.in.binary_path = binary_path;
 832         r.in.LoadOrderGroupKey = LoadOrderGroupKey;
 833         r.in.dependencies = dependencies;
 834         r.in.service_start_name = service_start_name;
 835         r.in.password = password;
 836
 837         if (DEBUGLEVEL >= 10)
 838                 NDR_PRINT_IN_DEBUG(svcctl_CreateServiceA, &r);
 839
 840         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);
 841
 842         if ( !NT_STATUS_IS_OK(status) ) {
 843                 return status;
 844         }
 845
 846         if (DEBUGLEVEL >= 10)
 847                 NDR_PRINT_OUT_DEBUG(svcctl_CreateServiceA, &r);
 848
 849         if (NT_STATUS_IS_ERR(status)) {
 850                 return status;
 851         }
 852
 853         /* Return variables */
 854         if ( TagId ) {
 855                 *TagId = *r.out.TagId;
 856         }
 857
 858         /* Return result */
 859         return werror_to_ntstatus(r.out.result);
 860 }
 861
 862 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)
 863 {
 864         struct svcctl_EnumDependentServicesA r;
 865         NTSTATUS status;
 866
 867         /* In parameters */
 868         r.in.service = service;
 869         r.in.state = state;
 870         r.in.buf_size = buf_size;
 871
 872         if (DEBUGLEVEL >= 10)
 873                 NDR_PRINT_IN_DEBUG(svcctl_EnumDependentServicesA, &r);
 874
 875         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);
 876
 877         if ( !NT_STATUS_IS_OK(status) ) {
 878                 return status;
 879         }
 880
 881         if (DEBUGLEVEL >= 10)
 882                 NDR_PRINT_OUT_DEBUG(svcctl_EnumDependentServicesA, &r);
 883
 884         if (NT_STATUS_IS_ERR(status)) {
 885                 return status;
 886         }
 887
 888         /* Return variables */
 889         if ( status ) {
 890                 *status = *r.out.status;
 891         }
 892         *bytes_needed = *r.out.bytes_needed;
 893         *services_returned = *r.out.services_returned;
 894
 895         /* Return result */
 896         return werror_to_ntstatus(r.out.result);
 897 }
 898
 899 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)
 900 {
 901         struct svcctl_EnumServicesStatusA r;
 902         NTSTATUS status;
 903
 904         /* In parameters */
 905         r.in.handle = handle;
 906         r.in.type = type;
 907         r.in.state = state;
 908         r.in.buf_size = buf_size;
 909         r.in.resume_handle = resume_handle;
 910
 911         if (DEBUGLEVEL >= 10)
 912                 NDR_PRINT_IN_DEBUG(svcctl_EnumServicesStatusA, &r);
 913
 914         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);
 915
 916         if ( !NT_STATUS_IS_OK(status) ) {
 917                 return status;
 918         }
 919
 920         if (DEBUGLEVEL >= 10)
 921                 NDR_PRINT_OUT_DEBUG(svcctl_EnumServicesStatusA, &r);
 922
 923         if (NT_STATUS_IS_ERR(status)) {
 924                 return status;
 925         }
 926
 927         /* Return variables */
 928         *service = *r.out.service;
 929         *bytes_needed = *r.out.bytes_needed;
 930         *services_returned = *r.out.services_returned;
 931         if ( resume_handle ) {
 932                 *resume_handle = *r.out.resume_handle;
 933         }
 934
 935         /* Return result */
 936         return werror_to_ntstatus(r.out.result);
 937 }
 938
 939 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)
 940 {
 941         struct svcctl_OpenSCManagerA r;
 942         NTSTATUS status;
 943
 944         /* In parameters */
 945         r.in.MachineName = MachineName;
 946         r.in.DatabaseName = DatabaseName;
 947         r.in.access_mask = access_mask;
 948
 949         if (DEBUGLEVEL >= 10)
 950                 NDR_PRINT_IN_DEBUG(svcctl_OpenSCManagerA, &r);
 951
 952         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);
 953
 954         if ( !NT_STATUS_IS_OK(status) ) {
 955                 return status;
 956         }
 957
 958         if (DEBUGLEVEL >= 10)
 959                 NDR_PRINT_OUT_DEBUG(svcctl_OpenSCManagerA, &r);
 960
 961         if (NT_STATUS_IS_ERR(status)) {
 962                 return status;
 963         }
 964
 965         /* Return variables */
 966         *handle = *r.out.handle;
 967
 968         /* Return result */
 969         return werror_to_ntstatus(r.out.result);
 970 }
 971
 972 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)
 973 {
 974         struct svcctl_OpenServiceA r;
 975         NTSTATUS status;
 976
 977         /* In parameters */
 978         r.in.scmanager_handle = scmanager_handle;
 979         r.in.ServiceName = ServiceName;
 980         r.in.access_mask = access_mask;
 981
 982         if (DEBUGLEVEL >= 10)
 983                 NDR_PRINT_IN_DEBUG(svcctl_OpenServiceA, &r);
 984
 985         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);
 986
 987         if ( !NT_STATUS_IS_OK(status) ) {
 988                 return status;
 989         }
 990
 991         if (DEBUGLEVEL >= 10)
 992                 NDR_PRINT_OUT_DEBUG(svcctl_OpenServiceA, &r);
 993
 994         if (NT_STATUS_IS_ERR(status)) {
 995                 return status;
 996         }
 997
 998         /* Return variables */
 999
1000         /* Return result */
1001         return werror_to_ntstatus(r.out.result);
1002 }
1003
1004 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)
1005 {
1006         struct svcctl_QueryServiceConfigA r;
1007         NTSTATUS status;
1008
1009         /* In parameters */
1010         r.in.handle = handle;
1011         r.in.buf_size = buf_size;
1012
1013         if (DEBUGLEVEL >= 10)
1014                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfigA, &r);
1015
1016         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);
1017
1018         if ( !NT_STATUS_IS_OK(status) ) {
1019                 return status;
1020         }
1021
1022         if (DEBUGLEVEL >= 10)
1023                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfigA, &r);
1024
1025         if (NT_STATUS_IS_ERR(status)) {
1026                 return status;
1027         }
1028
1029         /* Return variables */
1030         *query = *r.out.query;
1031         *bytes_needed = *r.out.bytes_needed;
1032
1033         /* Return result */
1034         return werror_to_ntstatus(r.out.result);
1035 }
1036
1037 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)
1038 {
1039         struct svcctl_QueryServiceLockStatusA r;
1040         NTSTATUS status;
1041
1042         /* In parameters */
1043         r.in.handle = handle;
1044         r.in.buf_size = buf_size;
1045
1046         if (DEBUGLEVEL >= 10)
1047                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceLockStatusA, &r);
1048
1049         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);
1050
1051         if ( !NT_STATUS_IS_OK(status) ) {
1052                 return status;
1053         }
1054
1055         if (DEBUGLEVEL >= 10)
1056                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceLockStatusA, &r);
1057
1058         if (NT_STATUS_IS_ERR(status)) {
1059                 return status;
1060         }
1061
1062         /* Return variables */
1063         *status = *r.out.status;
1064         *required_buf_size = *r.out.required_buf_size;
1065
1066         /* Return result */
1067         return werror_to_ntstatus(r.out.result);
1068 }
1069
1070 NTSTATUS rpccli_svcctl_StartServiceA(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t NumArgs, const char *Arguments)
1071 {
1072         struct svcctl_StartServiceA r;
1073         NTSTATUS status;
1074
1075         /* In parameters */
1076         r.in.handle = handle;
1077         r.in.NumArgs = NumArgs;
1078         r.in.Arguments = Arguments;
1079
1080         if (DEBUGLEVEL >= 10)
1081                 NDR_PRINT_IN_DEBUG(svcctl_StartServiceA, &r);
1082
1083         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);
1084
1085         if ( !NT_STATUS_IS_OK(status) ) {
1086                 return status;
1087         }
1088
1089         if (DEBUGLEVEL >= 10)
1090                 NDR_PRINT_OUT_DEBUG(svcctl_StartServiceA, &r);
1091
1092         if (NT_STATUS_IS_ERR(status)) {
1093                 return status;
1094         }
1095
1096         /* Return variables */
1097
1098         /* Return result */
1099         return werror_to_ntstatus(r.out.result);
1100 }
1101
1102 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)
1103 {
1104         struct svcctl_GetServiceDisplayNameA r;
1105         NTSTATUS status;
1106
1107         /* In parameters */
1108         r.in.handle = handle;
1109         r.in.service_name = service_name;
1110         r.in.display_name_length = display_name_length;
1111
1112         if (DEBUGLEVEL >= 10)
1113                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceDisplayNameA, &r);
1114
1115         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);
1116
1117         if ( !NT_STATUS_IS_OK(status) ) {
1118                 return status;
1119         }
1120
1121         if (DEBUGLEVEL >= 10)
1122                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceDisplayNameA, &r);
1123
1124         if (NT_STATUS_IS_ERR(status)) {
1125                 return status;
1126         }
1127
1128         /* Return variables */
1129         *display_name = *r.out.display_name;
1130         if ( display_name_length ) {
1131                 *display_name_length = *r.out.display_name_length;
1132         }
1133
1134         /* Return result */
1135         return werror_to_ntstatus(r.out.result);
1136 }
1137
1138 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)
1139 {
1140         struct svcctl_GetServiceKeyNameA r;
1141         NTSTATUS status;
1142
1143         /* In parameters */
1144         r.in.handle = handle;
1145         r.in.service_name = service_name;
1146         r.in.display_name_length = display_name_length;
1147
1148         if (DEBUGLEVEL >= 10)
1149                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceKeyNameA, &r);
1150
1151         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);
1152
1153         if ( !NT_STATUS_IS_OK(status) ) {
1154                 return status;
1155         }
1156
1157         if (DEBUGLEVEL >= 10)
1158                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceKeyNameA, &r);
1159
1160         if (NT_STATUS_IS_ERR(status)) {
1161                 return status;
1162         }
1163
1164         /* Return variables */
1165         *key_name = *r.out.key_name;
1166         if ( display_name_length ) {
1167                 *display_name_length = *r.out.display_name_length;
1168         }
1169
1170         /* Return result */
1171         return werror_to_ntstatus(r.out.result);
1172 }
1173
1174 NTSTATUS rpccli_svcctl_GetCurrentGroupeStateW(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx)
1175 {
1176         struct svcctl_GetCurrentGroupeStateW r;
1177         NTSTATUS status;
1178
1179         /* In parameters */
1180
1181         if (DEBUGLEVEL >= 10)
1182                 NDR_PRINT_IN_DEBUG(svcctl_GetCurrentGroupeStateW, &r);
1183
1184         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);
1185
1186         if ( !NT_STATUS_IS_OK(status) ) {
1187                 return status;
1188         }
1189
1190         if (DEBUGLEVEL >= 10)
1191                 NDR_PRINT_OUT_DEBUG(svcctl_GetCurrentGroupeStateW, &r);
1192
1193         if (NT_STATUS_IS_ERR(status)) {
1194                 return status;
1195         }
1196
1197         /* Return variables */
1198
1199         /* Return result */
1200         return werror_to_ntstatus(r.out.result);
1201 }
1202
1203 NTSTATUS rpccli_svcctl_EnumServiceGroupW(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx)
1204 {
1205         struct svcctl_EnumServiceGroupW r;
1206         NTSTATUS status;
1207
1208         /* In parameters */
1209
1210         if (DEBUGLEVEL >= 10)
1211                 NDR_PRINT_IN_DEBUG(svcctl_EnumServiceGroupW, &r);
1212
1213         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);
1214
1215         if ( !NT_STATUS_IS_OK(status) ) {
1216                 return status;
1217         }
1218
1219         if (DEBUGLEVEL >= 10)
1220                 NDR_PRINT_OUT_DEBUG(svcctl_EnumServiceGroupW, &r);
1221
1222         if (NT_STATUS_IS_ERR(status)) {
1223                 return status;
1224         }
1225
1226         /* Return variables */
1227
1228         /* Return result */
1229         return werror_to_ntstatus(r.out.result);
1230 }
1231
1232 NTSTATUS rpccli_svcctl_ChangeServiceConfig2A(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t info_level, uint8_t *info)
1233 {
1234         struct svcctl_ChangeServiceConfig2A r;
1235         NTSTATUS status;
1236
1237         /* In parameters */
1238         r.in.handle = handle;
1239         r.in.info_level = info_level;
1240         r.in.info = info;
1241
1242         if (DEBUGLEVEL >= 10)
1243                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfig2A, &r);
1244
1245         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);
1246
1247         if ( !NT_STATUS_IS_OK(status) ) {
1248                 return status;
1249         }
1250
1251         if (DEBUGLEVEL >= 10)
1252                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfig2A, &r);
1253
1254         if (NT_STATUS_IS_ERR(status)) {
1255                 return status;
1256         }
1257
1258         /* Return variables */
1259
1260         /* Return result */
1261         return werror_to_ntstatus(r.out.result);
1262 }
1263
1264 NTSTATUS rpccli_svcctl_ChangeServiceConfig2W(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint32_t info_level, uint8_t *info)
1265 {
1266         struct svcctl_ChangeServiceConfig2W r;
1267         NTSTATUS status;
1268
1269         /* In parameters */
1270         r.in.handle = handle;
1271         r.in.info_level = info_level;
1272         r.in.info = info;
1273
1274         if (DEBUGLEVEL >= 10)
1275                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfig2W, &r);
1276
1277         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);
1278
1279         if ( !NT_STATUS_IS_OK(status) ) {
1280                 return status;
1281         }
1282
1283         if (DEBUGLEVEL >= 10)
1284                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfig2W, &r);
1285
1286         if (NT_STATUS_IS_ERR(status)) {
1287                 return status;
1288         }
1289
1290         /* Return variables */
1291
1292         /* Return result */
1293         return werror_to_ntstatus(r.out.result);
1294 }
1295
1296 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)
1297 {
1298         struct svcctl_QueryServiceConfig2A r;
1299         NTSTATUS status;
1300
1301         /* In parameters */
1302         r.in.handle = handle;
1303         r.in.info_level = info_level;
1304         r.in.buf_size = buf_size;
1305
1306         if (DEBUGLEVEL >= 10)
1307                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfig2A, &r);
1308
1309         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);
1310
1311         if ( !NT_STATUS_IS_OK(status) ) {
1312                 return status;
1313         }
1314
1315         if (DEBUGLEVEL >= 10)
1316                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfig2A, &r);
1317
1318         if (NT_STATUS_IS_ERR(status)) {
1319                 return status;
1320         }
1321
1322         /* Return variables */
1323         *buffer = *r.out.buffer;
1324         *bytes_needed = *r.out.bytes_needed;
1325
1326         /* Return result */
1327         return werror_to_ntstatus(r.out.result);
1328 }
1329
1330 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)
1331 {
1332         struct svcctl_QueryServiceConfig2W r;
1333         NTSTATUS status;
1334
1335         /* In parameters */
1336         r.in.handle = handle;
1337         r.in.info_level = info_level;
1338         r.in.buf_size = buf_size;
1339
1340         if (DEBUGLEVEL >= 10)
1341                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfig2W, &r);
1342
1343         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);
1344
1345         if ( !NT_STATUS_IS_OK(status) ) {
1346                 return status;
1347         }
1348
1349         if (DEBUGLEVEL >= 10)
1350                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfig2W, &r);
1351
1352         if (NT_STATUS_IS_ERR(status)) {
1353                 return status;
1354         }
1355
1356         /* Return variables */
1357         *buffer = *r.out.buffer;
1358         *bytes_needed = *r.out.bytes_needed;
1359
1360         /* Return result */
1361         return werror_to_ntstatus(r.out.result);
1362 }
1363
1364 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)
1365 {
1366         struct svcctl_QueryServiceStatusEx r;
1367         NTSTATUS status;
1368
1369         /* In parameters */
1370         r.in.handle = handle;
1371         r.in.info_level = info_level;
1372         r.in.buf_size = buf_size;
1373
1374         if (DEBUGLEVEL >= 10)
1375                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceStatusEx, &r);
1376
1377         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);
1378
1379         if ( !NT_STATUS_IS_OK(status) ) {
1380                 return status;
1381         }
1382
1383         if (DEBUGLEVEL >= 10)
1384                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceStatusEx, &r);
1385
1386         if (NT_STATUS_IS_ERR(status)) {
1387                 return status;
1388         }
1389
1390         /* Return variables */
1391         *buffer = *r.out.buffer;
1392         *bytes_needed = *r.out.bytes_needed;
1393
1394         /* Return result */
1395         return werror_to_ntstatus(r.out.result);
1396 }
1397
1398 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)
1399 {
1400         struct EnumServicesStatusExA r;
1401         NTSTATUS status;
1402
1403         /* In parameters */
1404         r.in.scmanager = scmanager;
1405         r.in.info_level = info_level;
1406         r.in.type = type;
1407         r.in.state = state;
1408         r.in.buf_size = buf_size;
1409         r.in.resume_handle = resume_handle;
1410
1411         if (DEBUGLEVEL >= 10)
1412                 NDR_PRINT_IN_DEBUG(EnumServicesStatusExA, &r);
1413
1414         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);
1415
1416         if ( !NT_STATUS_IS_OK(status) ) {
1417                 return status;
1418         }
1419
1420         if (DEBUGLEVEL >= 10)
1421                 NDR_PRINT_OUT_DEBUG(EnumServicesStatusExA, &r);
1422
1423         if (NT_STATUS_IS_ERR(status)) {
1424                 return status;
1425         }
1426
1427         /* Return variables */
1428         *services = *r.out.services;
1429         *bytes_needed = *r.out.bytes_needed;
1430         *service_returned = *r.out.service_returned;
1431         if ( resume_handle ) {
1432                 *resume_handle = *r.out.resume_handle;
1433         }
1434         *group_name = *r.out.group_name;
1435
1436         /* Return result */
1437         return werror_to_ntstatus(r.out.result);
1438 }
1439
1440 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)
1441 {
1442         struct EnumServicesStatusExW r;
1443         NTSTATUS status;
1444
1445         /* In parameters */
1446         r.in.scmanager = scmanager;
1447         r.in.info_level = info_level;
1448         r.in.type = type;
1449         r.in.state = state;
1450         r.in.buf_size = buf_size;
1451         r.in.resume_handle = resume_handle;
1452
1453         if (DEBUGLEVEL >= 10)
1454                 NDR_PRINT_IN_DEBUG(EnumServicesStatusExW, &r);
1455
1456         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);
1457
1458         if ( !NT_STATUS_IS_OK(status) ) {
1459                 return status;
1460         }
1461
1462         if (DEBUGLEVEL >= 10)
1463                 NDR_PRINT_OUT_DEBUG(EnumServicesStatusExW, &r);
1464
1465         if (NT_STATUS_IS_ERR(status)) {
1466                 return status;
1467         }
1468
1469         /* Return variables */
1470         *services = *r.out.services;
1471         *bytes_needed = *r.out.bytes_needed;
1472         *service_returned = *r.out.service_returned;
1473         if ( resume_handle ) {
1474                 *resume_handle = *r.out.resume_handle;
1475         }
1476         *group_name = *r.out.group_name;
1477
1478         /* Return result */
1479         return werror_to_ntstatus(r.out.result);
1480 }
1481
1482 NTSTATUS rpccli_svcctl_SCSendTSMessage(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx)
1483 {
1484         struct svcctl_SCSendTSMessage r;
1485         NTSTATUS status;
1486
1487         /* In parameters */
1488
1489         if (DEBUGLEVEL >= 10)
1490                 NDR_PRINT_IN_DEBUG(svcctl_SCSendTSMessage, &r);
1491
1492         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);
1493
1494         if ( !NT_STATUS_IS_OK(status) ) {
1495                 return status;
1496         }
1497
1498         if (DEBUGLEVEL >= 10)
1499                 NDR_PRINT_OUT_DEBUG(svcctl_SCSendTSMessage, &r);
1500
1501         if (NT_STATUS_IS_ERR(status)) {
1502                 return status;
1503         }
1504
1505         /* Return variables */
1506
1507         /* Return result */
1508         return werror_to_ntstatus(r.out.result);
1509 }
1510