1 /*
2 * Services - controls services keeps track of their state
3 *
4 * Copyright 2007 Google (Mikolaj Zalewski)
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library 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 GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #define WIN32_LEAN_AND_MEAN
22
23 #include <stdarg.h>
24 #include <windows.h>
25 #include <winsvc.h>
26 #include <rpc.h>
27
28 #include "wine/unicode.h"
29 #include "wine/debug.h"
30 #include "svcctl.h"
31
32 #include "services.h"
33
34 #define MAX_SERVICE_NAME 260
35
36 WINE_DEFAULT_DEBUG_CHANNEL(service);
37
38 HANDLE g_hStartedEvent;
39 struct scmdatabase *active_database;
40
41 static const WCHAR SZ_LOCAL_SYSTEM[] = {'L','o','c','a','l','S','y','s','t','e','m',0};
42
43 /* Registry constants */
44 static const WCHAR SZ_SERVICES_KEY[] = { 'S','y','s','t','e','m','\\',
45 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
46 'S','e','r','v','i','c','e','s',0 };
47
48 /* Service key values names */
49 static const WCHAR SZ_DISPLAY_NAME[] = {'D','i','s','p','l','a','y','N','a','m','e',0 };
50 static const WCHAR SZ_TYPE[] = {'T','y','p','e',0 };
51 static const WCHAR SZ_START[] = {'S','t','a','r','t',0 };
52 static const WCHAR SZ_ERROR[] = {'E','r','r','o','r','C','o','n','t','r','o','l',0 };
53 static const WCHAR SZ_IMAGE_PATH[] = {'I','m','a','g','e','P','a','t','h',0};
54 static const WCHAR SZ_GROUP[] = {'G','r','o','u','p',0};
55 static const WCHAR SZ_DEPEND_ON_SERVICE[] = {'D','e','p','e','n','d','O','n','S','e','r','v','i','c','e',0};
56 static const WCHAR SZ_DEPEND_ON_GROUP[] = {'D','e','p','e','n','d','O','n','G','r','o','u','p',0};
57 static const WCHAR SZ_OBJECT_NAME[] = {'O','b','j','e','c','t','N','a','m','e',0};
58 static const WCHAR SZ_TAG[] = {'T','a','g',0};
59 static const WCHAR SZ_DESCRIPTION[] = {'D','e','s','c','r','i','p','t','i','o','n',0};
60
61
62 DWORD service_create(LPCWSTR name, struct service_entry **entry)
63 {
64 *entry = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**entry));
65 if (!*entry)
66 return ERROR_NOT_ENOUGH_SERVER_MEMORY;
67 (*entry)->name = strdupW(name);
68 if (!(*entry)->name)
69 {
70 HeapFree(GetProcessHeap(), 0, *entry);
71 return ERROR_NOT_ENOUGH_SERVER_MEMORY;
72 }
73 (*entry)->control_pipe = INVALID_HANDLE_VALUE;
74 (*entry)->status.dwCurrentState = SERVICE_STOPPED;
75 (*entry)->status.dwWin32ExitCode = ERROR_SERVICE_NEVER_STARTED;
76 /* all other fields are zero */
77 return ERROR_SUCCESS;
78 }
79
80 void free_service_entry(struct service_entry *entry)
81 {
82 HeapFree(GetProcessHeap(), 0, entry->name);
83 HeapFree(GetProcessHeap(), 0, entry->config.lpBinaryPathName);
84 HeapFree(GetProcessHeap(), 0, entry->config.lpDependencies);
85 HeapFree(GetProcessHeap(), 0, entry->config.lpLoadOrderGroup);
86 HeapFree(GetProcessHeap(), 0, entry->config.lpServiceStartName);
87 HeapFree(GetProcessHeap(), 0, entry->config.lpDisplayName);
88 HeapFree(GetProcessHeap(), 0, entry->description);
89 HeapFree(GetProcessHeap(), 0, entry->dependOnServices);
90 HeapFree(GetProcessHeap(), 0, entry->dependOnGroups);
91 CloseHandle(entry->control_mutex);
92 CloseHandle(entry->control_pipe);
93 CloseHandle(entry->status_changed_event);
94 HeapFree(GetProcessHeap(), 0, entry);
95 }
96
97 static DWORD load_service_config(HKEY hKey, struct service_entry *entry)
98 {
99 DWORD err;
100 WCHAR *wptr;
101
102 if ((err = load_reg_string(hKey, SZ_IMAGE_PATH, TRUE, &entry->config.lpBinaryPathName)) != 0)
103 return err;
104 if ((err = load_reg_string(hKey, SZ_GROUP, 0, &entry->config.lpLoadOrderGroup)) != 0)
105 return err;
106 if ((err = load_reg_string(hKey, SZ_OBJECT_NAME, TRUE, &entry->config.lpServiceStartName)) != 0)
107 return err;
108 if ((err = load_reg_string(hKey, SZ_DISPLAY_NAME, 0, &entry->config.lpDisplayName)) != 0)
109 return err;
110 if ((err = load_reg_string(hKey, SZ_DESCRIPTION, 0, &entry->description)) != 0)
111 return err;
112 if ((err = load_reg_multisz(hKey, SZ_DEPEND_ON_SERVICE, TRUE, &entry->dependOnServices)) != 0)
113 return err;
114 if ((err = load_reg_multisz(hKey, SZ_DEPEND_ON_GROUP, FALSE, &entry->dependOnGroups)) != 0)
115 return err;
116
117 if ((err = load_reg_dword(hKey, SZ_TYPE, &entry->config.dwServiceType)) != 0)
118 return err;
119 if ((err = load_reg_dword(hKey, SZ_START, &entry->config.dwStartType)) != 0)
120 return err;
121 if ((err = load_reg_dword(hKey, SZ_ERROR, &entry->config.dwErrorControl)) != 0)
122 return err;
123 if ((err = load_reg_dword(hKey, SZ_TAG, &entry->config.dwTagId)) != 0)
124 return err;
125
126 WINE_TRACE("Image path = %s\n", wine_dbgstr_w(entry->config.lpBinaryPathName) );
127 WINE_TRACE("Group = %s\n", wine_dbgstr_w(entry->config.lpLoadOrderGroup) );
128 WINE_TRACE("Service account name = %s\n", wine_dbgstr_w(entry->config.lpServiceStartName) );
129 WINE_TRACE("Display name = %s\n", wine_dbgstr_w(entry->config.lpDisplayName) );
130 WINE_TRACE("Service dependencies : %s\n", entry->dependOnServices[0] ? "" : "(none)");
131 for (wptr = entry->dependOnServices; *wptr; wptr += strlenW(wptr) + 1)
132 WINE_TRACE(" * %s\n", wine_dbgstr_w(wptr));
133 WINE_TRACE("Group dependencies : %s\n", entry->dependOnGroups[0] ? "" : "(none)");
134 for (wptr = entry->dependOnGroups; *wptr; wptr += strlenW(wptr) + 1)
135 WINE_TRACE(" * %s\n", wine_dbgstr_w(wptr));
136
137 return ERROR_SUCCESS;
138 }
139
140 static DWORD reg_set_string_value(HKEY hKey, LPCWSTR value_name, LPCWSTR string)
141 {
142 if (!string)
143 {
144 DWORD err;
145 err = RegDeleteValueW(hKey, value_name);
146 if (err != ERROR_FILE_NOT_FOUND)
147 return err;
148
149 return ERROR_SUCCESS;
150 }
151
152 return RegSetValueExW(hKey, value_name, 0, REG_SZ, (LPBYTE)string, sizeof(WCHAR)*(strlenW(string) + 1));
153 }
154
155 DWORD save_service_config(struct service_entry *entry)
156 {
157 DWORD err;
158 HKEY hKey = NULL;
159
160 err = RegCreateKeyW(entry->db->root_key, entry->name, &hKey);
161 if (err != ERROR_SUCCESS)
162 goto cleanup;
163
164 if ((err = reg_set_string_value(hKey, SZ_DISPLAY_NAME, entry->config.lpDisplayName)) != 0)
165 goto cleanup;
166 if ((err = reg_set_string_value(hKey, SZ_IMAGE_PATH, entry->config.lpBinaryPathName)) != 0)
167 goto cleanup;
168 if ((err = reg_set_string_value(hKey, SZ_GROUP, entry->config.lpLoadOrderGroup)) != 0)
169 goto cleanup;
170 if ((err = reg_set_string_value(hKey, SZ_OBJECT_NAME, entry->config.lpServiceStartName)) != 0)
171 goto cleanup;
172 if ((err = reg_set_string_value(hKey, SZ_DESCRIPTION, entry->description)) != 0)
173 goto cleanup;
174 if ((err = RegSetValueExW(hKey, SZ_START, 0, REG_DWORD, (LPBYTE)&entry->config.dwStartType, sizeof(DWORD))) != 0)
175 goto cleanup;
176 if ((err = RegSetValueExW(hKey, SZ_ERROR, 0, REG_DWORD, (LPBYTE)&entry->config.dwErrorControl, sizeof(DWORD))) != 0)
177 goto cleanup;
178
179 if ((err = RegSetValueExW(hKey, SZ_TYPE, 0, REG_DWORD, (LPBYTE)&entry->config.dwServiceType, sizeof(DWORD))) != 0)
180 goto cleanup;
181
182 if (entry->config.dwTagId)
183 err = RegSetValueExW(hKey, SZ_TAG, 0, REG_DWORD, (LPBYTE)&entry->config.dwTagId, sizeof(DWORD));
184 else
185 err = RegDeleteValueW(hKey, SZ_TAG);
186
187 if (err != 0 && err != ERROR_FILE_NOT_FOUND)
188 goto cleanup;
189
190 err = ERROR_SUCCESS;
191 cleanup:
192 RegCloseKey(hKey);
193 return err;
194 }
195
196 DWORD scmdatabase_add_service(struct scmdatabase *db, struct service_entry *service)
197 {
198 int err;
199 service->db = db;
200 if ((err = save_service_config(service)) != ERROR_SUCCESS)
201 {
202 WINE_ERR("Couldn't store service configuration: error %u\n", err);
203 return ERROR_GEN_FAILURE;
204 }
205
206 list_add_tail(&db->services, &service->entry);
207 return ERROR_SUCCESS;
208 }
209
210 DWORD scmdatabase_remove_service(struct scmdatabase *db, struct service_entry *service)
211 {
212 int err;
213
214 err = RegDeleteTreeW(db->root_key, service->name);
215
216 if (err != 0)
217 return err;
218
219 list_remove(&service->entry);
220 service->entry.next = service->entry.prev = NULL;
221 return ERROR_SUCCESS;
222 }
223
224 static void scmdatabase_autostart_services(struct scmdatabase *db)
225 {
226 struct service_entry **services_list;
227 unsigned int i = 0;
228 unsigned int size = 32;
229 struct service_entry *service;
230
231 services_list = HeapAlloc(GetProcessHeap(), 0, size * sizeof(services_list[0]));
232 if (!services_list)
233 return;
234
235 scmdatabase_lock_shared(db);
236
237 LIST_FOR_EACH_ENTRY(service, &db->services, struct service_entry, entry)
238 {
239 if (service->config.dwStartType == SERVICE_BOOT_START ||
240 service->config.dwStartType == SERVICE_SYSTEM_START ||
241 service->config.dwStartType == SERVICE_AUTO_START)
242 {
243 if (i+1 >= size)
244 {
245 size *= 2;
246 services_list = HeapReAlloc(GetProcessHeap(), 0, services_list, size * sizeof(services_list[0]));
247 if (!services_list)
248 break;
249 }
250 services_list[i] = service;
251 service->ref_count++;
252 i++;
253 }
254 }
255
256 scmdatabase_unlock(db);
257
258 size = i;
259 for (i = 0; i < size; i++)
260 {
261 DWORD err;
262 const WCHAR *argv[2];
263 service = services_list[i];
264 argv[0] = service->name;
265 argv[1] = NULL;
266 err = service_start(service, 1, argv);
267 /* FIXME: do something if the service failed to start */
268 release_service(service);
269 }
270
271 HeapFree(GetProcessHeap(), 0, services_list);
272 }
273
274 BOOL validate_service_name(LPCWSTR name)
275 {
276 return (name && name[0] && !strchrW(name, '/') && !strchrW(name, '\\'));
277 }
278
279 BOOL validate_service_config(struct service_entry *entry)
280 {
281 if (entry->config.dwServiceType & SERVICE_WIN32 && (entry->config.lpBinaryPathName == NULL || !entry->config.lpBinaryPathName[0]))
282 {
283 WINE_ERR("Service %s is Win32 but has no image path set\n", wine_dbgstr_w(entry->name));
284 return FALSE;
285 }
286
287 switch (entry->config.dwServiceType)
288 {
289 case SERVICE_KERNEL_DRIVER:
290 case SERVICE_FILE_SYSTEM_DRIVER:
291 case SERVICE_WIN32_OWN_PROCESS:
292 case SERVICE_WIN32_SHARE_PROCESS:
293 /* No problem */
294 break;
295 case SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS:
296 case SERVICE_WIN32_SHARE_PROCESS | SERVICE_INTERACTIVE_PROCESS:
297 /* These can be only run as LocalSystem */
298 if (entry->config.lpServiceStartName && strcmpiW(entry->config.lpServiceStartName, SZ_LOCAL_SYSTEM) != 0)
299 {
300 WINE_ERR("Service %s is interactive but has a start name\n", wine_dbgstr_w(entry->name));
301 return FALSE;
302 }
303 break;
304 default:
305 WINE_ERR("Service %s has an unknown service type\n", wine_dbgstr_w(entry->name));
306 return FALSE;
307 }
308
309 /* StartType can only be a single value (if several values are mixed the result is probably not what was intended) */
310 if (entry->config.dwStartType > SERVICE_DISABLED)
311 {
312 WINE_ERR("Service %s has an unknown start type\n", wine_dbgstr_w(entry->name));
313 return FALSE;
314 }
315
316 /* SERVICE_BOOT_START and SERVICE_SYSTEM_START are only allowed for driver services */
317 if (((entry->config.dwStartType == SERVICE_BOOT_START) || (entry->config.dwStartType == SERVICE_SYSTEM_START)) &&
318 ((entry->config.dwServiceType & SERVICE_WIN32_OWN_PROCESS) || (entry->config.dwServiceType & SERVICE_WIN32_SHARE_PROCESS)))
319 {
320 WINE_ERR("Service %s - SERVICE_BOOT_START and SERVICE_SYSTEM_START are only allowed for driver services\n", wine_dbgstr_w(entry->name));
321 return FALSE;
322 }
323
324 if (entry->config.lpServiceStartName == NULL)
325 entry->config.lpServiceStartName = strdupW(SZ_LOCAL_SYSTEM);
326
327 return TRUE;
328 }
329
330
331 struct service_entry *scmdatabase_find_service(struct scmdatabase *db, LPCWSTR name)
332 {
333 struct service_entry *service;
334
335 LIST_FOR_EACH_ENTRY(service, &db->services, struct service_entry, entry)
336 {
337 if (strcmpiW(name, service->name) == 0)
338 return service;
339 }
340
341 return NULL;
342 }
343
344 struct service_entry *scmdatabase_find_service_by_displayname(struct scmdatabase *db, LPCWSTR name)
345 {
346 struct service_entry *service;
347
348 LIST_FOR_EACH_ENTRY(service, &db->services, struct service_entry, entry)
349 {
350 if (strcmpiW(name, service->config.lpDisplayName) == 0)
351 return service;
352 }
353
354 return NULL;
355 }
356
357 void release_service(struct service_entry *service)
358 {
359 if (InterlockedDecrement(&service->ref_count) == 0 && is_marked_for_delete(service))
360 free_service_entry(service);
361 }
362
363 static DWORD scmdatabase_create(struct scmdatabase **db)
364 {
365 DWORD err;
366
367 *db = HeapAlloc(GetProcessHeap(), 0, sizeof(**db));
368 if (!*db)
369 return ERROR_NOT_ENOUGH_SERVER_MEMORY;
370
371 (*db)->service_start_lock = FALSE;
372 list_init(&(*db)->services);
373
374 InitializeCriticalSection(&(*db)->cs);
375
376 err = RegCreateKeyExW(HKEY_LOCAL_MACHINE, SZ_SERVICES_KEY, 0, NULL,
377 REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
378 &(*db)->root_key, NULL);
379 if (err != ERROR_SUCCESS)
380 HeapFree(GetProcessHeap(), 0, *db);
381
382 return err;
383 }
384
385 static void scmdatabase_destroy(struct scmdatabase *db)
386 {
387 RegCloseKey(db->root_key);
388 DeleteCriticalSection(&db->cs);
389 HeapFree(GetProcessHeap(), 0, db);
390 }
391
392 static DWORD scmdatabase_load_services(struct scmdatabase *db)
393 {
394 DWORD err;
395 int i;
396
397 for (i = 0; TRUE; i++)
398 {
399 WCHAR szName[MAX_SERVICE_NAME];
400 struct service_entry *entry;
401 HKEY hServiceKey;
402
403 err = RegEnumKeyW(db->root_key, i, szName, MAX_SERVICE_NAME);
404 if (err == ERROR_NO_MORE_ITEMS)
405 break;
406
407 if (err != 0)
408 {
409 WINE_ERR("Error %d reading key %d name - skipping\n", err, i);
410 continue;
411 }
412
413 err = service_create(szName, &entry);
414 if (err != ERROR_SUCCESS)
415 break;
416
417 WINE_TRACE("Loading service %s\n", wine_dbgstr_w(szName));
418 err = RegOpenKeyExW(db->root_key, szName, 0, KEY_READ | KEY_WRITE, &hServiceKey);
419 if (err == ERROR_SUCCESS)
420 {
421 err = load_service_config(hServiceKey, entry);
422 RegCloseKey(hServiceKey);
423 }
424
425 if (err != ERROR_SUCCESS)
426 {
427 WINE_ERR("Error %d reading registry key for service %s - skipping\n", err, wine_dbgstr_w(szName));
428 free_service_entry(entry);
429 continue;
430 }
431
432 if (entry->config.dwServiceType == 0)
433 {
434 /* Maybe an application only wrote some configuration in the service key. Continue silently */
435 WINE_TRACE("Even the service type not set for service %s - skipping\n", wine_dbgstr_w(szName));
436 free_service_entry(entry);
437 continue;
438 }
439
440 if (!validate_service_config(entry))
441 {
442 WINE_ERR("Invalid configuration of service %s - skipping\n", wine_dbgstr_w(szName));
443 free_service_entry(entry);
444 continue;
445 }
446
447 entry->status.dwServiceType = entry->config.dwServiceType;
448 entry->db = db;
449
450 list_add_tail(&db->services, &entry->entry);
451 }
452 return ERROR_SUCCESS;
453 }
454
455 DWORD scmdatabase_lock_startup(struct scmdatabase *db)
456 {
457 if (InterlockedCompareExchange(&db->service_start_lock, TRUE, FALSE))
458 return ERROR_SERVICE_DATABASE_LOCKED;
459 return ERROR_SUCCESS;
460 }
461
462 void scmdatabase_unlock_startup(struct scmdatabase *db)
463 {
464 InterlockedCompareExchange(&db->service_start_lock, FALSE, TRUE);
465 }
466
467 void scmdatabase_lock_shared(struct scmdatabase *db)
468 {
469 EnterCriticalSection(&db->cs);
470 }
471
472 void scmdatabase_lock_exclusive(struct scmdatabase *db)
473 {
474 EnterCriticalSection(&db->cs);
475 }
476
477 void scmdatabase_unlock(struct scmdatabase *db)
478 {
479 LeaveCriticalSection(&db->cs);
480 }
481
482 void service_lock_shared(struct service_entry *service)
483 {
484 EnterCriticalSection(&service->db->cs);
485 }
486
487 void service_lock_exclusive(struct service_entry *service)
488 {
489 EnterCriticalSection(&service->db->cs);
490 }
491
492 void service_unlock(struct service_entry *service)
493 {
494 LeaveCriticalSection(&service->db->cs);
495 }
496
497 /* only one service started at a time, so there is no race on the registry
498 * value here */
499 static LPWSTR service_get_pipe_name(void)
500 {
501 static const WCHAR format[] = { '\\','\\','.','\\','p','i','p','e','\\',
502 'n','e','t','\\','N','t','C','o','n','t','r','o','l','P','i','p','e','%','u',0};
503 static const WCHAR service_current_key_str[] = { 'S','Y','S','T','E','M','\\',
504 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
505 'C','o','n','t','r','o','l','\\',
506 'S','e','r','v','i','c','e','C','u','r','r','e','n','t',0};
507 LPWSTR name;
508 DWORD len;
509 HKEY service_current_key;
510 DWORD service_current = -1;
511 LONG ret;
512 DWORD type;
513
514 ret = RegCreateKeyExW(HKEY_LOCAL_MACHINE, service_current_key_str, 0,
515 NULL, REG_OPTION_VOLATILE, KEY_SET_VALUE | KEY_QUERY_VALUE, NULL,
516 &service_current_key, NULL);
517 if (ret != ERROR_SUCCESS)
518 return NULL;
519 len = sizeof(service_current);
520 ret = RegQueryValueExW(service_current_key, NULL, NULL, &type,
521 (BYTE *)&service_current, &len);
522 if ((ret == ERROR_SUCCESS && type == REG_DWORD) || ret == ERROR_FILE_NOT_FOUND)
523 {
524 service_current++;
525 RegSetValueExW(service_current_key, NULL, 0, REG_DWORD,
526 (BYTE *)&service_current, sizeof(service_current));
527 }
528 RegCloseKey(service_current_key);
529 if ((ret != ERROR_SUCCESS || type != REG_DWORD) && (ret != ERROR_FILE_NOT_FOUND))
530 return NULL;
531 len = sizeof(format)/sizeof(WCHAR) + 10 /* strlenW("4294967295") */;
532 name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
533 if (!name)
534 return NULL;
535 snprintfW(name, len, format, service_current);
536 return name;
537 }
538
539 static DWORD service_start_process(struct service_entry *service_entry, HANDLE *process)
540 {
541 PROCESS_INFORMATION pi;
542 STARTUPINFOW si;
543 LPWSTR path = NULL;
544 DWORD size;
545 BOOL r;
546
547 service_lock_exclusive(service_entry);
548
549 if (service_entry->config.dwServiceType == SERVICE_KERNEL_DRIVER)
550 {
551 static const WCHAR winedeviceW[] = {'\\','w','i','n','e','d','e','v','i','c','e','.','e','x','e',' ',0};
552 DWORD len = GetSystemDirectoryW( NULL, 0 ) + sizeof(winedeviceW)/sizeof(WCHAR) + strlenW(service_entry->name);
553
554 if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
555 return ERROR_NOT_ENOUGH_SERVER_MEMORY;
556 GetSystemDirectoryW( path, len );
557 lstrcatW( path, winedeviceW );
558 lstrcatW( path, service_entry->name );
559 }
560 else
561 {
562 size = ExpandEnvironmentStringsW(service_entry->config.lpBinaryPathName,NULL,0);
563 path = HeapAlloc(GetProcessHeap(),0,size*sizeof(WCHAR));
564 if (!path)
565 return ERROR_NOT_ENOUGH_SERVER_MEMORY;
566 ExpandEnvironmentStringsW(service_entry->config.lpBinaryPathName,path,size);
567 }
568
569 ZeroMemory(&si, sizeof(STARTUPINFOW));
570 si.cb = sizeof(STARTUPINFOW);
571 if (!(service_entry->config.dwServiceType & SERVICE_INTERACTIVE_PROCESS))
572 {
573 static WCHAR desktopW[] = {'_','_','w','i','n','e','s','e','r','v','i','c','e','_','w','i','n','s','t','a','t','i','o','n','\\','D','e','f','a','u','l','t',0};
574 si.lpDesktop = desktopW;
575 }
576
577 service_entry->status.dwCurrentState = SERVICE_START_PENDING;
578 service_entry->status.dwProcessId = pi.dwProcessId;
579
580 service_unlock(service_entry);
581
582 r = CreateProcessW(NULL, path, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
583 HeapFree(GetProcessHeap(),0,path);
584 if (!r)
585 {
586 service_lock_exclusive(service_entry);
587 service_entry->status.dwCurrentState = SERVICE_STOPPED;
588 service_entry->status.dwProcessId = 0;
589 service_unlock(service_entry);
590 return GetLastError();
591 }
592
593 *process = pi.hProcess;
594 CloseHandle( pi.hThread );
595
596 return ERROR_SUCCESS;
597 }
598
599 static DWORD service_wait_for_startup(struct service_entry *service_entry, HANDLE process_handle)
600 {
601 WINE_TRACE("%p\n", service_entry);
602
603 for (;;)
604 {
605 DWORD dwCurrentStatus;
606 HANDLE handles[2] = { service_entry->status_changed_event, process_handle };
607 DWORD ret;
608 ret = WaitForMultipleObjects(sizeof(handles)/sizeof(handles[0]), handles, FALSE, 20000);
609 if (ret != WAIT_OBJECT_0)
610 return ERROR_SERVICE_REQUEST_TIMEOUT;
611 service_lock_shared(service_entry);
612 dwCurrentStatus = service_entry->status.dwCurrentState;
613 service_unlock(service_entry);
614 if (dwCurrentStatus == SERVICE_RUNNING)
615 {
616 WINE_TRACE("Service started successfully\n");
617 return ERROR_SUCCESS;
618 }
619 if (dwCurrentStatus != SERVICE_START_PENDING)
620 return ERROR_SERVICE_REQUEST_TIMEOUT;
621 }
622 }
623
624 /******************************************************************************
625 * service_send_start_message
626 */
627 static BOOL service_send_start_message(struct service_entry *service, LPCWSTR *argv, DWORD argc)
628 {
629 DWORD i, len, count, result;
630 service_start_info *ssi;
631 LPWSTR p;
632 BOOL r;
633
634 WINE_TRACE("%s %p %d\n", wine_dbgstr_w(service->name), argv, argc);
635
636 /* FIXME: this can block so should be done in another thread */
637 r = ConnectNamedPipe(service->control_pipe, NULL);
638 if (!r && GetLastError() != ERROR_PIPE_CONNECTED)
639 {
640 WINE_ERR("pipe connect failed\n");
641 return FALSE;
642 }
643
644 /* calculate how much space do we need to send the startup info */
645 len = strlenW(service->name) + 1;
646 for (i=0; i<argc; i++)
647 len += strlenW(argv[i])+1;
648 len++;
649
650 ssi = HeapAlloc(GetProcessHeap(),0,FIELD_OFFSET(service_start_info, data[len]));
651 ssi->cmd = WINESERV_STARTINFO;
652 ssi->control = 0;
653 ssi->total_size = FIELD_OFFSET(service_start_info, data[len]);
654 ssi->name_size = strlenW(service->name) + 1;
655 strcpyW( ssi->data, service->name );
656
657 /* copy service args into a single buffer*/
658 p = &ssi->data[ssi->name_size];
659 for (i=0; i<argc; i++)
660 {
661 strcpyW(p, argv[i]);
662 p += strlenW(p) + 1;
663 }
664 *p=0;
665
666 r = WriteFile(service->control_pipe, ssi, ssi->total_size, &count, NULL);
667 if (r)
668 {
669 r = ReadFile(service->control_pipe, &result, sizeof result, &count, NULL);
670 if (r && result)
671 {
672 SetLastError(result);
673 r = FALSE;
674 }
675 }
676
677 HeapFree(GetProcessHeap(),0,ssi);
678
679 return r;
680 }
681
682 DWORD service_start(struct service_entry *service, DWORD service_argc, LPCWSTR *service_argv)
683 {
684 DWORD err;
685 LPWSTR name;
686 HANDLE process_handle = NULL;
687
688 err = scmdatabase_lock_startup(service->db);
689 if (err != ERROR_SUCCESS)
690 return err;
691
692 if (service->control_pipe != INVALID_HANDLE_VALUE)
693 {
694 scmdatabase_unlock_startup(service->db);
695 return ERROR_SERVICE_ALREADY_RUNNING;
696 }
697
698 service->control_mutex = CreateMutexW(NULL, TRUE, NULL);
699
700 if (!service->status_changed_event)
701 service->status_changed_event = CreateEventW(NULL, FALSE, FALSE, NULL);
702
703 name = service_get_pipe_name();
704 service->control_pipe = CreateNamedPipeW(name, PIPE_ACCESS_DUPLEX,
705 PIPE_TYPE_BYTE|PIPE_WAIT, 1, 256, 256, 10000, NULL );
706 HeapFree(GetProcessHeap(), 0, name);
707 if (service->control_pipe==INVALID_HANDLE_VALUE)
708 {
709 WINE_ERR("failed to create pipe for %s, error = %d\n",
710 wine_dbgstr_w(service->name), GetLastError());
711 scmdatabase_unlock_startup(service->db);
712 return GetLastError();
713 }
714
715 err = service_start_process(service, &process_handle);
716
717 if (err == ERROR_SUCCESS)
718 {
719 if (!service_send_start_message(service, service_argv, service_argc))
720 err = ERROR_SERVICE_REQUEST_TIMEOUT;
721 }
722
723 if (err == ERROR_SUCCESS)
724 err = service_wait_for_startup(service, process_handle);
725
726 if (process_handle)
727 CloseHandle(process_handle);
728
729 ReleaseMutex(service->control_mutex);
730 scmdatabase_unlock_startup(service->db);
731
732 WINE_TRACE("returning %d\n", err);
733
734 return err;
735 }
736
737
738 int main(int argc, char *argv[])
739 {
740 static const WCHAR svcctl_started_event[] = SVCCTL_STARTED_EVENT;
741 DWORD err;
742 g_hStartedEvent = CreateEventW(NULL, TRUE, FALSE, svcctl_started_event);
743 err = scmdatabase_create(&active_database);
744 if (err != ERROR_SUCCESS)
745 return err;
746 if ((err = scmdatabase_load_services(active_database)) != ERROR_SUCCESS)
747 return err;
748 if ((err = RPC_Init()) == ERROR_SUCCESS)
749 {
750 scmdatabase_autostart_services(active_database);
751 RPC_MainLoop();
752 }
753 scmdatabase_destroy(active_database);
754 return err;
755 }
756
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.