static void
socket_io_add (MonoAsyncResult *ares, MonoSocketAsyncResult *state)
{
MonoMList *list;
SocketIOData *data = &socket_io_data;
int fd;
gboolean is_new;
int ievt;
socket_io_init (&socket_io_data);
if (mono_runtime_is_shutting_down () || data->inited == 3 || data->sock_to_state == NULL)
return;
if (async_tp.pool_status == 2)
return;
MONO_OBJECT_SETREF (state, ares, ares);
fd = GPOINTER_TO_INT (state->handle);
EnterCriticalSection (&data->io_lock);
if (data->sock_to_state == NULL) {
LeaveCriticalSection (&data->io_lock);
return;
}
list = mono_g_hash_table_lookup (data->sock_to_state, GINT_TO_POINTER (fd));
if (list == NULL) {
list = mono_mlist_alloc ((MonoObject*)state);
is_new = TRUE;
} else {
list = mono_mlist_append (list, (MonoObject*)state);
is_new = FALSE;
}
mono_g_hash_table_replace (data->sock_to_state, state->handle, list);
ievt = get_events_from_list (list);
data->modify (data->event_data, fd, state->operation, ievt, is_new);
LeaveCriticalSection (&data->io_lock);
}
int main (int argc, char **argv)
{
int ret;
LorsExnode *exnode;
struct ibp_depot lbone_server = {"dsj.sinrg.cs.utk.edu", 6767};
socket_io_handler handle;
IBP_depot lbs;
char *s;
char *lbonehost = NULL;
char *output_filename = "-";
int same_output = 0;
const char *filename;
char *location = "state= tn";
int storage_type = IBP_SOFT;
int maxdepots = 6;
double duration = 2;
ulong_t data_blocksize = 1024*1024*5;
char *s_data_blocksize = NULL;
ulong_t max_buffersize = 1024*1024*45;
char *s_max_buffersize = NULL;
ulong_t prebuffer = 1;
char *s_prebuffer = NULL;
int cache = 2;
ulong_t offset=0, length=0;
int copies = 1;
int threads = 10;
int timeout = 600;
char *s_timeout = "600s";
int encryption = 0;
int v;
int try1 = 0;
int file_cnt = 0;
int dp_threads = -1;
int job_threads = 2;
int progress = 5;
XndRc xndrc;
int opts = 0;
char *report_host = NULL;
uuid_t out;
char session_id[33];
int i;
int inner_loop_flag = 0;
// init status
handle.status = CONN_WAITING;
poptContext optCon; /* context for parsing command-line options */
struct poptOption optionsTable[] = {
{ "samename", 'f', POPT_ARG_NONE, 0, SAME_OUTPUTNAME,
"Specify the exNode filename by appending .xnd to the original filename.", NULL },
{ "outputfile", 'o', POPT_ARG_STRING, &output_filename, OUTPUTNAME,
"Specify a specific name for the output exNode file.", NULL},
{ "version", 'v', POPT_ARG_NONE, 0, LORS_VERSION,
"Display Version information about this package.", NULL},
{ "verbose", 'V', POPT_ARG_INT, &xndrc.verbose, VERBOSE,
"Modify the level or mode of Verbosity in output messages.", "0"},
{ "thread-depot", 'a', POPT_ARG_INT, &dp_threads, THREADDEPOT,
"Specify the maxmium connection to any single IBP depot.",
"-1"},
{ "redundancy", 'r', POPT_ARG_INT, &job_threads, REDUNDANCY ,
"Specify the maxmium number of threads working on a single download job.",
"1"},
{ "resume", 'R', POPT_ARG_NONE, 0, LORS_RECOVER,
"Download will resume working on a partially downloaded file if one is detected.",
NULL},
{ "progress", 'p', POPT_ARG_INT, &progress, PROGRESS,
"The progress number specifies how many completed blocks are allowed before "
"a download of a pending block is duplicated.",
"0"},
/*{ "location", 'l', POPT_ARG_STRING, &xndrc.location, LOCATION_HINT,
"Specify a location hint to pass the LBone Query.", "'x'"},*/
{ "bs", 'b', POPT_ARG_STRING|POPT_ARGFLAG_ONEDASH, &s_data_blocksize, DATA_BLOCKSIZE,
"Specify the logical blocksize of transfers.", "'5M'"},
{ "threads", 't', POPT_ARG_INT, &xndrc.threads, THREADS,
"Specify the maximum number of threads to use to perform Download.", NULL},
{ "timeout", 'T', POPT_ARG_STRING, &s_timeout, TIMEOUT,
"Specify the maximum time to allow for all operations.", "'3m'"},
{ "prebuffer", 'q', POPT_ARG_INT, &prebuffer, PREBUFFER_SIZE,
"Specify the number of blocks to prebuffer before outputting to file.", NULL},
{ "cache", 'C', POPT_ARG_INT, &cache, CACHE_SIZE,
"Specify the number of block-sized memory buffers to use during download.", NULL},
{ "buffersize", 'M', POPT_ARG_STRING, &s_max_buffersize, MAX_BUFFSIZE,
"Specify the maximum internal buffer size to use on operations.", NULL},
{ "offset", 'O', POPT_ARG_LONG, &offset, FILE_OFFSET,
"Specify an offset relative to the exNode from which download will begin",NULL},
{ "length", 'L', POPT_ARG_LONG, &length, FILE_LENGTH,
"Specify a length other than the logical extent of the exNode.", NULL},
{ "demo", 'D', POPT_ARG_NONE, 0, LORS_ARG_DEMO,
"Add the messages understood by the LoRS View visualization.", NULL},
{ "visualize-progress", 'X', POPT_ARG_STRING, &report_host, VISUALIZE_PROGRESS,
"Http link to visualizer with port e.g. http://dlt.incntre.iu.edu:8000 .", NULL},
POPT_AUTOHELP
{ NULL, 0, 0, NULL, 0 }
};
optCon = poptGetContext(NULL, argc, (const char **)argv, optionsTable, 0);
poptSetOtherOptionHelp(optCon, "<filename>");
#ifndef _MINGW
signal(SIGPIPE, sigpipe_handle);
#endif
if ( argc < 2 )
{
poptPrintUsage(optCon, stderr, 0);
poptPrintHelp(optCon, stderr, 0);
exit(EXIT_FAILURE);
}
lbs = &lbone_server;
parse_xndrc_files(&xndrc);
g_lors_demo = xndrc.demo;
while ( (v=poptGetNextOpt(optCon)) >= 0)
{
switch(v)
{
case DATA_BLOCKSIZE:
if ( strtobytes(s_data_blocksize, &xndrc.data_blocksize) != 0 )
{
fprintf(stderr, "The blocksize specified is too large for internal datatype.\n");
exit(EXIT_FAILURE);
}
break;
case MAX_BUFFSIZE:
if ( strtobytes(s_max_buffersize, &xndrc.max_buffersize) != 0 )
{
fprintf(stderr, "The blocksize specified is too large for internal datatype.\n");
exit(EXIT_FAILURE);
}
break;
case TIMEOUT:
if ( strtotimeout(s_timeout, &xndrc.timeout) != 0 )
{
fprintf(stderr, "Value too large for type.\n");
exit(EXIT_FAILURE);
}
break;
case LBONESERVER:
strncpy(lbone_server.host, lbonehost, 255);
break;
case STORAGE_TYPE_HARD:
xndrc.storage_type = IBP_HARD;
break;
case STORAGE_TYPE_SOFT:
xndrc.storage_type = IBP_SOFT;
break;
case LORS_RECOVER:
opts |= LORS_RECOVER;
break;
case PREBUFFER_SIZE:
if ( prebuffer <= 0 ){
fprintf(stderr,"Invalid pre-buffer number !\n");
exit(-1);
};
break;
case CACHE_SIZE:
if ( cache < 0 ) { cache = 0 ; };
break;
case LORS_VERSION:
{
const char *package;
double version;
lorsGetLibraryVersion(&package, &version);
fprintf(stderr, "Version: %s %f\n", package, version);
exit(EXIT_FAILURE);
break;
}
case LORS_ARG_DEMO:
g_lors_demo = (!g_lors_demo);
break;
case SAME_OUTPUTNAME:
same_output = 1;
break;
default:
/* TODO: be more specific: */
/*fprintf(stderr, "Unsupported option: %d\n", v);*/
break;
}
}
g_db_level = xndrc.verbose;
if ( v < -1 )
{
fprintf(stderr, "error: %d\n", v);
fprintf(stderr, "%s: %s\n",
poptBadOption(optCon, POPT_BADOPTION_NOALIAS),
poptStrerror(v));
}
while ( (filename = poptGetArg(optCon)) != NULL )
{
longlong x = 0;
longlong y = 0;
file_cnt++;
if ( same_output == 1 ) { output_filename = NULL; }
lorsDebugPrint(D_LORS_VERBOSE, "%s %s %d %d %ld %d %d\n",
filename, output_filename, offset, length,
xndrc.max_buffersize, xndrc.threads, xndrc.timeout);
lorsDebugPrint(D_LORS_VERBOSE, "offset: %d, length: %d\n", offset, length);
lorsDebugPrint(D_LORS_VERBOSE, "File: %s--------------------------------------------\n", filename);
x = length;
y = offset;
// generate session id
if(report_host != NULL){
uuid_generate(out);
for(i = 0; i < 16; i++)
sprintf(session_id + (i*2),"%02x", out[i]);
handle.server_add = report_host;
handle.session_id = session_id;
//fprintf(stderr, "Init .. \n");
if(socket_io_init(&handle) != SOCK_SUCCESS){
fprintf(stderr, "socket io Init failed \n");
}
}
if ( lbonehost == NULL )
{
lbs = xndrc.lboneList[0];
try1 = 1;
} else
{
lbs = &lbone_server;
try1 = 0;
}
do
{
ret = lorsDownloadFile(filename, output_filename, y, x,
xndrc.data_blocksize,
xndrc.max_buffersize,
prebuffer,
dp_threads,
job_threads,
progress,
cache,
lbs->host,
lbs->port,
xndrc.location,xndrc.resolution_file,
xndrc.threads, xndrc.timeout,
&handle, opts);
if ( ret != LORS_SUCCESS )
{
if ( ret == LORS_LBONE_FAILED && xndrc.lboneList[try1] != NULL )
{
fprintf(stderr, "%s: %d\n", xndrc.lboneList[try1]->host,
xndrc.lboneList[try1]->port);
fprintf(stderr, "LBone failure: trying next server\n");
lbs = xndrc.lboneList[try1];
try1++;
} else
{
fprintf(stderr, "LORS_ERROR: %d\n", ret);
inner_loop_flag = 1;
break;
}
}
} while ( ret != LORS_SUCCESS );
if(report_host != NULL){
if(handle.status == CONN_CONNECTED){
socket_io_send_clear(&handle);
}
if(handle.status != CONN_WAITING){
socket_io_close(&handle);
}
}
if(inner_loop_flag){
exit(EXIT_FAILURE);
}
}
if ( file_cnt == 0 )
{
fprintf(stderr, "Error. You must also provide a filename on "
"which lors_upload operates.\n");
poptPrintHelp(optCon, stderr, 0);
exit(EXIT_FAILURE);
}
free_xndrc(&xndrc);
poptFreeContext(optCon);
return 0;
}
int main (int argc, char **argv)
{
int ret;
LorsExnode *exnode;
struct ibp_depot lbone_server = {"dsj.sinrg.cs.utk.edu", 6767};
socket_io_handler handle;
IBP_depot lbs = NULL,*dp_list = NULL;
char *s;
char *lbonehost = NULL;
char *output_filename = NULL;
char *upload_dir_path = NULL;
char *upload_dir_id = NULL;
const char *filename = NULL;
int same_name=0;
char *s_data_blocksize = NULL;
char *s_e2e_blocksize = NULL;
char *s_max_buffersize = NULL;
ulong_t offset=0;
long length=-1;
char * s_offset=NULL;
char * s_length=NULL;
char *s_timeout = "600s";
char *s_duration = "1d";
int encryption = 0;
int v;
int none=0;
int depot_list = 0;
int file_cnt = 0;
XndRc xndrc;
XndRc drc;
int *e2e_order_tmp = NULL;
int e2e_cnt = 0;
int try1 = 0;
int type_set = 0;
int fragments=0;
char *rcfile=NULL;
char *report_host = NULL;
uuid_t out;
char session_id[33];
int i;
unis_config config;
poptContext optCon; /* context for parsing command-line options */
handle.status = CONN_WAITING;
struct poptOption optionsTable[] = {
{ "samename", 'f', POPT_ARG_NONE, 0, SAME_OUTPUTNAME,
"Specify the exNode filename by appending .xnd to the original filename.", NULL },
{ "stdin", 'i', POPT_ARG_NONE, 0, READ_STDIN,
"Read from standard input rather than a specified filename.", NULL },
{ "outputfile", 'o', POPT_ARG_STRING, &output_filename, OUTPUTNAME,
"Specify a specific name for the output exNode file. "
"Default output format is Exnode. 1) If file extension is \".uef\" "
"then output file format will be Unis Exnode Format (.uef) "
"2) if ouputfile contain link then exnodes will posted"
" to that link", NULL},
{ "upload_dir", 'u', POPT_ARG_STRING, &upload_dir_path, UPLOAD_DIR,
"Specifiy the upload directory path in Unis File System e.g. /user23/LSAT8/2015/1/15", NULL},
{ "version", 'v', POPT_ARG_NONE, 0, LORS_VERSION,
"Display Version information about this package.", NULL},
{ "verbose", 'V', POPT_ARG_INT, &xndrc.verbose, VERBOSE,
"Modify the level or mode of Verbosity in output messages.", "0"},
{ "lbone-host", 'H', POPT_ARG_STRING, &lbonehost, LBONESERVER,
"Specify an L-Bone Server for resource discover and proxmity resolution.", NULL},
{ "lbone-port", 'P', POPT_ARG_INT, &lbone_server.port, LBONEPORT,
"Specify the port number when using an L-Bone Server on a non standard port.",
"6767"},
{ "location", 'l', POPT_ARG_STRING, &xndrc.location, LOCATION_HINT,
"Specify a location hint to pass the L-Bone Query.", "\"state= TN\""},
{ "duration", 'd', POPT_ARG_STRING, &s_duration, DURATION,
"Specify the amount of time to allocate storage. The available modifiers are "
"'m' 'h' 'd' for 'minute' 'hour' and 'days' respectively. Default is seconds. "
"(e.g. -d 1d or -d 1h)", NULL},
{ "soft", 's', POPT_ARG_NONE, 0, STORAGE_TYPE_SOFT,
"Specify SOFT storage for storage allocations.", NULL},
{ "hard", 'h', POPT_ARG_NONE, 0, STORAGE_TYPE_HARD,
"Specify HARD storage for storage allocations.", NULL},
{ "maxdepots", 'm', POPT_ARG_INT, &xndrc.maxdepots, MAX_DEPOTS,
"Specify the maximum number of depots returned by the 'location' hint.", "6"},
{ "bs", 'b', POPT_ARG_STRING|POPT_ARGFLAG_ONEDASH, &s_data_blocksize, DATA_BLOCKSIZE,
"Specify the logical data blocksize of input file.", "'5M'"},
{ "copies", 'c', POPT_ARG_INT, &xndrc.copies, COPIES,
"Specify the number of copies.", "1"},
{ "fragments", 'F', POPT_ARG_INT, &fragments, NUM_FRAGMENTS,
"Rather than specifying the logical data blocksize, specify the number of "
"blocks into which the file should be divided.", "4" },
{ "depot-list", 0, POPT_ARG_NONE, 0, DEPOT_LIST,
"Only use depots specified in .xndrc file", NULL},
{ "threads", 't', POPT_ARG_INT, &xndrc.threads, THREADS,
"Specify the maximum number of threads to use to perform Upload.", NULL},
{ "timeout", 'T', POPT_ARG_STRING, &s_timeout, TIMEOUT,
"Specify the maximum time to allow for all operations.", "'3m'"},
{ "buffersize", 'M', POPT_ARG_STRING, &s_max_buffersize, MAX_BUFFSIZE,
"Specify the maximum internal buffer to use on operations.", NULL},
{ "offset", 'O', POPT_ARG_STRING, &s_offset, FILE_OFFSET,
"Specify an offset relative to the exNode from which download will begin",NULL},
{ "length", 'L', POPT_ARG_STRING, &s_length, FILE_LENGTH,
"Specify a length other than the logical extent of the exNode.", NULL},
{ "none", 'n', POPT_ARG_NONE, 0, LORS_NO_E2E,
"Turn off all e2e services.", NULL},
{ "des", 'e', POPT_ARG_NONE|POPT_ARGFLAG_OR, &encryption, DES_ENCRYPTION,
"Turn on des encryption.", NULL},
{ "aes", 'a', POPT_ARG_NONE|POPT_ARGFLAG_OR, &encryption, AES_ENCRYPTION,
"Turn on aes encryption.", NULL},
{ "compress", 'z', POPT_ARG_NONE|POPT_ARGFLAG_OR, &encryption, ZLIB_COMPRESS,
"Turn on zlib compression.", NULL},
{ "xor", 'x', POPT_ARG_NONE|POPT_ARGFLAG_OR, &encryption, XOR_ENCRYPTION,
"Turn on xor encryption.", NULL},
{ "checksum", 'k', POPT_ARG_NONE|POPT_ARGFLAG_OR, &encryption, ADD_CHECKSUM,
"Turn on checksum.", NULL},
{ "e2e-blocksize", 'E', POPT_ARG_STRING, &s_e2e_blocksize, E2E_BLOCKSIZE,
"When specifying e2e conditioning, select an e2e bocksize "
"which will evenly fit into your chosen Mapping Blocksize.", NULL},
{ "xndrc", 'x', POPT_ARG_STRING, &rcfile, RCFILE,
"You may specify an alternate source for the upload DepotList.", "<filename>"},
{ "demo", 'D', POPT_ARG_NONE, 0, LORS_ARG_DEMO,
"Add the messages understood by the LoRS View visualization.", NULL},
{ "visualize-progress", 'X', POPT_ARG_STRING, &report_host, VISUALIZE_PROGRESS,
"Http link to visualizer with port e.g. http://dlt.incntre.iu.edu:8000 .", NULL},
POPT_AUTOHELP
{ NULL, 0, 0, NULL, 0 }
};
memset(&drc, 0, sizeof(XndRc));
memset(&xndrc, 0, sizeof(XndRc));
parse_xndrc_files(&xndrc);
lbs = &lbone_server;
g_lors_demo = xndrc.demo;
optCon = poptGetContext(NULL, argc, (const char **)argv, optionsTable, 0);
poptSetOtherOptionHelp(optCon, "<filename>");
#ifndef _MINGW
signal(SIGPIPE, sigpipe_handle);
#endif
/*signal(SIGINT, sigint_handle);*/
if ( argc < 2 )
{
poptPrintUsage(optCon, stderr, 0);
poptPrintHelp(optCon, stderr, 0);
exit(EXIT_FAILURE);
}
while ( (v=poptGetNextOpt(optCon)) >= 0)
{
switch(v)
{
case DATA_BLOCKSIZE:
if ( strtobytes(s_data_blocksize, &xndrc.data_blocksize) != 0 )
{
fprintf(stderr, "The blocksize specified is too large for internal datatype.\n");
exit(EXIT_FAILURE);
}
if ( fragments != 0 )
{
fprintf(stderr, "Specify either Fragments or Blocksize, not both.\n");
exit(EXIT_FAILURE);
}
break;
case NUM_FRAGMENTS:
if ( s_data_blocksize != NULL )
{
fprintf(stderr, "Specify either Fragments or Blocksize, not both.\n");
exit(EXIT_FAILURE);
}
break;
case MAX_BUFFSIZE:
if ( strtobytes(s_max_buffersize, &xndrc.max_buffersize) != 0 )
{
fprintf(stderr, "The blocksize specified is too large for "
"internal datatype.\n");
exit(EXIT_FAILURE);
}
break;
case AES_ENCRYPTION:
fprintf(stderr, "AES: encryption\n");
xndrc.e2e_order[e2e_cnt] = AES_ENCRYPTION;
e2e_cnt++;
break;
case DES_ENCRYPTION:
xndrc.e2e_order[e2e_cnt] = DES_ENCRYPTION;
e2e_cnt++;
break;
case XOR_ENCRYPTION:
xndrc.e2e_order[e2e_cnt] = XOR_ENCRYPTION;
e2e_cnt++;
break;
case ADD_CHECKSUM:
xndrc.e2e_order[e2e_cnt] = ADD_CHECKSUM;
e2e_cnt++;
break;
case ZLIB_COMPRESS:
xndrc.e2e_order[e2e_cnt] = ZLIB_COMPRESS;
e2e_cnt++;
break;
case LORS_NO_E2E:
none = 1;
break;
case FILE_OFFSET:
if ( strtobytes(s_offset, &offset) != 0 )
{
fprintf(stderr, "The offset specified is too large for "
"internal datatype.\n");
exit(EXIT_FAILURE);
}
break;
case FILE_LENGTH:
if ( strtobytes(s_length, &length) != 0 )
{
fprintf(stderr, "The length specified is too large for "
"internal datatype.\n");
exit(EXIT_FAILURE);
}
break;
case E2E_BLOCKSIZE:
if ( strtobytes(s_e2e_blocksize, &xndrc.e2e_blocksize) != 0 )
{
fprintf(stderr, "The e2e blocksize specified is too large for "
"internal datatype.\n");
exit(EXIT_FAILURE);
}
break;
case DEPOT_LIST:
depot_list = 1;
break;
case TIMEOUT:
if ( strtotimeout(s_timeout, &xndrc.timeout) != 0 )
{
fprintf(stderr, "Value too large for type.\n");
exit(EXIT_FAILURE);
}
break;
case LBONESERVER:
strncpy(lbone_server.host, lbonehost, 255);
break;
case STORAGE_TYPE_HARD:
if ( type_set > 0 )
{
fprintf(stderr, "Set one of either Hard or Soft storage.\n");
exit(EXIT_FAILURE);
}
xndrc.storage_type = IBP_HARD;
type_set++;
break;
case STORAGE_TYPE_SOFT:
if ( type_set > 0 )
{
fprintf(stderr, "Set one of either Hard or Soft storage.\n");
exit(EXIT_FAILURE);
}
xndrc.storage_type = IBP_SOFT;
type_set++;
break;
case DURATION:
if ( strtotimeout(s_duration, &xndrc.duration) != 0 )
{
fprintf(stderr, "Value too large for type.\n");
exit(EXIT_FAILURE);
}
break;
case LORS_VERSION:
{
const char *package;
double version;
lorsGetLibraryVersion(&package, &version);
fprintf(stderr, "Version: %s %f\n", package, version);
exit(EXIT_FAILURE);
break;
}
case LORS_ARG_DEMO:
g_lors_demo = (!g_lors_demo);
break;
case READ_STDIN:
filename = "-";
break;
case SAME_OUTPUTNAME:
same_name = 1;
break;
#if 0
default:
fprintf(stderr, "Unsupported option: %d\n", v);
#endif
}
}
if ( rcfile != NULL )
{
if ( read_xndrc_file(&drc, rcfile) != 0 )
{
fprintf(stderr, "Unable to open specified rcfile\n");
exit(EXIT_FAILURE);
}
xndrc.depotList = drc.depotList;
}
g_db_level = xndrc.verbose;
if ( v < -1 )
{
fprintf(stderr, "error: %d\n", v);
fprintf(stderr, "%s: %s\n",
poptBadOption(optCon, POPT_BADOPTION_NOALIAS),
poptStrerror(v));
}
/*g_db_level = D_LORS_TERSE | D_LORS_VERBOSE | D_LORS_ERR_MSG ;*/
if ( depot_list == 1 ){
dp_list = xndrc.depotList;
}else {
dp_list = NULL;
};
/* setup default e2e conditioning for upload */
if ( none > 0 )
{
xndrc.e2e_order[0] = -1;
e2e_cnt = 0;
} else if ( e2e_cnt == 0 )
{
for(; xndrc.e2e_order[e2e_cnt] != -1; e2e_cnt++);
}
/*check the upload directory */
if(output_filename != NULL && strstr(output_filename, "http://") != NULL )
{
if(upload_dir_path == NULL){
fprintf(stderr, "Missing UNIS upload directory absolute path \n");
exit(EXIT_FAILURE);
}else{
memset (&config, 0, sizeof(unis_config));
config.endpoint = output_filename;
config.persistent = 1;
ret = unis_create_directory(&config, upload_dir_path, &upload_dir_id);
if(ret == 0){
fprintf(stderr, "Failed to get the upload directory id from UNIS \n");
exit(EXIT_FAILURE);
}
}
}
/*Generate session UUID*/
if(report_host != NULL)
{
uuid_generate(out);
for(i = 0; i < 16; i++)
sprintf(session_id + (i*2),"%02x", out[i]);
handle.server_add = report_host;
handle.session_id = session_id;
if(socket_io_init(&handle) != SOCK_SUCCESS)
{
fprintf(stderr, "Socket IO Init failed \n");
}
}
if ( filename != NULL )
{
goto in_while;
}
while ( (filename = poptGetArg(optCon)) != NULL )
{
in_while:
file_cnt++;
if ( same_name == 1 )
{
int len;
char *s;
s = strrchr (filename, '/');
if ( s == NULL ) s = filename;
else s++;
len = strlen(s) + strlen(".xnd") + 1;
output_filename = malloc(sizeof(char)*len);
snprintf(output_filename, len, "%s.xnd", s);
}
lorsDebugPrint(D_LORS_VERBOSE, "%s %ld %ld %ld %d %s %d %s %d %d %d %ld %d %d\n",
filename, offset, length, xndrc.data_blocksize, xndrc.copies,
lbone_server.host, lbone_server.port, xndrc.location,
xndrc.maxdepots, xndrc.storage_type, xndrc.duration,
xndrc.max_buffersize, xndrc.threads, xndrc.timeout);
if ( e2e_cnt > 0 )
{
xndrc.e2e_order[e2e_cnt] = -1;
e2e_order_tmp = xndrc.e2e_order;
}
/* start from first lbone server in xndrc file */
if ( lbonehost == NULL )
{
lbs = xndrc.lboneList[try1];
try1 = 1;
} else {
lbs = &lbone_server;
try1 = 0;
}
do
{
/*fprintf(stderr, "e2e_blocksize: %ld\n", xndrc.e2e_blocksize);*/
ret = lorsUploadFile(filename, output_filename, offset, (longlong)length,
xndrc.data_blocksize, xndrc.copies, fragments,
xndrc.e2e_blocksize, e2e_order_tmp, lbs, dp_list,
xndrc.location, xndrc.maxdepots, xndrc.storage_type,
xndrc.duration, xndrc.max_buffersize,
xndrc.resolution_file, xndrc.threads,
xndrc.timeout, &handle, upload_dir_id, 0);
if ( ret != LORS_SUCCESS && ret != LORS_PARTIAL )
{
if ( ret == LORS_LBONE_FAILED && xndrc.lboneList[try1] != NULL )
{
fprintf(stderr, "%s: %d\n", xndrc.lboneList[try1]->host,
xndrc.lboneList[try1]->port);
fprintf(stderr, "L-Bone failure: trying next server\n");
lbs = xndrc.lboneList[try1];
try1++;
} else
{
fprintf(stderr, "LORS_ERROR: %d\n", ret);
exit(EXIT_FAILURE);
}
}
} while ( ret != LORS_SUCCESS && ret != LORS_PARTIAL );
free(output_filename);
}
if(report_host != NULL){
if(handle.status == CONN_CONNECTED){
socket_io_send_clear(&handle);
}
if(handle.status != CONN_WAITING){
socket_io_close(&handle);
}
}
if ( file_cnt == 0 )
{
fprintf(stderr, "Error. You must also provide a filename on "
"which lors_upload operates.\n");
poptPrintHelp(optCon, stderr, 0);
exit(EXIT_FAILURE);
}
free_xndrc(&xndrc);
poptFreeContext(optCon);
if ( ret == LORS_PARTIAL ) return 1;
return 0;
}