void *
globus_extension_registry_remove(
globus_extension_registry_t * registry,
void * symbol)
{
globus_l_extension_handle_t * entry;
void * datum = NULL;
GlobusFuncName(globus_extension_registry_remove);
GlobusExtensionDebugEnterSymbol(registry->user_hashing ? "" : symbol);
globus_rmutex_lock(&globus_l_extension_mutex);
{
if(registry->initialized)
{
entry = (globus_l_extension_handle_t *)
globus_hashtable_lookup(®istry->table, (void *) symbol);
if(entry && entry->datum)
{
datum = entry->datum;
globus_hashtable_remove(®istry->table, (void *) symbol);
if(--entry->ref == 0)
{
globus_free(entry);
}
}
}
}
globus_rmutex_unlock(&globus_l_extension_mutex);
GlobusExtensionDebugExit();
return datum;
}
/******************************************************************************
Function: globus_gass_server_ez_shutdown()
Description:
Parameters:
Returns:
******************************************************************************/
int
globus_gass_server_ez_shutdown(globus_gass_transfer_listener_t listener)
{
int rc;
void * user_arg = GLOBUS_NULL;
globus_hashtable_remove(&globus_l_gass_server_ez_listeners,
(void *)listener);
rc=globus_gass_transfer_close_listener(listener,
globus_l_gass_server_ez_close_callback,
user_arg);
return rc;
} /* globus_gass_server_ez_shutdown() */
/**
* Unregister protocol.
* @ingroup globus_gass_transfer_protocol
*
* This function unregisters a protocol module handler from the GASS Transfer
* library. If this succeeds, then users of the library may no longer
* user URLs with the protocol scheme implemented by this module descriptor
* in GASS Transfer operations.
*
* @param proto_desc
* The protocol module descriptor. See the "@ref
* globus_gass_transfer_protocol" section of the manual for information
* on this structure.
*
* @retval GLOBUS_SUCCESS
* The protocol module was successfully registered with GASS.
* @retval GLOBUS_GASS_TRANSFER_ERROR_NULL_POINTER
* The @a proto_desc parameter was @a GLOBUS_NULL.
* @retval GLOBUS_GASS_TRANSFER_ERROR_INVALID_USE
* A protocol module has not been registered with GASS to
* handle this URL scheme.
*/
int
globus_gass_transfer_proto_unregister_protocol(
globus_gass_transfer_proto_descriptor_t * proto_desc)
{
globus_gass_transfer_proto_descriptor_t * tmp;
if(proto_desc == GLOBUS_NULL)
{
return GLOBUS_GASS_TRANSFER_ERROR_NULL_POINTER;
}
tmp = globus_hashtable_lookup(&globus_i_gass_transfer_protocols,
proto_desc->url_scheme);
if(tmp)
{
tmp = globus_hashtable_remove(&globus_i_gass_transfer_protocols,
proto_desc->url_scheme);
return GLOBUS_SUCCESS;
}
else
{
return GLOBUS_GASS_TRANSFER_ERROR_INVALID_USE;
}
}
void
globus_extension_unregister_builtin(
const char * extension_name)
{
globus_l_extension_builtin_t * builtin;
GlobusFuncName(globus_extension_unregister_builtin);
GlobusExtensionDebugEnterSymbol(extension_name);
globus_rmutex_lock(&globus_l_extension_mutex);
{
builtin = (globus_l_extension_builtin_t *)
globus_hashtable_remove(
&globus_l_extension_builtins, (void *) extension_name);
if(builtin)
{
globus_free(builtin->extension_name);
globus_free(builtin);
}
}
globus_rmutex_unlock(&globus_l_extension_mutex);
GlobusExtensionDebugExit();
}
void
globus_module_setenv(
const char * name,
const char * value)
{
int rc;
/*
* First, check to see if the environment mutex has been initialized
*/
if(globus_l_environ_mutex_initialized == GLOBUS_FALSE)
{
if(globus_i_module_initialized == GLOBUS_TRUE)
{
rc = globus_mutex_init(&globus_l_environ_hashtable_mutex,
(globus_mutexattr_t *) GLOBUS_NULL);
globus_assert (rc == 0);
globus_l_environ_mutex_initialized = GLOBUS_TRUE;
}
}
/*
* then, check to see if the environment hash table has been initialized
*/
if((globus_l_environ_initialized == GLOBUS_FALSE))
{
if(globus_i_module_initialized==GLOBUS_TRUE)
{
globus_mutex_lock(&globus_l_environ_hashtable_mutex);
}
globus_hashtable_init(&globus_l_environ_table,
GLOBUS_L_ENVIRON_TABLE_SIZE,
globus_hashtable_string_hash,
globus_hashtable_string_keyeq);
globus_l_environ_initialized = GLOBUS_TRUE;
if(globus_i_module_initialized == GLOBUS_TRUE)
{
globus_mutex_unlock(&globus_l_environ_hashtable_mutex);
}
}
/*
* Then actually put the name and value into the hash table
*/
if(globus_i_module_initialized == GLOBUS_TRUE)
{
globus_mutex_lock(&globus_l_environ_hashtable_mutex);
}
globus_hashtable_remove(
&globus_l_environ_table,
(void *) name);
globus_hashtable_insert(
&globus_l_environ_table,
(void *) name,
(void *) value);
if(globus_i_module_initialized == GLOBUS_TRUE)
{
globus_mutex_unlock(&globus_l_environ_hashtable_mutex);
}
}
int
globus_extension_activate(
const char * extension_name)
{
globus_l_extension_module_t * extension;
globus_l_extension_module_t * last_extension;
globus_l_extension_builtin_t * builtin;
int rc;
globus_result_t result = GLOBUS_FAILURE;
GlobusFuncName(globus_extension_activate);
GlobusExtensionDebugEnterSymbol(extension_name);
if(!extension_name)
{
goto error_param;
}
globus_rmutex_lock(&globus_l_extension_mutex);
{
extension = (globus_l_extension_module_t *)
globus_hashtable_lookup(
&globus_l_extension_loaded, (void *) extension_name);
if(!extension)
{
extension = (globus_l_extension_module_t *)
globus_malloc(sizeof(globus_l_extension_module_t));
if(!extension)
{
goto error_alloc;
}
extension->module_ref = 1;
extension->ref = 1;
extension->name = globus_libc_strdup(extension_name);
if(!extension->name)
{
goto error_strdup;
}
builtin = (globus_l_extension_builtin_t *)
globus_hashtable_lookup(
&globus_l_extension_builtins, (void *) extension_name);
if(builtin && (!builtin->owner || builtin->owner->module_ref > 0))
{
# if !defined(BUILD_STATIC_ONLY)
{
extension->dlhandle = NULL;
}
# endif
extension->module = builtin->module;
extension->owner = builtin->owner;
if(extension->owner)
{
extension->owner->ref++;
}
}
else
{
extension->owner = NULL;
# if !defined(BUILD_STATIC_ONLY)
{
result =
globus_l_extension_dlopen(
extension->name,
&extension->dlhandle);
if(result != GLOBUS_SUCCESS)
{
goto error_dll;
}
result =
globus_l_extension_get_module(
extension->dlhandle,
extension_name,
&extension->module);
}
# else
{
globus_assert(BUILD_STATIC_ONLY == 0);
result = globus_error_put(
globus_error_construct_error(
GLOBUS_EXTENSION_MODULE,
NULL,
GLOBUS_EXTENSION_ERROR_OPEN_FAILED,
__FILE__,
_globus_func_name,
__LINE__,
"No support for dynamically loading %s\n",
extension->name));
}
# endif /* !defined(BUILD_STATIC_ONLY) */
if(result != GLOBUS_SUCCESS)
{
goto error_module;
}
}
globus_hashtable_insert(
&globus_l_extension_loaded,
extension->name,
extension);
last_extension = (globus_l_extension_module_t *)
globus_thread_getspecific(globus_l_extension_owner_key);
globus_thread_setspecific(globus_l_extension_owner_key, extension);
#if USE_SYMBOL_LABELS
{
int pre_warned = WARNING_USING_MIXED_THREAD_MODELS;
#endif
rc = globus_module_activate_proxy(
extension->module,
globus_l_extension_deactivate_proxy,
extension);
#if USE_SYMBOL_LABELS
if ((!pre_warned) && WARNING_USING_MIXED_THREAD_MODELS)
{
GlobusExtensionDebugPrintf(
GLOBUS_L_EXTENSION_DEBUG_VERBOSE,
(_GCSL("[%s] Warning: extension %s was compiled with pthreads for GT 5.0.x and may not work correctly\n"),
_globus_func_name,
extension->name));
}
}
#endif
globus_thread_setspecific(
globus_l_extension_owner_key, last_extension);
if(rc != GLOBUS_SUCCESS)
{
goto error_activate;
}
}
else
{
extension->module_ref++;
extension->ref++;
}
}
globus_rmutex_unlock(&globus_l_extension_mutex);
GlobusExtensionDebugExit();
return GLOBUS_SUCCESS;
error_activate:
globus_hashtable_remove(
&globus_l_extension_loaded, extension->name);
if(builtin && builtin->owner)
{
builtin->owner->ref--;
}
error_module:
#ifndef BUILD_STATIC_ONLY
if(extension->dlhandle)
{
lt_dlclose(extension->dlhandle);
}
error_dll:
#endif /* !BUILD_STATIC_ONLY */
globus_free(extension->name);
error_strdup:
globus_free(extension);
error_alloc:
globus_rmutex_unlock(&globus_l_extension_mutex);
error_param:
GlobusExtensionDebugExitWithError();
return result;
}
/**
* called locked
*
* dont call until ref goes to 0 or proxy deavtivate is called
* (circumventing my deactivate procedure)
*/
static
void
globus_l_extension_shutdown_extension(
globus_l_extension_module_t * extension,
globus_bool_t in_proxy)
{
globus_module_descriptor_t * module;
GlobusFuncName(globus_l_extension_shutdown_extension);
GlobusExtensionDebugEnter();
if(!in_proxy)
{
if(extension->module)
{
/* this will cause this function to be re-entered to do the
* bottom half
*/
globus_rmutex_unlock(&globus_l_extension_mutex);
globus_module_deactivate(extension->module);
globus_rmutex_lock(&globus_l_extension_mutex);
return;
}
}
else if(extension->module)
{
module = extension->module;
extension->module = NULL;
globus_hashtable_remove(
&globus_l_extension_loaded, extension->name);
if(module->deactivation_func)
{
globus_rmutex_unlock(&globus_l_extension_mutex);
module->deactivation_func();
globus_rmutex_lock(&globus_l_extension_mutex);
}
}
/** if this is not zero, then we must have been called by the deactivate
* proxy (on behalf of globus_module_deactivate_all() or someone getting
* a hold of our module descriptor and deactivating it themself
*
* this will be non-zero if users still have outstanding
* references on our registries when that circumvented deactivate occurred.
*/
if(extension->ref == 0)
{
# if !defined(BUILD_STATIC_ONLY)
{
if(extension->dlhandle)
{
/* cant do this until i provide a way for callbacks to be
* wrapped and hold a reference on this. from the xio TODO:
* - extension code needs to reference count callbacks to
* prevent modules from being unloaded. there is no way for
* the user to protect itself from this. this ref count does
* not need to block module deactivation, only the dlclose().
* probably also need a register_oneshot wrapper function
* that can do this.
* -- for now, extensions are just never unloaded.
*
lt_dlclose(extension->dlhandle);
*/
}
}
# endif /* !defined(BUILD_STATIC_ONLY) */
globus_free(extension->name);
globus_free(extension);
}
GlobusExtensionDebugExit();
}
