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

GATAdvertService.c Go to the documentation of this file. /** @file GATAdvertService.c * Source file for the GATAdvertService class. * * @date Fri Feb 13 2004 * * @version $Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/src/GATAdvertService.c,v 1.12 2004/04/29 14:18:49 hartmutkaiser Exp $ * * Copyright (C) Hartmut Kaiser * This file is part of the GAT Engine. * Contributed by Hartmut Kaiser <hartmutkaiser [at] t-online [dot] 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/GATAdvertService.c,v 1.12 2004/04/29 14:18:49 hartmutkaiser Exp $"; /* System Header objects */ #include <stdlib.h> #include <string.h> #include <assert.h> #include <time.h> #include <errno.h> #include <sys/utsname.h> /* GAT Header objects */ #include "GAT.h" #include "GATUtil.h" #include "GATInternal.h" #include "GATRegistry.h" #include "GATAdvertServiceCPI.h" #include "GATMetricEvent.h" #include "GATMonitorable.h" /* define the vtable types */ GATOBJECT_DEFINE_VTABLE(GATAdvertService); GATMONITORABLE_DEFINE_VTABLE(GATAdvertService); /* define the converters to/from GATObject */ GATOBJECT_DEFINE_CONVERTERS(GATAdvertService) /* Macros */ /* Structures, unions and enums */ struct GATAdvertService_S { /* supported interfaces */ GATAdvertService_vtable *GATObject__vtable; GATAdvertService_IMonitorable_vtable *GATMonitorable__vtable; /* instance data */ GATAdvertServiceCPI_Instance data; /* instance data of the corresponding CPI object */ GATAdvertServiceCPI cpi; /* CPI object to use for all subsequent operations */ GATAdvertServiceCPIList cpilist; /* CPI list of appropriate CPI objects */ }; /* Static function prototypes */ static GATResult GATAdvertService_GetCPIInstanceData(GATAdvertService object, void **data); static GATResult GATAdvertService_EnsureMetaDataItem(GATContext context, char const *item, GATTable metadata, char const *defaultvalue); static char * GATAdvertService_ExtractName(GATString_const path); static GATResult GATAdvertService_ResolvePath( GATString_const cwd, GATString_const path, char **absolute_path); /* file scope variables */ GATAdvertService_vtable GATAdvertService__vtable = { GATAdvertService_GetType, GATAdvertService_Destroy, GATAdvertService_Equals, GATAdvertService_Clone, GATAdvertService_GetInterface, GATAdvertService_GetCPIInstanceData }; static GATAdvertService_IMonitorable_vtable GATAdvertService_IMonitorable__vtable = { GATAdvertService_AddMetricListener, GATAdvertService_RegisterPolling, GATAdvertService_RemoveRegisteredMetric, GATAdvertService_GetMetrics }; /* External functions */ /** GATAdvertService_Create * @brief Create a new GATAdvertService object * * The function @c GATAdvertService_Create creates a new * GATAdvertService object * * @param context The GAT context to use while the initialisation of the * new object. * @param preferences The preferences to use while selecting the adaptor for * the corresponding CPI. * * @return Returns a handle to the newly created GATAdvertService object. * Returns 0 (zero) if an error occurs. */ GATAdvertService GATAdvertService_Create(GATContext context, GATPreferences_const preferences) { GAT_STATUS_APIENTRY(context, "GATAdvertService_Create"); GATAdvertService new_advertservice = (GATAdvertService) malloc( sizeof(struct GATAdvertService_S)); if (NULL != new_advertservice) { memset(new_advertservice, 0, sizeof(struct GATAdvertService_S)); new_advertservice->GATObject__vtable = &GATAdvertService__vtable; new_advertservice->GATMonitorable__vtable = &GATAdvertService_IMonitorable__vtable; new_advertservice->data.context = context; new_advertservice->data.source = GATAdvertService_ToGATObject_const(new_advertservice); new_advertservice->data.pwd = GATString_Create("/", 2, "ASCII"); GAT_CREATE_STATUS_IF(NULL == new_advertservice->data.pwd, GAT_MEMORYFAILURE); /* find a CPI object, which can handle this object */ { GATRegistry_const registry = GATContext_internal_GetRegistry(context); /* use default preferences, if appropriate */ if (NULL == preferences) { preferences = GATContext_GetPreferences(context); } new_advertservice->cpilist = GATRegistry_FindGATAdvertServiceCPI(registry, preferences); if (NULL == new_advertservice->cpilist) { GAT_CREATE_STATUS(GAT_NO_REGISTERED_CPI); } else if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { /* create a new instance of the CPI provider */ GATBool found_cpi = GATFalse; GATAdvertServiceCPIList current = NULL; for(current = new_advertservice->cpilist; NULL != current; current = current->next) { GAT_CREATE_STATUS(GATAdvertServiceCPI_CreateInstance(current->cpi, &new_advertservice->data)); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { new_advertservice->cpi = current->cpi; found_cpi = GATTrue; break; } } /* no available CPI object can handle this */ if (GATFalse == found_cpi) { GAT_CREATE_STATUS(GAT_NO_REGISTERED_CPI); } else { /* now, initialise the monitoring framework with the help of the CPI provider found */ GATList_GATMetric metrics = NULL; GATResult retval = GATAdvertServiceCPI_GetMetrics(new_advertservice->cpi, &new_advertservice->data, &metrics); if (GAT_SUCCEEDED(retval)) { new_advertservice->data.monitorable = GATMonitorable_Impl_Create(metrics); if (NULL == new_advertservice->data.monitorable) { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } GATList_GATMetric_Destroy(&metrics); } else if (GAT_NOTIMPL == retval) { retval = GAT_SUCCESS; /* no monitoring supported here */ } else { GAT_CREATE_STATUS(retval); } /* register this object with the engine */ GAT_CREATE_STATUS(GATRegistry_AddGATAdvertServiceToCPIList(context, new_advertservice->cpi, new_advertservice)); } } } } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } /* error handling */ if (GAT_FAILED(GAT_CURRENT_STATUS())) { GATAdvertService_Destroy(&new_advertservice); } GAT_STORE_STATUS(); return new_advertservice; } /** void GATAdvertService_Destroy(GATAdvertService *resource) * * The function GATAdvertService_Destroy is the destructor used to * free all the memory allocated by an GATAdvertService instance. * * @param description The pointer to the GATAdvertService to destroy */ void GATAdvertService_Destroy(GATAdvertService *object) { if (NULL != object && NULL != *object) { GATString_Destroy(&(*object)->data.pwd); GATMonitorable_Impl_Destroy(&(*object)->data.monitorable); if (NULL != (*object)->cpi) /* during creation this may be zero */ { GATRegistry_RemoveGATAdvertServiceFromCPIList((*object)->data.context, (*object)->cpi, *object); GATAdvertServiceCPI_DestroyInstance((*object)->cpi, &(*object)->data); } GATAdvertServiceCPIList_Destroy((*object)->cpilist); free(*object); *object = NULL; } } /** GATAdvertService_Equals * @brief Compare two GATAdvertService objects * * The function @c GATAdvertService_Equals compares two objects of the * @c GATAdvertService 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 GATAdvertService_Equals(GATAdvertService_const lhs, GATAdvertService_const rhs, GATBool *isequal) { if (NULL != lhs && NULL != rhs) { GAT_STATUS_APIENTRY(lhs->data.context, "GATAdvertService_Equals"); if (NULL != isequal) { GAT_CREATE_STATUS(GATString_Equals(lhs->data.pwd, rhs->data.pwd, isequal)); if (GATTrue == *isequal) { GAT_CREATE_STATUS(GATAdvertServiceCPI_EqualsInstance(lhs->cpi, &lhs->data, &rhs->data, isequal)); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** GATAdvertService_Clone * @brief Clone the given GATAdvertService * * The function @c GATAdvertService_Clone generates a (deep) copy of * the given GATAdvertService. * * @param description The object to clone * @param new_object The pointer, through which the result is to be * returned. * * @return An error type. */ GATResult GATAdvertService_Clone(GATAdvertService_const handle, GATAdvertService *new_handle) { if (NULL != handle) { GAT_STATUS_APIENTRY(handle->data.context, "GATAdvertService_Clone"); if (NULL == new_handle) { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } else { struct GATAdvertService_S const *object = handle; GATAdvertService new_object = (GATAdvertService)malloc(sizeof(struct GATAdvertService_S)); *new_handle = NULL; if (NULL == new_object) { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } else { memset(new_object, 0, sizeof(struct GATAdvertService_S)); new_object->GATObject__vtable = &GATAdvertService__vtable; new_object->GATMonitorable__vtable = &GATAdvertService_IMonitorable__vtable; new_object->data.context = object->data.context; new_object->data.source = GATAdvertService_ToGATObject_const(new_object); new_object->cpilist = GATRegistry_CloneGATAdvertServiceCPIList( object->cpilist); if (NULL == new_object->cpilist) { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } GAT_CREATE_STATUS(GATString_Clone(object->data.pwd, &new_object->data.pwd)); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { /* re-find the cpi to use */ GATAdvertServiceCPIList current = object->cpilist; GATAdvertServiceCPIList new_current = new_object->cpilist; for (/**/; NULL != current; current = current->next, new_current = new_current->next) { if (current->cpi == object->cpi) { new_object->cpi = new_current->cpi; break; } } assert(NULL != new_object->cpi); /* clone the instance data */ GAT_CREATE_STATUS(GATAdvertServiceCPI_CloneInstance(object->cpi, &object->data, &new_object->data)); /* clone the monitoring data */ if (NULL != object->data.monitorable) { GAT_CREATE_STATUS(GATMonitorable_Impl_Clone(object->data.monitorable, &new_object->data.monitorable)); } GAT_CREATE_STATUS(GATRegistry_AddGATAdvertServiceToCPIList( new_object->data.context, new_object->cpi, new_object)); } /* detroy the newly allocated object, if some error occured */ if (GAT_FAILED(GAT_CURRENT_STATUS())) { GATAdvertService_Destroy(&new_object); } else { /* return the new object */ *new_handle = new_object; } } } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** GATType GATAdvertService_GetType(GATAdvertService_const resource) * @brief Return the type of the GATAdvertService * * The function @c GATAdvertService_GetType always returns * @c #GATType_GATAdvertService. * * @param object The object to inspect * * @return Returns always @c #GATType_GATAdvertService. */ GATType GATAdvertService_GetType(GATAdvertService_const object) { GAT_UNUSED_PARAMETER(object); return GATType_GATAdvertService; } /** GATResult GATAdvertService_GetInterface(GATAdvertService_const file, GATInterface iftype, void const **ifp) * @brief Get an interface supported by a GATObject * * The function GATAdvertService_GetInterface allows to get a pointer to an * additional interface supported by this GATAdvertService. * * @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 GATAdvertService_GetInterface(GATAdvertService_const object, GATInterface iftype, void const **ifp) { if (NULL != object) { GAT_STATUS_APIENTRY(object->data.context, "GATAdvertService_GetInterface"); if (NULL != ifp) { if (GATInterface_IMonitorable == iftype && NULL != object->data.monitorable) { *ifp = (void const *) &object->GATMonitorable__vtable; } else { ifp = NULL; GAT_CREATE_STATUS(GAT_NO_INTERFACE); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /* GATMonitorable API */ /** GATAdvertService_AddMetricListener * * The function GATAdvertService_AddMetricListener adds the passed instance of a * GATMetricListener to the list of GATMetricListeners which are notified of * fired GATMetricEvents of the type described by the provided GATMetric * instance. * * @param object The GATAdvertService instance to add the GATMetricListener to. * @param listener The GATMetricListener to call, when the corresponding * GATMetricEvent is fired. * @param listener_data The client supplied data, which will be passed through * to the GATMetricListener. * @param metric The GATMetric instance describing the GATMetricEvent to pass * to the GATMetricListener. * @param cookie The returned value should be used to remove the * GATMetricListener from this GATMonitorable. * * @return An error code. */ GATResult GATAdvertService_AddMetricListener(GATAdvertService object, GATMetricListener listener, void *listener_data, GATMetric metric, GATuint32 *cookie) { if (NULL != object) { GAT_STATUS_APIENTRY(object->data.context, "GATAdvertService_AddMetricListener"); if (NULL != object->data.monitorable) { GAT_CREATE_STATUS(GATMonitorable_Impl_AddMetricListener( object->data.monitorable, listener, listener_data, metric, cookie)); } else { /* this may happen, if the adaptor has not registered any GATMetrics */ GAT_CREATE_STATUS(GAT_NO_INTERFACE); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** GATAdvertService_RegisterPolling * * The function GATAdvertService_RegisterPolling registers a continuous * metric with the given GATAdvertService instance. * * @param object The GATAdvertService instance to register the metric with. * @param metric The GATMetric instance describing the GATMetricEvent to pass * to the GATMetricListener. This metric instance must be of type * GATMeasurementType_Continuous, otherwise an error is returned. * @param event The pointer to a variable, which should receive the resulting * GATMetricEvent. The GATMetricEvent instance should be freed by the * caller when it isn't used anymore. * @param cookie The returned value should be used to remove the * GATMetricListener from this GATAdvertService. * * @return An error code. */ GATResult GATAdvertService_RegisterPolling(GATAdvertService object, GATMetric metric, GATMetricEvent *event, GATuint32 *cookie) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != object) { GAT_STATUS_APIENTRY(object->data.context, "GATAdvertService_RegisterPolling"); if (NULL != object->data.monitorable) { GAT_CREATE_STATUS(GATMonitorable_Impl_RegisterPolling( object->data.monitorable, metric, 0, cookie)); /* ask the CPI provider to return the corresponding metric event */ GAT_CREATE_STATUS(GATAdvertServiceCPI_GetMetricEvent(object->cpi, &object->data, metric, event)); if (GAT_FAILED(GAT_CURRENT_STATUS()) && NULL != cookie && 0 != *cookie) { GATMonitorable_Impl_RemoveRegisteredMetric(object->data.monitorable, metric, *cookie); *cookie = 0; } } else { /* this may happen, if the adaptor has not registered any GATMetrics */ GAT_CREATE_STATUS(GAT_NO_INTERFACE); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** GATAdvertService_RemoveRegisteredMetric * * The function GATAdvertService_RemoveRegisteredMetric removes a GATMetricListener, * which was previously registered with GATAdvertService_AddMetricListener. * * @param object The GATAdvertService instance to remove the GATMetricListener from. * @param listener The GTAMetricListener to call, when the corresponding * GATMetricEvent is fired. * @param metric The GATMetric instance describing the GATMetricEvent to pass * to the GATMetricListener. * @param cookie This value identifies the GATMetricListener to remove, it * was returned from the corresponding GATMonitorable_AddMetricListener * or GATMonitorable_MetricRegisterPolling functions. * * @return An error code. */ GATResult GATAdvertService_RemoveRegisteredMetric(GATAdvertService object, GATMetric metric, GATuint32 cookie) { if (NULL != object) { GAT_STATUS_APIENTRY(object->data.context, "GATAdvertService_RemoveRegisteredMetric"); if (NULL != object->data.monitorable) { GAT_CREATE_STATUS(GATMonitorable_Impl_RemoveRegisteredMetric( object->data.monitorable, metric, cookie)); } else { /* this may happen, if the adaptor has not registered any GATMetrics */ GAT_CREATE_STATUS(GAT_NO_INTERFACE); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** GATAdvertService_GetMetrics * * The function GATAdvertService_GetMetrics returns a list of metrics supported * by this GATAdvertService. * * @param object The GATAdvertService instance, for which the supported metrics * should be returned. * @param metrics The pointer to the variable, which receives the resulting * list of metrics. * * @return An error code. */ GATResult GATAdvertService_GetMetrics(GATAdvertService_const object, GATList_GATMetric *metrics) { if (NULL != object) { GAT_STATUS_APIENTRY(object->data.context, "GATAdvertService_GetMetrics"); if (NULL != object->data.monitorable) { GAT_CREATE_STATUS(GATMonitorable_Impl_GetMetrics( object->data.monitorable, metrics)); } else { /* this may happen, if the adaptor has not registered any GATMetrics */ GAT_CREATE_STATUS(GAT_NO_INTERFACE); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /* API specific functions */ /** GATAdvertService_Add * * The function GATAdvertService_Add adds an Advertizable instance and related * meta data to the GATAdvertService, at path (absolute or relative to PWD). * If an GATAdvertService entry exists at the specified path, that entry gets * overwritten. * * @param object The GATAdvertService instance, to which the advertisable * should be added. * @param advertisable The advertisable object, which should be stored in the * given advertservice. * @param metadata The meta data to rassociate with the newly created entry. * @param path The path inside the advert service, where the newly created * entry is to be stored. * * @return An error code. */ GATResult GATAdvertService_Add(GATAdvertService object, GATObject_const advertisable, GATTable metadata, GATString_const path) { if (NULL != object) { GAT_STATUS_APIENTRY(object->data.context, "GATAdvertService_Add"); if (NULL != path) { /* verify, that a GAT_NAME and GAT_PATH metadata attributes are given, supply default values, if appropriate */ char *name = GATAdvertService_ExtractName(path); char *resolved_path = NULL; struct utsname sysinfo; time_t curr_time = 0; char buffer[64]; char *newline = NULL; GAT_CREATE_STATUS_IF(NULL == name, GAT_MEMORYFAILURE); GAT_CREATE_STATUS(GATAdvertService_ResolvePath(object->data.pwd, path, &resolved_path)); GAT_CREATE_STATUS(GATAdvertService_EnsureMetaDataItem(object->data.context, "GAT_NAME", metadata, name)); GAT_CREATE_STATUS(GATAdvertService_EnsureMetaDataItem(object->data.context, "GAT_PATH", metadata, resolved_path)); GAT_CREATE_STATUS(GATAdvertService_EnsureMetaDataItem(object->data.context, "GAT_TYPE", metadata, GATType_GetName(GATObject_GetType(advertisable)))); GAT_CREATE_STATUS_IF(uname (&sysinfo) < 0, POSIX_TO_GAT(errno)); GAT_CREATE_STATUS(GATAdvertService_EnsureMetaDataItem(object->data.context, "GAT_HOSTNAME", metadata, sysinfo.nodename)); curr_time = time(NULL); strcpy(buffer, asctime(gmtime(&curr_time))); newline = strchr(buffer, '\n'); if (NULL != newline) { *newline = '\0'; } strcat(buffer, " GMT"); GAT_CREATE_STATUS(GATAdvertService_EnsureMetaDataItem(object->data.context, "GAT_CREATIONTIME", metadata, buffer)); free(name); free(resolved_path); /* add the advertisable to the advert service */ GAT_CREATE_STATUS(GATAdvertServiceCPI_Add(object->cpi, &object->data, advertisable, metadata, path)); } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** GATAdvertService_Delete * * The function GATAdvertService_Delete deletes the specified entry from the * GATAdvertService. * * @param object The GATAdvertService instance, from which the given path * should be deleted. * @param path The path of the entry to delete from the given advert service. * * @return An error code. */ GATResult GATAdvertService_Delete(GATAdvertService object, GATString_const path) { if (NULL != object) { GAT_STATUS_APIENTRY(object->data.context, ""); GAT_CREATE_STATUS(GATAdvertServiceCPI_Delete(object->cpi, &object->data, path)); return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** GATAdvertService_GetMetaData * * The function GATAdvertService_GetMetaData gets the meta data for the * specified AD entry. * * @param object The GATAdvertService instance, from which the metadata of the * given path should be returned. * @param path The path of the entry, for which the meta data should be * retrieved. * @param The pointer to a variable, which receives the requested meta data * (the returned GATTable object should be free'd by the user of this * function). * * @return An error code. */ GATResult GATAdvertService_GetMetaData(GATAdvertService_const object, GATString_const path, GATTable *metadata) { if (NULL != object) { GAT_STATUS_APIENTRY(object->data.context, "GATAdvertService_GetMetaData"); GAT_CREATE_STATUS(GATAdvertServiceCPI_GetMetaData(object->cpi, &object->data, path, metadata)); return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** GATAdvertService_GetAdvertisable * * The function GATAdvertService_GetAdvertisable gets the Advertisable instance * for the specified GATAdvertService entry. * * @param object The GATAdvertService instance, from which the advertisable of * the given path should be returned. * @param path The path of the entry, for which the stroed advertisable should * be retrieved. * @param advertisable The pointer to a variable, which should receive the * requested advertisable object (the returned GATObject should be * free'd by the user of this function). * * @return An error code. */ GATResult GATAdvertService_GetAdvertisable(GATAdvertService_const object, GATString_const path, GATObject *advertisable) { if (NULL != object) { GAT_STATUS_APIENTRY(object->data.context, "GATAdvertService_GetAdvertisable"); GAT_CREATE_STATUS(GATAdvertServiceCPI_GetAdvertisable(object->cpi, &object->data, path, advertisable)); return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** GATAdvertService_Find * * The function GATAdvertService_Find queries the GATAdvertService for entries * matching the specified set of meta data. * * @param object The GATAdvertService instance, inside which the query should * be executed. * @param metadata The meta data search criteria to use for the query. * @param paths The pointer to a variable, which should receive the list of * paths pointing to matching entries inside the given advert service * (the returned list of strings should be free'd by the user of this * function). * * @return An error code. */ GATResult GATAdvertService_Find(GATAdvertService_const object, GATTable_const metadata, GATList_String *paths) { if (NULL != object) { GAT_STATUS_APIENTRY(object->data.context, "GATAdvertService_Find"); GAT_CREATE_STATUS(GATAdvertServiceCPI_Find(object->cpi, &object->data, metadata, paths)); return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** GATAdvertService_SetPWD * * The function GATAdvertService_SetPWD specifies the element of the * GATAdvertService namespace to be used as reference for relative paths. * * @param object The GATAdvertService instance, for which the reference should * be set. * @param path The path referencing the namespace element to be used as the * reference for relative paths. * * @return An error code. */ GATResult GATAdvertService_SetPWD(GATAdvertService object, GATString_const path) { if (NULL != object) { GAT_STATUS_APIENTRY(object->data.context, "GATAdvertService_SetPWD"); char const *pathstr = GATString_GetBuffer(path); if (NULL != pathstr && '/' == pathstr[0]) { GATString_Destroy(&object->data.pwd); GAT_CREATE_STATUS(GATString_Clone(path, &object->data.pwd)); } else { /* the path should start with a '/' */ GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** GATAdvertService_GetPWD * * The function GATAdvertService_GetPWD gets the path of the element of the * GATAdvertService namespace, which is used as reference for relative paths. * * @param object The GATAdvertService instance, for which the reference should * be retrieved. * @param path The pointer of the variable, which should receive the path * referencing the namespace element, which is used as the reference for * relative paths. * * @return An error code. */ GATResult GATAdvertService_GetPWD(GATAdvertService object, GATString *path) { if (NULL != object) { GAT_STATUS_APIENTRY(object->data.context, "GATAdvertService_SetPWD"); GAT_CREATE_STATUS(GATString_Clone(object->data.pwd, path)); return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /* Local functions */ /* GATAdvertService_GetCPIInstanceData * * The function GATAdvertService_GetCPIInstanceData returns the CPI instance data, * associated with the given GATAdvertService 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 GATAdvertService_GetCPIInstanceData(GATAdvertService object, void **data) { if (NULL != object) { GAT_USES_STATUS(object->data.context, "GATAdvertService_GetCPIInstanceData"); if (NULL != data) { *data = (void *)&object->data; } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** GATAdvertService_EnsureMetaDataItem * * Ensure, that a given item was inserted into the GATTable, supply a default * value, if appropriate. */ static GATResult GATAdvertService_EnsureMetaDataItem(GATContext context, char const *item, GATTable metadata, char const *defaultvalue) { GAT_USES_STATUS(context, "GATAdvertService_EnsureMetaDataItem"); if (GAT_FAILED(GATTable_Get_String(metadata, item, 0, 0))) { GAT_CREATE_STATUS(GATTable_Add_String(metadata, item, defaultvalue)); } return GAT_RETURN_STATUS(); } /** GATAdvertService_ExtractName * * Extract the name component from the given path. */ static char * GATAdvertService_ExtractName(GATString_const path) { char const *pathstr = GATString_GetBuffer(path); char *last_delim = strrchr(pathstr, '/'); char *result = NULL; if (NULL == last_delim) { result = GATUtil_strdup(pathstr); } else { result = GATUtil_strdup(last_delim+1); } return result; } /** GATAdvertService_ResolvePath * */ static GATResult GATAdvertService_ResolvePath( GATString_const cwd, GATString_const path, char **absolute_path) { GATResult retval = GAT_INVALID_PARAMETER; char *new_path = NULL; char const *pwd = GATString_GetBuffer(cwd); char const *pathstr = GATString_GetBuffer(path); if (NULL != pwd && NULL != pathstr) { int len = strlen(pwd); if (0 == len) { retval = GAT_INVALID_PARAMETER; } else if ('/' != pathstr[0]) { /* the given path is relative */ retval = GATUtil_appendstring(&new_path, pwd); if (GAT_SUCCEEDED(retval) && '/' != new_path[len-1]) { /* make sure the pwd ends with an '/' */ retval = GATUtil_appendstring(&new_path, "/"); } if (GAT_SUCCEEDED(retval)) { /* append the relative part of the path */ retval = GATUtil_appendstring(&new_path, pathstr); } } else { /* the given path is absolute */ new_path = GATUtil_strdup(pathstr); if (NULL == new_path) { retval = GAT_MEMORYFAILURE; } else { retval = GAT_SUCCESS; } } /* return the complete path */ if (GAT_SUCCEEDED(retval)) { if (NULL != absolute_path) { *absolute_path = new_path; } else { retval = GAT_INVALID_PARAMETER; } } if (GAT_FAILED(retval)) { free(new_path); } } return retval; }