X-Git-Url: http://git.iain.cx/?a=blobdiff_plain;f=service.cpp;h=be7050117415e799b11f4fbbb0b9928d59d23294;hb=bf75c3da8b88b87c298e2b358a8d38c8476fa85b;hp=766031ee9e9a3e186b42b07a014d32bdec996323;hpb=f2ec1c0c55a6b3e8ca02b3d66b78c87fe0ac1f47;p=nssm.git diff --git a/service.cpp b/service.cpp index 766031e..be70501 100644 --- a/service.cpp +++ b/service.cpp @@ -11,9 +11,20 @@ char exe[EXE_LENGTH]; char flags[CMD_LENGTH]; char dir[MAX_PATH]; bool stopping; +bool allow_restart; unsigned long throttle_delay; +unsigned long stop_method; +unsigned long kill_console_delay; +unsigned long kill_window_delay; +unsigned long kill_threads_delay; +CRITICAL_SECTION throttle_section; +CONDITION_VARIABLE throttle_condition; HANDLE throttle_timer; LARGE_INTEGER throttle_duetime; +bool use_critical_section; +FILETIME creation_time; + +extern imports_t imports; 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 }; @@ -26,6 +37,14 @@ static inline int throttle_milliseconds() { return ret * 1000; } +/* + Wrapper to be called in a new thread so that we can acknowledge a STOP + control immediately. +*/ +static unsigned long WINAPI shutdown_service(void *arg) { + return stop_service(0, true, true); +} + /* Connect to the service manager */ SC_HANDLE open_service_manager() { SC_HANDLE ret = OpenSCManager(0, SERVICES_ACTIVE_DATABASE, SC_MANAGER_ALL_ACCESS); @@ -90,7 +109,7 @@ int install_service(char *name, char *exe, char *flags) { print_message(stderr, NSSM_MESSAGE_OPEN_SERVICE_MANAGER_FAILED); return 2; } - + /* Get path of this program */ char path[MAX_PATH]; GetModuleFileName(0, path, MAX_PATH); @@ -102,7 +121,7 @@ int install_service(char *name, char *exe, char *flags) { print_message(stderr, NSSM_MESSAGE_PATH_TOO_LONG, NSSM); return 3; } - if (_snprintf(command, sizeof(command), "\"%s\"", path) < 0) { + if (_snprintf_s(command, sizeof(command), _TRUNCATE, "\"%s\"", path) < 0) { print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY_FOR_IMAGEPATH); return 4; } @@ -149,7 +168,7 @@ int remove_service(char *name) { print_message(stderr, NSSM_MESSAGE_OPEN_SERVICE_MANAGER_FAILED); return 2; } - + /* Try to open the service */ SC_HANDLE service = OpenService(services, name, SC_MANAGER_ALL_ACCESS); if (! service) { @@ -176,11 +195,15 @@ int remove_service(char *name) { /* Service initialisation */ void WINAPI service_main(unsigned long argc, char **argv) { - if (_snprintf(service_name, sizeof(service_name), "%s", argv[0]) < 0) { + 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); return; } + /* We can use a condition variable in a critical section on Vista or later. */ + if (imports.SleepConditionVariableCS && imports.WakeConditionVariable) use_critical_section = true; + else use_critical_section = false; + /* Initialise status */ ZeroMemory(&service_status, sizeof(service_status)); service_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS; @@ -215,9 +238,12 @@ void WINAPI service_main(unsigned long argc, char **argv) { } /* Used for signalling a resume if the service pauses when throttled. */ - throttle_timer = CreateWaitableTimer(0, 1, 0); - if (! throttle_timer) { - log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_CREATEWAITABLETIMER_FAILED, service_name, error_string(GetLastError()), 0); + if (use_critical_section) InitializeCriticalSection(&throttle_section); + else { + throttle_timer = CreateWaitableTimer(0, 1, 0); + if (! throttle_timer) { + log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_CREATEWAITABLETIMER_FAILED, service_name, error_string(GetLastError()), 0); + } } monitor_service(); @@ -259,13 +285,13 @@ int monitor_service() { int ret = start_service(); if (ret) { char code[16]; - _snprintf(code, sizeof(code), "%d", ret); + _snprintf_s(code, sizeof(code), _TRUNCATE, "%d", ret); log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_START_SERVICE_FAILED, exe, service_name, ret, 0); return ret; } log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_STARTED_SERVICE, exe, flags, service_name, dir, 0); - /* Monitor service service */ + /* Monitor service */ if (! RegisterWaitForSingleObject(&wait_handle, process_handle, end_service, (void *) pid, INFINITE, WT_EXECUTEONLYONCE | WT_EXECUTELONGFUNCTION)) { log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_REGISTERWAITFORSINGLEOBJECT_FAILED, service_name, exe, error_string(GetLastError()), 0); } @@ -294,11 +320,11 @@ void log_service_control(char *service_name, unsigned long control, bool handled /* "0x" + 8 x hex + NULL */ text = (char *) HeapAlloc(GetProcessHeap(), 0, 11); 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, "control code", "log_service_control()", 0); return; } - if (_snprintf(text, 11, "0x%08x", control) < 0) { - log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, "control code", "log_service_control", 0); + 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); HeapFree(GetProcessHeap(), 0, text); return; } @@ -318,18 +344,42 @@ void log_service_control(char *service_name, unsigned long control, bool handled /* Service control handler */ unsigned long WINAPI service_control_handler(unsigned long control, unsigned long event, void *data, void *context) { switch (control) { + case SERVICE_CONTROL_INTERROGATE: + /* We always keep the service status up-to-date so this is a no-op. */ + return NO_ERROR; + case SERVICE_CONTROL_SHUTDOWN: case SERVICE_CONTROL_STOP: log_service_control(service_name, control, true); - stop_service(0, true, true); + /* + We MUST acknowledge the stop request promptly but we're committed to + waiting for the application to exit. Spawn a new thread to wait + while we acknowledge the request. + */ + if (! CreateThread(NULL, 0, shutdown_service, (void *) service_name, 0, NULL)) { + log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATETHREAD_FAILED, error_string(GetLastError()), 0); + + /* + We couldn't create a thread to tidy up so we'll have to force the tidyup + to complete in time in this thread. + */ + kill_console_delay = NSSM_KILL_CONSOLE_GRACE_PERIOD; + kill_window_delay = NSSM_KILL_WINDOW_GRACE_PERIOD; + kill_threads_delay = NSSM_KILL_THREADS_GRACE_PERIOD; + + stop_service(0, true, true); + } return NO_ERROR; case SERVICE_CONTROL_CONTINUE: log_service_control(service_name, control, true); - if (! throttle_timer) return ERROR_CALL_NOT_IMPLEMENTED; throttle = 0; - ZeroMemory(&throttle_duetime, sizeof(throttle_duetime)); - SetWaitableTimer(throttle_timer, &throttle_duetime, 0, 0, 0, 0); + if (use_critical_section) imports.WakeConditionVariable(&throttle_condition); + else { + if (! throttle_timer) return ERROR_CALL_NOT_IMPLEMENTED; + ZeroMemory(&throttle_duetime, sizeof(throttle_duetime)); + SetWaitableTimer(throttle_timer, &throttle_duetime, 0, 0, 0, 0); + } service_status.dwCurrentState = SERVICE_CONTINUE_PENDING; service_status.dwWaitHint = throttle_milliseconds() + NSSM_WAITHINT_MARGIN; log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_RESET_THROTTLE, service_name, 0); @@ -353,6 +403,7 @@ unsigned long WINAPI service_control_handler(unsigned long control, unsigned lon /* Start the service */ int start_service() { stopping = false; + allow_restart = true; if (process_handle) return 0; @@ -367,7 +418,7 @@ int start_service() { /* Get startup parameters */ char *env = 0; - int ret = get_parameters(service_name, exe, sizeof(exe), flags, sizeof(flags), dir, sizeof(dir), &env, &throttle_delay); + int ret = get_parameters(service_name, exe, sizeof(exe), flags, sizeof(flags), dir, sizeof(dir), &env, &throttle_delay, &stop_method, &kill_console_delay, &kill_window_delay, &kill_threads_delay, &si); if (ret) { log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_GET_PARAMETERS_FAILED, service_name, 0); return stop_service(2, true, true); @@ -375,34 +426,66 @@ int start_service() { /* Launch executable with arguments */ char cmd[CMD_LENGTH]; - if (_snprintf(cmd, sizeof(cmd), "\"%s\" %s", exe, flags) < 0) { + if (_snprintf_s(cmd, sizeof(cmd), _TRUNCATE, "\"%s\" %s", exe, flags) < 0) { log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, "command line", "start_service", 0); + close_output_handles(&si); return stop_service(2, true, true); } throttle_restart(); - if (! CreateProcess(0, cmd, 0, 0, false, 0, env, dir, &si, &pi)) { + bool inherit_handles = false; + if (si.dwFlags & STARTF_USESTDHANDLES) inherit_handles = true; + if (! CreateProcess(0, cmd, 0, 0, inherit_handles, 0, env, dir, &si, &pi)) { unsigned long error = GetLastError(); if (error == ERROR_INVALID_PARAMETER && env) log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATEPROCESS_FAILED_INVALID_ENVIRONMENT, service_name, exe, NSSM_REG_ENV, 0); else log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATEPROCESS_FAILED, service_name, exe, error_string(error), 0); + close_output_handles(&si); return stop_service(3, true, true); } process_handle = pi.hProcess; pid = pi.dwProcessId; + if (get_process_creation_time(process_handle, &creation_time)) ZeroMemory(&creation_time, sizeof(creation_time)); + + close_output_handles(&si); + + /* + 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 + so abandon the wait before too much time has elapsed. + */ + unsigned long delay = 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); + log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_STARTUP_DELAY_TOO_LONG, service_name, delay_milliseconds, NSSM, deadline_milliseconds, 0); + delay = NSSM_SERVICE_STATUS_DEADLINE; + } + unsigned long deadline = WaitForSingleObject(process_handle, delay); + /* Signal successful start */ service_status.dwCurrentState = SERVICE_RUNNING; SetServiceStatus(service_handle, &service_status); - /* Wait for a clean startup. */ - if (WaitForSingleObject(process_handle, throttle_delay) == WAIT_TIMEOUT) throttle = 0; + /* Continue waiting for a clean startup. */ + if (deadline == WAIT_TIMEOUT) { + if (throttle_delay > delay) { + if (WaitForSingleObject(process_handle, throttle_delay - delay) == WAIT_TIMEOUT) throttle = 0; + } + else throttle = 0; + } return 0; } /* Stop the service */ int stop_service(unsigned long exitcode, bool graceful, bool default_action) { + allow_restart = false; + if (wait_handle) UnregisterWait(wait_handle); + if (default_action && ! exitcode && ! graceful) { log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_GRACEFUL_SUICIDE, service_name, 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; @@ -411,16 +494,15 @@ int stop_service(unsigned long exitcode, bool graceful, bool default_action) { /* Signal we are stopping */ if (graceful) { service_status.dwCurrentState = SERVICE_STOP_PENDING; - service_status.dwWaitHint = NSSM_KILL_WINDOW_GRACE_PERIOD + NSSM_KILL_THREADS_GRACE_PERIOD + NSSM_WAITHINT_MARGIN; + service_status.dwWaitHint = NSSM_WAITHINT_MARGIN; SetServiceStatus(service_handle, &service_status); } - /* Nothing to do if server isn't running */ + /* Nothing to do if service isn't running */ if (pid) { - /* Shut down server */ + /* Shut down service */ log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_TERMINATEPROCESS, service_name, exe, 0); - kill_process(service_name, process_handle, pid, 0); - process_handle = 0; + kill_process(service_name, service_handle, &service_status, stop_method, process_handle, pid, 0); } else log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_PROCESS_ALREADY_STOPPED, service_name, exe, 0); @@ -453,10 +535,24 @@ void CALLBACK end_service(void *arg, unsigned char why) { /* Check exit code */ unsigned long exitcode = 0; + char code[16]; + FILETIME exit_time; GetExitCodeProcess(process_handle, &exitcode); + if (exitcode == STILL_ACTIVE || get_process_exit_time(process_handle, &exit_time)) GetSystemTimeAsFileTime(&exit_time); + CloseHandle(process_handle); + + /* + 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); + log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_ENDED_SERVICE, exe, service_name, code, 0); + } /* Clean up. */ - kill_process_tree(service_name, pid, exitcode, pid); + if (exitcode == STILL_ACTIVE) exitcode = 0; + kill_process_tree(service_name, service_handle, &service_status, stop_method, pid, exitcode, pid, &creation_time, &exit_time); /* The why argument is true if our wait timed out or false otherwise. @@ -465,10 +561,7 @@ void CALLBACK end_service(void *arg, unsigned char why) { this is a controlled shutdown, and don't take any restart action. */ if (why) return; - - char code[16]; - _snprintf(code, sizeof(code), "%d", exitcode); - log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_ENDED_SERVICE, exe, service_name, code, 0); + if (! allow_restart) return; /* What action should we take? */ int action = NSSM_EXIT_RESTART; @@ -510,7 +603,9 @@ void CALLBACK end_service(void *arg, unsigned char why) { /* Fake a crash so pre-Vista service managers will run recovery actions. */ case NSSM_EXIT_UNCLEAN: log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_EXIT_UNCLEAN, service_name, code, exit_action_strings[action], 0); - exit(stop_service(exitcode, false, default_action)); + stop_service(exitcode, false, default_action); + free_imports(); + exit(exitcode); break; } } @@ -524,11 +619,12 @@ void throttle_restart() { if (throttle > 7) throttle = 8; char threshold[8], milliseconds[8]; - _snprintf(threshold, sizeof(threshold), "%d", throttle_delay); - _snprintf(milliseconds, sizeof(milliseconds), "%d", ms); + _snprintf_s(threshold, sizeof(threshold), _TRUNCATE, "%lu", throttle_delay); + _snprintf_s(milliseconds, sizeof(milliseconds), _TRUNCATE, "%lu", ms); log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_THROTTLED, service_name, threshold, milliseconds, 0); - if (throttle_timer) { + if (use_critical_section) EnterCriticalSection(&throttle_section); + else if (throttle_timer) { ZeroMemory(&throttle_duetime, sizeof(throttle_duetime)); throttle_duetime.QuadPart = 0 - (ms * 10000LL); SetWaitableTimer(throttle_timer, &throttle_duetime, 0, 0, 0, 0); @@ -537,6 +633,99 @@ void throttle_restart() { service_status.dwCurrentState = SERVICE_PAUSED; SetServiceStatus(service_handle, &service_status); - if (throttle_timer) WaitForSingleObject(throttle_timer, INFINITE); - else Sleep(ms); + if (use_critical_section) { + imports.SleepConditionVariableCS(&throttle_condition, &throttle_section, ms); + LeaveCriticalSection(&throttle_section); + } + else { + if (throttle_timer) WaitForSingleObject(throttle_timer, INFINITE); + else Sleep(ms); + } +} + +/* + When responding to a stop (or any other) request we need to set dwWaitHint to + the number of milliseconds we expect the operation to take, and optionally + increase dwCheckPoint. If dwWaitHint milliseconds elapses without the + operation completing or dwCheckPoint increasing, the system will consider the + service to be hung. + + However the system will consider the service to be hung after 30000 + milliseconds regardless of the value of dwWaitHint if dwCheckPoint has not + changed. Therefore if we want to wait longer than that we must periodically + increase dwCheckPoint. + + Furthermore, it will consider the service to be hung after 60000 milliseconds + regardless of the value of dwCheckPoint unless dwWaitHint is increased every + time dwCheckPoint is also increased. + + Our strategy then is to retrieve the initial dwWaitHint and wait for + NSSM_SERVICE_STATUS_DEADLINE milliseconds. If the process is still running + and we haven't finished waiting we increment dwCheckPoint and add whichever is + smaller of NSSM_SERVICE_STATUS_DEADLINE or the remaining timeout to + dwWaitHint. + + Only doing both these things will prevent the system from killing the service. + + Returns: 1 if the wait timed out. + 0 if the wait completed. + -1 on error. +*/ +int await_shutdown(char *function_name, char *service_name, SERVICE_STATUS_HANDLE service_handle, SERVICE_STATUS *service_status, HANDLE process_handle, 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; + + /* Add brackets to function name. */ + size_t funclen = strlen(function_name) + 3; + char *func = (char *) HeapAlloc(GetProcessHeap(), 0, funclen); + if (func) { + if (_snprintf_s(func, funclen, _TRUNCATE, "%s()", function_name) > -1) function = func; + } + + _snprintf_s(timeout_milliseconds, sizeof(timeout_milliseconds), _TRUNCATE, "%lu", timeout); + + waithint = service_status->dwWaitHint; + waited = 0; + while (waited < timeout) { + interval = timeout - waited; + if (interval > NSSM_SERVICE_STATUS_DEADLINE) interval = NSSM_SERVICE_STATUS_DEADLINE; + + service_status->dwCurrentState = SERVICE_STOP_PENDING; + service_status->dwWaitHint += interval; + service_status->dwCheckPoint++; + SetServiceStatus(service_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); + log_event(EVENTLOG_INFORMATION_TYPE, NSSM_EVENT_AWAITING_SHUTDOWN, function, service_name, waited_milliseconds, interval_milliseconds, timeout_milliseconds, 0); + } + + switch (WaitForSingleObject(process_handle, interval)) { + case WAIT_OBJECT_0: + ret = 0; + goto awaited; + + case WAIT_TIMEOUT: + ret = 1; + break; + + default: + ret = -1; + goto awaited; + } + + waited += interval; + } + +awaited: + if (func) HeapFree(GetProcessHeap(), 0, func); + + return ret; }