int set_hook(const TCHAR *service_name, const TCHAR *hook_event, const TCHAR *hook_action, TCHAR *cmd) { /* Try to open the registry */ TCHAR registry[KEY_LENGTH]; if (_sntprintf_s(registry, _countof(registry), _TRUNCATE, _T("%s\\%s"), NSSM_REG_HOOK, hook_event) < 0) { log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, _T("hook registry"), _T("set_hook()"), 0); return 1; } HKEY key; long error; /* Don't create keys needlessly. */ if (! _tcslen(cmd)) { key = open_registry(service_name, registry, KEY_READ, false); if (! key) return 0; error = RegQueryValueEx(key, hook_action, 0, 0, 0, 0); RegCloseKey(key); if (error == ERROR_FILE_NOT_FOUND) return 0; } key = open_registry(service_name, registry, KEY_WRITE); if (! key) return 1; int ret = 1; if (_tcslen(cmd)) ret = set_string(key, (TCHAR *) hook_action, cmd, true); else { error = RegDeleteValue(key, hook_action); if (error == ERROR_SUCCESS || error == ERROR_FILE_NOT_FOUND) ret = 0; } /* Close registry */ RegCloseKey(key); return ret; }
/* Sets the string for the exit action corresponding to the exit code. ret is a pointer to an unsigned long containing the exit code. If ret is NULL, we retrieve the default exit action unconditionally. action is a buffer which receives the string. default_action is a pointer to a bool which is set to false if there was an explicit string for the given exit code, or true if we are returning the default action. Returns: 0 on success. 1 on error. */ int get_exit_action(const TCHAR *service_name, unsigned long *ret, TCHAR *action, bool *default_action) { /* Are we returning the default action or a status-specific one? */ *default_action = ! ret; /* Try to open the registry */ HKEY key = open_registry(service_name, NSSM_REG_EXIT, KEY_READ); if (! key) return 1; unsigned long type = REG_SZ; unsigned long action_len = ACTION_LEN; TCHAR code[16]; if (! ret) code[0] = _T('\0'); else if (_sntprintf_s(code, _countof(code), _TRUNCATE, _T("%lu"), *ret) < 0) { RegCloseKey(key); return get_exit_action(service_name, 0, action, default_action); } if (RegQueryValueEx(key, code, 0, &type, (unsigned char *) action, &action_len) != ERROR_SUCCESS) { RegCloseKey(key); /* Try again with * as the key if an exit code was defined */ if (ret) return get_exit_action(service_name, 0, action, default_action); return 0; } /* Close registry */ RegCloseKey(key); return 0; }
static void init_part_two(void) { #ifdef WIN32 close_registry(); open_registry("Software\\Mbone Applications\\rat"); #endif }
static int setting_set_exit_action(const TCHAR *service_name, void *param, const TCHAR *name, void *default_value, value_t *value, const TCHAR *additional) { unsigned long exitcode; TCHAR *code; TCHAR action_string[ACTION_LEN]; if (additional) { /* Default action? */ if (is_default(additional)) code = 0; else { if (str_number(additional, &exitcode)) return -1; code = (TCHAR *) additional; } } HKEY key = open_registry(service_name, name, KEY_WRITE); if (! key) return -1; long error; int ret = 1; /* Resetting to default? */ if (value && value->string) _sntprintf_s(action_string, _countof(action_string), _TRUNCATE, _T("%s"), value->string); else { if (code) { /* Delete explicit action. */ error = RegDeleteValue(key, code); RegCloseKey(key); if (error == ERROR_SUCCESS || error == ERROR_FILE_NOT_FOUND) return 0; print_message(stderr, NSSM_MESSAGE_REGDELETEVALUE_FAILED, code, service_name, error_string(error)); return -1; } else { /* Explicitly keep the default action. */ if (default_value) _sntprintf_s(action_string, _countof(action_string), _TRUNCATE, _T("%s"), (TCHAR *) default_value); ret = 0; } } /* Validate the string. */ for (int i = 0; exit_action_strings[i]; i++) { if (! _tcsnicmp((const TCHAR *) action_string, exit_action_strings[i], ACTION_LEN)) { if (default_value && str_equiv(action_string, (TCHAR *) default_value)) ret = 0; if (RegSetValueEx(key, code, 0, REG_SZ, (const unsigned char *) exit_action_strings[i], (unsigned long) (_tcslen(action_string) + 1) * sizeof(TCHAR)) != ERROR_SUCCESS) { print_message(stderr, NSSM_MESSAGE_SETVALUE_FAILED, code, service_name, error_string(GetLastError())); RegCloseKey(key); return -1; } RegCloseKey(key); return ret; } } print_message(stderr, NSSM_MESSAGE_INVALID_EXIT_ACTION, action_string); for (int i = 0; exit_action_strings[i]; i++) _ftprintf(stderr, _T("%s\n"), exit_action_strings[i]); return -1; }
static void save_init_rtp(void) { #ifndef WIN32 asarray_create(&aa); #else open_registry("Software\\Mbone Applications\\common"); #endif }
static void save_init_rat(void) { /* We assume this function gets called after save_init_rtp so */ /* file/registry need closing before use. */ #ifndef WIN32 asarray_create(&aa); #else open_registry("Software\\Mbone Applications\\rat"); #endif }
static void init_registry(void) { TRACE("Initializing registry\n"); // can't be free-ed - it's static and probably thread // unsafe structure which is stored in glibc regpathname = get_path("registry"); localregpathname = regpathname; open_registry(); insert_handle(HKEY_LOCAL_MACHINE, "HKLM"); insert_handle(HKEY_CURRENT_USER, "HKCU"); }
static void init_registry(void) { // can't be free-ed - it's static and probably thread // unsafe structure which is stored in glibc if( regpathname != NULL ) localregpathname = regpathname; if(!open_registry(localregpathname)) create_registry(); // required base handles insert_handle((long)HKEY_LOCAL_MACHINE, "HKLM"); insert_handle((long)HKEY_CURRENT_USER, "HKCU"); load_registry_xml("special://xbmc/system/registry.xml"); load_registry_xml("special://masterprofile/registry.xml"); }
static void load_init(void) { #ifndef WIN32 FILE *sfile; char *buffer; char *key, *value; uint32_t i; asarray_create(&aa); i = 0; for (i = 0; i < 2; i++) { if ((sfile = settings_file_open(i, "r")) != NULL) { buffer = xmalloc(SETTINGS_READ_SIZE+1); buffer[100] = '\0'; while(fgets(buffer, SETTINGS_READ_SIZE, sfile) != NULL) { if (buffer[0] != '*') { debug_msg("Garbage ignored: %s\n", buffer); continue; } key = (char *) strtok(buffer, ":"); if (key == NULL) { continue; } key = key + 1; /* skip asterisk */ value = (char *) strtok(NULL, "\n"); if (value == NULL) { continue; } while (*value != '\0' && isascii((int)*value) && isspace((int)*value)) { /* skip leading spaces, and stop skipping if * not ascii*/ value++; } asarray_add(aa, key, value); } settings_file_close(sfile); xfree(buffer); } } #else open_registry("Software\\Mbone Applications\\common"); #endif }
static void init_registry(void) { TRACE("Initializing registry\n"); // can't be free-ed - it's static and probably thread // unsafe structure which is stored in glibc #ifdef MPLAYER regpathname = get_path("registry"); localregpathname = regpathname; #else #ifdef XINE_MAJOR localregpathname = (char *)malloc(strlen(xine_get_homedir()) + 21); sprintf(localregpathname, "%s/.xine/win32registry", xine_get_homedir()); #else // regpathname is an external pointer // // registry.c is holding it's own internal pointer // localregpathname - which is being allocate/deallocated if (localregpathname == 0) { const char* pthn = regpathname; if (!regpathname) { // avifile - for now reading data from user's home struct passwd* pwent; pwent = getpwuid(geteuid()); pthn = pwent->pw_dir; } localregpathname = (char*)malloc(strlen(pthn)+20); strcpy(localregpathname, pthn); strcat(localregpathname, "/.registry"); } #endif #endif open_registry(); insert_handle(HKEY_LOCAL_MACHINE, "HKLM"); insert_handle(HKEY_CURRENT_USER, "HKCU"); }
int get_hook(const TCHAR *service_name, const TCHAR *hook_event, const TCHAR *hook_action, TCHAR *buffer, unsigned long buflen) { /* Try to open the registry */ TCHAR registry[KEY_LENGTH]; if (_sntprintf_s(registry, _countof(registry), _TRUNCATE, _T("%s\\%s"), NSSM_REG_HOOK, hook_event) < 0) { log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, _T("hook registry"), _T("get_hook()"), 0); return 1; } HKEY key; long error = open_registry(service_name, registry, KEY_READ, &key, false); if (! key) { if (error == ERROR_FILE_NOT_FOUND) { ZeroMemory(buffer, buflen); return 0; } return 1; } int ret = expand_parameter(key, (TCHAR *) hook_action, buffer, buflen, true, false); /* Close registry */ RegCloseKey(key); return ret; }
int main(int argc, char *argv[]) { int i; long type = REG_SZ; char c, path[256], key[256], *value = NULL; HKEY root = 0; int Option_Index; int list = 0, del = 0; int newkey, status; static struct option Long_Options[] = { {"registry", 1, 0, 'r'}, {"list", 0, 0, 'l'}, {"key", 1, 0, 'k'}, {"value", 1, 0, 'v'}, {"type", 1, 0, 't'}, {"del", 0, 0, 'd'}, }; while(1) { c = getopt_long(argc, argv, "r:lk:v:t:id", Long_Options, &Option_Index); if (c == EOF) break; switch(c) { case 'r': localregpathname = optarg; break; case 'l': list = 1; break; case 'k': parse_key(optarg, &root, path, key); break; case 'v': value = optarg; break; case 't': if (!strcmp(optarg, "string")) type = REG_SZ; else if (!strcmp(optarg, "dword")) type = REG_DWORD; break; case 'd': del = 1; break; } } if (localregpathname == NULL || (! list && ! root)) { printf("Must specify '-r' and either '-k' or '-l'\n"); return 1; } if (del && (list || value)) { printf("Can't specify '-d' along with '-l' or '-v'\n"); return 1; } open_registry(); insert_handle(HKEY_LOCAL_MACHINE, "HKLM"); insert_handle(HKEY_CURRENT_USER, "HKCU"); if (del) { char tmpname[256]; sprintf(tmpname, "%s\\%s", path, key); remove_key(root, tmpname); return 0; } if (list) { for (i=0; i < reg_size; i++) { if (regs[i].type == DIR) { printf("Directory: %s\n", regs[i].name); } else if (regs[i].type == REG_DWORD) { DWORD v = *(DWORD *)regs[i].value; printf("%s :: %08x type: DWORD\n", regs[i].name, v); } else if (regs[i].type == REG_SZ) { printf("%s :: '%s' len: %d type: String\n", regs[i].name, regs[i].value, regs[i].len); } else { printf("%s :: '%s' len: %d type: %08x\n", regs[i].name, regs[i].value, regs[i].len, regs[i].type); } } } if (root) { RegCreateKeyExA(root, path, 0, 0, 0, 0, 0, &newkey, &status); if (value != NULL) { int len; DWORD v; if (type == REG_DWORD) { len = sizeof(DWORD); v = strtoul(value, NULL, 0); value = (char *)&v; } else len = strlen(value)+1; printf("%08x -- %d\n", *value, len); RegSetValueExA(newkey, key, 0, type, value, len); } } return 0; }
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; }
HKEY open_registry(const TCHAR *service_name, REGSAM sam) { return open_registry(service_name, 0, sam, true); }
HKEY open_registry(const TCHAR *service_name, const TCHAR *sub, REGSAM sam, bool must_exist) { HKEY key; long error = open_registry(service_name, sub, sam, &key, must_exist); return key; }