globus_bool_t
globus_extension_error_match_with_cb(
globus_extension_handle_t handle,
globus_object_t * error,
globus_extension_error_match_cb_t callback,
void * type)
{
globus_bool_t match = GLOBUS_FALSE;
GlobusFuncName(globus_extension_error_match);
GlobusExtensionDebugEnter();
if(!handle || !error)
{
goto error_param;
}
match = callback(error, handle->module, type);
GlobusExtensionDebugExit();
return match;
error_param:
GlobusExtensionDebugExitWithError();
return GLOBUS_FALSE;
}
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;
}
/**
* Destroy a restart marker.
* @ingroup globus_ftp_client_restart_marker
*
* @param marker
* Restart marker. This marker must be initialized by either
* calling globus_ftp_client_restart_marker_init() or
* globus_ftp_client_restart_marker_copy()
*
* @see globus_ftp_client_restart_marker_t,
* globus_ftp_client_restart_marker_init(),
* globus_ftp_client_restart_marker_copy()
*/
globus_result_t
globus_ftp_client_restart_marker_destroy(
globus_ftp_client_restart_marker_t * marker)
{
GlobusFuncName(globus_ftp_client_restart_marker_destroy);
if(marker == GLOBUS_NULL)
{
return globus_error_put(
GLOBUS_I_FTP_CLIENT_ERROR_NULL_PARAMETER("marker"));
}
switch(marker->type)
{
case GLOBUS_FTP_CLIENT_RESTART_EXTENDED_BLOCK:
while(!globus_fifo_empty(&marker->extended_block.ranges))
{
globus_i_ftp_client_range_t * range;
range = (globus_i_ftp_client_range_t *)
globus_fifo_dequeue(&marker->extended_block.ranges);
globus_libc_free(range);
}
globus_fifo_destroy(&marker->extended_block.ranges);
/* FALLSTHROUGH */
case GLOBUS_FTP_CLIENT_RESTART_NONE:
case GLOBUS_FTP_CLIENT_RESTART_STREAM:
memset(marker, '\0', sizeof(globus_ftp_client_restart_marker_t));
marker->type = GLOBUS_FTP_CLIENT_RESTART_NONE;
break;
}
return GLOBUS_SUCCESS;
}
/**
* Destroy an instance of the GridFTP restart plugin
* @ingroup globus_ftp_client_restart_plugin
*
* This function will free all restart plugin-specific instance data
* from this plugin, and will make the plugin unusable for further ftp
* handle creation.
*
* Existing FTP client handles and handle attributes will not be affected by
* destroying a plugin associated with them, as a local copy of the plugin
* is made upon handle initialization.
*
* @param plugin
* A pointer to a GridFTP restart plugin, previously initialized by
* calling globus_ftp_client_restart_plugin_init()
*
* @return This function returns an error if
* - plugin is null
* - plugin is not a restart plugin
*
* @see globus_ftp_client_restart_plugin_init(),
* globus_ftp_client_handleattr_add_plugin(),
* globus_ftp_client_handleattr_remove_plugin(),
* globus_ftp_client_handle_init()
*/
globus_result_t
globus_ftp_client_restart_plugin_destroy(
globus_ftp_client_plugin_t * plugin)
{
globus_l_ftp_client_restart_plugin_t * d;
globus_result_t result;
GlobusFuncName(globus_ftp_client_restart_plugin_destroy);
GLOBUS_L_FTP_CLIENT_RESTART_PLUGIN_RETURN(plugin);
result = globus_ftp_client_plugin_get_plugin_specific(plugin,
(void **) &d);
if(result != GLOBUS_SUCCESS)
{
return result;
}
globus_l_ftp_client_restart_plugin_genericify(d);
if(d->ticker_set)
{
d->ticker_set = GLOBUS_FALSE;
/* XXX where is d freed? if was a previous leak free in l_ticker_done */
globus_callback_unregister(
d->ticker_handle, l_ticker_done, d, NULL);
}
else
{
/* XXX free d here ? */
globus_free(d);
}
return globus_ftp_client_plugin_destroy(plugin);
}
void
globus_extension_release(
globus_extension_handle_t handle)
{
globus_l_extension_handle_t * entry;
globus_l_extension_module_t * owner = NULL;
GlobusFuncName(globus_extension_release);
entry = handle;
GlobusExtensionDebugEnterSymbol(entry->user_hashing ? "" : entry->symbol);
globus_rmutex_lock(&globus_l_extension_mutex);
{
if(entry)
{
if(entry->owner && --entry->owner->ref == 0)
{
owner = entry->owner;
}
if(--entry->ref == 0)
{
globus_free(entry);
}
if(owner)
{
globus_l_extension_shutdown_extension(owner, GLOBUS_FALSE);
}
}
}
globus_rmutex_unlock(&globus_l_extension_mutex);
GlobusExtensionDebugExit();
}
/**
* Create a copy of a restart marker.
* @ingroup globus_ftp_client_restart_marker
*
* This function copies the contents of marker to new_marker.
*
* @param new_marker
* A pointer to a new restart marker.
* @param marker
* The marker to copy.
*
* @see globus_ftp_client_restart_marker_init(),
* globus_ftp_client_restart_marker_destroy()
*/
globus_result_t
globus_ftp_client_restart_marker_copy(
globus_ftp_client_restart_marker_t * new_marker,
globus_ftp_client_restart_marker_t * marker)
{
globus_fifo_t * tmp;
GlobusFuncName(globus_ftp_client_restart_marker_copy);
if(new_marker == GLOBUS_NULL)
{
return globus_error_put(
GLOBUS_I_FTP_CLIENT_ERROR_NULL_PARAMETER("new_marker"));
}
if(marker == GLOBUS_NULL)
{
return globus_error_put(
GLOBUS_I_FTP_CLIENT_ERROR_NULL_PARAMETER("marker"));
}
globus_ftp_client_restart_marker_init(new_marker);
new_marker->type = marker->type;
switch(new_marker->type)
{
case GLOBUS_FTP_CLIENT_RESTART_NONE:
break;
case GLOBUS_FTP_CLIENT_RESTART_STREAM:
new_marker->stream.offset = marker->stream.offset;
break;
case GLOBUS_FTP_CLIENT_RESTART_EXTENDED_BLOCK:
globus_fifo_init(&new_marker->extended_block.ranges);
if(globus_fifo_empty(&marker->extended_block.ranges))
{
break;
}
tmp = globus_fifo_copy(&marker->extended_block.ranges);
while(!globus_fifo_empty(tmp))
{
globus_i_ftp_client_range_t * range;
range = (globus_i_ftp_client_range_t *) globus_fifo_dequeue(tmp);
globus_ftp_client_restart_marker_insert_range(new_marker,
range->offset,
range->end_offset);
}
globus_fifo_destroy(tmp);
globus_free(tmp);
break;
}
return GLOBUS_SUCCESS;
}
int
globus_extension_deactivate(
const char * extension_name)
{
globus_l_extension_module_t * extension;
globus_l_extension_module_t * owner = NULL;
GlobusFuncName(globus_extension_deactivate);
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->module_ref <= 0)
{
goto error_lookup;
}
extension->module_ref--;
if(--extension->ref == 0)
{
if(extension->owner && --extension->owner->ref == 0)
{
owner = extension->owner;
}
globus_l_extension_shutdown_extension(extension, GLOBUS_FALSE);
if(owner)
{
globus_l_extension_shutdown_extension(owner, GLOBUS_FALSE);
}
}
}
globus_rmutex_unlock(&globus_l_extension_mutex);
GlobusExtensionDebugExit();
return GLOBUS_SUCCESS;
error_lookup:
globus_rmutex_unlock(&globus_l_extension_mutex);
error_param:
GlobusExtensionDebugExitWithError();
return GLOBUS_FAILURE;
}
int
globus_extension_register_builtin(
const char * extension_name,
globus_module_descriptor_t * module_descriptor)
{
globus_l_extension_builtin_t * builtin;
GlobusFuncName(globus_extension_register_builtin);
GlobusExtensionDebugEnterSymbol(extension_name);
builtin = (globus_l_extension_builtin_t *)
globus_malloc(sizeof(globus_l_extension_builtin_t));
if(!builtin)
{
goto error_alloc;
}
builtin->owner = (globus_l_extension_module_t *)
globus_thread_getspecific(globus_l_extension_owner_key);
builtin->module = module_descriptor;
builtin->extension_name = globus_libc_strdup(extension_name);
if(!builtin->extension_name)
{
goto error_strdup;
}
globus_rmutex_lock(&globus_l_extension_mutex);
{
int rc;
rc = globus_hashtable_insert(
&globus_l_extension_builtins, builtin->extension_name, builtin);
if(rc != 0)
{
goto error_insert;
}
}
globus_rmutex_unlock(&globus_l_extension_mutex);
GlobusExtensionDebugExit();
return GLOBUS_SUCCESS;
error_insert:
globus_rmutex_unlock(&globus_l_extension_mutex);
globus_free(builtin->extension_name);
error_strdup:
globus_free(builtin);
error_alloc:
GlobusExtensionDebugExitWithError();
return GLOBUS_FAILURE;
}
/**
* Get total bytes accounted for in restart marker
* @ingroup globus_ftp_client_restart_marker
*
* This funtion will return the sum of all bytes accounted for in
* a restart marker. If this restart marker contains a stream offset
* then this value is the same as the offset (not the ascii offset)
* that it was set with. If it is a range list, it a sum of all the
* bytes in the ranges.
*
* @param marker
* A previously initialized or copied restart marker
*
* @param total_bytes
* pointer to storage for total bytes in marker
*
* @return
* - Error on NULL marker or total bytes
* - <possible return>
*/
globus_result_t
globus_ftp_client_restart_marker_get_total(
globus_ftp_client_restart_marker_t * marker,
globus_off_t * total_bytes)
{
GlobusFuncName(globus_ftp_client_restart_marker_get_total);
if(marker == GLOBUS_NULL)
{
return globus_error_put(
GLOBUS_I_FTP_CLIENT_ERROR_NULL_PARAMETER("marker"));
}
if(total_bytes == GLOBUS_NULL)
{
return globus_error_put(
GLOBUS_I_FTP_CLIENT_ERROR_NULL_PARAMETER("total_bytes"));
}
*total_bytes = 0;
if(marker->type == GLOBUS_FTP_CLIENT_RESTART_STREAM)
{
*total_bytes = marker->stream.offset;
}
else if(marker->type == GLOBUS_FTP_CLIENT_RESTART_EXTENDED_BLOCK &&
!globus_fifo_empty(&marker->extended_block.ranges))
{
globus_fifo_t * tmp;
globus_off_t total;
globus_i_ftp_client_range_t * range;
tmp = globus_fifo_copy(&marker->extended_block.ranges);
total = 0;
while((!globus_fifo_empty(tmp)))
{
range = (globus_i_ftp_client_range_t *) globus_fifo_dequeue(tmp);
total += range->end_offset - range->offset;
}
*total_bytes = total;
globus_fifo_destroy(tmp);
globus_libc_free(tmp);
}
return GLOBUS_SUCCESS;
}
globus_result_t
globus_ftp_client_restart_marker_get_first_block(
globus_ftp_client_restart_marker_t * marker,
globus_off_t * start_offset,
globus_off_t * end_offset)
{
GlobusFuncName(globus_ftp_client_restart_marker_get_first_block);
if(marker == GLOBUS_NULL)
{
return globus_error_put(
GLOBUS_I_FTP_CLIENT_ERROR_NULL_PARAMETER("marker"));
}
if(start_offset == GLOBUS_NULL)
{
return globus_error_put(
GLOBUS_I_FTP_CLIENT_ERROR_NULL_PARAMETER("start_offset"));
}
if(end_offset == GLOBUS_NULL)
{
return globus_error_put(
GLOBUS_I_FTP_CLIENT_ERROR_NULL_PARAMETER("end_offset"));
}
*start_offset = 0;
*end_offset = 0;
if(marker->type == GLOBUS_FTP_CLIENT_RESTART_STREAM)
{
*end_offset = marker->stream.offset;
}
else if(marker->type == GLOBUS_FTP_CLIENT_RESTART_EXTENDED_BLOCK &&
!globus_fifo_empty(&marker->extended_block.ranges))
{
globus_i_ftp_client_range_t * range;
range = (globus_i_ftp_client_range_t *)
globus_fifo_peek(&marker->extended_block.ranges);
*start_offset = range->offset;
*end_offset = range->end_offset;
}
return GLOBUS_SUCCESS;
}
/**
* Initialize a restart marker.
* @ingroup globus_ftp_client_restart_marker
*
* @param marker
* New restart marker.
* @see globus_ftp_client_restart_marker_t,
* globus_ftp_client_restart_marker_destroy()
*/
globus_result_t
globus_ftp_client_restart_marker_init(
globus_ftp_client_restart_marker_t * marker)
{
GlobusFuncName(globus_ftp_client_restart_marker_init);
if(marker == GLOBUS_NULL)
{
return globus_error_put(
GLOBUS_I_FTP_CLIENT_ERROR_NULL_PARAMETER("marker"));
}
memset(marker, '\0', sizeof(globus_ftp_client_restart_marker_t));
marker->type = GLOBUS_FTP_CLIENT_RESTART_NONE;
return GLOBUS_SUCCESS;
}
globus_result_t
globus_ftp_client_restart_marker_plugin_destroy(
globus_ftp_client_plugin_t * plugin)
{
globus_result_t result;
restart_marker_plugin_info_t * ps;
GlobusFuncName(globus_ftp_client_restart_marker_plugin_destroy);
if(plugin == GLOBUS_NULL)
{
return globus_error_put(globus_error_construct_string(
GLOBUS_FTP_CLIENT_MODULE,
GLOBUS_NULL,
"[%s] NULL plugin at %s\n",
GLOBUS_FTP_CLIENT_MODULE->module_name,
_globus_func_name));
}
result = globus_ftp_client_plugin_get_plugin_specific(
plugin,
(void **) (void *) &ps);
if(result != GLOBUS_SUCCESS)
{
return result;
}
if(ps->error_obj)
{
globus_object_free(ps->error_obj);
ps->error_obj = GLOBUS_NULL;
}
if(ps->error_url)
{
globus_libc_free(ps->error_url);
ps->error_url = GLOBUS_NULL;
}
globus_mutex_destroy(&ps->lock);
globus_free(ps);
return globus_ftp_client_plugin_destroy(plugin);
}
void
globus_extension_unregister_builtins(
globus_extension_builtin_t * builtins)
{
GlobusFuncName(globus_extension_unregister_builtins);
GlobusExtensionDebugEnter();
globus_rmutex_lock(&globus_l_extension_mutex);
{
while(builtins->extension_name)
{
globus_extension_unregister_builtin(builtins->extension_name);
builtins++;
}
}
globus_rmutex_unlock(&globus_l_extension_mutex);
GlobusExtensionDebugExit();
}
void *
globus_extension_reference(
globus_extension_handle_t handle)
{
globus_l_extension_handle_t * entry;
void * datum = NULL;
GlobusFuncName(globus_extension_reference);
GlobusExtensionDebugEnter();
if(!handle)
{
goto error_param;
}
entry = handle;
globus_rmutex_lock(&globus_l_extension_mutex);
{
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 reference something owned by the calling module");
}
}
globus_rmutex_unlock(&globus_l_extension_mutex);
GlobusExtensionDebugExit();
return datum;
error_param:
GlobusExtensionDebugExitWithError();
return NULL;
}
/**
* Set the offset for a restart marker.
* @ingroup globus_ftp_client_restart_marker
*
* This function modifies a restart marker to contain a stream offset,
* suitable for using to restart a steam mode transfer.
*
* The marker must first be initialized by calling
* globus_ftp_client_restart_marker_init() or
* globus_ftp_client_restart_marker_copy().
*
* A marker can only hold a range list or a stream offset. Calling
* this function after calling
* globus_ftp_client_restart_marker_insert_range() will delete the
* ranges associated with the marker, and replace it with a marker
* suitable only for use restarting a stream mode transfer.
*
* When restarting an ASCII type transfer, the offset must take into
* account the additional carriage return characters added to the data
* stream.
*
* @param marker
* A restart marker
* @param offset
* The stream offset
*
* @see globus_ftp_client_restart_marker_insert_range(),
* globus_ftp_client_operationattr_set_mode(),
* globus_ftp_client_operationattr_set_type()
*/
globus_result_t
globus_ftp_client_restart_marker_set_offset(
globus_ftp_client_restart_marker_t * marker,
globus_off_t offset)
{
GlobusFuncName(globus_ftp_client_restart_marker_set_offset);
if(marker == GLOBUS_NULL)
{
return globus_error_put(
GLOBUS_I_FTP_CLIENT_ERROR_NULL_PARAMETER("marker"));
}
if(marker->type != GLOBUS_FTP_CLIENT_RESTART_STREAM)
{
globus_ftp_client_restart_marker_destroy(marker);
marker->type = GLOBUS_FTP_CLIENT_RESTART_STREAM;
}
marker->stream.offset = marker->stream.ascii_offset = offset;
return GLOBUS_SUCCESS;
}
static
int
globus_l_extension_deactivate_proxy(
globus_module_descriptor_t * module,
void * user_arg)
{
globus_l_extension_module_t * extension;
GlobusFuncName(globus_l_extension_deactivate_proxy);
GlobusExtensionDebugEnter();
extension = (globus_l_extension_module_t *) user_arg;
globus_rmutex_lock(&globus_l_extension_mutex);
{
extension->ref -= extension->module_ref;
extension->module_ref = 0;
globus_l_extension_shutdown_extension(extension, GLOBUS_TRUE);
}
globus_rmutex_unlock(&globus_l_extension_mutex);
GlobusExtensionDebugExit();
return GLOBUS_SUCCESS;
}
int
globus_extension_register_builtins(
globus_extension_builtin_t * builtins)
{
int i;
GlobusFuncName(globus_extension_register_builtins);
GlobusExtensionDebugEnter();
globus_rmutex_lock(&globus_l_extension_mutex);
{
for(i = 0; builtins[i].extension_name; i++)
{
int rc;
rc = globus_extension_register_builtin(
builtins[i].extension_name, builtins[i].module_descriptor);
if(rc != 0)
{
goto error_register;
}
}
}
globus_rmutex_unlock(&globus_l_extension_mutex);
GlobusExtensionDebugExit();
return GLOBUS_SUCCESS;
error_register:
while(i--)
{
globus_extension_unregister_builtin(builtins->extension_name);
builtins++;
}
globus_rmutex_unlock(&globus_l_extension_mutex);
return GLOBUS_FAILURE;
}
int
globus_extension_registry_set_hashing(
globus_extension_registry_t * registry,
globus_hashtable_hash_func_t hash_func,
globus_hashtable_keyeq_func_t keyeq_func)
{
int rc = GLOBUS_SUCCESS;
GlobusFuncName(globus_extension_registry_remove);
GlobusExtensionDebugEnter();
globus_rmutex_lock(&globus_l_extension_mutex);
{
/* if registry->initialized == true,
* can't detect if this is misuse or just the result of being
* activated after a deactivate, so just return success
*/
if(!registry->initialized)
{
rc = globus_hashtable_init(
®istry->table,
20,
hash_func,
keyeq_func);
if(rc == GLOBUS_SUCCESS)
{
registry->initialized = GLOBUS_TRUE;
registry->user_hashing = GLOBUS_TRUE;
}
}
}
globus_rmutex_unlock(&globus_l_extension_mutex);
GlobusExtensionDebugExit();
return rc;
}
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();
}
/**
* Initialize a restart marker from a string.
* @ingroup globus_ftp_client_restart_marker
*
* This function initializes a new restart, @a marker, based on the
* @a marker_string parameter. The string may be either a single offset
* for a stream-mode restart marker, or a comma-separated list of start-end
* ranges.
*
* @param marker
* The restart marker to be unitialized.
* @param marker_string
* The string containing a textual representation of a restart marker.
* @see globus_ftp_client_restart_marker
*/
globus_result_t
globus_ftp_client_restart_marker_from_string(
globus_ftp_client_restart_marker_t * marker,
const char * marker_string)
{
globus_off_t offset;
globus_off_t end;
int consumed;
globus_object_t * err;
globus_result_t res;
const char * p;
GlobusFuncName(globus_ftp_client_restart_marker_from_string);
if(marker == GLOBUS_NULL)
{
return globus_error_put(
GLOBUS_I_FTP_CLIENT_ERROR_NULL_PARAMETER("marker"));
}
else if(marker_string == GLOBUS_NULL)
{
return globus_error_put(
GLOBUS_I_FTP_CLIENT_ERROR_NULL_PARAMETER("marker_string"));
}
res = globus_ftp_client_restart_marker_init(marker);
if(res != GLOBUS_SUCCESS)
{
goto res_exit;
}
if(strchr(marker_string, '-') != GLOBUS_NULL)
{
/* Looks like an extended block mode restart marker */
if(marker->type == GLOBUS_FTP_CLIENT_RESTART_NONE)
{
marker->type = GLOBUS_FTP_CLIENT_RESTART_EXTENDED_BLOCK;
}
if(marker->type != GLOBUS_FTP_CLIENT_RESTART_EXTENDED_BLOCK)
{
err = GLOBUS_I_FTP_CLIENT_ERROR_INVALID_PARAMETER("marker");
goto error_exit;
}
p = marker_string;
while( sscanf(p, "%"GLOBUS_OFF_T_FORMAT"-%"GLOBUS_OFF_T_FORMAT"%n",
&offset,
&end,
&consumed) >= 2)
{
res = globus_ftp_client_restart_marker_insert_range(marker,
offset,
end);
if(res != GLOBUS_SUCCESS)
{
goto res_exit;
}
p += consumed;
if(*p == ',')
{
p++;
}
else
{
break;
}
}
}
else /* assume stream mode */
{
if(marker->type == GLOBUS_FTP_CLIENT_RESTART_NONE)
{
marker->type = GLOBUS_FTP_CLIENT_RESTART_STREAM;
}
if(marker->type != GLOBUS_FTP_CLIENT_RESTART_STREAM)
{
err = GLOBUS_I_FTP_CLIENT_ERROR_INVALID_PARAMETER("marker");
goto error_exit;
}
if(sscanf(marker_string, "%"GLOBUS_OFF_T_FORMAT, &offset) != 1)
{
err = GLOBUS_I_FTP_CLIENT_ERROR_INVALID_PARAMETER("marker_string");
goto error_exit;
}
else
{
marker->stream.ascii_offset = marker->stream.offset = offset;
}
}
return GLOBUS_SUCCESS;
error_exit:
res = globus_error_put(err);
res_exit:
return res;
}
/**
* Create a string representation of a restart marker.
* @ingroup globus_ftp_client_restart_marker
*
* This function sets the @a marker_string parameter to point to
* a freshly allocated string suitable for sending as an argument to
* the FTP REST command, or for a later call to
* globus_ftp_client_restart_marker_from_string().
*
* The string pointed to by marker_string must be freed by the caller.
*
* @param marker
* An initialized FTP client restart marker.
* @param marker_string
* A pointer to a char * to be set to a freshly allocated marker
* string.
*
* @see globus_ftp_client_restart_marker
*/
globus_result_t
globus_ftp_client_restart_marker_to_string(
globus_ftp_client_restart_marker_t * marker,
char ** marker_string)
{
int length = 0, mylen;
char * buf = GLOBUS_NULL;
char * tbuf;
globus_i_ftp_client_range_t * range;
globus_fifo_t * tmp;
globus_off_t offset;
globus_size_t digits;
globus_object_t * err;
GlobusFuncName(globus_ftp_client_restart_marker_to_string);
if(marker == GLOBUS_NULL)
{
return globus_error_put(
GLOBUS_I_FTP_CLIENT_ERROR_NULL_PARAMETER("marker"));
}
else if(marker_string == GLOBUS_NULL)
{
return globus_error_put(
GLOBUS_I_FTP_CLIENT_ERROR_NULL_PARAMETER("marker_string"));
}
(*marker_string) = GLOBUS_NULL;
if(marker->type == GLOBUS_FTP_CLIENT_RESTART_NONE)
{
return GLOBUS_SUCCESS;
}
else if(marker->type == GLOBUS_FTP_CLIENT_RESTART_STREAM)
{
if(marker->stream.ascii_offset > marker->stream.offset)
{
offset = marker->stream.ascii_offset;
}
else
{
offset = marker->stream.offset;
}
digits = globus_i_ftp_client_count_digits(offset);
(*marker_string) = globus_libc_malloc(digits+1);
if(!(*marker_string))
{
err = GLOBUS_I_FTP_CLIENT_ERROR_OUT_OF_MEMORY();
if(!err)
{
err = GLOBUS_ERROR_NO_INFO;
}
goto error_exit;
}
globus_libc_sprintf((*marker_string),
"%lu",
(unsigned long) offset);
}
else if(marker->type == GLOBUS_FTP_CLIENT_RESTART_EXTENDED_BLOCK &&
!globus_fifo_empty(&marker->extended_block.ranges))
{
tmp = globus_fifo_copy(&marker->extended_block.ranges);
while((! globus_fifo_empty(tmp)))
{
range = (globus_i_ftp_client_range_t *) globus_fifo_dequeue(tmp);
mylen = globus_i_ftp_client_count_digits(range->offset);
mylen++;
mylen += globus_i_ftp_client_count_digits(range->end_offset);
mylen++;
if(buf)
{
tbuf = realloc(buf, length + mylen + 1);
}
else
{
tbuf = malloc(length + mylen + 1);
}
if(!tbuf)
{
err = GLOBUS_I_FTP_CLIENT_ERROR_OUT_OF_MEMORY();
if(!err)
{
err = GLOBUS_ERROR_NO_INFO;
}
goto buf_err;
}
else
{
buf = tbuf;
}
length += globus_libc_sprintf(
buf + length,
"%"GLOBUS_OFF_T_FORMAT"-%"GLOBUS_OFF_T_FORMAT",",
range->offset,
range->end_offset);
}
buf[strlen(buf)-1] = '\0';
(*marker_string) = buf;
globus_fifo_destroy(tmp);
globus_libc_free(tmp);
}
return GLOBUS_SUCCESS;
buf_err:
globus_fifo_destroy(tmp);
globus_libc_free(buf);
error_exit:
return globus_error_put(err);
}
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;
}
/**
* Insert a range into a restart marker
* @ingroup globus_ftp_client_restart_marker
*
* This function updates a restart marker with a new byte range,
* suitable for using to restart an extended block mode transfer.
* Adjacent ranges within the marker will be combined into a single
* entry in the marker.
*
* The marker must first be initialized by calling
* globus_ftp_client_restart_marker_init() or
* globus_ftp_client_restart_marker_copy().
*
* A marker can only hold a range list or a stream offset. Calling
* this function after calling
* globus_ftp_client_restart_marker_set_offset() will result in a marker
* suitable only for use restarting an extended block mode transfer.
*
* @param marker
* A restart marker
* @param offset
* The starting offset of the range.
* @param end_offset
* The ending offset of the range.
*
* @see globus_ftp_client_restart_marker_set_offset()
* globus_ftp_client_operationattr_set_mode()
*/
globus_result_t
globus_ftp_client_restart_marker_insert_range(
globus_ftp_client_restart_marker_t * marker,
globus_off_t offset,
globus_off_t end_offset)
{
globus_fifo_t tmp;
globus_i_ftp_client_range_t * range;
globus_i_ftp_client_range_t * newrange;
globus_object_t * err = GLOBUS_SUCCESS;
GlobusFuncName(globus_ftp_client_insert_range);
if(marker == GLOBUS_NULL)
{
return globus_error_put(
GLOBUS_I_FTP_CLIENT_ERROR_NULL_PARAMETER("marker"));
}
if(marker->type != GLOBUS_FTP_CLIENT_RESTART_EXTENDED_BLOCK)
{
memset(marker,
'\0',
sizeof(globus_ftp_client_restart_extended_block_t));
marker->type = GLOBUS_FTP_CLIENT_RESTART_EXTENDED_BLOCK;
globus_fifo_init(&marker->extended_block.ranges);
}
globus_fifo_move(&tmp, &marker->extended_block.ranges);
while(!globus_fifo_empty(&tmp))
{
range = globus_fifo_dequeue(&tmp);
if(offset <= range->offset)
{
if(end_offset+1 < range->offset)
{
newrange = globus_malloc(sizeof(globus_i_ftp_client_range_t));
if(newrange == NULL)
{
err = GLOBUS_I_FTP_CLIENT_ERROR_OUT_OF_MEMORY();
if(!err)
err = GLOBUS_ERROR_NO_INFO;
goto copy_rest;
}
newrange->offset = offset;
newrange->end_offset = end_offset;
globus_fifo_enqueue(&marker->extended_block.ranges, newrange);
globus_fifo_enqueue(&marker->extended_block.ranges, range);
goto copy_rest;
}
else if(end_offset+1 == range->offset)
{
end_offset = range->end_offset;
globus_libc_free(range);
}
else
{
/* weird.... overlapping data */
if(end_offset < range->end_offset)
{
end_offset = range->end_offset;
}
globus_libc_free(range);
}
}
else
{
if(range->end_offset < offset - 1)
{
globus_fifo_enqueue(&marker->extended_block.ranges, range);
}
else if(range->end_offset >= offset - 1)
{
offset = range->offset;
if(end_offset < range->end_offset)
{
end_offset = range->end_offset;
}
globus_libc_free(range);
}
else
{
globus_fifo_enqueue(&marker->extended_block.ranges, range);
}
}
}
newrange = globus_malloc(sizeof(globus_i_ftp_client_range_t));
if(newrange == GLOBUS_NULL)
{
err = GLOBUS_I_FTP_CLIENT_ERROR_OUT_OF_MEMORY();
if(!err)
err = GLOBUS_ERROR_NO_INFO;
goto copy_rest;
}
newrange->offset = offset;
newrange->end_offset = end_offset;
globus_fifo_enqueue(&marker->extended_block.ranges, newrange);
copy_rest:
while(! globus_fifo_empty(&tmp))
{
globus_fifo_enqueue(&marker->extended_block.ranges,
globus_fifo_dequeue(&tmp));
}
globus_fifo_destroy(&tmp);
return err ? globus_error_put(err) : GLOBUS_SUCCESS;
}
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;
}
/**
* Initialize an instance of the GridFTP restart plugin
* @ingroup globus_ftp_client_restart_plugin
*
* This function will initialize the plugin-specific instance data
* for this plugin, and will make the plugin usable for ftp
* client handle attribute and handle creation.
*
* @param plugin
* A pointer to an uninitialized plugin. The plugin will be
* configured as a restart plugin.
* @param max_retries
* The maximum number of times to retry the operation before giving
* up on the transfer. If this value is less than or equal to 0,
* then the restart plugin will keep trying to restart the operation
* until it completes or the deadline is reached with an unsuccessful
* operation.
* @param interval
* The interval to wait after a failures before retrying the transfer.
* If the interval is 0 seconds or GLOBUS_NULL, then an exponential
* backoff will be used.
* @param deadline
* An absolute timeout. If the deadline is GLOBUS_NULL then the retry
* will never timeout.
*
* @return This function returns an error if
* - plugin is null
*
* @see globus_ftp_client_restart_plugin_destroy(),
* globus_ftp_client_handleattr_add_plugin(),
* globus_ftp_client_handleattr_remove_plugin(),
* globus_ftp_client_handle_init()
*/
globus_result_t
globus_ftp_client_restart_plugin_init(
globus_ftp_client_plugin_t * plugin,
int max_retries,
globus_reltime_t * interval,
globus_abstime_t * deadline)
{
char * env_str;
globus_l_ftp_client_restart_plugin_t * d;
globus_result_t result;
GlobusFuncName(globus_ftp_client_restart_plugin_init);
if(plugin == GLOBUS_NULL)
{
return globus_error_put(globus_error_construct_string(
GLOBUS_FTP_CLIENT_MODULE,
GLOBUS_NULL,
"[%s] NULL plugin at %s\n",
GLOBUS_FTP_CLIENT_MODULE->module_name,
_globus_func_name));
}
d =
globus_libc_calloc(1, sizeof(globus_l_ftp_client_restart_plugin_t));
if(! d)
{
return globus_error_put(globus_error_construct_string(
GLOBUS_FTP_CLIENT_MODULE,
GLOBUS_NULL,
"[%s] Out of memory at %s\n",
GLOBUS_FTP_CLIENT_MODULE->module_name,
_globus_func_name));
}
result = globus_ftp_client_plugin_init(plugin,
GLOBUS_L_FTP_CLIENT_RESTART_PLUGIN_NAME,
GLOBUS_FTP_CLIENT_CMD_MASK_ALL,
d);
if(result != GLOBUS_SUCCESS)
{
globus_libc_free(d);
return result;
}
d->max_retries = max_retries > 0 ? max_retries : -1;
if(interval)
{
GlobusTimeReltimeCopy(d->interval, *interval);
}
if((!interval) || (interval->tv_sec == 0 && interval->tv_usec == 0))
{
d->backoff = GLOBUS_TRUE;
d->interval.tv_sec = 1;
d->interval.tv_usec = 0;
}
else
{
d->backoff = GLOBUS_FALSE;
}
if(deadline)
{
GlobusTimeAbstimeCopy(d->deadline, *deadline);
}
else
{
GlobusTimeAbstimeCopy(d->deadline, globus_i_abstime_infinity);
}
d->dest_url = GLOBUS_NULL;
d->source_url = GLOBUS_NULL;
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, copy);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, destroy);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, chmod);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, cksm);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, delete);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, modification_time);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, size);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, feat);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, mkdir);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, rmdir);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, move);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, verbose_list);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, machine_list);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, mlst);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, stat);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, list);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, get);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, put);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, third_party_transfer);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, fault);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, abort);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, complete);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin, data);
GLOBUS_FTP_CLIENT_RESTART_PLUGIN_SET_FUNC(plugin,
response);
env_str = globus_libc_getenv("GUC_STALL_TIMEOUT");
if(env_str != NULL)
{
int sc;
int to_secs;
sc = sscanf(env_str, "%d", &to_secs);
if(sc == 1)
{
globus_ftp_client_restart_plugin_set_stall_timeout(
plugin, to_secs);
}
}
return GLOBUS_SUCCESS;
result_exit:
globus_ftp_client_plugin_destroy(plugin);
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;
}
globus_result_t
globus_ftp_client_restart_marker_plugin_init(
globus_ftp_client_plugin_t * plugin,
globus_ftp_client_restart_marker_plugin_begin_cb_t begin_cb,
globus_ftp_client_restart_marker_plugin_marker_cb_t marker_cb,
globus_ftp_client_restart_marker_plugin_complete_cb_t complete_cb,
void * user_arg)
{
restart_marker_plugin_info_t * ps;
globus_result_t result;
GlobusFuncName(globus_ftp_client_restart_marker_plugin_init);
if(plugin == GLOBUS_NULL)
{
return globus_error_put(globus_error_construct_string(
GLOBUS_FTP_CLIENT_MODULE,
GLOBUS_NULL,
"[%s] NULL plugin at %s\n",
GLOBUS_FTP_CLIENT_MODULE->module_name,
_globus_func_name));
}
ps = (restart_marker_plugin_info_t *)
globus_malloc(sizeof(restart_marker_plugin_info_t));
if(ps == GLOBUS_NULL)
{
return globus_error_put(globus_error_construct_string(
GLOBUS_FTP_CLIENT_MODULE,
GLOBUS_NULL,
"[%s] Out of memory at %s\n",
GLOBUS_FTP_CLIENT_MODULE->module_name,
_globus_func_name));
}
/*
* initialize plugin specific structure.
*/
ps->user_arg = user_arg;
ps->begin_cb = begin_cb;
ps->marker_cb = marker_cb;
ps->complete_cb = complete_cb;
ps->error_url = GLOBUS_NULL;
ps->error_obj = GLOBUS_NULL;
globus_mutex_init(&ps->lock, GLOBUS_NULL);
result = globus_ftp_client_plugin_init(
plugin,
GLOBUS_L_FTP_CLIENT_RESTART_MARKER_PLUGIN_NAME,
GLOBUS_FTP_CLIENT_CMD_MASK_FILE_ACTIONS,
ps);
if(result != GLOBUS_SUCCESS)
{
globus_mutex_destroy(&ps->lock);
globus_free(ps);
return result;
}
globus_ftp_client_plugin_set_destroy_func(plugin,
restart_marker_plugin_destroy_cb);
globus_ftp_client_plugin_set_copy_func(plugin,
restart_marker_plugin_copy_cb);
globus_ftp_client_plugin_set_get_func(plugin,
restart_marker_plugin_get_cb);
globus_ftp_client_plugin_set_data_func(plugin,
restart_marker_plugin_data_cb);
globus_ftp_client_plugin_set_put_func(plugin,
restart_marker_plugin_put_cb);
globus_ftp_client_plugin_set_third_party_transfer_func(plugin,
restart_marker_plugin_transfer_cb);
globus_ftp_client_plugin_set_response_func(plugin,
restart_marker_plugin_response_cb);
globus_ftp_client_plugin_set_complete_func(plugin,
restart_marker_plugin_complete_cb);
globus_ftp_client_plugin_set_fault_func(plugin,
restart_marker_plugin_fault_cb);
globus_ftp_client_plugin_set_abort_func(plugin,
restart_marker_plugin_abort_cb);
return GLOBUS_SUCCESS;
}
/**
* 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();
}
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_registry_add(
globus_extension_registry_t * registry,
void * symbol,
globus_module_descriptor_t * module,
void * data)
{
globus_l_extension_handle_t * entry;
GlobusFuncName(globus_extension_registry_add);
GlobusExtensionDebugEnterSymbol(registry->user_hashing ? "" : symbol);
if(!data || !symbol || !registry)
{
goto error_params;
}
entry = (globus_l_extension_handle_t *)
globus_malloc(sizeof(globus_l_extension_handle_t));
if(!entry)
{
goto error_malloc;
}
entry->owner = (globus_l_extension_module_t *)
globus_thread_getspecific(globus_l_extension_owner_key);
entry->module = module;
entry->datum = data;
entry->ref = 1;
entry->symbol = symbol;
entry->user_hashing = registry->user_hashing;
globus_rmutex_lock(&globus_l_extension_mutex);
{
if(!registry->initialized)
{
if(globus_hashtable_init(
®istry->table,
20,
globus_hashtable_string_hash,
globus_hashtable_string_keyeq) != GLOBUS_SUCCESS)
{
goto error_init;
}
registry->initialized = GLOBUS_TRUE;
}
if(globus_hashtable_insert(
®istry->table, entry->symbol, entry) != GLOBUS_SUCCESS)
{
goto error_insert;
}
}
globus_rmutex_unlock(&globus_l_extension_mutex);
GlobusExtensionDebugExit();
return GLOBUS_SUCCESS;
error_insert:
error_init:
globus_rmutex_unlock(&globus_l_extension_mutex);
globus_free(entry);
error_malloc:
error_params:
GlobusExtensionDebugExitWithError();
return GLOBUS_FAILURE;
}
