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 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; }