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