/* Start the service */
int start_service() {
stopping = false;
if (process_handle) return 0;
/* Allocate a STARTUPINFO structure for a new process */
STARTUPINFO si;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
/* Allocate a PROCESSINFO structure for the process */
PROCESS_INFORMATION pi;
ZeroMemory(&pi, sizeof(pi));
/* Get startup parameters */
char *env = 0;
int ret = get_parameters(service_name, exe, sizeof(exe), flags, sizeof(flags), dir, sizeof(dir), &env, &throttle_delay);
if (ret) {
log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_GET_PARAMETERS_FAILED, service_name, 0);
return stop_service(2, true, true);
}
/* Launch executable with arguments */
char cmd[CMD_LENGTH];
if (_snprintf(cmd, sizeof(cmd), "\"%s\" %s", exe, flags) < 0) {
log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, "command line", "start_service", 0);
return stop_service(2, true, true);
}
throttle_restart();
if (! CreateProcess(0, cmd, 0, 0, false, 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);
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));
/* 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;
return 0;
}
/*
Returns:
NSSM_HOOK_STATUS_SUCCESS if the hook ran successfully.
NSSM_HOOK_STATUS_NOTFOUND if no hook was found.
NSSM_HOOK_STATUS_ABORT if the hook failed and we should cancel service start.
NSSM_HOOK_STATUS_ERROR on error.
NSSM_HOOK_STATUS_NOTRUN if the hook didn't run.
NSSM_HOOK_STATUS_TIMEOUT if the hook timed out.
NSSM_HOOK_STATUS_FAILED if the hook failed.
*/
int nssm_hook(hook_thread_t *hook_threads, nssm_service_t *service, TCHAR *hook_event, TCHAR *hook_action, unsigned long *hook_control, unsigned long deadline, bool async) {
int ret = 0;
hook_t *hook = (hook_t *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(hook_t));
if (! hook) {
log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, _T("hook"), _T("nssm_hook()"), 0);
return NSSM_HOOK_STATUS_ERROR;
}
FILETIME now;
GetSystemTimeAsFileTime(&now);
EnterCriticalSection(&service->hook_section);
/* Set the environment. */
if (service->env) duplicate_environment(service->env);
if (service->env_extra) set_environment_block(service->env_extra);
/* ABI version. */
TCHAR number[16];
_sntprintf_s(number, _countof(number), _TRUNCATE, _T("%lu"), NSSM_HOOK_VERSION);
SetEnvironmentVariable(NSSM_HOOK_ENV_VERSION, number);
/* Event triggering this action. */
SetEnvironmentVariable(NSSM_HOOK_ENV_EVENT, hook_event);
/* Hook action. */
SetEnvironmentVariable(NSSM_HOOK_ENV_ACTION, hook_action);
/* Control triggering this action. May be empty. */
if (hook_control) SetEnvironmentVariable(NSSM_HOOK_ENV_TRIGGER, service_control_text(*hook_control));
else SetEnvironmentVariable(NSSM_HOOK_ENV_TRIGGER, _T(""));
/* Last control handled. */
SetEnvironmentVariable(NSSM_HOOK_ENV_LAST_CONTROL, service_control_text(service->last_control));
/* Path to NSSM. */
TCHAR path[PATH_LENGTH];
GetModuleFileName(0, path, _countof(path));
SetEnvironmentVariable(NSSM_HOOK_ENV_IMAGE_PATH, path);
/* NSSM version. */
SetEnvironmentVariable(NSSM_HOOK_ENV_NSSM_CONFIGURATION, NSSM_CONFIGURATION);
SetEnvironmentVariable(NSSM_HOOK_ENV_NSSM_VERSION, NSSM_VERSION);
SetEnvironmentVariable(NSSM_HOOK_ENV_BUILD_DATE, NSSM_DATE);
/* NSSM PID. */
_sntprintf_s(number, _countof(number), _TRUNCATE, _T("%lu"), GetCurrentProcessId());
SetEnvironmentVariable(NSSM_HOOK_ENV_PID, number);
/* NSSM runtime. */
set_hook_runtime(NSSM_HOOK_ENV_RUNTIME, &service->nssm_creation_time, &now);
/* Application PID. */
if (service->pid) {
_sntprintf_s(number, _countof(number), _TRUNCATE, _T("%lu"), service->pid);
SetEnvironmentVariable(NSSM_HOOK_ENV_APPLICATION_PID, number);
/* Application runtime. */
set_hook_runtime(NSSM_HOOK_ENV_APPLICATION_RUNTIME, &service->creation_time, &now);
/* Exit code. */
SetEnvironmentVariable(NSSM_HOOK_ENV_EXITCODE, _T(""));
}
else {
SetEnvironmentVariable(NSSM_HOOK_ENV_APPLICATION_PID, _T(""));
if (str_equiv(hook_event, NSSM_HOOK_EVENT_START) && str_equiv(hook_action, NSSM_HOOK_ACTION_PRE)) {
SetEnvironmentVariable(NSSM_HOOK_ENV_APPLICATION_RUNTIME, _T(""));
SetEnvironmentVariable(NSSM_HOOK_ENV_EXITCODE, _T(""));
}
else {
set_hook_runtime(NSSM_HOOK_ENV_APPLICATION_RUNTIME, &service->creation_time, &service->exit_time);
/* Exit code. */
_sntprintf_s(number, _countof(number), _TRUNCATE, _T("%lu"), service->exitcode);
SetEnvironmentVariable(NSSM_HOOK_ENV_EXITCODE, number);
}
}
/* Deadline for this script. */
_sntprintf_s(number, _countof(number), _TRUNCATE, _T("%lu"), deadline);
SetEnvironmentVariable(NSSM_HOOK_ENV_DEADLINE, number);
/* Service name. */
SetEnvironmentVariable(NSSM_HOOK_ENV_SERVICE_NAME, service->name);
SetEnvironmentVariable(NSSM_HOOK_ENV_SERVICE_DISPLAYNAME, service->displayname);
/* Times the service was asked to start. */
_sntprintf_s(number, _countof(number), _TRUNCATE, _T("%lu"), service->start_requested_count);
SetEnvironmentVariable(NSSM_HOOK_ENV_START_REQUESTED_COUNT, number);
/* Times the service actually did start. */
_sntprintf_s(number, _countof(number), _TRUNCATE, _T("%lu"), service->start_count);
SetEnvironmentVariable(NSSM_HOOK_ENV_START_COUNT, number);
/* Times the service exited. */
_sntprintf_s(number, _countof(number), _TRUNCATE, _T("%lu"), service->exit_count);
SetEnvironmentVariable(NSSM_HOOK_ENV_EXIT_COUNT, number);
/* Throttled count. */
_sntprintf_s(number, _countof(number), _TRUNCATE, _T("%lu"), service->throttle);
SetEnvironmentVariable(NSSM_HOOK_ENV_THROTTLE_COUNT, number);
/* Command line. */
TCHAR app[CMD_LENGTH];
_sntprintf_s(app, _countof(app), _TRUNCATE, _T("\"%s\" %s"), service->exe, service->flags);
SetEnvironmentVariable(NSSM_HOOK_ENV_COMMAND_LINE, app);
TCHAR cmd[CMD_LENGTH];
if (get_hook(service->name, hook_event, hook_action, cmd, sizeof(cmd))) {
log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_GET_HOOK_FAILED, hook_event, hook_action, service->name, 0);
duplicate_environment_strings(service->initial_env);
LeaveCriticalSection(&service->hook_section);
HeapFree(GetProcessHeap(), 0, hook);
return NSSM_HOOK_STATUS_ERROR;
}
/* No hook. */
if (! _tcslen(cmd)) {
duplicate_environment_strings(service->initial_env);
LeaveCriticalSection(&service->hook_section);
HeapFree(GetProcessHeap(), 0, hook);
return NSSM_HOOK_STATUS_NOTFOUND;
}
/* Run the command. */
STARTUPINFO si;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
PROCESS_INFORMATION pi;
ZeroMemory(&pi, sizeof(pi));
unsigned long flags = 0;
#ifdef UNICODE
flags |= CREATE_UNICODE_ENVIRONMENT;
#endif
ret = NSSM_HOOK_STATUS_NOTRUN;
if (CreateProcess(0, cmd, 0, 0, false, flags, 0, service->dir, &si, &pi)) {
hook->name = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, HOOK_NAME_LENGTH * sizeof(TCHAR));
if (hook->name) _sntprintf_s(hook->name, HOOK_NAME_LENGTH, _TRUNCATE, _T("%s (%s/%s)"), service->name, hook_event, hook_action);
hook->process_handle = pi.hProcess;
hook->pid = pi.dwProcessId;
hook->deadline = deadline;
if (get_process_creation_time(hook->process_handle, &hook->creation_time)) GetSystemTimeAsFileTime(&hook->creation_time);
unsigned long tid;
HANDLE thread_handle = CreateThread(NULL, 0, await_hook, (void *) hook, 0, &tid);
if (thread_handle) {
if (async) {
ret = 0;
await_hook_threads(hook_threads, service->status_handle, &service->status, 0);
add_thread_handle(hook_threads, thread_handle, hook->name);
}
else {
await_single_handle(service->status_handle, &service->status, thread_handle, hook->name, _T(__FUNCTION__), deadline + NSSM_SERVICE_STATUS_DEADLINE);
unsigned long exitcode;
GetExitCodeThread(thread_handle, &exitcode);
ret = (int) exitcode;
CloseHandle(thread_handle);
}
}
else {
log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATETHREAD_FAILED, error_string(GetLastError()), 0);
await_hook(hook);
if (hook->name) HeapFree(GetProcessHeap(), 0, hook->name);
HeapFree(GetProcessHeap(), 0, hook);
}
}
else {
log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_HOOK_CREATEPROCESS_FAILED, hook_event, hook_action, service->name, cmd, error_string(GetLastError()), 0);
HeapFree(GetProcessHeap(), 0, hook);
}
/* Restore our environment. */
duplicate_environment_strings(service->initial_env);
LeaveCriticalSection(&service->hook_section);
return ret;
}
