- Merge from trunk up to r45543
[reactos.git] / base / applications / mscutils / servman / query.c
1 /*
2 * PROJECT: ReactOS Services
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: base/applications/mscutils/servman/query.c
5 * PURPOSE: Query service information
6 * COPYRIGHT: Copyright 2006-2007 Ged Murphy <gedmurphy@reactos.org>
7 *
8 */
9
10 #include "precomp.h"
11
12
13 ENUM_SERVICE_STATUS_PROCESS*
14 GetSelectedService(PMAIN_WND_INFO Info)
15 {
16 LVITEM lvItem;
17
18 lvItem.mask = LVIF_PARAM;
19 lvItem.iItem = Info->SelectedItem;
20 SendMessage(Info->hListView,
21 LVM_GETITEM,
22 0,
23 (LPARAM)&lvItem);
24
25 /* return pointer to selected service */
26 return (ENUM_SERVICE_STATUS_PROCESS *)lvItem.lParam;
27 }
28
29
30 LPQUERY_SERVICE_CONFIG
31 GetServiceConfig(LPTSTR lpServiceName)
32 {
33 LPQUERY_SERVICE_CONFIG lpServiceConfig = NULL;
34 SC_HANDLE hSCManager;
35 SC_HANDLE hService;
36 DWORD dwBytesNeeded;
37
38 hSCManager = OpenSCManager(NULL,
39 NULL,
40 SC_MANAGER_ALL_ACCESS);
41 if (hSCManager)
42 {
43 hService = OpenService(hSCManager,
44 lpServiceName,
45 SERVICE_QUERY_STATUS | SERVICE_ENUMERATE_DEPENDENTS | SERVICE_QUERY_CONFIG);
46 if (hService)
47 {
48 if (!QueryServiceConfig(hService,
49 NULL,
50 0,
51 &dwBytesNeeded))
52 {
53 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
54 {
55 lpServiceConfig = (LPQUERY_SERVICE_CONFIG)HeapAlloc(GetProcessHeap(),
56 0,
57 dwBytesNeeded);
58 if (lpServiceConfig)
59 {
60 if (!QueryServiceConfig(hService,
61 lpServiceConfig,
62 dwBytesNeeded,
63 &dwBytesNeeded))
64 {
65 HeapFree(GetProcessHeap(),
66 0,
67 lpServiceConfig);
68 lpServiceConfig = NULL;
69 }
70 }
71 }
72 }
73
74 CloseServiceHandle(hService);
75 }
76
77 CloseServiceHandle(hSCManager);
78 }
79
80 return lpServiceConfig;
81 }
82
83
84 BOOL
85 SetServiceConfig(LPQUERY_SERVICE_CONFIG pServiceConfig,
86 LPTSTR lpServiceName,
87 LPTSTR lpPassword)
88 {
89 SC_HANDLE hSCManager;
90 SC_HANDLE hSc;
91 SC_LOCK scLock;
92 BOOL bRet = FALSE;
93
94 hSCManager = OpenSCManager(NULL,
95 NULL,
96 SC_MANAGER_LOCK);
97 if (hSCManager)
98 {
99 scLock = LockServiceDatabase(hSCManager);
100 if (scLock)
101 {
102 hSc = OpenService(hSCManager,
103 lpServiceName,
104 SERVICE_CHANGE_CONFIG);
105 if (hSc)
106 {
107 if (ChangeServiceConfig(hSc,
108 pServiceConfig->dwServiceType,
109 pServiceConfig->dwStartType,
110 pServiceConfig->dwErrorControl,
111 pServiceConfig->lpBinaryPathName,
112 pServiceConfig->lpLoadOrderGroup,
113 pServiceConfig->dwTagId ? &pServiceConfig->dwTagId : NULL,
114 pServiceConfig->lpDependencies,
115 pServiceConfig->lpServiceStartName,
116 lpPassword,
117 pServiceConfig->lpDisplayName))
118 {
119 bRet = TRUE;
120 }
121
122 CloseServiceHandle(hSc);
123 }
124
125 UnlockServiceDatabase(scLock);
126 }
127
128 CloseServiceHandle(hSCManager);
129 }
130
131 if (!bRet)
132 GetError();
133
134 return bRet;
135 }
136
137
138 LPTSTR
139 GetServiceDescription(LPTSTR lpServiceName)
140 {
141 SC_HANDLE hSCManager = NULL;
142 SC_HANDLE hSc = NULL;
143 SERVICE_DESCRIPTION *pServiceDescription = NULL;
144 LPTSTR lpDescription = NULL;
145 DWORD BytesNeeded = 0;
146 DWORD dwSize;
147
148 hSCManager = OpenSCManager(NULL,
149 NULL,
150 SC_MANAGER_ENUMERATE_SERVICE);
151 if (hSCManager == NULL)
152 {
153 GetError();
154 return NULL;
155 }
156
157 hSc = OpenService(hSCManager,
158 lpServiceName,
159 SERVICE_QUERY_CONFIG);
160 if (hSc)
161 {
162 if (!QueryServiceConfig2(hSc,
163 SERVICE_CONFIG_DESCRIPTION,
164 NULL,
165 0,
166 &BytesNeeded))
167 {
168 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
169 {
170 pServiceDescription = (SERVICE_DESCRIPTION *) HeapAlloc(ProcessHeap,
171 0,
172 BytesNeeded);
173 if (pServiceDescription == NULL)
174 goto cleanup;
175
176 if (QueryServiceConfig2(hSc,
177 SERVICE_CONFIG_DESCRIPTION,
178 (LPBYTE)pServiceDescription,
179 BytesNeeded,
180 &BytesNeeded))
181 {
182 if (pServiceDescription->lpDescription)
183 {
184 dwSize = _tcslen(pServiceDescription->lpDescription) + 1;
185 lpDescription = HeapAlloc(ProcessHeap,
186 0,
187 dwSize * sizeof(TCHAR));
188 if (lpDescription)
189 {
190 _tcscpy_s(lpDescription,
191 dwSize,
192 pServiceDescription->lpDescription);
193 }
194 }
195 }
196 }
197 }
198 }
199
200 cleanup:
201 if (pServiceDescription)
202 HeapFree(ProcessHeap,
203 0,
204 pServiceDescription);
205 if (hSCManager != NULL)
206 CloseServiceHandle(hSCManager);
207 if (hSc != NULL)
208 CloseServiceHandle(hSc);
209
210 return lpDescription;
211 }
212
213
214 BOOL
215 SetServiceDescription(LPTSTR lpServiceName,
216 LPTSTR lpDescription)
217 {
218 SC_HANDLE hSCManager;
219 SC_HANDLE hSc;
220 SC_LOCK scLock;
221 SERVICE_DESCRIPTION ServiceDescription;
222 BOOL bRet = FALSE;
223
224 hSCManager = OpenSCManager(NULL,
225 NULL,
226 SC_MANAGER_LOCK);
227 if (hSCManager)
228 {
229 scLock = LockServiceDatabase(hSCManager);
230 if (scLock)
231 {
232 hSc = OpenService(hSCManager,
233 lpServiceName,
234 SERVICE_CHANGE_CONFIG);
235 if (hSc)
236 {
237 ServiceDescription.lpDescription = lpDescription;
238
239 if (ChangeServiceConfig2(hSc,
240 SERVICE_CONFIG_DESCRIPTION,
241 &ServiceDescription))
242 {
243 bRet = TRUE;
244 }
245
246 CloseServiceHandle(hSc);
247 }
248
249 UnlockServiceDatabase(scLock);
250 }
251
252 CloseServiceHandle(hSCManager);
253 }
254
255 if (!bRet)
256 GetError();
257
258 return bRet;
259 }
260
261
262 BOOL
263 GetServiceList(PMAIN_WND_INFO Info,
264 DWORD *NumServices)
265 {
266 SC_HANDLE ScHandle;
267 BOOL bRet = FALSE;
268
269 DWORD BytesNeeded = 0;
270 DWORD ResumeHandle = 0;
271
272 *NumServices = 0;
273
274 if (Info->pAllServices != NULL)
275 {
276 HeapFree(ProcessHeap,
277 0,
278 Info->pAllServices);
279 }
280
281 ScHandle = OpenSCManager(NULL,
282 NULL,
283 SC_MANAGER_ENUMERATE_SERVICE);
284 if (ScHandle != INVALID_HANDLE_VALUE)
285 {
286 if (!EnumServicesStatusEx(ScHandle,
287 SC_ENUM_PROCESS_INFO,
288 SERVICE_WIN32,
289 SERVICE_STATE_ALL,
290 NULL,
291 0,
292 &BytesNeeded,
293 NumServices,
294 &ResumeHandle,
295 0))
296 {
297 /* Call function again if required size was returned */
298 if (GetLastError() == ERROR_MORE_DATA)
299 {
300 /* reserve memory for service info array */
301 Info->pAllServices = (ENUM_SERVICE_STATUS_PROCESS *) HeapAlloc(ProcessHeap,
302 0,
303 BytesNeeded);
304 if (Info->pAllServices)
305 {
306 /* fill array with service info */
307 if (EnumServicesStatusEx(ScHandle,
308 SC_ENUM_PROCESS_INFO,
309 SERVICE_WIN32,
310 SERVICE_STATE_ALL,
311 (LPBYTE)Info->pAllServices,
312 BytesNeeded,
313 &BytesNeeded,
314 NumServices,
315 &ResumeHandle,
316 0))
317 {
318 bRet = TRUE;
319 }
320 }
321 }
322 }
323 }
324
325 if (ScHandle)
326 CloseServiceHandle(ScHandle);
327
328 if (!bRet)
329 {
330 HeapFree(ProcessHeap,
331 0,
332 Info->pAllServices);
333 }
334
335 return bRet;
336 }
337
338
339 BOOL
340 UpdateServiceStatus(ENUM_SERVICE_STATUS_PROCESS* pService)
341 {
342 SC_HANDLE hScm;
343 BOOL bRet = FALSE;
344
345 hScm = OpenSCManager(NULL,
346 NULL,
347 SC_MANAGER_ENUMERATE_SERVICE);
348 if (hScm != INVALID_HANDLE_VALUE)
349 {
350 SC_HANDLE hService;
351
352 hService = OpenService(hScm,
353 pService->lpServiceName,
354 SERVICE_QUERY_STATUS);
355 if (hService)
356 {
357 DWORD size;
358
359 QueryServiceStatusEx(hService,
360 SC_STATUS_PROCESS_INFO,
361 (LPBYTE)&pService->ServiceStatusProcess,
362 sizeof(SERVICE_STATUS_PROCESS),
363 &size);
364
365 CloseServiceHandle(hService);
366 bRet = TRUE;
367 }
368
369 CloseServiceHandle(hScm);
370 }
371
372 return bRet;
373 }