Service Control Manager - service enumeration.
[samba.git] / source / rpc_client / cli_svcctl.c
1
2 /* 
3  *  Unix SMB/Netbios implementation.
4  *  Version 1.9.
5  *  RPC Pipe client / server routines
6  *  Copyright (C) Andrew Tridgell              1992-1998,
7  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1998,
8  *  Copyright (C) Paul Ashton                  1997-1998.
9  *  
10  *  This program is free software; you can redistribute it and/or modify
11  *  it under the terms of the GNU General Public License as published by
12  *  the Free Software Foundation; either version 2 of the License, or
13  *  (at your option) any later version.
14  *  
15  *  This program is distributed in the hope that it will be useful,
16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  *  GNU General Public License for more details.
19  *  
20  *  You should have received a copy of the GNU General Public License
21  *  along with this program; if not, write to the Free Software
22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23  */
24
25
26 #ifdef SYSLOG
27 #undef SYSLOG
28 #endif
29
30 #include "includes.h"
31
32 extern int DEBUGLEVEL;
33
34 /****************************************************************************
35 do a SVC Open Policy
36 ****************************************************************************/
37 BOOL do_svc_open_sc_man(struct cli_state *cli, uint16 fnum, 
38                                 char *srv_name, char *db_name,
39                                 uint32 des_access,
40                                 POLICY_HND *hnd)
41 {
42         prs_struct rbuf;
43         prs_struct buf; 
44         SVC_Q_OPEN_SC_MAN q_o;
45         BOOL valid_pol = False;
46
47         if (hnd == NULL) return False;
48
49         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
50         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
51
52         /* create and send a MSRPC command with api SVC_OPEN_SC_MAN */
53
54         DEBUG(4,("SVC Open SC_MAN\n"));
55
56         make_svc_q_open_sc_man(&q_o, srv_name, db_name, des_access);
57
58         /* turn parameters into data stream */
59         svc_io_q_open_sc_man("", &q_o, &buf, 0);
60
61         /* send the data on \PIPE\ */
62         if (rpc_api_pipe_req(cli, fnum, SVC_OPEN_SC_MAN, &buf, &rbuf))
63         {
64                 SVC_R_OPEN_SC_MAN r_o;
65                 BOOL p;
66
67                 ZERO_STRUCT(r_o);
68
69                 svc_io_r_open_sc_man("", &r_o, &rbuf, 0);
70                 p = rbuf.offset != 0;
71
72                 if (p && r_o.status != 0)
73                 {
74                         /* report error code */
75                         DEBUG(0,("SVC_OPEN_SC_MAN: %s\n", get_nt_error_msg(r_o.status)));
76                         p = False;
77                 }
78
79                 if (p)
80                 {
81                         /* ok, at last: we're happy. return the policy handle */
82                         memcpy(hnd, r_o.pol.data, sizeof(hnd->data));
83                         valid_pol = True;
84                 }
85         }
86
87         prs_mem_free(&rbuf);
88         prs_mem_free(&buf );
89
90         return valid_pol;
91 }
92
93
94 /****************************************************************************
95 do a SVC Enumerate Services
96 ****************************************************************************/
97 BOOL do_svc_enum_svcs(struct cli_state *cli, uint16 fnum, 
98                                 POLICY_HND *hnd,
99                                 uint32 services_type, uint32 services_state,
100                                 uint32 *buf_size, uint32 *resume_hnd,
101                                 uint32 *dos_error,
102                                 ENUM_SRVC_STATUS **svcs, uint32 *num_svcs)
103 {
104         prs_struct rbuf;
105         prs_struct buf; 
106         SVC_Q_ENUM_SVCS_STATUS q_o;
107         BOOL valid_pol = False;
108
109         if (hnd == NULL || buf_size == NULL || dos_error == NULL || num_svcs == NULL)
110         {
111                 return False;
112         }
113
114         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
115         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
116
117         /* create and send a MSRPC command with api SVC_ENUM_SVCS_STATUS */
118
119         DEBUG(4,("SVC Enum Services Status\n"));
120
121         make_svc_q_enum_svcs_status(&q_o, hnd,
122                                     services_type, services_state,
123                                     *buf_size, *resume_hnd);
124
125         /* turn parameters into data stream */
126         svc_io_q_enum_svcs_status("", &q_o, &buf, 0);
127
128         /* send the data on \PIPE\ */
129         if (rpc_api_pipe_req(cli, fnum, SVC_ENUM_SVCS_STATUS, &buf, &rbuf))
130         {
131                 SVC_R_ENUM_SVCS_STATUS r_o;
132                 BOOL p;
133
134                 ZERO_STRUCT(r_o);
135
136                 svc_io_r_enum_svcs_status("", &r_o, &rbuf, 0);
137                 p = rbuf.offset != 0;
138
139                 if (p && r_o.dos_status != 0)
140                 {
141                         /* report error code */
142                         DEBUG(0,("SVC_ENUM_SVCS_STATUS: %s\n", smb_err_msg(ERRDOS, r_o.dos_status)));
143                         p = r_o.dos_status == ERRmoredata;
144                 }
145
146                 if (p)
147                 {
148                         (*svcs) = r_o.svcs;
149                         (*num_svcs) = r_o.num_svcs;
150                         (*resume_hnd) = get_enum_hnd(&r_o.resume_hnd);
151                         (*buf_size) = r_o.more_buf_size;
152                         (*dos_error) = r_o.dos_status;
153                         valid_pol = True;
154                 }
155         }
156
157         prs_mem_free(&rbuf);
158         prs_mem_free(&buf );
159
160         return valid_pol;
161 }
162
163
164 /****************************************************************************
165 do a SVC Close
166 ****************************************************************************/
167 BOOL do_svc_close(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd)
168 {
169         prs_struct rbuf;
170         prs_struct buf; 
171         SVC_Q_CLOSE q_c;
172         BOOL valid_close = False;
173
174         if (hnd == NULL) return False;
175
176         /* create and send a MSRPC command with api SVC_CLOSE */
177
178         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
179         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
180
181         DEBUG(4,("SVC Close\n"));
182
183         /* store the parameters */
184         make_svc_q_close(&q_c, hnd);
185
186         /* turn parameters into data stream */
187         svc_io_q_close("", &q_c, &buf, 0);
188
189         /* send the data on \PIPE\ */
190         if (rpc_api_pipe_req(cli, fnum, SVC_CLOSE, &buf, &rbuf))
191         {
192                 SVC_R_CLOSE r_c;
193                 BOOL p;
194
195                 ZERO_STRUCT(r_c);
196
197                 svc_io_r_close("", &r_c, &rbuf, 0);
198                 p = rbuf.offset != 0;
199
200                 if (p && r_c.status != 0)
201                 {
202                         /* report error code */
203                         DEBUG(0,("SVC_CLOSE: %s\n", get_nt_error_msg(r_c.status)));
204                         p = False;
205                 }
206
207                 if (p)
208                 {
209                         /* check that the returned policy handle is all zeros */
210                         int i;
211                         valid_close = True;
212
213                         for (i = 0; i < sizeof(r_c.pol.data); i++)
214                         {
215                                 if (r_c.pol.data[i] != 0)
216                                 {
217                                         valid_close = False;
218                                         break;
219                                 }
220                         }       
221                         if (!valid_close)
222                         {
223                                 DEBUG(0,("SVC_CLOSE: non-zero handle returned\n"));
224                         }
225                 }
226         }
227
228         prs_mem_free(&rbuf);
229         prs_mem_free(&buf );
230
231         return valid_close;
232 }
233
234