bool use_critical_section;\r
\r
extern imports_t imports;\r
+extern settings_t settings[];\r
\r
const TCHAR *exit_action_strings[] = { _T("Restart"), _T("Ignore"), _T("Exit"), _T("Suicide"), 0 };\r
+const TCHAR *startup_strings[] = { _T("SERVICE_AUTO_START"), _T("SERVICE_DELAYED_AUTO_START"), _T("SERVICE_DEMAND_START"), _T("SERVICE_DISABLED"), 0 };\r
+const TCHAR *priority_strings[] = { _T("REALTIME_PRIORITY_CLASS"), _T("HIGH_PRIORITY_CLASS"), _T("ABOVE_NORMAL_PRIORITY_CLASS"), _T("NORMAL_PRIORITY_CLASS"), _T("BELOW_NORMAL_PRIORITY_CLASS"), _T("IDLE_PRIORITY_CLASS"), 0 };\r
\r
-static inline int throttle_milliseconds(unsigned long throttle) {\r
+typedef struct {\r
+ int first;\r
+ int last;\r
+} list_t;\r
+\r
+/*\r
+ Check the status in response to a control.\r
+ Returns: 1 if the status is expected, eg STOP following CONTROL_STOP.\r
+ 0 if the status is desired, eg STOPPED following CONTROL_STOP.\r
+ -1 if the status is undesired, eg STOPPED following CONTROL_START.\r
+*/\r
+static inline int service_control_response(unsigned long control, unsigned long status) {\r
+ switch (control) {\r
+ case NSSM_SERVICE_CONTROL_START:\r
+ switch (status) {\r
+ case SERVICE_START_PENDING:\r
+ return 1;\r
+\r
+ case SERVICE_RUNNING:\r
+ return 0;\r
+\r
+ default:\r
+ return -1;\r
+ }\r
+\r
+ case SERVICE_CONTROL_STOP:\r
+ case SERVICE_CONTROL_SHUTDOWN:\r
+ switch (status) {\r
+ case SERVICE_STOP_PENDING:\r
+ return 1;\r
+\r
+ case SERVICE_STOPPED:\r
+ return 0;\r
+\r
+ default:\r
+ return -1;\r
+ }\r
+\r
+ case SERVICE_CONTROL_PAUSE:\r
+ switch (status) {\r
+ case SERVICE_PAUSE_PENDING:\r
+ return 1;\r
+\r
+ case SERVICE_PAUSED:\r
+ return 0;\r
+\r
+ default:\r
+ return -1;\r
+ }\r
+\r
+ case SERVICE_CONTROL_CONTINUE:\r
+ switch (status) {\r
+ case SERVICE_CONTINUE_PENDING:\r
+ return 1;\r
+\r
+ case SERVICE_RUNNING:\r
+ return 0;\r
+\r
+ default:\r
+ return -1;\r
+ }\r
+\r
+ case SERVICE_CONTROL_INTERROGATE:\r
+ return 0;\r
+ }\r
+\r
+ 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
+ int tries = 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
+ if (! response) return response;\r
+ if (response > 0 || service_status->dwCurrentState == initial_status) {\r
+ if (++tries > 10) return response;\r
+ Sleep(50 * tries);\r
+ }\r
+ else return response;\r
+ }\r
+ return -1;\r
+}\r
+\r
+int affinity_mask_to_string(__int64 mask, TCHAR **string) {\r
+ if (! string) return 1;\r
+ if (! mask) {\r
+ *string = 0;\r
+ return 0;\r
+ }\r
+\r
+ __int64 i, n;\r
+\r
+ /* SetProcessAffinityMask() accepts a mask of up to 64 processors. */\r
+ list_t set[64];\r
+ for (n = 0; n < _countof(set); n++) set[n].first = set[n].last = -1;\r
+\r
+ for (i = 0, n = 0; i < _countof(set); i++) {\r
+ if (mask & (1LL << i)) {\r
+ if (set[n].first == -1) set[n].first = set[n].last = (int) i;\r
+ else if (set[n].last == (int) i - 1) set[n].last = (int) i;\r
+ else {\r
+ n++;\r
+ set[n].first = set[n].last = (int) i;\r
+ }\r
+ }\r
+ }\r
+\r
+ /* Worst case is 2x2 characters for first and last CPU plus - and/or , */\r
+ size_t len = (size_t) (n + 1) * 6;\r
+ *string = (TCHAR *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(TCHAR));\r
+ if (! string) return 2;\r
+\r
+ size_t s = 0;\r
+ int ret;\r
+ for (i = 0; i <= n; i++) {\r
+ if (i) (*string)[s++] = _T(',');\r
+ ret = _sntprintf_s(*string + s, 3, _TRUNCATE, _T("%u"), set[i].first);\r
+ if (ret < 0) {\r
+ HeapFree(GetProcessHeap(), 0, *string);\r
+ *string = 0;\r
+ return 3;\r
+ }\r
+ else s += ret;\r
+ if (set[i].last != set[i].first) {\r
+ ret =_sntprintf_s(*string + s, 4, _TRUNCATE, _T("%c%u"), (set[i].last == set[i].first + 1) ? _T(',') : _T('-'), set[i].last);\r
+ if (ret < 0) {\r
+ HeapFree(GetProcessHeap(), 0, *string);\r
+ *string = 0;\r
+ return 4;\r
+ }\r
+ else s += ret;\r
+ }\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+int affinity_string_to_mask(TCHAR *string, __int64 *mask) {\r
+ if (! mask) return 1;\r
+\r
+ *mask = 0LL;\r
+ if (! string) return 0;\r
+\r
+ list_t set[64];\r
+\r
+ TCHAR *s = string;\r
+ TCHAR *end;\r
+ int ret;\r
+ int i;\r
+ int n = 0;\r
+ unsigned long number;\r
+\r
+ for (n = 0; n < _countof(set); n++) set[n].first = set[n].last = -1;\r
+ n = 0;\r
+\r
+ while (*s) {\r
+ ret = str_number(s, &number, &end);\r
+ s = end;\r
+ if (ret == 0 || ret == 2) {\r
+ if (number >= _countof(set)) return 2;\r
+ set[n].first = set[n].last = (int) number;\r
+\r
+ switch (*s) {\r
+ case 0:\r
+ break;\r
+\r
+ case _T(','):\r
+ n++;\r
+ s++;\r
+ break;\r
+\r
+ case _T('-'):\r
+ if (! *(++s)) return 3;\r
+ ret = str_number(s, &number, &end);\r
+ if (ret == 0 || ret == 2) {\r
+ s = end;\r
+ if (! *s || *s == _T(',')) {\r
+ set[n].last = (int) number;\r
+ if (! *s) break;\r
+ n++;\r
+ s++;\r
+ }\r
+ else return 3;\r
+ }\r
+ else return 3;\r
+ break;\r
+\r
+ default:\r
+ return 3;\r
+ }\r
+ }\r
+ else return 4;\r
+ }\r
+\r
+ for (i = 0; i <= n; i++) {\r
+ for (int j = set[i].first; j <= set[i].last; j++) (__int64) *mask |= (1LL << (__int64) j);\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+inline 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
+int priority_constant_to_index(unsigned long constant) {\r
+ switch (constant & priority_mask()) {\r
+ case REALTIME_PRIORITY_CLASS: return NSSM_REALTIME_PRIORITY;\r
+ case HIGH_PRIORITY_CLASS: return NSSM_HIGH_PRIORITY;\r
+ case ABOVE_NORMAL_PRIORITY_CLASS: return NSSM_ABOVE_NORMAL_PRIORITY;\r
+ case BELOW_NORMAL_PRIORITY_CLASS: return NSSM_BELOW_NORMAL_PRIORITY;\r
+ case IDLE_PRIORITY_CLASS: return NSSM_IDLE_PRIORITY;\r
+ }\r
+ return NSSM_NORMAL_PRIORITY;\r
+}\r
+\r
+unsigned long priority_index_to_constant(int index) {\r
+ switch (index) {\r
+ case NSSM_REALTIME_PRIORITY: return REALTIME_PRIORITY_CLASS;\r
+ case NSSM_HIGH_PRIORITY: return HIGH_PRIORITY_CLASS;\r
+ case NSSM_ABOVE_NORMAL_PRIORITY: return ABOVE_NORMAL_PRIORITY_CLASS;\r
+ case NSSM_BELOW_NORMAL_PRIORITY: return BELOW_NORMAL_PRIORITY_CLASS;\r
+ case NSSM_IDLE_PRIORITY: return IDLE_PRIORITY_CLASS;\r
+ }\r
+ return NORMAL_PRIORITY_CLASS;\r
+}\r
+\r
+static inline unsigned long throttle_milliseconds(unsigned long throttle) {\r
/* pow() operates on doubles. */\r
- int ret = 1; for (unsigned long i = 1; i < throttle; i++) ret *= 2;\r
+ unsigned long ret = 1; for (unsigned long i = 1; i < throttle; i++) ret *= 2;\r
return ret * 1000;\r
}\r
\r
}\r
\r
/* Connect to the service manager */\r
-SC_HANDLE open_service_manager() {\r
- SC_HANDLE ret = OpenSCManager(0, SERVICES_ACTIVE_DATABASE, SC_MANAGER_ALL_ACCESS);\r
+SC_HANDLE open_service_manager(unsigned long access) {\r
+ SC_HANDLE ret = OpenSCManager(0, SERVICES_ACTIVE_DATABASE, access);\r
if (! ret) {\r
if (is_admin) log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OPENSCMANAGER_FAILED, 0);\r
return 0;\r
return ret;\r
}\r
\r
+/* Open a service by name or display name. */\r
+SC_HANDLE open_service(SC_HANDLE services, TCHAR *service_name, unsigned long access, TCHAR *canonical_name, unsigned long canonical_namelen) {\r
+ SC_HANDLE service_handle = OpenService(services, service_name, access);\r
+ if (service_handle) {\r
+ if (canonical_name && canonical_name != service_name) {\r
+ TCHAR displayname[SERVICE_NAME_LENGTH];\r
+ unsigned long displayname_len = (unsigned long) _countof(displayname);\r
+ GetServiceDisplayName(services, service_name, displayname, &displayname_len);\r
+ unsigned long keyname_len = canonical_namelen;\r
+ GetServiceKeyName(services, displayname, canonical_name, &keyname_len);\r
+ }\r
+ return service_handle;\r
+ }\r
+\r
+ unsigned long error = GetLastError();\r
+ if (error != ERROR_SERVICE_DOES_NOT_EXIST) {\r
+ print_message(stderr, NSSM_MESSAGE_OPENSERVICE_FAILED, error_string(GetLastError()));\r
+ return 0;\r
+ }\r
+\r
+ /* We can't look for a display name because there's no buffer to store it. */\r
+ if (! canonical_name) {\r
+ print_message(stderr, NSSM_MESSAGE_OPENSERVICE_FAILED, error_string(GetLastError()));\r
+ return 0;\r
+ }\r
+\r
+ unsigned long bufsize, required, count, i;\r
+ unsigned long resume = 0;\r
+ EnumServicesStatus(services, SERVICE_DRIVER | SERVICE_FILE_SYSTEM_DRIVER | SERVICE_KERNEL_DRIVER | SERVICE_WIN32, SERVICE_STATE_ALL, 0, 0, &required, &count, &resume);\r
+ error = GetLastError();\r
+ if (error != ERROR_MORE_DATA) {\r
+ print_message(stderr, NSSM_MESSAGE_ENUMSERVICESSTATUS_FAILED, error_string(GetLastError()));\r
+ return 0;\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("open_service()"));\r
+ return 0;\r
+ }\r
+\r
+ bufsize = required;\r
+ while (true) {\r
+ /*\r
+ EnumServicesStatus() returns:\r
+ 1 when it retrieved data and there's no more data to come.\r
+ 0 and sets last error to ERROR_MORE_DATA when it retrieved data and\r
+ there's more data to come.\r
+ 0 and sets last error to something else on error.\r
+ */\r
+ int ret = EnumServicesStatus(services, SERVICE_DRIVER | SERVICE_FILE_SYSTEM_DRIVER | SERVICE_KERNEL_DRIVER | 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 0;\r
+ }\r
+ }\r
+\r
+ for (i = 0; i < count; i++) {\r
+ if (str_equiv(status[i].lpDisplayName, service_name)) {\r
+ if (_sntprintf_s(canonical_name, canonical_namelen, _TRUNCATE, _T("%s"), status[i].lpServiceName) < 0) {\r
+ HeapFree(GetProcessHeap(), 0, status);\r
+ print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("canonical_name"), _T("open_service()"));\r
+ return 0;\r
+ }\r
+\r
+ HeapFree(GetProcessHeap(), 0, status);\r
+ return open_service(services, canonical_name, access, 0, 0);\r
+ }\r
+ }\r
+\r
+ if (ret) break;\r
+ }\r
+\r
+ /* Recurse so we can get an error message. */\r
+ return open_service(services, service_name, access, 0, 0);\r
+}\r
+\r
+QUERY_SERVICE_CONFIG *query_service_config(const TCHAR *service_name, SC_HANDLE service_handle) {\r
+ QUERY_SERVICE_CONFIG *qsc;\r
+ unsigned long bufsize;\r
+ unsigned long error;\r
+\r
+ QueryServiceConfig(service_handle, 0, 0, &bufsize);\r
+ error = GetLastError();\r
+ if (error == ERROR_INSUFFICIENT_BUFFER) {\r
+ qsc = (QUERY_SERVICE_CONFIG *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, bufsize);\r
+ if (! qsc) {\r
+ print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("QUERY_SERVICE_CONFIG"), _T("query_service_config()"), 0);\r
+ return 0;\r
+ }\r
+ }\r
+ else {\r
+ print_message(stderr, NSSM_MESSAGE_QUERYSERVICECONFIG_FAILED, service_name, error_string(error), 0);\r
+ return 0;\r
+ }\r
+\r
+ if (! QueryServiceConfig(service_handle, qsc, bufsize, &bufsize)) {\r
+ HeapFree(GetProcessHeap(), 0, qsc);\r
+ print_message(stderr, NSSM_MESSAGE_QUERYSERVICECONFIG_FAILED, service_name, error_string(GetLastError()), 0);\r
+ return 0;\r
+ }\r
+\r
+ return qsc;\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
+\r
+ if (buffer && buffer[0]) {\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
+ /*\r
+ Count the dependencies then allocate a buffer big enough for their\r
+ canonical names, ie n * SERVICE_NAME_LENGTH.\r
+ */\r
+ TCHAR *s;\r
+ TCHAR *groups = 0;\r
+ for (s = buffer; *s; s++) {\r
+ num_dependencies++;\r
+ if (*s == SC_GROUP_IDENTIFIER) groups = s;\r
+ while (*s) s++;\r
+ }\r
+\r
+ /* At least one dependency is a group so we need to verify them. */\r
+ if (groups) {\r
+ HKEY key;\r
+ if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, NSSM_REGISTRY_GROUPS, 0, KEY_READ, &key)) {\r
+ _ftprintf(stderr, _T("%s: %s\n"), NSSM_REGISTRY_GROUPS, error_string(GetLastError()));\r
+ return 2;\r
+ }\r
+\r
+ unsigned long type;\r
+ unsigned long groupslen;\r
+ unsigned long ret = RegQueryValueEx(key, NSSM_REG_GROUPS, 0, &type, NULL, &groupslen);\r
+ if (ret == ERROR_SUCCESS) {\r
+ groups = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, groupslen);\r
+ if (! groups) {\r
+ print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("groups"), _T("set_service_dependencies()"));\r
+ return 3;\r
+ }\r
+\r
+ ret = RegQueryValueEx(key, NSSM_REG_GROUPS, 0, &type, (unsigned char *) groups, &groupslen);\r
+ if (ret != ERROR_SUCCESS) {\r
+ _ftprintf(stderr, _T("%s\\%s: %s"), NSSM_REGISTRY_GROUPS, NSSM_REG_GROUPS, error_string(GetLastError()));\r
+ HeapFree(GetProcessHeap(), 0, groups);\r
+ RegCloseKey(key);\r
+ return 4;\r
+ }\r
+ }\r
+ else if (ret != ERROR_FILE_NOT_FOUND) {\r
+ _ftprintf(stderr, _T("%s\\%s: %s"), NSSM_REGISTRY_GROUPS, NSSM_REG_GROUPS, error_string(GetLastError()));\r
+ RegCloseKey(key);\r
+ return 4;\r
+ }\r
+\r
+ RegCloseKey(key);\r
+\r
+ }\r
+\r
+ unsigned long dependencieslen = (num_dependencies * SERVICE_NAME_LENGTH) + 2;\r
+ dependencies = (TCHAR *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dependencieslen * sizeof(TCHAR));\r
+ size_t i = 0;\r
+\r
+ TCHAR dependency[SERVICE_NAME_LENGTH];\r
+ for (s = buffer; *s; s++) {\r
+ /* Group? */\r
+ if (*s == SC_GROUP_IDENTIFIER) {\r
+ TCHAR *group = s + 1;\r
+\r
+ bool ok = false;\r
+ if (*group) {\r
+ for (TCHAR *g = groups; *g; g++) {\r
+ if (str_equiv(g, group)) {\r
+ ok = true;\r
+ /* Set canonical name. */\r
+ memmove(group, g, _tcslen(g) * sizeof(TCHAR));\r
+ break;\r
+ }\r
+\r
+ while (*g) g++;\r
+ }\r
+ }\r
+\r
+ if (ok) _sntprintf_s(dependency, _countof(dependency), _TRUNCATE, _T("%s"), s);\r
+ else {\r
+ HeapFree(GetProcessHeap(), 0, dependencies);\r
+ if (groups) HeapFree(GetProcessHeap(), 0, groups);\r
+ _ftprintf(stderr, _T("%s: %s"), s, error_string(ERROR_SERVICE_DEPENDENCY_DELETED));\r
+ return 5;\r
+ }\r
+ }\r
+ else {\r
+ SC_HANDLE dependency_handle = open_service(services, s, SERVICE_QUERY_STATUS, dependency, _countof(dependency));\r
+ if (! dependency_handle) {\r
+ HeapFree(GetProcessHeap(), 0, dependencies);\r
+ if (groups) HeapFree(GetProcessHeap(), 0, groups);\r
+ CloseServiceHandle(services);\r
+ _ftprintf(stderr, _T("%s: %s"), s, error_string(ERROR_SERVICE_DEPENDENCY_DELETED));\r
+ return 5;\r
+ }\r
+ }\r
+\r
+ size_t len = _tcslen(dependency) + 1;\r
+ memmove(dependencies + i, dependency, len * sizeof(TCHAR));\r
+ i += len;\r
+\r
+ while (*s) s++;\r
+ }\r
+\r
+ if (groups) HeapFree(GetProcessHeap(), 0, groups);\r
+ CloseServiceHandle(services);\r
+ }\r
+\r
+ if (! ChangeServiceConfig(service_handle, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE, 0, 0, 0, dependencies, 0, 0, 0)) {\r
+ if (num_dependencies) HeapFree(GetProcessHeap(), 0, dependencies);\r
+ print_message(stderr, NSSM_MESSAGE_CHANGESERVICECONFIG_FAILED, error_string(GetLastError()));\r
+ return -1;\r
+ }\r
+\r
+ if (num_dependencies) HeapFree(GetProcessHeap(), 0, dependencies);\r
+ return 0;\r
+}\r
+\r
+int get_service_dependencies(const TCHAR *service_name, SC_HANDLE service_handle, TCHAR **buffer, unsigned long *bufsize, int type) {\r
+ if (! buffer) return 1;\r
+ if (! bufsize) return 2;\r
+\r
+ *buffer = 0;\r
+ *bufsize = 0;\r
+\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
+\r
+ /* lpDependencies is doubly NULL terminated. */\r
+ while (qsc->lpDependencies[*bufsize]) {\r
+ while (qsc->lpDependencies[*bufsize]) ++*bufsize;\r
+ ++*bufsize;\r
+ }\r
+\r
+ *bufsize += 2;\r
+\r
+ *buffer = (TCHAR *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *bufsize * sizeof(TCHAR));\r
+ if (! *buffer) {\r
+ *bufsize = 0;\r
+ print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("lpDependencies"), _T("get_service_dependencies()"));\r
+ return 4;\r
+ }\r
+\r
+ if (type == DEPENDENCY_ALL) memmove(*buffer, qsc->lpDependencies, *bufsize * sizeof(TCHAR));\r
+ else {\r
+ TCHAR *s;\r
+ size_t i = 0;\r
+ *bufsize = 0;\r
+ for (s = qsc->lpDependencies; *s; s++) {\r
+ /* Only copy the appropriate type of dependency. */\r
+ if ((*s == SC_GROUP_IDENTIFIER && type & DEPENDENCY_GROUPS) || (*s != SC_GROUP_IDENTIFIER && type & DEPENDENCY_SERVICES)) {\r
+ size_t len = _tcslen(s) + 1;\r
+ *bufsize += (unsigned long) len;\r
+ memmove(*buffer + i, s, len * sizeof(TCHAR));\r
+ i += len;\r
+ }\r
+\r
+ while (*s) s++;\r
+ }\r
+ ++*bufsize;\r
+ }\r
+\r
+ HeapFree(GetProcessHeap(), 0, qsc);\r
+\r
+ return 0;\r
+}\r
+\r
+int get_service_dependencies(const TCHAR *service_name, SC_HANDLE service_handle, TCHAR **buffer, unsigned long *bufsize) {\r
+ return get_service_dependencies(service_name, service_handle, buffer, bufsize, DEPENDENCY_ALL);\r
+}\r
+\r
+int set_service_description(const TCHAR *service_name, SC_HANDLE service_handle, TCHAR *buffer) {\r
+ SERVICE_DESCRIPTION description;\r
+ ZeroMemory(&description, sizeof(description));\r
+ /*\r
+ lpDescription must be NULL if we aren't changing, the new description\r
+ or "".\r
+ */\r
+ if (buffer && buffer[0]) description.lpDescription = buffer;\r
+ else description.lpDescription = _T("");\r
+\r
+ if (ChangeServiceConfig2(service_handle, SERVICE_CONFIG_DESCRIPTION, &description)) return 0;\r
+\r
+ log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_SERVICE_CONFIG_DESCRIPTION_FAILED, service_name, error_string(GetLastError()), 0);\r
+ return 1;\r
+}\r
+\r
+int get_service_description(const TCHAR *service_name, SC_HANDLE service_handle, unsigned long len, TCHAR *buffer) {\r
+ if (! buffer) return 1;\r
+\r
+ unsigned long bufsize;\r
+ QueryServiceConfig2(service_handle, SERVICE_CONFIG_DESCRIPTION, 0, 0, &bufsize);\r
+ unsigned long error = GetLastError();\r
+ if (error == ERROR_INSUFFICIENT_BUFFER) {\r
+ SERVICE_DESCRIPTION *description = (SERVICE_DESCRIPTION *) HeapAlloc(GetProcessHeap(), 0, bufsize);\r
+ if (! description) {\r
+ print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("SERVICE_CONFIG_DESCRIPTION"), _T("get_service_description()"));\r
+ return 2;\r
+ }\r
+\r
+ if (QueryServiceConfig2(service_handle, SERVICE_CONFIG_DESCRIPTION, (unsigned char *) description, bufsize, &bufsize)) {\r
+ if (description->lpDescription) _sntprintf_s(buffer, len, _TRUNCATE, _T("%s"), description->lpDescription);\r
+ else ZeroMemory(buffer, len * sizeof(TCHAR));\r
+ HeapFree(GetProcessHeap(), 0, description);\r
+ return 0;\r
+ }\r
+ else {\r
+ HeapFree(GetProcessHeap(), 0, description);\r
+ print_message(stderr, NSSM_MESSAGE_QUERYSERVICECONFIG2_FAILED, service_name, _T("SERVICE_CONFIG_DESCRIPTION"), error_string(error));\r
+ return 3;\r
+ }\r
+ }\r
+ else {\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 (! qsc) return 1;\r
+\r
+ switch (qsc->dwStartType) {\r
+ case SERVICE_DEMAND_START: *startup = NSSM_STARTUP_MANUAL; break;\r
+ case SERVICE_DISABLED: *startup = NSSM_STARTUP_DISABLED; break;\r
+ default: *startup = NSSM_STARTUP_AUTOMATIC;\r
+ }\r
+\r
+ if (*startup != NSSM_STARTUP_AUTOMATIC) return 0;\r
+\r
+ /* Check for delayed start. */\r
+ unsigned long bufsize;\r
+ unsigned long error;\r
+ QueryServiceConfig2(service_handle, SERVICE_CONFIG_DELAYED_AUTO_START_INFO, 0, 0, &bufsize);\r
+ error = GetLastError();\r
+ if (error == ERROR_INSUFFICIENT_BUFFER) {\r
+ SERVICE_DELAYED_AUTO_START_INFO *info = (SERVICE_DELAYED_AUTO_START_INFO *) HeapAlloc(GetProcessHeap(), 0, bufsize);\r
+ if (! info) {\r
+ print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("SERVICE_DELAYED_AUTO_START_INFO"), _T("get_service_startup()"));\r
+ return 2;\r
+ }\r
+\r
+ if (QueryServiceConfig2(service_handle, SERVICE_CONFIG_DELAYED_AUTO_START_INFO, (unsigned char *) info, bufsize, &bufsize)) {\r
+ if (info->fDelayedAutostart) *startup = NSSM_STARTUP_DELAYED;\r
+ HeapFree(GetProcessHeap(), 0, info);\r
+ return 0;\r
+ }\r
+ else {\r
+ error = GetLastError();\r
+ if (error != ERROR_INVALID_LEVEL) {\r
+ print_message(stderr, NSSM_MESSAGE_QUERYSERVICECONFIG2_FAILED, service_name, _T("SERVICE_CONFIG_DELAYED_AUTO_START_INFO"), error_string(error));\r
+ return 3;\r
+ }\r
+ }\r
+ }\r
+ else if (error != ERROR_INVALID_LEVEL) {\r
+ print_message(stderr, NSSM_MESSAGE_QUERYSERVICECONFIG2_FAILED, service_name, _T("SERVICE_DELAYED_AUTO_START_INFO"), error_string(error));\r
+ return 3;\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+int get_service_username(const TCHAR *service_name, const QUERY_SERVICE_CONFIG *qsc, TCHAR **username, size_t *usernamelen) {\r
+ if (! username) return 1;\r
+ if (! usernamelen) return 1;\r
+\r
+ *username = 0;\r
+ *usernamelen = 0;\r
+\r
+ if (! qsc) return 1;\r
+\r
+ if (qsc->lpServiceStartName[0]) {\r
+ if (is_localsystem(qsc->lpServiceStartName)) return 0;\r
+\r
+ size_t len = _tcslen(qsc->lpServiceStartName);\r
+ *username = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(TCHAR));\r
+ if (! *username) {\r
+ print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("username"), _T("get_service_username()"));\r
+ return 2;\r
+ }\r
+\r
+ memmove(*username, qsc->lpServiceStartName, (len + 1) * sizeof(TCHAR));\r
+ *usernamelen = len;\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
/* Set default values which aren't zero. */\r
void set_nssm_service_defaults(nssm_service_t *service) {\r
if (! service) return;\r
\r
+ service->type = SERVICE_WIN32_OWN_PROCESS;\r
+ service->priority = NORMAL_PRIORITY_CLASS;\r
service->stdin_sharing = NSSM_STDIN_SHARING;\r
service->stdin_disposition = NSSM_STDIN_DISPOSITION;\r
service->stdin_flags = NSSM_STDIN_FLAGS;\r
service->kill_console_delay = NSSM_KILL_CONSOLE_GRACE_PERIOD;\r
service->kill_window_delay = NSSM_KILL_WINDOW_GRACE_PERIOD;\r
service->kill_threads_delay = NSSM_KILL_THREADS_GRACE_PERIOD;\r
+ service->kill_process_tree = 1;\r
}\r
\r
/* Allocate and zero memory for a service. */\r
/* Free memory for a service. */\r
void cleanup_nssm_service(nssm_service_t *service) {\r
if (! service) return;\r
+ if (service->username) HeapFree(GetProcessHeap(), 0, service->username);\r
+ if (service->password) {\r
+ SecureZeroMemory(service->password, service->passwordlen);\r
+ HeapFree(GetProcessHeap(), 0, service->password);\r
+ }\r
+ if (service->dependencies) HeapFree(GetProcessHeap(), 0, service->dependencies);\r
if (service->env) HeapFree(GetProcessHeap(), 0, service->env);\r
if (service->env_extra) HeapFree(GetProcessHeap(), 0, service->env_extra);\r
if (service->handle) CloseServiceHandle(service->handle);\r
if (service->process_handle) CloseHandle(service->process_handle);\r
- if (service->wait_handle) UnregisterWait(service->process_handle);\r
+ if (service->wait_handle) UnregisterWait(service->wait_handle);\r
if (service->throttle_section_initialised) DeleteCriticalSection(&service->throttle_section);\r
if (service->throttle_timer) CloseHandle(service->throttle_timer);\r
+ if (service->initial_env) FreeEnvironmentStrings(service->initial_env);\r
HeapFree(GetProcessHeap(), 0, service);\r
}\r
\r
/* About to install the service */\r
int pre_install_service(int argc, TCHAR **argv) {\r
+ nssm_service_t *service = alloc_nssm_service();\r
+ set_nssm_service_defaults(service);\r
+ if (argc) _sntprintf_s(service->name, _countof(service->name), _TRUNCATE, _T("%s"), argv[0]);\r
+\r
/* Show the dialogue box if we didn't give the service name and path */\r
- if (argc < 2) return nssm_gui(IDD_INSTALL, argv[0]);\r
+ if (argc < 2) return nssm_gui(IDD_INSTALL, service);\r
\r
- nssm_service_t *service = alloc_nssm_service();\r
if (! service) {\r
- print_message(stderr, NSSM_EVENT_OUT_OF_MEMORY, _T("service"), _T("pre_install_service()"));\r
+ print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("service"), _T("pre_install_service()"));\r
return 1;\r
}\r
-\r
- set_nssm_service_defaults(service);\r
- _sntprintf_s(service->name, _countof(service->name), _TRUNCATE, _T("%s"), argv[0]);\r
_sntprintf_s(service->exe, _countof(service->exe), _TRUNCATE, _T("%s"), argv[1]);\r
\r
/* Arguments are optional */\r
return ret;\r
}\r
\r
+/* About to edit the service. */\r
+int pre_edit_service(int argc, TCHAR **argv) {\r
+ /* Require service name. */\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
+ const TCHAR *verb = argv[0];\r
+ const TCHAR *service_name = argv[1];\r
+ bool getting = false;\r
+ bool unsetting = false;\r
+\r
+ /* Minimum number of arguments. */\r
+ int mandatory = 2;\r
+ /* Index of first value. */\r
+ int remainder = 3;\r
+ int i;\r
+ if (str_equiv(verb, _T("get"))) {\r
+ mandatory = 3;\r
+ mode = MODE_GETTING;\r
+ }\r
+ else if (str_equiv(verb, _T("set"))) {\r
+ mandatory = 4;\r
+ mode = MODE_SETTING;\r
+ }\r
+ else if (str_equiv(verb, _T("reset")) || str_equiv(verb, _T("unset"))) {\r
+ mandatory = 3;\r
+ mode = MODE_RESETTING;\r
+ }\r
+ if (argc < mandatory) return usage(1);\r
+\r
+ const TCHAR *parameter = 0;\r
+ settings_t *setting = 0;\r
+ TCHAR *additional;\r
+\r
+ /* Validate the parameter. */\r
+ if (mandatory > 2) {\r
+ bool additional_mandatory = false;\r
+\r
+ parameter = argv[2];\r
+ for (i = 0; settings[i].name; i++) {\r
+ setting = &settings[i];\r
+ if (! str_equiv(setting->name, parameter)) continue;\r
+ if (((setting->additional & ADDITIONAL_GETTING) && mode == MODE_GETTING) || ((setting->additional & ADDITIONAL_SETTING) && mode == MODE_SETTING) || ((setting->additional & ADDITIONAL_RESETTING) && mode == MODE_RESETTING)) {\r
+ additional_mandatory = true;\r
+ mandatory++;\r
+ }\r
+ break;\r
+ }\r
+ if (! settings[i].name) {\r
+ print_message(stderr, NSSM_MESSAGE_INVALID_PARAMETER, parameter);\r
+ for (i = 0; settings[i].name; i++) _ftprintf(stderr, _T("%s\n"), settings[i].name);\r
+ return 1;\r
+ }\r
+\r
+ additional = 0;\r
+ if (additional_mandatory) {\r
+ if (argc < mandatory) {\r
+ print_message(stderr, NSSM_MESSAGE_MISSING_SUBPARAMETER, parameter);\r
+ return 1;\r
+ }\r
+ additional = argv[3];\r
+ remainder = 4;\r
+ }\r
+ else if (str_equiv(setting->name, NSSM_NATIVE_OBJECTNAME) && mode == MODE_SETTING) {\r
+ additional = argv[3];\r
+ remainder = 4;\r
+ }\r
+ else {\r
+ additional = argv[remainder];\r
+ if (argc < mandatory) return usage(1);\r
+ }\r
+ }\r
+\r
+ nssm_service_t *service = alloc_nssm_service();\r
+ _sntprintf_s(service->name, _countof(service->name), _TRUNCATE, _T("%s"), service_name);\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 2;\r
+ }\r
+\r
+ /* Try to open the service */\r
+ unsigned long access = SERVICE_QUERY_CONFIG;\r
+ if (mode != MODE_GETTING) access |= SERVICE_CHANGE_CONFIG;\r
+ service->handle = open_service(services, service->name, access, service->name, _countof(service->name));\r
+ if (! service->handle) {\r
+ CloseServiceHandle(services);\r
+ return 3;\r
+ }\r
+\r
+ /* Get system details. */\r
+ QUERY_SERVICE_CONFIG *qsc = query_service_config(service->name, service->handle);\r
+ if (! qsc) {\r
+ CloseServiceHandle(service->handle);\r
+ CloseServiceHandle(services);\r
+ return 4;\r
+ }\r
+\r
+ service->type = qsc->dwServiceType;\r
+ if (! (service->type & SERVICE_WIN32_OWN_PROCESS)) {\r
+ if (mode != MODE_GETTING) {\r
+ HeapFree(GetProcessHeap(), 0, qsc);\r
+ CloseServiceHandle(service->handle);\r
+ CloseServiceHandle(services);\r
+ print_message(stderr, NSSM_MESSAGE_CANNOT_EDIT, service->name, NSSM_WIN32_OWN_PROCESS, 0);\r
+ return 3;\r
+ }\r
+ }\r
+\r
+ if (get_service_startup(service->name, service->handle, qsc, &service->startup)) {\r
+ if (mode != MODE_GETTING) {\r
+ HeapFree(GetProcessHeap(), 0, qsc);\r
+ CloseServiceHandle(service->handle);\r
+ CloseServiceHandle(services);\r
+ return 4;\r
+ }\r
+ }\r
+\r
+ if (get_service_username(service->name, qsc, &service->username, &service->usernamelen)) {\r
+ if (mode != MODE_GETTING) {\r
+ HeapFree(GetProcessHeap(), 0, qsc);\r
+ CloseServiceHandle(service->handle);\r
+ CloseServiceHandle(services);\r
+ return 5;\r
+ }\r
+ }\r
+\r
+ _sntprintf_s(service->displayname, _countof(service->displayname), _TRUNCATE, _T("%s"), qsc->lpDisplayName);\r
+\r
+ /* Get the canonical service name. We open it case insensitively. */\r
+ unsigned long bufsize = _countof(service->name);\r
+ GetServiceKeyName(services, service->displayname, service->name, &bufsize);\r
+\r
+ /* Remember the executable in case it isn't NSSM. */\r
+ _sntprintf_s(service->image, _countof(service->image), _TRUNCATE, _T("%s"), qsc->lpBinaryPathName);\r
+ HeapFree(GetProcessHeap(), 0, qsc);\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
+ CloseServiceHandle(service->handle);\r
+ CloseServiceHandle(services);\r
+ return 6;\r
+ }\r
+ }\r
+\r
+ if (get_service_dependencies(service->name, service->handle, &service->dependencies, &service->dependencieslen)) {\r
+ if (mode != MODE_GETTING) {\r
+ CloseServiceHandle(service->handle);\r
+ CloseServiceHandle(services);\r
+ return 7;\r
+ }\r
+ }\r
+\r
+ /* Get NSSM details. */\r
+ get_parameters(service, 0);\r
+\r
+ CloseServiceHandle(services);\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
+ }\r
+\r
+ /* Editing with the GUI. */\r
+ if (mode == MODE_EDITING) {\r
+ nssm_gui(IDD_EDIT, service);\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
+ print_message(stderr, NSSM_MESSAGE_NATIVE_PARAMETER, setting->name, NSSM);\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
+ if (! key) return 4;\r
+ }\r
+\r
+ if (setting->native) ret = get_setting(service->name, service->handle, setting, &value, additional);\r
+ else ret = get_setting(service->name, key, setting, &value, additional);\r
+ if (ret < 0) {\r
+ CloseServiceHandle(service->handle);\r
+ return 5;\r
+ }\r
+\r
+ switch (setting->type) {\r
+ case REG_EXPAND_SZ:\r
+ case REG_MULTI_SZ:\r
+ case REG_SZ:\r
+ _tprintf(_T("%s\n"), value.string ? value.string : _T(""));\r
+ HeapFree(GetProcessHeap(), 0, value.string);\r
+ break;\r
+\r
+ case REG_DWORD:\r
+ _tprintf(_T("%u\n"), value.numeric);\r
+ break;\r
+ }\r
+\r
+ if (! service->native) RegCloseKey(key);\r
+ CloseServiceHandle(service->handle);\r
+ return 0;\r
+ }\r
+\r
+ /* Build the value. */\r
+ if (mode == MODE_RESETTING) {\r
+ /* Unset the parameter. */\r
+ value.string = 0;\r
+ }\r
+ else if (remainder == argc) {\r
+ value.string = 0;\r
+ }\r
+ else {\r
+ /* Set the parameter. */\r
+ size_t len = 0;\r
+ size_t delimiterlen = (setting->additional & ADDITIONAL_CRLF) ? 2 : 1;\r
+ for (i = remainder; i < argc; i++) len += _tcslen(argv[i]) + delimiterlen;\r
+ len++;\r
+\r
+ value.string = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, len * sizeof(TCHAR));\r
+ if (! value.string) {\r
+ print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("value"), _T("edit_service()"));\r
+ CloseServiceHandle(service->handle);\r
+ return 2;\r
+ }\r
+\r
+ size_t s = 0;\r
+ for (i = remainder; i < argc; i++) {\r
+ size_t len = _tcslen(argv[i]);\r
+ memmove(value.string + s, argv[i], len * sizeof(TCHAR));\r
+ s += len;\r
+ if (i < argc - 1) {\r
+ if (setting->additional & ADDITIONAL_CRLF) {\r
+ value.string[s++] = _T('\r');\r
+ value.string[s++] = _T('\n');\r
+ }\r
+ else value.string[s++] = _T(' ');\r
+ }\r
+ }\r
+ value.string[s] = _T('\0');\r
+ }\r
+\r
+ if (! service->native) {\r
+ key = open_registry(service->name, KEY_WRITE);\r
+ if (! key) {\r
+ if (value.string) HeapFree(GetProcessHeap(), 0, value.string);\r
+ return 4;\r
+ }\r
+ }\r
+\r
+ if (setting->native) ret = set_setting(service->name, service->handle, setting, &value, additional);\r
+ else ret = set_setting(service->name, key, setting, &value, additional);\r
+ if (value.string) HeapFree(GetProcessHeap(), 0, value.string);\r
+ if (ret < 0) {\r
+ if (! service->native) RegCloseKey(key);\r
+ CloseServiceHandle(service->handle);\r
+ return 6;\r
+ }\r
+\r
+ if (! service->native) RegCloseKey(key);\r
+ CloseServiceHandle(service->handle);\r
+\r
+ return 0;\r
+}\r
+\r
/* About to remove the service */\r
int pre_remove_service(int argc, TCHAR **argv) {\r
+ nssm_service_t *service = alloc_nssm_service();\r
+ set_nssm_service_defaults(service);\r
+ if (argc) _sntprintf_s(service->name, _countof(service->name), _TRUNCATE, _T("%s"), argv[0]);\r
+\r
/* Show dialogue box if we didn't pass service name and "confirm" */\r
- if (argc < 2) return nssm_gui(IDD_REMOVE, argv[0]);\r
+ if (argc < 2) return nssm_gui(IDD_REMOVE, service);\r
if (str_equiv(argv[1], _T("confirm"))) {\r
- nssm_service_t *service = alloc_nssm_service();\r
- _sntprintf_s(service->name, _countof(service->name), _TRUNCATE, _T("%s"), argv[0]);\r
int ret = remove_service(service);\r
cleanup_nssm_service(service);\r
return ret;\r
if (! service) return 1;\r
\r
/* Open service manager */\r
- SC_HANDLE services = open_service_manager();\r
+ SC_HANDLE services = open_service_manager(SC_MANAGER_CONNECT | SC_MANAGER_CREATE_SERVICE);\r
if (! services) {\r
print_message(stderr, NSSM_MESSAGE_OPEN_SERVICE_MANAGER_FAILED);\r
cleanup_nssm_service(service);\r
}\r
\r
/* Get path of this program */\r
- TCHAR command[MAX_PATH];\r
- GetModuleFileName(0, command, _countof(command));\r
+ GetModuleFileName(0, service->image, _countof(service->image));\r
\r
- /* Create the service */\r
- service->handle = CreateService(services, service->name, service->name, SC_MANAGER_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, command, 0, 0, 0, 0, 0);\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
if (! service->handle) {\r
- print_message(stderr, NSSM_MESSAGE_CREATESERVICE_FAILED);\r
+ print_message(stderr, NSSM_MESSAGE_CREATESERVICE_FAILED, error_string(GetLastError()));\r
CloseServiceHandle(services);\r
return 5;\r
}\r
\r
- /* Now we need to put the parameters into the registry */\r
- if (create_parameters(service)) {\r
- print_message(stderr, NSSM_MESSAGE_CREATE_PARAMETERS_FAILED);\r
+ if (edit_service(service, false)) {\r
DeleteService(service->handle);\r
CloseServiceHandle(services);\r
return 6;\r
}\r
\r
- set_service_recovery(service);\r
-\r
print_message(stdout, NSSM_MESSAGE_SERVICE_INSTALLED, service->name);\r
\r
/* Cleanup */\r
return 0;\r
}\r
\r
+/* Edit the service. */\r
+int edit_service(nssm_service_t *service, bool editing) {\r
+ if (! service) return 1;\r
+\r
+ /*\r
+ The only two valid flags for service type are SERVICE_WIN32_OWN_PROCESS\r
+ and SERVICE_INTERACTIVE_PROCESS.\r
+ */\r
+ service->type &= SERVICE_INTERACTIVE_PROCESS;\r
+ service->type |= SERVICE_WIN32_OWN_PROCESS;\r
+\r
+ /* Startup type. */\r
+ unsigned long startup;\r
+ switch (service->startup) {\r
+ case NSSM_STARTUP_MANUAL: startup = SERVICE_DEMAND_START; break;\r
+ case NSSM_STARTUP_DISABLED: startup = SERVICE_DISABLED; break;\r
+ default: startup = SERVICE_AUTO_START;\r
+ }\r
+\r
+ /* Display name. */\r
+ if (! service->displayname[0]) _sntprintf_s(service->displayname, _countof(service->displayname), _TRUNCATE, _T("%s"), service->name);\r
+\r
+ /*\r
+ Username must be NULL if we aren't changing or an account name.\r
+ We must explicitly use LOCALSYSTEM to change it when we are editing.\r
+ Password must be NULL if we aren't changing, a password or "".\r
+ Empty passwords are valid but we won't allow them in the GUI.\r
+ */\r
+ TCHAR *username = 0;\r
+ TCHAR *canon = 0;\r
+ TCHAR *password = 0;\r
+ if (service->usernamelen) {\r
+ username = service->username;\r
+ if (canonicalise_username(username, &canon)) return 5;\r
+ if (service->passwordlen) password = service->password;\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
+ }\r
+ }\r
+\r
+ TCHAR *dependencies = _T("");\r
+ if (service->dependencieslen) dependencies = 0; /* Change later. */\r
+\r
+ if (! ChangeServiceConfig(service->handle, service->type, startup, SERVICE_NO_CHANGE, 0, 0, 0, dependencies, canon, password, service->displayname)) {\r
+ if (canon != username) HeapFree(GetProcessHeap(), 0, canon);\r
+ print_message(stderr, NSSM_MESSAGE_CHANGESERVICECONFIG_FAILED, error_string(GetLastError()));\r
+ return 5;\r
+ }\r
+ if (canon != username) HeapFree(GetProcessHeap(), 0, canon);\r
+\r
+ if (service->dependencieslen) {\r
+ if (set_service_dependencies(service->name, service->handle, service->dependencies)) return 5;\r
+ }\r
+\r
+ if (service->description[0] || editing) {\r
+ set_service_description(service->name, service->handle, service->description);\r
+ }\r
+\r
+ SERVICE_DELAYED_AUTO_START_INFO delayed;\r
+ ZeroMemory(&delayed, sizeof(delayed));\r
+ if (service->startup == NSSM_STARTUP_DELAYED) delayed.fDelayedAutostart = 1;\r
+ else delayed.fDelayedAutostart = 0;\r
+ /* Delayed startup isn't supported until Vista. */\r
+ if (! ChangeServiceConfig2(service->handle, SERVICE_CONFIG_DELAYED_AUTO_START_INFO, &delayed)) {\r
+ unsigned long error = GetLastError();\r
+ /* Pre-Vista we expect to fail with ERROR_INVALID_LEVEL */\r
+ if (error != ERROR_INVALID_LEVEL) {\r
+ log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_SERVICE_CONFIG_DELAYED_AUTO_START_INFO_FAILED, service->name, error_string(error), 0);\r
+ }\r
+ }\r
+\r
+ /* Don't mess with parameters which aren't ours. */\r
+ if (! service->native) {\r
+ /* Now we need to put the parameters into the registry */\r
+ if (create_parameters(service, editing)) {\r
+ print_message(stderr, NSSM_MESSAGE_CREATE_PARAMETERS_FAILED);\r
+ return 6;\r
+ }\r
+\r
+ set_service_recovery(service);\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+/* Control a service. */\r
+int control_service(unsigned long control, int argc, TCHAR **argv) {\r
+ if (argc < 1) return usage(1);\r
+ TCHAR *service_name = argv[0];\r
+ TCHAR canonical_name[SERVICE_NAME_LENGTH];\r
+\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 2;\r
+ }\r
+\r
+ unsigned long access = SERVICE_QUERY_STATUS;\r
+ switch (control) {\r
+ case NSSM_SERVICE_CONTROL_START:\r
+ access |= SERVICE_START;\r
+ break;\r
+\r
+ case SERVICE_CONTROL_CONTINUE:\r
+ case SERVICE_CONTROL_PAUSE:\r
+ access |= SERVICE_PAUSE_CONTINUE;\r
+ break;\r
+\r
+ case SERVICE_CONTROL_STOP:\r
+ access |= SERVICE_STOP;\r
+ break;\r
+\r
+ case NSSM_SERVICE_CONTROL_ROTATE:\r
+ access |= SERVICE_USER_DEFINED_CONTROL;\r
+ break;\r
+ }\r
+\r
+ SC_HANDLE service_handle = open_service(services, service_name, access, canonical_name, _countof(canonical_name));\r
+ if (! service_handle) {\r
+ CloseServiceHandle(services);\r
+ return 3;\r
+ }\r
+\r
+ int ret;\r
+ unsigned long error;\r
+ SERVICE_STATUS service_status;\r
+ if (control == NSSM_SERVICE_CONTROL_START) {\r
+ unsigned long initial_status = SERVICE_STOPPED;\r
+ ret = StartService(service_handle, (unsigned long) argc, (const TCHAR **) argv);\r
+ error = GetLastError();\r
+ CloseServiceHandle(services);\r
+\r
+ if (error == ERROR_IO_PENDING) {\r
+ /*\r
+ Older versions of Windows return immediately with ERROR_IO_PENDING\r
+ indicate that the operation is still in progress. Newer versions\r
+ will return it if there really is a delay.\r
+ */\r
+ ret = 1;\r
+ error = ERROR_SUCCESS;\r
+ }\r
+\r
+ if (ret) {\r
+ int response = await_service_control_response(control, service_handle, &service_status, initial_status);\r
+ CloseServiceHandle(service_handle);\r
+\r
+ if (response) {\r
+ print_message(stderr, NSSM_MESSAGE_BAD_CONTROL_RESPONSE, canonical_name, service_status_text(service_status.dwCurrentState), service_control_text(control));\r
+ return 1;\r
+ }\r
+ else _tprintf(_T("%s: %s: %s"), canonical_name, service_control_text(control), error_string(error));\r
+ return 0;\r
+ }\r
+ else {\r
+ CloseServiceHandle(service_handle);\r
+ _ftprintf(stderr, _T("%s: %s: %s"), canonical_name, service_control_text(control), error_string(error));\r
+ return 1;\r
+ }\r
+ }\r
+ else if (control == SERVICE_CONTROL_INTERROGATE) {\r
+ /*\r
+ We could actually send an INTERROGATE control but that won't return\r
+ any information if the service is stopped and we don't care about\r
+ the extra details it might give us in any case. So we'll fake it.\r
+ */\r
+ ret = QueryServiceStatus(service_handle, &service_status);\r
+ error = GetLastError();\r
+\r
+ if (ret) {\r
+ _tprintf(_T("%s\n"), service_status_text(service_status.dwCurrentState));\r
+ return 0;\r
+ }\r
+ else {\r
+ _ftprintf(stderr, _T("%s: %s\n"), canonical_name, error_string(error));\r
+ return 1;\r
+ }\r
+ }\r
+ else {\r
+ ret = ControlService(service_handle, control, &service_status);\r
+ unsigned long initial_status = service_status.dwCurrentState;\r
+ error = GetLastError();\r
+ CloseServiceHandle(services);\r
+\r
+ if (error == ERROR_IO_PENDING) {\r
+ ret = 1;\r
+ error = ERROR_SUCCESS;\r
+ }\r
+\r
+ if (ret) {\r
+ int response = await_service_control_response(control, service_handle, &service_status, initial_status);\r
+ CloseServiceHandle(service_handle);\r
+\r
+ if (response) {\r
+ print_message(stderr, NSSM_MESSAGE_BAD_CONTROL_RESPONSE, canonical_name, service_status_text(service_status.dwCurrentState), service_control_text(control));\r
+ return 1;\r
+ }\r
+ else _tprintf(_T("%s: %s: %s"), canonical_name, service_control_text(control), error_string(error));\r
+ return 0;\r
+ }\r
+ else {\r
+ CloseServiceHandle(service_handle);\r
+ _ftprintf(stderr, _T("%s: %s: %s"), canonical_name, service_control_text(control), error_string(error));\r
+ if (error == ERROR_SERVICE_NOT_ACTIVE) {\r
+ if (control == SERVICE_CONTROL_SHUTDOWN || control == SERVICE_CONTROL_STOP) return 0;\r
+ }\r
+ return 1;\r
+ }\r
+ }\r
+}\r
+\r
/* Remove the service */\r
int remove_service(nssm_service_t *service) {\r
if (! service) return 1;\r
\r
/* Open service manager */\r
- SC_HANDLE services = 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 2;\r
}\r
\r
/* Try to open the service */\r
- service->handle = OpenService(services, service->name, SC_MANAGER_ALL_ACCESS);\r
+ service->handle = open_service(services, service->name, DELETE, service->name, _countof(service->name));\r
if (! service->handle) {\r
- print_message(stderr, NSSM_MESSAGE_OPENSERVICE_FAILED);\r
CloseServiceHandle(services);\r
return 3;\r
}\r
\r
+ /* Get the canonical service name. We open it case insensitively. */\r
+ unsigned long bufsize = _countof(service->displayname);\r
+ GetServiceDisplayName(services, service->name, service->displayname, &bufsize);\r
+ bufsize = _countof(service->name);\r
+ GetServiceKeyName(services, service->displayname, service->name, &bufsize);\r
+\r
/* Try to delete the service */\r
if (! DeleteService(service->handle)) {\r
print_message(stderr, NSSM_MESSAGE_DELETESERVICE_FAILED);\r
/* Initialise status */\r
ZeroMemory(&service->status, sizeof(service->status));\r
service->status.dwServiceType = SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS;\r
- service->status.dwControlsAccepted = SERVICE_ACCEPT_SHUTDOWN | SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_PAUSE_CONTINUE;\r
+ service->status.dwControlsAccepted = SERVICE_ACCEPT_POWEREVENT | SERVICE_ACCEPT_SHUTDOWN | SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_PAUSE_CONTINUE;\r
service->status.dwWin32ExitCode = NO_ERROR;\r
service->status.dwServiceSpecificExitCode = 0;\r
service->status.dwCheckPoint = 0;\r
\r
if (is_admin) {\r
/* Try to create the exit action parameters; we don't care if it fails */\r
- create_exit_action(service->name, exit_action_strings[0]);\r
+ create_exit_action(service->name, exit_action_strings[0], false);\r
\r
- SC_HANDLE services = open_service_manager();\r
+ SC_HANDLE services = open_service_manager(SC_MANAGER_CONNECT);\r
if (services) {\r
- service->handle = OpenService(services, service->name, SC_MANAGER_ALL_ACCESS);\r
+ service->handle = open_service(services, service->name, SERVICE_CHANGE_CONFIG, 0, 0);\r
set_service_recovery(service);\r
+\r
CloseServiceHandle(services);\r
}\r
}\r
}\r
}\r
\r
+ /* Remember our initial environment. */\r
+ service->initial_env = GetEnvironmentStrings();\r
+\r
monitor_service(service);\r
}\r
\r
unsigned long error = GetLastError();\r
/* Pre-Vista we expect to fail with ERROR_INVALID_LEVEL */\r
if (error != ERROR_INVALID_LEVEL) {\r
- log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CHANGESERVICECONFIG2_FAILED, service->name, error_string(error), 0);\r
+ log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_SERVICE_CONFIG_FAILURE_ACTIONS_FAILED, service->name, error_string(error), 0);\r
}\r
}\r
}\r
TCHAR *service_control_text(unsigned long control) {\r
switch (control) {\r
/* HACK: there is no SERVICE_CONTROL_START constant */\r
- case 0: return _T("START");\r
+ case NSSM_SERVICE_CONTROL_START: return _T("START");\r
case SERVICE_CONTROL_STOP: return _T("STOP");\r
case SERVICE_CONTROL_SHUTDOWN: return _T("SHUTDOWN");\r
case SERVICE_CONTROL_PAUSE: return _T("PAUSE");\r
case SERVICE_CONTROL_CONTINUE: return _T("CONTINUE");\r
case SERVICE_CONTROL_INTERROGATE: return _T("INTERROGATE");\r
+ case NSSM_SERVICE_CONTROL_ROTATE: return _T("ROTATE");\r
+ case SERVICE_CONTROL_POWEREVENT: return _T("POWEREVENT");\r
+ default: return 0;\r
+ }\r
+}\r
+\r
+TCHAR *service_status_text(unsigned long status) {\r
+ switch (status) {\r
+ case SERVICE_STOPPED: return _T("SERVICE_STOPPED");\r
+ case SERVICE_START_PENDING: return _T("SERVICE_START_PENDING");\r
+ case SERVICE_STOP_PENDING: return _T("SERVICE_STOP_PENDING");\r
+ case SERVICE_RUNNING: return _T("SERVICE_RUNNING");\r
+ case SERVICE_CONTINUE_PENDING: return _T("SERVICE_CONTINUE_PENDING");\r
+ case SERVICE_PAUSE_PENDING: return _T("SERVICE_PAUSE_PENDING");\r
+ case SERVICE_PAUSED: return _T("SERVICE_PAUSED");\r
default: return 0;\r
}\r
}\r
ZeroMemory(&service->throttle_duetime, sizeof(service->throttle_duetime));\r
SetWaitableTimer(service->throttle_timer, &service->throttle_duetime, 0, 0, 0, 0);\r
}\r
- service->status.dwCurrentState = SERVICE_CONTINUE_PENDING;\r
+ /* We can't continue if the application is running! */\r
+ if (! service->process_handle) service->status.dwCurrentState = SERVICE_CONTINUE_PENDING;\r
service->status.dwWaitHint = throttle_milliseconds(service->throttle) + NSSM_WAITHINT_MARGIN;\r
log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_RESET_THROTTLE, service->name, 0);\r
SetServiceStatus(service->status_handle, &service->status);\r
*/\r
log_service_control(service->name, control, false);\r
return ERROR_CALL_NOT_IMPLEMENTED;\r
+\r
+ case NSSM_SERVICE_CONTROL_ROTATE:\r
+ log_service_control(service->name, control, true);\r
+ if (service->rotate_stdout_online == NSSM_ROTATE_ONLINE) service->rotate_stdout_online = NSSM_ROTATE_ONLINE_ASAP;\r
+ if (service->rotate_stderr_online == NSSM_ROTATE_ONLINE) service->rotate_stderr_online = NSSM_ROTATE_ONLINE_ASAP;\r
+ return NO_ERROR;\r
+\r
+ case SERVICE_CONTROL_POWEREVENT:\r
+ if (event != PBT_APMRESUMEAUTOMATIC) {\r
+ log_service_control(service->name, control, false);\r
+ return NO_ERROR;\r
+ }\r
+ log_service_control(service->name, control, true);\r
+ end_service((void *) service, false);\r
+ return NO_ERROR;\r
}\r
\r
/* Unknown control */\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
- close_output_handles(&si);\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
+ /* Set up I/O redirection. */\r
+ if (get_output_handles(service, &si)) {\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
+ return stop_service(service, 4, true, true);\r
+ }\r
+\r
bool inherit_handles = false;\r
if (si.dwFlags & STARTF_USESTDHANDLES) inherit_handles = true;\r
- unsigned long flags = 0;\r
-#ifdef UNICODE\r
- flags |= CREATE_UNICODE_ENVIRONMENT;\r
-#endif\r
- if (! CreateProcess(0, cmd, 0, 0, inherit_handles, flags, service->env, service->dir, &si, &pi)) {\r
+ unsigned long flags = service->priority & priority_mask();\r
+ if (service->affinity) flags |= CREATE_SUSPENDED;\r
+ if (! CreateProcess(0, cmd, 0, 0, inherit_handles, flags, 0, service->dir, &si, &pi)) {\r
+ unsigned long exitcode = 3;\r
unsigned long error = GetLastError();\r
- if (error == ERROR_INVALID_PARAMETER && service->env) log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATEPROCESS_FAILED_INVALID_ENVIRONMENT, service->name, service->exe, NSSM_REG_ENV, 0);\r
- else log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATEPROCESS_FAILED, service->name, service->exe, error_string(error), 0);\r
+ log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATEPROCESS_FAILED, service->name, service->exe, error_string(error), 0);\r
close_output_handles(&si);\r
- return stop_service(service, 3, true, true);\r
+ duplicate_environment_strings(service->initial_env);\r
+ return stop_service(service, exitcode, true, true);\r
}\r
service->process_handle = pi.hProcess;\r
service->pid = pi.dwProcessId;\r
\r
close_output_handles(&si);\r
\r
+ if (! service->no_console) FreeConsole();\r
+\r
+ /* Restore our environment. */\r
+ duplicate_environment_strings(service->initial_env);\r
+\r
+ if (service->affinity) {\r
+ /*\r
+ We are explicitly storing service->affinity as a 64-bit unsigned integer\r
+ so that we can parse it regardless of whether we're running in 32-bit\r
+ or 64-bit mode. The arguments to SetProcessAffinityMask(), however, are\r
+ defined as type DWORD_PTR and hence limited to 32 bits on a 32-bit system\r
+ (or when running the 32-bit NSSM).\r
+\r
+ The result is a lot of seemingly-unnecessary casting throughout the code\r
+ and potentially confusion when we actually try to start the service.\r
+ Having said that, however, it's unlikely that we're actually going to\r
+ run in 32-bit mode on a system which has more than 32 CPUs so the\r
+ likelihood of seeing a confusing situation is somewhat diminished.\r
+ */\r
+ DWORD_PTR affinity, system_affinity;\r
+\r
+ if (GetProcessAffinityMask(service->process_handle, &affinity, &system_affinity)) affinity = service->affinity & system_affinity;\r
+ else {\r
+ affinity = (DWORD_PTR) service->affinity;\r
+ log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_GETPROCESSAFFINITYMASK_FAILED, service->name, error_string(GetLastError()), 0);\r
+ }\r
+\r
+ if (! SetProcessAffinityMask(service->process_handle, affinity)) {\r
+ log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_SETPROCESSAFFINITYMASK_FAILED, service->name, error_string(GetLastError()), 0);\r
+ }\r
+\r
+ ResumeThread(pi.hThread);\r
+ }\r
+\r
/*\r
Wait for a clean startup before changing the service status to RUNNING\r
but be mindful of the fact that we are blocking the service control manager\r
so abandon the wait before too much time has elapsed.\r
*/\r
- unsigned long delay = service->throttle_delay;\r
- if (delay > NSSM_SERVICE_STATUS_DEADLINE) {\r
- TCHAR delay_milliseconds[16];\r
- _sntprintf_s(delay_milliseconds, _countof(delay_milliseconds), _TRUNCATE, _T("%lu"), delay);\r
- TCHAR deadline_milliseconds[16];\r
- _sntprintf_s(deadline_milliseconds, _countof(deadline_milliseconds), _TRUNCATE, _T("%lu"), NSSM_SERVICE_STATUS_DEADLINE);\r
- log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_STARTUP_DELAY_TOO_LONG, service->name, delay_milliseconds, NSSM, deadline_milliseconds, 0);\r
- delay = NSSM_SERVICE_STATUS_DEADLINE;\r
- }\r
- unsigned long deadline = WaitForSingleObject(service->process_handle, delay);\r
+ service->status.dwCurrentState = SERVICE_START_PENDING;\r
+ if (await_single_handle(service->status_handle, &service->status, service->process_handle, service->name, _T("start_service"), service->throttle_delay) == 1) service->throttle = 0;\r
\r
/* Signal successful start */\r
service->status.dwCurrentState = SERVICE_RUNNING;\r
else service->throttle = 0;\r
}\r
\r
+ /* Ensure the restart delay is always applied. */\r
+ if (service->restart_delay && ! service->throttle) service->throttle++;\r
+\r
return 0;\r
}\r
\r
service->wait_handle = 0;\r
}\r
\r
+ service->rotate_stdout_online = service->rotate_stderr_online = NSSM_ROTATE_OFFLINE;\r
+\r
if (default_action && ! exitcode && ! graceful) {\r
- log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_GRACEFUL_SUICIDE, service->name, service->exe, exit_action_strings[NSSM_EXIT_UNCLEAN], exit_action_strings[NSSM_EXIT_UNCLEAN], exit_action_strings[NSSM_EXIT_UNCLEAN], exit_action_strings[NSSM_EXIT_REALLY] ,0);\r
+ log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_GRACEFUL_SUICIDE, service->name, service->exe, exit_action_strings[NSSM_EXIT_UNCLEAN], exit_action_strings[NSSM_EXIT_UNCLEAN], exit_action_strings[NSSM_EXIT_UNCLEAN], exit_action_strings[NSSM_EXIT_REALLY], 0);\r
graceful = true;\r
}\r
\r
if (service->pid) {\r
/* Shut down service */\r
log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_TERMINATEPROCESS, service->name, service->exe, 0);\r
- kill_process(service, service->process_handle, service->pid, 0);\r
+ kill_t k;\r
+ service_kill_t(service, &k);\r
+ k.exitcode = 0;\r
+ kill_process(&k);\r
}\r
else log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_PROCESS_ALREADY_STOPPED, service->name, service->exe, 0);\r
\r
\r
service->stopping = true;\r
\r
+ service->rotate_stdout_online = service->rotate_stderr_online = NSSM_ROTATE_OFFLINE;\r
+\r
+ /* Use now as a dummy exit time. */\r
+ GetSystemTimeAsFileTime(&service->exit_time);\r
+\r
/* Check exit code */\r
unsigned long exitcode = 0;\r
TCHAR code[16];\r
- GetExitCodeProcess(service->process_handle, &exitcode);\r
- if (exitcode == STILL_ACTIVE || get_process_exit_time(service->process_handle, &service->exit_time)) GetSystemTimeAsFileTime(&service->exit_time);\r
- CloseHandle(service->process_handle);\r
+ if (service->process_handle) {\r
+ GetExitCodeProcess(service->process_handle, &exitcode);\r
+ /* Check real exit time. */\r
+ if (exitcode != STILL_ACTIVE) get_process_exit_time(service->process_handle, &service->exit_time);\r
+ CloseHandle(service->process_handle);\r
+ }\r
\r
service->process_handle = 0;\r
- service->pid = 0;\r
\r
/*\r
Log that the service ended BEFORE logging about killing the process\r
\r
/* Clean up. */\r
if (exitcode == STILL_ACTIVE) exitcode = 0;\r
- kill_process_tree(service, service->pid, exitcode, service->pid);\r
+ if (service->pid && service->kill_process_tree) {\r
+ kill_t k;\r
+ service_kill_t(service, &k);\r
+ kill_process_tree(&k, service->pid);\r
+ }\r
+ service->pid = 0;\r
\r
/*\r
The why argument is true if our wait timed out or false otherwise.\r
/* This can't be a restart if the service is already running. */\r
if (! service->throttle++) return;\r
\r
- int ms = throttle_milliseconds(service->throttle);\r
+ unsigned long ms;\r
+ unsigned long throttle_ms = throttle_milliseconds(service->throttle);\r
+ TCHAR threshold[8], milliseconds[8];\r
+\r
+ if (service->restart_delay > throttle_ms) ms = service->restart_delay;\r
+ else ms = throttle_ms;\r
\r
if (service->throttle > 7) service->throttle = 8;\r
\r
- TCHAR threshold[8], milliseconds[8];\r
- _sntprintf_s(threshold, _countof(threshold), _TRUNCATE, _T("%lu"), service->throttle_delay);\r
_sntprintf_s(milliseconds, _countof(milliseconds), _TRUNCATE, _T("%lu"), ms);\r
- log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_THROTTLED, service->name, threshold, milliseconds, 0);\r
+\r
+ if (service->throttle == 1 && service->restart_delay > throttle_ms) log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_RESTART_DELAY, service->name, milliseconds, 0);\r
+ else {\r
+ _sntprintf_s(threshold, _countof(threshold), _TRUNCATE, _T("%lu"), service->throttle_delay);\r
+ log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_THROTTLED, service->name, threshold, milliseconds, 0);\r
+ }\r
\r
if (use_critical_section) EnterCriticalSection(&service->throttle_section);\r
else if (service->throttle_timer) {\r
\r
Only doing both these things will prevent the system from killing the service.\r
\r
+ If the status_handle and service_status arguments are omitted, this function\r
+ will not try to update the service manager but it will still log to the\r
+ event log that it is waiting for a handle.\r
+\r
Returns: 1 if the wait timed out.\r
0 if the wait completed.\r
-1 on error.\r
*/\r
-int await_shutdown(nssm_service_t *service, TCHAR *function_name, unsigned long timeout) {\r
+int await_single_handle(SERVICE_STATUS_HANDLE status_handle, SERVICE_STATUS *status, HANDLE handle, TCHAR *name, TCHAR *function_name, unsigned long timeout) {\r
unsigned long interval;\r
- unsigned long waithint;\r
unsigned long ret;\r
unsigned long waited;\r
TCHAR interval_milliseconds[16];\r
\r
_sntprintf_s(timeout_milliseconds, _countof(timeout_milliseconds), _TRUNCATE, _T("%lu"), timeout);\r
\r
- waithint = service->status.dwWaitHint;\r
waited = 0;\r
while (waited < timeout) {\r
interval = timeout - waited;\r
if (interval > NSSM_SERVICE_STATUS_DEADLINE) interval = NSSM_SERVICE_STATUS_DEADLINE;\r
\r
- service->status.dwCurrentState = SERVICE_STOP_PENDING;\r
- service->status.dwWaitHint += interval;\r
- service->status.dwCheckPoint++;\r
- SetServiceStatus(service->status_handle, &service->status);\r
+ if (status) {\r
+ status->dwWaitHint += interval;\r
+ status->dwCheckPoint++;\r
+ SetServiceStatus(status_handle, status);\r
+ }\r
\r
if (waited) {\r
_sntprintf_s(waited_milliseconds, _countof(waited_milliseconds), _TRUNCATE, _T("%lu"), waited);\r
_sntprintf_s(interval_milliseconds, _countof(interval_milliseconds), _TRUNCATE, _T("%lu"), interval);\r
- log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_AWAITING_SHUTDOWN, function, service->name, waited_milliseconds, interval_milliseconds, timeout_milliseconds, 0);\r
+ log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_AWAITING_SINGLE_HANDLE, function, name, waited_milliseconds, interval_milliseconds, timeout_milliseconds, 0);\r
}\r
\r
- switch (WaitForSingleObject(service->process_handle, interval)) {\r
+ switch (WaitForSingleObject(handle, interval)) {\r
case WAIT_OBJECT_0:\r
ret = 0;\r
goto awaited;\r
\r
case WAIT_TIMEOUT:\r
ret = 1;\r
- break;\r
+ break;\r
\r
default:\r
ret = -1;\r
git://git.iain.cx/iain / nssm.git / blobdiff