4a529c171d60ccb103b36fafe66b0f0b6b9e75cc
[reactos.git] / reactos / base / system / services / config.c
1 /*
2 * PROJECT: ReactOS Service Control Manager
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: base/system/services/config.c
5 * PURPOSE: Service configuration interface
6 * COPYRIGHT: Copyright 2005 Eric Kohl
7 *
8 */
9
10 /* INCLUDES *****************************************************************/
11
12 #include "services.h"
13
14 #define NDEBUG
15 #include <debug.h>
16
17 /* FUNCTIONS *****************************************************************/
18
19
20 DWORD
21 ScmOpenServiceKey(LPWSTR lpServiceName,
22 REGSAM samDesired,
23 PHKEY phKey)
24 {
25 HKEY hServicesKey = NULL;
26 DWORD dwError;
27
28 *phKey = NULL;
29
30 dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
31 L"System\\CurrentControlSet\\Services",
32 0,
33 KEY_READ,
34 &hServicesKey);
35 if (dwError != ERROR_SUCCESS)
36 return dwError;
37
38 dwError = RegOpenKeyExW(hServicesKey,
39 lpServiceName,
40 0,
41 samDesired,
42 phKey);
43
44 RegCloseKey(hServicesKey);
45
46 return dwError;
47 }
48
49
50 DWORD
51 ScmCreateServiceKey(LPCWSTR lpServiceName,
52 REGSAM samDesired,
53 PHKEY phKey)
54 {
55 HKEY hServicesKey = NULL;
56 DWORD dwDisposition;
57 DWORD dwError;
58
59 *phKey = NULL;
60
61 dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
62 L"System\\CurrentControlSet\\Services",
63 0,
64 KEY_READ | KEY_CREATE_SUB_KEY,
65 &hServicesKey);
66 if (dwError != ERROR_SUCCESS)
67 return dwError;
68
69 dwError = RegCreateKeyExW(hServicesKey,
70 lpServiceName,
71 0,
72 NULL,
73 REG_OPTION_NON_VOLATILE,
74 samDesired,
75 NULL,
76 phKey,
77 &dwDisposition);
78 #if 0
79 if ((dwError == ERROR_SUCCESS) &&
80 (dwDisposition == REG_OPENED_EXISTING_KEY))
81 {
82 RegCloseKey(*phKey);
83 *phKey = NULL;
84 dwError = ERROR_SERVICE_EXISTS;
85 }
86 #endif
87
88 RegCloseKey(hServicesKey);
89
90 return dwError;
91 }
92
93
94
95 DWORD
96 ScmWriteDependencies(HKEY hServiceKey,
97 LPCWSTR lpDependencies,
98 DWORD dwDependenciesLength)
99 {
100 DWORD dwError = ERROR_SUCCESS;
101 SIZE_T cchGroupLength = 0;
102 SIZE_T cchServiceLength = 0;
103 SIZE_T cchLength;
104 LPWSTR lpGroupDeps;
105 LPWSTR lpServiceDeps;
106 LPCWSTR lpSrc;
107 LPWSTR lpDst;
108
109 if (*lpDependencies == 0)
110 {
111 RegDeleteValueW(hServiceKey,
112 L"DependOnService");
113 RegDeleteValueW(hServiceKey,
114 L"DependOnGroup");
115 }
116 else
117 {
118 lpGroupDeps = HeapAlloc(GetProcessHeap(),
119 HEAP_ZERO_MEMORY,
120 (dwDependenciesLength + 2) * sizeof(WCHAR));
121 if (lpGroupDeps == NULL)
122 return ERROR_NOT_ENOUGH_MEMORY;
123
124 lpSrc = lpDependencies;
125 lpDst = lpGroupDeps;
126 while (*lpSrc != 0)
127 {
128 cchLength = wcslen(lpSrc) + 1;
129 if (*lpSrc == SC_GROUP_IDENTIFIERW)
130 {
131 lpSrc++;
132 cchLength--;
133 cchGroupLength += cchLength;
134 wcscpy(lpDst, lpSrc);
135 lpDst = lpDst + cchLength;
136 }
137
138 lpSrc = lpSrc + cchLength;
139 }
140 *lpDst = 0;
141 lpDst++;
142 cchGroupLength++;
143
144 lpSrc = lpDependencies;
145 lpServiceDeps = lpDst;
146 while (*lpSrc != 0)
147 {
148 cchLength = wcslen(lpSrc) + 1;
149 if (*lpSrc != SC_GROUP_IDENTIFIERW)
150 {
151 cchServiceLength += cchLength;
152 wcscpy(lpDst, lpSrc);
153 lpDst = lpDst + cchLength;
154 }
155
156 lpSrc = lpSrc + cchLength;
157 }
158 *lpDst = 0;
159 cchServiceLength++;
160
161 if (cchGroupLength > 1)
162 {
163 dwError = RegSetValueExW(hServiceKey,
164 L"DependOnGroup",
165 0,
166 REG_MULTI_SZ,
167 (LPBYTE)lpGroupDeps,
168 (DWORD)(cchGroupLength * sizeof(WCHAR)));
169 }
170 else
171 {
172 RegDeleteValueW(hServiceKey,
173 L"DependOnGroup");
174 }
175
176 if (dwError == ERROR_SUCCESS)
177 {
178 if (cchServiceLength > 1)
179 {
180 dwError = RegSetValueExW(hServiceKey,
181 L"DependOnService",
182 0,
183 REG_MULTI_SZ,
184 (LPBYTE)lpServiceDeps,
185 (DWORD)(cchServiceLength * sizeof(WCHAR)));
186 }
187 else
188 {
189 RegDeleteValueW(hServiceKey,
190 L"DependOnService");
191 }
192 }
193
194 HeapFree(GetProcessHeap(), 0, lpGroupDeps);
195 }
196
197 return dwError;
198 }
199
200
201 DWORD
202 ScmMarkServiceForDelete(PSERVICE pService)
203 {
204 HKEY hServiceKey = NULL;
205 DWORD dwValue = 1;
206 DWORD dwError;
207
208 DPRINT("ScmMarkServiceForDelete() called\n");
209
210 dwError = ScmOpenServiceKey(pService->lpServiceName,
211 KEY_WRITE,
212 &hServiceKey);
213 if (dwError != ERROR_SUCCESS)
214 return dwError;
215
216 dwError = RegSetValueExW(hServiceKey,
217 L"DeleteFlag",
218 0,
219 REG_DWORD,
220 (LPBYTE)&dwValue,
221 sizeof(DWORD));
222
223 RegCloseKey(hServiceKey);
224
225 return dwError;
226 }
227
228
229 BOOL
230 ScmIsDeleteFlagSet(HKEY hServiceKey)
231 {
232 DWORD dwError;
233 DWORD dwType;
234 DWORD dwFlag;
235 DWORD dwSize = sizeof(DWORD);
236
237 dwError = RegQueryValueExW(hServiceKey,
238 L"DeleteFlag",
239 0,
240 &dwType,
241 (LPBYTE)&dwFlag,
242 &dwSize);
243
244 return (dwError == ERROR_SUCCESS);
245 }
246
247
248 DWORD
249 ScmReadString(HKEY hServiceKey,
250 LPCWSTR lpValueName,
251 LPWSTR *lpValue)
252 {
253 DWORD dwError = 0;
254 DWORD dwSize = 0;
255 DWORD dwType = 0;
256 LPWSTR ptr = NULL;
257 LPWSTR expanded = NULL;
258
259 *lpValue = NULL;
260
261 dwError = RegQueryValueExW(hServiceKey,
262 lpValueName,
263 0,
264 &dwType,
265 NULL,
266 &dwSize);
267 if (dwError != ERROR_SUCCESS)
268 return dwError;
269
270 ptr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize);
271 if (ptr == NULL)
272 return ERROR_NOT_ENOUGH_MEMORY;
273
274 dwError = RegQueryValueExW(hServiceKey,
275 lpValueName,
276 0,
277 &dwType,
278 (LPBYTE)ptr,
279 &dwSize);
280 if (dwError != ERROR_SUCCESS)
281 {
282 HeapFree(GetProcessHeap(), 0, ptr);
283 return dwError;
284 }
285
286 if (dwType == REG_EXPAND_SZ)
287 {
288 /* Expand the value... */
289 dwSize = ExpandEnvironmentStringsW(ptr, NULL, 0);
290 if (dwSize > 0)
291 {
292 expanded = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize * sizeof(WCHAR));
293 if (expanded)
294 {
295 if (dwSize == ExpandEnvironmentStringsW(ptr, expanded, dwSize))
296 {
297 *lpValue = expanded;
298 dwError = ERROR_SUCCESS;
299 }
300 else
301 {
302 dwError = GetLastError();
303 HeapFree(GetProcessHeap(), 0, expanded);
304 }
305 }
306 else
307 {
308 dwError = ERROR_NOT_ENOUGH_MEMORY;
309 }
310 }
311 else
312 {
313 dwError = GetLastError();
314 }
315
316 HeapFree(GetProcessHeap(), 0, ptr);
317 }
318 else
319 {
320 *lpValue = ptr;
321 }
322
323 return dwError;
324 }
325
326
327 DWORD
328 ScmReadDependencies(HKEY hServiceKey,
329 LPWSTR *lpDependencies,
330 DWORD *lpdwDependenciesLength)
331 {
332 LPWSTR lpGroups = NULL;
333 LPWSTR lpServices = NULL;
334 SIZE_T cchGroupsLength = 0;
335 SIZE_T cchServicesLength = 0;
336 LPWSTR lpSrc;
337 LPWSTR lpDest;
338 SIZE_T cchLength;
339 SIZE_T cchTotalLength;
340
341 *lpDependencies = NULL;
342 *lpdwDependenciesLength = 0;
343
344 /* Read the dependency values */
345 ScmReadString(hServiceKey,
346 L"DependOnGroup",
347 &lpGroups);
348
349 ScmReadString(hServiceKey,
350 L"DependOnService",
351 &lpServices);
352
353 /* Leave, if there are no dependencies */
354 if (lpGroups == NULL && lpServices == NULL)
355 return ERROR_SUCCESS;
356
357 /* Determine the total buffer size for the dependencies */
358 if (lpGroups)
359 {
360 DPRINT("Groups:\n");
361 lpSrc = lpGroups;
362 while (*lpSrc != 0)
363 {
364 DPRINT(" %S\n", lpSrc);
365
366 cchLength = wcslen(lpSrc) + 1;
367 cchGroupsLength += cchLength + 1;
368
369 lpSrc = lpSrc + cchLength;
370 }
371 }
372
373 if (lpServices)
374 {
375 DPRINT("Services:\n");
376 lpSrc = lpServices;
377 while (*lpSrc != 0)
378 {
379 DPRINT(" %S\n", lpSrc);
380
381 cchLength = wcslen(lpSrc) + 1;
382 cchServicesLength += cchLength;
383
384 lpSrc = lpSrc + cchLength;
385 }
386 }
387
388 cchTotalLength = cchGroupsLength + cchServicesLength + 1;
389 DPRINT("cchTotalLength: %lu\n", cchTotalLength);
390
391 /* Allocate the common buffer for the dependencies */
392 *lpDependencies = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cchTotalLength * sizeof(WCHAR));
393 if (*lpDependencies == NULL)
394 {
395 if (lpGroups)
396 HeapFree(GetProcessHeap(), 0, lpGroups);
397
398 if (lpServices)
399 HeapFree(GetProcessHeap(), 0, lpServices);
400
401 return ERROR_NOT_ENOUGH_MEMORY;
402 }
403
404 /* Return the allocated buffer length in characters */
405 *lpdwDependenciesLength = (DWORD)cchTotalLength;
406
407 /* Copy the service dependencies into the common buffer */
408 lpDest = *lpDependencies;
409 if (lpServices)
410 {
411 memcpy(lpDest,
412 lpServices,
413 cchServicesLength * sizeof(WCHAR));
414
415 lpDest = lpDest + cchServicesLength;
416 }
417
418 /* Copy the group dependencies into the common buffer */
419 if (lpGroups)
420 {
421 lpSrc = lpGroups;
422 while (*lpSrc != 0)
423 {
424 cchLength = wcslen(lpSrc) + 1;
425
426 *lpDest = SC_GROUP_IDENTIFIERW;
427 lpDest++;
428
429 wcscpy(lpDest, lpSrc);
430
431 lpDest = lpDest + cchLength;
432 lpSrc = lpSrc + cchLength;
433 }
434 }
435
436 /* Free the temporary buffers */
437 if (lpGroups)
438 HeapFree(GetProcessHeap(), 0, lpGroups);
439
440 if (lpServices)
441 HeapFree(GetProcessHeap(), 0, lpServices);
442
443 return ERROR_SUCCESS;
444 }
445
446 /* EOF */