source3/utils/net_rpc_service.c

   1 /*
   2    Samba Unix/Linux SMB client library
   3    Distributed SMB/CIFS Server Management Utility
   4    Copyright (C) Gerald (Jerry) Carter          2005
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include "includes.h"
  20 #include "utils/net.h"
  21 #include "../librpc/gen_ndr/cli_svcctl.h"
  22
  23 struct svc_state_msg {
  24         uint32 flag;
  25         const char *message;
  26 };
  27
  28 static struct svc_state_msg state_msg_table[] = {
  29         { SVCCTL_STOPPED,            N_("stopped") },
  30         { SVCCTL_START_PENDING,      N_("start pending") },
  31         { SVCCTL_STOP_PENDING,       N_("stop pending") },
  32         { SVCCTL_RUNNING,            N_("running") },
  33         { SVCCTL_CONTINUE_PENDING,   N_("resume pending") },
  34         { SVCCTL_PAUSE_PENDING,      N_("pause pending") },
  35         { SVCCTL_PAUSED,             N_("paused") },
  36         { 0,                          NULL }
  37 };
  38
  39
  40 /********************************************************************
  41 ********************************************************************/
  42 const char *svc_status_string( uint32 state )
  43 {
  44         fstring msg;
  45         int i;
  46
  47         fstr_sprintf( msg, _("Unknown State [%d]"), state );
  48
  49         for ( i=0; state_msg_table[i].message; i++ ) {
  50                 if ( state_msg_table[i].flag == state ) {
  51                         fstrcpy( msg, state_msg_table[i].message );
  52                         break;
  53                 }
  54         }
  55
  56         return talloc_strdup(talloc_tos(), msg);
  57 }
  58
  59 /********************************************************************
  60 ********************************************************************/
  61
  62 static WERROR query_service_state(struct rpc_pipe_client *pipe_hnd,
  63                                 TALLOC_CTX *mem_ctx,
  64                                 struct policy_handle *hSCM,
  65                                 const char *service,
  66                                 uint32 *state )
  67 {
  68         struct policy_handle hService;
  69         struct SERVICE_STATUS service_status;
  70         WERROR result = WERR_GENERAL_FAILURE;
  71         NTSTATUS status;
  72
  73         /* now cycle until the status is actually 'watch_state' */
  74
  75         status = rpccli_svcctl_OpenServiceW(pipe_hnd, mem_ctx,
  76                                             hSCM,
  77                                             service,
  78                                             SC_RIGHT_SVC_QUERY_STATUS,
  79                                             &hService,
  80                                             &result);
  81         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
  82                 d_fprintf(stderr, _("Failed to open service.  [%s]\n"),
  83                           win_errstr(result));
  84                 return result;
  85         }
  86
  87         status = rpccli_svcctl_QueryServiceStatus(pipe_hnd, mem_ctx,
  88                                                   &hService,
  89                                                   &service_status,
  90                                                   &result);
  91
  92         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
  93                 *state = service_status.state;
  94         }
  95
  96         rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hService, NULL);
  97
  98         return result;
  99 }
 100
 101 /********************************************************************
 102 ********************************************************************/
 103
 104 static WERROR watch_service_state(struct rpc_pipe_client *pipe_hnd,
 105                                 TALLOC_CTX *mem_ctx,
 106                                 struct policy_handle *hSCM,
 107                                 const char *service,
 108                                 uint32 watch_state,
 109                                 uint32 *final_state )
 110 {
 111         uint32 i;
 112         uint32 state = 0;
 113         WERROR result = WERR_GENERAL_FAILURE;
 114
 115
 116         i = 0;
 117         while ( (state != watch_state ) && i<30 ) {
 118                 /* get the status */
 119
 120                 result = query_service_state(pipe_hnd, mem_ctx, hSCM, service, &state  );
 121                 if ( !W_ERROR_IS_OK(result) ) {
 122                         break;
 123                 }
 124
 125                 d_printf(".");
 126                 i++;
 127                 sys_usleep( 100 );
 128         }
 129         d_printf("\n");
 130
 131         *final_state = state;
 132
 133         return result;
 134 }
 135
 136 /********************************************************************
 137 ********************************************************************/
 138
 139 static WERROR control_service(struct rpc_pipe_client *pipe_hnd,
 140                                 TALLOC_CTX *mem_ctx,
 141                                 struct policy_handle *hSCM,
 142                                 const char *service,
 143                                 uint32 control,
 144                                 uint32 watch_state )
 145 {
 146         struct policy_handle hService;
 147         WERROR result = WERR_GENERAL_FAILURE;
 148         NTSTATUS status;
 149         struct SERVICE_STATUS service_status;
 150         uint32 state = 0;
 151
 152         /* Open the Service */
 153
 154         status = rpccli_svcctl_OpenServiceW(pipe_hnd, mem_ctx,
 155                                             hSCM,
 156                                             service,
 157                                             (SC_RIGHT_SVC_STOP|SC_RIGHT_SVC_PAUSE_CONTINUE),
 158                                             &hService,
 159                                             &result);
 160
 161         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
 162                 d_fprintf(stderr, _("Failed to open service.  [%s]\n"),
 163                           win_errstr(result));
 164                 goto done;
 165         }
 166
 167         /* get the status */
 168
 169         status = rpccli_svcctl_ControlService(pipe_hnd, mem_ctx,
 170                                               &hService,
 171                                               control,
 172                                               &service_status,
 173                                               &result);
 174
 175         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
 176                 d_fprintf(stderr, _("Control service request failed.  [%s]\n"),
 177                           win_errstr(result));
 178                 goto done;
 179         }
 180
 181         /* loop -- checking the state until we are where we want to be */
 182
 183         result = watch_service_state(pipe_hnd, mem_ctx, hSCM, service, watch_state, &state );
 184
 185         d_printf(_("%s service is %s.\n"), service, svc_status_string(state));
 186
 187 done:
 188         rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hService, NULL);
 189
 190         return result;
 191 }
 192
 193 /********************************************************************
 194 ********************************************************************/
 195
 196 static NTSTATUS rpc_service_list_internal(struct net_context *c,
 197                                         const DOM_SID *domain_sid,
 198                                         const char *domain_name,
 199                                         struct cli_state *cli,
 200                                         struct rpc_pipe_client *pipe_hnd,
 201                                         TALLOC_CTX *mem_ctx,
 202                                         int argc,
 203                                         const char **argv )
 204 {
 205         struct policy_handle hSCM;
 206         struct ENUM_SERVICE_STATUSW *services = NULL;
 207         WERROR result = WERR_GENERAL_FAILURE;
 208         NTSTATUS status;
 209         int i;
 210
 211         uint8_t *buffer = NULL;
 212         uint32_t buf_size = 0;
 213         uint32_t bytes_needed = 0;
 214         uint32_t num_services = 0;
 215         uint32_t resume_handle = 0;
 216
 217         if (argc != 0 ) {
 218                 d_printf("%s net rpc service list\n", _("Usage:"));
 219                 return NT_STATUS_OK;
 220         }
 221
 222         status = rpccli_svcctl_OpenSCManagerW(pipe_hnd, mem_ctx,
 223                                               pipe_hnd->srv_name_slash,
 224                                               NULL,
 225                                               SC_RIGHT_MGR_ENUMERATE_SERVICE,
 226                                               &hSCM,
 227                                               &result);
 228         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
 229                 d_fprintf(stderr,
 230                           _("Failed to open Service Control Manager. [%s]\n"),
 231                           win_errstr(result));
 232                 return werror_to_ntstatus(result);
 233         }
 234
 235         do {
 236                 status = rpccli_svcctl_EnumServicesStatusW(pipe_hnd, mem_ctx,
 237                                                            &hSCM,
 238                                                            SERVICE_TYPE_WIN32,
 239                                                            SERVICE_STATE_ALL,
 240                                                            buffer,
 241                                                            buf_size,
 242                                                            &bytes_needed,
 243                                                            &num_services,
 244                                                            &resume_handle,
 245                                                            &result);
 246
 247                 if (NT_STATUS_IS_ERR(status)) {
 248                         d_fprintf(stderr,
 249                                 _("Failed to enumerate services.  [%s]\n"),
 250                                 win_errstr(result));
 251                         break;
 252                 }
 253
 254                 if (W_ERROR_EQUAL(result, WERR_MORE_DATA) && bytes_needed > 0) {
 255                         buffer = talloc_array(mem_ctx, uint8_t, bytes_needed);
 256                         buf_size = bytes_needed;
 257                         continue;
 258                 }
 259
 260                 if ( num_services == 0 ) {
 261                         d_printf(_("No services returned\n"));
 262                         break;
 263                 }
 264
 265                 {
 266                         enum ndr_err_code ndr_err;
 267                         DATA_BLOB blob;
 268                         struct ndr_pull *ndr;
 269
 270                         blob.length = buf_size;
 271                         blob.data = talloc_steal(mem_ctx, buffer);
 272
 273                         services = talloc_array(mem_ctx, struct ENUM_SERVICE_STATUSW, num_services);
 274                         if (!services) {
 275                                 status = NT_STATUS_NO_MEMORY;
 276                                 break;
 277                         }
 278
 279                         ndr = ndr_pull_init_blob(&blob, mem_ctx, NULL);
 280                         if (ndr == NULL) {
 281                                 status = NT_STATUS_NO_MEMORY;
 282                                 break;
 283                         }
 284
 285                         ndr_err = ndr_pull_ENUM_SERVICE_STATUSW_array(
 286                                 ndr, num_services, services);
 287                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 288                                 status = ndr_map_error2ntstatus(ndr_err);
 289                                 break;
 290                         }
 291
 292                         for ( i=0; i<num_services; i++ ) {
 293                                 d_printf("%-20s    \"%s\"\n",
 294                                         services[i].service_name,
 295                                         services[i].display_name);
 296                         }
 297                 }
 298
 299         } while (W_ERROR_EQUAL(result, WERR_MORE_DATA));
 300
 301         rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
 302
 303         return status;
 304 }
 305
 306 /********************************************************************
 307 ********************************************************************/
 308
 309 static NTSTATUS rpc_service_status_internal(struct net_context *c,
 310                                                 const DOM_SID *domain_sid,
 311                                                 const char *domain_name,
 312                                                 struct cli_state *cli,
 313                                                 struct rpc_pipe_client *pipe_hnd,
 314                                                 TALLOC_CTX *mem_ctx,
 315                                                 int argc,
 316                                                 const char **argv )
 317 {
 318         struct policy_handle hSCM, hService;
 319         WERROR result = WERR_GENERAL_FAILURE;
 320         NTSTATUS status;
 321         struct SERVICE_STATUS service_status;
 322         struct QUERY_SERVICE_CONFIG config;
 323         uint32_t buf_size = sizeof(config);
 324         uint32_t ret_size = 0;
 325
 326         if (argc != 1 ) {
 327                 d_printf("%s net rpc service status <service>\n", _("Usage:"));
 328                 return NT_STATUS_OK;
 329         }
 330
 331         /* Open the Service Control Manager */
 332         status = rpccli_svcctl_OpenSCManagerW(pipe_hnd, mem_ctx,
 333                                               pipe_hnd->srv_name_slash,
 334                                               NULL,
 335                                               SC_RIGHT_MGR_ENUMERATE_SERVICE,
 336                                               &hSCM,
 337                                               &result);
 338         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
 339                 d_fprintf(stderr,
 340                           _("Failed to open Service Control Manager. [%s]\n"),
 341                           win_errstr(result));
 342                 return werror_to_ntstatus(result);
 343         }
 344
 345         /* Open the Service */
 346
 347         status = rpccli_svcctl_OpenServiceW(pipe_hnd, mem_ctx,
 348                                             &hSCM,
 349                                             argv[0],
 350                                             (SC_RIGHT_SVC_QUERY_STATUS|SC_RIGHT_SVC_QUERY_CONFIG),
 351                                             &hService,
 352                                             &result);
 353
 354         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
 355                 d_fprintf(stderr, _("Failed to open service.  [%s]\n"),
 356                           win_errstr(result));
 357                 goto done;
 358         }
 359
 360         /* get the status */
 361
 362         status = rpccli_svcctl_QueryServiceStatus(pipe_hnd, mem_ctx,
 363                                                   &hService,
 364                                                   &service_status,
 365                                                   &result);
 366
 367         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
 368                 d_fprintf(stderr, _("Query status request failed.  [%s]\n"),
 369                           win_errstr(result));
 370                 goto done;
 371         }
 372
 373         d_printf(_("%s service is %s.\n"), argv[0],
 374                  svc_status_string(service_status.state));
 375
 376         /* get the config */
 377
 378         status = rpccli_svcctl_QueryServiceConfigW(pipe_hnd, mem_ctx,
 379                                                    &hService,
 380                                                    &config,
 381                                                    buf_size,
 382                                                    &ret_size,
 383                                                    &result);
 384         if (W_ERROR_EQUAL(result, WERR_INSUFFICIENT_BUFFER)) {
 385                 buf_size = ret_size;
 386                 status = rpccli_svcctl_QueryServiceConfigW(pipe_hnd, mem_ctx,
 387                                                            &hService,
 388                                                            &config,
 389                                                            buf_size,
 390                                                            &ret_size,
 391                                                            &result);
 392         }
 393
 394         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
 395                 d_fprintf(stderr, _("Query config request failed.  [%s]\n"),
 396                           win_errstr(result));
 397                 goto done;
 398         }
 399
 400         /* print out the configuration information for the service */
 401
 402         d_printf(_("Configuration details:\n"));
 403         d_printf(_("\tControls Accepted    = 0x%x\n"),
 404                  service_status.controls_accepted);
 405         d_printf(_("\tService Type         = 0x%x\n"), config.service_type);
 406         d_printf(_("\tStart Type           = 0x%x\n"), config.start_type);
 407         d_printf(_("\tError Control        = 0x%x\n"), config.error_control);
 408         d_printf(_("\tTag ID               = 0x%x\n"), config.tag_id);
 409
 410         if (config.executablepath) {
 411                 d_printf(_("\tExecutable Path      = %s\n"),
 412                          config.executablepath);
 413         }
 414
 415         if (config.loadordergroup) {
 416                 d_printf(_("\tLoad Order Group     = %s\n"),
 417                          config.loadordergroup);
 418         }
 419
 420         if (config.dependencies) {
 421                 d_printf(_("\tDependencies         = %s\n"),
 422                          config.dependencies);
 423         }
 424
 425         if (config.startname) {
 426                 d_printf(_("\tStart Name           = %s\n"), config.startname);
 427         }
 428
 429         if (config.displayname) {
 430                 d_printf(_("\tDisplay Name         = %s\n"),
 431                          config.displayname);
 432         }
 433
 434 done:
 435         rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hService, NULL);
 436         rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
 437
 438         return werror_to_ntstatus(result);
 439 }
 440
 441 /********************************************************************
 442 ********************************************************************/
 443
 444 static NTSTATUS rpc_service_stop_internal(struct net_context *c,
 445                                         const DOM_SID *domain_sid,
 446                                         const char *domain_name,
 447                                         struct cli_state *cli,
 448                                         struct rpc_pipe_client *pipe_hnd,
 449                                         TALLOC_CTX *mem_ctx,
 450                                         int argc,
 451                                         const char **argv )
 452 {
 453         struct policy_handle hSCM;
 454         WERROR result = WERR_GENERAL_FAILURE;
 455         NTSTATUS status;
 456         fstring servicename;
 457
 458         if (argc != 1 ) {
 459                 d_printf("%s net rpc service status <service>\n", _("Usage:"));
 460                 return NT_STATUS_OK;
 461         }
 462
 463         fstrcpy( servicename, argv[0] );
 464
 465         /* Open the Service Control Manager */
 466         status = rpccli_svcctl_OpenSCManagerW(pipe_hnd, mem_ctx,
 467                                               pipe_hnd->srv_name_slash,
 468                                               NULL,
 469                                               SC_RIGHT_MGR_ENUMERATE_SERVICE,
 470                                               &hSCM,
 471                                               &result);
 472         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
 473                 d_fprintf(stderr,
 474                           _("Failed to open Service Control Manager.  [%s]\n"),
 475                           win_errstr(result));
 476                 return werror_to_ntstatus(result);
 477         }
 478
 479         result = control_service(pipe_hnd, mem_ctx, &hSCM, servicename,
 480                 SVCCTL_CONTROL_STOP, SVCCTL_STOPPED );
 481
 482         rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
 483
 484         return werror_to_ntstatus(result);
 485 }
 486
 487 /********************************************************************
 488 ********************************************************************/
 489
 490 static NTSTATUS rpc_service_pause_internal(struct net_context *c,
 491                                         const DOM_SID *domain_sid,
 492                                         const char *domain_name,
 493                                         struct cli_state *cli,
 494                                         struct rpc_pipe_client *pipe_hnd,
 495                                         TALLOC_CTX *mem_ctx,
 496                                         int argc,
 497                                         const char **argv )
 498 {
 499         struct policy_handle hSCM;
 500         WERROR result = WERR_GENERAL_FAILURE;
 501         NTSTATUS status;
 502         fstring servicename;
 503
 504         if (argc != 1 ) {
 505                 d_printf("%s net rpc service status <service>\n", _("Usage:"));
 506                 return NT_STATUS_OK;
 507         }
 508
 509         fstrcpy( servicename, argv[0] );
 510
 511         /* Open the Service Control Manager */
 512         status = rpccli_svcctl_OpenSCManagerW(pipe_hnd, mem_ctx,
 513                                               pipe_hnd->srv_name_slash,
 514                                               NULL,
 515                                               SC_RIGHT_MGR_ENUMERATE_SERVICE,
 516                                               &hSCM,
 517                                               &result);
 518         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
 519                 d_fprintf(stderr,
 520                           _("Failed to open Service Control Manager.  [%s]\n"),
 521                           win_errstr(result));
 522                 return werror_to_ntstatus(result);
 523         }
 524
 525         result = control_service(pipe_hnd, mem_ctx, &hSCM, servicename,
 526                 SVCCTL_CONTROL_PAUSE, SVCCTL_PAUSED );
 527
 528         rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
 529
 530         return werror_to_ntstatus(result);
 531 }
 532
 533 /********************************************************************
 534 ********************************************************************/
 535
 536 static NTSTATUS rpc_service_resume_internal(struct net_context *c,
 537                                         const DOM_SID *domain_sid,
 538                                         const char *domain_name,
 539                                         struct cli_state *cli,
 540                                         struct rpc_pipe_client *pipe_hnd,
 541                                         TALLOC_CTX *mem_ctx,
 542                                         int argc,
 543                                         const char **argv )
 544 {
 545         struct policy_handle hSCM;
 546         WERROR result = WERR_GENERAL_FAILURE;
 547         NTSTATUS status;
 548         fstring servicename;
 549
 550         if (argc != 1 ) {
 551                 d_printf("%s net rpc service status <service>\n", _("Usage:"));
 552                 return NT_STATUS_OK;
 553         }
 554
 555         fstrcpy( servicename, argv[0] );
 556
 557         /* Open the Service Control Manager */
 558         status = rpccli_svcctl_OpenSCManagerW(pipe_hnd, mem_ctx,
 559                                               pipe_hnd->srv_name_slash,
 560                                               NULL,
 561                                               SC_RIGHT_MGR_ENUMERATE_SERVICE,
 562                                               &hSCM,
 563                                               &result);
 564         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
 565                 d_fprintf(stderr,
 566                           _("Failed to open Service Control Manager.  [%s]\n"),
 567                           win_errstr(result));
 568                 return werror_to_ntstatus(result);
 569         }
 570
 571         result = control_service(pipe_hnd, mem_ctx, &hSCM, servicename,
 572                 SVCCTL_CONTROL_CONTINUE, SVCCTL_RUNNING );
 573
 574         rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
 575
 576         return werror_to_ntstatus(result);
 577 }
 578
 579 /********************************************************************
 580 ********************************************************************/
 581
 582 static NTSTATUS rpc_service_start_internal(struct net_context *c,
 583                                         const DOM_SID *domain_sid,
 584                                         const char *domain_name,
 585                                         struct cli_state *cli,
 586                                         struct rpc_pipe_client *pipe_hnd,
 587                                         TALLOC_CTX *mem_ctx,
 588                                         int argc,
 589                                         const char **argv )
 590 {
 591         struct policy_handle hSCM, hService;
 592         WERROR result = WERR_GENERAL_FAILURE;
 593         NTSTATUS status;
 594         uint32 state = 0;
 595
 596         if (argc != 1 ) {
 597                 d_printf("%s net rpc service status <service>\n", _("Usage:"));
 598                 return NT_STATUS_OK;
 599         }
 600
 601         /* Open the Service Control Manager */
 602         status = rpccli_svcctl_OpenSCManagerW(pipe_hnd, mem_ctx,
 603                                               pipe_hnd->srv_name_slash,
 604                                               NULL,
 605                                               SC_RIGHT_MGR_ENUMERATE_SERVICE,
 606                                               &hSCM,
 607                                               &result);
 608         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
 609                 d_fprintf(stderr,
 610                           _("Failed to open Service Control Manager.  [%s]\n"),
 611                           win_errstr(result));
 612                 return werror_to_ntstatus(result);
 613         }
 614
 615         /* Open the Service */
 616
 617         status = rpccli_svcctl_OpenServiceW(pipe_hnd, mem_ctx,
 618                                             &hSCM,
 619                                             argv[0],
 620                                             SC_RIGHT_SVC_START,
 621                                             &hService,
 622                                             &result);
 623
 624         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
 625                 d_fprintf(stderr, _("Failed to open service.  [%s]\n"),
 626                           win_errstr(result));
 627                 goto done;
 628         }
 629
 630         /* get the status */
 631
 632         status = rpccli_svcctl_StartServiceW(pipe_hnd, mem_ctx,
 633                                              &hService,
 634                                              0,
 635                                              NULL,
 636                                              &result);
 637
 638         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
 639                 d_fprintf(stderr, _("Query status request failed.  [%s]\n"),
 640                           win_errstr(result));
 641                 goto done;
 642         }
 643
 644         result = watch_service_state(pipe_hnd, mem_ctx, &hSCM, argv[0], SVCCTL_RUNNING, &state  );
 645
 646         if ( W_ERROR_IS_OK(result) && (state == SVCCTL_RUNNING) )
 647                 d_printf(_("Successfully started service: %s\n"),
 648                          argv[0] );
 649         else
 650                 d_fprintf(stderr,_("Failed to start service: %s [%s]\n"),
 651                           argv[0], win_errstr(result) );
 652
 653 done:
 654         rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hService, NULL);
 655         rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
 656
 657         return werror_to_ntstatus(result);
 658 }
 659
 660 /********************************************************************
 661 ********************************************************************/
 662
 663 static NTSTATUS rpc_service_delete_internal(struct net_context *c,
 664                                             const DOM_SID *domain_sid,
 665                                             const char *domain_name,
 666                                             struct cli_state *cli,
 667                                             struct rpc_pipe_client *pipe_hnd,
 668                                             TALLOC_CTX *mem_ctx,
 669                                             int argc,
 670                                             const char **argv)
 671 {
 672         struct policy_handle hSCM, hService;
 673         WERROR result = WERR_GENERAL_FAILURE;
 674         NTSTATUS status;
 675
 676         if (argc != 1 ) {
 677                 d_printf("%s net rpc service delete <service>\n", _("Usage:"));
 678                 return NT_STATUS_OK;
 679         }
 680
 681         /* Open the Service Control Manager */
 682         status = rpccli_svcctl_OpenSCManagerW(pipe_hnd, mem_ctx,
 683                                               pipe_hnd->srv_name_slash,
 684                                               NULL,
 685                                               SC_RIGHT_MGR_ENUMERATE_SERVICE,
 686                                               &hSCM,
 687                                               &result);
 688         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
 689                 d_fprintf(stderr,
 690                         _("Failed to open Service Control Manager.  [%s]\n"),
 691                         win_errstr(result));
 692                 return werror_to_ntstatus(result);
 693         }
 694
 695         /* Open the Service */
 696
 697         status = rpccli_svcctl_OpenServiceW(pipe_hnd, mem_ctx,
 698                                             &hSCM,
 699                                             argv[0],
 700                                             SERVICE_ALL_ACCESS,
 701                                             &hService,
 702                                             &result);
 703
 704         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
 705                 d_fprintf(stderr, _("Failed to open service.  [%s]\n"),
 706                         win_errstr(result));
 707                 goto done;
 708         }
 709
 710         /* Delete the Service */
 711
 712         status = rpccli_svcctl_DeleteService(pipe_hnd, mem_ctx,
 713                                              &hService,
 714                                              &result);
 715
 716         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
 717                 d_fprintf(stderr, _("Delete service request failed.  [%s]\n"),
 718                         win_errstr(result));
 719                 goto done;
 720         }
 721
 722         d_printf(_("Successfully deleted Service: %s\n"), argv[0]);
 723
 724  done:
 725         if (is_valid_policy_hnd(&hService)) {
 726                 rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hService, NULL);
 727         }
 728         if (is_valid_policy_hnd(&hSCM)) {
 729                 rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
 730         }
 731
 732         return werror_to_ntstatus(result);
 733 }
 734
 735 /********************************************************************
 736 ********************************************************************/
 737
 738 static NTSTATUS rpc_service_create_internal(struct net_context *c,
 739                                             const DOM_SID *domain_sid,
 740                                             const char *domain_name,
 741                                             struct cli_state *cli,
 742                                             struct rpc_pipe_client *pipe_hnd,
 743                                             TALLOC_CTX *mem_ctx,
 744                                             int argc,
 745                                             const char **argv)
 746 {
 747         struct policy_handle hSCM, hService;
 748         WERROR result = WERR_GENERAL_FAILURE;
 749         NTSTATUS status;
 750         const char *ServiceName;
 751         const char *DisplayName;
 752         const char *binary_path;
 753
 754         if (argc != 3) {
 755                 d_printf("%s net rpc service create <service> "
 756                          "<displayname> <binarypath>\n", _("Usage:"));
 757                 return NT_STATUS_OK;
 758         }
 759
 760         /* Open the Service Control Manager */
 761         status = rpccli_svcctl_OpenSCManagerW(pipe_hnd, mem_ctx,
 762                                               pipe_hnd->srv_name_slash,
 763                                               NULL,
 764                                               SC_RIGHT_MGR_CREATE_SERVICE,
 765                                               &hSCM,
 766                                               &result);
 767         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
 768                 d_fprintf(stderr,
 769                         _("Failed to open Service Control Manager.  [%s]\n"),
 770                         win_errstr(result));
 771                 return werror_to_ntstatus(result);
 772         }
 773
 774         /* Create the service */
 775
 776         ServiceName = argv[0];
 777         DisplayName = argv[1];
 778         binary_path = argv[2];
 779
 780         status = rpccli_svcctl_CreateServiceW(pipe_hnd, mem_ctx,
 781                                               &hSCM,
 782                                               ServiceName,
 783                                               DisplayName,
 784                                               SERVICE_ALL_ACCESS,
 785                                               SERVICE_TYPE_WIN32_OWN_PROCESS,
 786                                               SVCCTL_DEMAND_START,
 787                                               SVCCTL_SVC_ERROR_NORMAL,
 788                                               binary_path,
 789                                               NULL, /* LoadOrderGroupKey */
 790                                               NULL, /* TagId */
 791                                               NULL, /* dependencies */
 792                                               0, /* dependencies_size */
 793                                               NULL, /* service_start_name */
 794                                               NULL, /* password */
 795                                               0, /* password_size */
 796                                               &hService,
 797                                               &result);
 798
 799         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
 800                 d_fprintf(stderr, _("Create service request failed.  [%s]\n"),
 801                         win_errstr(result));
 802                 goto done;
 803         }
 804
 805         d_printf(_("Successfully created Service: %s\n"), argv[0]);
 806
 807  done:
 808         if (is_valid_policy_hnd(&hService)) {
 809                 rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hService, NULL);
 810         }
 811         if (is_valid_policy_hnd(&hSCM)) {
 812                 rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
 813         }
 814
 815         return werror_to_ntstatus(result);
 816 }
 817
 818 /********************************************************************
 819 ********************************************************************/
 820
 821 static int rpc_service_list(struct net_context *c, int argc, const char **argv )
 822 {
 823         if (c->display_usage) {
 824                 d_printf(  "%s\n"
 825                            "net rpc service list\n"
 826                            "    %s\n",
 827                          _("Usage:"),
 828                          _("View configured Win32 services"));
 829                 return 0;
 830         }
 831
 832         return run_rpc_command(c, NULL, &ndr_table_svcctl.syntax_id, 0,
 833                 rpc_service_list_internal, argc, argv );
 834 }
 835
 836 /********************************************************************
 837 ********************************************************************/
 838
 839 static int rpc_service_start(struct net_context *c, int argc, const char **argv )
 840 {
 841         if (c->display_usage) {
 842                 d_printf(  "%s\n"
 843                            "net rpc service start <service>\n"
 844                            "    %s\n",
 845                          _("Usage:"),
 846                          _("Start a Win32 service"));
 847                 return 0;
 848         }
 849
 850         return run_rpc_command(c, NULL, &ndr_table_svcctl.syntax_id, 0,
 851                 rpc_service_start_internal, argc, argv );
 852 }
 853
 854 /********************************************************************
 855 ********************************************************************/
 856
 857 static int rpc_service_stop(struct net_context *c, int argc, const char **argv )
 858 {
 859         if (c->display_usage) {
 860                 d_printf(  "%s\n"
 861                            "net rpc service stop <service>\n"
 862                            "    %s\n",
 863                          _("Usage:"),
 864                          _("Stop a Win32 service"));
 865                 return 0;
 866         }
 867
 868         return run_rpc_command(c, NULL, &ndr_table_svcctl.syntax_id, 0,
 869                 rpc_service_stop_internal, argc, argv );
 870 }
 871
 872 /********************************************************************
 873 ********************************************************************/
 874
 875 static int rpc_service_resume(struct net_context *c, int argc, const char **argv )
 876 {
 877         if (c->display_usage) {
 878                 d_printf(  "%s\n"
 879                            "net rpc service resume <service>\n"
 880                            "    %s\n",
 881                          _("Usage:"),
 882                          _("Resume a Win32 service"));
 883                 return 0;
 884         }
 885
 886         return run_rpc_command(c, NULL, &ndr_table_svcctl.syntax_id, 0,
 887                 rpc_service_resume_internal, argc, argv );
 888 }
 889
 890 /********************************************************************
 891 ********************************************************************/
 892
 893 static int rpc_service_pause(struct net_context *c, int argc, const char **argv )
 894 {
 895         if (c->display_usage) {
 896                 d_printf(  "%s\n"
 897                            "net rpc service pause <service>\n"
 898                            "    %s\n",
 899                          _("Usage:"),
 900                          _("Pause a Win32 service"));
 901                 return 0;
 902         }
 903
 904         return run_rpc_command(c, NULL, &ndr_table_svcctl.syntax_id, 0,
 905                 rpc_service_pause_internal, argc, argv );
 906 }
 907
 908 /********************************************************************
 909 ********************************************************************/
 910
 911 static int rpc_service_status(struct net_context *c, int argc, const char **argv )
 912 {
 913         if (c->display_usage) {
 914                 d_printf(  "%s\n"
 915                            "net rpc service status <service>\n"
 916                            "     %s\n",
 917                          _("Usage:"),
 918                          _("Show the current status of a service"));
 919                 return 0;
 920         }
 921
 922         return run_rpc_command(c, NULL, &ndr_table_svcctl.syntax_id, 0,
 923                 rpc_service_status_internal, argc, argv );
 924 }
 925
 926 /********************************************************************
 927 ********************************************************************/
 928
 929 static int rpc_service_delete(struct net_context *c, int argc, const char **argv)
 930 {
 931         if (c->display_usage) {
 932                 d_printf(  "%s\n"
 933                            "net rpc service delete <service>\n"
 934                            "    %s\n",
 935                          _("Usage:"),
 936                          _("Delete a Win32 service"));
 937                 return 0;
 938         }
 939
 940         return run_rpc_command(c, NULL, &ndr_table_svcctl.syntax_id, 0,
 941                 rpc_service_delete_internal, argc, argv);
 942 }
 943
 944 /********************************************************************
 945 ********************************************************************/
 946
 947 static int rpc_service_create(struct net_context *c, int argc, const char **argv)
 948 {
 949         if (c->display_usage) {
 950                 d_printf(  "%s\n"
 951                            "net rpc service create <service>\n"
 952                            "    %s\n",
 953                          _("Usage:"),
 954                          _("Create a Win32 service"));
 955                 return 0;
 956         }
 957
 958         return run_rpc_command(c, NULL, &ndr_table_svcctl.syntax_id, 0,
 959                 rpc_service_create_internal, argc, argv);
 960 }
 961
 962 /********************************************************************
 963 ********************************************************************/
 964
 965 int net_rpc_service(struct net_context *c, int argc, const char **argv)
 966 {
 967         struct functable func[] = {
 968                 {
 969                         "list",
 970                         rpc_service_list,
 971                         NET_TRANSPORT_RPC,
 972                         N_("View configured Win32 services"),
 973                         N_("net rpc service list\n"
 974                            "    View configured Win32 services")
 975                 },
 976                 {
 977                         "start",
 978                         rpc_service_start,
 979                         NET_TRANSPORT_RPC,
 980                         N_("Start a service"),
 981                         N_("net rpc service start\n"
 982                            "    Start a service")
 983                 },
 984                 {
 985                         "stop",
 986                         rpc_service_stop,
 987                         NET_TRANSPORT_RPC,
 988                         N_("Stop a service"),
 989                         N_("net rpc service stop\n"
 990                            "    Stop a service")
 991                 },
 992                 {
 993                         "pause",
 994                         rpc_service_pause,
 995                         NET_TRANSPORT_RPC,
 996                         N_("Pause a service"),
 997                         N_("net rpc service pause\n"
 998                            "    Pause a service")
 999                 },
1000                 {
1001                         "resume",
1002                         rpc_service_resume,
1003                         NET_TRANSPORT_RPC,
1004                         N_("Resume a paused service"),
1005                         N_("net rpc service resume\n"
1006                            "    Resume a service")
1007                 },
1008                 {
1009                         "status",
1010                         rpc_service_status,
1011                         NET_TRANSPORT_RPC,
1012                         N_("View current status of a service"),
1013                         N_("net rpc service status\n"
1014                            "    View current status of a service")
1015                 },
1016                 {
1017                         "delete",
1018                         rpc_service_delete,
1019                         NET_TRANSPORT_RPC,
1020                         N_("Delete a service"),
1021                         N_("net rpc service delete\n"
1022                            "    Deletes a service")
1023                 },
1024                 {
1025                         "create",
1026                         rpc_service_create,
1027                         NET_TRANSPORT_RPC,
1028                         N_("Create a service"),
1029                         N_("net rpc service create\n"
1030                            "    Creates a service")
1031                 },
1032
1033                 {NULL, NULL, 0, NULL, NULL}
1034         };
1035
1036         return net_run_function(c, argc, argv, "net rpc service",func);
1037 }