static void data_cb_read( void * user_arg,
globus_ftp_client_handle_t * handle,
globus_object_t * err,
globus_byte_t * buffer,
globus_size_t length,
globus_off_t offset,
globus_bool_t eof)
{
if(err) {
fprintf(stderr, "%s", globus_object_printable_to_string(err));
}
else {
FILE* fd = (FILE*) user_arg;
int rc = fwrite(buffer, 1, length, fd);
if (ferror(fd)) {
printf("Read error in function data_cb_read; errno = %d\n", errno);
return;
}
if (!eof) {
globus_ftp_client_register_read(handle,
buffer,
MAX_BUFFER_SIZE_R,
data_cb_read,
(void*) fd);
}
}
return;
}
static
void
data_cb(
void * user_arg,
globus_ftp_client_handle_t * handle,
globus_object_t * err,
globus_byte_t * buffer,
globus_size_t length,
globus_off_t offset,
globus_bool_t eof)
{
globus_result_t result;
printf("Data callback: %s, %s\n",
eof ? "eof" : "not eof",
err ? "error" : "not error");
fwrite(buffer, 1, length, stdout);
if(!eof)
{
result = globus_ftp_client_register_read(handle,
buffer,
1024,
data_cb,
0);
printf("result=%d\n", (int) result);
}
}
static
void
data_cb(
void * user_arg,
globus_ftp_client_handle_t * handle,
globus_object_t * err,
globus_byte_t * buffer,
globus_size_t length,
globus_off_t offset,
globus_bool_t eof)
{
static int first = 1;
fprintf(stdout,
"%s[%"GLOBUS_OFF_T_FORMAT",%"GLOBUS_OFF_T_FORMAT"]\n",
first?"":"\n", offset, offset+length);
first = 0;
fwrite(buffer, 1, length, stdout);
if(!eof)
{
globus_ftp_client_register_read(handle,
buffer,
SIZE,
data_cb,
0);
}
}
static void touch_data_cb(void *myargs, globus_ftp_client_handle_t *handle, globus_object_t *error,
globus_byte_t *buffer, globus_size_t length, globus_off_t offset,
globus_bool_t eof)
{
if (error)
FPRINTF(stderr, "%s\n", globus_object_printable_to_string(error));
globus_ftp_client_register_read(handle,buffer,length,touch_data_cb,myargs);
return;
}
static void readdiscontig_data_cb(void *myargs, globus_ftp_client_handle_t *handle, globus_object_t *error,
globus_byte_t *buffer, globus_size_t length, globus_off_t offset,
globus_bool_t eof)
{
globus_size_t *bytes_read;
bytes_read=(globus_size_t *)myargs;
if (error)
{
fprintf(stderr, "%s\n", globus_object_printable_to_string(error));
}
*bytes_read+=length;
/* I don't understand why the data callback has to keep recalling register_read,
but everything I've done and all the examples I've seen seem to require
that behavior to work... */
if ( !eof )
globus_ftp_client_register_read(handle,
buffer,
length,
readdiscontig_data_cb,
(void *)(bytes_read));
return;
}
static void readcontig_data_cb(void *myargs, globus_ftp_client_handle_t *handle, globus_object_t *error,
globus_byte_t *buffer, globus_size_t length, globus_off_t offset,
globus_bool_t eof)
{
globus_size_t *bytes_read;
bytes_read=(globus_size_t *)myargs;
if (error)
{
fprintf(stderr, "%s\n", globus_object_printable_to_string(error));
}
*bytes_read+=length;
/* I don't understand why the data callback has to keep recalling register_read,
but everything I've done and all the examples I've seen seem to require
that behavior to work... */
/*
* Using buffer+length seems to work, but is probably not the correct
* solution. A big read of 256kB chunks will have lines like this:
readcontig_data_cb: buffer 0x404e0008 length 0 offset 31719424 eof 1
readcontig_data_cb: buffer 0x404a0008 length 65536 offset 31981568 eof 0
readcontig_data_cb: buffer 0x404b0008 length 65536 offset 32047104 eof 0
readcontig_data_cb: buffer 0x404c0008 length 65536 offset 32112640 eof 0
readcontig_data_cb: buffer 0x404d0008 length 65536 offset 32178176 eof 0
*/
#if 0
fprintf(stderr, "%s: buffer %p length %d offset %Ld eof %d\n",
__func__, buffer, length, offset, eof);
#endif
if ( !eof )
globus_ftp_client_register_read(handle,
buffer+length,
length,
readcontig_data_cb,
(void *)(bytes_read));
return;
}
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_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_get(char *filename, FILE **gsiftpfile, int num_streams)
{
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[MAX_BUFFER_SIZE_R];
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_get)");
return (FILE_NOT_OPENED);
}
strcat(gsiurl,filename);
*gsiftpfile = fopen(gsiftp_tmpfile,"w+");
if (!*gsiftpfile) {
ffpmsg("Unable to open temporary file!");
return (FILE_NOT_OPENED);
}
result = globus_ftp_client_get(&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 {
globus_ftp_client_register_read(&handle,
buffer,
buffer_length,
data_cb_read,
(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_ReadDiscontig(ADIO_File fd, void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
ADIO_Offset offset, ADIO_Status *status, int
*error_code)
{
char myname[]="ADIOI_GRIDFTP_ReadDiscontig";
int myrank,nprocs;
/* size and extent of buffer in memory */
MPI_Aint btype_size,btype_extent;
/* size and extent of file record layout */
MPI_Aint ftype_size,ftype_extent;
/* size of file elemental type; seeks are done in units of this */
MPI_Aint etype_size;
MPI_Aint extent;
ADIOI_Flatlist_node *flat_file;
int i,buf_contig,boff,nblks;
globus_off_t start,end,goff;
globus_size_t bytes_read;
globus_result_t result;
globus_byte_t *tmp;
if ( fd->access_mode&MPI_MODE_WRONLY )
{
*error_code=MPIR_ERR_MODE_WRONLY;
return;
}
*error_code=MPI_SUCCESS;
MPI_Comm_rank(fd->comm,&myrank);
MPI_Comm_size(fd->comm,&nprocs);
etype_size=fd->etype_size;
MPI_Type_size(fd->filetype,&ftype_size);
MPI_Type_extent(fd->filetype,&ftype_extent);
/* This is arguably unnecessary, as this routine assumes that the
buffer in memory is contiguous */
MPI_Type_size(datatype,&btype_size);
MPI_Type_extent(datatype,&btype_extent);
ADIOI_Datatype_iscontig(datatype,&buf_contig);
if ( ( btype_extent!=btype_size ) || ( ! buf_contig ) )
{
FPRINTF(stderr,"[%d/%d] %s called with discontigous memory buffer\n",
myrank,nprocs,myname);
fflush(stderr);
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, myname, __LINE__,
MPI_ERR_IO, "**io", 0 );
return;
}
/* from here we can assume btype_extent==btype_size */
/* Flatten out fd->filetype so we know which blocks to skip */
ADIOI_Flatten_datatype(fd->filetype);
flat_file = ADIOI_Flatlist;
while (flat_file->type != fd->filetype && flat_file->next!=NULL)
flat_file = flat_file->next;
/* Figure out how big the area to read is */
start=(globus_off_t)(offset*etype_size);
goff=start;
boff=0;
extent=0;
nblks=0;
while ( boff < (count*btype_size) )
{
int blklen=0;
for (i=0;i<flat_file->count;i++)
{
/* find the length of the next block */
if ( (boff+flat_file->blocklens[i]) < (count*btype_size) )
blklen=flat_file->blocklens[i];
else
blklen=(count*btype_size)-boff;
/* increment buffer size to be used */
boff+=blklen;
/* compute extent -- the nblks*ftype_extent bit is
there so we remember how many ftypes we've already
been through */
extent=MAX(extent,nblks*ftype_extent+flat_file->indices[i]+blklen);
if ( boff>=(count*btype_size) )
break;
}
nblks++;
}
if ( extent < count*btype_size )
{
fprintf(stderr,"[%d/%d] %s error in computing extent -- extent %d is smaller than total bytes requested %d!\n",
myrank,nprocs,myname,extent,count*btype_size);
fflush(stderr);
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, myanem, __LINE__,
MPI_ERR_IO, "**io", 0);
return;
}
end=start+(globus_off_t)extent;
tmp=(globus_byte_t *)malloc((size_t)extent*sizeof(globus_byte_t));
/* start up the globus partial read */
globus_mutex_init(&readdiscontig_ctl_lock, GLOBUS_NULL);
globus_cond_init(&readdiscontig_ctl_cond, GLOBUS_NULL);
readdiscontig_ctl_done=GLOBUS_FALSE;
if ( (result=globus_ftp_client_partial_get(&(gridftp_fh[fd->fd_sys]),
fd->filename,
&(oattr[fd->fd_sys]),
GLOBUS_NULL,
start,
end,
readdiscontig_ctl_cb,
GLOBUS_NULL))!=GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_partial_get",myname,result);
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, myanem, __LINE__,
MPI_ERR_IO, "**io", "**io %s",
globus_object_printable_to_string(result));
return;
}
/* Do all the actual I/Os */
/* Since globus_ftp_client_register_read() is brain-dead and doesn't
let you specify an offset, we have to slurp the entire extent into
memory and then parse out the pieces we want... Sucks, doesn't it?
This should probably be done in chunks (preferably of a size
set using a file hint), but that'll have to come later.
--TB */
if ( (result=globus_ftp_client_register_read(&(gridftp_fh[fd->fd_sys]),
tmp,
(globus_size_t)extent,
readdiscontig_data_cb,
(void *)(&bytes_read)))!=GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_register_read",myname,result);
*error_code = MPIO_Err_create_code(MPI_SUCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", globus_object_printable_to_string(result));
return;
}
/* The ctl callback won't start till the data callbacks complete, so it's
safe to wait on just the ctl callback */
globus_mutex_lock(&readdiscontig_ctl_lock);
while ( readdiscontig_ctl_done!=GLOBUS_TRUE )
globus_cond_wait(&readdiscontig_ctl_cond,&readdiscontig_ctl_lock);
globus_mutex_unlock(&readdiscontig_ctl_lock);
globus_mutex_destroy(&readdiscontig_ctl_lock);
globus_cond_destroy(&readdiscontig_ctl_cond);
boff=0;
nblks=0;
goff=0;
while ( boff < (count*btype_size) )
{
int i,blklen;
for (i=0;i<flat_file->count;i++)
{
if ( (boff+flat_file->blocklens[i]) < (count*btype_size) )
blklen=flat_file->blocklens[i];
else
blklen=(count*btype_size)-boff;
if ( blklen > 0 )
{
goff=nblks*ftype_extent+flat_file->indices[i];
memcpy((globus_byte_t *)buf+boff,tmp+goff,(size_t)blklen);
boff+=blklen;
if ( boff>=(count*btype_size) )
break;
}
}
nblks++;
}
free(tmp);
#ifdef HAVE_STATUS_SET_BYTES
MPIR_Status_set_bytes(status, datatype, bytes_read);
#endif
if (file_ptr_type != ADIO_EXPLICIT_OFFSET)
{
fd->fp_ind += extent;
fd->fp_sys_posn = fd->fp_ind;
}
else {
fd->fp_sys_posn = offset + extent;
}
}
void ADIOI_GRIDFTP_ReadContig(ADIO_File fd, void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
ADIO_Offset offset, ADIO_Status *status, int
*error_code)
{
static char myname[]="ADIOI_GRIDFTP_ReadContig";
int myrank, nprocs, datatype_size;
globus_size_t len,bytes_read=0;
globus_off_t goff;
globus_result_t result;
if ( fd->access_mode&MPI_MODE_WRONLY )
{
*error_code=MPIR_ERR_MODE_WRONLY;
return;
}
*error_code = MPI_SUCCESS;
MPI_Comm_size(fd->comm, &nprocs);
MPI_Comm_rank(fd->comm, &myrank);
MPI_Type_size(datatype, &datatype_size);
if (file_ptr_type != ADIO_EXPLICIT_OFFSET)
{
offset = fd->fp_ind;
}
/* Do the gridftp I/O transfer */
goff = (globus_off_t)offset;
len = ((globus_size_t)datatype_size)*((globus_size_t)count);
globus_mutex_init(&readcontig_ctl_lock, GLOBUS_NULL);
globus_cond_init(&readcontig_ctl_cond, GLOBUS_NULL);
readcontig_ctl_done=GLOBUS_FALSE;
if ( (result=globus_ftp_client_partial_get(&(gridftp_fh[fd->fd_sys]),
fd->filename,
&(oattr[fd->fd_sys]),
GLOBUS_NULL,
goff,
goff+(globus_off_t)len,
readcontig_ctl_cb,
GLOBUS_NULL))!=GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_partial_get",myname,result);
*error_code=MPI_ERR_IO;
ADIOI_Error(fd,*error_code,myname);
return;
}
result=globus_ftp_client_register_read(&(gridftp_fh[fd->fd_sys]),
(globus_byte_t *)buf, len, readcontig_data_cb,
(void *)(&bytes_read));
if ( result != GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_register_read",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(result));
return;
}
/* The ctl callback won't start till the data callbacks complete, so it's
safe to wait on just the ctl callback */
globus_mutex_lock(&readcontig_ctl_lock);
while ( readcontig_ctl_done!=GLOBUS_TRUE )
globus_cond_wait(&readcontig_ctl_cond,&readcontig_ctl_lock);
globus_mutex_unlock(&readcontig_ctl_lock);
globus_mutex_destroy(&readcontig_ctl_lock);
globus_cond_destroy(&readcontig_ctl_cond);
#ifdef HAVE_STATUS_SET_BYTES
MPIR_Status_set_bytes(status, datatype, bytes_read);
#endif
if (file_ptr_type != ADIO_EXPLICIT_OFFSET)
{
fd->fp_ind += bytes_read;
fd->fp_sys_posn = fd->fp_ind;
}
else {
fd->fp_sys_posn = offset + bytes_read;
}
}
void gw_tm_ftp_list_read_callback(void * user_arg,
globus_ftp_client_handle_t * handle,
globus_object_t * err,
globus_byte_t * buffer,
globus_size_t length,
globus_off_t offset,
globus_bool_t eof)
{
gw_tm_ftp_transfer_t * xfr;
globus_result_t grc;
char * temp_p = NULL;
char * start_ptr;
char * end_ptr;
char mode[16];
char links[16];
char owner[16];
char group[16];
char size[16];
char month[5];
char day[5];
char file[256];
char alt_file[256];
char * filename;
char * url;
int i,len, rc;
int xfr_id;
if(err) /* ERROR DIR DOES NOT EXISTS : ERROR HANDLING NOT HERE */
return;
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;
}
if( xfr->list_buffer == NULL && eof && offset == 0)
{
xfr->list_buffer = (char *) malloc( sizeof(char) *length);
xfr->buffer_length = length;
memcpy(xfr->list_buffer,buffer,length);
}
else
{
if( (length + offset) > xfr->buffer_length )
{
temp_p = (char *) realloc(xfr->list_buffer, length + offset);
xfr->list_buffer = temp_p;
xfr->buffer_length = length + offset;
}
memcpy(xfr->list_buffer + offset,buffer,length);
}
if(!eof)
{
grc = globus_ftp_client_register_read (&(xfr->handle), buffer,
GW_TM_FTP_BUFFER_LENGTH, gw_tm_ftp_list_read_callback, user_arg);
if( grc != GLOBUS_SUCCESS ) /* ERROR & CANCEL? */
{
printf("RMDIR %d - FAILURE globus_ftp_client_register_read command\n", xfr->jid);
free(user_arg);
return;
}
}
else
{
i = 0;
start_ptr = xfr->list_buffer;
end_ptr = xfr->list_buffer;
while (i < xfr->buffer_length)
{
while ((*end_ptr != '\n') && (*end_ptr != '\r'))
{
end_ptr++;
i++;
}
*end_ptr = '\0';
rc = sscanf(start_ptr,"%s %s %s %s %s %s %s %s %s",
mode,
links,
owner,
group,
size,
month,
day,
file,
alt_file);
if ( rc == 8 )
filename = file;
else if (rc == 9)
filename = alt_file;
else
{
start_ptr = end_ptr+1;
end_ptr = start_ptr;
i = i+1;
continue;
}
if ( (strcmp(filename,".") !=0) &&
(strcmp(filename,"..")!=0) )
{
len = xfr->base_dir_length + strlen(filename) + 1;
if (mode[0] == '-')
{
url = (char *) malloc (sizeof(char)* len);
snprintf(url, sizeof(char)* len,"%s%s",
xfr->base_dir,
filename);
gw_tm_ftp_stack_push(&(xfr->file_stack),
url,
GW_TM_FTP_FILE,
GW_FALSE);
free(url);
}
else if (mode[0] == 'd')
{
url = (char *) malloc (sizeof(char)* (len+1));
snprintf(url, sizeof(char)* (len + 1),"%s%s/",
xfr->base_dir,
filename);
gw_tm_ftp_stack_push(&(xfr->file_stack),
url,
GW_TM_FTP_DIR,
GW_FALSE);
free(url);
}
}
start_ptr = end_ptr+1;
end_ptr = start_ptr;
i = i+1;
}
free(xfr->list_buffer);
xfr->list_buffer = NULL;
xfr->buffer_length = 0;
free(user_arg);
}
return;
}
int gw_tm_ftp_transfer_expand_url ( int xfr_id,
const char * url_dir,
globus_ftp_client_complete_callback_t done_cb)
{
globus_result_t grc;
int rc;
int length;
gw_tm_ftp_transfer_t * xfr;
int * _xfr_id;
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
return 1;
else
return 1;
length = strlen(url_dir);
if ( xfr->base_dir != NULL )
free(xfr->base_dir);
if ( url_dir[length-1] != '/' )
{
xfr->base_dir = (char *) malloc ( (length + 2) * sizeof(char) );
snprintf(xfr->base_dir,(length + 2)*sizeof(char), "%s/",url_dir);
}
else
xfr->base_dir = strdup(url_dir);
xfr->base_dir_length = strlen(xfr->base_dir);
rc = gw_tm_ftp_stack_push(&(xfr->file_stack), xfr->base_dir, GW_TM_FTP_DIR, GW_TRUE);
if ( rc != 0 )
return 1;
/* MACHINE LIST SHOULD BE CHECK IF FEATURE IS SUPPORTED */
/* WE WILL USE LIST COMMAND...
grc = globus_ftp_client_machine_list ( &(xfr->handle), xfr->base_dir,
&(xfr->op_attr), done_cb, (void *) xfr);
*/
_xfr_id = ( int *) malloc (sizeof(int));
*(_xfr_id) = xfr->jid;
grc = globus_ftp_client_verbose_list( &(xfr->handle), xfr->base_dir,
&(xfr->op_attr), done_cb, (void *) _xfr_id);
if ( grc != GLOBUS_SUCCESS)
{
free(_xfr_id);
return 1;
}
_xfr_id = ( int *) malloc (sizeof(int));
*(_xfr_id) = xfr->jid;
grc = globus_ftp_client_register_read (&(xfr->handle), (xfr->read_buffer),
GW_TM_FTP_BUFFER_LENGTH, gw_tm_ftp_list_read_callback, (void *) _xfr_id);
if ( grc != GLOBUS_SUCCESS )
{
free(_xfr_id); /*Leaving one int (_xfr_id) behind!!!!*/
return 1;
}
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;
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;
}