int
globus_validate_filename( char * value,
void * parms,
char ** error_msg )
{
int fd;
int mode;
int my_errno;
if (!parms)
{
*error_msg = _GCSL(globus_l_validate_error_null_parms);
return GLOBUS_FAILURE;
}
mode = *((int *)(parms));
fd = globus_libc_open( value, mode );
my_errno = errno;
if (fd < 0)
{
*error_msg = globus_libc_system_error_string(my_errno);
return GLOBUS_FAILURE;
}
globus_libc_close(fd);
return GLOBUS_SUCCESS;
}
/**
* Return a copy of the short description from the instance data
* @ingroup globus_errno_error_object
*
* @param error
* The error object to retrieve the data from.
* @return
* String containing the short description if it exists, NULL
* otherwise.
*/
static
char *
globus_l_error_errno_printable(
globus_object_t * error)
{
globus_module_descriptor_t * base_source;
char * sys_failed =
_GCSL("A system call failed:");
char * sys_error = NULL;
int length = 10 + strlen(sys_failed);
char * printable;
#ifndef WIN32
sys_error = globus_libc_system_error_string(
*((int *) globus_object_get_local_instance_data(error)));
length += sys_error ? strlen(sys_error) : 0;
#else
length += FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
*((int *) globus_object_get_local_instance_data(error)),
0,
(LPTSTR)&sys_error,
0,
NULL);
#endif
base_source = globus_error_get_source(error);
if(base_source && base_source->module_name)
{
length += strlen(base_source->module_name);
printable = globus_libc_malloc(length);
globus_libc_snprintf(printable,length,"%s: %s %s",
base_source->module_name,
sys_failed,
sys_error ? sys_error : "(null)");
}
else
{
printable = globus_libc_malloc(length);
globus_libc_snprintf(printable,length,"%s %s",
sys_failed,
sys_error ? sys_error : "(null)");
}
#ifdef WIN32
if(sys_error)
{
LocalFree(sys_error);
}
#endif
return printable;
}/* globus_l_error_errno_printable */
int
globus_l_args_create_error_msg( char ** error_msg,
int current_argc,
char * current_argv,
char * error_string,
const char * oneline_usage )
{
char * my_error_string;
char * p;
int usage_len;
int len;
#define error_format _GCSL("\nError, argument #%d (%s) : %s\n\nSyntax : ")
#define error_epilogue _GCSL("\n\nUse -help to display full usage.\n")
my_error_string = (error_string) ? error_string : _GCSL("(no error message)");
len = strlen(error_format)
+ strlen(current_argv)
+ strlen(my_error_string)
+ strlen(oneline_usage)
+ strlen(error_epilogue)
+ 10;
p = globus_l_args_malloc( char, len );
globus_assert( p );
globus_libc_sprintf( p,
error_format,
current_argc,
current_argv,
my_error_string );
usage_len = strlen( oneline_usage );
len = strlen(p);
strncpy( &p[len], oneline_usage, usage_len );
sprintf( &p[len+usage_len], "%s", error_epilogue );
if (error_msg)
*error_msg = p;
else
{
globus_libc_fprintf( stderr, "%s", p );
free(p);
}
return GLOBUS_SUCCESS;
}
void
globus_version_print(
const char * name,
const globus_version_t * version,
FILE * stream,
globus_bool_t verbose)
{
if(name)
{
globus_libc_fprintf(stream, "%s: ", name);
}
if(version)
{
if(verbose)
{
globus_libc_fprintf(
stream,
"%d.%d (%lu-%d)\n",
version->major,
version->minor,
version->timestamp,
version->branch_id);
}
else
{
globus_libc_fprintf(
stream,
"%d.%d\n",
version->major,
version->minor);
}
}
else
{
globus_libc_fprintf(stream, "%s", _GCSL("<no version>\n"));
}
}
int
globus_validate_int( char * value,
void * parms,
char ** error_msg )
{
int val;
char * format;
globus_validate_int_parms_t * range;
if (!parms)
{
*error_msg = _GCSL(globus_l_validate_error_null_parms);
return GLOBUS_FAILURE;
}
format = "%d";
range = (globus_validate_int_parms_t *) parms;
/* if the string starts with '0', then it's octal or hex */
/* if the string starts with '0x' or '0X', then it's hex */
if ( value[0] == '0' )
{
format = "%o";
if ( !strncmp(value, "0x",2) || !strncmp(value, "0X",2) )
format = "%x";
}
if ( !sscanf(value, format, &val ) )
{
*error_msg = _GCSL(globus_l_validate_error_not_an_int);
return GLOBUS_FAILURE;
}
if (range->range_type == GLOBUS_VALIDATE_INT_NOCHECK)
return GLOBUS_SUCCESS;
if (!(range->range_type & GLOBUS_VALIDATE_INT_MINMAX))
{
*error_msg = _GCSL(globus_l_validate_error_range_type);
return GLOBUS_FAILURE;
}
if ((range->range_type & GLOBUS_VALIDATE_INT_MIN) &&
(range->range_min > val))
{
globus_libc_sprintf(globus_l_validate_error_buf,
_GCSL("value is smaller than allowed min=%d"),
range->range_min);
*error_msg = globus_l_validate_error_buf;
return GLOBUS_FAILURE;
}
if ((range->range_type & GLOBUS_VALIDATE_INT_MAX) &&
(range->range_max < val))
{
globus_libc_sprintf(globus_l_validate_error_buf,
_GCSL("value is larger than allowed max=%d"),
range->range_max);
*error_msg = globus_l_validate_error_buf;
return GLOBUS_FAILURE;
}
return GLOBUS_SUCCESS;
}
int
globus_args_scan(
int * argc,
char *** argv,
int option_count,
globus_args_option_descriptor_t * options,
const char * name,
const globus_version_t * version,
const char * oneline_usage,
const char * long_usage,
globus_list_t ** options_found,
char ** error_msg )
{
static globus_mutex_t args_mutex;
static globus_bool_t args_mutex_initialized = GLOBUS_FALSE;
int rc;
int my_argc;
char * my_arg;
int len;
int i;
char ** alias;
char ** arglist;
globus_fifo_t fifo;
globus_bool_t done;
globus_bool_t found;
globus_libc_lock();
if (!args_mutex_initialized)
{
globus_mutex_init(&args_mutex,
(globus_mutexattr_t *) GLOBUS_NULL);
args_mutex_initialized = GLOBUS_TRUE;
}
globus_libc_unlock();
globus_mutex_lock(&args_mutex);
rc = GLOBUS_SUCCESS;
globus_fifo_init(&fifo);
*options_found = GLOBUS_NULL;
if (error_msg)
*error_msg = GLOBUS_NULL;
/* precheck : are the options correct? */
rc = globus_l_args_check_options(option_count, options, error_msg);
done = (rc==GLOBUS_SUCCESS) ? GLOBUS_FALSE : GLOBUS_TRUE;
my_argc=1;
while (!done)
{
/* any more options? */
if (my_argc == *argc)
{
done=GLOBUS_TRUE;
continue;
}
my_arg = (*argv)[my_argc];
len = strlen(my_arg);
if (my_arg[0]!='-' || len<2)
{
/* unrecognized option */
done=GLOBUS_TRUE;
continue;
}
/* '--*' is a special case : if '*' is non-null, it's an error.
Otherwise, it signals end of parsing. */
if (!strncmp(my_arg,"--",2))
{
if (len == 2) /* end of parsing */
{
/* next argument is first "unrecognized" option */
my_argc++;
}
else
{
rc = GLOBUS_FAILURE;
globus_l_args_create_error_msg(
error_msg,
my_argc,
my_arg,
_GCSL("double-dashed option syntax is not allowed"),
oneline_usage );
}
done = GLOBUS_TRUE;
continue;
}
/* four specials : -help, -usage, -version, -versions */
if (!strcmp("-help",my_arg))
{
globus_l_args_create_msg( error_msg ,
(char *) long_usage );
rc = GLOBUS_ARGS_HELP;
done = GLOBUS_TRUE;
continue;
}
if(!strcmp("-usage",my_arg))
{
globus_l_args_create_msg( error_msg ,
(char *) oneline_usage );
rc = GLOBUS_ARGS_HELP;
done = GLOBUS_TRUE;
continue;
}
if (!strcmp("-version",my_arg))
{
globus_version_print(
name,
version,
stderr,
GLOBUS_FALSE);
rc = GLOBUS_ARGS_VERSION;
done = GLOBUS_TRUE;
continue;
}
if (!strcmp("-versions",my_arg))
{
globus_version_print(
name,
version,
stderr,
GLOBUS_TRUE);
globus_module_print_activated_versions(stderr, GLOBUS_TRUE);
rc = GLOBUS_ARGS_VERSION;
done = GLOBUS_TRUE;
continue;
}
/* is it a known flag? */
found=GLOBUS_FALSE;
for (i=0; !found && !rc && i<option_count; i++)
{
for (alias=options[i].names; !found && !rc && *alias; alias++)
{
if (!strcmp(my_arg, *alias))
{
found = GLOBUS_TRUE;
arglist = GLOBUS_NULL;
if (options[i].arity > 0)
{
if (my_argc+options[i].arity >= *argc)
{
globus_l_args_create_error_msg(
error_msg,
my_argc,
my_arg,
_GCSL("not enough arguments"),
oneline_usage );
rc = GLOBUS_FAILURE;
continue;
}
rc = globus_l_args_validate( &options[i],
my_argc,
(*argv),
&arglist,
oneline_usage,
error_msg );
} /* if */
if (rc==GLOBUS_SUCCESS)
{
/* option successfully detected: add it */
globus_l_args_add_instance( &fifo,
&options[i],
arglist );
my_argc += 1+options[i].arity;
}
} /* strcmp(my_arg,*alias)) */
} /* alias */
} /* i */
if (!found)
{
/* my_arg contains an unregistered option */
rc = GLOBUS_FAILURE;
globus_l_args_create_error_msg( error_msg,
my_argc,
my_arg,
_GCSL("unknown option"),
oneline_usage );
}
if (rc!=GLOBUS_SUCCESS)
{
done = GLOBUS_TRUE;
continue;
}
} /* while (!done) */
if (rc==GLOBUS_SUCCESS)
{
/* if successful, return number of options found */
rc = globus_fifo_size(&fifo);
*options_found = globus_fifo_convert_to_list( &fifo );
/* modify argc/argv */
if (my_argc>1)
{
for (i = my_argc; i < *argc; i++)
(*argv)[i-my_argc+1] = (*argv)[i];
*argc -= my_argc - 1;
}
}
globus_fifo_destroy(&fifo);
globus_mutex_unlock(&args_mutex);
return rc;
}
/* default error strings for all types in the error hierarchy,
* which should be overridden w/ special code over time
*/
char *
globus_error_generic_string_func (globus_object_t * error)
{
char * string;
const globus_object_type_t * type;
type = globus_object_get_type (error);
if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_NO_CREDENTIALS)
== GLOBUS_TRUE ) {
string = _GCSL("no credentials were available");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_NO_TRUST)
== GLOBUS_TRUE ) {
string = _GCSL("no trust relationship exists");
}
else if ( globus_object_type_match (type,
GLOBUS_ERROR_TYPE_INVALID_CREDENTIALS)
== GLOBUS_TRUE ) {
string = _GCSL("the credentials were invalid");
}
else if ( globus_object_type_match (type,
GLOBUS_ERROR_TYPE_NO_AUTHENTICATION)
== GLOBUS_TRUE ) {
string = _GCSL("authentication failed");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_NO_AUTHORIZATION)
== GLOBUS_TRUE ) {
string = _GCSL("the operation was not authorized");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_OFFLINE)
== GLOBUS_TRUE ) {
string = _GCSL("the resource was offline");
}
else if ( globus_object_type_match (type,
GLOBUS_ERROR_TYPE_QUOTA_DEPLETED)
== GLOBUS_TRUE ) {
string = _GCSL("the resource quota was depleted");
}
else if ( globus_object_type_match (type,
GLOBUS_ERROR_TYPE_DEPLETED)
== GLOBUS_TRUE ) {
string = _GCSL("the resource was depleted");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_NOT_AVAILABLE)
== GLOBUS_TRUE ) {
string = _GCSL("the resource was not available");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_ACCESS_FAILED)
== GLOBUS_TRUE ) {
string = _GCSL("access failed");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_USER_CANCELLED)
== GLOBUS_TRUE ) {
string = _GCSL("the operation was cancelled by the user");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_INTERNAL_ERROR)
== GLOBUS_TRUE ) {
string = _GCSL("the operation was aborted due to an internal error");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_SYSTEM_ABORTED)
== GLOBUS_TRUE ) {
string = _GCSL("the operation was aborted by the system");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_ABORTED)
== GLOBUS_TRUE ) {
string = _GCSL("the operation was aborted");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_NULL_REFERENCE)
== GLOBUS_TRUE ) {
string = _GCSL("a NULL reference was encountered");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_TYPE_MISMATCH)
== GLOBUS_TRUE ) {
string = _GCSL("the data was not of the required type");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_NAME_UNKNOWN)
== GLOBUS_TRUE ) {
string = _GCSL("an unknown resource was encountered");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_BAD_FORMAT)
== GLOBUS_TRUE ) {
string = _GCSL("badly formatted data was encountered");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_TOO_LARGE)
== GLOBUS_TRUE ) {
string = _GCSL("the data was too large");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_TOO_SMALL)
== GLOBUS_TRUE ) {
string = _GCSL("the data was too small");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_OUT_OF_RANGE)
== GLOBUS_TRUE ) {
string = _GCSL("out-of-range data was encountered");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_BAD_DATA)
== GLOBUS_TRUE ) {
string = _GCSL("bad data was encountered");
}
else if ( globus_object_type_match (type,
GLOBUS_ERROR_TYPE_UNREACHABLE)
== GLOBUS_TRUE ) {
string = _GCSL("the destination was unreachable");
}
else if ( globus_object_type_match (type,
GLOBUS_ERROR_TYPE_PROTOCOL_MISMATCH)
== GLOBUS_TRUE ) {
string = _GCSL("no common protocol could be negotiated");
}
else if ( globus_object_type_match (type,
GLOBUS_ERROR_TYPE_PROTOCOL_VIOLATED)
== GLOBUS_TRUE ) {
string = _GCSL("the protocol was violated");
}
else if ( globus_object_type_match (type,
GLOBUS_ERROR_TYPE_COMMUNICATION_FAILED)
== GLOBUS_TRUE ) {
string = _GCSL("communication failed");
}
else if ( globus_object_type_match (type,
GLOBUS_ERROR_TYPE_ALREADY_REGISTERED)
== GLOBUS_TRUE ) {
string = _GCSL("the resource is already registered");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_ALREADY_CANCELLED)
== GLOBUS_TRUE ) {
string = _GCSL("a cancel was already issued");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_ALREADY_DONE)
== GLOBUS_TRUE ) {
string = _GCSL("the operation was already performed");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_NOT_INITIALIZED)
== GLOBUS_TRUE ) {
string = _GCSL("the mechanism was not initialized");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_INVALID_USE)
== GLOBUS_TRUE ) {
string = _GCSL("the use was invalid");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_BASE)
== GLOBUS_TRUE ) {
string = _GCSL("an unknown error occurred");
}
else {
string = NULL;
}
return s_string_copy (string);
}
void *
globus_extension_lookup(
globus_extension_handle_t * handle,
globus_extension_registry_t * registry,
void * symbol)
{
globus_l_extension_handle_t * entry;
void * datum = NULL;
GlobusFuncName(globus_extension_lookup);
GlobusExtensionDebugEnterSymbol(registry->user_hashing ? "" : symbol);
if(!handle)
{
goto error_param;
}
*handle = NULL;
if(!registry || !symbol)
{
goto error_param;
}
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->owner || entry->owner->module_ref > 0))
{
datum = entry->datum;
entry->ref++;
if(entry->owner)
{
entry->owner->ref++;
globus_assert(
(entry->owner != (globus_l_extension_module_t *)
globus_thread_getspecific(
globus_l_extension_owner_key)) &&
"You can not lookup something owned by the calling module");
GlobusExtensionDebugPrintf(
GLOBUS_L_EXTENSION_DEBUG_VERBOSE,
(_GCSL("[%s] Accessing entry %s within %s\n"),
_globus_func_name,
registry->user_hashing ? "" : symbol,
entry->owner->name));
}
*handle = entry;
}
}
}
globus_rmutex_unlock(&globus_l_extension_mutex);
GlobusExtensionDebugExit();
return datum;
error_param:
GlobusExtensionDebugExitWithError();
return NULL;
}
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;
}
static
globus_result_t
globus_l_extension_get_module(
lt_dlhandle dlhandle,
const char * module_name,
globus_module_descriptor_t ** module_desc)
{
globus_result_t result = GLOBUS_SUCCESS;
globus_module_descriptor_t * module;
GlobusFuncName(globus_l_extension_get_module);
module = (globus_module_descriptor_t *)
lt_dlsym(dlhandle, "globus_extension_module");
if(!module)
{
char * module_descriptor_name = malloc(strlen(module_name) + 8);
const char * p = module_name;
const char * last_slash = module_name;
if (module_descriptor_name == NULL)
{
result = GLOBUS_FAILURE;
}
while (*p != '\0')
{
if (*p == '/')
{
last_slash = p+1;
}
p++;
}
sprintf(module_descriptor_name, "%s_module", last_slash);
module = (globus_module_descriptor_t *)
lt_dlsym(dlhandle, module_descriptor_name);
free(module_descriptor_name);
}
if (!module)
{
const char * error;
error = lt_dlerror();
GlobusExtensionDebugPrintf(
GLOBUS_L_EXTENSION_DEBUG_DLL,
(_GCSL("[%s] Couldn't find module descriptor : %s\n"),
_globus_func_name, error ? error : "(null)"));
result = globus_error_put(
globus_error_construct_error(
GLOBUS_EXTENSION_MODULE,
NULL,
GLOBUS_EXTENSION_ERROR_LOOKUP_FAILED,
__FILE__,
_globus_func_name,
__LINE__,
"Couldn't find module descriptor : %s\n",
error ? error : "(null)"));
}
*module_desc = module;
return result;
}
static
globus_result_t
globus_l_extension_dlopen(
const char * name,
lt_dlhandle * handle)
{
char library[1024];
lt_dlhandle dlhandle;
char * path;
char * basename;
char * search_path = NULL;
char * save_path = NULL;
globus_result_t result = GLOBUS_SUCCESS;
GlobusFuncName(globus_l_extension_dlopen);
path = globus_libc_strdup(name);
if(path && (basename = strrchr(path, '/')))
{
*basename = 0;
if(basename == path)
{
/* ignore root dir */
name = path + 1;
}
else if(*(basename + 1) == 0)
{
/* ignore trailing slashes */
name = path;
}
else
{
name = basename + 1;
if(globus_l_globus_location)
{
/* if globus_location is not set, then it's likely I won't
* find the library
*/
search_path = globus_common_create_string(
"%s/%s", globus_l_globus_location, path);
}
}
}
globus_l_libtool_mutex_lock();
if(search_path || globus_l_globus_location)
{
if((save_path = (char *) lt_dlgetsearchpath()))
{
/* libtool frees this pointer before setting the next one */
save_path = globus_libc_strdup(save_path);
}
lt_dlsetsearchpath(
search_path ? search_path : globus_l_globus_location);
}
snprintf(library, 1024, "lib%s", name);
library[1023] = 0;
dlhandle = lt_dlopenext(library);
if(!dlhandle)
{
/* older libtools dont search the extensions correctly */
snprintf(library, 1024, "lib%s" MY_LIB_EXT, name);
library[1023] = 0;
dlhandle = lt_dlopenext(library);
}
#if USE_SYMBOL_LABELS
if (!dlhandle)
{
snprintf(library, 1024, "lib%s_%s",
name,
(sizeof(long) == 8) ? "gcc64pthr" : "gcc32pthr");
library[1023] = 0;
dlhandle = lt_dlopenext(library);
if(!dlhandle)
{
/* older libtools dont search the extensions correctly */
snprintf(library, 1024, "lib%s_%s" MY_LIB_EXT, name,
(sizeof(long) == 8) ? "gcc64pthr" : "gcc32pthr");
library[1023] = 0;
dlhandle = lt_dlopenext(library);
}
}
#endif
if(!dlhandle)
{
const char * error;
error = lt_dlerror();
GlobusExtensionDebugPrintf(
GLOBUS_L_EXTENSION_DEBUG_DLL,
(_GCSL("[%s] Couldn't dlopen %s in %s (or LD_LIBRARY_PATH): %s\n"),
_globus_func_name, library,
search_path ? search_path : globus_l_globus_location
? globus_l_globus_location : "(default)",
error ? error : "(null)"));
result = globus_error_put(
globus_error_construct_error(
GLOBUS_EXTENSION_MODULE,
NULL,
GLOBUS_EXTENSION_ERROR_OPEN_FAILED,
__FILE__,
_globus_func_name,
__LINE__,
"Couldn't dlopen %s in %s (or LD_LIBRARY_PATH): %s\n",
library,
(search_path ? search_path :
(globus_l_globus_location ?
globus_l_globus_location :
"(default)")),
error ? error : "(null)"));
}
if(search_path || globus_l_globus_location)
{
lt_dlsetsearchpath(save_path);
if(save_path)
{
globus_free(save_path);
}
}
globus_l_libtool_mutex_unlock();
if(search_path)
{
globus_free(search_path);
}
if(path)
{
globus_free(path);
}
*handle = dlhandle;
return result;
}
