smpd_user_data.c

fortran并行计算包

/* -*- Mode: C; c-basic-offset:4 ; -*- */
/*
 *  (C) 2001 by Argonne National Laboratory.
 *      See COPYRIGHT in top-level directory.
 */

#include "smpd.h"
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#include <stdlib.h>

#ifndef HAVE_WINDOWS_H
static FILE * smpd_open_smpd_file(SMPD_BOOL create);
static void str_replace(char *str, char *find_chars, char replace_char);

#undef FCNAME
#define FCNAME "smpd_open_smpd_file"
static FILE * smpd_open_smpd_file(SMPD_BOOL create)
{
    char *homedir;
    struct stat s;
    FILE *fin = NULL;

    smpd_enter_fn(FCNAME);
    if (smpd_process.smpd_filename[0] == '\0')
    {
	homedir = getenv("HOME");
	if (homedir != NULL)
	{
	    strcpy(smpd_process.smpd_filename, homedir);
	    if (smpd_process.smpd_filename[strlen(smpd_process.smpd_filename)-1] != '/')
	    {
		strcat(smpd_process.smpd_filename, "/.smpd");
	    }
	    else
	    {
		strcat(smpd_process.smpd_filename, ".smpd");
	    }
	}
	else
	{
	    strcpy(smpd_process.smpd_filename, ".smpd");
	}
    }
    if (stat(smpd_process.smpd_filename, &s) == 0)
    {
	if (s.st_mode & 00077)
	{
	    printf(".smpd file, %s, cannot be readable by anyone other than the current user, please set the permissions accordingly (0600).\n", smpd_process.smpd_filename);
	}
	else
	{
	    if (create)
	    {
		fin = fopen(smpd_process.smpd_filename, "w");
	    }
	    else
	    {
		fin = fopen(smpd_process.smpd_filename, "r+");
	    }
	}
    }
    if (fin == NULL && create)
    {
	umask(077);
	fin = fopen(smpd_process.smpd_filename, "w");
    }
    smpd_exit_fn(FCNAME);
    return fin;
}

#undef FCNAME
#define FCNAME "str_replace"
static void str_replace(char *str, char *find_chars, char replace_char)
{
    char *cur_str;
    int i;

    smpd_enter_fn(FCNAME);
    for (i=0; i<strlen(find_chars); i++)
    {
	cur_str = strchr(str, find_chars[i]);
	while (cur_str)
	{
	    *cur_str = replace_char;
	    cur_str = strchr(cur_str, find_chars[i]);
	}
    }
    smpd_exit_fn(FCNAME);
}

#undef FCNAME
#define FCNAME "smpd_parse_smpd_file"
static smpd_data_t * smpd_parse_smpd_file()
{
    FILE *fin;
    char *buffer;
    int len;
    smpd_data_t *list = NULL, *node;
    char *iter;
    char name[SMPD_MAX_NAME_LENGTH];
    char equal_str[SMPD_MAX_NAME_LENGTH];
    char data[SMPD_MAX_VALUE_LENGTH];
    int num_chars;
    int result;

    smpd_enter_fn(FCNAME);
    fin = smpd_open_smpd_file(SMPD_FALSE);
    if (fin != NULL)
    {
	result = fseek(fin, 0, SEEK_END);
	if (result != 0)
	{
	    smpd_err_printf("Unable to seek to the end of the .smpd file.\n");
	    smpd_exit_fn(FCNAME);
	    return NULL;
	}
	len = ftell(fin);
	if (len == -1)
	{
	    smpd_err_printf("Unable to determine the length of the .smpd file, ftell returned -1 and errno = %d.\n", errno);
	    smpd_exit_fn(FCNAME);
	    return NULL;
	}
	result = fseek(fin, 0, SEEK_SET);
	if (result != 0)
	{
	    smpd_err_printf("Unable to seek to the beginning of the .smpd file.\n");
	    smpd_exit_fn(FCNAME);
	    return NULL;
	}
	if (len > 0)
	{
	    buffer = (char*)MPIU_Malloc(len+1);
	    if (buffer == NULL)
	    {
		smpd_err_printf("Unable to allocate a buffer of length %d, malloc failed.\n", len+1);
		smpd_exit_fn(FCNAME);
		return NULL;
	    }
	    iter = buffer;
	    if ((len = (int)fread(buffer, 1, len, fin)) > 0)
	    {
		buffer[len] = '\0';
		str_replace(buffer, "\r\n", SMPD_SEPAR_CHAR);
		while (iter)
		{
		    result = MPIU_Str_get_string(&iter, name, SMPD_MAX_NAME_LENGTH);
		    if (result != MPIU_STR_SUCCESS)
		    {
			smpd_exit_fn(FCNAME);
			return NULL;
		    }
		    equal_str[0] = '\0';
		    result = MPIU_Str_get_string(&iter, equal_str, SMPD_MAX_NAME_LENGTH);
		    while (iter && equal_str[0] != MPIU_STR_DELIM_CHAR)
		    {
			strcpy(name, equal_str);
			result = MPIU_Str_get_string(&iter, equal_str, SMPD_MAX_NAME_LENGTH);
			if (result != MPIU_STR_SUCCESS)
			{
			    smpd_exit_fn(FCNAME);
			    return NULL;
			}
		    }
		    data[0] = '\0';
		    result = MPIU_Str_get_string(&iter, data, SMPD_MAX_VALUE_LENGTH);
		    /*smpd_dbg_printf("parsed <%s> <%s> <%s>\n", name, equal_str, data);*/
		    if (result == MPIU_STR_SUCCESS)
		    {
			node = (smpd_data_t*)MPIU_Malloc(sizeof(smpd_data_t));
			if (node == NULL)
			{
			    smpd_err_printf("Unable to allocate a smpd_data_t node, malloc failed.\n");
			    smpd_exit_fn(FCNAME);
			    return list; /* Should we return NULL or the current number of parsed options? */
			}
			strcpy(node->name, name);
			strcpy(node->value, data);
			node->next = list;
			list = node;
		    }
		}
	    }
	    else
	    {
		printf("Unable to read the contents of %s.\n", smpd_process.smpd_filename);
	    }
	    MPIU_Free(buffer);
	}
	fclose(fin);
    }
    smpd_exit_fn(FCNAME);
    return list;
}
#endif

