static int setting_set_affinity(const TCHAR *service_name, void *param, const TCHAR *name, void *default_value, value_t *value, const TCHAR *additional) {
HKEY key = (HKEY) param;
if (! key) return -1;
long error;
__int64 mask;
__int64 system_affinity = 0LL;
if (value && value->string) {
DWORD_PTR affinity;
if (! GetProcessAffinityMask(GetCurrentProcess(), &affinity, (DWORD_PTR *) &system_affinity)) system_affinity = ~0;
if (is_default(value->string) || str_equiv(value->string, NSSM_AFFINITY_ALL)) mask = 0LL;
else if (affinity_string_to_mask(value->string, &mask)) {
print_message(stderr, NSSM_MESSAGE_BOGUS_AFFINITY_MASK, value->string, num_cpus() - 1);
return -1;
}
}
else mask = 0LL;
if (! mask) {
error = RegDeleteValue(key, name);
if (error == ERROR_SUCCESS || error == ERROR_FILE_NOT_FOUND) return 0;
print_message(stderr, NSSM_MESSAGE_REGDELETEVALUE_FAILED, name, service_name, error_string(error));
return -1;
}
/* Canonicalise. */
TCHAR *canon = 0;
if (affinity_mask_to_string(mask, &canon)) canon = value->string;
__int64 effective_affinity = mask & system_affinity;
if (effective_affinity != mask) {
/* Requested CPUs did not intersect with available CPUs? */
if (! effective_affinity) mask = effective_affinity = system_affinity;
TCHAR *system = 0;
if (! affinity_mask_to_string(system_affinity, &system)) {
TCHAR *effective = 0;
if (! affinity_mask_to_string(effective_affinity, &effective)) {
print_message(stderr, NSSM_MESSAGE_EFFECTIVE_AFFINITY_MASK, value->string, system, effective);
HeapFree(GetProcessHeap(), 0, effective);
}
HeapFree(GetProcessHeap(), 0, system);
}
}
if (RegSetValueEx(key, name, 0, REG_SZ, (const unsigned char *) canon, (unsigned long) (_tcslen(canon) + 1) * sizeof(TCHAR)) != ERROR_SUCCESS) {
if (canon != value->string) HeapFree(GetProcessHeap(), 0, canon);
log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_SETVALUE_FAILED, name, error_string(GetLastError()), 0);
return -1;
}
if (canon != value->string) HeapFree(GetProcessHeap(), 0, canon);
return 1;
}
static int setting_get_affinity(const TCHAR *service_name, void *param, const TCHAR *name, void *default_value, value_t *value, const TCHAR *additional) {
HKEY key = (HKEY) param;
if (! key) return -1;
unsigned long type;
TCHAR *buffer = 0;
unsigned long buflen = 0;
int ret = RegQueryValueEx(key, name, 0, &type, 0, &buflen);
if (ret == ERROR_FILE_NOT_FOUND) {
if (value_from_string(name, value, NSSM_AFFINITY_ALL) == 1) return 0;
return -1;
}
if (ret != ERROR_SUCCESS) return -1;
if (type != REG_SZ) return -1;
buffer = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, buflen);
if (! buffer) {
print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY, _T("affinity"), _T("setting_get_affinity"));
return -1;
}
if (get_string(key, (TCHAR *) name, buffer, buflen, false, false, true)) {
HeapFree(GetProcessHeap(), 0, buffer);
return -1;
}
__int64 affinity;
if (affinity_string_to_mask(buffer, &affinity)) {
print_message(stderr, NSSM_MESSAGE_BOGUS_AFFINITY_MASK, buffer, num_cpus() - 1);
HeapFree(GetProcessHeap(), 0, buffer);
return -1;
}
HeapFree(GetProcessHeap(), 0, buffer);
/* Canonicalise. */
if (affinity_mask_to_string(affinity, &buffer)) {
if (buffer) HeapFree(GetProcessHeap(), 0, buffer);
return -1;
}
ret = value_from_string(name, value, buffer);
HeapFree(GetProcessHeap(), 0, buffer);
return ret;
}
int create_parameters(nssm_service_t *service, bool editing) {
/* Try to open the registry */
HKEY key = open_registry(service->name, KEY_WRITE);
if (! key) return 1;
/* Remember parameters in case we need to delete them. */
TCHAR registry[KEY_LENGTH];
int ret = service_registry_path(service->name, true, 0, registry, _countof(registry));
/* Try to create the parameters */
if (set_expand_string(key, NSSM_REG_EXE, service->exe)) {
if (ret > 0) RegDeleteKey(HKEY_LOCAL_MACHINE, registry);
RegCloseKey(key);
return 2;
}
if (set_expand_string(key, NSSM_REG_FLAGS, service->flags)) {
if (ret > 0) RegDeleteKey(HKEY_LOCAL_MACHINE, registry);
RegCloseKey(key);
return 3;
}
if (set_expand_string(key, NSSM_REG_DIR, service->dir)) {
if (ret > 0) RegDeleteKey(HKEY_LOCAL_MACHINE, registry);
RegCloseKey(key);
return 4;
}
/* Other non-default parameters. May fail. */
if (service->priority != NORMAL_PRIORITY_CLASS) set_number(key, NSSM_REG_PRIORITY, service->priority);
else if (editing) RegDeleteValue(key, NSSM_REG_PRIORITY);
if (service->affinity) {
TCHAR *string;
if (! affinity_mask_to_string(service->affinity, &string)) {
if (RegSetValueEx(key, NSSM_REG_AFFINITY, 0, REG_SZ, (const unsigned char *) string, (unsigned long) (_tcslen(string) + 1) * sizeof(TCHAR)) != ERROR_SUCCESS) {
log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_SETVALUE_FAILED, NSSM_REG_AFFINITY, error_string(GetLastError()), 0);
HeapFree(GetProcessHeap(), 0, string);
return 5;
}
}
if (string) HeapFree(GetProcessHeap(), 0, string);
}
else if (editing) RegDeleteValue(key, NSSM_REG_AFFINITY);
unsigned long stop_method_skip = ~service->stop_method;
if (stop_method_skip) set_number(key, NSSM_REG_STOP_METHOD_SKIP, stop_method_skip);
else if (editing) RegDeleteValue(key, NSSM_REG_STOP_METHOD_SKIP);
if (service->default_exit_action < NSSM_NUM_EXIT_ACTIONS) create_exit_action(service->name, exit_action_strings[service->default_exit_action], editing);
if (service->restart_delay) set_number(key, NSSM_REG_RESTART_DELAY, service->restart_delay);
else if (editing) RegDeleteValue(key, NSSM_REG_RESTART_DELAY);
if (service->throttle_delay != NSSM_RESET_THROTTLE_RESTART) set_number(key, NSSM_REG_THROTTLE, service->throttle_delay);
else if (editing) RegDeleteValue(key, NSSM_REG_THROTTLE);
if (service->kill_console_delay != NSSM_KILL_CONSOLE_GRACE_PERIOD) set_number(key, NSSM_REG_KILL_CONSOLE_GRACE_PERIOD, service->kill_console_delay);
else if (editing) RegDeleteValue(key, NSSM_REG_KILL_CONSOLE_GRACE_PERIOD);
if (service->kill_window_delay != NSSM_KILL_WINDOW_GRACE_PERIOD) set_number(key, NSSM_REG_KILL_WINDOW_GRACE_PERIOD, service->kill_window_delay);
else if (editing) RegDeleteValue(key, NSSM_REG_KILL_WINDOW_GRACE_PERIOD);
if (service->kill_threads_delay != NSSM_KILL_THREADS_GRACE_PERIOD) set_number(key, NSSM_REG_KILL_THREADS_GRACE_PERIOD, service->kill_threads_delay);
else if (editing) RegDeleteValue(key, NSSM_REG_KILL_THREADS_GRACE_PERIOD);
if (! service->kill_process_tree) set_number(key, NSSM_REG_KILL_PROCESS_TREE, 0);
else if (editing) RegDeleteValue(key, NSSM_REG_KILL_PROCESS_TREE);
if (service->stdin_path[0] || editing) {
if (service->stdin_path[0]) set_expand_string(key, NSSM_REG_STDIN, service->stdin_path);
else if (editing) RegDeleteValue(key, NSSM_REG_STDIN);
if (service->stdin_sharing != NSSM_STDIN_SHARING) set_createfile_parameter(key, NSSM_REG_STDIN, NSSM_REG_STDIO_SHARING, service->stdin_sharing);
else if (editing) delete_createfile_parameter(key, NSSM_REG_STDIN, NSSM_REG_STDIO_SHARING);
if (service->stdin_disposition != NSSM_STDIN_DISPOSITION) set_createfile_parameter(key, NSSM_REG_STDIN, NSSM_REG_STDIO_DISPOSITION, service->stdin_disposition);
else if (editing) delete_createfile_parameter(key, NSSM_REG_STDIN, NSSM_REG_STDIO_DISPOSITION);
if (service->stdin_flags != NSSM_STDIN_FLAGS) set_createfile_parameter(key, NSSM_REG_STDIN, NSSM_REG_STDIO_FLAGS, service->stdin_flags);
else if (editing) delete_createfile_parameter(key, NSSM_REG_STDIN, NSSM_REG_STDIO_FLAGS);
}
if (service->stdout_path[0] || editing) {
if (service->stdout_path[0]) set_expand_string(key, NSSM_REG_STDOUT, service->stdout_path);
else if (editing) RegDeleteValue(key, NSSM_REG_STDOUT);
if (service->stdout_sharing != NSSM_STDOUT_SHARING) set_createfile_parameter(key, NSSM_REG_STDOUT, NSSM_REG_STDIO_SHARING, service->stdout_sharing);
else if (editing) delete_createfile_parameter(key, NSSM_REG_STDOUT, NSSM_REG_STDIO_SHARING);
if (service->stdout_disposition != NSSM_STDOUT_DISPOSITION) set_createfile_parameter(key, NSSM_REG_STDOUT, NSSM_REG_STDIO_DISPOSITION, service->stdout_disposition);
else if (editing) delete_createfile_parameter(key, NSSM_REG_STDOUT, NSSM_REG_STDIO_DISPOSITION);
if (service->stdout_flags != NSSM_STDOUT_FLAGS) set_createfile_parameter(key, NSSM_REG_STDOUT, NSSM_REG_STDIO_FLAGS, service->stdout_flags);
else if (editing) delete_createfile_parameter(key, NSSM_REG_STDOUT, NSSM_REG_STDIO_FLAGS);
if (service->stdout_copy_and_truncate) set_createfile_parameter(key, NSSM_REG_STDOUT, NSSM_REG_STDIO_COPY_AND_TRUNCATE, 1);
else if (editing) delete_createfile_parameter(key, NSSM_REG_STDOUT, NSSM_REG_STDIO_COPY_AND_TRUNCATE);
}
if (service->stderr_path[0] || editing) {
if (service->stderr_path[0]) set_expand_string(key, NSSM_REG_STDERR, service->stderr_path);
else if (editing) RegDeleteValue(key, NSSM_REG_STDERR);
if (service->stderr_sharing != NSSM_STDERR_SHARING) set_createfile_parameter(key, NSSM_REG_STDERR, NSSM_REG_STDIO_SHARING, service->stderr_sharing);
else if (editing) delete_createfile_parameter(key, NSSM_REG_STDERR, NSSM_REG_STDIO_SHARING);
if (service->stderr_disposition != NSSM_STDERR_DISPOSITION) set_createfile_parameter(key, NSSM_REG_STDERR, NSSM_REG_STDIO_DISPOSITION, service->stderr_disposition);
else if (editing) delete_createfile_parameter(key, NSSM_REG_STDERR, NSSM_REG_STDIO_DISPOSITION);
if (service->stderr_flags != NSSM_STDERR_FLAGS) set_createfile_parameter(key, NSSM_REG_STDERR, NSSM_REG_STDIO_FLAGS, service->stderr_flags);
else if (editing) delete_createfile_parameter(key, NSSM_REG_STDERR, NSSM_REG_STDIO_FLAGS);
if (service->stderr_copy_and_truncate) set_createfile_parameter(key, NSSM_REG_STDERR, NSSM_REG_STDIO_COPY_AND_TRUNCATE, 1);
else if (editing) delete_createfile_parameter(key, NSSM_REG_STDERR, NSSM_REG_STDIO_COPY_AND_TRUNCATE);
}
if (service->timestamp_log) set_number(key, NSSM_REG_TIMESTAMP_LOG, 1);
else if (editing) RegDeleteValue(key, NSSM_REG_TIMESTAMP_LOG);
if (service->hook_share_output_handles) set_number(key, NSSM_REG_HOOK_SHARE_OUTPUT_HANDLES, 1);
else if (editing) RegDeleteValue(key, NSSM_REG_HOOK_SHARE_OUTPUT_HANDLES);
if (service->rotate_files) set_number(key, NSSM_REG_ROTATE, 1);
else if (editing) RegDeleteValue(key, NSSM_REG_ROTATE);
if (service->rotate_stdout_online) set_number(key, NSSM_REG_ROTATE_ONLINE, 1);
else if (editing) RegDeleteValue(key, NSSM_REG_ROTATE_ONLINE);
if (service->rotate_seconds) set_number(key, NSSM_REG_ROTATE_SECONDS, service->rotate_seconds);
else if (editing) RegDeleteValue(key, NSSM_REG_ROTATE_SECONDS);
if (service->rotate_bytes_low) set_number(key, NSSM_REG_ROTATE_BYTES_LOW, service->rotate_bytes_low);
else if (editing) RegDeleteValue(key, NSSM_REG_ROTATE_BYTES_LOW);
if (service->rotate_bytes_high) set_number(key, NSSM_REG_ROTATE_BYTES_HIGH, service->rotate_bytes_high);
else if (editing) RegDeleteValue(key, NSSM_REG_ROTATE_BYTES_HIGH);
if (service->rotate_delay != NSSM_ROTATE_DELAY) set_number(key, NSSM_REG_ROTATE_DELAY, service->rotate_delay);
else if (editing) RegDeleteValue(key, NSSM_REG_ROTATE_DELAY);
if (service->no_console) set_number(key, NSSM_REG_NO_CONSOLE, 1);
else if (editing) RegDeleteValue(key, NSSM_REG_NO_CONSOLE);
/* Environment */
if (service->env) {
if (RegSetValueEx(key, NSSM_REG_ENV, 0, REG_MULTI_SZ, (const unsigned char *) service->env, (unsigned long) service->envlen * sizeof(TCHAR)) != ERROR_SUCCESS) {
log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_SETVALUE_FAILED, NSSM_REG_ENV, error_string(GetLastError()), 0);
}
}
else if (editing) RegDeleteValue(key, NSSM_REG_ENV);
if (service->env_extra) {
if (RegSetValueEx(key, NSSM_REG_ENV_EXTRA, 0, REG_MULTI_SZ, (const unsigned char *) service->env_extra, (unsigned long) service->env_extralen * sizeof(TCHAR)) != ERROR_SUCCESS) {
log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_SETVALUE_FAILED, NSSM_REG_ENV_EXTRA, error_string(GetLastError()), 0);
}
}
else if (editing) RegDeleteValue(key, NSSM_REG_ENV_EXTRA);
/* Close registry. */
RegCloseKey(key);
return 0;
}
int get_parameters(nssm_service_t *service, STARTUPINFO *si) {
unsigned long ret;
/* Try to open the registry */
HKEY key = open_registry(service->name, KEY_READ);
if (! key) return 1;
/* Don't expand parameters when retrieving for the GUI. */
bool expand = si ? true : false;
/* Try to get environment variables - may fail */
get_environment(service->name, key, NSSM_REG_ENV, &service->env, &service->envlen);
/* Environment variables to add to existing rather than replace - may fail. */
get_environment(service->name, key, NSSM_REG_ENV_EXTRA, &service->env_extra, &service->env_extralen);
/* Set environment if we are starting the service. */
if (si) set_service_environment(service);
/* Try to get executable file - MUST succeed */
if (get_string(key, NSSM_REG_EXE, service->exe, sizeof(service->exe), expand, false, true)) {
RegCloseKey(key);
return 3;
}
/* Try to get flags - may fail and we don't care */
if (get_string(key, NSSM_REG_FLAGS, service->flags, sizeof(service->flags), expand, false, true)) {
log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_NO_FLAGS, NSSM_REG_FLAGS, service->name, service->exe, 0);
ZeroMemory(service->flags, sizeof(service->flags));
}
/* Try to get startup directory - may fail and we fall back to a default */
if (get_string(key, NSSM_REG_DIR, service->dir, sizeof(service->dir), expand, true, true) || ! service->dir[0]) {
_sntprintf_s(service->dir, _countof(service->dir), _TRUNCATE, _T("%s"), service->exe);
strip_basename(service->dir);
if (service->dir[0] == _T('\0')) {
/* Help! */
ret = GetWindowsDirectory(service->dir, sizeof(service->dir));
if (! ret || ret > sizeof(service->dir)) {
log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_NO_DIR_AND_NO_FALLBACK, NSSM_REG_DIR, service->name, 0);
RegCloseKey(key);
return 4;
}
}
log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_NO_DIR, NSSM_REG_DIR, service->name, service->dir, 0);
}
/* Try to get processor affinity - may fail. */
TCHAR buffer[512];
if (get_string(key, NSSM_REG_AFFINITY, buffer, sizeof(buffer), false, false, false) || ! buffer[0]) service->affinity = 0LL;
else if (affinity_string_to_mask(buffer, &service->affinity)) {
log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_BOGUS_AFFINITY_MASK, service->name, buffer);
service->affinity = 0LL;
}
else {
DWORD_PTR affinity, system_affinity;
if (GetProcessAffinityMask(GetCurrentProcess(), &affinity, &system_affinity)) {
_int64 effective_affinity = service->affinity & system_affinity;
if (effective_affinity != service->affinity) {
TCHAR *system = 0;
if (! affinity_mask_to_string(system_affinity, &system)) {
TCHAR *effective = 0;
if (! affinity_mask_to_string(effective_affinity, &effective)) {
log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_EFFECTIVE_AFFINITY_MASK, service->name, buffer, system, effective, 0);
}
HeapFree(GetProcessHeap(), 0, effective);
}
HeapFree(GetProcessHeap(), 0, system);
}
}
}
/* Try to get priority - may fail. */
unsigned long priority;
if (get_number(key, NSSM_REG_PRIORITY, &priority, false) == 1) {
if (priority == (priority & priority_mask())) service->priority = priority;
else log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_BOGUS_PRIORITY, service->name, NSSM_REG_PRIORITY, 0);
}
/* Try to get hook I/O sharing - may fail. */
unsigned long hook_share_output_handles;
if (get_number(key, NSSM_REG_HOOK_SHARE_OUTPUT_HANDLES, &hook_share_output_handles, false) == 1) {
if (hook_share_output_handles) service->hook_share_output_handles = true;
else service->hook_share_output_handles = false;
}
else hook_share_output_handles = false;
/* Try to get file rotation settings - may fail. */
unsigned long rotate_files;
if (get_number(key, NSSM_REG_ROTATE, &rotate_files, false) == 1) {
if (rotate_files) service->rotate_files = true;
else service->rotate_files = false;
}
else service->rotate_files = false;
if (get_number(key, NSSM_REG_ROTATE_ONLINE, &rotate_files, false) == 1) {
if (rotate_files) service->rotate_stdout_online = service->rotate_stderr_online = true;
else service->rotate_stdout_online = service->rotate_stderr_online = false;
}
else service->rotate_stdout_online = service->rotate_stderr_online = false;
/* Log timestamping requires a logging thread.*/
unsigned long timestamp_log;
if (get_number(key, NSSM_REG_TIMESTAMP_LOG, ×tamp_log, false) == 1) {
if (timestamp_log) service->timestamp_log = true;
else service->timestamp_log = false;
}
else service->timestamp_log = false;
/* Hook I/O sharing and online rotation need a pipe. */
service->use_stdout_pipe = service->rotate_stdout_online || service->timestamp_log || hook_share_output_handles;
service->use_stderr_pipe = service->rotate_stderr_online || service->timestamp_log || hook_share_output_handles;
if (get_number(key, NSSM_REG_ROTATE_SECONDS, &service->rotate_seconds, false) != 1) service->rotate_seconds = 0;
if (get_number(key, NSSM_REG_ROTATE_BYTES_LOW, &service->rotate_bytes_low, false) != 1) service->rotate_bytes_low = 0;
if (get_number(key, NSSM_REG_ROTATE_BYTES_HIGH, &service->rotate_bytes_high, false) != 1) service->rotate_bytes_high = 0;
override_milliseconds(service->name, key, NSSM_REG_ROTATE_DELAY, &service->rotate_delay, NSSM_ROTATE_DELAY, NSSM_EVENT_BOGUS_THROTTLE);
/* Try to get force new console setting - may fail. */
if (get_number(key, NSSM_REG_NO_CONSOLE, &service->no_console, false) != 1) service->no_console = 0;
/* Change to startup directory in case stdout/stderr are relative paths. */
TCHAR cwd[PATH_LENGTH];
GetCurrentDirectory(_countof(cwd), cwd);
SetCurrentDirectory(service->dir);
/* Try to get stdout and stderr */
if (get_io_parameters(service, key)) {
log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_GET_OUTPUT_HANDLES_FAILED, service->name, 0);
RegCloseKey(key);
SetCurrentDirectory(cwd);
return 5;
}
/* Change back in case the startup directory needs to be deleted. */
SetCurrentDirectory(cwd);
/* Try to get mandatory restart delay */
override_milliseconds(service->name, key, NSSM_REG_RESTART_DELAY, &service->restart_delay, 0, NSSM_EVENT_BOGUS_RESTART_DELAY);
/* Try to get throttle restart delay */
override_milliseconds(service->name, key, NSSM_REG_THROTTLE, &service->throttle_delay, NSSM_RESET_THROTTLE_RESTART, NSSM_EVENT_BOGUS_THROTTLE);
/* Try to get service stop flags. */
unsigned long type = REG_DWORD;
unsigned long stop_method_skip;
unsigned long buflen = sizeof(stop_method_skip);
bool stop_ok = false;
ret = RegQueryValueEx(key, NSSM_REG_STOP_METHOD_SKIP, 0, &type, (unsigned char *) &stop_method_skip, &buflen);
if (ret != ERROR_SUCCESS) {
if (ret != ERROR_FILE_NOT_FOUND) {
if (type != REG_DWORD) {
log_event(EVENTLOG_WARNING_TYPE, NSSM_EVENT_BOGUS_STOP_METHOD_SKIP, service->name, NSSM_REG_STOP_METHOD_SKIP, NSSM, 0);
}
else log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_QUERYVALUE_FAILED, NSSM_REG_STOP_METHOD_SKIP, error_string(ret), 0);
}
}
else stop_ok = true;
/* Try all methods except those requested to be skipped. */
service->stop_method = ~0;
if (stop_ok) service->stop_method &= ~stop_method_skip;
/* Try to get kill delays - may fail. */
override_milliseconds(service->name, key, NSSM_REG_KILL_CONSOLE_GRACE_PERIOD, &service->kill_console_delay, NSSM_KILL_CONSOLE_GRACE_PERIOD, NSSM_EVENT_BOGUS_KILL_CONSOLE_GRACE_PERIOD);
override_milliseconds(service->name, key, NSSM_REG_KILL_WINDOW_GRACE_PERIOD, &service->kill_window_delay, NSSM_KILL_WINDOW_GRACE_PERIOD, NSSM_EVENT_BOGUS_KILL_WINDOW_GRACE_PERIOD);
override_milliseconds(service->name, key, NSSM_REG_KILL_THREADS_GRACE_PERIOD, &service->kill_threads_delay, NSSM_KILL_THREADS_GRACE_PERIOD, NSSM_EVENT_BOGUS_KILL_THREADS_GRACE_PERIOD);
/* Try to get process tree settings - may fail. */
unsigned long kill_process_tree;
if (get_number(key, NSSM_REG_KILL_PROCESS_TREE, &kill_process_tree, false) == 1) {
if (kill_process_tree) service->kill_process_tree = true;
else service->kill_process_tree = false;
}
else service->kill_process_tree = true;
/* Try to get default exit action. */
bool default_action;
service->default_exit_action = NSSM_EXIT_RESTART;
TCHAR action_string[ACTION_LEN];
if (! get_exit_action(service->name, 0, action_string, &default_action)) {
for (int i = 0; exit_action_strings[i]; i++) {
if (! _tcsnicmp((const TCHAR *) action_string, exit_action_strings[i], ACTION_LEN)) {
service->default_exit_action = i;
break;
}
}
}
/* Close registry */
RegCloseKey(key);
return 0;
}
