return 0;\r
}\r
\r
-static inline int await_service_control_response(unsigned long control, SC_HANDLE service_handle, SERVICE_STATUS *service_status, unsigned long initial_status) {\r
+static inline int await_service_control_response(unsigned long control, SC_HANDLE service_handle, SERVICE_STATUS *service_status, unsigned long initial_status, unsigned long cutoff) {\r
int tries = 0;\r
unsigned long checkpoint = 0;\r
unsigned long waithint = 0;\r
+ unsigned long waited = 0;\r
while (QueryServiceStatus(service_handle, service_status)) {\r
int response = service_control_response(control, service_status->dwCurrentState);\r
/* Alas we can't WaitForSingleObject() on an SC_HANDLE. */\r
checkpoint = service_status->dwCheckPoint;\r
waithint = service_status->dwWaitHint;\r
if (++tries > 10) tries = 10;\r
- Sleep(50 * tries);\r
+ unsigned long wait = 50 * tries;\r
+ if (cutoff) {\r
+ if (waited > cutoff) return response;\r
+ waited += wait;\r
+ }\r
+ Sleep(wait);\r
}\r
else return response;\r
}\r
return -1;\r
}\r
\r
+static inline int await_service_control_response(unsigned long control, SC_HANDLE service_handle, SERVICE_STATUS *service_status, unsigned long initial_status) {\r
+ return await_service_control_response(control, service_handle, service_status, initial_status, 0);\r
+}\r
+\r
static inline void wait_for_hooks(nssm_service_t *service, bool notify) {\r
SERVICE_STATUS_HANDLE status_handle;\r
SERVICE_STATUS *status;\r
return 0;\r
}\r
\r
-inline unsigned long priority_mask() {\r
+unsigned long priority_mask() {\r
return REALTIME_PRIORITY_CLASS | HIGH_PRIORITY_CLASS | ABOVE_NORMAL_PRIORITY_CLASS | NORMAL_PRIORITY_CLASS | BELOW_NORMAL_PRIORITY_CLASS | IDLE_PRIORITY_CLASS;\r
}\r
\r
return ret * 1000;\r
}\r
\r
+void set_service_environment(nssm_service_t *service) {\r
+ if (! service) return;\r
+\r
+ /*\r
+ We have to duplicate the block because this function will be called\r
+ multiple times between registry reads.\r
+ */\r
+ if (service->env) duplicate_environment_strings(service->env);\r
+ if (! service->env_extra) return;\r
+ TCHAR *env_extra = copy_environment_block(service->env_extra);\r
+ if (! env_extra) return;\r
+\r
+ set_environment_block(env_extra);\r
+ HeapFree(GetProcessHeap(), 0, env_extra);\r
+}\r
+\r
+void unset_service_environment(nssm_service_t *service) {\r
+ if (! service) return;\r
+ duplicate_environment_strings(service->initial_env);\r
+}\r
+\r
/*\r
Wrapper to be called in a new thread so that we can acknowledge a STOP\r
control immediately.\r
return qsc;\r
}\r
\r
+/* WILL NOT allocate a new string if the identifier is already present. */\r
+int prepend_service_group_identifier(TCHAR *group, TCHAR **canon) {\r
+ if (! group || ! group[0] || group[0] == SC_GROUP_IDENTIFIER) {\r
+ *canon = group;\r
+ return 0;\r
+ }\r
+\r
+ size_t len = _tcslen(group) + 1;\r
+ *canon = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(TCHAR));\r
+ if (! *canon) {\r
+ print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("canon"), _T("prepend_service_group_identifier()"));\r
+ return 1;\r
+ }\r
+\r
+ TCHAR *s = *canon;\r
+ *s++ = SC_GROUP_IDENTIFIER;\r
+ memmove(s, group, len * sizeof(TCHAR));\r
+ (*canon)[len] = _T('\0');\r
+\r
+ return 0;\r
+}\r
+\r
+int append_to_dependencies(TCHAR *dependencies, unsigned long dependencieslen, TCHAR *string, TCHAR **newdependencies, unsigned long *newlen, int type) {\r
+ *newlen = 0;\r
+\r
+ TCHAR *canon = 0;\r
+ if (type == DEPENDENCY_GROUPS) {\r
+ if (prepend_service_group_identifier(string, &canon)) return 1;\r
+ }\r
+ else canon = string;\r
+ int ret = append_to_double_null(dependencies, dependencieslen, newdependencies, newlen, canon, 0, false);\r
+ if (canon && canon != string) HeapFree(GetProcessHeap(), 0, canon);\r
+\r
+ return ret;\r
+}\r
+\r
+int remove_from_dependencies(TCHAR *dependencies, unsigned long dependencieslen, TCHAR *string, TCHAR **newdependencies, unsigned long *newlen, int type) {\r
+ *newlen = 0;\r
+\r
+ TCHAR *canon = 0;\r
+ if (type == DEPENDENCY_GROUPS) {\r
+ if (prepend_service_group_identifier(string, &canon)) return 1;\r
+ }\r
+ else canon = string;\r
+ int ret = remove_from_double_null(dependencies, dependencieslen, newdependencies, newlen, canon, 0, false);\r
+ if (canon && canon != string) HeapFree(GetProcessHeap(), 0, canon);\r
+\r
+ return ret;\r
+}\r
+\r
int set_service_dependencies(const TCHAR *service_name, SC_HANDLE service_handle, TCHAR *buffer) {\r
TCHAR *dependencies = _T("");\r
unsigned long num_dependencies = 0;\r
QUERY_SERVICE_CONFIG *qsc = query_service_config(service_name, service_handle);\r
if (! qsc) return 3;\r
\r
- if (! qsc->lpDependencies) return 0;\r
- if (! qsc->lpDependencies[0]) return 0;\r
+ if (! qsc->lpDependencies || ! qsc->lpDependencies[0]) {\r
+ HeapFree(GetProcessHeap(), 0, qsc);\r
+ return 0;\r
+ }\r
\r
/* lpDependencies is doubly NULL terminated. */\r
while (qsc->lpDependencies[*bufsize]) {\r
if (! *buffer) {\r
*bufsize = 0;\r
print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("lpDependencies"), _T("get_service_dependencies()"));\r
+ HeapFree(GetProcessHeap(), 0, qsc);\r
return 4;\r
}\r
\r
\r
HeapFree(GetProcessHeap(), 0, qsc);\r
\r
+ if (! *buffer[0]) {\r
+ HeapFree(GetProcessHeap(), 0, *buffer);\r
+ *buffer = 0;\r
+ *bufsize = 0;\r
+ }\r
+\r
return 0;\r
}\r
\r
print_message(stderr, NSSM_MESSAGE_QUERYSERVICECONFIG2_FAILED, service_name, _T("SERVICE_CONFIG_DESCRIPTION"), error_string(error));\r
return 4;\r
}\r
-\r
- return 0;\r
}\r
\r
int get_service_startup(const TCHAR *service_name, SC_HANDLE service_handle, const QUERY_SERVICE_CONFIG *qsc, unsigned long *startup) {\r
if (! service) return;\r
if (service->username) HeapFree(GetProcessHeap(), 0, service->username);\r
if (service->password) {\r
- SecureZeroMemory(service->password, service->passwordlen);\r
+ SecureZeroMemory(service->password, service->passwordlen * sizeof(TCHAR));\r
HeapFree(GetProcessHeap(), 0, service->password);\r
}\r
if (service->dependencies) HeapFree(GetProcessHeap(), 0, service->dependencies);\r
if (service->throttle_section_initialised) DeleteCriticalSection(&service->throttle_section);\r
if (service->throttle_timer) CloseHandle(service->throttle_timer);\r
if (service->hook_section_initialised) DeleteCriticalSection(&service->hook_section);\r
- if (service->initial_env) FreeEnvironmentStrings(service->initial_env);\r
+ if (service->initial_env) HeapFree(GetProcessHeap(), 0, service->initial_env);\r
HeapFree(GetProcessHeap(), 0, service);\r
}\r
\r
if (argc < 2) return usage(1);\r
\r
/* Are we editing on the command line? */\r
- enum { MODE_EDITING, MODE_GETTING, MODE_SETTING, MODE_RESETTING } mode = MODE_EDITING;\r
+ enum { MODE_EDITING, MODE_GETTING, MODE_SETTING, MODE_RESETTING, MODE_DUMPING } mode = MODE_EDITING;\r
const TCHAR *verb = argv[0];\r
const TCHAR *service_name = argv[1];\r
bool getting = false;\r
mandatory = 3;\r
mode = MODE_RESETTING;\r
}\r
+ else if (str_equiv(verb, _T("dump"))) {\r
+ mandatory = 1;\r
+ remainder = 2;\r
+ mode = MODE_DUMPING;\r
+ }\r
if (argc < mandatory) return usage(1);\r
\r
const TCHAR *parameter = 0;\r
\r
service->type = qsc->dwServiceType;\r
if (! (service->type & SERVICE_WIN32_OWN_PROCESS)) {\r
- if (mode != MODE_GETTING) {\r
+ if (mode != MODE_GETTING && mode != MODE_DUMPING) {\r
HeapFree(GetProcessHeap(), 0, qsc);\r
CloseServiceHandle(service->handle);\r
CloseServiceHandle(services);\r
}\r
\r
if (get_service_startup(service->name, service->handle, qsc, &service->startup)) {\r
- if (mode != MODE_GETTING) {\r
+ if (mode != MODE_GETTING && mode != MODE_DUMPING) {\r
HeapFree(GetProcessHeap(), 0, qsc);\r
CloseServiceHandle(service->handle);\r
CloseServiceHandle(services);\r
}\r
\r
if (get_service_username(service->name, qsc, &service->username, &service->usernamelen)) {\r
- if (mode != MODE_GETTING) {\r
+ if (mode != MODE_GETTING && mode != MODE_DUMPING) {\r
HeapFree(GetProcessHeap(), 0, qsc);\r
CloseServiceHandle(service->handle);\r
CloseServiceHandle(services);\r
\r
/* Get extended system details. */\r
if (get_service_description(service->name, service->handle, _countof(service->description), service->description)) {\r
- if (mode != MODE_GETTING) {\r
+ if (mode != MODE_GETTING && mode != MODE_DUMPING) {\r
CloseServiceHandle(service->handle);\r
CloseServiceHandle(services);\r
return 6;\r
}\r
\r
if (get_service_dependencies(service->name, service->handle, &service->dependencies, &service->dependencieslen)) {\r
- if (mode != MODE_GETTING) {\r
+ if (mode != MODE_GETTING && mode != MODE_DUMPING) {\r
CloseServiceHandle(service->handle);\r
CloseServiceHandle(services);\r
return 7;\r
\r
if (! service->exe[0]) {\r
service->native = true;\r
- if (mode != MODE_GETTING) print_message(stderr, NSSM_MESSAGE_INVALID_SERVICE, service->name, NSSM, service->image);\r
+ if (mode != MODE_GETTING && mode != MODE_DUMPING) print_message(stderr, NSSM_MESSAGE_INVALID_SERVICE, service->name, NSSM, service->image);\r
}\r
\r
/* Editing with the GUI. */\r
return 0;\r
}\r
\r
+ HKEY key;\r
+ value_t value;\r
+ int ret;\r
+\r
+ if (mode == MODE_DUMPING) {\r
+ TCHAR *service_name = service->name;\r
+ if (argc > remainder) service_name = argv[remainder];\r
+ if (service->native) key = 0;\r
+ else {\r
+ key = open_registry(service->name, KEY_READ);\r
+ if (! key) return 4;\r
+ }\r
+\r
+ TCHAR quoted_service_name[SERVICE_NAME_LENGTH * 2];\r
+ TCHAR quoted_exe[EXE_LENGTH * 2];\r
+ TCHAR quoted_nssm[EXE_LENGTH * 2];\r
+ if (quote(service_name, quoted_service_name, _countof(quoted_service_name))) return 5;\r
+ if (quote(service->exe, quoted_exe, _countof(quoted_exe))) return 6;\r
+ if (quote(nssm_exe(), quoted_nssm, _countof(quoted_nssm))) return 6;\r
+ _tprintf(_T("%s install %s %s\n"), quoted_nssm, quoted_service_name, quoted_exe);\r
+\r
+ ret = 0;\r
+ for (i = 0; settings[i].name; i++) {\r
+ setting = &settings[i];\r
+ if (! setting->native && service->native) continue;\r
+ if (dump_setting(service_name, key, service->handle, setting)) ret++;\r
+ }\r
+\r
+ if (! service->native) RegCloseKey(key);\r
+ CloseServiceHandle(service->handle);\r
+\r
+ if (ret) return 1;\r
+ return 0;\r
+ }\r
+\r
/* Trying to manage App* parameters for a non-NSSM service. */\r
if (! setting->native && service->native) {\r
CloseServiceHandle(service->handle);\r
return 1;\r
}\r
\r
- HKEY key;\r
- value_t value;\r
- int ret;\r
-\r
if (mode == MODE_GETTING) {\r
if (! service->native) {\r
key = open_registry(service->name, KEY_READ);\r
break;\r
\r
case REG_DWORD:\r
- _tprintf(_T("%u\n"), value.numeric);\r
+ _tprintf(_T("%lu\n"), value.numeric);\r
break;\r
}\r
\r
}\r
\r
if (! service->native) {\r
- key = open_registry(service->name, KEY_WRITE);\r
+ key = open_registry(service->name, KEY_READ | KEY_WRITE);\r
if (! key) {\r
if (value.string) HeapFree(GetProcessHeap(), 0, value.string);\r
return 4;\r
}\r
\r
/* Get path of this program */\r
- GetModuleFileName(0, service->image, _countof(service->image));\r
+ _sntprintf_s(service->image, _countof(service->image), _TRUNCATE, _T("%s"), nssm_imagepath());\r
\r
/* Create the service - settings will be changed in edit_service() */\r
service->handle = CreateService(services, service->name, service->name, SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, service->image, 0, 0, 0, 0, 0);\r
TCHAR *username = 0;\r
TCHAR *canon = 0;\r
TCHAR *password = 0;\r
+ boolean virtual_account = false;\r
if (service->usernamelen) {\r
username = service->username;\r
- if (canonicalise_username(username, &canon)) return 5;\r
- if (service->passwordlen) password = service->password;\r
+ if (is_virtual_account(service->name, username)) {\r
+ virtual_account = true;\r
+ canon = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, (service->usernamelen + 1) * sizeof(TCHAR));\r
+ if (! canon) {\r
+ print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("canon"), _T("edit_service()"));\r
+ return 5;\r
+ }\r
+ memmove(canon, username, (service->usernamelen + 1) * sizeof(TCHAR));\r
+ }\r
+ else {\r
+ if (canonicalise_username(username, &canon)) return 5;\r
+ if (service->passwordlen) password = service->password;\r
+ }\r
}\r
else if (editing) username = canon = NSSM_LOCALSYSTEM_ACCOUNT;\r
\r
- if (well_known_username(canon)) password = _T("");\r
- else {\r
- if (grant_logon_as_service(canon)) {\r
- if (canon != username) HeapFree(GetProcessHeap(), 0, canon);\r
- print_message(stderr, NSSM_MESSAGE_GRANT_LOGON_AS_SERVICE_FAILED, username);\r
- return 5;\r
+ if (! virtual_account) {\r
+ if (well_known_username(canon)) password = _T("");\r
+ else {\r
+ if (grant_logon_as_service(canon)) {\r
+ if (canon != username) HeapFree(GetProcessHeap(), 0, canon);\r
+ print_message(stderr, NSSM_MESSAGE_GRANT_LOGON_AS_SERVICE_FAILED, username);\r
+ return 5;\r
+ }\r
}\r
}\r
\r
}\r
\r
if (ret) {\r
- int response = await_service_control_response(control, service_handle, &service_status, initial_status);\r
+ unsigned long cutoff = 0;\r
+\r
+ /* If we manage the service, respect the throttle time. */\r
+ HKEY key = open_registry(service_name, 0, KEY_READ, false);\r
+ if (key) {\r
+ if (get_number(key, NSSM_REG_THROTTLE, &cutoff, false) != 1) cutoff = NSSM_RESET_THROTTLE_RESTART;\r
+ RegCloseKey(key);\r
+ }\r
+\r
+ int response = await_service_control_response(control, service_handle, &service_status, initial_status, cutoff);\r
CloseServiceHandle(service_handle);\r
\r
if (response) {\r
nssm_service_t *service = alloc_nssm_service();\r
if (! service) return;\r
\r
+ static volatile bool await_debugger = (argc > 1 && str_equiv(argv[1], _T("debug")));\r
+ while (await_debugger) Sleep(1000);\r
+\r
if (_sntprintf_s(service->name, _countof(service->name), _TRUNCATE, _T("%s"), argv[0]) < 0) {\r
log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, _T("service->name"), _T("service_main()"), 0);\r
return;\r
service->hook_section_initialised = true;\r
\r
/* Remember our initial environment. */\r
- service->initial_env = GetEnvironmentStrings();\r
+ service->initial_env = copy_environment();\r
\r
/* Remember our creation time. */\r
if (get_process_creation_time(GetCurrentProcess(), &service->nssm_creation_time)) ZeroMemory(&service->nssm_creation_time, sizeof(service->nssm_creation_time));\r
int ret = get_parameters(service, &si);\r
if (ret) {\r
log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_GET_PARAMETERS_FAILED, service->name, 0);\r
+ unset_service_environment(service);\r
return stop_service(service, 2, true, true);\r
}\r
\r
TCHAR cmd[CMD_LENGTH];\r
if (_sntprintf_s(cmd, _countof(cmd), _TRUNCATE, _T("\"%s\" %s"), service->exe, service->flags) < 0) {\r
log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, _T("command line"), _T("start_service"), 0);\r
+ unset_service_environment(service);\r
return stop_service(service, 2, true, true);\r
}\r
\r
throttle_restart(service);\r
\r
- /* Set the environment. */\r
- if (service->env) duplicate_environment(service->env);\r
- if (service->env_extra) set_environment_block(service->env_extra);\r
-\r
service->status.dwCurrentState = SERVICE_START_PENDING;\r
service->status.dwControlsAccepted = SERVICE_ACCEPT_POWEREVENT | SERVICE_ACCEPT_SHUTDOWN | SERVICE_ACCEPT_STOP;\r
SetServiceStatus(service->status_handle, &service->status);\r
\r
- /* Pre-start hook. */\r
unsigned long control = NSSM_SERVICE_CONTROL_START;\r
- if (nssm_hook(&hook_threads, service, NSSM_HOOK_EVENT_START, NSSM_HOOK_ACTION_PRE, &control, NSSM_SERVICE_STATUS_DEADLINE, false) == NSSM_HOOK_STATUS_ABORT) {\r
- TCHAR code[16];\r
- _sntprintf_s(code, _countof(code), _TRUNCATE, _T("%lu"), NSSM_HOOK_STATUS_ABORT);\r
- log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_PRESTART_HOOK_ABORT, NSSM_HOOK_EVENT_START, NSSM_HOOK_ACTION_PRE, service->name, code, 0);\r
- duplicate_environment_strings(service->initial_env);\r
- return stop_service(service, 5, true, true);\r
- }\r
\r
/* Did another thread receive a stop control? */\r
if (service->allow_restart) {\r
log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_GET_OUTPUT_HANDLES_FAILED, service->name, 0);\r
if (! service->no_console) FreeConsole();\r
close_output_handles(&si);\r
- duplicate_environment_strings(service->initial_env);\r
+ unset_service_environment(service);\r
return stop_service(service, 4, true, true);\r
}\r
\r
+ /* Pre-start hook. May need I/O to have been redirected already. */\r
+ if (nssm_hook(&hook_threads, service, NSSM_HOOK_EVENT_START, NSSM_HOOK_ACTION_PRE, &control, NSSM_SERVICE_STATUS_DEADLINE, false) == NSSM_HOOK_STATUS_ABORT) {\r
+ TCHAR code[16];\r
+ _sntprintf_s(code, _countof(code), _TRUNCATE, _T("%lu"), NSSM_HOOK_STATUS_ABORT);\r
+ log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_PRESTART_HOOK_ABORT, NSSM_HOOK_EVENT_START, NSSM_HOOK_ACTION_PRE, service->name, code, 0);\r
+ unset_service_environment(service);\r
+ return stop_service(service, 5, true, true);\r
+ }\r
+\r
+ /* The pre-start hook will have cleaned the environment. */\r
+ set_service_environment(service);\r
+\r
bool inherit_handles = false;\r
if (si.dwFlags & STARTF_USESTDHANDLES) inherit_handles = true;\r
unsigned long flags = service->priority & priority_mask();\r
unsigned long error = GetLastError();\r
log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATEPROCESS_FAILED, service->name, service->exe, error_string(error), 0);\r
close_output_handles(&si);\r
- duplicate_environment_strings(service->initial_env);\r
+ unset_service_environment(service);\r
return stop_service(service, exitcode, true, true);\r
}\r
service->start_count++;\r
}\r
\r
/* Restore our environment. */\r
- duplicate_environment_strings(service->initial_env);\r
+ unset_service_environment(service);\r
\r
/*\r
Wait for a clean startup before changing the service status to RUNNING\r
log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_EXIT_UNCLEAN, service->name, code, exit_action_strings[action], 0);\r
stop_service(service, exitcode, false, default_action);\r
wait_for_hooks(service, false);\r
- free_imports();\r
- exit(exitcode);\r
- break;\r
+ nssm_exit(exitcode);\r
}\r
}\r
\r
\r
return ret;\r
}\r
+\r
+int list_nssm_services(int argc, TCHAR **argv) {\r
+ bool including_native = (argc > 0 && str_equiv(argv[0], _T("all")));\r
+\r
+ /* Open service manager. */\r
+ SC_HANDLE services = open_service_manager(SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE);\r
+ if (! services) {\r
+ print_message(stderr, NSSM_MESSAGE_OPEN_SERVICE_MANAGER_FAILED);\r
+ return 1;\r
+ }\r
+\r
+ unsigned long bufsize, required, count, i;\r
+ unsigned long resume = 0;\r
+ EnumServicesStatus(services, SERVICE_WIN32, SERVICE_STATE_ALL, 0, 0, &required, &count, &resume);\r
+ unsigned long error = GetLastError();\r
+ if (error != ERROR_MORE_DATA) {\r
+ print_message(stderr, NSSM_MESSAGE_ENUMSERVICESSTATUS_FAILED, error_string(GetLastError()));\r
+ return 2;\r
+ }\r
+\r
+ ENUM_SERVICE_STATUS *status = (ENUM_SERVICE_STATUS *) HeapAlloc(GetProcessHeap(), 0, required);\r
+ if (! status) {\r
+ print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("ENUM_SERVICE_STATUS"), _T("list_nssm_services()"));\r
+ return 3;\r
+ }\r
+\r
+ bufsize = required;\r
+ while (true) {\r
+ int ret = EnumServicesStatus(services, SERVICE_WIN32, SERVICE_STATE_ALL, status, bufsize, &required, &count, &resume);\r
+ if (! ret) {\r
+ error = GetLastError();\r
+ if (error != ERROR_MORE_DATA) {\r
+ HeapFree(GetProcessHeap(), 0, status);\r
+ print_message(stderr, NSSM_MESSAGE_ENUMSERVICESSTATUS_FAILED, error_string(GetLastError()));\r
+ return 4;\r
+ }\r
+ }\r
+\r
+ for (i = 0; i < count; i++) {\r
+ /* Try to get the service parameters. */\r
+ nssm_service_t *service = alloc_nssm_service();\r
+ if (! service) {\r
+ HeapFree(GetProcessHeap(), 0, status);\r
+ print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("nssm_service_t"), _T("list_nssm_services()"));\r
+ return 5;\r
+ }\r
+ _sntprintf_s(service->name, _countof(service->name), _TRUNCATE, _T("%s"), status[i].lpServiceName);\r
+\r
+ get_parameters(service, 0);\r
+ /* We manage the service if we have an Application. */\r
+ if (including_native || service->exe[0]) _tprintf(_T("%s\n"), service->name);\r
+\r
+ cleanup_nssm_service(service);\r
+ }\r
+\r
+ if (ret) break;\r
+ }\r
+\r
+ HeapFree(GetProcessHeap(), 0, status);\r
+ return 0;\r
+}\r
+\r
+int service_process_tree(int argc, TCHAR **argv) {\r
+ int errors = 0;\r
+ if (argc < 1) return usage(1);\r
+\r
+ SC_HANDLE services = open_service_manager(SC_MANAGER_CONNECT);\r
+ if (! services) {\r
+ print_message(stderr, NSSM_MESSAGE_OPEN_SERVICE_MANAGER_FAILED);\r
+ return 1;\r
+ }\r
+\r
+ /*\r
+ We need SeDebugPrivilege to read the process tree.\r
+ We ignore failure here so that an error will be printed later when we\r
+ try to open a process handle.\r
+ */\r
+ HANDLE token = get_debug_token();\r
+\r
+ TCHAR canonical_name[SERVICE_NAME_LENGTH];\r
+ SERVICE_STATUS_PROCESS service_status;\r
+ nssm_service_t *service;\r
+ kill_t k;\r
+\r
+ int i;\r
+ for (i = 0; i < argc; i++) {\r
+ TCHAR *service_name = argv[i];\r
+ SC_HANDLE service_handle = open_service(services, service_name, SERVICE_QUERY_STATUS, canonical_name, _countof(canonical_name));\r
+ if (! service_handle) {\r
+ errors++;\r
+ continue;\r
+ }\r
+\r
+ unsigned long size;\r
+ int ret = QueryServiceStatusEx(service_handle, SC_STATUS_PROCESS_INFO, (LPBYTE) &service_status, sizeof(service_status), &size);\r
+ long error = GetLastError();\r
+ CloseServiceHandle(service_handle);\r
+ if (! ret) {\r
+ _ftprintf(stderr, _T("%s: %s\n"), canonical_name, error_string(error));\r
+ errors++;\r
+ continue;\r
+ }\r
+\r
+ ZeroMemory(&k, sizeof(k));\r
+ k.pid = service_status.dwProcessId;\r
+ if (! k.pid) continue;\r
+\r
+ k.process_handle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, k.pid);\r
+ if (! k.process_handle) {\r
+ _ftprintf(stderr, _T("%s: %lu: %s\n"), canonical_name, k.pid, error_string(GetLastError()));\r
+ continue;\r
+ }\r
+\r
+ if (get_process_creation_time(k.process_handle, &k.creation_time)) continue;\r
+ /* Dummy exit time so we can check processes' parents. */\r
+ GetSystemTimeAsFileTime(&k.exit_time);\r
+\r
+ service = alloc_nssm_service();\r
+ if (! service) {\r
+ errors++;\r
+ continue;\r
+ }\r
+\r
+ _sntprintf_s(service->name, _countof(service->name), _TRUNCATE, _T("%s"), canonical_name);\r
+ k.name = service->name;\r
+ walk_process_tree(service, print_process, &k, k.pid);\r
+\r
+ cleanup_nssm_service(service);\r
+ }\r
+\r
+ CloseServiceHandle(services);\r
+ if (token != INVALID_HANDLE_VALUE) CloseHandle(token);\r
+\r
+ return errors;\r
+}\r
git://git.iain.cx/iain / nssm.git / blobdiff