#undef FCNAME
#define FCNAME "smpd_is_affirmative"
SMPD_BOOL smpd_is_affirmative(const char *str)
{
    const char *iter = str;

    smpd_enter_fn(FCNAME);
    if (*iter != 'y' && *iter != 'Y')
    {
	smpd_exit_fn(FCNAME);
	return SMPD_FALSE;
    }
    iter++;
    if (*iter == '\0')
    {
	smpd_exit_fn(FCNAME);
	return SMPD_TRUE;
    }
    if (*iter == '\n')
    {
	iter++;
	if (*iter == '\0')
	{
	    smpd_exit_fn(FCNAME);
	    return SMPD_TRUE;
	}
	smpd_exit_fn(FCNAME);
	return SMPD_FALSE;
    }
    if (*iter != 'e' && *iter != 'E')
    {
	smpd_exit_fn(FCNAME);
	return SMPD_FALSE;
    }
    iter++;
    if (*iter != 's' && *iter != 's')
    {
	smpd_exit_fn(FCNAME);
	return SMPD_FALSE;
    }
    iter++;
    if (*iter == '\n')
    {
	iter++;
	if (*iter == '\0')
	{
	    smpd_exit_fn(FCNAME);
	    return SMPD_TRUE;
	}
	smpd_exit_fn(FCNAME);
	return SMPD_FALSE;
    }
    if (*iter == '\0')
    {
	smpd_exit_fn(FCNAME);
	return SMPD_TRUE;
    }
    smpd_exit_fn(FCNAME);
    return SMPD_FALSE;

    /*
    if (strcmp(str, "yes\n") == 0 ||
	strcmp(str, "Yes\n") == 0 ||
	strcmp(str, "YES\n") == 0 ||
	strcmp(str, "Y\n") == 0 ||
	strcmp(str, "y\n") == 0 ||
	strcmp(str, "yes") == 0 ||
	strcmp(str, "Yes") == 0 ||
	strcmp(str, "YES") == 0 ||
	strcmp(str, "Y") == 0 ||
	strcmp(str, "y") == 0)
	return SMPD_TRUE;
    return SMPD_FALSE;
    */
}

#undef FCNAME
#define FCNAME "smpd_option_on"
SMPD_BOOL smpd_option_on(const char *option)
{
    char val[SMPD_MAX_VALUE_LENGTH];

    smpd_enter_fn(FCNAME);

    if (smpd_get_smpd_data(option, val, SMPD_MAX_VALUE_LENGTH) == SMPD_SUCCESS)
    {
	if (smpd_is_affirmative(val) || (strcmp(val, "1") == 0))
	{
	    smpd_exit_fn(FCNAME);
	    return SMPD_TRUE;
	}
    }
    smpd_exit_fn(FCNAME);
    return SMPD_FALSE;
}

#undef FCNAME
#define FCNAME "smpd_delete_user_data"
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
}

#undef FCNAME
#define FCNAME "smpd_delete_smpd_data"
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
}

#undef FCNAME
#define FCNAME "smpd_set_user_data"
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;