int smpd_set_user_data(const char *key, const char *value) { #ifdef HAVE_WINDOWS_H HKEY tkey; DWORD len, result; char err_msg[512]; smpd_enter_fn(FCNAME); if (key == NULL || value == NULL) { smpd_exit_fn(FCNAME); return SMPD_FAIL; } result = RegCreateKeyEx(HKEY_CURRENT_USER, SMPD_REGISTRY_KEY, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &tkey, NULL); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 512, "Unable to open the HKEY_CURRENT_USER\\" SMPD_REGISTRY_KEY " registry key, error %d: ", result); smpd_err_printf("%s\n", err_msg); smpd_exit_fn(FCNAME); return SMPD_FAIL; } len = (DWORD)(strlen(value)+1); result = RegSetValueEx(tkey, key, 0, REG_SZ, (const BYTE *)value, len); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 512, "Unable to write the user smpd registry value '%s:%s', error %d\n", key, value, result); smpd_err_printf("%s\n", err_msg); RegCloseKey(tkey); smpd_exit_fn(FCNAME); return SMPD_FAIL; } result = RegCloseKey(tkey); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 512, "Unable to close the HKEY_CURRENT_USER\\" SMPD_REGISTRY_KEY " registry key, error %d: ", result); smpd_err_printf("%s\n", err_msg); smpd_exit_fn(FCNAME); return SMPD_FAIL; } smpd_exit_fn(FCNAME); return SMPD_SUCCESS; #else int result; smpd_enter_fn(FCNAME); result = smpd_set_smpd_data(key, value); smpd_exit_fn(FCNAME); return result; #endif }
int smpd_get_user_data(const char *key, char *value, int value_len) { #ifdef HAVE_WINDOWS_H HKEY tkey; DWORD len, result; char err_msg[512]; smpd_enter_fn(FCNAME); result = RegOpenKeyEx(HKEY_CURRENT_USER, SMPD_REGISTRY_KEY, 0, KEY_READ, &tkey); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 512, "Unable to open the HKEY_CURRENT_USER\\" SMPD_REGISTRY_KEY " registry key, error %d\n", result); smpd_dbg_printf("%s\n", err_msg); result = smpd_get_user_data_default(key, value, value_len); smpd_exit_fn(FCNAME); return result; } len = value_len; result = RegQueryValueEx(tkey, key, 0, NULL, (unsigned char *)value, &len); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 512, "Unable to read the smpd registry key '%s', error %d\n", key, result); smpd_dbg_printf("%s\n", err_msg); RegCloseKey(tkey); result = smpd_get_user_data_default(key, value, value_len); smpd_exit_fn(FCNAME); return result; } result = RegCloseKey(tkey); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 512, "Unable to close the HKEY_CURRENT_USER\\" SMPD_REGISTRY_KEY " registry key, error %d: ", result); smpd_err_printf("%s\n", err_msg); smpd_exit_fn(FCNAME); return SMPD_FAIL; } smpd_exit_fn(FCNAME); return SMPD_SUCCESS; #else int result; smpd_enter_fn(FCNAME); result = smpd_get_smpd_data(key, value, value_len); if (result != SMPD_SUCCESS) { result = smpd_get_user_data_default(key, value, value_len); } smpd_exit_fn(FCNAME); return result; #endif }
int smpd_delete_user_data(const char *key) { #ifdef HAVE_WINDOWS_H HKEY tkey; DWORD result; char err_msg[512]; smpd_enter_fn(FCNAME); if (key == NULL) { smpd_exit_fn(FCNAME); return SMPD_FAIL; } result = RegCreateKeyEx(HKEY_CURRENT_USER, SMPD_REGISTRY_KEY, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &tkey, NULL); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 512, "Unable to open the HKEY_CURRENT_USER\\" SMPD_REGISTRY_KEY " registry key, error %d: ", result); smpd_err_printf("%s\n", err_msg); smpd_exit_fn(FCNAME); return SMPD_FAIL; } result = RegDeleteValue(tkey, key); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 512, "Unable to delete the user smpd registry value '%s', error %d: ", key, result); smpd_err_printf("%s\n", err_msg); RegCloseKey(tkey); smpd_exit_fn(FCNAME); return SMPD_FAIL; } result = RegCloseKey(tkey); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 512, "Unable to close the HKEY_CURRENT_USER\\" SMPD_REGISTRY_KEY " registry key, error %d: ", result); smpd_err_printf("%s\n", err_msg); smpd_exit_fn(FCNAME); return SMPD_FAIL; } smpd_exit_fn(FCNAME); return SMPD_SUCCESS; #else int result; smpd_enter_fn(FCNAME); result = smpd_delete_smpd_data(key); smpd_exit_fn(FCNAME); return result; #endif }
int smpd_watch_processes() { HANDLE hThread; char line[1024], cmd[1024]; int result; /* turn off extra error output */ smpd_process.dbg_state ^= SMPD_DBG_STATE_TRACE; smpd_process.dbg_state ^= SMPD_DBG_STATE_PREPEND_RANK; hQuit = CreateEvent(NULL, TRUE, FALSE, NULL); if (hQuit == NULL) { result = GetLastError(); smpd_translate_win_error(result, line, 1024, NULL); smpd_err_printf("CreateEvent failed: %s\n", line); goto fn_exit; } hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)smpd_watch_processes_thread, NULL, 0, NULL); if (hThread == NULL) { printf("Unable to create a thread to watch the processes, exiting...\n"); fflush(stdout); goto fn_exit; } while (fgets(line, 1024, stdin) != NULL) { line[1023] = '\0'; cmd[0] = '\0'; result = sscanf(line, "%s", cmd); if (result == EOF) { goto fn_exit; } if (stricmp(cmd, "start") == 0) { bPrint = SMPD_TRUE; } if (stricmp(cmd, "stop") == 0) { bPrint = SMPD_FALSE; } if ((stricmp(cmd, "quit") == 0) || (stricmp(cmd, "exit") == 0)) { SetEvent(hQuit); WaitForSingleObject(hThread, INFINITE); break; } } fn_exit: if (hThread != NULL) CloseHandle(hThread); if (hQuit != NULL) CloseHandle(hQuit); return SMPD_SUCCESS; }
int smpd_lookup_spn(char *target, int length, const char *host, int port) { int result; char err_msg[256]; ULONG len = length/*SMPD_MAX_NAME_LENGTH*/; char *env; smpd_host_spn_node_t *iter; env = getenv("MPICH_SPN"); if (env) { MPIU_Strncpy(target, env, SMPD_MAX_NAME_LENGTH); return SMPD_SUCCESS; } smpd_build_spn_list(); iter = spn_list; while (iter != NULL) { if (stricmp(iter->host, host) == 0) { MPIU_Strncpy(target, iter->spn, SMPD_MAX_NAME_LENGTH); return SMPD_SUCCESS; } if (stricmp(iter->dnshost, host) == 0) { MPIU_Strncpy(target, iter->spn, SMPD_MAX_NAME_LENGTH); return SMPD_SUCCESS; } iter = iter->next; } result = DsMakeSpn(SMPD_SERVICE_NAME, NULL, host, (USHORT)port, NULL, &len, target); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 255, NULL); smpd_err_printf("DsMakeSpn(%s, %s, %d) failed: %s\n", SMPD_SERVICE_NAME, host, port, err_msg); return SMPD_FAIL; } /*result = DsMakeSpn(SMPD_SERVICE_NAME, SMPD_SERVICE_NAME, NULL, 0, NULL, &len, target);*/ /* char **spns; result = DsGetSpn(DS_SPN_DNS_HOST, SMPD_SERVICE_NAME, NULL, port, 1, &host, NULL, &len, &spns); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 255, NULL); smpd_err_printf("DsGetSpn failed: %s\n", err_msg); return SMPD_FAIL; } MPIU_Strncpy(target, spns[0], SMPD_MAX_NAME_LENGTH); DsFreeSpnArray(1, spns); */ /*MPIU_Snprintf(target, SMPD_MAX_NAME_LENGTH, "%s/%s:%d", SMPD_SERVICE_NAME, host, port);*/ return SMPD_SUCCESS; }
int smpd_restart() { #ifdef HAVE_WINDOWS_H int error; char szExe[1024]; char pszStr[2048]; STARTUPINFO sInfo; PROCESS_INFORMATION pInfo; if (!GetModuleFileName(NULL, szExe, 1024)) { smpd_translate_win_error(GetLastError(), pszStr, 2048, "GetModuleFileName failed.\nError: "); return SMPD_FAIL; } /* Warning: This function can raise an exception */ GetStartupInfo(&sInfo); snprintf(pszStr, 2048, "\"%s\" -restart", szExe); if (!CreateProcess(NULL, pszStr, NULL, NULL, FALSE, DETACHED_PROCESS, NULL, NULL, &sInfo, &pInfo)) { error = GetLastError(); printf("CreateProcess failed for '%s'\n", pszStr); smpd_translate_win_error(error, pszStr, 2048, "Error: "); return SMPD_FAIL; } CloseHandle(pInfo.hProcess); CloseHandle(pInfo.hThread); #else /* close all fd's */ /* exec a new smpd? */ #endif return SMPD_SUCCESS; }
int smpd_unlock_smpd_data(void) { smpd_enter_fn(FCNAME); #ifdef HAVE_WINDOWS_H if (!ReleaseMutex(smpd_process.hSMPDDataMutex)) { int result; char err_msg[512]; result = GetLastError(); smpd_translate_win_error(result, err_msg, 512, "Unable to release the SMPD data mutex, error %d: ", result); smpd_err_printf("%s\n", err_msg); return SMPD_FAIL; } #else /* No lock implemented for Unix systems */ #endif smpd_exit_fn(FCNAME); return SMPD_SUCCESS; }
int smpd_register_spn(const char *dc, const char *dn, const char *dh) { DWORD len; char err_msg[256]; LPSTR *spns; HANDLE ds; DWORD result; char domain_controller[SMPD_MAX_HOST_LENGTH] = ""; char domain_name[SMPD_MAX_HOST_LENGTH] = ""; char domain_host[SMPD_MAX_HOST_LENGTH] = ""; char host[SMPD_MAX_HOST_LENGTH] = ""; int really = 0; char *really_env; PDOMAIN_CONTROLLER_INFO pInfo; result = DsGetDcName(NULL/*local computer*/, NULL, NULL, NULL, /*DS_IS_FLAT_NAME | DS_RETURN_DNS_NAME | DS_DIRECTORY_SERVICE_REQUIRED, */ DS_DIRECTORY_SERVICE_REQUIRED | DS_KDC_REQUIRED, &pInfo); if (result == ERROR_SUCCESS) { strcpy(domain_controller, pInfo->DomainControllerName); strcpy(domain_name, pInfo->DomainName); NetApiBufferFree(pInfo); } if (dc && *dc != '\0') { strcpy(domain_controller, dc); } if (dn && *dn != '\0') { strcpy(domain_name, dn); } if (dh && *dh != '\0') { strcpy(domain_host, dh); } if (domain_host[0] == '\0') { smpd_get_hostname(host, SMPD_MAX_HOST_LENGTH); if (domain_name[0] != '\0') { sprintf(domain_host, "%s\\%s", domain_name, host); } else { strcpy(domain_host, host); } } printf("DsBind(%s, %s, ...)\n", domain_controller[0] == '\0' ? NULL : domain_controller, domain_name[0] == '\0' ? NULL : domain_name); result = DsBind( domain_controller[0] == '\0' ? NULL : domain_controller, domain_name[0] == '\0' ? NULL : domain_name, &ds); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 256, NULL); smpd_err_printf("DsBind failed: %s\n", err_msg); return SMPD_FAIL; } really_env = getenv("really"); if (really_env) really = 1; #if 1 len = 1; /*result = DsGetSpn(DS_SPN_SERVICE, SMPD_SERVICE_NAME, SMPD_SERVICE_NAME, 0, 0, NULL, NULL, &len, &spns);*/ result = DsGetSpn(DS_SPN_DNS_HOST, SMPD_SERVICE_NAME, NULL, SMPD_LISTENER_PORT, 0, NULL, NULL, &len, &spns); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 256, NULL); smpd_err_printf("DsGetSpn failed: %s\n", err_msg); return SMPD_FAIL; } if (really) { printf("registering: %s\n", spns[0]); len = SMPD_MAX_HOST_LENGTH; GetComputerObjectName(NameFullyQualifiedDN, domain_host, &len); printf("on account: %s\n", domain_host); result = DsWriteAccountSpn(ds, DS_SPN_ADD_SPN_OP, domain_host, 1, (LPCSTR*)spns); if (result != ERROR_SUCCESS) { DsFreeSpnArray(1, spns); smpd_translate_win_error(result, err_msg, 256, NULL); smpd_err_printf("DsWriteAccountSpn failed: %s\n", err_msg); return SMPD_FAIL; } } else { printf("would register '%s' on %s\n", spns[0], domain_host); } DsFreeSpnArray(1, spns); #else if (really) { result = DsServerRegisterSpn(DS_SPN_ADD_SPN_OP, SMPD_SERVICE_NAME, domain_host); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 256, NULL); smpd_err_printf("DsServerRegisterSpn failed: %s\n", err_msg); return SMPD_FAIL; } } else { printf("would register '%s' on %s\n", SMPD_SERVICE_NAME, domain_host); } #endif result = DsUnBind(&ds); return SMPD_SUCCESS; }
int smpd_watch_processes_thread() { HKEY hKey, hProcKey; char name[100]; char value[1024]; DWORD len; DWORD index; HANDLE hRegEvent; HANDLE hEvents[2]; FILETIME t; DWORD result; smpd_registry_proc *node, *trailer, *temp_list, *list = NULL; smpd_enter_fn(FCNAME); restart: hRegEvent = CreateEvent(NULL, TRUE, FALSE, NULL); if (hRegEvent == NULL) { result = GetLastError(); smpd_translate_win_error(result, value, 1024, NULL); smpd_err_printf("CreateEvent failed: %s\n", value); return SMPD_FAIL; } if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SOFTWARE\\MPICH\\SMPD\\process", 0, KEY_READ, &hKey) == ERROR_SUCCESS) { for (;;) { result = RegNotifyChangeKeyValue(hKey, FALSE, REG_NOTIFY_CHANGE_NAME, hRegEvent, TRUE); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, value, 1024, NULL); smpd_err_printf("RegNotifyChangeKeyValue(SOFTWARE\\MPICH\\SMPD\\process) failed: %s\n", value); /*printf("result = %d\n", result);*/ RegCloseKey(hKey); break; } index = 0; len = 100; temp_list = NULL; for(;;) { result = RegEnumKeyEx(hKey, index, name, &len, NULL, NULL, NULL, &t); if (result == ERROR_NO_MORE_ITEMS) break; if (result != ERROR_SUCCESS) break; if (len > 0) { if (RegOpenKeyEx(hKey, name, 0, KEY_READ, &hProcKey) == ERROR_SUCCESS) { len = 1024; if (RegQueryValueEx(hProcKey, "exe", NULL, NULL, (LPBYTE)value, &len) == ERROR_SUCCESS) { node = MPIU_Malloc(sizeof(smpd_registry_proc)); strcpy(node->pid, name); if (len > 0) strcpy(node->exe, value); else node->exe[0] = '\0'; node->next = temp_list; temp_list = node; } RegCloseKey(hProcKey); } } index++; len = 100; } node = list; while (node != NULL) { node->handled = SMPD_FALSE; node = node->next; } while (temp_list) { node = list; while (node) { if (strcmp(node->pid, temp_list->pid) == 0) { node->handled = SMPD_TRUE; break; } node = node->next; } if (node == NULL) { node = temp_list; temp_list = temp_list->next; node->next = list; list = node; node->handled = SMPD_TRUE; if (bPrint) { printf("+%s %s\n", node->pid, node->exe); fflush(stdout); } } else { node = temp_list; temp_list = temp_list->next; MPIU_Free(node); } } trailer = node = list; while (node != NULL) { if (node->handled == SMPD_FALSE) { if (bPrint) { printf("-%s %s\n", node->pid, node->exe); fflush(stdout); } if (trailer != node) { trailer->next = node->next; MPIU_Free(node); node = trailer->next; } else { list = list->next; trailer = list; MPIU_Free(node); node = list; } } else { if (trailer != node) trailer = trailer->next; node = node->next; } } hEvents[0] = hQuit; hEvents[1] = hRegEvent; result = WaitForMultipleObjects(2, hEvents, FALSE, INFINITE); if (result < WAIT_OBJECT_0 || result > WAIT_OBJECT_0 + 2) { if (result == WAIT_FAILED) { result = GetLastError(); smpd_translate_win_error(result, value, 1024, NULL); smpd_err_printf("WaitForMultipleObjects failed: %s\n", value); /* printf("hQuit = %p\n", hQuit); printf("hRegEvent = %p\n", hRegEvent); fflush(stdout); */ } else if (result == WAIT_TIMEOUT) { smpd_err_printf("WaitFoMultipleObjects timed out\n"); } else if (result == WAIT_ABANDONED_0) { smpd_err_printf("WaitForMultipleObjects abandoned due to the hQuit event.\n"); } else if (result == (WAIT_ABANDONED_0 + 1)) { smpd_err_printf("WaitForMultipleObjects abandoned due to the hRegEvent.\n"); } else { smpd_err_printf("WaitForMultipleObjects returned an unexpected value: %d\n", result); } RegCloseKey(hKey); break; } if (WaitForSingleObject(hQuit, 0) == WAIT_OBJECT_0) { RegCloseKey(hKey); break; } /* result = WaitForSingleObject(hRegEvent, INFINITE); if (result != WAIT_OBJECT_0) { RegCloseKey(hKey); break; } */ if (!ResetEvent(hRegEvent)) { result = GetLastError(); smpd_translate_win_error(result, value, 1024, NULL); smpd_err_printf("ResetEvent failed: %s\n", value); return SMPD_FAIL; } } } else { if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SOFTWARE\\MPICH\\SMPD", 0, KEY_READ, &hKey) == ERROR_SUCCESS) { for(;;) { result = RegNotifyChangeKeyValue(hKey, FALSE, REG_NOTIFY_CHANGE_NAME, hRegEvent, TRUE); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, value, 1024, NULL); smpd_err_printf("RegNotifyChangeKeyValue(SOFTWARE\\MPICH\\SMPD) failed: %s\n", value); /*printf("result = %d\n", result);*/ RegCloseKey(hKey); break; } index = 0; len = 100; for(;;) { result = RegEnumKeyEx(hKey, index, name, &len, NULL, NULL, NULL, &t); if (result == ERROR_NO_MORE_ITEMS) break; if (result != ERROR_SUCCESS) break; if (len > 0) { if (strcmp(name, "process") == 0) { CloseHandle(hRegEvent); RegCloseKey(hKey); goto restart; } } index++; len = 100; } hEvents[0] = hQuit; hEvents[1] = hRegEvent; result = WaitForMultipleObjects(2, hEvents, FALSE, INFINITE); if (result < WAIT_OBJECT_0 || result > WAIT_OBJECT_0 + 2) { if (result == WAIT_FAILED) { result = GetLastError(); smpd_translate_win_error(result, value, 1024, NULL); smpd_err_printf("WaitForMultipleObjects failed: %s\n", value); /* printf("hQuit = %p\n", hQuit); printf("hRegEvent = %p\n", hRegEvent); fflush(stdout); */ } else if (result == WAIT_TIMEOUT) { smpd_err_printf("WaitFoMultipleObjects timed out\n"); } else if (result == WAIT_ABANDONED_0) { smpd_err_printf("WaitForMultipleObjects abandoned due to the hQuit event.\n"); } else if (result == (WAIT_ABANDONED_0 + 1)) { smpd_err_printf("WaitForMultipleObjects abandoned due to the hRegEvent.\n"); } else { smpd_err_printf("WaitForMultipleObjects returned an unexpected value: %d\n", result); } RegCloseKey(hKey); break; } if (WaitForSingleObject(hQuit, 0) == WAIT_OBJECT_0) { RegCloseKey(hKey); break; } /* result = WaitForSingleObject(hRegEvent, INFINITE); if (result != WAIT_OBJECT_0) { RegCloseKey(hKey); break; } */ ResetEvent(hRegEvent); } } } CloseHandle(hRegEvent); smpd_exit_fn(FCNAME); return SMPD_SUCCESS; }
int smpd_get_all_smpd_data(smpd_data_t **data) { #ifdef HAVE_WINDOWS_H HKEY tkey; DWORD result; LONG enum_result; char name[SMPD_MAX_NAME_LENGTH], value[SMPD_MAX_VALUE_LENGTH]; DWORD name_length, value_length, index; smpd_data_t *list, *item; char err_msg[512]; smpd_enter_fn(FCNAME); if (data == NULL) { smpd_exit_fn(FCNAME); return SMPD_FAIL; } result = RegOpenKeyEx(HKEY_LOCAL_MACHINE, SMPD_REGISTRY_KEY, 0, KEY_READ, &tkey); if (result != ERROR_SUCCESS) { /* No key therefore no settings */ /* No access to the key, therefore no soup for you */ *data = NULL; smpd_exit_fn(FCNAME); return SMPD_SUCCESS; } list = NULL; index = 0; name_length = SMPD_MAX_NAME_LENGTH; value_length = SMPD_MAX_VALUE_LENGTH; enum_result = RegEnumValue(tkey, index, name, &name_length, NULL, NULL, (LPBYTE)value, &value_length); while (enum_result == ERROR_SUCCESS) { item = (smpd_data_t*)MPIU_Malloc(sizeof(smpd_data_t)); if (item == NULL) { *data = NULL; result = RegCloseKey(tkey); smpd_exit_fn(FCNAME); return SMPD_FAIL; } memcpy(item->name, name, SMPD_MAX_NAME_LENGTH); memcpy(item->value, value, SMPD_MAX_VALUE_LENGTH); item->next = list; list = item; index++; name_length = SMPD_MAX_NAME_LENGTH; value_length = SMPD_MAX_VALUE_LENGTH; enum_result = RegEnumValue(tkey, index, name, &name_length, NULL, NULL, (LPBYTE)value, &value_length); } result = RegCloseKey(tkey); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 512, "Unable to close the HKEY_LOCAL_MACHINE\\" SMPD_REGISTRY_KEY " registry key, error %d: ", result); smpd_err_printf("%s\n", err_msg); smpd_exit_fn(FCNAME); return SMPD_FAIL; } *data = list; smpd_exit_fn(FCNAME); return SMPD_SUCCESS; #else smpd_enter_fn(FCNAME); if (data == NULL) { smpd_exit_fn(FCNAME); return SMPD_FAIL; } *data = NULL; smpd_exit_fn(FCNAME); return SMPD_FAIL; #endif }
int smpd_get_smpd_data(const char *key, char *value, int value_len) { #ifdef HAVE_WINDOWS_H HKEY tkey; DWORD len, result; char err_msg[512]; smpd_enter_fn(FCNAME); if (smpd_get_smpd_data_from_environment(key, value, value_len) == SMPD_TRUE) { smpd_exit_fn(FCNAME); return SMPD_SUCCESS; } result = RegOpenKeyEx(HKEY_LOCAL_MACHINE, SMPD_REGISTRY_KEY, 0, KEY_READ, &tkey); if (result != ERROR_SUCCESS) { if (smpd_get_smpd_data_default(key, value, value_len) != SMPD_SUCCESS) { smpd_dbg_printf("Unable to get the data for the key '%s'\n", key); smpd_exit_fn(FCNAME); return SMPD_FAIL; } smpd_exit_fn(FCNAME); return SMPD_SUCCESS; } len = value_len; result = RegQueryValueEx(tkey, key, 0, NULL, (unsigned char *)value, &len); if (result != ERROR_SUCCESS) { RegCloseKey(tkey); if (smpd_get_smpd_data_default(key, value, value_len) != SMPD_SUCCESS) { smpd_dbg_printf("Unable to get the data for the key '%s'\n", key); smpd_exit_fn(FCNAME); return SMPD_FAIL; } smpd_exit_fn(FCNAME); return SMPD_SUCCESS; } result = RegCloseKey(tkey); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 512, "Unable to close the HKEY_LOCAL_MACHINE\\" SMPD_REGISTRY_KEY " registry key, error %d: ", result); smpd_err_printf("%s\n", err_msg); smpd_exit_fn(FCNAME); return SMPD_FAIL; } smpd_exit_fn(FCNAME); return SMPD_SUCCESS; #else int result; smpd_data_t *list = NULL, *node; int num_bytes; smpd_enter_fn(FCNAME); smpd_dbg_printf("getting smpd data: %s\n", key); if (smpd_get_smpd_data_from_environment(key, value, value_len) == SMPD_TRUE) { smpd_exit_fn(FCNAME); return SMPD_SUCCESS; } list = smpd_parse_smpd_file(); if (list) { int found = 0; while (list) { node = list; list = list->next; if (strcmp(key, node->name) == 0) { strcpy(value, node->value); smpd_dbg_printf("smpd data: %s=%s\n", key, value); found = 1; } MPIU_Free(node); } if (found) { smpd_exit_fn(FCNAME); return SMPD_SUCCESS; } } result = smpd_get_smpd_data_default(key, value, value_len); if (result == SMPD_SUCCESS) { smpd_dbg_printf("smpd data: %s=%s\n", key, value); } else { smpd_dbg_printf("smpd data: failed to get %s\n", key); } smpd_exit_fn(FCNAME); return result; #endif }
int smpd_set_smpd_data(const char *key, const char *value) { #ifdef HAVE_WINDOWS_H HKEY tkey; DWORD len, result; char err_msg[512]; smpd_enter_fn(FCNAME); if (key == NULL || value == NULL) { smpd_exit_fn(FCNAME); return SMPD_FAIL; } result = RegCreateKeyEx(HKEY_LOCAL_MACHINE, SMPD_REGISTRY_KEY, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &tkey, NULL); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 512, "Unable to open the HKEY_LOCAL_MACHINE\\" SMPD_REGISTRY_KEY " registry key, error %d\n", result); smpd_err_printf("%s\n", err_msg); smpd_exit_fn(FCNAME); return SMPD_FAIL; } len = (DWORD)(strlen(value)+1); result = RegSetValueEx(tkey, key, 0, REG_SZ, (const BYTE *)value, len); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 512, "Unable to write the smpd registry value '%s:%s', error %d\n", key, value, result); smpd_err_printf("%s\n", err_msg); RegCloseKey(tkey); smpd_exit_fn(FCNAME); return SMPD_FAIL; } result = RegCloseKey(tkey); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 512, "Unable to close the HKEY_LOCAL_MACHINE\\" SMPD_REGISTRY_KEY " registry key, error %d: ", result); smpd_err_printf("%s\n", err_msg); smpd_exit_fn(FCNAME); return SMPD_FAIL; } smpd_exit_fn(FCNAME); return SMPD_SUCCESS; #else int result; smpd_data_t *list = NULL, *node; int found = 0; FILE *fout; char *str; int maxlen; char buffer[1024]; char name_str[SMPD_MAX_NAME_LENGTH]; char value_str[SMPD_MAX_VALUE_LENGTH]; smpd_enter_fn(FCNAME); smpd_dbg_printf("setting smpd data: %s=%s\n", key, value); list = smpd_parse_smpd_file(); fout = smpd_open_smpd_file(SMPD_TRUE); if (fout == NULL) { smpd_err_printf("Unable to open the .smpd file\n"); smpd_exit_fn(FCNAME); return SMPD_FAIL; } while (list) { node = list; list = list->next; if (strcmp(key, node->name) == 0) { strcpy(node->value, value); found = 1; } if (fout) { str = buffer; maxlen = 1024; if (MPIU_Str_add_string_arg(&str, &maxlen, node->name, node->value) == MPIU_STR_SUCCESS) { buffer[strlen(buffer)-1] = '\0'; /* remove the trailing space */ smpd_dbg_printf("writing '%s' to .smpd file\n", buffer); fprintf(fout, "%s\n", buffer); } } MPIU_Free(node); } if (!found && fout) { str = buffer; maxlen = 1024; if (MPIU_Str_add_string_arg(&str, &maxlen, key, value) == MPIU_STR_SUCCESS) { buffer[strlen(buffer)-1] = '\0'; /* remove the trailing space */ smpd_dbg_printf("writing '%s' to .smpd file\n", buffer); fprintf(fout, "%s\n", buffer); } fclose(fout); smpd_exit_fn(FCNAME); return SMPD_SUCCESS; } if (fout != NULL) { fclose(fout); smpd_exit_fn(FCNAME); return SMPD_SUCCESS; } smpd_exit_fn(FCNAME); return SMPD_FAIL; #endif }
int smpd_delete_smpd_data(const char *key) { #ifdef HAVE_WINDOWS_H HKEY tkey; DWORD result; char err_msg[512]; smpd_enter_fn(FCNAME); if (key == NULL) { smpd_exit_fn(FCNAME); return SMPD_FAIL; } result = RegCreateKeyEx(HKEY_LOCAL_MACHINE, SMPD_REGISTRY_KEY, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &tkey, NULL); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 512, "Unable to open the HKEY_CURRENT_USER\\" SMPD_REGISTRY_KEY " registry key, error %d: ", result); smpd_err_printf("%s\n", err_msg); smpd_exit_fn(FCNAME); return SMPD_FAIL; } result = RegDeleteValue(tkey, key); if (result != ERROR_SUCCESS) { if (result != ERROR_FILE_NOT_FOUND && result != ERROR_PATH_NOT_FOUND) { smpd_translate_win_error(result, err_msg, 512, "Unable to delete the smpd registry value '%s', error %d: ", key, result); smpd_err_printf("%s\n", err_msg); RegCloseKey(tkey); smpd_exit_fn(FCNAME); return SMPD_FAIL; } } result = RegCloseKey(tkey); if (result != ERROR_SUCCESS) { smpd_translate_win_error(result, err_msg, 512, "Unable to close the HKEY_CURRENT_USER\\" SMPD_REGISTRY_KEY " registry key, error %d: ", result); smpd_err_printf("%s\n", err_msg); smpd_exit_fn(FCNAME); return SMPD_FAIL; } smpd_exit_fn(FCNAME); return SMPD_SUCCESS; #else int result; smpd_data_t *list = NULL, *node, *trailer; int num_bytes; int found = 0; smpd_enter_fn(FCNAME); list = smpd_parse_smpd_file(); node = trailer = list; while (node) { if (strcmp(key, node->name) == 0) { if (trailer != node) { trailer->next = node->next; } else { list = list->next; } found = 1; MPIU_Free(node); break; } if (trailer != node) { trailer = trailer->next; } node = node->next; } if (found) { FILE *fout; char buffer[1024]; char *str; int maxlen; fout = smpd_open_smpd_file(SMPD_TRUE); if (fout) { while (list) { str = buffer; maxlen = 1024; if (MPIU_Str_add_string_arg(&str, &maxlen, list->name, list->value) == MPIU_STR_SUCCESS) { buffer[strlen(buffer)-1] = '\0'; /* remove the trailing space */ fprintf(fout, "%s\n", buffer); } node = list; list = list->next; MPIU_Free(node); } fclose(fout); smpd_exit_fn(FCNAME); return SMPD_SUCCESS; } } while (list) { node = list; list = list->next; MPIU_Free(node); } smpd_exit_fn(FCNAME); return SMPD_SUCCESS; #endif }