static
void
restart_marker_plugin_get_cb(
globus_ftp_client_plugin_t * plugin,
void * plugin_specific,
globus_ftp_client_handle_t * handle,
const char * url,
const globus_ftp_client_operationattr_t * attr,
globus_bool_t restart)
{
restart_marker_plugin_info_t * ps;
ps = (restart_marker_plugin_info_t *) plugin_specific;
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;
}
if(restart)
{
/* we have been restarted.. previous fault disregarded */
return;
}
ps->use_data = GLOBUS_TRUE;
ps->last_time = 0;
if(ps->begin_cb)
{
restart = ps->begin_cb(
ps->user_arg,
handle,
url,
GLOBUS_NULL,
&ps->restart_marker);
}
if(restart)
{
globus_ftp_client_plugin_restart_get(
handle,
url,
attr,
&ps->restart_marker,
GLOBUS_NULL);
}
else
{
globus_ftp_client_restart_marker_init(&ps->restart_marker);
}
}
/**
* 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;
}
static
void
restart_marker_plugin_transfer_cb(
globus_ftp_client_plugin_t * plugin,
void * plugin_specific,
globus_ftp_client_handle_t * handle,
const char * source_url,
const globus_ftp_client_operationattr_t * source_attr,
const char * dest_url,
const globus_ftp_client_operationattr_t * dest_attr,
globus_bool_t restart)
{
restart_marker_plugin_info_t * ps;
ps = (restart_marker_plugin_info_t *) plugin_specific;
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;
}
if(restart)
{
/* we have been restarted.. previous fault disregarded */
return;
}
ps->use_data = GLOBUS_FALSE;
if(ps->begin_cb)
{
restart = ps->begin_cb(
ps->user_arg,
handle,
source_url,
dest_url,
&ps->restart_marker);
}
if(restart)
{
globus_ftp_client_plugin_restart_third_party_transfer(
handle,
source_url,
source_attr,
dest_url,
dest_attr,
&ps->restart_marker,
GLOBUS_NULL);
}
else
{
globus_ftp_client_restart_marker_init(&ps->restart_marker);
}
}
int main(int argc,
char *argv[])
{
globus_ftp_client_handle_t handle;
globus_ftp_client_operationattr_t attr;
globus_byte_t buffer[SIZE];
globus_size_t buffer_length = sizeof(buffer);
globus_result_t result;
char * src;
char * dst;
globus_ftp_client_handleattr_t handle_attr;
globus_ftp_control_layout_t layout;
globus_ftp_control_parallelism_t parallelism;
int i;
globus_ftp_client_restart_marker_t restart;
LTDL_SET_PRELOADED_SYMBOLS();
globus_module_activate(GLOBUS_FTP_CLIENT_MODULE);
globus_ftp_client_handleattr_init(&handle_attr);
globus_ftp_client_operationattr_init(&attr);
layout.mode = GLOBUS_FTP_CONTROL_STRIPING_NONE;
parallelism.mode = GLOBUS_FTP_CONTROL_PARALLELISM_NONE;
globus_ftp_client_restart_marker_init(&restart);
/* Parse local arguments */
for(i = 1; i < argc; i++)
{
if(strcmp(argv[i], "-S") == 0 && i < argc)
{
layout.mode =
GLOBUS_FTP_CONTROL_STRIPING_BLOCKED_ROUND_ROBIN;
layout.round_robin.block_size = 15;
test_remove_arg(&argc, argv, &i, 0);
}
else if(strcmp(argv[i], "-P") == 0 && i + 1 < argc)
{
parallelism.mode = GLOBUS_FTP_CONTROL_PARALLELISM_FIXED;
parallelism.fixed.size = atoi(argv[i+1]);
test_remove_arg(&argc, argv, &i, 1);
}
else if(strcmp(argv[i], "-R") == 0 && i+1 < argc)
{
char * p;
globus_off_t offset, end;
int bytes;
p = argv[i+1];
while((*p) && (sscanf(p,
"%"GLOBUS_OFF_T_FORMAT
"-%"GLOBUS_OFF_T_FORMAT"%n",
&offset,
&end,
&bytes) >= 2))
{
globus_ftp_client_restart_marker_insert_range(
&restart,
offset, end);
p += bytes;
if(*p && *p == ',') p++;
}
test_remove_arg(&argc, argv, &i, 1);
}
}
test_parse_args(argc,
argv,
&handle_attr,
&attr,
&src,
&dst);
globus_mutex_init(&lock, GLOBUS_NULL);
globus_cond_init(&cond, GLOBUS_NULL);
globus_ftp_client_operationattr_set_mode(
&attr,
GLOBUS_FTP_CONTROL_MODE_EXTENDED_BLOCK);
globus_ftp_client_operationattr_set_layout(&attr,
&layout);
globus_ftp_client_operationattr_set_parallelism(&attr,
¶llelism);
globus_ftp_client_handle_init(&handle, &handle_attr);
done = GLOBUS_FALSE;
result = globus_ftp_client_get(&handle,
src,
&attr,
&restart,
done_cb,
0);
if(result != GLOBUS_SUCCESS)
{
fprintf(stderr, "%s", globus_object_printable_to_string(globus_error_get(result)));
done = GLOBUS_TRUE;
error = GLOBUS_TRUE;
}
else
{
globus_ftp_client_register_read(
&handle,
buffer,
buffer_length,
data_cb,
0);
}
globus_mutex_lock(&lock);
while(!done)
{
globus_cond_wait(&cond, &lock);
}
globus_mutex_unlock(&lock);
globus_ftp_client_handle_destroy(&handle);
globus_module_deactivate_all();
if(test_abort_count && error)
{
return 0;
}
return error;
}
/**
* 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;
}
int gsiftp_put(char *filename, FILE **gsiftpfile, int num_streams)
{
int i;
char gsiurl[MAXLEN];
globus_ftp_client_handle_t handle;
globus_ftp_client_operationattr_t attr;
globus_ftp_client_handleattr_t handle_attr;
globus_ftp_control_parallelism_t parallelism;
globus_ftp_control_layout_t layout;
globus_byte_t * buffer;
globus_size_t buffer_length = sizeof(buffer);
globus_result_t result;
globus_ftp_client_restart_marker_t restart;
globus_ftp_control_type_t filetype;
globus_module_activate(GLOBUS_FTP_CLIENT_MODULE);
globus_mutex_init(&lock, GLOBUS_NULL);
globus_cond_init(&cond, GLOBUS_NULL);
globus_ftp_client_handle_init(&handle, GLOBUS_NULL);
globus_ftp_client_handleattr_init(&handle_attr);
globus_ftp_client_operationattr_init(&attr);
layout.mode = GLOBUS_FTP_CONTROL_STRIPING_NONE;
globus_ftp_client_restart_marker_init(&restart);
globus_ftp_client_operationattr_set_mode(
&attr,
GLOBUS_FTP_CONTROL_MODE_EXTENDED_BLOCK);
if (num_streams >= 1)
{
parallelism.mode = GLOBUS_FTP_CONTROL_PARALLELISM_FIXED;
parallelism.fixed.size = num_streams;
globus_ftp_client_operationattr_set_parallelism(
&attr,
¶llelism);
}
globus_ftp_client_operationattr_set_layout(&attr,
&layout);
filetype = GLOBUS_FTP_CONTROL_TYPE_IMAGE;
globus_ftp_client_operationattr_set_type (&attr,
filetype);
globus_ftp_client_handle_init(&handle, &handle_attr);
done = GLOBUS_FALSE;
strcpy(gsiurl,"gsiftp://");
if (strlen(gsiurl)+strlen(filename) > MAXLEN-1)
{
ffpmsg("file name too long (gsiftp_put)");
return (FILE_NOT_OPENED);
}
strcat(gsiurl,filename);
*gsiftpfile = fopen(gsiftp_tmpfile,"r");
if (!*gsiftpfile) {
ffpmsg("Unable to open temporary file!");
return (FILE_NOT_OPENED);
}
result = globus_ftp_client_put(&handle,
gsiurl,
&attr,
&restart,
done_cb,
0);
if(result != GLOBUS_SUCCESS) {
globus_object_t * err;
err = globus_error_get(result);
fprintf(stderr, "%s", globus_object_printable_to_string(err));
done = GLOBUS_TRUE;
}
else {
int rc;
int curr_offset;
for (i = 0; i< 2 * num_streams && feof(*gsiftpfile) == 0; i++)
{
buffer = malloc(MAX_BUFFER_SIZE_W);
globus_mutex_lock(&lock);
curr_offset = global_offset;
rc = fread(buffer, 1, MAX_BUFFER_SIZE_W, *gsiftpfile);
global_offset += rc;
globus_mutex_unlock(&lock);
globus_ftp_client_register_write(
&handle,
buffer,
rc,
curr_offset,
feof(*gsiftpfile) != 0,
data_cb_write,
(void*) *gsiftpfile);
}
}
globus_mutex_lock(&lock);
while(!done) {
globus_cond_wait(&cond, &lock);
}
globus_mutex_unlock(&lock);
globus_ftp_client_handle_destroy(&handle);
globus_module_deactivate_all();
return 0;
}
