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
}