58a5b27f400ca73719f05e82f3af3e8cae713465
[sfrench/samba-autobuild/.git] / source / 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 2 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, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
19  
20 #include "includes.h"
21 #include "utils/net.h"
22
23
24 /********************************************************************
25 ********************************************************************/
26
27 static WERROR query_service_state(struct rpc_pipe_client *pipe_hnd,
28                                 TALLOC_CTX *mem_ctx, 
29                                 POLICY_HND *hSCM,
30                                 const char *service,
31                                 uint32 *state )
32 {
33         POLICY_HND hService;
34         SERVICE_STATUS service_status;
35         WERROR result = WERR_GENERAL_FAILURE;
36         
37         /* now cycle until the status is actually 'watch_state' */
38         
39         result = rpccli_svcctl_open_service(pipe_hnd, mem_ctx, hSCM, &hService, 
40                 service, SC_RIGHT_SVC_QUERY_STATUS );
41
42         if ( !W_ERROR_IS_OK(result) ) {
43                 d_fprintf(stderr, "Failed to open service.  [%s]\n", dos_errstr(result));
44                 return result;
45         }
46
47         result = rpccli_svcctl_query_status(pipe_hnd, mem_ctx, &hService, &service_status  );
48         if ( W_ERROR_IS_OK(result) ) {
49                 *state = service_status.state;
50         }
51         
52         rpccli_svcctl_close_service(pipe_hnd, mem_ctx, &hService );
53         
54         return result;
55 }
56
57 /********************************************************************
58 ********************************************************************/
59
60 static WERROR watch_service_state(struct rpc_pipe_client *pipe_hnd,
61                                 TALLOC_CTX *mem_ctx, 
62                                 POLICY_HND *hSCM,
63                                 const char *service, 
64                                 uint32 watch_state,
65                                 uint32 *final_state )
66 {
67         uint32 i;
68         uint32 state = 0;
69         WERROR result = WERR_GENERAL_FAILURE;
70         
71         
72         i = 0;
73         while ( (state != watch_state ) && i<30 ) {
74                 /* get the status */
75
76                 result = query_service_state(pipe_hnd, mem_ctx, hSCM, service, &state  );
77                 if ( !W_ERROR_IS_OK(result) ) {
78                         break;
79                 }
80                 
81                 d_printf(".");
82                 i++;
83                 sys_usleep( 100 );
84         }
85         d_printf("\n");
86         
87         *final_state = state;
88         
89         return result;
90 }
91
92 /********************************************************************
93 ********************************************************************/
94
95 static WERROR control_service(struct rpc_pipe_client *pipe_hnd,
96                                 TALLOC_CTX *mem_ctx, 
97                                 POLICY_HND *hSCM,
98                                 const char *service, 
99                                 uint32 control,
100                                 uint32 watch_state )
101 {
102         POLICY_HND hService;
103         WERROR result = WERR_GENERAL_FAILURE;
104         SERVICE_STATUS service_status;
105         uint32 state = 0;
106         
107         /* Open the Service */
108         
109         result = rpccli_svcctl_open_service(pipe_hnd, mem_ctx, hSCM, &hService, 
110                 service, (SC_RIGHT_SVC_STOP|SC_RIGHT_SVC_PAUSE_CONTINUE) );
111
112         if ( !W_ERROR_IS_OK(result) ) {
113                 d_fprintf(stderr, "Failed to open service.  [%s]\n", dos_errstr(result));
114                 goto done;
115         }
116         
117         /* get the status */
118
119         result = rpccli_svcctl_control_service(pipe_hnd, mem_ctx, &hService, 
120                 control, &service_status  );
121                 
122         if ( !W_ERROR_IS_OK(result) ) {
123                 d_fprintf(stderr, "Control service request failed.  [%s]\n", dos_errstr(result));
124                 goto done;
125         }
126         
127         /* loop -- checking the state until we are where we want to be */
128         
129         result = watch_service_state(pipe_hnd, mem_ctx, hSCM, service, watch_state, &state );
130                 
131         d_printf("%s service is %s.\n", service, svc_status_string(state));
132
133 done:   
134         rpccli_svcctl_close_service(pipe_hnd, mem_ctx, &hService  );
135                 
136         return result;
137 }       
138
139 /********************************************************************
140 ********************************************************************/
141
142 static NTSTATUS rpc_service_list_internal(const DOM_SID *domain_sid,
143                                         const char *domain_name, 
144                                         struct cli_state *cli,
145                                         struct rpc_pipe_client *pipe_hnd,
146                                         TALLOC_CTX *mem_ctx, 
147                                         int argc,
148                                         const char **argv )
149 {
150         POLICY_HND hSCM;
151         ENUM_SERVICES_STATUS *services;
152         WERROR result = WERR_GENERAL_FAILURE;
153         fstring servicename;
154         fstring displayname;
155         uint32 num_services = 0;
156         int i;
157         
158         if (argc != 0 ) {
159                 d_printf("Usage: net rpc service list\n");
160                 return NT_STATUS_OK;
161         }
162
163         result = rpccli_svcctl_open_scm(pipe_hnd, mem_ctx, &hSCM, SC_RIGHT_MGR_ENUMERATE_SERVICE  );
164         if ( !W_ERROR_IS_OK(result) ) {
165                 d_fprintf(stderr, "Failed to open Service Control Manager.  [%s]\n", dos_errstr(result));
166                 return werror_to_ntstatus(result);
167         }
168         
169         result = rpccli_svcctl_enumerate_services(pipe_hnd, mem_ctx, &hSCM, SVCCTL_TYPE_WIN32,
170                 SVCCTL_STATE_ALL, &num_services, &services );
171         
172         if ( !W_ERROR_IS_OK(result) ) {
173                 d_fprintf(stderr, "Failed to enumerate services.  [%s]\n", dos_errstr(result));
174                 goto done;
175         }
176         
177         if ( num_services == 0 )
178                 d_printf("No services returned\n");
179         
180         for ( i=0; i<num_services; i++ ) {
181                 rpcstr_pull( servicename, services[i].servicename.buffer, sizeof(servicename), -1, STR_TERMINATE );
182                 rpcstr_pull( displayname, services[i].displayname.buffer, sizeof(displayname), -1, STR_TERMINATE );
183                 
184                 d_printf("%-20s    \"%s\"\n", servicename, displayname);
185         }
186
187 done:   
188         rpccli_svcctl_close_service(pipe_hnd, mem_ctx, &hSCM  );
189                 
190         return werror_to_ntstatus(result);
191 }       
192
193 /********************************************************************
194 ********************************************************************/
195
196 static NTSTATUS rpc_service_status_internal(const DOM_SID *domain_sid,
197                                                 const char *domain_name, 
198                                                 struct cli_state *cli,
199                                                 struct rpc_pipe_client *pipe_hnd,
200                                                 TALLOC_CTX *mem_ctx, 
201                                                 int argc,
202                                                 const char **argv )
203 {
204         POLICY_HND hSCM, hService;
205         WERROR result = WERR_GENERAL_FAILURE;
206         fstring servicename;
207         SERVICE_STATUS service_status;
208         SERVICE_CONFIG config;
209         fstring ascii_string;
210         
211         if (argc != 1 ) {
212                 d_printf("Usage: net rpc service status <service>\n");
213                 return NT_STATUS_OK;
214         }
215
216         fstrcpy( servicename, argv[0] );
217
218         /* Open the Service Control Manager */
219         
220         result = rpccli_svcctl_open_scm(pipe_hnd, mem_ctx, &hSCM, SC_RIGHT_MGR_ENUMERATE_SERVICE  );
221         if ( !W_ERROR_IS_OK(result) ) {
222                 d_fprintf(stderr, "Failed to open Service Control Manager.  [%s]\n", dos_errstr(result));
223                 return werror_to_ntstatus(result);
224         }
225         
226         /* Open the Service */
227         
228         result = rpccli_svcctl_open_service(pipe_hnd, mem_ctx, &hSCM, &hService, servicename, 
229                 (SC_RIGHT_SVC_QUERY_STATUS|SC_RIGHT_SVC_QUERY_CONFIG) );
230
231         if ( !W_ERROR_IS_OK(result) ) {
232                 d_fprintf(stderr, "Failed to open service.  [%s]\n", dos_errstr(result));
233                 goto done;
234         }
235         
236         /* get the status */
237
238         result = rpccli_svcctl_query_status(pipe_hnd, mem_ctx, &hService, &service_status  );
239         if ( !W_ERROR_IS_OK(result) ) {
240                 d_fprintf(stderr, "Query status request failed.  [%s]\n", dos_errstr(result));
241                 goto done;
242         }
243         
244         d_printf("%s service is %s.\n", servicename, svc_status_string(service_status.state));
245
246         /* get the config */
247
248         result = rpccli_svcctl_query_config(pipe_hnd, mem_ctx, &hService, &config  );
249         if ( !W_ERROR_IS_OK(result) ) {
250                 d_fprintf(stderr, "Query config request failed.  [%s]\n", dos_errstr(result));
251                 goto done;
252         }
253
254         /* print out the configuration information for the service */
255
256         d_printf("Configuration details:\n");
257         d_printf("\tControls Accepted    = 0x%x\n", service_status.controls_accepted);
258         d_printf("\tService Type         = 0x%x\n", config.service_type);
259         d_printf("\tStart Type           = 0x%x\n", config.start_type);
260         d_printf("\tError Control        = 0x%x\n", config.error_control);
261         d_printf("\tTag ID               = 0x%x\n", config.tag_id);
262
263         if ( config.executablepath ) {
264                 rpcstr_pull( ascii_string, config.executablepath->buffer, sizeof(ascii_string), -1, STR_TERMINATE );
265                 d_printf("\tExecutable Path      = %s\n", ascii_string);
266         }
267
268         if ( config.loadordergroup ) {
269                 rpcstr_pull( ascii_string, config.loadordergroup->buffer, sizeof(ascii_string), -1, STR_TERMINATE );
270                 d_printf("\tLoad Order Group     = %s\n", ascii_string);
271         }
272
273         if ( config.dependencies ) {
274                 rpcstr_pull( ascii_string, config.dependencies->buffer, sizeof(ascii_string), -1, STR_TERMINATE );
275                 d_printf("\tDependencies         = %s\n", ascii_string);
276         }
277
278         if ( config.startname ) {
279                 rpcstr_pull( ascii_string, config.startname->buffer, sizeof(ascii_string), -1, STR_TERMINATE );
280                 d_printf("\tStart Name           = %s\n", ascii_string);
281         }
282
283         if ( config.displayname ) {
284                 rpcstr_pull( ascii_string, config.displayname->buffer, sizeof(ascii_string), -1, STR_TERMINATE );
285                 d_printf("\tDisplay Name         = %s\n", ascii_string);
286         }
287
288 done:   
289         rpccli_svcctl_close_service(pipe_hnd, mem_ctx, &hService  );
290         rpccli_svcctl_close_service(pipe_hnd, mem_ctx, &hSCM  );
291
292         return werror_to_ntstatus(result);
293 }       
294
295 /********************************************************************
296 ********************************************************************/
297
298 static NTSTATUS rpc_service_stop_internal(const DOM_SID *domain_sid,
299                                         const char *domain_name, 
300                                         struct cli_state *cli,
301                                         struct rpc_pipe_client *pipe_hnd,
302                                         TALLOC_CTX *mem_ctx, 
303                                         int argc,
304                                         const char **argv )
305 {
306         POLICY_HND hSCM;
307         WERROR result = WERR_GENERAL_FAILURE;
308         fstring servicename;
309         
310         if (argc != 1 ) {
311                 d_printf("Usage: net rpc service status <service>\n");
312                 return NT_STATUS_OK;
313         }
314
315         fstrcpy( servicename, argv[0] );
316
317         /* Open the Service Control Manager */
318         
319         result = rpccli_svcctl_open_scm(pipe_hnd, mem_ctx, &hSCM, SC_RIGHT_MGR_ENUMERATE_SERVICE  );
320         if ( !W_ERROR_IS_OK(result) ) {
321                 d_fprintf(stderr, "Failed to open Service Control Manager.  [%s]\n", dos_errstr(result));
322                 return werror_to_ntstatus(result);
323         }
324         
325         result = control_service(pipe_hnd, mem_ctx, &hSCM, servicename, 
326                 SVCCTL_CONTROL_STOP, SVCCTL_STOPPED );
327                 
328         rpccli_svcctl_close_service(pipe_hnd, mem_ctx, &hSCM  );
329                 
330         return werror_to_ntstatus(result);
331 }       
332
333 /********************************************************************
334 ********************************************************************/
335
336 static NTSTATUS rpc_service_pause_internal(const DOM_SID *domain_sid,
337                                         const char *domain_name, 
338                                         struct cli_state *cli,
339                                         struct rpc_pipe_client *pipe_hnd,
340                                         TALLOC_CTX *mem_ctx, 
341                                         int argc,
342                                         const char **argv )
343 {
344         POLICY_HND hSCM;
345         WERROR result = WERR_GENERAL_FAILURE;
346         fstring servicename;
347         
348         if (argc != 1 ) {
349                 d_printf("Usage: net rpc service status <service>\n");
350                 return NT_STATUS_OK;
351         }
352
353         fstrcpy( servicename, argv[0] );
354
355         /* Open the Service Control Manager */
356         
357         result = rpccli_svcctl_open_scm(pipe_hnd, mem_ctx, &hSCM, SC_RIGHT_MGR_ENUMERATE_SERVICE  );
358         if ( !W_ERROR_IS_OK(result) ) {
359                 d_fprintf(stderr, "Failed to open Service Control Manager.  [%s]\n", dos_errstr(result));
360                 return werror_to_ntstatus(result);
361         }
362         
363         result = control_service(pipe_hnd, mem_ctx, &hSCM, servicename, 
364                 SVCCTL_CONTROL_PAUSE, SVCCTL_PAUSED );
365                 
366         rpccli_svcctl_close_service(pipe_hnd, mem_ctx, &hSCM  );
367                 
368         return werror_to_ntstatus(result);
369 }       
370
371 /********************************************************************
372 ********************************************************************/
373
374 static NTSTATUS rpc_service_resume_internal(const DOM_SID *domain_sid,
375                                         const char *domain_name, 
376                                         struct cli_state *cli,
377                                         struct rpc_pipe_client *pipe_hnd,
378                                         TALLOC_CTX *mem_ctx, 
379                                         int argc,
380                                         const char **argv )
381 {
382         POLICY_HND hSCM;
383         WERROR result = WERR_GENERAL_FAILURE;
384         fstring servicename;
385         
386         if (argc != 1 ) {
387                 d_printf("Usage: net rpc service status <service>\n");
388                 return NT_STATUS_OK;
389         }
390
391         fstrcpy( servicename, argv[0] );
392
393         /* Open the Service Control Manager */
394         
395         result = rpccli_svcctl_open_scm(pipe_hnd, mem_ctx, &hSCM, SC_RIGHT_MGR_ENUMERATE_SERVICE  );
396         if ( !W_ERROR_IS_OK(result) ) {
397                 d_fprintf(stderr, "Failed to open Service Control Manager.  [%s]\n", dos_errstr(result));
398                 return werror_to_ntstatus(result);
399         }
400         
401         result = control_service(pipe_hnd, mem_ctx, &hSCM, servicename, 
402                 SVCCTL_CONTROL_CONTINUE, SVCCTL_RUNNING );
403                 
404         rpccli_svcctl_close_service(pipe_hnd, mem_ctx, &hSCM  );
405                 
406         return werror_to_ntstatus(result);
407 }       
408
409 /********************************************************************
410 ********************************************************************/
411
412 static NTSTATUS rpc_service_start_internal(const DOM_SID *domain_sid,
413                                         const char *domain_name, 
414                                         struct cli_state *cli,
415                                         struct rpc_pipe_client *pipe_hnd,
416                                         TALLOC_CTX *mem_ctx, 
417                                         int argc,
418                                         const char **argv )
419 {
420         POLICY_HND hSCM, hService;
421         WERROR result = WERR_GENERAL_FAILURE;
422         fstring servicename;
423         uint32 state = 0;
424         
425         if (argc != 1 ) {
426                 d_printf("Usage: net rpc service status <service>\n");
427                 return NT_STATUS_OK;
428         }
429
430         fstrcpy( servicename, argv[0] );
431
432         /* Open the Service Control Manager */
433         
434         result = rpccli_svcctl_open_scm( pipe_hnd, mem_ctx, &hSCM, SC_RIGHT_MGR_ENUMERATE_SERVICE  );
435         if ( !W_ERROR_IS_OK(result) ) {
436                 d_fprintf(stderr, "Failed to open Service Control Manager.  [%s]\n", dos_errstr(result));
437                 return werror_to_ntstatus(result);
438         }
439         
440         /* Open the Service */
441         
442         result = rpccli_svcctl_open_service(pipe_hnd, mem_ctx, &hSCM, &hService, 
443                 servicename, SC_RIGHT_SVC_START );
444
445         if ( !W_ERROR_IS_OK(result) ) {
446                 d_fprintf(stderr, "Failed to open service.  [%s]\n", dos_errstr(result));
447                 goto done;
448         }
449         
450         /* get the status */
451
452         result = rpccli_svcctl_start_service(pipe_hnd, mem_ctx, &hService, NULL, 0 );
453         if ( !W_ERROR_IS_OK(result) ) {
454                 d_fprintf(stderr, "Query status request failed.  [%s]\n", dos_errstr(result));
455                 goto done;
456         }
457         
458         result = watch_service_state(pipe_hnd, mem_ctx, &hSCM, servicename, SVCCTL_RUNNING, &state  );
459         
460         if ( W_ERROR_IS_OK(result) && (state == SVCCTL_RUNNING) )
461                 d_printf("Successfully started service: %s\n", servicename );
462         else
463                 d_fprintf(stderr, "Failed to start service: %s [%s]\n", servicename, dos_errstr(result) );
464         
465 done:   
466         rpccli_svcctl_close_service(pipe_hnd, mem_ctx, &hService  );
467         rpccli_svcctl_close_service(pipe_hnd, mem_ctx, &hSCM  );
468
469         return werror_to_ntstatus(result);
470 }
471
472 /********************************************************************
473 ********************************************************************/
474
475 static int rpc_service_list( int argc, const char **argv )
476 {
477         return run_rpc_command( NULL, PI_SVCCTL, 0, 
478                 rpc_service_list_internal, argc, argv );
479 }
480
481 /********************************************************************
482 ********************************************************************/
483
484 static int rpc_service_start( int argc, const char **argv )
485 {
486         return run_rpc_command( NULL, PI_SVCCTL, 0, 
487                 rpc_service_start_internal, argc, argv );
488 }
489
490 /********************************************************************
491 ********************************************************************/
492
493 static int rpc_service_stop( int argc, const char **argv )
494 {
495         return run_rpc_command( NULL, PI_SVCCTL, 0, 
496                 rpc_service_stop_internal, argc, argv );
497 }
498
499 /********************************************************************
500 ********************************************************************/
501
502 static int rpc_service_resume( int argc, const char **argv )
503 {
504         return run_rpc_command( NULL, PI_SVCCTL, 0, 
505                 rpc_service_resume_internal, argc, argv );
506 }
507
508 /********************************************************************
509 ********************************************************************/
510
511 static int rpc_service_pause( int argc, const char **argv )
512 {
513         return run_rpc_command( NULL, PI_SVCCTL, 0, 
514                 rpc_service_pause_internal, argc, argv );
515 }
516
517 /********************************************************************
518 ********************************************************************/
519
520 static int rpc_service_status( int argc, const char **argv )
521 {
522         return run_rpc_command( NULL, PI_SVCCTL, 0, 
523                 rpc_service_status_internal, argc, argv );
524 }
525
526 /********************************************************************
527 ********************************************************************/
528
529 static int net_help_service( int argc, const char **argv )
530 {
531         d_printf("net rpc service list               View configured Win32 services\n");
532         d_printf("net rpc service start <service>    Start a service\n");
533         d_printf("net rpc service stop <service>     Stop a service\n");
534         d_printf("net rpc service pause <service>    Pause a service\n");
535         d_printf("net rpc service resume <service>   Resume a paused service\n");
536         d_printf("net rpc service status <service>   View the current status of a service\n");
537         
538         return -1;
539 }
540
541 /********************************************************************
542 ********************************************************************/
543
544 int net_rpc_service(int argc, const char **argv) 
545 {
546         struct functable func[] = {
547                 {"list", rpc_service_list},
548                 {"start", rpc_service_start},
549                 {"stop", rpc_service_stop},
550                 {"pause", rpc_service_pause},
551                 {"resume", rpc_service_resume},
552                 {"status", rpc_service_status},
553                 {NULL, NULL}
554         };
555         
556         if ( argc )
557                 return net_run_function( argc, argv, func, net_help_service );
558                 
559         return net_help_service( argc, argv );
560 }