Grid Application Toolkit A simple API for Grid Applications

Menu Home API-Specification API-Overview Status C Reference Manual Download Java Java-Reference General GridLab - WP-1 Links

GATConfig.c Go to the documentation of this file. /** @file GATConfig.c * Main file for the GATConfig class. * * A GATConfig object contains a set of configuration tables * which define configuration parameters for the system and * for specific adaptors. * * @date Tue Sep 23 2003 * * @version $Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/src/GATConfig.c,v 1.18 2004/04/28 10:50:10 hartmutkaiser Exp $ * * Copyright (C) Tom Goodale * This file is part of the GAT Engine. * Contributed by Tom Goodale <goodale@aei.mpg.de>. * * Use, modification and distribution is subject to the Gridlab Software * License. (See accompanying file GLlicense.txt or copy at * http://www.gridlab.org/GLlicense.txt) */ static const char *rcsid = "$Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/src/GATConfig.c,v 1.18 2004/04/28 10:50:10 hartmutkaiser Exp $"; /* System Header Files */ #include <errno.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <ctype.h> #include <limits.h> #include <unistd.h> #include <sys/stat.h> /* GAT Header Files */ #include "GATUtil.h" #include "GATConfig.h" #include "GATTable.h" #include "GATContext.h" #include "GATErrors.h" /* Macros */ #define LINE_LENGTH 1024 #define RC_FILENAME ".gatrc" #if !defined(MAX_PATH) #define MAX_PATH _POSIX_PATH_MAX #endif /* Structures, unions and enums */ enum linetype {line_blank, line_comment, line_section, line_adaptor, line_string}; enum parse_error { parse_success, parse_empty_token, parse_memory_failure, parse_malformed_line }; struct adaptor_list { struct adaptor_list *next; char *name; GATConfigTableList configs; }; struct GATConfig_S { GATTable system_config; struct adaptor_list *adaptor_configs; }; /* Static function prototypes */ static GATResult AddToAdaptorConfig(GATContext error_context, struct adaptor_list *adaptor, const char *nickname, GATTable config); static GATResult ParseConfigFile(GATConfig this, GATContext error_context, const char *filename); static enum parse_error Tokenise(const char *line, char **token1, char **token2, enum linetype *type); static enum parse_error ParseKeyVal(const char *string, char **token1, char **token2, enum linetype *type); static enum parse_error ParseString(const char *token_start, char **buffer); static enum parse_error ParseSection(const char *token_start, char **buffer); /* File scope variables */ /* External functions */ /** GATConfig_Create * The GATConfig constructor. * This is the constructor for GATConfig objects. * * @return A new GATConfig */ GATConfig GATConfig_Create(GATContext error_context) { GAT_USES_STATUS(error_context, "GATConfig_Create"); GATConfig new_config = (GATConfig)malloc(sizeof(struct GATConfig_S)); /* Create the structure */ if (NULL != new_config) { char *config_path = NULL; char const *env_var = NULL; new_config->system_config = GATTable_Create(); new_config->adaptor_configs = NULL; /* Now parse the configuration file */ if (NULL != (env_var = getenv("GAT_CONFIG_FILE"))) { config_path = GATUtil_strdup(env_var); } else if (NULL != (env_var = getenv("HOME"))) { config_path = (char *)malloc(strlen(env_var)+sizeof(RC_FILENAME)+2); if (NULL != config_path) { struct stat buf; sprintf(config_path, "%s/%s", env_var, RC_FILENAME); if (stat(config_path, &buf)) { /* Error stating the file, try to create it. */ int fd = creat(config_path, S_IREAD | S_IWRITE); close(fd); /* free the allocated memory */ free(config_path); config_path = NULL; } } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } } /* FIXME: should also try a system.gatrc file as a fallback. * Should this be in <prefix>/etc ? */ if (NULL != config_path) { GATResult retval = ParseConfigFile(new_config, error_context, config_path); if (GAT_FAILED(retval)) { char buffer[MAX_PATH+100]; sprintf(buffer, "Error opening config file '%s'", config_path); GAT_CREATE_STATUS_MSG(retval, buffer); } free(config_path); } } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } if (GAT_FAILED(GAT_CURRENT_STATUS())) { GATConfig_Destroy(&new_config); } GAT_STORE_STATUS(); return new_config; } /** GATConfig_Destroy * The GATConfig destructor. * This is the destructor for GATConfig objects. * * @param this An old GATConfig */ void GATConfig_Destroy(GATConfig *object) { if(NULL != object && NULL != *object) { struct adaptor_list *current = (*object)->adaptor_configs; while(NULL != current) { struct adaptor_list *next = current->next; GATConfigTableList current_config_table = current->configs; while (NULL != current_config_table) { GATConfigTableList next_config_table = current_config_table->next; GATTable_Destroy(&current_config_table->config); free(current_config_table->nickname); free(current_config_table); current_config_table = next_config_table; } free(current->name); free(current); current = next; } GATTable_Destroy(&((*object)->system_config)); free (*object); *object = NULL; } } /** GATConfig_GetSystemConfig * Gets the system configuration table. * Gets the GATTable holding system configuration data. * * @param this The GATConfig structure * * @return The system configuration table. */ GATTable_const GATConfig_GetSystemConfig(GATConfig_const this) { return this->system_config; } /** GATConfig_GetAdaptorConfigs * Gets the configuration tables for an adaptor. * An adaptor may have more than one configuration table * associated with it. This function returns a list of * them all. * * @param this The GATConfig structure * @param adaptor The adaptor to get the tables for. * * @return A list of adaptor configuration tables. */ GATConfigTableList_const GATConfig_GetAdaptorConfigs(GATConfig_const this, const char *adaptor) { GATConfigTableList retval = NULL; struct adaptor_list *current = this->adaptor_configs; for(/**/; NULL != current; current = current->next) { if (!strcmp(current->name, adaptor)) { retval = current->configs; break; } } return retval; } /** GATConfig_AddAdaptorConfig * Adds a configuration table to an adaptor. * An adaptor may have more than one configuration table * associated with it. This function add a new table. * * @param this The GATConfig structure * @param adaptor The adaptor to add the tables to. * @param nickname The name for thisinstance of the adaptor. * @param config The new configuration table. * * @return An error code. */ GATResult GATConfig_AddAdaptorConfig(GATConfig this, GATContext error_context, const char *adaptor, const char *nickname, GATTable config) { GAT_USES_STATUS(error_context, "GATConfig_AddAdaptorConfig"); struct adaptor_list *current = NULL; struct adaptor_list *last = NULL; /* Look for the adaptor in the list */ for(current = this->adaptor_configs; NULL != current; last = current, current = current->next) { if (!strcmp(current->name, adaptor)) { break; /* This already exists */ } } if (NULL == current) { struct adaptor_list *new_adaptor = (struct adaptor_list *)malloc(sizeof(*new_adaptor)); if (NULL != new_adaptor) { new_adaptor->name = GATUtil_strdup(adaptor); if (new_adaptor->name) { /* Add to list */ new_adaptor->next = NULL; if (NULL != last) { last->next = new_adaptor; } else { this->adaptor_configs = new_adaptor; } new_adaptor->configs = NULL; } else { free(new_adaptor); new_adaptor = NULL; GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } current = new_adaptor; } if (NULL != current) { GAT_CREATE_STATUS(AddToAdaptorConfig(error_context, current, nickname, config)); } return GAT_RETURN_STATUS(); } /** AddAdaptorToConfig * Adds a configuration table to an internal list for an adaptor. * An adaptor may have more than one configuration table * associated with it. This function add a new table to the * internal list maintained by a GATConfig structure. * * @param adaptor_list Structure to add the config to. * @param nickname The name for thisinstance of the adaptor. * @param config The new configuration table. * * @return An error code. */ static GATResult AddToAdaptorConfig(GATContext error_context, struct adaptor_list *adaptor, const char *nickname, GATTable config) { GAT_USES_STATUS(error_context, "AddToAdaptorConfig"); GATConfigTableList current; GATConfigTableList last = NULL; /* Look through the config list, it should be alphabetical */ for (current = adaptor->configs; NULL != current; last = current, current = current->next) { if (!strcmp(current->nickname, nickname)) { /* This already exists */ GAT_CREATE_STATUS(GAT_DUPLICATE_CONFIG); break; } } if (NULL == current) { GATConfigTableList new_config = (GATConfigTableList)malloc(sizeof(*new_config)); if (NULL != new_config) { new_config->nickname = GATUtil_strdup(nickname); if (NULL != new_config->nickname) { /* Add to list */ new_config->next = NULL; if (NULL != last) { last->next = new_config; } else { adaptor->configs = new_config; } new_config->config = config; } else { free(new_config); new_config = NULL; GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } } return GAT_RETURN_STATUS(); } /** ParseConfigFile * Parse a GAT configuration file. * Open and parse the contents of a GAT configuration file, * creating new configuration tables as necessary. * * @param this The GATConfig structure * @param filename The configuration filename. * * @return An error code. */ static GATResult ParseConfigFile(GATConfig this, GATContext error_context, const char *filename) { GAT_USES_STATUS(error_context, "ParseConfigFile"); FILE *file = NULL; if (NULL != (file = fopen(filename, "r"))) { enum parse_error error; enum linetype type; char line[LINE_LENGTH+1]; int linenumber = 0; char *section = NULL; char *adaptor = NULL; GATTable current_config = this->system_config; /* FIXME: This whole parsing sequence should be replaced * by something more robust against really long lines. * This is a stop-gap quick solution. */ while (NULL != fgets(line, LINE_LENGTH+1, file)) { char *token1 = NULL; char *token2 = NULL; linenumber++; error = Tokenise(line, &token1, &token2, &type); switch(error) { case parse_success: switch(type) { case line_blank: break; case line_comment: break; case line_section: if (NULL != section) { if (NULL != adaptor) { GAT_CREATE_STATUS(GATConfig_AddAdaptorConfig(this, error_context, adaptor, section, current_config)); free(adaptor); adaptor = NULL; } else { char buffer[MAX_PATH+100]; sprintf(buffer, "Error <%s:%d>: No adaptor defined in " "section '%s'.", filename, linenumber, section); GAT_CREATE_STATUS_MSG(GAT_INVALID_CONFIG_FORMAT, buffer); } free(section); } section = token1; current_config = GATTable_Create(); break; case line_adaptor: if (NULL != adaptor) { char buffer[MAX_PATH+100]; sprintf(buffer, "Error <%s:%d>: Second adaptor defined in " "section '%s'", filename, linenumber, section); GAT_CREATE_STATUS_MSG(GAT_INVALID_CONFIG_FORMAT, buffer); } else if (NULL == section) { char buffer[MAX_PATH+100]; sprintf(buffer, "Error <%s:%d>: Can't define adaptor in " "default section", filename, linenumber); } else { adaptor = token1; } break; case line_string: /* FIXME: Should parse this and put numeric types in as * ints and doubles depending on what they look like. */ GATTable_Add_String(current_config, token1, token2); free(token1); free(token2); token1 = NULL; token2 = NULL; break; } break; case parse_empty_token: { char buffer[MAX_PATH+100]; sprintf(buffer, "Error <%s:%d>: Empty token when parsing line", filename, linenumber); GAT_CREATE_STATUS_MSG(GAT_INVALID_CONFIG_FORMAT, buffer); } break; case parse_memory_failure: { char buffer[MAX_PATH+100]; sprintf(buffer, "Error <%s:%d>: Out of memory when parsing line", filename, linenumber); GAT_CREATE_STATUS_MSG(GAT_INVALID_CONFIG_FORMAT, buffer); } break; case parse_malformed_line: { char buffer[MAX_PATH+100]; sprintf(buffer, "Error <%s:%d>: Malformed line", filename, linenumber); GAT_CREATE_STATUS_MSG(GAT_INVALID_CONFIG_FORMAT, buffer); } break; } } /* Finish the last section */ if (NULL != section) { if (NULL != adaptor) { GAT_CREATE_STATUS(GATConfig_AddAdaptorConfig(this, error_context, adaptor, section, current_config)); free(adaptor); adaptor = NULL; } else { char buffer[MAX_PATH+100]; sprintf(buffer, "Error <%s:%d>: No adaptor defined in section '%s'.", filename, linenumber, section); GAT_CREATE_STATUS_MSG(GAT_INVALID_CONFIG_FORMAT, buffer); } free(section); } } else { GAT_CREATE_STATUS(GAT_FILEOPEN_ERROR); } return GAT_RETURN_STATUS(); } /** Tokenise * Determine what sort of string has been pased in and split into tokens. * Configuration file lines are either blank, comments, section * definitions, adaptor definitions, or key/value pairs for the * table. This function determines which, and splits the line into the * requisite number of tokens. * * @param line The line to tokenise * @param token1 Buffer for first token on line. * @param token2 Buffer for first token on line. * @param type What type the line is. * * @return An error code. */ static enum parse_error Tokenise(const char *line, char **token1, char **token2, enum linetype *type) { enum parse_error error; const char *token_start; error = parse_success; /* Remove leading whitespace */ for(token_start = line; isspace(*token_start); token_start++) { /* Do nothing */ } switch(*token_start) { case 0 : *type = line_blank; break; case '#' : *type = line_comment; break; case '[' : *type = line_section; error = ParseSection(token_start+1, token1); break; default : error = ParseKeyVal(token_start, token1, token2, type); } return error; } /** ParseKeyVal * Parse a line defining a key/value pair. * Key/Value lines are of the form token1 = token2 * Where token1 cannot have an "=" in it. * Such lines are either destined for the configuration table * or define an adaptor. * * @param string The string to tokenise * @param token1 Buffer for first token on line. * @param token2 Buffer for first token on line. * @param type What type the line is. * * @return An error code. */ static enum parse_error ParseKeyVal(const char *string, char **token1, char **token2, enum linetype *type) { enum parse_error error; const char *equals; const char *token_end; int i; if((equals = strchr(string, '='))) { for(token_end = equals-1; token_end >= string && isspace(*token_end); token_end--) { /* Do nothing */ } if(!strncmp(string, "Adaptor", token_end - string)) { *type = line_adaptor; error = ParseString(equals+1, token1); } else { *type = line_string; if(token_end - string > 0) { *token1 = (char *)malloc(token_end-string+2); if(*token1) { for(i=0; i <= token_end - string; i++) { (*token1)[i] = string[i]; } (*token1)[i] = 0; error = ParseString(equals+1, token2); } else { error = parse_memory_failure; } } else { error = parse_empty_token; } } } else { error = parse_malformed_line; } return error; } /** ParseString * Parse a string token * Strip whitespace from either end of a string and * get rid of comments. * * @param token_start The beginning of the token. * @param buffer Buffer to put the stripped token into. * * @return An error code. */ static enum parse_error ParseString(const char *token_start, char **buffer) { enum parse_error error; const char *token_end; int i; error = parse_success; /* Remove leading whitespace */ for(; isspace(*token_start); token_start++) { /* Do nothing */ } /* Remove any comment */ token_end = strchr(token_start, '#'); if(! token_end) { token_end = token_start+strlen(token_start)-1; } else { token_end--; } /* Remove trailing whitespace */ for(; token_end >= token_start && isspace(*token_end); token_end--) { /* Do nothing */ } if(token_end - token_start > 0) { *buffer = (char *)malloc(token_end - token_start+2); if(*buffer) { for(i=0; i <= token_end - token_start; i++) { (*buffer)[i] = token_start[i]; } (*buffer)[i] = 0; } else { error = parse_memory_failure; } } else { error = parse_empty_token; } return error; } /** ParseSection * Parse a section definition * Get a section name from a section definition. * * @param token_start The beginning of the token. * @param buffer Buffer to put the section name into. * * @return An error code. */ static enum parse_error ParseSection(const char *token_start, char **buffer) { enum parse_error error; const char *token_end; int i; error = parse_success; /* Remove leading whitespace */ for(; isspace(*token_start); token_start++) { /* Do nothing */ } for(token_end = token_start; *token_end && *token_end != ']'; token_end++) { /* Do nothing */ } if(*token_end != ']') { error = parse_malformed_line; } else { token_end--; } if(error == parse_success) { if(token_end - token_start > 0) { *buffer = (char *)malloc(token_end - token_start+2); if(*buffer) { for(i=0; i <= token_end - token_start; i++) { (*buffer)[i] = token_start[i]; } (*buffer)[i] = 0; } else { error = parse_memory_failure; } } else { error = parse_empty_token; } } /* FIXME: ignoring everything else on line. * Should really check for extraneous chars. */ return error; }