2 * Services - controls services keeps track of their state
4 * Copyright 2007 Google (Mikolaj Zalewski)
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.
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.
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
21 #define WIN32_LEAN_AND_MEAN
28 #include "wine/unicode.h"
29 #include "wine/debug.h"
34 #define MAX_SERVICE_NAME 260
36 WINE_DEFAULT_DEBUG_CHANNEL(service
);
38 HANDLE g_hStartedEvent
;
39 struct scmdatabase
*active_database
;
41 DWORD service_pipe_timeout
= 10000;
42 DWORD service_kill_timeout
= 20000;
44 static const int is_win64
= (sizeof(void *) > sizeof(int));
46 static const WCHAR SZ_LOCAL_SYSTEM
[] = {'L','o','c','a','l','S','y','s','t','e','m',0};
48 /* Registry constants */
49 static const WCHAR SZ_SERVICES_KEY
[] = { 'S','y','s','t','e','m','\\',
50 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
51 'S','e','r','v','i','c','e','s',0 };
53 /* Service key values names */
54 static const WCHAR SZ_DISPLAY_NAME
[] = {'D','i','s','p','l','a','y','N','a','m','e',0 };
55 static const WCHAR SZ_TYPE
[] = {'T','y','p','e',0 };
56 static const WCHAR SZ_START
[] = {'S','t','a','r','t',0 };
57 static const WCHAR SZ_ERROR
[] = {'E','r','r','o','r','C','o','n','t','r','o','l',0 };
58 static const WCHAR SZ_IMAGE_PATH
[] = {'I','m','a','g','e','P','a','t','h',0};
59 static const WCHAR SZ_GROUP
[] = {'G','r','o','u','p',0};
60 static const WCHAR SZ_DEPEND_ON_SERVICE
[] = {'D','e','p','e','n','d','O','n','S','e','r','v','i','c','e',0};
61 static const WCHAR SZ_DEPEND_ON_GROUP
[] = {'D','e','p','e','n','d','O','n','G','r','o','u','p',0};
62 static const WCHAR SZ_OBJECT_NAME
[] = {'O','b','j','e','c','t','N','a','m','e',0};
63 static const WCHAR SZ_TAG
[] = {'T','a','g',0};
64 static const WCHAR SZ_DESCRIPTION
[] = {'D','e','s','c','r','i','p','t','i','o','n',0};
67 DWORD
service_create(LPCWSTR name
, struct service_entry
**entry
)
69 *entry
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(**entry
));
71 return ERROR_NOT_ENOUGH_SERVER_MEMORY
;
72 (*entry
)->name
= strdupW(name
);
75 HeapFree(GetProcessHeap(), 0, *entry
);
76 return ERROR_NOT_ENOUGH_SERVER_MEMORY
;
78 (*entry
)->control_pipe
= INVALID_HANDLE_VALUE
;
79 (*entry
)->status
.dwCurrentState
= SERVICE_STOPPED
;
80 (*entry
)->status
.dwWin32ExitCode
= ERROR_SERVICE_NEVER_STARTED
;
81 /* all other fields are zero */
85 void free_service_entry(struct service_entry
*entry
)
87 HeapFree(GetProcessHeap(), 0, entry
->name
);
88 HeapFree(GetProcessHeap(), 0, entry
->config
.lpBinaryPathName
);
89 HeapFree(GetProcessHeap(), 0, entry
->config
.lpDependencies
);
90 HeapFree(GetProcessHeap(), 0, entry
->config
.lpLoadOrderGroup
);
91 HeapFree(GetProcessHeap(), 0, entry
->config
.lpServiceStartName
);
92 HeapFree(GetProcessHeap(), 0, entry
->config
.lpDisplayName
);
93 HeapFree(GetProcessHeap(), 0, entry
->description
);
94 HeapFree(GetProcessHeap(), 0, entry
->dependOnServices
);
95 HeapFree(GetProcessHeap(), 0, entry
->dependOnGroups
);
96 CloseHandle(entry
->control_mutex
);
97 CloseHandle(entry
->control_pipe
);
98 CloseHandle(entry
->overlapped_event
);
99 CloseHandle(entry
->status_changed_event
);
100 HeapFree(GetProcessHeap(), 0, entry
);
103 static DWORD
load_service_config(HKEY hKey
, struct service_entry
*entry
)
108 if ((err
= load_reg_string(hKey
, SZ_IMAGE_PATH
, TRUE
, &entry
->config
.lpBinaryPathName
)) != 0)
110 if ((err
= load_reg_string(hKey
, SZ_GROUP
, 0, &entry
->config
.lpLoadOrderGroup
)) != 0)
112 if ((err
= load_reg_string(hKey
, SZ_OBJECT_NAME
, TRUE
, &entry
->config
.lpServiceStartName
)) != 0)
114 if ((err
= load_reg_string(hKey
, SZ_DISPLAY_NAME
, 0, &entry
->config
.lpDisplayName
)) != 0)
116 if ((err
= load_reg_string(hKey
, SZ_DESCRIPTION
, 0, &entry
->description
)) != 0)
118 if ((err
= load_reg_multisz(hKey
, SZ_DEPEND_ON_SERVICE
, TRUE
, &entry
->dependOnServices
)) != 0)
120 if ((err
= load_reg_multisz(hKey
, SZ_DEPEND_ON_GROUP
, FALSE
, &entry
->dependOnGroups
)) != 0)
123 if ((err
= load_reg_dword(hKey
, SZ_TYPE
, &entry
->config
.dwServiceType
)) != 0)
125 if ((err
= load_reg_dword(hKey
, SZ_START
, &entry
->config
.dwStartType
)) != 0)
127 if ((err
= load_reg_dword(hKey
, SZ_ERROR
, &entry
->config
.dwErrorControl
)) != 0)
129 if ((err
= load_reg_dword(hKey
, SZ_TAG
, &entry
->config
.dwTagId
)) != 0)
132 WINE_TRACE("Image path = %s\n", wine_dbgstr_w(entry
->config
.lpBinaryPathName
) );
133 WINE_TRACE("Group = %s\n", wine_dbgstr_w(entry
->config
.lpLoadOrderGroup
) );
134 WINE_TRACE("Service account name = %s\n", wine_dbgstr_w(entry
->config
.lpServiceStartName
) );
135 WINE_TRACE("Display name = %s\n", wine_dbgstr_w(entry
->config
.lpDisplayName
) );
136 WINE_TRACE("Service dependencies : %s\n", entry
->dependOnServices
[0] ? "" : "(none)");
137 for (wptr
= entry
->dependOnServices
; *wptr
; wptr
+= strlenW(wptr
) + 1)
138 WINE_TRACE(" * %s\n", wine_dbgstr_w(wptr
));
139 WINE_TRACE("Group dependencies : %s\n", entry
->dependOnGroups
[0] ? "" : "(none)");
140 for (wptr
= entry
->dependOnGroups
; *wptr
; wptr
+= strlenW(wptr
) + 1)
141 WINE_TRACE(" * %s\n", wine_dbgstr_w(wptr
));
143 return ERROR_SUCCESS
;
146 static DWORD
reg_set_string_value(HKEY hKey
, LPCWSTR value_name
, LPCWSTR string
)
151 err
= RegDeleteValueW(hKey
, value_name
);
152 if (err
!= ERROR_FILE_NOT_FOUND
)
155 return ERROR_SUCCESS
;
158 return RegSetValueExW(hKey
, value_name
, 0, REG_SZ
, (const BYTE
*)string
, sizeof(WCHAR
)*(strlenW(string
) + 1));
161 static DWORD
reg_set_multisz_value(HKEY hKey
, LPCWSTR value_name
, LPCWSTR string
)
168 err
= RegDeleteValueW(hKey
, value_name
);
169 if (err
!= ERROR_FILE_NOT_FOUND
)
172 return ERROR_SUCCESS
;
176 while (*ptr
) ptr
+= strlenW(ptr
) + 1;
177 return RegSetValueExW(hKey
, value_name
, 0, REG_MULTI_SZ
, (const BYTE
*)string
, sizeof(WCHAR
)*(ptr
- string
+ 1));
180 DWORD
save_service_config(struct service_entry
*entry
)
185 err
= RegCreateKeyW(entry
->db
->root_key
, entry
->name
, &hKey
);
186 if (err
!= ERROR_SUCCESS
)
189 if ((err
= reg_set_string_value(hKey
, SZ_DISPLAY_NAME
, entry
->config
.lpDisplayName
)) != 0)
191 if ((err
= reg_set_string_value(hKey
, SZ_IMAGE_PATH
, entry
->config
.lpBinaryPathName
)) != 0)
193 if ((err
= reg_set_string_value(hKey
, SZ_GROUP
, entry
->config
.lpLoadOrderGroup
)) != 0)
195 if ((err
= reg_set_string_value(hKey
, SZ_OBJECT_NAME
, entry
->config
.lpServiceStartName
)) != 0)
197 if ((err
= reg_set_string_value(hKey
, SZ_DESCRIPTION
, entry
->description
)) != 0)
199 if ((err
= reg_set_multisz_value(hKey
, SZ_DEPEND_ON_SERVICE
, entry
->dependOnServices
)) != 0)
201 if ((err
= reg_set_multisz_value(hKey
, SZ_DEPEND_ON_GROUP
, entry
->dependOnGroups
)) != 0)
203 if ((err
= RegSetValueExW(hKey
, SZ_START
, 0, REG_DWORD
, (LPBYTE
)&entry
->config
.dwStartType
, sizeof(DWORD
))) != 0)
205 if ((err
= RegSetValueExW(hKey
, SZ_ERROR
, 0, REG_DWORD
, (LPBYTE
)&entry
->config
.dwErrorControl
, sizeof(DWORD
))) != 0)
208 if ((err
= RegSetValueExW(hKey
, SZ_TYPE
, 0, REG_DWORD
, (LPBYTE
)&entry
->config
.dwServiceType
, sizeof(DWORD
))) != 0)
211 if (entry
->config
.dwTagId
)
212 err
= RegSetValueExW(hKey
, SZ_TAG
, 0, REG_DWORD
, (LPBYTE
)&entry
->config
.dwTagId
, sizeof(DWORD
));
214 err
= RegDeleteValueW(hKey
, SZ_TAG
);
216 if (err
!= 0 && err
!= ERROR_FILE_NOT_FOUND
)
225 DWORD
scmdatabase_add_service(struct scmdatabase
*db
, struct service_entry
*service
)
229 if ((err
= save_service_config(service
)) != ERROR_SUCCESS
)
231 WINE_ERR("Couldn't store service configuration: error %u\n", err
);
232 return ERROR_GEN_FAILURE
;
235 list_add_tail(&db
->services
, &service
->entry
);
236 return ERROR_SUCCESS
;
239 DWORD
scmdatabase_remove_service(struct scmdatabase
*db
, struct service_entry
*service
)
243 err
= RegDeleteTreeW(db
->root_key
, service
->name
);
248 list_remove(&service
->entry
);
249 service
->entry
.next
= service
->entry
.prev
= NULL
;
250 return ERROR_SUCCESS
;
253 static void scmdatabase_autostart_services(struct scmdatabase
*db
)
255 struct service_entry
**services_list
;
257 unsigned int size
= 32;
258 struct service_entry
*service
;
260 services_list
= HeapAlloc(GetProcessHeap(), 0, size
* sizeof(services_list
[0]));
264 scmdatabase_lock_shared(db
);
266 LIST_FOR_EACH_ENTRY(service
, &db
->services
, struct service_entry
, entry
)
268 if (service
->config
.dwStartType
== SERVICE_BOOT_START
||
269 service
->config
.dwStartType
== SERVICE_SYSTEM_START
||
270 service
->config
.dwStartType
== SERVICE_AUTO_START
)
274 struct service_entry
**slist_new
;
276 slist_new
= HeapReAlloc(GetProcessHeap(), 0, services_list
, size
* sizeof(services_list
[0]));
279 services_list
= slist_new
;
281 services_list
[i
] = service
;
282 service
->ref_count
++;
287 scmdatabase_unlock(db
);
290 for (i
= 0; i
< size
; i
++)
293 const WCHAR
*argv
[2];
294 service
= services_list
[i
];
295 argv
[0] = service
->name
;
297 err
= service_start(service
, 1, argv
);
298 if (err
!= ERROR_SUCCESS
)
299 WINE_FIXME("Auto-start service %s failed to start: %d\n",
300 wine_dbgstr_w(service
->name
), err
);
301 release_service(service
);
304 HeapFree(GetProcessHeap(), 0, services_list
);
307 BOOL
validate_service_name(LPCWSTR name
)
309 return (name
&& name
[0] && !strchrW(name
, '/') && !strchrW(name
, '\\'));
312 BOOL
validate_service_config(struct service_entry
*entry
)
314 if (entry
->config
.dwServiceType
& SERVICE_WIN32
&& (entry
->config
.lpBinaryPathName
== NULL
|| !entry
->config
.lpBinaryPathName
[0]))
316 WINE_ERR("Service %s is Win32 but has no image path set\n", wine_dbgstr_w(entry
->name
));
320 switch (entry
->config
.dwServiceType
)
322 case SERVICE_KERNEL_DRIVER
:
323 case SERVICE_FILE_SYSTEM_DRIVER
:
324 case SERVICE_WIN32_OWN_PROCESS
:
325 case SERVICE_WIN32_SHARE_PROCESS
:
328 case SERVICE_WIN32_OWN_PROCESS
| SERVICE_INTERACTIVE_PROCESS
:
329 case SERVICE_WIN32_SHARE_PROCESS
| SERVICE_INTERACTIVE_PROCESS
:
330 /* These can be only run as LocalSystem */
331 if (entry
->config
.lpServiceStartName
&& strcmpiW(entry
->config
.lpServiceStartName
, SZ_LOCAL_SYSTEM
) != 0)
333 WINE_ERR("Service %s is interactive but has a start name\n", wine_dbgstr_w(entry
->name
));
338 WINE_ERR("Service %s has an unknown service type (0x%x)\n", wine_dbgstr_w(entry
->name
), entry
->config
.dwServiceType
);
342 /* StartType can only be a single value (if several values are mixed the result is probably not what was intended) */
343 if (entry
->config
.dwStartType
> SERVICE_DISABLED
)
345 WINE_ERR("Service %s has an unknown start type\n", wine_dbgstr_w(entry
->name
));
349 /* SERVICE_BOOT_START and SERVICE_SYSTEM_START are only allowed for driver services */
350 if (((entry
->config
.dwStartType
== SERVICE_BOOT_START
) || (entry
->config
.dwStartType
== SERVICE_SYSTEM_START
)) &&
351 ((entry
->config
.dwServiceType
& SERVICE_WIN32_OWN_PROCESS
) || (entry
->config
.dwServiceType
& SERVICE_WIN32_SHARE_PROCESS
)))
353 WINE_ERR("Service %s - SERVICE_BOOT_START and SERVICE_SYSTEM_START are only allowed for driver services\n", wine_dbgstr_w(entry
->name
));
357 if (entry
->config
.lpServiceStartName
== NULL
)
358 entry
->config
.lpServiceStartName
= strdupW(SZ_LOCAL_SYSTEM
);
364 struct service_entry
*scmdatabase_find_service(struct scmdatabase
*db
, LPCWSTR name
)
366 struct service_entry
*service
;
368 LIST_FOR_EACH_ENTRY(service
, &db
->services
, struct service_entry
, entry
)
370 if (strcmpiW(name
, service
->name
) == 0)
377 struct service_entry
*scmdatabase_find_service_by_displayname(struct scmdatabase
*db
, LPCWSTR name
)
379 struct service_entry
*service
;
381 LIST_FOR_EACH_ENTRY(service
, &db
->services
, struct service_entry
, entry
)
383 if (service
->config
.lpDisplayName
&& strcmpiW(name
, service
->config
.lpDisplayName
) == 0)
390 void release_service(struct service_entry
*service
)
392 if (InterlockedDecrement(&service
->ref_count
) == 0 && is_marked_for_delete(service
))
393 free_service_entry(service
);
396 static DWORD
scmdatabase_create(struct scmdatabase
**db
)
400 *db
= HeapAlloc(GetProcessHeap(), 0, sizeof(**db
));
402 return ERROR_NOT_ENOUGH_SERVER_MEMORY
;
404 (*db
)->service_start_lock
= FALSE
;
405 list_init(&(*db
)->services
);
407 InitializeCriticalSection(&(*db
)->cs
);
409 err
= RegCreateKeyExW(HKEY_LOCAL_MACHINE
, SZ_SERVICES_KEY
, 0, NULL
,
410 REG_OPTION_NON_VOLATILE
, MAXIMUM_ALLOWED
, NULL
,
411 &(*db
)->root_key
, NULL
);
412 if (err
!= ERROR_SUCCESS
)
413 HeapFree(GetProcessHeap(), 0, *db
);
418 static void scmdatabase_destroy(struct scmdatabase
*db
)
420 RegCloseKey(db
->root_key
);
421 DeleteCriticalSection(&db
->cs
);
422 HeapFree(GetProcessHeap(), 0, db
);
425 static DWORD
scmdatabase_load_services(struct scmdatabase
*db
)
430 for (i
= 0; TRUE
; i
++)
432 WCHAR szName
[MAX_SERVICE_NAME
];
433 struct service_entry
*entry
;
436 err
= RegEnumKeyW(db
->root_key
, i
, szName
, MAX_SERVICE_NAME
);
437 if (err
== ERROR_NO_MORE_ITEMS
)
442 WINE_ERR("Error %d reading key %d name - skipping\n", err
, i
);
446 err
= service_create(szName
, &entry
);
447 if (err
!= ERROR_SUCCESS
)
450 WINE_TRACE("Loading service %s\n", wine_dbgstr_w(szName
));
451 err
= RegOpenKeyExW(db
->root_key
, szName
, 0, KEY_READ
, &hServiceKey
);
452 if (err
== ERROR_SUCCESS
)
454 err
= load_service_config(hServiceKey
, entry
);
455 RegCloseKey(hServiceKey
);
458 if (err
!= ERROR_SUCCESS
)
460 WINE_ERR("Error %d reading registry key for service %s - skipping\n", err
, wine_dbgstr_w(szName
));
461 free_service_entry(entry
);
465 if (entry
->config
.dwServiceType
== 0)
467 /* Maybe an application only wrote some configuration in the service key. Continue silently */
468 WINE_TRACE("Even the service type not set for service %s - skipping\n", wine_dbgstr_w(szName
));
469 free_service_entry(entry
);
473 if (!validate_service_config(entry
))
475 WINE_ERR("Invalid configuration of service %s - skipping\n", wine_dbgstr_w(szName
));
476 free_service_entry(entry
);
480 entry
->status
.dwServiceType
= entry
->config
.dwServiceType
;
483 list_add_tail(&db
->services
, &entry
->entry
);
485 return ERROR_SUCCESS
;
488 DWORD
scmdatabase_lock_startup(struct scmdatabase
*db
)
490 if (InterlockedCompareExchange(&db
->service_start_lock
, TRUE
, FALSE
))
491 return ERROR_SERVICE_DATABASE_LOCKED
;
492 return ERROR_SUCCESS
;
495 void scmdatabase_unlock_startup(struct scmdatabase
*db
)
497 InterlockedCompareExchange(&db
->service_start_lock
, FALSE
, TRUE
);
500 void scmdatabase_lock_shared(struct scmdatabase
*db
)
502 EnterCriticalSection(&db
->cs
);
505 void scmdatabase_lock_exclusive(struct scmdatabase
*db
)
507 EnterCriticalSection(&db
->cs
);
510 void scmdatabase_unlock(struct scmdatabase
*db
)
512 LeaveCriticalSection(&db
->cs
);
515 void service_lock_shared(struct service_entry
*service
)
517 EnterCriticalSection(&service
->db
->cs
);
520 void service_lock_exclusive(struct service_entry
*service
)
522 EnterCriticalSection(&service
->db
->cs
);
525 void service_unlock(struct service_entry
*service
)
527 LeaveCriticalSection(&service
->db
->cs
);
530 /* only one service started at a time, so there is no race on the registry
532 static LPWSTR
service_get_pipe_name(void)
534 static const WCHAR format
[] = { '\\','\\','.','\\','p','i','p','e','\\',
535 'n','e','t','\\','N','t','C','o','n','t','r','o','l','P','i','p','e','%','u',0};
536 static const WCHAR service_current_key_str
[] = { 'S','Y','S','T','E','M','\\',
537 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
538 'C','o','n','t','r','o','l','\\',
539 'S','e','r','v','i','c','e','C','u','r','r','e','n','t',0};
542 HKEY service_current_key
;
543 DWORD service_current
= -1;
547 ret
= RegCreateKeyExW(HKEY_LOCAL_MACHINE
, service_current_key_str
, 0,
548 NULL
, REG_OPTION_VOLATILE
, KEY_SET_VALUE
| KEY_QUERY_VALUE
, NULL
,
549 &service_current_key
, NULL
);
550 if (ret
!= ERROR_SUCCESS
)
552 len
= sizeof(service_current
);
553 ret
= RegQueryValueExW(service_current_key
, NULL
, NULL
, &type
,
554 (BYTE
*)&service_current
, &len
);
555 if ((ret
== ERROR_SUCCESS
&& type
== REG_DWORD
) || ret
== ERROR_FILE_NOT_FOUND
)
558 RegSetValueExW(service_current_key
, NULL
, 0, REG_DWORD
,
559 (BYTE
*)&service_current
, sizeof(service_current
));
561 RegCloseKey(service_current_key
);
562 if ((ret
!= ERROR_SUCCESS
|| type
!= REG_DWORD
) && (ret
!= ERROR_FILE_NOT_FOUND
))
564 len
= sizeof(format
)/sizeof(WCHAR
) + 10 /* strlenW("4294967295") */;
565 name
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
568 snprintfW(name
, len
, format
, service_current
);
572 static DWORD
service_start_process(struct service_entry
*service_entry
, HANDLE
*process
)
574 PROCESS_INFORMATION pi
;
580 service_lock_exclusive(service_entry
);
582 size
= ExpandEnvironmentStringsW(service_entry
->config
.lpBinaryPathName
,NULL
,0);
583 path
= HeapAlloc(GetProcessHeap(),0,size
*sizeof(WCHAR
));
586 service_unlock(service_entry
);
587 return ERROR_NOT_ENOUGH_SERVER_MEMORY
;
589 ExpandEnvironmentStringsW(service_entry
->config
.lpBinaryPathName
,path
,size
);
591 if (service_entry
->config
.dwServiceType
== SERVICE_KERNEL_DRIVER
)
593 static const WCHAR winedeviceW
[] = {'\\','w','i','n','e','d','e','v','i','c','e','.','e','x','e',' ',0};
594 WCHAR system_dir
[MAX_PATH
];
597 GetSystemDirectoryW( system_dir
, MAX_PATH
);
600 if (!GetBinaryTypeW( path
, &type
))
602 HeapFree( GetProcessHeap(), 0, path
);
603 service_unlock(service_entry
);
604 return GetLastError();
606 if (type
== SCS_32BIT_BINARY
) GetSystemWow64DirectoryW( system_dir
, MAX_PATH
);
609 len
= strlenW( system_dir
) + sizeof(winedeviceW
)/sizeof(WCHAR
) + strlenW(service_entry
->name
);
610 HeapFree( GetProcessHeap(), 0, path
);
611 if (!(path
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) )))
613 service_unlock(service_entry
);
614 return ERROR_NOT_ENOUGH_SERVER_MEMORY
;
616 lstrcpyW( path
, system_dir
);
617 lstrcatW( path
, winedeviceW
);
618 lstrcatW( path
, service_entry
->name
);
621 ZeroMemory(&si
, sizeof(STARTUPINFOW
));
622 si
.cb
= sizeof(STARTUPINFOW
);
623 if (!(service_entry
->config
.dwServiceType
& SERVICE_INTERACTIVE_PROCESS
))
625 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};
626 si
.lpDesktop
= desktopW
;
629 service_entry
->status
.dwCurrentState
= SERVICE_START_PENDING
;
631 service_unlock(service_entry
);
633 r
= CreateProcessW(NULL
, path
, NULL
, NULL
, FALSE
, 0, NULL
, NULL
, &si
, &pi
);
634 HeapFree(GetProcessHeap(),0,path
);
637 service_lock_exclusive(service_entry
);
638 service_entry
->status
.dwCurrentState
= SERVICE_STOPPED
;
639 service_unlock(service_entry
);
640 return GetLastError();
643 service_entry
->status
.dwProcessId
= pi
.dwProcessId
;
644 *process
= pi
.hProcess
;
645 CloseHandle( pi
.hThread
);
647 return ERROR_SUCCESS
;
650 static DWORD
service_wait_for_startup(struct service_entry
*service_entry
, HANDLE process_handle
)
652 WINE_TRACE("%p\n", service_entry
);
656 DWORD dwCurrentStatus
;
657 HANDLE handles
[2] = { service_entry
->status_changed_event
, process_handle
};
659 ret
= WaitForMultipleObjects( 2, handles
, FALSE
, service_pipe_timeout
);
660 if (ret
!= WAIT_OBJECT_0
)
661 return ERROR_SERVICE_REQUEST_TIMEOUT
;
662 service_lock_shared(service_entry
);
663 dwCurrentStatus
= service_entry
->status
.dwCurrentState
;
664 service_unlock(service_entry
);
665 if (dwCurrentStatus
== SERVICE_RUNNING
)
667 WINE_TRACE("Service started successfully\n");
668 return ERROR_SUCCESS
;
670 if (dwCurrentStatus
!= SERVICE_START_PENDING
)
671 return ERROR_SERVICE_REQUEST_TIMEOUT
;
675 /******************************************************************************
676 * service_send_start_message
678 static BOOL
service_send_start_message(struct service_entry
*service
, HANDLE process_handle
,
679 LPCWSTR
*argv
, DWORD argc
)
681 OVERLAPPED overlapped
;
682 DWORD i
, len
, result
;
683 service_start_info
*ssi
;
687 WINE_TRACE("%s %p %d\n", wine_dbgstr_w(service
->name
), argv
, argc
);
689 overlapped
.hEvent
= service
->overlapped_event
;
690 if (!ConnectNamedPipe(service
->control_pipe
, &overlapped
))
692 if (GetLastError() == ERROR_IO_PENDING
)
695 handles
[0] = service
->overlapped_event
;
696 handles
[1] = process_handle
;
697 if (WaitForMultipleObjects( 2, handles
, FALSE
, service_pipe_timeout
) != WAIT_OBJECT_0
)
698 CancelIo( service
->control_pipe
);
699 if (!HasOverlappedCompleted( &overlapped
))
701 WINE_ERR( "service %s failed to start\n", wine_dbgstr_w( service
->name
));
705 else if (GetLastError() != ERROR_PIPE_CONNECTED
)
707 WINE_ERR("pipe connect failed\n");
712 /* calculate how much space do we need to send the startup info */
713 len
= strlenW(service
->name
) + 1;
714 for (i
=0; i
<argc
; i
++)
715 len
+= strlenW(argv
[i
])+1;
718 ssi
= HeapAlloc(GetProcessHeap(),0,FIELD_OFFSET(service_start_info
, data
[len
]));
719 ssi
->cmd
= WINESERV_STARTINFO
;
721 ssi
->total_size
= FIELD_OFFSET(service_start_info
, data
[len
]);
722 ssi
->name_size
= strlenW(service
->name
) + 1;
723 strcpyW( ssi
->data
, service
->name
);
725 /* copy service args into a single buffer*/
726 p
= &ssi
->data
[ssi
->name_size
];
727 for (i
=0; i
<argc
; i
++)
734 r
= service_send_command( service
, service
->control_pipe
, ssi
, ssi
->total_size
, &result
);
737 SetLastError(result
);
741 HeapFree(GetProcessHeap(),0,ssi
);
746 DWORD
service_start(struct service_entry
*service
, DWORD service_argc
, LPCWSTR
*service_argv
)
750 HANDLE process_handle
= NULL
;
752 err
= scmdatabase_lock_startup(service
->db
);
753 if (err
!= ERROR_SUCCESS
)
756 if (service
->control_pipe
!= INVALID_HANDLE_VALUE
)
758 scmdatabase_unlock_startup(service
->db
);
759 return ERROR_SERVICE_ALREADY_RUNNING
;
762 service
->control_mutex
= CreateMutexW(NULL
, TRUE
, NULL
);
764 if (!service
->status_changed_event
)
765 service
->status_changed_event
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
766 if (!service
->overlapped_event
)
767 service
->overlapped_event
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
769 name
= service_get_pipe_name();
770 service
->control_pipe
= CreateNamedPipeW(name
, PIPE_ACCESS_DUPLEX
| FILE_FLAG_OVERLAPPED
,
771 PIPE_TYPE_BYTE
|PIPE_WAIT
, 1, 256, 256, 10000, NULL
);
772 HeapFree(GetProcessHeap(), 0, name
);
773 if (service
->control_pipe
==INVALID_HANDLE_VALUE
)
775 WINE_ERR("failed to create pipe for %s, error = %d\n",
776 wine_dbgstr_w(service
->name
), GetLastError());
777 err
= GetLastError();
781 err
= service_start_process(service
, &process_handle
);
782 if (err
== ERROR_SUCCESS
)
784 if (!service_send_start_message(service
, process_handle
, service_argv
, service_argc
))
785 err
= ERROR_SERVICE_REQUEST_TIMEOUT
;
788 if (err
== ERROR_SUCCESS
)
789 err
= service_wait_for_startup(service
, process_handle
);
792 CloseHandle(process_handle
);
795 if (err
== ERROR_SUCCESS
)
796 ReleaseMutex(service
->control_mutex
);
799 CloseHandle(service
->overlapped_event
);
800 service
->overlapped_event
= NULL
;
801 CloseHandle(service
->status_changed_event
);
802 service
->status_changed_event
= NULL
;
803 CloseHandle(service
->control_mutex
);
804 service
->control_mutex
= NULL
;
805 if (service
->control_pipe
!= INVALID_HANDLE_VALUE
)
806 CloseHandle(service
->control_pipe
);
807 service
->control_pipe
= INVALID_HANDLE_VALUE
;
809 service
->status
.dwProcessId
= 0;
810 service_lock_exclusive(service
);
811 service
->status
.dwCurrentState
= SERVICE_STOPPED
;
812 service_unlock(service
);
814 scmdatabase_unlock_startup(service
->db
);
816 WINE_TRACE("returning %d\n", err
);
821 static void load_registry_parameters(void)
823 static const WCHAR controlW
[] =
824 { 'S','y','s','t','e','m','\\',
825 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
826 'C','o','n','t','r','o','l',0 };
827 static const WCHAR pipetimeoutW
[] =
828 {'S','e','r','v','i','c','e','s','P','i','p','e','T','i','m','e','o','u','t',0};
829 static const WCHAR killtimeoutW
[] =
830 {'W','a','i','t','T','o','K','i','l','l','S','e','r','v','i','c','e','T','i','m','e','o','u','t',0};
833 DWORD type
, count
, val
;
835 if (RegOpenKeyW( HKEY_LOCAL_MACHINE
, controlW
, &key
)) return;
837 count
= sizeof(buffer
);
838 if (!RegQueryValueExW( key
, pipetimeoutW
, NULL
, &type
, (BYTE
*)buffer
, &count
) &&
839 type
== REG_SZ
&& (val
= atoiW( buffer
)))
840 service_pipe_timeout
= val
;
842 count
= sizeof(buffer
);
843 if (!RegQueryValueExW( key
, killtimeoutW
, NULL
, &type
, (BYTE
*)buffer
, &count
) &&
844 type
== REG_SZ
&& (val
= atoiW( buffer
)))
845 service_kill_timeout
= val
;
850 int main(int argc
, char *argv
[])
852 static const WCHAR svcctl_started_event
[] = SVCCTL_STARTED_EVENT
;
855 g_hStartedEvent
= CreateEventW(NULL
, TRUE
, FALSE
, svcctl_started_event
);
856 load_registry_parameters();
857 err
= scmdatabase_create(&active_database
);
858 if (err
!= ERROR_SUCCESS
)
860 if ((err
= scmdatabase_load_services(active_database
)) != ERROR_SUCCESS
)
862 if ((err
= RPC_Init()) == ERROR_SUCCESS
)
864 scmdatabase_autostart_services(active_database
);
867 scmdatabase_destroy(active_database
);