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

GATSelf.c Go to the documentation of this file. /** @file GATSelf.c * Main File for the GATSelf class. * * The GATSelf class corresponds to the current GAT job. There is * only ever one instance of this class, which is * obtained by the GetInstance method. This object can be used to * change various properties of this job, such as whether it is * checkpointable or not, and what metrics or events it can report. It * can also provide the GATJob instance associated with this * job, which may then be advertised. * * @date Tue Sep 2 2003 * * @version $Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/src/GATSelf.c,v 1.56 2004/05/12 18:56:01 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/GATSelf.c,v 1.56 2004/05/12 18:56:01 hartmutkaiser Exp $"; /* System Header Files */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <dirent.h> #include <sys/stat.h> #include <unistd.h> #include <ctype.h> #include <errno.h> #include <limits.h> /* include headers of dependand libraries */ #include "uuid.h" #include "sqlite.h" #include "regex.h" /* GAT Header Files */ #include "GATInternal.h" #include "GATErrors.h" #include "GATSelf.h" #include "GATJob.h" #include "GATRequest.h" #include "GATContext.h" #include "GATTable.h" #include "GATRegistry.h" #include "GATLoader.h" #include "GATConfig.h" #include "GATInterfaceMap.h" /* defines */ #if !defined(MAX_PATH) #define MAX_PATH _POSIX_PATH_MAX #endif /* define the vtable types */ GATOBJECT_DEFINE_VTABLE(GATSelf); /* * The GATErrorMessageHandlerData structure holds the data associated with a * registered error message handler. */ typedef struct GATErrorMessageHandlerData { GATuint32 facility; GATuint32 cookie; GATErrorMessageHandler handler; } GATErrorMessageHandlerData; GATLIST_DEFINE_QUALIFIED(static, GATErrorMessageHandlerData, GATList_GATErrorMessageHandlerData, GATType_PlainOldData) /* Declare the converters to/from GATObject */ GATOBJECT_DEFINE_CONVERTERS(GATSelf); GATOBJECT_DEFINE_CONVERTERS_QUALIFIED(static, GATList_GATErrorMessageHandlerData, GATType_GATList); /* Macros */ #ifndef PATH_MAX #define PATH_MAX 4096 #endif /* ! PATH_MAX */ /* Structures, unions and enums */ /* * The structure stored for a GATRequest inside the corresponding list */ typedef struct GATRequestListenerData { GATRequest request; /* the registered GATRequest */ GATuint32 cookie; /* cookie identifying the registered GATRequestListener */ } GATRequestListenerData; /* Define the type specific interface functions for the GATRequestListenerData list */ GATLIST_DEFINE_QUALIFIED(static, GATRequestListenerData, GATList_GATRequestListenerData, GATType_PlainOldData); /* Declare the converters to/from GATObject */ GATOBJECT_DEFINE_CONVERTERS_QUALIFIED(static, GATList_GATRequestListenerData, GATType_GATList); struct contextlist { struct contextlist *prev; struct contextlist *next; GATContext context; }; struct GATSelf_S { /* supported interfaces */ GATSelf_vtable *GATObject__vtable; /* GATSelf instance data */ GATConfig config; GATLoader loader; GATRegistry registry; struct contextlist *contexts; GATJobID gatjobid; /* the GAT job id of this job */ GATList_GATRequestListenerData listeners; /* GATSelf CPI specific data */ GATSelfCPI_Instance data; /* instance data of the corresponding CPI object */ GATSelfCPI cpi; /* CPI object to use for all subsequent operations */ GATSelfCPIList cpilist; /* CPI list of appropriate CPI objects */ }; struct load_data { GATConfig config; GATLoader loader; GATRegistry registry; }; /* Static function prototypes */ static GATSelf GATSelf_Create(GATContext error_context); static void GATSelf_Destroy(GATSelf *this); static GATResult LoadAdaptors(GATContext error_context, GATLoader loader, GATRegistry registry, GATConfig config); static GATResult Load(GATContext error_context, const char *filename, void *data); static GATResult ProcessDir(GATContext error_context, const char *dirname, int (*action)(GATContext, const char *, void *), void *data); static GATResult ProcessFile(GATContext error_context, const char *filename, int (*action)(GATContext, const char *, void *), void *data); static const char * MakePath(const char *base, const char *original, char sep, char *pathentry, int pathentry_length); static char * CanonicaliseName(const char *original); /* local GATObject interface functions */ static GATResult GATSelf_GetCPIInstanceData(GATSelf object, void **data); static GATResult GATSelf_Equals(GATSelf_const lhs, GATSelf_const rhs, GATBool *isequal); static GATResult GATSelf_Clone(GATSelf_const object, GATSelf *new_object); static GATType GATSelf_GetType(GATSelf_const object); static GATResult GATSelf_GetInterface(GATSelf_const object, GATInterface iftype, void const **ifp); /* Error message handler functions */ static GATResult GATStatus_ErrorMessagesEngine(GATResult err_code, char *buffer, GATuint32 length, GATuint32 *written); static GATResult GATStatus_ErrorMessagesXds(GATResult err_code, char *buffer, GATuint32 length, GATuint32 *written); static GATResult GATStatus_ErrorMessagesUuid(GATResult err_code, char *buffer, GATuint32 length, GATuint32 *written); static GATResult GATStatus_ErrorMessagesRegex(GATResult err_code, char *buffer, GATuint32 length, GATuint32 *written); static GATResult GATStatus_ErrorMessagesSQLite(GATResult err_code, char *buffer, GATuint32 length, GATuint32 *written); static GATResult GATStatus_ErrorMessagesPosix(GATResult err_code, char *buffer, GATuint32 length, GATuint32 *written); /* File scope variables */ GATSelf_vtable GATSelf__vtable = { GATSelf_GetType, GATSelf_Destroy, GATSelf_Equals, GATSelf_Clone, GATSelf_GetInterface, GATSelf_GetCPIInstanceData }; /* GATSelf is a singleton variable */ static GATSelf thegatself = NULL; /* the cookies are static and separate from the GATSelf to allow error reporting, even if the GATSelf creation fails */ static GATuint32 cookie_engine = 0; static GATuint32 cookie_xds = 0; static GATuint32 cookie_uuid = 0; static GATuint32 cookie_regex = 0; static GATuint32 cookie_sqlite = 0; static GATuint32 cookie_posix = 0; /* * Holds the next available cookie used for identifying the registered * requests. */ static GATuint32 request_cookie_jar = 0; /* static data for managing registered error message handlers */ static GATList_GATErrorMessageHandlerData error_message_handlers = NULL; static GATuint32 error_cookie_jar = 0; /* External functions */ /** GATSelf_GetInstance * Gets the GATSelf object. * This is the method used by any application code to get the GATSelf * object. * * @param context A GATContext which is used to find the GATSelf object. * * @return The GATSelf object */ GATSelf_const GATSelf_GetInstance(GATContext context) { GATSelf_const ret_val; if(context) { ret_val = GATContext_internal_GetSelf(context); } else { ret_val = NULL; } return ret_val; } /** GATSelf_Equals * @brief Compare two GATSelf objects * * The function @c GATSelf_Equals compares two objects of the * @c GATSelf type. * * @param lhs The first list to compare * @param rhs The second list to compare * @param isequal The pointer to the GATBool variable, which should receive * the result if the comparision * * @return An error code. */ GATResult GATSelf_Equals(GATSelf_const lhs, GATSelf_const rhs, GATBool *isequal) { GAT_UNUSED_PARAMETER(lhs); GAT_UNUSED_PARAMETER(rhs); GAT_UNUSED_PARAMETER(isequal); return GAT_NOTIMPL; /* shouldn't ever get called */ } /** GATSelf_Clone * @brief Clone the given GATSelf * * The function @c GATSelf_Clone generates a (deep) copy of * the given GATSelf. * * @param description The object to clone * @param new_object The pointer, through which the result is to be * returned. * * @return An error type. */ GATResult GATSelf_Clone(GATSelf_const handle, GATSelf *new_handle) { GAT_UNUSED_PARAMETER(handle); GAT_UNUSED_PARAMETER(new_handle); return GAT_NOTIMPL; /* shouldn't ever get called */ } /** GATType GATSelf_GetType(GATSelf_const resource) * @brief Return the type of the GATSelf * * The function @c GATSelf_GetType always returns * @c #GATType_GATSelf. * * @param object The object to inspect * * @return Returns always @c #GATType_GATSelf. */ GATType GATSelf_GetType(GATSelf_const object) { GAT_UNUSED_PARAMETER(object); return GATType_GATSelf; } /** GATResult GATSelf_GetInterface(GATSelf_const file, GATInterface iftype, void const **ifp) * @brief Get an interface supported by a GATObject * * The function GATSelf_GetInterface allows to get a pointer to an * additional interface supported by this GATSelf. * * @param object The object to be asked for the new interface. * @param iftype The interface the object is to be asked for. * @param ifp The pointer, through which the result is to be returned. * * @return An error type. */ GATResult GATSelf_GetInterface(GATSelf_const object, GATInterface iftype, void const **ifp) { GATResult retval = GAT_INVALID_PARAMETER; GAT_UNUSED_PARAMETER(object); GAT_UNUSED_PARAMETER(iftype); if (NULL != ifp) { *ifp = NULL; retval = GAT_NO_INTERFACE; } return retval; } /** GATSelf_AddRequestListener * Adds a GATRequestListener to the GATSelf. * Registers a new callback function and a new type of * request which the GATEngine should react to when queried from * the outside world. * Request names should be unique. * * @param self The GATSelf object * @param listener The callback function * @param data Data object for the callback function * @param type The type of the new request * @param name The name of the new request * * @return An error code */ GATResult GATSelf_AddRequestListener(GATContext context, GATRequestListener listener, void *data, GATRequestType type, GATTable_const parameters, const char *name, GATuint32 *cookie) { GAT_STATUS_APIENTRY(context, "GATSelf_AddRequestListener"); GATSelf self = GATContext_internal_GetSelf(context); if (NULL != self) { GATRequest request = NULL; GAT_CREATE_STATUS(GATSelfCPI_CreateRequestForListener(self->cpi, &self->data, context, listener, data, type, parameters, name, &request)); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { /* insert the listener data into the appropriate list */ GATRequestListenerData localdata; GATList_GATRequestListenerData_Iterator it = GATList_GATRequestListenerData_Begin(self->listeners); /* verify, that this listener isn't already registered */ GATList_GATRequestListenerData_Iterator end = GATList_GATRequestListenerData_End(self->listeners); for (/**/; it != end; it = GATList_GATRequestListenerData_Next(it)) { GATBool isequal = GATFalse; GATRequestListenerData *value = GATList_GATRequestListenerData_Get(it); if (NULL == value) { GAT_CREATE_STATUS(GAT_FAIL); break; } GAT_CREATE_STATUS(GATRequest_Equals(request, value->request, &isequal)); if (GAT_FAILED(GAT_CURRENT_STATUS()) || GATFalse == isequal) { GAT_CREATE_STATUS(GAT_KEY_ALREADY_EXISTS); break; } } if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { if (NULL != cookie) { GATuint32 mycookie = ++request_cookie_jar; localdata.request = request; localdata.cookie = mycookie; it = GATList_GATRequestListenerData_Insert(self->listeners, end, localdata); if (NULL == it) { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } else { *cookie = mycookie; } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } } } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } /** GATSelf_RemoveRequestListener * Removes a GATRequestListener from the GATSelf. * Unregisters a request callback function. * * @param this The GATSelf object * @param name The name of the old request * * @return An error code */ GATResult GATSelf_RemoveRequestListener(GATContext context, GATuint32 cookie) { GAT_STATUS_APIENTRY(context, "GATSelf_RemoveRequestListener"); GATSelf self = GATContext_internal_GetSelf(context); if (NULL != self) { GATList_GATRequestListenerData_Iterator it = GATList_GATRequestListenerData_Begin(self->listeners); GATList_GATRequestListenerData_Iterator end = GATList_GATRequestListenerData_End(self->listeners); GATBool found = GATFalse; for (/**/; it != end; it = GATList_GATRequestListenerData_Next(it)) { GATRequestListenerData *value = GATList_GATRequestListenerData_Get(it); if (NULL == value) { GAT_CREATE_STATUS(GAT_FAIL); break; } if (value->cookie == cookie) { GAT_CREATE_STATUS(GATSelfCPI_DestroyRequestForListener(self->cpi, &self->data, context, &value->request)); found = GATTrue; break; } } if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { GATList_GATRequestListenerData_Erase(self->listeners, it); if (GATFalse == found) { GAT_CREATE_STATUS(GAT_KEY_NOT_FOUND); } } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } /** GATSelf_GetJob * Gets the GATJob associated with this job. * Each GAT job has an associated GATJob object * which can be advertised to allow other GAT applications * to manipulate it. * * @param self The GATSelf object * @param job The pointer to the variable, which receives the created job * object. * * @return The associated GATJob. */ GATResult GATSelf_GetJob(GATContext context, GATJob *job) { GAT_STATUS_APIENTRY(context, "GATSelf_GetJob"); GATSelf self = GATContext_internal_GetSelf(context); if (NULL != self) { if (NULL != self->cpi) { GAT_CREATE_STATUS(GATSelfCPI_GetJob(self->cpi, &self->data, context, job)); GAT_CREATE_STATUS(GATJob_internal_SetGATJobId(*job, self->gatjobid)); } else { /* there was no adaptor found, which knows our RMS */ GAT_CREATE_STATUS(GAT_NO_REGISTERED_CPI); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } /** GATSelf_internal_GetInstance * Private GATEngine method to get the GATSelf object. * This is the method used by the constructor of a GATContext to get the * GATSelf object. This creates the GATSelf if it has not already been * created. * * @param error_context This is the created context, which potentially * triggers the creation of the GATSelf. This context may be used for * storing/retrieving the current status only. * * @return The GATSelf object */ GATSelf GATSelf_internal_GetInstance(GATContext error_context) { if (!thegatself) { thegatself = GATSelf_Create(error_context); } return thegatself; } /** GATSelf_internal_GetRegistry * Gets the GATRegsitry object. * This is the method used by a new GATContext to get the registry * object from the GATSelf * * @param this The GATSelf which is used to find the GATRegistry object. * * @return A GATRegistry object */ GATRegistry GATSelf_internal_GetRegistry(GATSelf self) { if (NULL != self) { return self->registry; } return NULL; } /** GATSelf_internal_AddContext * Private method to add a new GATContext to the GATSelf object. * This is the method used by the constructor of a GATContext to add itself * to the list of GATContexts maintained by the GATSelf. * * @param this The GATSelf object * @param context A new GATContext * */ GATResult GATSelf_internal_AddContext(GATSelf self, GATContext context) { if (NULL != self) { GAT_USES_STATUS(context, "GATSelf_internal_AddContext"); struct contextlist *new_context = (struct contextlist *)malloc(sizeof(struct contextlist)); if (NULL != new_context) { new_context->prev = NULL; new_context->next = NULL; new_context->context = context; /* Now add it to list */ if (NULL != self->contexts) { /* Find the end of the list */ struct contextlist *current = self->contexts; for(/**/; NULL != current->next; current = current->next) { /* Do nothing */ } current->next = new_context; new_context->prev = current; } else { /* New list */ self->contexts = new_context; } } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** GATSelf_internal_RemoveContext * Private method to remove a GATContext from the GATSelf object. * This is the method used by the destructor of a GATContext to remove itself * from the list of GATContexts maintained by the GATSelf. If this was the last * GATContext on the list, the GATSelf is destroyed. * * @param this The GATSelf object * @param context An old GATContext * */ void GATSelf_internal_RemoveContext(GATSelf self, GATContext context) { if (NULL != self) { if (NULL != self->contexts) { /* Find the context on the list */ struct contextlist *current = self->contexts; for (/**/; current->context != context; current = current->next) { /* Do nothing */ } if (NULL != current) { if (NULL != current->next) { current->next->prev = current->prev; } if (NULL != current->prev) { current->prev->next = current->next; } if (current == self->contexts) { /* we have to remove the first element in the context list */ self->contexts = current->next; } free(current); if(NULL == self->contexts) { /* this was the last context on this list */ GATSelf_Destroy(&self); } } else { /* Error ! */ } } else { /* Error ! */ } } } /* Local functions */ /** GATSelf_Create * The GATSelf constructor. * This is the constuctor for the GATSelf. * It should initialise the GATEngine, e.g. load adaptors or * at least find them, load configuration files, etc. * * @param error_context This is the created context, which potentially * triggers the creation of the GATSelf. This context may be used for * storing/retrieving the current status only. * * @return A new GATSelf */ static GATSelf GATSelf_Create(GATContext error_context) { GAT_USES_STATUS(error_context, "GATSelf_Create"); /* create the new GATSelf object */ GATSelf new_self = (GATSelf)malloc(sizeof(struct GATSelf_S)); if (NULL != new_self) { // initialise all the members memset(new_self, 0, sizeof(struct GATSelf_S)); new_self->GATObject__vtable = &GATSelf__vtable; new_self->contexts = NULL; new_self->config = GATConfig_Create(error_context); GAT_CREATE_STATUS_IF(NULL == new_self->config, GAT_MEMORYFAILURE); new_self->registry = GATRegistry_Create(); GAT_CREATE_STATUS_IF(NULL == new_self->registry, GAT_MEMORYFAILURE); new_self->loader = GATLoader_Create(); GAT_CREATE_STATUS_IF(NULL == new_self->loader, GAT_MEMORYFAILURE); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { char *jobid_env = getenv("GAT_JOBID"); if (NULL != jobid_env) { /* GAT_JOBID environment exists, use whatever is given there */ new_self->gatjobid = GATString_Create(jobid_env, strlen(jobid_env)+1, "ASCII"); GAT_CREATE_STATUS_IF(NULL == new_self->gatjobid, GAT_MEMORYFAILURE); } else { GAT_CREATE_STATUS(GATSelf_internal_CreateGATJobId(new_self, error_context, &new_self->gatjobid)); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { /* set the GAT job id, if it isn't set already */ setenv("GAT_JOBID", GATString_GetBuffer(new_self->gatjobid), 1); } } } new_self->listeners = GATList_GATRequestListenerData_Create(); GAT_CREATE_STATUS_IF(NULL == new_self->listeners, GAT_MEMORYFAILURE); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { GAT_CREATE_STATUS(LoadAdaptors(error_context, new_self->loader, new_self->registry, new_self->config)); GAT_CREATE_STATUS(GATObject_Register_GATSerialisables()); /* find CPI provider, which knows how to manage this job */ if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { GATRegistry registry = GATSelf_internal_GetRegistry(new_self); new_self->cpilist = GATRegistry_FindGATSelfCPI(registry, 0); if (NULL != new_self->cpilist) { GATBool found_cpi = GATFalse; GATSelfCPIList current = NULL; for(current = new_self->cpilist; NULL != current; current = current->next) { GAT_CREATE_STATUS(GATSelfCPI_CreateInstance(current->cpi, &new_self->data)); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { new_self->cpi = current->cpi; found_cpi = GATTrue; break; } } /* register this object with the engine */ if (GATTrue == found_cpi) { GAT_CREATE_STATUS(GATRegistry_internal_AddGATSelfToCPIList(registry, new_self->cpi, new_self)); } } /* the load process shouldn't fail, if no GATSelfCPI is found */ } } } /* error handling */ if (GAT_FAILED(GAT_CURRENT_STATUS())) { GATSelf_Destroy(&new_self); } GAT_STORE_STATUS(); /* register error message handlers */ if (0 == cookie_engine) { GAT_CREATE_STATUS_UNCOND(GATSelf_AddErrorMessageHandler(GAT_FACILITY_ENGINE, GATStatus_ErrorMessagesEngine, &cookie_engine)); } if (0 == cookie_xds) { GAT_CREATE_STATUS_UNCOND(GATSelf_AddErrorMessageHandler(GAT_FACILITY_ENGINE_XDS, GATStatus_ErrorMessagesXds, &cookie_xds)); } if (0 == cookie_uuid) { GAT_CREATE_STATUS_UNCOND(GATSelf_AddErrorMessageHandler(GAT_FACILITY_ENGINE_UUID, GATStatus_ErrorMessagesUuid, &cookie_uuid)); } if (0 == cookie_regex) { GAT_CREATE_STATUS_UNCOND(GATSelf_AddErrorMessageHandler(GAT_FACILITY_ENGINE_REGEX, GATStatus_ErrorMessagesRegex, &cookie_regex)); } if (0 == cookie_sqlite) { GAT_CREATE_STATUS_UNCOND(GATSelf_AddErrorMessageHandler(GAT_FACILITY_SQLITE, GATStatus_ErrorMessagesSQLite, &cookie_sqlite)); } if (0 == cookie_posix) { GAT_CREATE_STATUS_UNCOND(GATSelf_AddErrorMessageHandler(GAT_FACILITY_POSIX, GATStatus_ErrorMessagesPosix, &cookie_posix)); } return new_self; } /** GATSelf_Destroy * The GATSelf destructor. * This is the destructor for the GATSelf. It should shut-down * the GATEngine, e.g. unload adaptors, etc. * * @param this An old GATContext */ static void GATSelf_Destroy(GATSelf *object) { if (NULL != object && NULL != *object) { GATSelf_RemoveErrorMessageHandler(&cookie_engine); GATSelf_RemoveErrorMessageHandler(&cookie_xds); GATSelf_RemoveErrorMessageHandler(&cookie_uuid); GATSelf_RemoveErrorMessageHandler(&cookie_regex); GATSelf_RemoveErrorMessageHandler(&cookie_sqlite); GATSelf_RemoveErrorMessageHandler(&cookie_posix); GATList_GATRequestListenerData_Destroy(&(*object)->listeners); if (NULL != (*object)->cpi) { GATRegistry registry = GATSelf_internal_GetRegistry(*object); GATRegistry_internal_RemoveGATSelfFromCPIList(registry, (*object)->cpi, *object); } GATObject_Unregister_GATSerialisables(); GATString_Destroy(&(*object)->gatjobid); GATSelfCPIList_Destroy((*object)->cpilist); GATConfig_Destroy(&(*object)->config); GATRegistry_Destroy(&(*object)->registry); GATLoader_Destroy(&(*object)->loader); free(*object); *object = NULL; } } /** LoadAdaptors * Load all adaptors on adaptor path. * This function examines the GAT_ADAPTOR_PATH environment * variable and loads all the adaptors it finds. * The environment variable is a colon seperated list of files * or directories. * * @param loader The GATLoader object which loads and track individual adaptors. * @param registry The CPI registry * @param config The GAT configuration database. * * @return An error code - 0 for success, -1 for failure. */ static GATResult LoadAdaptors(GATContext error_context, GATLoader loader, GATRegistry registry, GATConfig config) { GAT_USES_STATUS(error_context, "LoadAdaptors"); struct load_data ldata; struct stat buf; const char *env_var = NULL; ldata.config = config; ldata.loader = loader; ldata.registry = registry; env_var = getenv("GAT_ADAPTOR_PATH"); if (NULL != env_var) { /* Copy into a local variable as * another thread may also call getenv. */ char *adaptor_path = (char *)malloc(strlen(env_var)+1); if (NULL != adaptor_path) { char base[PATH_MAX+1]; const char *position = NULL; strcpy(adaptor_path, env_var); /* Get the current working directory, to * allow relative paths on the GAT_ADAPTOR_PATH */ getcwd(base, PATH_MAX); /* Now split the environment variable into * individual paths, which may be either files * or directories, and load the indicated adaptors. */ position = adaptor_path; do { char path[PATH_MAX+1]; position = MakePath(base, position, ':', path, PATH_MAX+1); if(path[0] == '/') { if (!stat(path, &buf)) { if (S_ISDIR(buf.st_mode)) { GAT_CREATE_STATUS(ProcessDir(error_context, path, Load, (void *)&ldata)); } else if (S_ISREG(buf.st_mode)) { GAT_CREATE_STATUS(ProcessFile(error_context, path, Load, (void *)&ldata)); } else { /* Not a directory or regular file. Not a critical error. */ char buffer[PATH_MAX+100]; sprintf(buffer, "Entry '%s' on GAT_ADAPTOR_PATH is not a file " "or a directory", path); GAT_CREATE_STATUS_MSG(GAT_FALSE, buffer); } } else { char buffer[PATH_MAX+100]; /* Couldn't stat the file - probably doesn't exist */ if(errno == ENOENT) { sprintf(buffer, "Entry '%s' on GAT_ADAPTOR_PATH doesn't exist", path); } else if(errno == EACCES) { sprintf(buffer, "Entry '%s' on GAT_ADAPTOR_PATH doesn't exist", path); } else { sprintf(buffer, "Could not get status of entry '%s' on " "GAT_ADAPTOR_PATH", path); } GAT_CREATE_STATUS_MSG(POSIX_TO_GAT(errno), buffer); } } else { /* Something went wrong when processing the path element. * e.g. "/.." is erroneous. */ char buffer[PATH_MAX+100]; sprintf(buffer, "Erroneous GAT_ADAPTOR_PATH '%s'", adaptor_path); GAT_CREATE_STATUS_MSG(GAT_FAIL, buffer); } } while(NULL != position); free(adaptor_path); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } } else { /* No GAT_ADAPTOR_PATH environment variable. * Could use a system defined one coming from * configure, or the configuration database. */ GAT_CREATE_STATUS_MSG(GAT_FAIL, "GAT_ADAPTOR_PATH not set, no adaptors loaded"); } return GAT_RETURN_STATUS(); } /** Load * Loads an single adaptor, as many times as configured. * A callback function invoked by the functions which scan * directories or files for adaptors. It takes a full path * to an adaptor and then invokes the GATLoader with this * adaptor and any associated config database tables. * * @param filename The full path to the adaptor. * @param registry The CPI registry * @param config The GAT configuration database. * * @return The number of adaptors loaded. */ static GATResult Load (GATContext error_context, const char *filename, void *data) { GAT_USES_STATUS(error_context, "Load"); struct load_data *ldata = (struct load_data *)data; /* Extract the adaptor name from the full path * Need to do this here to use it as the key to * getting the config table(s) for this adaptor. */ char *adaptorname = CanonicaliseName(filename); if (NULL != adaptorname) { /* Get any configuration tables associated with the adaptor. */ GATTable_const system_config = GATConfig_GetSystemConfig(ldata->config); GATConfigTableList_const instance_configs = GATConfig_GetAdaptorConfigs( ldata->config, adaptorname); if (NULL != instance_configs) { /* We have at least one set of configuration options for this adaptor. */ GATConfigTableList_const current = NULL; for (current = instance_configs; NULL != current; current = current->next) { GAT_CREATE_STATUS_UNCOND(GATLoader_LoadAdaptor(ldata->loader, error_context, ldata->registry, system_config, current->config, filename, adaptorname, current->nickname)); } } else { /* No configuration options. */ GATTable instance_config = GATTable_Create(); if (NULL != instance_config) { /* Create a table to allow this adaptor to be configured later. */ GAT_CREATE_STATUS(GATConfig_AddAdaptorConfig(ldata->config, error_context, adaptorname, adaptorname, instance_config)); /* Now load the adaptor */ GAT_CREATE_STATUS(GATLoader_LoadAdaptor(ldata->loader, error_context, ldata->registry, system_config, instance_config, filename, adaptorname, NULL)); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } } free(adaptorname); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } return GAT_RETURN_STATUS(); } /** ProcessDir * Search a directory for files and invoke an action on each one. * Finds all non-hidden files in a directory and invokes the designated * function on them. * * @param dirname The full path to a directory. * @param action A callback function which does something with this file * @param data Data for the callback function. * * @return The number of files found. */ static GATResult ProcessDir(GATContext error_context, const char *dirname, int (*action)(GATContext, const char *, void *), void *data) { GAT_USES_STATUS(error_context, "ProcessDir"); DIR *directory; if (NULL != (directory = opendir(dirname))) { struct dirent *entry = NULL; char const *sep = NULL; size_t dirname_length = strlen(dirname); if (dirname[dirname_length-1] == '/') { sep = ""; } else { sep = "/"; } while (NULL != (entry = readdir(directory))) { if(strcmp(entry->d_name, ".") && strcmp(entry->d_name, "..")) { char *fullpathname = (char *)malloc(dirname_length + strlen(entry->d_name)+2); if (NULL != fullpathname) { struct stat buf; sprintf(fullpathname, "%s%s%s", dirname, sep, entry->d_name); stat(fullpathname, &buf); if(S_ISREG(buf.st_mode) && entry->d_name[0] != '.') { GAT_CREATE_STATUS_UNCOND(action(error_context, fullpathname, data)); } free(fullpathname); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); break; } } } closedir(directory); } return GAT_RETURN_STATUS(); } /** ProcessFile * Search a file for valid filenames and invoke an action on each one. * Finds all non-empty, non-commented out lines in the file and * strips leading and trailing whitespace before converting into * a full pathname and passing to a callback function. * * @param filename The full path to a file * @param action A callback function which does something with a file * @param data Data for the callback function. * * @return The number of files found. */ static GATResult ProcessFile(GATContext error_context, const char *filename, int (*action)(GATContext, const char *, void *), void *data) { GAT_USES_STATUS(error_context, "ProcessFile"); FILE *file = NULL; if(NULL != (file = fopen(filename, "r"))) { char *pos = NULL; char line[PATH_MAX+1]; char directory[PATH_MAX+1]; char fullpathname[PATH_MAX+1]; /* Get directory part of filename */ strncpy(directory, filename, PATH_MAX); for(pos = directory+strlen(directory); pos > directory && *pos != '/'; pos--) { /* Do nothing */ } if(*pos == '/') { *(pos+1) = 0; } else { /* filename was not absolute. Internal error. */ GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { while (NULL != fgets(line, PATH_MAX+1, file)) { /* Allow lines to be commented out. */ if(*line == '#') { continue; } /* Strip off trailing whitepace or newlines */ for(pos = line + strlen(line)-1; pos >= line; pos--) { if (isspace(*pos)) { *pos = 0; } else { break; } } /* Strip off preceding whitespace */ for(pos = line; 0 != *pos; pos++) { if(isspace(*pos)) { *pos = 0; } else { break; } } /* Now make path from a non-empty line */ if (*pos) { MakePath (directory, pos, 0, fullpathname, PATH_MAX+1); if (*fullpathname == '/') { GAT_CREATE_STATUS(action(error_context, fullpathname, data)); } else { /* something went wrong when processing the path. */ GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } } } } fclose(file); } else { /* Couldn't open file */ char buffer[MAX_PATH+100]; sprintf(buffer, "Couldn't open adaptor list file '%s'", filename); GAT_CREATE_STATUS_MSG(GAT_FILEOPEN_ERROR, buffer); } return GAT_RETURN_STATUS(); } /** MakePath * Search a delimited string and return full paths. * Parses a string, splitting it into tokens which it * assumes are path-names. It returns the first path-name * in the pathentry buffer, after converting it to an absolute path. * The return value is a pointer to the next path in the string. * * @param base The base for pathames - used if path starts with ./ * @param original The search string * @param sep The delimiter between different pathnames * @param pathentry A buffer to put the new pathname into * @param pathentry_length the length of the pathentry buffer * * @return The number of files found. */ static const char * MakePath(const char *base, const char *original, char sep, char *pathentry, int pathentry_length) { const char *place; char *current; int count; /* Is it an absolute or relative path. */ if(original[0] != '/') { if(base) { strncpy(pathentry, base, pathentry_length-1); } else { getcwd(pathentry, pathentry_length-1); } current = pathentry+strlen(pathentry); *current = '/'; current++; } else { current = pathentry; } /* Now parse this pathentry removing /./ and /../ * parts. */ for(place = original; *place && (current - pathentry) < pathentry_length; place++) { if(*place == sep) { break; } if(*place !='.' || (place > original && *(place-1) != '/')) { /* Just a normal character */ *current = *place; current++; } else if(*(place+1) == '/' || ! *(place+1) || *(place+1) == sep) { /* Embedded /./ - ignore */ place++; if(! *place || *place == sep) { break; } } else if(*(place+1) == '.' && (*(place+2) == '/' || ! *(place+2) || *(place+2) == sep)) { /* We have a /.. - so backtrack two slashes*/ for(count = 0; current > pathentry || count == 1; current--) { if(*current == '/') { count++; } if(count ==2) { current++; break; } } if(current == pathentry) { /* This is an error */ strcpy(pathentry, "Invalid path"); current = pathentry+strlen(pathentry); place = strchr(place, sep); break; } place +=2; if(! *place || *place == sep) { break; } } else { /* Just a normal character */ *current = *place; current++; } } if(current == pathentry) { /* Root directory */ *current = '/'; current++; } /* Null terminate */ *current = 0; if(place && *place == sep) { place++; } else if (place && ! *place) { place = NULL; } return place; } /** CanonicaliseName * Extract the canonical name of an adaptor from its full path name. * We need the name of the adaptor in order to invoke its * registration function. CanonicaliseName takes the path * to an adaptor and extracts the base filename from it. * Additionally, if it is a libtool library, it removes the "lib" * prefix which libtool insists on having. * * @param input The path to an adaptor file. * * @return A canonoical name for the adaptor. */ static char * CanonicaliseName(const char *original) { char *retval; const char *start; const char *end; char *pos; /* Find filename part of name */ start = strrchr(original, '/'); if(!start) { start = original; } else { start++; } /* Scan forward and end at any character not in [a-zA-Z0-9_-] */ for(end = start; *end && (isalnum(*end) || *end == '_' || *end == '-'); end++) { /* Do nothing */ } if(!strcmp(end,".la")) { /* It's a libtool library, which insists on having lib as * first three chars. */ if(start[0] == 'l' && start[1] == 'i' && start[2] == 'b') { start += 3; } } /* Allocate memory */ retval = (char *)malloc(end-start + 1); if(retval) { /* Copy data */ for(pos = retval; start < end ; start++, pos++) { *pos = *start; } *pos = 0; } return retval; } /* internal helper functions */ /* GATSelf_internal_GetGATJobId * * The function GATSelf_internal_GetGATJobId retrieves the GAT related job id * of the give job. * * @param self The GATSelf object to query for its GAT job id. * @param context The error context to use for error reporting. * @param The pointer to a variable, which should receive the GAT job id * associated with the current job. * * @return An error code. */ GATResult GATSelf_internal_GetGATJobId(GATSelf_const self, GATContext context, GATString_const *gatjobid) { if (NULL != self) { GAT_USES_STATUS(context, "GATSelf_internal_GetGATJobId"); if (NULL != gatjobid) { *gatjobid = self->gatjobid; } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } GATResult GATSelf_internal_CreateGATJobId(GATSelf_const self, GATContext context, GATString *gatjobid) { GAT_USES_STATUS(context, "GATSelf_internal_CreateGATJobId"); GAT_UNUSED_PARAMETER(self); if (NULL != gatjobid) { /* create a new GAT job id (here UUID) */ uuid_rc_t uuid_rc = UUID_RC_OK; uuid_t *uuid; char *str = NULL; if (UUID_RC_OK == (uuid_rc = uuid_create(&uuid)) && UUID_RC_OK == (uuid_rc = uuid_make(uuid, UUID_MAKE_V1)) && UUID_RC_OK == (uuid_rc = uuid_export(uuid, UUID_FMT_STR, (void **)&str, 0)) && UUID_RC_OK == (uuid_rc = uuid_destroy (uuid))) { char gatjobid_prefix[] = "GAT_JOBID:"; char buffer[UUID_LEN_STR + sizeof(gatjobid_prefix) +1]; strcpy(buffer, gatjobid_prefix); strcpy(&buffer[sizeof(gatjobid_prefix)-1], str); *gatjobid = GATString_Create(buffer, strlen(buffer)+1, "ASCII"); GAT_CREATE_STATUS_IF(NULL == *gatjobid, GAT_MEMORYFAILURE); } else { GAT_CREATE_STATUS(UUID_TO_GAT(uuid_rc)); } free(str); } return GAT_RETURN_STATUS(); } /* GATSelf_GetCPIInstanceData * * The function GATSelf_GetCPIInstanceData returns the CPI instance data, * associated with the given GATSelf object. * * @param object The object, for which to return the CPI instance data. * @param data The pointer to the variable, which should receive the * resulting CPI instance data. * * @return An error code. */ static GATResult GATSelf_GetCPIInstanceData(GATSelf object, void **data) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != object) { if (NULL != data) { *data = (void *)&object->data; retval = GAT_SUCCESS; } else { retval = GAT_INVALID_PARAMETER; } } return retval; } /** GATSelf_AddErrorMessageHandler * * The GATSelf_AddErrorMessageHandler function registeres the given callback * function with the engine. This callback function is used by the engine to * get the error message corresponding to a given error code. The callback * function is called for error codes belonging to the given facility (the * facility code is contained in the error code, namely bits 16...27). * * @param facility The facility code, for which this callback function has to * be called. * @param callback The callback function to call to get the error messages for * error codes belon ing to the given facility. * @param cookie The pointer to a variable, which receives a unique cookie * representing the registered function, which should be used to remove * the registration of this function later on. * * @return An error code. */ GATResult GATSelf_AddErrorMessageHandler(GATuint32 facility, GATErrorMessageHandler handler, GATuint32 *cookie) { GATResult retval = GAT_MEMORYFAILURE; if (NULL == error_message_handlers) { error_message_handlers = GATList_GATErrorMessageHandlerData_Create(); } if (NULL != error_message_handlers) { if (NULL != cookie) { GATErrorMessageHandlerData data; GATuint32 mycookie = ++error_cookie_jar; GATList_GATErrorMessageHandlerData_Iterator it = NULL; data.facility = facility; data.cookie = mycookie; data.handler = handler; it = GATList_GATErrorMessageHandlerData_Insert(error_message_handlers, GATList_GATErrorMessageHandlerData_End(error_message_handlers), data); if (NULL == it) { retval = GAT_MEMORYFAILURE; } else { retval = GAT_SUCCESS; *cookie = mycookie; } } else { retval = GAT_INVALID_PARAMETER; } } if (GAT_FAILED(retval) && NULL != error_message_handlers) { /* free the list, if it is empty */ if (0 == GATList_GATErrorMessageHandlerData_Size(error_message_handlers)) { GATList_GATErrorMessageHandlerData_Destroy(&error_message_handlers); } } return retval; } /** GATSelf_RemoveErrorMessageHandler * * The GATSelf_RemoveErrorMessageHandler function removes the registration of * the error message handler associated with the given cookie. */ GATResult GATSelf_RemoveErrorMessageHandler(GATuint32 *cookie) { GATResult retval = GAT_KEY_NOT_FOUND; if (NULL != cookie) { if (0 != *cookie && NULL != error_message_handlers) { GATList_GATErrorMessageHandlerData_Iterator it = GATList_GATErrorMessageHandlerData_Begin(error_message_handlers); GATList_GATErrorMessageHandlerData_Iterator end = GATList_GATErrorMessageHandlerData_End(error_message_handlers); for (/**/; it != end; it = GATList_GATErrorMessageHandlerData_Next(it)) { GATErrorMessageHandlerData *data = GATList_GATErrorMessageHandlerData_Get(it); if (NULL != data && data->cookie == *cookie) { GATList_GATErrorMessageHandlerData_Erase(error_message_handlers, it); retval = GAT_SUCCESS; break; } } } *cookie = 0; } if (NULL != error_message_handlers && 0 == GATList_GATErrorMessageHandlerData_Size(error_message_handlers)) { /* free the list, if it is empty */ GATList_GATErrorMessageHandlerData_Destroy(&error_message_handlers); } return retval; } /** GATSelf_ResolveErrorMessage * * The function GATSelf_ResolveErrorMessage returns an error message * associated with the given error code. * * @param err_code The error code, for which the system needs to get the error * message. * @param buffer The buffer, where to return the resulting error message. * @param length The size of the given buffer. If this size is insufficient for * the error message to return, the error callback function should return * the required length in the written output parameter and it should * additionally return the GAT_BUFFER_TOO_SMALL return value to the * caller. * @param written The pointer to a variable, which should receive the real * size of the generated error message. * * @return An error code. */ GATResult GATSelf_ResolveErrorMessage(GATResult err_code, char *buffer, GATuint32 length, GATuint32 *written) { GATResult retval = GAT_KEY_NOT_FOUND; if (NULL != error_message_handlers) { GATList_GATErrorMessageHandlerData_Iterator it = GATList_GATErrorMessageHandlerData_Begin(error_message_handlers); GATList_GATErrorMessageHandlerData_Iterator end = GATList_GATErrorMessageHandlerData_End(error_message_handlers); for (/**/; it != end; it = GATList_GATErrorMessageHandlerData_Next(it)) { GATErrorMessageHandlerData *data = GATList_GATErrorMessageHandlerData_Get(it); if (NULL != data && data->facility == GAT_RESULT_FACILITY(err_code)) { retval = data->handler(err_code, buffer, length, written); if (GAT_SUCCEEDED(retval) || GAT_BUFFER_TOO_SMALL == retval) { // found an error message handler, which knows about this error code break; } } } } return retval; } /* Error message handler functions */ static GATResult GATStatus_ErrorMessagesEngine(GATResult err_code, char *buffer, GATuint32 length, GATuint32 *written) { static char const *error_strings[] = { "GAT: No error", "GAT: Generic (unspecified error)", "GAT: Not implemented", "GAT: Out of memory", "GAT: Duplicate adaptorname", "GAT: Failed to load adaptor", "GAT: No appropriate adaptor registration function found", "GAT: Duplicate configuration key", "GAT: File open error (file not found?)", "GAT: Key not found", "GAT: Unexpected/wrong key type", "GAT: Invalid GAT handle", "GAT: Invalid parameter", "GAT: Unknown CPI structure version", "GAT: No registered CPI found", "GAT: Invalid encoding", "GAT: Incomplete enconding", "GAT: No matching CPI found", "GAT: No matching resource found", "GAT: This interface is not implemented by the given GAT object", "GAT: Unknown format", "GAT: Key already exists in this context", "GAT: Remote call failed", "GAT: Generic input/output error", "GAT: Invalid state", "GAT: Type mismatch", "GAT: Buffer too small", "GAT: Bad object conversion", "GAT: Invalid config file format", "GAT: The referenced GATContext instance is usable as error context only", }; GATResult retval = GAT_INVALID_PARAMETER; if (NULL != buffer && NULL != written) { GATuint32 code = GAT_RESULT_CODE(err_code); if (0 <= code && code < sizeof(error_strings)/sizeof(error_strings[0])) { size_t len = strlen(error_strings[code]); if (length > len) { strncpy(buffer, error_strings[code], length); buffer[length-1] = '\0'; *written = length; retval = GAT_SUCCESS; } else { *written = len+1; retval = GAT_BUFFER_TOO_SMALL; } } } return retval; } static GATResult GATStatus_ErrorMessagesXds(GATResult err_code, char *buffer, GATuint32 length, GATuint32 *written) { static char const *error_strings[] = { "Xds: No error", "Xds: Out of memory", "Xds: Buffer overflow", "Xds: Invalid parameter", "Xds: Type mismatch", "Xds: Unknown engine", "Xds: Invalid mode", "Xds: Buffer underflow", "Xds: Unknown error", "Xds: System error", }; GATResult retval = GAT_INVALID_PARAMETER; if (NULL != buffer && NULL != written) { GATuint32 code = GAT_RESULT_CODE(err_code); if (0 <= code && code < sizeof(error_strings)/sizeof(error_strings[0])) { size_t len = strlen(error_strings[code]); if (length > len) { strncpy(buffer, error_strings[code], length); buffer[length-1] = '\0'; *written = length; retval = GAT_SUCCESS; } else { *written = len+1; retval = GAT_BUFFER_TOO_SMALL; } } } return retval; } static GATResult GATStatus_ErrorMessagesUuid(GATResult err_code, char *buffer, GATuint32 length, GATuint32 *written) { static char const *error_strings[] = { "Uuid: No error", "Uuid: Invalid parameter", "Uuid: Out of memory", "Uuid: System error", "Uuid: Internal error", "Uuid: Not implemented", }; GATResult retval = GAT_INVALID_PARAMETER; if (NULL != buffer && NULL != written) { GATuint32 code = GAT_RESULT_CODE(err_code); if (0 <= code && code < sizeof(error_strings)/sizeof(error_strings[0])) { size_t len = strlen(error_strings[code]); if (length > len) { strncpy(buffer, error_strings[code], length); buffer[length-1] = '\0'; *written = length; retval = GAT_SUCCESS; } else { *written = len+1; retval = GAT_BUFFER_TOO_SMALL; } } } return retval; } static GATResult GATStatus_ErrorMessagesRegex(GATResult err_code, char *buffer, GATuint32 length, GATuint32 *written) { static char const *error_strings[] = { "Regex: Success", "Regex: Didn't find a match (for regexec)", "Regex: Invalid pattern", "Regex: Not implemented", "Regex: Invalid character class name", "Regex: Trailing backslash", "Regex: Invalid back reference", "Regex: Unmatched left bracket", "Regex: Parenthesis imbalance", "Regex: Unmatched \\{", "Regex: Invalid contents of \\{\\}", "Regex: Invalid range end", "Regex: Ran out of memory", "Regex: No preceding regulare for repetition operand", "Regex: Premature end", "Regex: Compiled pattern bigger than 2^16 bytes", "Regex: Unmatched ) or \\); not returned from regcomp" }; GATResult retval = GAT_INVALID_PARAMETER; if (NULL != buffer && NULL != written) { GATuint32 code = GAT_RESULT_CODE(err_code); if (0 <= code && code < sizeof(error_strings)/sizeof(error_strings[0])) { size_t len = strlen(error_strings[code]); if (length > len) { strncpy(buffer, error_strings[code], length); buffer[length-1] = '\0'; *written = length; retval = GAT_SUCCESS; } else { *written = len+1; retval = GAT_BUFFER_TOO_SMALL; } } } return retval; } static GATResult GATStatus_ErrorMessagesSQLite(GATResult err_code, char *buffer, GATuint32 length, GATuint32 *written) { static char const *error_strings[] = { "SQLite: Successful result", "SQLite: SQL error or missing database", "SQLite: An internal logic error in SQLite", "SQLite: Access permission denied", "SQLite: Callback routine requested an abort", "SQLite: The database file is locked", "SQLite: A table in the database is locked", "SQLite: A malloc() failed", "SQLite: Attempt to write a readonly database", "SQLite: Operation terminated by sqlite_interrupt()", "SQLite: Some kind of disk I/O error occurred", "SQLite: The database disk image is malformed", "SQLite: Table or record not found", "SQLite: Insertion failed because database is full", "SQLite: Unable to open the database file", "SQLite: Database lock protocol error", "SQLite: (Internal Only) Database table is empty", "SQLite: The database schema changed", "SQLite: Too much data for one row of a table", "SQLite: Abort due to constraint violation", "SQLite: Data type mismatch", "SQLite: Library used incorrectly", "SQLite: Uses OS features not supported on host", "SQLite: Authorization denied", "SQLite: Auxiliary database format error", "SQLite: 2nd parameter to sqlite_bind out of range", "SQLite: File opened that is not a database file" }; GATResult retval = GAT_INVALID_PARAMETER; if (NULL != buffer && NULL != written) { GATuint32 code = GAT_RESULT_CODE(err_code); if (0 <= code && code < sizeof(error_strings)/sizeof(error_strings[0])) { size_t len = strlen(error_strings[code]); if (length > len) { strncpy(buffer, error_strings[code], length); buffer[length-1] = '\0'; *written = length; retval = GAT_SUCCESS; } else { *written = len+1; retval = GAT_BUFFER_TOO_SMALL; } } else if (SQLITE_ROW == code) { char const *err_msg = "SQLite: sqlite_step() has another row ready"; size_t len = strlen(err_msg); if (length > len) { strncpy(buffer, err_msg, length); buffer[length-1] = '\0'; *written = length; retval = GAT_SUCCESS; } else { *written = len+1; retval = GAT_BUFFER_TOO_SMALL; } } else if (SQLITE_DONE == code) { char const *err_msg = "SQLite: sqlite_step() has finished executing"; size_t len = strlen(err_msg); if (length > len) { strncpy(buffer, err_msg, length); buffer[length-1] = '\0'; *written = length; retval = GAT_SUCCESS; } else { *written = len+1; retval = GAT_BUFFER_TOO_SMALL; } } } return retval; } static GATResult GATStatus_ErrorMessagesPosix(GATResult err_code, char *buffer, GATuint32 length, GATuint32 *written) { GATResult retval = GAT_INVALID_PARAMETER; if (NULL != buffer && NULL != written) { GATuint32 code = GAT_RESULT_CODE(err_code); if (0 == code) { char const *no_error = "Posix: No error."; size_t len = strlen(no_error); if (length > len) { strncpy(buffer, no_error, length); buffer[length-1] = '\0'; retval = GAT_SUCCESS; } else { *written = len+1; retval = GAT_BUFFER_TOO_SMALL; } } else { char const *error_text = strerror(code); size_t posix_len = strlen("Posix: "); size_t len = strlen(error_text); if (length > len+posix_len) { strcpy(buffer, "Posix: "); strncat(buffer, error_text, length-posix_len); buffer[length+posix_len-2] = '\0'; /* truncate trailing '\n' */ *written = length+posix_len-1; retval = GAT_SUCCESS; } else { *written = len; retval = GAT_BUFFER_TOO_SMALL; } } } return retval; } /* I hate IRIX. Why? Because you need to define the symbols * 'allow_severity' and 'deny_severity' to use getenv. Oops you * say, and Oops it is! So, why is that? IRIX defined getenv not * in libc.so, oh no, but in libwrapp.so. Well, why not - but, * also, libwrap.so defines some syslog stuff, which require the * user to define log severity flags externally to the lib. Uhm. * Whatever - if configure deremines that this is the case, the * code below is used, and we are fine... :-) * * -- Andre */ #ifdef NEED_SEVERITY_HACK #include <sys/syslog.h> int allow_severity = LOG_INFO; int deny_severity = LOG_WARNING; #endif