X-Git-Url: http://git.iain.cx/?a=blobdiff_plain;f=service.cpp;h=ee60c1072fa7f0cd36712db4489f9bf09f9270ed;hb=eac4d7eedfe338703f0103aac01af2ca306f615a;hp=dffd7aa000b7f907790da095f0cb0c436f9812bc;hpb=fce252d07bdf443e3b283c26a940d3b0f26fd440;p=nssm.git diff --git a/service.cpp b/service.cpp index dffd7aa..ee60c10 100644 --- a/service.cpp +++ b/service.cpp @@ -1,16 +1,249 @@ #include "nssm.h" +/* This is explicitly a wide string. */ +#define NSSM_LOGON_AS_SERVICE_RIGHT L"SeServiceLogonRight" + bool is_admin; bool use_critical_section; extern imports_t imports; +extern settings_t settings[]; + +const TCHAR *exit_action_strings[] = { _T("Restart"), _T("Ignore"), _T("Exit"), _T("Suicide"), 0 }; +const TCHAR *startup_strings[] = { _T("SERVICE_AUTO_START"), _T("SERVICE_DELAYED_AUTO_START"), _T("SERVICE_DEMAND_START"), _T("SERVICE_DISABLED"), 0 }; +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 }; + +typedef struct { + int first; + int last; +} list_t; + +/* + Check the status in response to a control. + Returns: 1 if the status is expected, eg STOP following CONTROL_STOP. + 0 if the status is desired, eg STOPPED following CONTROL_STOP. + -1 if the status is undesired, eg STOPPED following CONTROL_START. +*/ +static inline int service_control_response(unsigned long control, unsigned long status) { + switch (control) { + case NSSM_SERVICE_CONTROL_START: + switch (status) { + case SERVICE_START_PENDING: + return 1; + + case SERVICE_RUNNING: + return 0; + + default: + return -1; + } + + case SERVICE_CONTROL_STOP: + case SERVICE_CONTROL_SHUTDOWN: + switch (status) { + case SERVICE_STOP_PENDING: + return 1; + + case SERVICE_STOPPED: + return 0; + + default: + return -1; + } + + case SERVICE_CONTROL_PAUSE: + switch (status) { + case SERVICE_PAUSE_PENDING: + return 1; + + case SERVICE_PAUSED: + return 0; + + default: + return -1; + } + + case SERVICE_CONTROL_CONTINUE: + switch (status) { + case SERVICE_CONTINUE_PENDING: + return 1; + + case SERVICE_RUNNING: + return 0; + + default: + return -1; + } -static enum { NSSM_EXIT_RESTART, NSSM_EXIT_IGNORE, NSSM_EXIT_REALLY, NSSM_EXIT_UNCLEAN } exit_actions; -static const char *exit_action_strings[] = { "Restart", "Ignore", "Exit", "Suicide", 0 }; + case SERVICE_CONTROL_INTERROGATE: + return 0; + } + + return 0; +} + +static inline int await_service_control_response(unsigned long control, SC_HANDLE service_handle, SERVICE_STATUS *service_status, unsigned long initial_status) { + int tries = 0; + while (QueryServiceStatus(service_handle, service_status)) { + int response = service_control_response(control, service_status->dwCurrentState); + /* Alas we can't WaitForSingleObject() on an SC_HANDLE. */ + if (! response) return response; + if (response > 0 || service_status->dwCurrentState == initial_status) { + if (++tries > 10) return response; + Sleep(50 * tries); + } + else return response; + } + return -1; +} + +int affinity_mask_to_string(__int64 mask, TCHAR **string) { + if (! string) return 1; + if (! mask) { + *string = 0; + return 0; + } + + __int64 i, n; + + /* SetProcessAffinityMask() accepts a mask of up to 64 processors. */ + list_t set[64]; + for (n = 0; n < _countof(set); n++) set[n].first = set[n].last = -1; + + for (i = 0, n = 0; i < _countof(set); i++) { + if (mask & (1LL << i)) { + if (set[n].first == -1) set[n].first = set[n].last = (int) i; + else if (set[n].last == (int) i - 1) set[n].last = (int) i; + else { + n++; + set[n].first = set[n].last = (int) i; + } + } + } + + /* Worst case is 2x2 characters for first and last CPU plus - and/or , */ + size_t len = (size_t) (n + 1) * 6; + *string = (TCHAR *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(TCHAR)); + if (! string) return 2; + + size_t s = 0; + int ret; + for (i = 0; i <= n; i++) { + if (i) (*string)[s++] = _T(','); + ret = _sntprintf_s(*string + s, 3, _TRUNCATE, _T("%u"), set[i].first); + if (ret < 0) { + HeapFree(GetProcessHeap(), 0, *string); + *string = 0; + return 3; + } + else s += ret; + if (set[i].last != set[i].first) { + ret =_sntprintf_s(*string + s, 4, _TRUNCATE, _T("%c%u"), (set[i].last == set[i].first + 1) ? _T(',') : _T('-'), set[i].last); + if (ret < 0) { + HeapFree(GetProcessHeap(), 0, *string); + *string = 0; + return 4; + } + else s += ret; + } + } -static inline int throttle_milliseconds(unsigned long throttle) { + return 0; +} + +int affinity_string_to_mask(TCHAR *string, __int64 *mask) { + if (! mask) return 1; + + *mask = 0LL; + if (! string) return 0; + + list_t set[64]; + + TCHAR *s = string; + TCHAR *end; + int ret; + int i; + int n = 0; + unsigned long number; + + for (n = 0; n < _countof(set); n++) set[n].first = set[n].last = -1; + n = 0; + + while (*s) { + ret = str_number(s, &number, &end); + s = end; + if (ret == 0 || ret == 2) { + if (number >= _countof(set)) return 2; + set[n].first = set[n].last = (int) number; + + switch (*s) { + case 0: + break; + + case _T(','): + n++; + s++; + break; + + case _T('-'): + if (! *(++s)) return 3; + ret = str_number(s, &number, &end); + if (ret == 0 || ret == 2) { + s = end; + if (! *s || *s == _T(',')) { + set[n].last = (int) number; + if (! *s) break; + n++; + s++; + } + else return 3; + } + else return 3; + break; + + default: + return 3; + } + } + else return 4; + } + + for (i = 0; i <= n; i++) { + for (int j = set[i].first; j <= set[i].last; j++) (__int64) *mask |= (1LL << (__int64) j); + } + + return 0; +} + +inline unsigned long priority_mask() { + return REALTIME_PRIORITY_CLASS | HIGH_PRIORITY_CLASS | ABOVE_NORMAL_PRIORITY_CLASS | NORMAL_PRIORITY_CLASS | BELOW_NORMAL_PRIORITY_CLASS | IDLE_PRIORITY_CLASS; +} + +int priority_constant_to_index(unsigned long constant) { + switch (constant & priority_mask()) { + case REALTIME_PRIORITY_CLASS: return NSSM_REALTIME_PRIORITY; + case HIGH_PRIORITY_CLASS: return NSSM_HIGH_PRIORITY; + case ABOVE_NORMAL_PRIORITY_CLASS: return NSSM_ABOVE_NORMAL_PRIORITY; + case BELOW_NORMAL_PRIORITY_CLASS: return NSSM_BELOW_NORMAL_PRIORITY; + case IDLE_PRIORITY_CLASS: return NSSM_IDLE_PRIORITY; + } + return NSSM_NORMAL_PRIORITY; +} + +unsigned long priority_index_to_constant(int index) { + switch (index) { + case NSSM_REALTIME_PRIORITY: return REALTIME_PRIORITY_CLASS; + case NSSM_HIGH_PRIORITY: return HIGH_PRIORITY_CLASS; + case NSSM_ABOVE_NORMAL_PRIORITY: return ABOVE_NORMAL_PRIORITY_CLASS; + case NSSM_BELOW_NORMAL_PRIORITY: return BELOW_NORMAL_PRIORITY_CLASS; + case NSSM_IDLE_PRIORITY: return IDLE_PRIORITY_CLASS; + } + return NORMAL_PRIORITY_CLASS; +} + +static inline unsigned long throttle_milliseconds(unsigned long throttle) { /* pow() operates on doubles. */ - int ret = 1; for (unsigned long i = 1; i < throttle; i++) ret *= 2; + unsigned long ret = 1; for (unsigned long i = 1; i < throttle; i++) ret *= 2; return ret * 1000; } @@ -33,77 +266,735 @@ SC_HANDLE open_service_manager() { return ret; } +/* Open a service by name or display name. */ +SC_HANDLE open_service(SC_HANDLE services, TCHAR *service_name, TCHAR *canonical_name, unsigned long canonical_namelen) { + SC_HANDLE service_handle = OpenService(services, service_name, SERVICE_ALL_ACCESS); + if (service_handle) { + if (canonical_name && canonical_name != service_name) { + if (_sntprintf_s(canonical_name, canonical_namelen, _TRUNCATE, _T("%s"), service_name) < 0) { + print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("canonical_name"), _T("open_service()")); + return 0; + } + } + return service_handle; + } + + unsigned long error = GetLastError(); + if (error != ERROR_SERVICE_DOES_NOT_EXIST) { + print_message(stderr, NSSM_MESSAGE_OPENSERVICE_FAILED, error_string(GetLastError())); + return 0; + } + + /* We can't look for a display name because there's no buffer to store it. */ + if (! canonical_name) { + print_message(stderr, NSSM_MESSAGE_OPENSERVICE_FAILED, error_string(GetLastError())); + return 0; + } + + unsigned long bufsize, required, count, i; + unsigned long resume = 0; + EnumServicesStatus(services, SERVICE_DRIVER | SERVICE_FILE_SYSTEM_DRIVER | SERVICE_KERNEL_DRIVER | SERVICE_WIN32, SERVICE_STATE_ALL, 0, 0, &required, &count, &resume); + error = GetLastError(); + if (error != ERROR_MORE_DATA) { + print_message(stderr, NSSM_MESSAGE_ENUMSERVICESSTATUS_FAILED, error_string(GetLastError())); + return 0; + } + + ENUM_SERVICE_STATUS *status = (ENUM_SERVICE_STATUS *) HeapAlloc(GetProcessHeap(), 0, required); + if (! status) { + print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("ENUM_SERVICE_STATUS"), _T("open_service()")); + return 0; + } + + bufsize = required; + while (true) { + /* + EnumServicesStatus() returns: + 1 when it retrieved data and there's no more data to come. + 0 and sets last error to ERROR_MORE_DATA when it retrieved data and + there's more data to come. + 0 and sets last error to something else on error. + */ + int ret = EnumServicesStatus(services, SERVICE_DRIVER | SERVICE_FILE_SYSTEM_DRIVER | SERVICE_KERNEL_DRIVER | SERVICE_WIN32, SERVICE_STATE_ALL, status, bufsize, &required, &count, &resume); + if (! ret) { + error = GetLastError(); + if (error != ERROR_MORE_DATA) { + HeapFree(GetProcessHeap(), 0, status); + print_message(stderr, NSSM_MESSAGE_ENUMSERVICESSTATUS_FAILED, error_string(GetLastError())); + return 0; + } + } + + for (i = 0; i < count; i++) { + if (str_equiv(status[i].lpDisplayName, service_name)) { + if (_sntprintf_s(canonical_name, canonical_namelen, _TRUNCATE, _T("%s"), status[i].lpServiceName) < 0) { + HeapFree(GetProcessHeap(), 0, status); + print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("canonical_name"), _T("open_service()")); + return 0; + } + + HeapFree(GetProcessHeap(), 0, status); + return open_service(services, canonical_name, 0, 0); + } + } + + if (ret) break; + } + + /* Recurse so we can get an error message. */ + return open_service(services, service_name, 0, 0); +} + +QUERY_SERVICE_CONFIG *query_service_config(const TCHAR *service_name, SC_HANDLE service_handle) { + QUERY_SERVICE_CONFIG *qsc; + unsigned long bufsize; + unsigned long error; + + QueryServiceConfig(service_handle, 0, 0, &bufsize); + error = GetLastError(); + if (error == ERROR_INSUFFICIENT_BUFFER) { + qsc = (QUERY_SERVICE_CONFIG *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, bufsize); + if (! qsc) { + print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("QUERY_SERVICE_CONFIG"), _T("query_service_config()"), 0); + return 0; + } + } + else { + print_message(stderr, NSSM_MESSAGE_QUERYSERVICECONFIG_FAILED, service_name, error_string(error), 0); + return 0; + } + + if (! QueryServiceConfig(service_handle, qsc, bufsize, &bufsize)) { + HeapFree(GetProcessHeap(), 0, qsc); + print_message(stderr, NSSM_MESSAGE_QUERYSERVICECONFIG_FAILED, service_name, error_string(GetLastError()), 0); + return 0; + } + + return qsc; +} + +int set_service_description(const TCHAR *service_name, SC_HANDLE service_handle, TCHAR *buffer) { + SERVICE_DESCRIPTION description; + ZeroMemory(&description, sizeof(description)); + /* + lpDescription must be NULL if we aren't changing, the new description + or "". + */ + if (buffer && buffer[0]) description.lpDescription = buffer; + else description.lpDescription = _T(""); + + if (ChangeServiceConfig2(service_handle, SERVICE_CONFIG_DESCRIPTION, &description)) return 0; + + log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_SERVICE_CONFIG_DESCRIPTION_FAILED, service_name, error_string(GetLastError()), 0); + return 1; +} + +int get_service_description(const TCHAR *service_name, SC_HANDLE service_handle, unsigned long len, TCHAR *buffer) { + if (! buffer) return 1; + + unsigned long bufsize; + QueryServiceConfig2(service_handle, SERVICE_CONFIG_DESCRIPTION, 0, 0, &bufsize); + unsigned long error = GetLastError(); + if (error == ERROR_INSUFFICIENT_BUFFER) { + SERVICE_DESCRIPTION *description = (SERVICE_DESCRIPTION *) HeapAlloc(GetProcessHeap(), 0, bufsize); + if (! description) { + print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("SERVICE_CONFIG_DESCRIPTION"), _T("get_service_description()")); + return 2; + } + + if (QueryServiceConfig2(service_handle, SERVICE_CONFIG_DESCRIPTION, (unsigned char *) description, bufsize, &bufsize)) { + if (description->lpDescription) _sntprintf_s(buffer, len, _TRUNCATE, _T("%s"), description->lpDescription); + else ZeroMemory(buffer, len * sizeof(TCHAR)); + HeapFree(GetProcessHeap(), 0, description); + return 0; + } + else { + HeapFree(GetProcessHeap(), 0, description); + print_message(stderr, NSSM_MESSAGE_QUERYSERVICECONFIG2_FAILED, service_name, _T("SERVICE_CONFIG_DESCRIPTION"), error_string(error)); + return 3; + } + } + else { + print_message(stderr, NSSM_MESSAGE_QUERYSERVICECONFIG2_FAILED, service_name, _T("SERVICE_CONFIG_DESCRIPTION"), error_string(error)); + return 4; + } + + return 0; +} + +int get_service_startup(const TCHAR *service_name, SC_HANDLE service_handle, const QUERY_SERVICE_CONFIG *qsc, unsigned long *startup) { + if (! qsc) return 1; + + switch (qsc->dwStartType) { + case SERVICE_DEMAND_START: *startup = NSSM_STARTUP_MANUAL; break; + case SERVICE_DISABLED: *startup = NSSM_STARTUP_DISABLED; break; + default: *startup = NSSM_STARTUP_AUTOMATIC; + } + + if (*startup != NSSM_STARTUP_AUTOMATIC) return 0; + + /* Check for delayed start. */ + unsigned long bufsize; + unsigned long error; + QueryServiceConfig2(service_handle, SERVICE_CONFIG_DELAYED_AUTO_START_INFO, 0, 0, &bufsize); + error = GetLastError(); + if (error == ERROR_INSUFFICIENT_BUFFER) { + SERVICE_DELAYED_AUTO_START_INFO *info = (SERVICE_DELAYED_AUTO_START_INFO *) HeapAlloc(GetProcessHeap(), 0, bufsize); + if (! info) { + print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("SERVICE_DELAYED_AUTO_START_INFO"), _T("get_service_startup()")); + return 2; + } + + if (QueryServiceConfig2(service_handle, SERVICE_CONFIG_DELAYED_AUTO_START_INFO, (unsigned char *) info, bufsize, &bufsize)) { + if (info->fDelayedAutostart) *startup = NSSM_STARTUP_DELAYED; + HeapFree(GetProcessHeap(), 0, info); + return 0; + } + else { + error = GetLastError(); + if (error != ERROR_INVALID_LEVEL) { + print_message(stderr, NSSM_MESSAGE_QUERYSERVICECONFIG2_FAILED, service_name, _T("SERVICE_CONFIG_DELAYED_AUTO_START_INFO"), error_string(error)); + return 3; + } + } + } + else if (error != ERROR_INVALID_LEVEL) { + print_message(stderr, NSSM_MESSAGE_QUERYSERVICECONFIG2_FAILED, service_name, _T("SERVICE_DELAYED_AUTO_START_INFO"), error_string(error)); + return 3; + } + + return 0; +} + +int get_service_username(const TCHAR *service_name, const QUERY_SERVICE_CONFIG *qsc, TCHAR **username, size_t *usernamelen) { + if (! username) return 1; + if (! usernamelen) return 1; + + *username = 0; + *usernamelen = 0; + + if (! qsc) return 1; + + if (str_equiv(qsc->lpServiceStartName, NSSM_LOCALSYSTEM_ACCOUNT)) return 0; + + size_t len = _tcslen(qsc->lpServiceStartName); + *username = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(TCHAR)); + if (! *username) { + print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("username"), _T("get_service_username()")); + return 2; + } + + memmove(*username, qsc->lpServiceStartName, (len + 1) * sizeof(TCHAR)); + *usernamelen = len; + + return 0; +} + +int grant_logon_as_service(const TCHAR *username) { + if (! username) return 0; + if (str_equiv(username, NSSM_LOCALSYSTEM_ACCOUNT)) return 0; + + /* Open Policy object. */ + LSA_OBJECT_ATTRIBUTES attributes; + ZeroMemory(&attributes, sizeof(attributes)); + + LSA_HANDLE policy; + + NTSTATUS status = LsaOpenPolicy(0, &attributes, POLICY_ALL_ACCESS, &policy); + if (status) { + print_message(stderr, NSSM_MESSAGE_LSAOPENPOLICY_FAILED, error_string(LsaNtStatusToWinError(status))); + return 1; + } + + /* Look up SID for the account. */ + LSA_UNICODE_STRING lsa_username; +#ifdef UNICODE + lsa_username.Buffer = (wchar_t *) username; + lsa_username.Length = (unsigned short) _tcslen(username) * sizeof(TCHAR); + lsa_username.MaximumLength = lsa_username.Length + sizeof(TCHAR); +#else + size_t buflen; + mbstowcs_s(&buflen, NULL, 0, username, _TRUNCATE); + lsa_username.MaximumLength = (unsigned short) buflen * sizeof(wchar_t); + lsa_username.Length = lsa_username.MaximumLength - sizeof(wchar_t); + lsa_username.Buffer = (wchar_t *) HeapAlloc(GetProcessHeap(), 0, lsa_username.MaximumLength); + if (lsa_username.Buffer) mbstowcs_s(&buflen, lsa_username.Buffer, lsa_username.MaximumLength, username, _TRUNCATE); + else { + LsaClose(policy); + print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("LSA_UNICODE_STRING"), _T("grant_logon_as_service()")); + return 2; + } +#endif + + LSA_REFERENCED_DOMAIN_LIST *translated_domains; + LSA_TRANSLATED_SID *translated_sid; + status = LsaLookupNames(policy, 1, &lsa_username, &translated_domains, &translated_sid); +#ifndef UNICODE + HeapFree(GetProcessHeap(), 0, lsa_username.Buffer); +#endif + if (status) { + LsaFreeMemory(translated_domains); + LsaFreeMemory(translated_sid); + LsaClose(policy); + print_message(stderr, NSSM_MESSAGE_LSALOOKUPNAMES_FAILED, username, error_string(LsaNtStatusToWinError(status))); + return 3; + } + + if (translated_sid->Use != SidTypeUser) { + LsaFreeMemory(translated_domains); + LsaFreeMemory(translated_sid); + LsaClose(policy); + print_message(stderr, NSSM_GUI_INVALID_USERNAME, username); + return 4; + } + + LSA_TRUST_INFORMATION *trust = &translated_domains->Domains[translated_sid->DomainIndex]; + if (! trust || ! IsValidSid(trust->Sid)) { + LsaFreeMemory(translated_domains); + LsaFreeMemory(translated_sid); + LsaClose(policy); + print_message(stderr, NSSM_GUI_INVALID_USERNAME, username); + return 4; + } + + /* GetSidSubAuthority*() return pointers! */ + unsigned char *n = GetSidSubAuthorityCount(trust->Sid); + + /* Convert translated SID to SID. */ + SID *sid = (SID *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, GetSidLengthRequired(*n + 1)); + if (! sid) { + LsaFreeMemory(translated_domains); + LsaFreeMemory(translated_sid); + LsaClose(policy); + print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("SID"), _T("grant_logon_as_service")); + return 4; + } + + unsigned long error; + if (! InitializeSid(sid, GetSidIdentifierAuthority(trust->Sid), *n + 1)) { + error = GetLastError(); + HeapFree(GetProcessHeap(), 0, sid); + LsaFreeMemory(translated_domains); + LsaFreeMemory(translated_sid); + LsaClose(policy); + print_message(stderr, NSSM_MESSAGE_INITIALIZESID_FAILED, username, error_string(error)); + return 5; + } + + for (unsigned char i = 0; i <= *n; i++) { + unsigned long *sub = GetSidSubAuthority(sid, i); + if (i < *n) *sub = *GetSidSubAuthority(trust->Sid, i); + else *sub = translated_sid->RelativeId; + } + + LsaFreeMemory(translated_domains); + LsaFreeMemory(translated_sid); + + /* Check if the SID has the "Log on as a service" right. */ + LSA_UNICODE_STRING lsa_right; + lsa_right.Buffer = NSSM_LOGON_AS_SERVICE_RIGHT; + lsa_right.Length = (unsigned short) wcslen(lsa_right.Buffer) * sizeof(wchar_t); + lsa_right.MaximumLength = lsa_right.Length + sizeof(wchar_t); + + LSA_UNICODE_STRING *rights; + unsigned long count = ~0; + status = LsaEnumerateAccountRights(policy, sid, &rights, &count); + if (status) { + /* + If the account has no rights set LsaEnumerateAccountRights() will return + STATUS_OBJECT_NAME_NOT_FOUND and set count to 0. + */ + error = LsaNtStatusToWinError(status); + if (error != ERROR_FILE_NOT_FOUND) { + HeapFree(GetProcessHeap(), 0, sid); + LsaClose(policy); + print_message(stderr, NSSM_MESSAGE_LSAENUMERATEACCOUNTRIGHTS_FAILED, username, error_string(error)); + return 4; + } + } + + for (unsigned long i = 0; i < count; i++) { + if (rights[i].Length != lsa_right.Length) continue; + if (_wcsnicmp(rights[i].Buffer, lsa_right.Buffer, lsa_right.MaximumLength)) continue; + /* The SID has the right. */ + HeapFree(GetProcessHeap(), 0, sid); + LsaFreeMemory(rights); + LsaClose(policy); + return 0; + } + LsaFreeMemory(rights); + + /* Add the right. */ + status = LsaAddAccountRights(policy, sid, &lsa_right, 1); + HeapFree(GetProcessHeap(), 0, sid); + LsaClose(policy); + if (status) { + print_message(stderr, NSSM_MESSAGE_LSAADDACCOUNTRIGHTS_FAILED, error_string(LsaNtStatusToWinError(status))); + return 5; + } + + print_message(stdout, NSSM_MESSAGE_GRANTED_LOGON_AS_SERVICE, username); + return 0; +} + +/* Set default values which aren't zero. */ +void set_nssm_service_defaults(nssm_service_t *service) { + if (! service) return; + + service->type = SERVICE_WIN32_OWN_PROCESS; + service->priority = NORMAL_PRIORITY_CLASS; + service->stdin_sharing = NSSM_STDIN_SHARING; + service->stdin_disposition = NSSM_STDIN_DISPOSITION; + service->stdin_flags = NSSM_STDIN_FLAGS; + service->stdout_sharing = NSSM_STDOUT_SHARING; + service->stdout_disposition = NSSM_STDOUT_DISPOSITION; + service->stdout_flags = NSSM_STDOUT_FLAGS; + service->stderr_sharing = NSSM_STDERR_SHARING; + service->stderr_disposition = NSSM_STDERR_DISPOSITION; + service->stderr_flags = NSSM_STDERR_FLAGS; + service->throttle_delay = NSSM_RESET_THROTTLE_RESTART; + service->stop_method = ~0; + service->kill_console_delay = NSSM_KILL_CONSOLE_GRACE_PERIOD; + service->kill_window_delay = NSSM_KILL_WINDOW_GRACE_PERIOD; + service->kill_threads_delay = NSSM_KILL_THREADS_GRACE_PERIOD; +} + /* Allocate and zero memory for a service. */ nssm_service_t *alloc_nssm_service() { nssm_service_t *service = (nssm_service_t *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(nssm_service_t)); - if (! service) log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, "service", "alloc_nssm_service()", 0); + if (! service) log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, _T("service"), _T("alloc_nssm_service()"), 0); return service; } /* Free memory for a service. */ void cleanup_nssm_service(nssm_service_t *service) { if (! service) return; + if (service->username) HeapFree(GetProcessHeap(), 0, service->username); + if (service->password) { + SecureZeroMemory(service->password, service->passwordlen); + HeapFree(GetProcessHeap(), 0, service->password); + } if (service->env) HeapFree(GetProcessHeap(), 0, service->env); + if (service->env_extra) HeapFree(GetProcessHeap(), 0, service->env_extra); if (service->handle) CloseServiceHandle(service->handle); if (service->process_handle) CloseHandle(service->process_handle); if (service->wait_handle) UnregisterWait(service->process_handle); if (service->throttle_section_initialised) DeleteCriticalSection(&service->throttle_section); if (service->throttle_timer) CloseHandle(service->throttle_timer); + if (service->initial_env) FreeEnvironmentStrings(service->initial_env); HeapFree(GetProcessHeap(), 0, service); } /* About to install the service */ -int pre_install_service(int argc, char **argv) { +int pre_install_service(int argc, TCHAR **argv) { + nssm_service_t *service = alloc_nssm_service(); + set_nssm_service_defaults(service); + if (argc) _sntprintf_s(service->name, _countof(service->name), _TRUNCATE, _T("%s"), argv[0]); + /* Show the dialogue box if we didn't give the service name and path */ - if (argc < 2) return nssm_gui(IDD_INSTALL, argv[0]); + if (argc < 2) return nssm_gui(IDD_INSTALL, service); - nssm_service_t *service = alloc_nssm_service(); if (! service) { - print_message(stderr, NSSM_EVENT_OUT_OF_MEMORY, "service", "pre_install_service()"); + print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("service"), _T("pre_install_service()")); return 1; } - - memmove(service->name, argv[0], strlen(argv[0])); - memmove(service->exe, argv[1], strlen(argv[1])); + _sntprintf_s(service->exe, _countof(service->exe), _TRUNCATE, _T("%s"), argv[1]); /* Arguments are optional */ size_t flagslen = 0; size_t s = 0; - size_t i; - for (i = 2; i < argc; i++) flagslen += strlen(argv[i]) + 1; + int i; + for (i = 2; i < argc; i++) flagslen += _tcslen(argv[i]) + 1; if (! flagslen) flagslen = 1; + if (flagslen > _countof(service->flags)) { + print_message(stderr, NSSM_MESSAGE_FLAGS_TOO_LONG); + return 2; + } - /* - This probably isn't UTF8-safe and should use std::string or something - but it's been broken for the best part of a decade and due for a rewrite - anyway so it'll do as a quick-'n'-dirty fix. Note that we don't free - the flags buffer but as the program exits that isn't a big problem. - */ for (i = 2; i < argc; i++) { - size_t len = strlen(argv[i]); - memmove(service->flags + s, argv[i], len); + size_t len = _tcslen(argv[i]); + memmove(service->flags + s, argv[i], len * sizeof(TCHAR)); s += len; - if (i < argc - 1) service->flags[s++] = ' '; + if (i < argc - 1) service->flags[s++] = _T(' '); } /* Work out directory name */ - size_t len = strlen(service->exe); - for (i = len; i && service->exe[i] != '\\' && service->exe[i] != '/'; i--); - memmove(service->dir, service->exe, i); - service->dir[i] = '\0'; + _sntprintf_s(service->dir, _countof(service->dir), _TRUNCATE, _T("%s"), service->exe); + strip_basename(service->dir); int ret = install_service(service); cleanup_nssm_service(service); return ret; } +/* About to edit the service. */ +int pre_edit_service(int argc, TCHAR **argv) { + /* Require service name. */ + if (argc < 2) return usage(1); + + /* Are we editing on the command line? */ + enum { MODE_EDITING, MODE_GETTING, MODE_SETTING, MODE_RESETTING } mode = MODE_EDITING; + const TCHAR *verb = argv[0]; + const TCHAR *service_name = argv[1]; + bool getting = false; + bool unsetting = false; + + /* Minimum number of arguments. */ + int mandatory = 2; + /* Index of first value. */ + int remainder = 3; + int i; + if (str_equiv(verb, _T("get"))) { + mandatory = 3; + mode = MODE_GETTING; + } + else if (str_equiv(verb, _T("set"))) { + mandatory = 4; + mode = MODE_SETTING; + } + else if (str_equiv(verb, _T("reset")) || str_equiv(verb, _T("unset"))) { + mandatory = 3; + mode = MODE_RESETTING; + } + if (argc < mandatory) return usage(1); + + const TCHAR *parameter = 0; + settings_t *setting = 0; + TCHAR *additional; + + /* Validate the parameter. */ + if (mandatory > 2) { + bool additional_mandatory = false; + + parameter = argv[2]; + for (i = 0; settings[i].name; i++) { + setting = &settings[i]; + if (! str_equiv(setting->name, parameter)) continue; + if (((setting->additional & ADDITIONAL_GETTING) && mode == MODE_GETTING) || ((setting->additional & ADDITIONAL_SETTING) && mode == MODE_SETTING) || ((setting->additional & ADDITIONAL_RESETTING) && mode == MODE_RESETTING)) { + additional_mandatory = true; + mandatory++; + } + break; + } + if (! settings[i].name) { + print_message(stderr, NSSM_MESSAGE_INVALID_PARAMETER, parameter); + for (i = 0; settings[i].name; i++) _ftprintf(stderr, _T("%s\n"), settings[i].name); + return 1; + } + + additional = 0; + if (additional_mandatory) { + if (argc < mandatory) { + print_message(stderr, NSSM_MESSAGE_MISSING_SUBPARAMETER, parameter); + return 1; + } + additional = argv[3]; + remainder = 4; + } + else { + additional = argv[remainder]; + if (argc < mandatory) return usage(1); + } + } + + nssm_service_t *service = alloc_nssm_service(); + _sntprintf_s(service->name, _countof(service->name), _TRUNCATE, _T("%s"), service_name); + + /* Open service manager */ + SC_HANDLE services = open_service_manager(); + if (! services) { + print_message(stderr, NSSM_MESSAGE_OPEN_SERVICE_MANAGER_FAILED); + return 2; + } + + /* Try to open the service */ + service->handle = open_service(services, service->name, service->name, _countof(service->name)); + if (! service->handle) { + CloseServiceHandle(services); + return 3; + } + + /* Get system details. */ + QUERY_SERVICE_CONFIG *qsc = query_service_config(service->name, service->handle); + if (! qsc) { + CloseHandle(service->handle); + CloseServiceHandle(services); + return 4; + } + + service->type = qsc->dwServiceType; + if (! (service->type & SERVICE_WIN32_OWN_PROCESS)) { + if (mode != MODE_GETTING) { + HeapFree(GetProcessHeap(), 0, qsc); + CloseHandle(service->handle); + CloseServiceHandle(services); + print_message(stderr, NSSM_MESSAGE_CANNOT_EDIT, service->name, NSSM_WIN32_OWN_PROCESS, 0); + return 3; + } + } + + if (get_service_startup(service->name, service->handle, qsc, &service->startup)) { + if (mode != MODE_GETTING) { + HeapFree(GetProcessHeap(), 0, qsc); + CloseHandle(service->handle); + CloseServiceHandle(services); + return 4; + } + } + + if (get_service_username(service->name, qsc, &service->username, &service->usernamelen)) { + if (mode != MODE_GETTING) { + HeapFree(GetProcessHeap(), 0, qsc); + CloseHandle(service->handle); + CloseServiceHandle(services); + return 5; + } + } + + _sntprintf_s(service->displayname, _countof(service->displayname), _TRUNCATE, _T("%s"), qsc->lpDisplayName); + + /* Get the canonical service name. We open it case insensitively. */ + unsigned long bufsize = _countof(service->name); + GetServiceKeyName(services, service->displayname, service->name, &bufsize); + + /* Remember the executable in case it isn't NSSM. */ + _sntprintf_s(service->image, _countof(service->image), _TRUNCATE, _T("%s"), qsc->lpBinaryPathName); + HeapFree(GetProcessHeap(), 0, qsc); + + /* Get extended system details. */ + if (get_service_description(service->name, service->handle, _countof(service->description), service->description)) { + if (mode != MODE_GETTING) { + CloseHandle(service->handle); + CloseServiceHandle(services); + return 6; + } + } + + /* Get NSSM details. */ + get_parameters(service, 0); + + CloseServiceHandle(services); + + if (! service->exe[0]) { + service->native = true; + if (mode != MODE_GETTING) print_message(stderr, NSSM_MESSAGE_INVALID_SERVICE, service->name, NSSM, service->image); + } + + /* Editing with the GUI. */ + if (mode == MODE_EDITING) { + nssm_gui(IDD_EDIT, service); + return 0; + } + + /* Trying to manage App* parameters for a non-NSSM service. */ + if (! setting->native && service->native) { + CloseHandle(service->handle); + print_message(stderr, NSSM_MESSAGE_NATIVE_PARAMETER, setting->name, NSSM); + return 1; + } + + HKEY key; + value_t value; + int ret; + + if (mode == MODE_GETTING) { + if (! service->native) { + key = open_registry(service->name, KEY_READ); + if (! key) return 4; + } + + if (setting->native) ret = get_setting(service->name, service->handle, setting, &value, additional); + else ret = get_setting(service->name, key, setting, &value, additional); + if (ret < 0) { + CloseHandle(service->handle); + return 5; + } + + switch (setting->type) { + case REG_EXPAND_SZ: + case REG_MULTI_SZ: + case REG_SZ: + _tprintf(_T("%s\n"), value.string ? value.string : _T("")); + HeapFree(GetProcessHeap(), 0, value.string); + break; + + case REG_DWORD: + _tprintf(_T("%u\n"), value.numeric); + break; + } + + if (! service->native) RegCloseKey(key); + CloseHandle(service->handle); + return 0; + } + + /* Build the value. */ + if (mode == MODE_RESETTING) { + /* Unset the parameter. */ + value.string = 0; + } + else { + /* Set the parameter. */ + size_t len = 0; + size_t delimiterlen = (setting->additional & ADDITIONAL_CRLF) ? 2 : 1; + for (i = remainder; i < argc; i++) len += _tcslen(argv[i]) + delimiterlen; + len++; + + value.string = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, len * sizeof(TCHAR)); + if (! value.string) { + print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("value"), _T("edit_service()")); + CloseHandle(service->handle); + return 2; + } + + size_t s = 0; + for (i = remainder; i < argc; i++) { + size_t len = _tcslen(argv[i]); + memmove(value.string + s, argv[i], len * sizeof(TCHAR)); + s += len; + if (i < argc - 1) { + if (setting->additional & ADDITIONAL_CRLF) { + value.string[s++] = _T('\r'); + value.string[s++] = _T('\n'); + } + else value.string[s++] = _T(' '); + } + } + value.string[s] = _T('\0'); + } + + if (! service->native) { + key = open_registry(service->name, KEY_WRITE); + if (! key) { + if (value.string) HeapFree(GetProcessHeap(), 0, value.string); + return 4; + } + } + + if (setting->native) ret = set_setting(service->name, service->handle, setting, &value, additional); + else ret = set_setting(service->name, key, setting, &value, additional); + if (value.string) HeapFree(GetProcessHeap(), 0, value.string); + if (ret < 0) { + if (! service->native) RegCloseKey(key); + CloseHandle(service->handle); + return 6; + } + + if (! service->native) RegCloseKey(key); + CloseHandle(service->handle); + + return 0; +} + /* About to remove the service */ -int pre_remove_service(int argc, char **argv) { +int pre_remove_service(int argc, TCHAR **argv) { + nssm_service_t *service = alloc_nssm_service(); + set_nssm_service_defaults(service); + if (argc) _sntprintf_s(service->name, _countof(service->name), _TRUNCATE, _T("%s"), argv[0]); + /* Show dialogue box if we didn't pass service name and "confirm" */ - if (argc < 2) return nssm_gui(IDD_REMOVE, argv[0]); - if (str_equiv(argv[1], "confirm")) { - nssm_service_t *service = alloc_nssm_service(); - memmove(service->name, argv[0], strlen(argv[0])); + if (argc < 2) return nssm_gui(IDD_REMOVE, service); + if (str_equiv(argv[1], _T("confirm"))) { int ret = remove_service(service); cleanup_nssm_service(service); return ret; @@ -125,39 +1016,22 @@ int install_service(nssm_service_t *service) { } /* Get path of this program */ - char path[MAX_PATH]; - GetModuleFileName(0, path, MAX_PATH); - - /* Construct command */ - char command[CMD_LENGTH]; - size_t pathlen = strlen(path); - if (pathlen + 1 >= VALUE_LENGTH) { - print_message(stderr, NSSM_MESSAGE_PATH_TOO_LONG, NSSM); - return 3; - } - if (_snprintf_s(command, sizeof(command), _TRUNCATE, "\"%s\"", path) < 0) { - print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY_FOR_IMAGEPATH); - return 4; - } + GetModuleFileName(0, service->image, _countof(service->image)); - /* Create the service */ - 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); + /* Create the service - settings will be changed in edit_service() */ + 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); if (! service->handle) { - print_message(stderr, NSSM_MESSAGE_CREATESERVICE_FAILED); + print_message(stderr, NSSM_MESSAGE_CREATESERVICE_FAILED, error_string(GetLastError())); CloseServiceHandle(services); return 5; } - /* Now we need to put the parameters into the registry */ - if (create_parameters(service)) { - print_message(stderr, NSSM_MESSAGE_CREATE_PARAMETERS_FAILED); + if (edit_service(service, false)) { DeleteService(service->handle); CloseServiceHandle(services); return 6; } - set_service_recovery(service); - print_message(stdout, NSSM_MESSAGE_SERVICE_INSTALLED, service->name); /* Cleanup */ @@ -166,6 +1040,189 @@ int install_service(nssm_service_t *service) { return 0; } +/* Edit the service. */ +int edit_service(nssm_service_t *service, bool editing) { + if (! service) return 1; + + /* + The only two valid flags for service type are SERVICE_WIN32_OWN_PROCESS + and SERVICE_INTERACTIVE_PROCESS. + */ + service->type &= SERVICE_INTERACTIVE_PROCESS; + service->type |= SERVICE_WIN32_OWN_PROCESS; + + /* Startup type. */ + unsigned long startup; + switch (service->startup) { + case NSSM_STARTUP_MANUAL: startup = SERVICE_DEMAND_START; break; + case NSSM_STARTUP_DISABLED: startup = SERVICE_DISABLED; break; + default: startup = SERVICE_AUTO_START; + } + + /* Display name. */ + if (! service->displayname[0]) _sntprintf_s(service->displayname, _countof(service->displayname), _TRUNCATE, _T("%s"), service->name); + + /* + Username must be NULL if we aren't changing or an account name. + We must explicitly use LOCALSYSTEM to change it when we are editing. + Password must be NULL if we aren't changing, a password or "". + Empty passwords are valid but we won't allow them in the GUI. + */ + TCHAR *username = 0; + TCHAR *password = 0; + if (service->usernamelen) { + username = service->username; + if (service->passwordlen) password = service->password; + else password = _T(""); + } + else if (editing) username = NSSM_LOCALSYSTEM_ACCOUNT; + + if (grant_logon_as_service(username)) { + print_message(stderr, NSSM_MESSAGE_GRANT_LOGON_AS_SERVICE_FAILED, username); + return 5; + } + + if (! ChangeServiceConfig(service->handle, service->type, startup, SERVICE_NO_CHANGE, 0, 0, 0, 0, username, password, service->displayname)) { + print_message(stderr, NSSM_MESSAGE_CHANGESERVICECONFIG_FAILED, error_string(GetLastError())); + return 5; + } + + if (service->description[0] || editing) { + set_service_description(service->name, service->handle, service->description); + } + + SERVICE_DELAYED_AUTO_START_INFO delayed; + ZeroMemory(&delayed, sizeof(delayed)); + if (service->startup == NSSM_STARTUP_DELAYED) delayed.fDelayedAutostart = 1; + else delayed.fDelayedAutostart = 0; + /* Delayed startup isn't supported until Vista. */ + if (! ChangeServiceConfig2(service->handle, SERVICE_CONFIG_DELAYED_AUTO_START_INFO, &delayed)) { + unsigned long error = GetLastError(); + /* Pre-Vista we expect to fail with ERROR_INVALID_LEVEL */ + if (error != ERROR_INVALID_LEVEL) { + log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_SERVICE_CONFIG_DELAYED_AUTO_START_INFO_FAILED, service->name, error_string(error), 0); + } + } + + /* Don't mess with parameters which aren't ours. */ + if (! service->native) { + /* Now we need to put the parameters into the registry */ + if (create_parameters(service, editing)) { + print_message(stderr, NSSM_MESSAGE_CREATE_PARAMETERS_FAILED); + return 6; + } + + set_service_recovery(service); + } + + return 0; +} + +/* Control a service. */ +int control_service(unsigned long control, int argc, TCHAR **argv) { + if (argc < 1) return usage(1); + TCHAR *service_name = argv[0]; + TCHAR canonical_name[SERVICE_NAME_LENGTH]; + + SC_HANDLE services = open_service_manager(); + if (! services) { + print_message(stderr, NSSM_MESSAGE_OPEN_SERVICE_MANAGER_FAILED); + return 2; + } + + SC_HANDLE service_handle = open_service(services, service_name, canonical_name, _countof(canonical_name)); + if (! service_handle) { + CloseServiceHandle(services); + return 3; + } + + int ret; + unsigned long error; + SERVICE_STATUS service_status; + if (control == NSSM_SERVICE_CONTROL_START) { + unsigned long initial_status = SERVICE_STOPPED; + ret = StartService(service_handle, (unsigned long) argc, (const TCHAR **) argv); + error = GetLastError(); + CloseServiceHandle(services); + + if (error == ERROR_IO_PENDING) { + /* + Older versions of Windows return immediately with ERROR_IO_PENDING + indicate that the operation is still in progress. Newer versions + will return it if there really is a delay. + */ + ret = 1; + error = ERROR_SUCCESS; + } + + if (ret) { + int response = await_service_control_response(control, service_handle, &service_status, initial_status); + CloseHandle(service_handle); + + if (response) { + print_message(stderr, NSSM_MESSAGE_BAD_CONTROL_RESPONSE, canonical_name, service_status_text(service_status.dwCurrentState), service_control_text(control)); + return 1; + } + else _tprintf(_T("%s: %s: %s"), canonical_name, service_control_text(control), error_string(error)); + return 0; + } + else { + CloseHandle(service_handle); + _ftprintf(stderr, _T("%s: %s: %s"), canonical_name, service_control_text(control), error_string(error)); + return 1; + } + } + else if (control == SERVICE_CONTROL_INTERROGATE) { + /* + We could actually send an INTERROGATE control but that won't return + any information if the service is stopped and we don't care about + the extra details it might give us in any case. So we'll fake it. + */ + ret = QueryServiceStatus(service_handle, &service_status); + error = GetLastError(); + + if (ret) { + _tprintf(_T("%s\n"), service_status_text(service_status.dwCurrentState)); + return 0; + } + else { + _ftprintf(stderr, _T("%s: %s\n"), canonical_name, error_string(error)); + return 1; + } + } + else { + ret = ControlService(service_handle, control, &service_status); + unsigned long initial_status = service_status.dwCurrentState; + error = GetLastError(); + CloseServiceHandle(services); + + if (error == ERROR_IO_PENDING) { + ret = 1; + error = ERROR_SUCCESS; + } + + if (ret) { + int response = await_service_control_response(control, service_handle, &service_status, initial_status); + CloseHandle(service_handle); + + if (response) { + print_message(stderr, NSSM_MESSAGE_BAD_CONTROL_RESPONSE, canonical_name, service_status_text(service_status.dwCurrentState), service_control_text(control)); + return 1; + } + else _tprintf(_T("%s: %s: %s"), canonical_name, service_control_text(control), error_string(error)); + return 0; + } + else { + CloseHandle(service_handle); + _ftprintf(stderr, _T("%s: %s: %s"), canonical_name, service_control_text(control), error_string(error)); + if (error == ERROR_SERVICE_NOT_ACTIVE) { + if (control == SERVICE_CONTROL_SHUTDOWN || control == SERVICE_CONTROL_STOP) return 0; + } + return 1; + } + } +} + /* Remove the service */ int remove_service(nssm_service_t *service) { if (! service) return 1; @@ -178,13 +1235,18 @@ int remove_service(nssm_service_t *service) { } /* Try to open the service */ - service->handle = OpenService(services, service->name, SC_MANAGER_ALL_ACCESS); + service->handle = open_service(services, service->name, service->name, _countof(service->name)); if (! service->handle) { - print_message(stderr, NSSM_MESSAGE_OPENSERVICE_FAILED); CloseServiceHandle(services); return 3; } + /* Get the canonical service name. We open it case insensitively. */ + unsigned long bufsize = _countof(service->displayname); + GetServiceDisplayName(services, service->name, service->displayname, &bufsize); + bufsize = _countof(service->name); + GetServiceKeyName(services, service->displayname, service->name, &bufsize); + /* Try to delete the service */ if (! DeleteService(service->handle)) { print_message(stderr, NSSM_MESSAGE_DELETESERVICE_FAILED); @@ -200,12 +1262,12 @@ int remove_service(nssm_service_t *service) { } /* Service initialisation */ -void WINAPI service_main(unsigned long argc, char **argv) { +void WINAPI service_main(unsigned long argc, TCHAR **argv) { nssm_service_t *service = alloc_nssm_service(); if (! service) return; - if (_snprintf_s(service->name, sizeof(service->name), _TRUNCATE, "%s", argv[0]) < 0) { - log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, "service->name", "service_main()", 0); + if (_sntprintf_s(service->name, _countof(service->name), _TRUNCATE, _T("%s"), argv[0]) < 0) { + log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, _T("service->name"), _T("service_main()"), 0); return; } @@ -241,7 +1303,7 @@ void WINAPI service_main(unsigned long argc, char **argv) { if (is_admin) { /* Try to create the exit action parameters; we don't care if it fails */ - create_exit_action(service->name, exit_action_strings[0]); + create_exit_action(service->name, exit_action_strings[0], false); SC_HANDLE services = open_service_manager(); if (services) { @@ -263,6 +1325,9 @@ void WINAPI service_main(unsigned long argc, char **argv) { } } + /* Remember our initial environment. */ + service->initial_env = GetEnvironmentStrings(); + monitor_service(service); } @@ -277,7 +1342,7 @@ void set_service_recovery(nssm_service_t *service) { unsigned long error = GetLastError(); /* Pre-Vista we expect to fail with ERROR_INVALID_LEVEL */ if (error != ERROR_INVALID_LEVEL) { - log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CHANGESERVICECONFIG2_FAILED, service->name, error_string(error), 0); + log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_SERVICE_CONFIG_FAILURE_ACTIONS_FAILED, service->name, error_string(error), 0); } } } @@ -286,8 +1351,8 @@ int monitor_service(nssm_service_t *service) { /* Set service status to started */ int ret = start_service(service); if (ret) { - char code[16]; - _snprintf_s(code, sizeof(code), _TRUNCATE, "%d", ret); + TCHAR code[16]; + _sntprintf_s(code, _countof(code), _TRUNCATE, _T("%d"), ret); log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_START_SERVICE_FAILED, service->exe, service->name, ret, 0); return ret; } @@ -301,32 +1366,46 @@ int monitor_service(nssm_service_t *service) { return 0; } -char *service_control_text(unsigned long control) { +TCHAR *service_control_text(unsigned long control) { switch (control) { /* HACK: there is no SERVICE_CONTROL_START constant */ - case 0: return "START"; - case SERVICE_CONTROL_STOP: return "STOP"; - case SERVICE_CONTROL_SHUTDOWN: return "SHUTDOWN"; - case SERVICE_CONTROL_PAUSE: return "PAUSE"; - case SERVICE_CONTROL_CONTINUE: return "CONTINUE"; - case SERVICE_CONTROL_INTERROGATE: return "INTERROGATE"; + case NSSM_SERVICE_CONTROL_START: return _T("START"); + case SERVICE_CONTROL_STOP: return _T("STOP"); + case SERVICE_CONTROL_SHUTDOWN: return _T("SHUTDOWN"); + case SERVICE_CONTROL_PAUSE: return _T("PAUSE"); + case SERVICE_CONTROL_CONTINUE: return _T("CONTINUE"); + case SERVICE_CONTROL_INTERROGATE: return _T("INTERROGATE"); + case NSSM_SERVICE_CONTROL_ROTATE: return _T("ROTATE"); default: return 0; } } -void log_service_control(char *service_name, unsigned long control, bool handled) { - char *text = service_control_text(control); +TCHAR *service_status_text(unsigned long status) { + switch (status) { + case SERVICE_STOPPED: return _T("SERVICE_STOPPED"); + case SERVICE_START_PENDING: return _T("SERVICE_START_PENDING"); + case SERVICE_STOP_PENDING: return _T("SERVICE_STOP_PENDING"); + case SERVICE_RUNNING: return _T("SERVICE_RUNNING"); + case SERVICE_CONTINUE_PENDING: return _T("SERVICE_CONTINUE_PENDING"); + case SERVICE_PAUSE_PENDING: return _T("SERVICE_PAUSE_PENDING"); + case SERVICE_PAUSED: return _T("SERVICE_PAUSED"); + default: return 0; + } +} + +void log_service_control(TCHAR *service_name, unsigned long control, bool handled) { + TCHAR *text = service_control_text(control); unsigned long event; if (! text) { /* "0x" + 8 x hex + NULL */ - text = (char *) HeapAlloc(GetProcessHeap(), 0, 11); + text = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, 11 * sizeof(TCHAR)); if (! text) { - log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, "control code", "log_service_control()", 0); + log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, _T("control code"), _T("log_service_control()"), 0); return; } - if (_snprintf_s(text, 11, _TRUNCATE, "0x%08x", control) < 0) { - log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, "control code", "log_service_control()", 0); + if (_sntprintf_s(text, 11, _TRUNCATE, _T("0x%08x"), control) < 0) { + log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, _T("control code"), _T("log_service_control()"), 0); HeapFree(GetProcessHeap(), 0, text); return; } @@ -384,7 +1463,8 @@ unsigned long WINAPI service_control_handler(unsigned long control, unsigned lon ZeroMemory(&service->throttle_duetime, sizeof(service->throttle_duetime)); SetWaitableTimer(service->throttle_timer, &service->throttle_duetime, 0, 0, 0, 0); } - service->status.dwCurrentState = SERVICE_CONTINUE_PENDING; + /* We can't continue if the application is running! */ + if (! service->process_handle) service->status.dwCurrentState = SERVICE_CONTINUE_PENDING; service->status.dwWaitHint = throttle_milliseconds(service->throttle) + NSSM_WAITHINT_MARGIN; log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_RESET_THROTTLE, service->name, 0); SetServiceStatus(service->status_handle, &service->status); @@ -397,6 +1477,12 @@ unsigned long WINAPI service_control_handler(unsigned long control, unsigned lon */ log_service_control(service->name, control, false); return ERROR_CALL_NOT_IMPLEMENTED; + + case NSSM_SERVICE_CONTROL_ROTATE: + log_service_control(service->name, control, true); + if (service->rotate_stdout_online == NSSM_ROTATE_ONLINE) service->rotate_stdout_online = NSSM_ROTATE_ONLINE_ASAP; + if (service->rotate_stderr_online == NSSM_ROTATE_ONLINE) service->rotate_stderr_online = NSSM_ROTATE_ONLINE_ASAP; + return NO_ERROR; } /* Unknown control */ @@ -428,23 +1514,31 @@ int start_service(nssm_service_t *service) { } /* Launch executable with arguments */ - char cmd[CMD_LENGTH]; - if (_snprintf_s(cmd, sizeof(cmd), _TRUNCATE, "\"%s\" %s", service->exe, service->flags) < 0) { - log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, "command line", "start_service", 0); + TCHAR cmd[CMD_LENGTH]; + if (_sntprintf_s(cmd, _countof(cmd), _TRUNCATE, _T("\"%s\" %s"), service->exe, service->flags) < 0) { + log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, _T("command line"), _T("start_service"), 0); close_output_handles(&si); return stop_service(service, 2, true, true); } throttle_restart(service); + /* Set the environment. */ + if (service->env) duplicate_environment(service->env); + if (service->env_extra) set_environment_block(service->env_extra); + bool inherit_handles = false; if (si.dwFlags & STARTF_USESTDHANDLES) inherit_handles = true; - if (! CreateProcess(0, cmd, 0, 0, inherit_handles, 0, service->env, service->dir, &si, &pi)) { + unsigned long flags = service->priority & priority_mask(); + if (service->stdin_pipe) flags |= DETACHED_PROCESS; + if (service->affinity) flags |= CREATE_SUSPENDED; + if (! CreateProcess(0, cmd, 0, 0, inherit_handles, flags, 0, service->dir, &si, &pi)) { + unsigned long exitcode = 3; unsigned long error = GetLastError(); - 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); - else log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATEPROCESS_FAILED, service->name, service->exe, error_string(error), 0); + log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATEPROCESS_FAILED, service->name, service->exe, error_string(error), 0); close_output_handles(&si); - return stop_service(service, 3, true, true); + duplicate_environment(service->initial_env); + return stop_service(service, exitcode, true, true); } service->process_handle = pi.hProcess; service->pid = pi.dwProcessId; @@ -453,6 +1547,38 @@ int start_service(nssm_service_t *service) { close_output_handles(&si); + /* Restore our environment. */ + duplicate_environment(service->initial_env); + + if (service->affinity) { + /* + We are explicitly storing service->affinity as a 64-bit unsigned integer + so that we can parse it regardless of whether we're running in 32-bit + or 64-bit mode. The arguments to SetProcessAffinityMask(), however, are + defined as type DWORD_PTR and hence limited to 32 bits on a 32-bit system + (or when running the 32-bit NSSM). + + The result is a lot of seemingly-unnecessary casting throughout the code + and potentially confusion when we actually try to start the service. + Having said that, however, it's unlikely that we're actually going to + run in 32-bit mode on a system which has more than 32 CPUs so the + likelihood of seeing a confusing situation is somewhat diminished. + */ + DWORD_PTR affinity, system_affinity; + + if (GetProcessAffinityMask(service->process_handle, &affinity, &system_affinity)) affinity = service->affinity & system_affinity; + else { + affinity = (DWORD_PTR) service->affinity; + log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_GETPROCESSAFFINITYMASK_FAILED, service->name, error_string(GetLastError()), 0); + } + + if (! SetProcessAffinityMask(service->process_handle, affinity)) { + log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_SETPROCESSAFFINITYMASK_FAILED, service->name, error_string(GetLastError()), 0); + } + + ResumeThread(pi.hThread); + } + /* Wait for a clean startup before changing the service status to RUNNING but be mindful of the fact that we are blocking the service control manager @@ -460,10 +1586,10 @@ int start_service(nssm_service_t *service) { */ unsigned long delay = service->throttle_delay; if (delay > NSSM_SERVICE_STATUS_DEADLINE) { - char delay_milliseconds[16]; - _snprintf_s(delay_milliseconds, sizeof(delay_milliseconds), _TRUNCATE, "%lu", delay); - char deadline_milliseconds[16]; - _snprintf_s(deadline_milliseconds, sizeof(deadline_milliseconds), _TRUNCATE, "%lu", NSSM_SERVICE_STATUS_DEADLINE); + TCHAR delay_milliseconds[16]; + _sntprintf_s(delay_milliseconds, _countof(delay_milliseconds), _TRUNCATE, _T("%lu"), delay); + TCHAR deadline_milliseconds[16]; + _sntprintf_s(deadline_milliseconds, _countof(deadline_milliseconds), _TRUNCATE, _T("%lu"), NSSM_SERVICE_STATUS_DEADLINE); log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_STARTUP_DELAY_TOO_LONG, service->name, delay_milliseconds, NSSM, deadline_milliseconds, 0); delay = NSSM_SERVICE_STATUS_DEADLINE; } @@ -481,6 +1607,9 @@ int start_service(nssm_service_t *service) { else service->throttle = 0; } + /* Ensure the restart delay is always applied. */ + if (service->restart_delay && ! service->throttle) service->throttle++; + return 0; } @@ -491,9 +1620,15 @@ int stop_service(nssm_service_t *service, unsigned long exitcode, bool graceful, UnregisterWait(service->wait_handle); service->wait_handle = 0; } + if (service->stdin_pipe) { + CloseHandle(service->stdin_pipe); + service->stdin_pipe = 0; + } + + service->rotate_stdout_online = service->rotate_stderr_online = NSSM_ROTATE_OFFLINE; if (default_action && ! exitcode && ! graceful) { - 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); + 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); graceful = true; } @@ -539,28 +1674,33 @@ void CALLBACK end_service(void *arg, unsigned char why) { service->stopping = true; + service->rotate_stdout_online = service->rotate_stderr_online = NSSM_ROTATE_OFFLINE; + /* Check exit code */ unsigned long exitcode = 0; - char code[16]; - GetExitCodeProcess(service->process_handle, &exitcode); - if (exitcode == STILL_ACTIVE || get_process_exit_time(service->process_handle, &service->exit_time)) GetSystemTimeAsFileTime(&service->exit_time); - CloseHandle(service->process_handle); + TCHAR code[16]; + if (service->process_handle) { + GetExitCodeProcess(service->process_handle, &exitcode); + if (exitcode == STILL_ACTIVE || get_process_exit_time(service->process_handle, &service->exit_time)) GetSystemTimeAsFileTime(&service->exit_time); + CloseHandle(service->process_handle); + } + else GetSystemTimeAsFileTime(&service->exit_time); service->process_handle = 0; - service->pid = 0; /* Log that the service ended BEFORE logging about killing the process tree. See below for the possible values of the why argument. */ if (! why) { - _snprintf_s(code, sizeof(code), _TRUNCATE, "%lu", exitcode); + _sntprintf_s(code, _countof(code), _TRUNCATE, _T("%lu"), exitcode); log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_ENDED_SERVICE, service->exe, service->name, code, 0); } /* Clean up. */ if (exitcode == STILL_ACTIVE) exitcode = 0; - kill_process_tree(service, service->pid, exitcode, service->pid); + if (service->pid) kill_process_tree(service, service->pid, exitcode, service->pid); + service->pid = 0; /* The why argument is true if our wait timed out or false otherwise. @@ -573,11 +1713,11 @@ void CALLBACK end_service(void *arg, unsigned char why) { /* What action should we take? */ int action = NSSM_EXIT_RESTART; - unsigned char action_string[ACTION_LEN]; + TCHAR action_string[ACTION_LEN]; bool default_action; if (! get_exit_action(service->name, &exitcode, action_string, &default_action)) { for (int i = 0; exit_action_strings[i]; i++) { - if (! _strnicmp((const char *) action_string, exit_action_strings[i], ACTION_LEN)) { + if (! _tcsnicmp((const TCHAR *) action_string, exit_action_strings[i], ACTION_LEN)) { action = i; break; } @@ -620,14 +1760,22 @@ void throttle_restart(nssm_service_t *service) { /* This can't be a restart if the service is already running. */ if (! service->throttle++) return; - int ms = throttle_milliseconds(service->throttle); + unsigned long ms; + unsigned long throttle_ms = throttle_milliseconds(service->throttle); + TCHAR threshold[8], milliseconds[8]; + + if (service->restart_delay > throttle_ms) ms = service->restart_delay; + else ms = throttle_ms; if (service->throttle > 7) service->throttle = 8; - char threshold[8], milliseconds[8]; - _snprintf_s(threshold, sizeof(threshold), _TRUNCATE, "%lu", service->throttle_delay); - _snprintf_s(milliseconds, sizeof(milliseconds), _TRUNCATE, "%lu", ms); - log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_THROTTLED, service->name, threshold, milliseconds, 0); + _sntprintf_s(milliseconds, _countof(milliseconds), _TRUNCATE, _T("%lu"), ms); + + if (service->throttle == 1 && service->restart_delay > throttle_ms) log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_RESTART_DELAY, service->name, milliseconds, 0); + else { + _sntprintf_s(threshold, _countof(threshold), _TRUNCATE, _T("%lu"), service->throttle_delay); + log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_THROTTLED, service->name, threshold, milliseconds, 0); + } if (use_critical_section) EnterCriticalSection(&service->throttle_section); else if (service->throttle_timer) { @@ -677,24 +1825,24 @@ void throttle_restart(nssm_service_t *service) { 0 if the wait completed. -1 on error. */ -int await_shutdown(nssm_service_t *service, char *function_name, unsigned long timeout) { +int await_shutdown(nssm_service_t *service, TCHAR *function_name, unsigned long timeout) { unsigned long interval; unsigned long waithint; unsigned long ret; unsigned long waited; - char interval_milliseconds[16]; - char timeout_milliseconds[16]; - char waited_milliseconds[16]; - char *function = function_name; + TCHAR interval_milliseconds[16]; + TCHAR timeout_milliseconds[16]; + TCHAR waited_milliseconds[16]; + TCHAR *function = function_name; /* Add brackets to function name. */ - size_t funclen = strlen(function_name) + 3; - char *func = (char *) HeapAlloc(GetProcessHeap(), 0, funclen); + size_t funclen = _tcslen(function_name) + 3; + TCHAR *func = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, funclen * sizeof(TCHAR)); if (func) { - if (_snprintf_s(func, funclen, _TRUNCATE, "%s()", function_name) > -1) function = func; + if (_sntprintf_s(func, funclen, _TRUNCATE, _T("%s()"), function_name) > -1) function = func; } - _snprintf_s(timeout_milliseconds, sizeof(timeout_milliseconds), _TRUNCATE, "%lu", timeout); + _sntprintf_s(timeout_milliseconds, _countof(timeout_milliseconds), _TRUNCATE, _T("%lu"), timeout); waithint = service->status.dwWaitHint; waited = 0; @@ -708,8 +1856,8 @@ int await_shutdown(nssm_service_t *service, char *function_name, unsigned long t SetServiceStatus(service->status_handle, &service->status); if (waited) { - _snprintf_s(waited_milliseconds, sizeof(waited_milliseconds), _TRUNCATE, "%lu", waited); - _snprintf_s(interval_milliseconds, sizeof(interval_milliseconds), _TRUNCATE, "%lu", interval); + _sntprintf_s(waited_milliseconds, _countof(waited_milliseconds), _TRUNCATE, _T("%lu"), waited); + _sntprintf_s(interval_milliseconds, _countof(interval_milliseconds), _TRUNCATE, _T("%lu"), interval); log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_AWAITING_SHUTDOWN, function, service->name, waited_milliseconds, interval_milliseconds, timeout_milliseconds, 0); }