int main(int argc, char * argv[])
{
globus_ftp_client_handle_t handle;
globus_ftp_client_operationattr_t attr;
globus_result_t result;
globus_ftp_client_handleattr_t handle_attr;
char * src;
char * dst;
globus_module_activate(GLOBUS_FTP_CLIENT_MODULE);
globus_ftp_client_handleattr_init(&handle_attr);
globus_ftp_client_operationattr_init(&attr);
globus_mutex_init(&lock, GLOBUS_NULL);
globus_cond_init(&cond, GLOBUS_NULL);
test_parse_args(argc,
argv,
&handle_attr,
&attr,
&src,
&dst);
globus_ftp_client_operationattr_set_type(&attr,
GLOBUS_FTP_CONTROL_TYPE_ASCII);
globus_ftp_client_handle_init(&handle, &handle_attr);
done = GLOBUS_FALSE;
result = globus_ftp_client_symlink(&handle,
src,
dst,
&attr,
done_cb,
0);
if(result != GLOBUS_SUCCESS)
{
done = GLOBUS_TRUE;
}
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;
}
int main(int argc, char * argv[])
{
globus_ftp_client_handle_t handle;
globus_ftp_client_operationattr_t attr;
globus_result_t result;
globus_ftp_client_handleattr_t handle_attr;
char * src = NULL;
char * dst = NULL;
struct tm modtime;
extern char * optarg;
extern int optind;
int c;
globus_module_activate(GLOBUS_FTP_CLIENT_MODULE);
globus_ftp_client_handleattr_init(&handle_attr);
globus_ftp_client_operationattr_init(&attr);
globus_mutex_init(&lock, GLOBUS_NULL);
globus_cond_init(&cond, GLOBUS_NULL);
test_parse_args(argc,
argv,
&handle_attr,
&attr,
&src,
&dst);
optind = 1;
while((c = getopt(argc, argv, "T:")) != -1)
{
switch(c)
{
case 'T':
memset(&modtime, 0, sizeof(modtime));
if (sscanf(optarg, "%4d%2d%2d%2d%2d%2d",
&modtime.tm_year, &modtime.tm_mon, &modtime.tm_mday,
&modtime.tm_hour, &modtime.tm_min, &modtime.tm_sec) != 6)
{
printf("Invalid time format\n");
return GLOBUS_TRUE;
}
modtime.tm_year -= 1900;
modtime.tm_mon -= 1;
break;
}
}
globus_ftp_client_operationattr_set_type(&attr,
GLOBUS_FTP_CONTROL_TYPE_ASCII);
globus_ftp_client_handleattr_set_cache_all(&handle_attr,
GLOBUS_TRUE);
globus_ftp_client_handle_init(&handle, &handle_attr);
done = GLOBUS_FALSE;
result = globus_ftp_client_utime(&handle,
src,
&modtime,
&attr,
done_cb,
0);
if(result != GLOBUS_SUCCESS)
{
done = GLOBUS_TRUE;
}
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;
}
int main(int argc,
char *argv[])
{
globus_ftp_client_handle_t handle;
globus_ftp_client_operationattr_t attr;
globus_byte_t * buffer;
globus_size_t buffer_length;
globus_result_t result;
char * src;
char * dst;
globus_ftp_client_handleattr_t handle_attr;
globus_ftp_control_mode_t mode;
int i;
globus_ftp_control_parallelism_t parallelism;
globus_module_activate(GLOBUS_FTP_CLIENT_MODULE);
globus_ftp_client_handleattr_init(&handle_attr);
globus_ftp_client_operationattr_init(&attr);
parallelism.mode = GLOBUS_FTP_CONTROL_PARALLELISM_FIXED;
parallelism.fixed.size = 1;
mode = GLOBUS_FTP_CONTROL_MODE_STREAM;
for(i = 1; i < argc; i++)
{
if(strcmp(argv[i], "-P") == 0 && i + 1 < argc)
{
mode = GLOBUS_FTP_CONTROL_MODE_EXTENDED_BLOCK;
parallelism.mode = GLOBUS_FTP_CONTROL_PARALLELISM_FIXED;
parallelism.fixed.size = atoi(argv[i+1]);
test_remove_arg(&argc, argv, &i, 1);
}
}
test_parse_args(argc,
argv,
&handle_attr,
&attr,
&src,
&dst);
buffer = globus_libc_malloc(SIZE);
buffer_length = SIZE;
globus_mutex_init(&lock, GLOBUS_NULL);
globus_cond_init(&cond, GLOBUS_NULL);
globus_ftp_client_operationattr_set_mode(&attr,
mode);
globus_ftp_client_operationattr_set_parallelism(&attr,
¶llelism);
globus_ftp_client_operationattr_set_read_all(&attr,
GLOBUS_TRUE,
intermediate_cb,
GLOBUS_NULL);
globus_ftp_client_handle_init(&handle, &handle_attr);
done = GLOBUS_FALSE;
result = globus_ftp_client_get(&handle,
src,
&attr,
GLOBUS_NULL,
done_cb,
0);
if(result != GLOBUS_SUCCESS)
{
fprintf(stderr, globus_object_printable_to_string(globus_error_get(result)));
error = GLOBUS_TRUE;
done = 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_libc_free(buffer);
globus_module_deactivate_all();
if(test_abort_count && error)
{
return 0;
}
return error;
}
int main(int argc,
char *argv[])
{
globus_ftp_client_handle_t handle;
globus_ftp_client_operationattr_t attr;
globus_ftp_client_handleattr_t handle_attr;
globus_byte_t buffer[SIZE];
globus_size_t buffer_length = sizeof(buffer);
globus_result_t result;
globus_off_t size;
char * src;
char * dst;
LTDL_SET_PRELOADED_SYMBOLS();
globus_module_activate(GLOBUS_FTP_CLIENT_MODULE);
globus_ftp_client_handleattr_init(&handle_attr);
globus_ftp_client_operationattr_init(&attr);
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_handle_init(&handle, &handle_attr);
done = GLOBUS_FALSE;
result = globus_ftp_client_size(&handle,
src,
&attr,
&size,
done_cb,
0);
if(result != GLOBUS_SUCCESS)
{
fprintf(stderr, "%s", globus_object_printable_to_string(globus_error_get(result)));
error = GLOBUS_TRUE;
done = GLOBUS_TRUE;
}
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;
}
if(error == GLOBUS_SUCCESS)
{
printf("%"GLOBUS_OFF_T_FORMAT"\n", size);
}
return error;
}
int main(int argc, char **argv)
{
globus_ftp_client_handle_t handle;
globus_ftp_client_operationattr_t attr;
globus_result_t result;
globus_ftp_client_handleattr_t handle_attr;
char * src;
char * dst;
LTDL_SET_PRELOADED_SYMBOLS();
globus_module_activate(GLOBUS_FTP_CLIENT_MODULE);
globus_ftp_client_handleattr_init(&handle_attr);
globus_mutex_init(&lock, GLOBUS_NULL);
globus_cond_init(&cond, GLOBUS_NULL);
globus_ftp_client_operationattr_init(&attr);
test_parse_args(argc,
argv,
&handle_attr,
&attr,
&src,
&dst);
globus_ftp_client_handle_init(&handle, &handle_attr);
done = GLOBUS_FALSE;
result = globus_ftp_client_third_party_transfer(&handle,
src,
&attr,
dst,
&attr,
GLOBUS_NULL,
done_cb,
0);
if(result != GLOBUS_SUCCESS)
{
globus_object_t * err;
char * tmpstr;
err = globus_error_get(result);
tmpstr = globus_object_printable_to_string(err);
fprintf(stderr, "Error: %s", tmpstr);
globus_object_free(err);
globus_libc_free(tmpstr);
error = GLOBUS_TRUE;
done = GLOBUS_TRUE;
}
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;
}
int main(int argc, char **argv)
{
globus_ftp_client_handle_t handle;
globus_ftp_client_operationattr_t attr;
globus_result_t result;
int i;
globus_ftp_client_handleattr_t handle_attr;
char * src;
char * dst;
LTDL_SET_PRELOADED_SYMBOLS();
globus_module_activate(GLOBUS_FTP_CLIENT_MODULE);
globus_ftp_client_handleattr_init(&handle_attr);
globus_ftp_client_operationattr_init(&attr);
globus_mutex_init(&lock, GLOBUS_NULL);
globus_cond_init(&cond, GLOBUS_NULL);
test_parse_args(argc,
argv,
&handle_attr,
&attr,
&src,
&dst);
globus_ftp_client_handle_init(&handle, &handle_attr);
globus_ftp_client_handle_cache_url_state(&handle,
src);
globus_ftp_client_handle_cache_url_state(&handle,
dst);
for (i = 0; i < 2; i++)
{
done = GLOBUS_FALSE;
result = globus_ftp_client_third_party_transfer(&handle,
src,
&attr,
dst,
&attr,
GLOBUS_NULL,
done_cb,
0);
if(result != GLOBUS_SUCCESS)
{
done = GLOBUS_TRUE;
}
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;
}
int main()
{
int rc = 0;
int count=0;
globus_ftp_client_handle_t handle;
globus_ftp_client_plugin_t restart_plugin;
globus_ftp_client_plugin_t debug_plugin;
globus_result_t result;
globus_ftp_client_handleattr_t handleattr;
globus_module_activate(GLOBUS_FTP_CLIENT_MODULE);
globus_module_activate(GLOBUS_FTP_CLIENT_RESTART_PLUGIN_MODULE);
globus_module_activate(GLOBUS_FTP_CLIENT_DEBUG_PLUGIN_MODULE);
/* Test using attributes */
result = globus_ftp_client_handleattr_init(&handleattr);
globus_assert(result == GLOBUS_SUCCESS);
result = globus_ftp_client_restart_plugin_init(
&restart_plugin,
0,
GLOBUS_NULL,
GLOBUS_NULL);
globus_assert(result == GLOBUS_SUCCESS);
result = globus_ftp_client_debug_plugin_init(
&debug_plugin,
stderr,
"hello");
globus_assert(result == GLOBUS_SUCCESS);
/* Test 1: insert restart plugin into handle attr */
count++;
result = globus_ftp_client_handleattr_add_plugin(&handleattr,
&restart_plugin);
if(result != GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test 2: insert restart plugin into handle attr (fail) */
count++;
result = globus_ftp_client_handleattr_add_plugin(&handleattr,
&restart_plugin);
if(result == GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test 3: create/destroy handle with attr */
count++;
result = globus_ftp_client_handle_init(&handle, &handleattr);
if(result != GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
else if(globus_ftp_client_handle_destroy(&handle) != GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test 4: insert debug plugin into handle attr */
count++;
result = globus_ftp_client_handleattr_add_plugin(&handleattr,
&debug_plugin);
if(result != GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test 5: create/destroy handle with attr */
count++;
result = globus_ftp_client_handle_init(&handle, &handleattr);
if(result != GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
else if(globus_ftp_client_handle_destroy(&handle) != GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test 6: remove restart plugin from handle attr */
count++;
result = globus_ftp_client_handleattr_remove_plugin(&handleattr,
&restart_plugin);
if(result != GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test 7: remove restart plugin from handle attr (fail) */
count++;
result = globus_ftp_client_handleattr_remove_plugin(&handleattr,
&restart_plugin);
if(result == GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test 8: insert debug plugin into handle attr (fail) */
count++;
result = globus_ftp_client_handleattr_add_plugin(&handleattr,
&debug_plugin);
if(result == GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test 9: remove debug plugin from handle attr */
count++;
result = globus_ftp_client_handleattr_remove_plugin(&handleattr,
&debug_plugin);
if(result != GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test 10: remove restart plugin from handle attr (fail) */
count++;
result = globus_ftp_client_handleattr_remove_plugin(&handleattr,
&restart_plugin);
if(result == GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test 11: create/destroy handle with attr */
count++;
result = globus_ftp_client_handle_init(&handle, &handleattr);
if(result != GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
else if(globus_ftp_client_handle_destroy(&handle) != GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test without attributes */
/* Test 12: create handle without attr */
count++;
result = globus_ftp_client_handle_init(&handle, GLOBUS_NULL);
if(result != GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test 13: add restart plugin into handle */
count++;
result = globus_ftp_client_handle_add_plugin(&handle, &restart_plugin);
if(result != GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test 14: add restart plugin into handle (fail) */
count++;
result = globus_ftp_client_handle_add_plugin(&handle, &restart_plugin);
if(result == GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test 15: add debug plugin into handle */
count++;
result = globus_ftp_client_handle_add_plugin(&handle, &debug_plugin);
if(result != GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test 16: remove restart plugin from handle */
count++;
result = globus_ftp_client_handle_remove_plugin(&handle, &restart_plugin);
if(result != GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test 17: remove restart plugin from handle (fail) */
count++;
result = globus_ftp_client_handle_remove_plugin(&handle, &restart_plugin);
if(result == GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test 18: add debug plugin into handle (fail) */
count++;
result = globus_ftp_client_handle_add_plugin(&handle, &debug_plugin);
if(result == GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test 19: remove debug plugin into handle */
count++;
result = globus_ftp_client_handle_remove_plugin(&handle, &debug_plugin);
if(result != GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test 20: remove restart plugin into handle (fail) */
count++;
result = globus_ftp_client_handle_remove_plugin(&handle, &restart_plugin);
if(result == GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
/* Test 21: destroy handle */
count++;
result = globus_ftp_client_handle_destroy(&handle);
if(result != GLOBUS_SUCCESS)
{
printf("Failed test %d\n", count);
rc++;
}
globus_module_deactivate_all();
return rc;
}
int main(int argc, char **argv)
{
globus_ftp_client_handle_t handle;
globus_ftp_client_operationattr_t attr;
globus_byte_t buffer[1024];
globus_size_t buffer_length = sizeof(buffer);
globus_result_t result;
globus_ftp_client_handleattr_t handle_attr;
char * src;
char * dst;
globus_module_activate(GLOBUS_FTP_CLIENT_MODULE);
globus_ftp_client_handleattr_init(&handle_attr);
globus_ftp_client_operationattr_init(&attr);
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_handle_init(&handle, &handle_attr);
done = GLOBUS_FALSE;
result = globus_ftp_client_get(&handle,
src,
&attr,
GLOBUS_NULL,
done_cb,
0);
if(result != GLOBUS_SUCCESS)
{
done = GLOBUS_TRUE;
}
else
{
globus_ftp_client_register_read(
&handle,
(globus_byte_t *) 0x1,
buffer_length,
data_cb,
0);
globus_ftp_client_register_read(
&handle,
(globus_byte_t *) 0x0,
buffer_length,
data_cb,
0);
}
globus_mutex_lock(&lock);
globus_poll();
globus_ftp_client_register_read(
&handle,
(globus_byte_t *) 0x3,
buffer_length,
data_cb,
0);
while(!done)
{
globus_cond_wait(&cond, &lock);
}
globus_mutex_unlock(&lock);
globus_ftp_client_handle_destroy(&handle);
globus_module_deactivate_all();
return 0;
}
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;
}
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;
}
void ADIOI_GRIDFTP_Delete(char *filename, int *error_code)
{
char myname[]="ADIOI_GRIDFTP_Delete";
int myrank, nprocs;
globus_ftp_client_handle_t handle;
globus_result_t result;
*error_code = MPI_SUCCESS;
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
globus_module_activate(GLOBUS_FTP_CLIENT_MODULE);
result=globus_ftp_client_handle_init(&handle,GLOBUS_NULL);
if (result != GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_handle_init",myname,result);
*error_code= MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE,
myname, __LINE__,
MPI_ERR_IO,
"**io", "**io %s",
globus_object_printable_to_string(globus_error_get(result)));
return;
}
delete_done=GLOBUS_FALSE;
delete_success=GLOBUS_FALSE;
result=globus_ftp_client_delete(&handle,filename,GLOBUS_NULL,delete_cb,GLOBUS_NULL);
if (result != GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_delete",myname,result);
*error_code= MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE,
myname, __LINE__,
MPI_ERR_IO,
"**io", "**io %s",
globus_object_printable_to_string(globus_error_get(result)));
return;
}
globus_mutex_lock(&lock);
while ( delete_done!=GLOBUS_TRUE )
globus_cond_wait(&cond,&lock);
globus_mutex_unlock(&lock);
result=globus_ftp_client_handle_destroy(&handle);
if (result != GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_handle_destroy",myname,result);
*error_code= MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE,
myname, __LINE__,
MPI_ERR_IO,
"**io", "**io %s",
globus_object_printable_to_string(globus_error_get(result)));
return;
}
if ( delete_success!=GLOBUS_TRUE )
{
*error_code= MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE,
myname, __LINE__,
MPI_ERR_IO,
"**io", "**io %s",
globus_object_printable_to_string(globus_error_get(result)));
}
}
int main(int argc, char **argv)
{
globus_ftp_client_handle_t handle;
globus_ftp_client_operationattr_t attr;
globus_byte_t * buffer;
globus_result_t result;
globus_ftp_client_handleattr_t handle_attr;
char * src;
char * dst;
int i;
globus_size_t parallelism_level = 1;
globus_ftp_control_parallelism_t parallelism;
globus_ftp_control_layout_t layout;
LTDL_SET_PRELOADED_SYMBOLS();
globus_module_activate(GLOBUS_FTP_CLIENT_MODULE);
globus_ftp_client_handleattr_init(&handle_attr);
globus_ftp_client_operationattr_init(&attr);
/* Parse local arguments */
for(i = 1; i < argc; i++)
{
if(strcmp(argv[i], "-P") == 0 && i + 1 < argc)
{
parallelism_level = atoi(argv[i+1]);
test_remove_arg(&argc, argv, &i, 1);
}
}
test_parse_args(argc,
argv,
&handle_attr,
&attr,
&src,
&dst);
if(parallelism_level < 1)
{
parallelism_level = 1;
}
parallelism.mode = GLOBUS_FTP_CONTROL_PARALLELISM_FIXED;
parallelism.fixed.size = parallelism_level;
layout.mode = GLOBUS_FTP_CONTROL_STRIPING_BLOCKED_ROUND_ROBIN;
layout.round_robin.block_size = 64*1024;
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_parallelism(&attr,
¶llelism);
globus_ftp_client_operationattr_set_layout(&attr,
&layout);
globus_ftp_client_handle_init(&handle, &handle_attr);
done = GLOBUS_FALSE;
result = globus_ftp_client_put(&handle,
dst,
&attr,
GLOBUS_NULL,
done_cb,
0);
globus_mutex_lock(&lock);
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=1;
int i;
for(i = 0; i < parallelism_level && rc != 0; i++)
{
buffer = malloc(MYSIZE);
rc = read(0, buffer, MYSIZE);
globus_ftp_client_register_write(
&handle,
buffer,
rc,
global_offset,
rc == 0,
data_cb,
0);
global_offset += rc;
}
}
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;
}
void gw_tm_ftp_transfer_cancel_cb( void * user_arg,
globus_gass_copy_handle_t * handle,
globus_object_t * err)
{
int xfr_id;
gw_tm_ftp_transfer_t * xfr;
xfr_id = *( (int *) user_arg );
if ( ( xfr_id < GW_TM_FTP_XFR_POOL_MAX ) && (xfr_id >= 0 ) )
if ( gw_tm_ftp_xfr_pool[xfr_id] != NULL )
xfr = gw_tm_ftp_xfr_pool[xfr_id];
else
{
free(user_arg);
return;
}
else
{
free(user_arg);
return;
}
free(user_arg);
globus_ftp_client_handle_destroy (&(xfr->handle));
globus_ftp_client_handleattr_destroy (&(xfr->attr));
globus_ftp_client_operationattr_destroy (&(xfr->op_attr));
globus_ftp_client_operationattr_destroy (&(xfr->src_op_attr));
globus_gass_copy_handle_destroy (&(xfr->gass_handle));
globus_gass_copy_handleattr_destroy(&(xfr->gass_handel_attr));
/* THERE IS NO FUNCTION TO DESTROY globus_gass_copy_attr_t */
/*
globus_gass_copy_attr_destroy(&(xfr->gass_attr));
globus_gass_copy_attr_destroy(&(xfr->src_gass_attr));
*/
if ( xfr->current_xfr.src_url != NULL )
free(xfr->current_xfr.src_url);
if ( xfr->current_xfr.dst_url != NULL )
free(xfr->current_xfr.dst_url);
if ( xfr->list_buffer != NULL )
free(xfr->list_buffer);
if ( xfr->read_buffer != NULL )
free(xfr->read_buffer);
if ( xfr->base_dir != NULL )
free(xfr->base_dir);
gw_tm_ftp_stack_destroy(&(xfr->file_stack));
gw_tm_ftp_queue_destroy(&(xfr->url_queue));
printf("END %i - SUCCESS -\n",xfr_id);
free(gw_tm_ftp_xfr_pool[xfr_id]);
gw_tm_ftp_xfr_pool[xfr_id] = NULL;
}
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;
int i;
char * subject = GLOBUS_NULL;
globus_module_activate(GLOBUS_FTP_CLIENT_MODULE);
globus_ftp_client_handleattr_init(&handle_attr);
globus_mutex_init(&lock, GLOBUS_NULL);
globus_cond_init(&cond, GLOBUS_NULL);
globus_ftp_client_operationattr_init(&attr);
/* Parse local arguments */
for(i = 1; i < argc; i++)
{
if(strcmp(argv[i], "-A") == 0 && i + 1 < argc)
{
subject = argv[i+1];
test_remove_arg(&argc, argv, &i, 1);
}
}
test_parse_args(argc,
argv,
&handle_attr,
&attr,
&src,
&dst);
globus_ftp_client_operationattr_set_authorization(&attr,
GSS_C_NO_CREDENTIAL,
":globus-mapping:",
"",
0,
subject);
globus_ftp_client_handle_init(&handle, &handle_attr);
done = GLOBUS_FALSE;
result = globus_ftp_client_get(&handle,
src,
&attr,
GLOBUS_NULL,
done_cb,
0);
if(result != GLOBUS_SUCCESS)
{
error = GLOBUS_TRUE;
done = 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;
}
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_off_t start_offset=5;
globus_off_t end_offset=15;
int i;
globus_ftp_control_mode_t mode;
globus_module_activate(GLOBUS_FTP_CLIENT_MODULE);
globus_ftp_client_handleattr_init(&handle_attr);
globus_ftp_client_operationattr_init(&attr);
mode = GLOBUS_FTP_CONTROL_MODE_STREAM;
/* Parse local arguments */
for(i = 1; i < argc; i++)
{
if(strcmp(argv[i], "-R") == 0 && i + 2 < argc)
{
globus_libc_scan_off_t(argv[i+1], &start_offset, GLOBUS_NULL);
globus_libc_scan_off_t(argv[i+2], &end_offset, GLOBUS_NULL);
test_remove_arg(&argc, argv, &i, 2);
}
else if(strcmp(argv[i], "-E") == 0 && i < argc)
{
mode = GLOBUS_FTP_CONTROL_MODE_EXTENDED_BLOCK;
test_remove_arg(&argc, argv, &i, 0);
}
}
test_parse_args(argc,
argv,
&handle_attr,
&attr,
&src,
&dst);
if(start_offset < 0) start_offset = 0;
if(end_offset < 0) end_offset = 0;
globus_mutex_init(&lock, GLOBUS_NULL);
globus_cond_init(&cond, GLOBUS_NULL);
globus_ftp_client_handle_init(&handle, &handle_attr);
globus_ftp_client_operationattr_set_mode(&attr,
mode);
done = GLOBUS_FALSE;
result = globus_ftp_client_partial_get(&handle,
src,
&attr,
GLOBUS_NULL,
start_offset,
end_offset,
done_cb,
0);
if(result != GLOBUS_SUCCESS)
{
error = GLOBUS_TRUE;
done = 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;
}
