/*************************************************************************
* destroy
* -------
* This is called when a session ends, ie client quits or disconnects.
* The dsi should clean up all memory they associated wit the session
* here.
************************************************************************/
static
void
globus_l_dsi_rest_destroy(
void * user_arg)
{
globus_l_dsi_rest_handle_t *dsi_rest_handle = user_arg;
if (dsi_rest_handle)
{
globus_mutex_lock(&dsi_rest_handle->mutex);
dsi_rest_handle->terminate = true;
while (!dsi_rest_handle->terminate_complete)
{
globus_cond_wait(&dsi_rest_handle->cond, &dsi_rest_handle->mutex);
}
globus_mutex_unlock(&dsi_rest_handle->mutex);
free(dsi_rest_handle->contact_string);
globus_xio_server_close(dsi_rest_handle->xio_server);
globus_xio_stack_destroy(dsi_rest_handle->server_stack);
globus_xio_driver_unload(dsi_rest_handle->http_driver);
globus_xio_driver_unload(dsi_rest_handle->tcp_driver);
free(dsi_rest_handle);
}
}
static
int
globus_l_gram_deactivate(void)
{
(void) globus_xio_stack_destroy(
globus_i_gram_job_manager_file_stack);
(void) globus_xio_stack_destroy(
globus_i_gram_job_manager_popen_stack);
globus_xio_driver_unload(globus_i_gram_job_manager_file_driver);
globus_xio_driver_unload(globus_i_gram_job_manager_popen_driver);
return globus_module_deactivate_all();
}
/**
* Activate all globus modules used by the job manager
*
* Attempts to activate all of the modules used by the job manager. In the
* case of an error, a diagnostic message is printed to stderr.
*
* @retval GLOBUS_SUCCESS
* Success
* @retval all other
* A module failed to activate
*/
static
int
globus_l_gram_job_manager_activate(void)
{
int rc;
globus_result_t result;
globus_module_descriptor_t * modules[] =
{
GLOBUS_COMMON_MODULE,
GLOBUS_CALLOUT_MODULE,
GLOBUS_GSI_SYSCONFIG_MODULE,
GLOBUS_GSI_GSSAPI_MODULE,
GLOBUS_GSI_GSS_ASSIST_MODULE,
GLOBUS_GRAM_JOBMANAGER_CALLOUT_ERROR_MODULE,
GLOBUS_XIO_MODULE,
GLOBUS_GRAM_PROTOCOL_MODULE,
GLOBUS_GASS_CACHE_MODULE,
NULL
};
globus_module_descriptor_t * failed_module = NULL;
rc = globus_module_activate_array(modules, &failed_module);
if (rc != GLOBUS_SUCCESS)
{
fprintf(stderr, "Error (%d) activating %s\n",
rc, failed_module->module_name);
goto activate_failed;
}
result = globus_l_gram_create_stack(
"file",
&globus_i_gram_job_manager_file_stack,
&globus_i_gram_job_manager_file_driver);
if (result != GLOBUS_SUCCESS)
{
rc = GLOBUS_FAILURE;
goto stack_init_failed;
}
result = globus_l_gram_create_stack(
"popen",
&globus_i_gram_job_manager_popen_stack,
&globus_i_gram_job_manager_popen_driver);
if (result != GLOBUS_SUCCESS)
{
goto destroy_file_stack;
}
if (rc != GLOBUS_SUCCESS)
{
destroy_file_stack:
globus_xio_stack_destroy(globus_i_gram_job_manager_file_stack);
globus_xio_driver_unload(globus_i_gram_job_manager_file_driver);
stack_init_failed:
activate_failed:
;
}
return rc;
}
void
globus_xio_driver_list_destroy(
globus_list_t * driver_list,
globus_bool_t unload)
{
globus_xio_driver_list_ent_t * ent;
globus_list_t * list;
for(list = driver_list;
!globus_list_empty(list);
list = globus_list_rest(list))
{
ent = (globus_xio_driver_list_ent_t *) globus_list_first(list);
if(ent->driver_name != NULL)
{
globus_free(ent->driver_name);
}
if(ent->opts != NULL)
{
globus_free(ent->opts);
}
if(unload)
{
globus_xio_driver_unload(ent->driver);
}
globus_free(ent);
}
}
static
int
gfork_l_activate()
{
int rc;
globus_result_t res;
rc = globus_module_activate(GLOBUS_XIO_MODULE);
if(rc != 0)
{
goto error_activate;
}
if(!gfork_l_globals_set)
{
GlobusDebugInit(GLOBUS_GFORK,
ERROR WARNING TRACE INTERNAL_TRACE INFO STATE INFO_VERBOSE);
gfork_i_state_init();
res = globus_xio_stack_init(&gfork_i_file_stack, NULL);
if(res != GLOBUS_SUCCESS)
{
goto error_file_stack;
}
res = globus_xio_driver_load("file", &gfork_i_file_driver);
if(res != GLOBUS_SUCCESS)
{
goto error_file_driver;
}
res = globus_xio_stack_push_driver(
gfork_i_file_stack, gfork_i_file_driver);
if(res != GLOBUS_SUCCESS)
{
goto error_file_push;
}
globus_xio_attr_init(&gfork_i_file_attr);
}
gfork_l_globals_set = GLOBUS_TRUE;
return 0;
error_file_push:
globus_xio_driver_unload(gfork_i_file_driver);
error_file_driver:
globus_xio_stack_destroy(gfork_i_file_stack);
error_file_stack:
globus_module_deactivate(GLOBUS_XIO_MODULE);
error_activate:
return 1;
}
static
globus_result_t
globus_l_gram_create_stack(
const char * driver_name,
globus_xio_stack_t * stack,
globus_xio_driver_t * driver)
{
globus_result_t result;
result = globus_xio_driver_load(
driver_name,
driver);
if (result != GLOBUS_SUCCESS)
{
goto driver_load_failed;
}
result = globus_xio_stack_init(stack, NULL);
if (result != GLOBUS_SUCCESS)
{
goto stack_init_failed;
}
result = globus_xio_stack_push_driver(
*stack,
*driver);
if (result != GLOBUS_SUCCESS)
{
goto driver_push_failed;
}
if (result != GLOBUS_SUCCESS)
{
driver_push_failed:
globus_xio_stack_destroy(*stack);
*stack = NULL;
stack_init_failed:
globus_xio_driver_unload(*driver);
*driver = NULL;
driver_load_failed:
;
}
return result;
}
int
main(
int argc,
char * argv[])
{
int rc;
globus_bool_t server = GLOBUS_FALSE;
char gets_buffer[1024];
http_test_info_t * info;
performance_t perf;
info = (http_test_info_t *) globus_malloc(sizeof(http_test_info_t));
info->version = GLOBUS_XIO_HTTP_VERSION_UNSET;
info->transfer_encoding = NULL;
info->iterations = 100;
info->temp_iterations = 100;
info->size = 0;
info->contact = NULL;
while ((rc = getopt(argc, argv, "h:cst:b:v:i:")) != EOF)
{
switch (rc)
{
case 'h':
usage(argv[0]);
exit(0);
case 'c':
server = GLOBUS_FALSE;
info->contact = fgets(gets_buffer, sizeof(gets_buffer), stdin);
break;
case 's':
server = GLOBUS_TRUE;
info->contact = NULL;
break;
case 't':
if ((strcmp(optarg, CHUNKED) == 0)
|| (strcmp(optarg, IDENTITY) == 0))
{
info->transfer_encoding = optarg;
}
else
{
usage(argv[0]);
exit(1);
}
break;
case 'b':
sscanf(optarg, "%zd", &info->size);
if (rc != 1)
{
usage(argv[0]);
exit(1);
}
break;
case 'v':
if (strcmp(optarg, HTTP_1_0) == 0)
{
info->version = GLOBUS_XIO_HTTP_VERSION_1_0;
}
else if (strcmp(optarg, HTTP_1_1) == 0)
{
info->version = GLOBUS_XIO_HTTP_VERSION_1_1;
}
else
{
usage(argv[0]);
exit(1);
}
break;
case 'i':
info->iterations = atoi(optarg);
if (info->iterations <= 0)
{
usage(argv[0]);
exit(1);
}
info->temp_iterations = info->iterations;
break;
default:
usage(argv[0]);
exit(1);
}
}
if ((!server) && (info->contact == NULL))
{
usage(argv[0]);
exit(1);
}
if (info->iterations > 1 && info->version == GLOBUS_XIO_HTTP_VERSION_1_0)
{
fprintf(stderr,
"Can't have multiple iterations with HTTP/1.0 server\n");
usage(argv[0]);
exit(1);
}
rc = http_test_initialize(
&info->tcp_driver, &info->http_driver, &info->stack);
if (rc != 0)
{
goto error_exit;
}
if (server)
{
performance_init(
&perf,
server_test,
throughput_next_size,
info->iterations,
"throughput-globus-xio-http",
info->size);
performance_start_slave(&perf, info);
}
else
{
performance_init(
&perf,
client_test,
throughput_next_size,
info->iterations,
"throughput-globus-xio-http",
info->size);
rc = performance_start_master(&perf, info);
if (rc != 0)
{
goto error_exit;
}
performance_write_timers(&perf);
}
globus_xio_stack_destroy(info->stack);
globus_xio_driver_unload(info->tcp_driver);
globus_xio_driver_unload(info->http_driver);
globus_module_deactivate_all();
error_exit:
if (rc == 0)
{
printf("Success\n");
}
else
{
printf("Error\n");
}
return rc;
}
int
main(
int argc,
char ** argv)
{
globus_xio_stack_t stack;
globus_xio_stack_t mode_e_stack;
globus_xio_handle_t xio_handle;
globus_xio_server_t server;
globus_xio_attr_t attr = NULL;
char * cs = NULL;
globus_result_t res;
int ctr;
int num_streams = 1;
globus_bool_t be_server = GLOBUS_FALSE;
int rc;
char filename[FILE_NAME_LEN];
FILE * fp;
rc = globus_module_activate(GLOBUS_XIO_MODULE);
globus_assert(rc == GLOBUS_SUCCESS);
res = globus_xio_driver_load("mode_e", &mode_e_driver);
test_res(res);
res = globus_xio_driver_load("ordering", &ordering_driver);
test_res(res);
res = globus_xio_stack_init(&stack, NULL);
test_res(res);
res = globus_xio_stack_push_driver(stack, mode_e_driver);
test_res(res);
res = globus_xio_stack_push_driver(stack, ordering_driver);
test_res(res);
res = globus_xio_driver_load("tcp", &tcp_driver);
test_res(res);
res = globus_xio_stack_init(&mode_e_stack, NULL);
test_res(res);
res = globus_xio_stack_push_driver(mode_e_stack, tcp_driver);
test_res(res);
if (argc < 4)
{
help();
exit(1);
}
test_res(globus_xio_attr_init(&attr));
test_res(globus_xio_attr_cntl(
attr,
mode_e_driver,
GLOBUS_XIO_MODE_E_SET_STACK,
mode_e_stack));
for(ctr = 1; ctr < argc; ctr++)
{
if(strcmp(argv[ctr], "-h") == 0)
{
help();
return 0;
}
else if(strcmp(argv[ctr], "-c") == 0)
{
if (argc < 5)
{
help();
exit(1);
}
cs = argv[ctr + 1];
ctr++;
}
else if(strcmp(argv[ctr], "-s") == 0)
{
be_server = GLOBUS_TRUE;
}
else if(strcmp(argv[ctr], "-p") == 0)
{
if (argc < 6)
{
help();
exit(1);
}
port = atoi(argv[ctr+1]);
/* test_res(globus_xio_attr_cntl(
attr,
mode_e_driver,
GLOBUS_XIO_MODE_E_APPLY_ATTR_CNTLS,
attr_cntl_cb));*/
}
else if(strcmp(argv[ctr], "-P") == 0)
{
if (argc < 6)
{
help();
exit(1);
}
num_streams = atoi(argv[ctr+1]);
test_res(globus_xio_attr_init(&attr));
test_res(globus_xio_attr_cntl(
attr,
ordering_driver,
GLOBUS_XIO_ORDERING_SET_MAX_READ_COUNT,
num_streams));
test_res(globus_xio_attr_cntl(
attr,
mode_e_driver,
GLOBUS_XIO_MODE_E_SET_NUM_STREAMS,
num_streams));
}
else if(strcmp(argv[ctr], "-f") == 0)
{
if (ctr + 1 < argc)
{
strcpy(filename, argv[ctr + 1]);
}
else
{
help();
exit(1);
}
}
}
if (!be_server && (!cs || !*cs))
{
help();
exit(1);
}
if(be_server)
{
globus_size_t size = CHUNK_SIZE + 1;
int i, nbytes;
res = globus_xio_server_create(&server, attr, stack);
test_res(res);
globus_xio_server_get_contact_string(server, &cs);
fprintf(stdout, "Contact: %s\n", cs);
res = globus_xio_server_accept(&xio_handle, server);
test_res(res);
res = globus_xio_open(xio_handle, NULL, attr);
test_res(res);
fp = fopen(filename, "w");
while(1)
{
char * buffer;
buffer = (char *) globus_malloc(size);
for (i=0; i<size; i++)
buffer[i] = '\0';
res = globus_xio_read(
xio_handle,
buffer,
size - 1,
1,
&nbytes,
NULL);
fputs(buffer, fp);
if (res != GLOBUS_SUCCESS)
break;
}
res = globus_xio_close(xio_handle, NULL);
test_res(res);
res = globus_xio_server_close(server);
test_res(res);
res = globus_xio_driver_unload(mode_e_driver);
test_res(res);
rc = globus_module_deactivate(GLOBUS_XIO_MODULE);
globus_assert(rc == GLOBUS_SUCCESS);
}
else
{
globus_size_t size = CHUNK_SIZE + 1;
int nbytes;
int i,x;
res = globus_xio_handle_create(&xio_handle, stack);
test_res(res);
res = globus_xio_stack_destroy(stack);
test_res(res);
res = globus_xio_open(xio_handle, cs, attr);
test_res(res);
globus_mutex_init(&mutex, NULL);
globus_cond_init(&cond, NULL);
fp = fopen(filename, "r");
globus_mutex_lock(&mutex);
while(!feof(fp))
{
char * buffer;
buffer = (char *) globus_malloc(size);
for (i = 0; i < size; i++)
buffer[i] = '\0';
x = fread(buffer, CHUNK_SIZE, 1, fp);
nbytes = strlen(buffer);
res = globus_xio_register_write(
xio_handle,
buffer,
nbytes,
nbytes,
NULL,
write_cb,
NULL);
test_res(res);
++y;
}
fclose(fp);
/* test_res(globus_xio_data_descriptor_init(&dd, xio_handle));
test_res(globus_xio_data_descriptor_cntl(
dd,
mode_e_driver,
GLOBUS_XIO_MODE_E_SEND_EOD,
GLOBUS_TRUE));
res = globus_xio_write(
xio_handle,
buffer,
nbytes,
nbytes,
&nbytes,
NULL);
test_res(res); */
while(y)
{
globus_cond_wait(&mutex, &cond);
}
globus_mutex_unlock(&mutex);
res = globus_xio_close(xio_handle, attr);
test_res(res);
res = globus_xio_driver_unload(mode_e_driver);
test_res(res);
res = globus_xio_driver_unload(ordering_driver);
test_res(res);
rc = globus_module_deactivate(GLOBUS_XIO_MODULE);
globus_assert(rc == GLOBUS_SUCCESS);
globus_mutex_destroy(&mutex);
globus_cond_destroy(&cond);
}
return 0;
}
/* driver list stuff */
globus_result_t
globus_xio_driver_list_from_string(
char * driver_string,
globus_list_t ** driver_list,
globus_hashtable_t * safe_table)
{
globus_result_t result;
globus_bool_t done = GLOBUS_FALSE;
globus_bool_t loaded;
char * opts;
char * ptr;
char * driver_str;
char * driver_name;
char * tmp_str;
globus_xio_driver_t driver;
globus_list_t * list = NULL;
globus_xio_driver_list_ent_t * list_ent;
GlobusXIOName(globus_xio_driver_list_from_string);
*driver_list = NULL;
if(driver_string == NULL)
{
result = GlobusXIOErrorParameter("driver_string");
goto error_param;
}
driver_str = globus_libc_strdup(driver_string);
tmp_str = driver_str;
while(!done)
{
loaded = GLOBUS_FALSE;
driver_name = tmp_str;
ptr = strchr(driver_name, ',');
if(ptr != NULL)
{
*ptr = '\0';
tmp_str = ptr+1;
}
else
{
done = GLOBUS_TRUE;
}
opts = strchr(driver_name, ':');
if(opts != NULL)
{
*opts = '\0';
opts++;
/* decode the string */
globus_url_string_hex_decode(opts);
}
/* check against the safe list */
if(safe_table != NULL)
{
char * err_str;
list_ent = (globus_xio_driver_list_ent_t *)
globus_hashtable_lookup(safe_table, driver_name);
if(list_ent == NULL)
{
err_str = globus_common_create_string(
"%s driver not whitelisted", driver_name);
result = GlobusXIOErrorParameter(err_str);
globus_free(err_str);
goto error_load;
}
driver = list_ent->driver;
}
else
{
result = globus_xio_driver_load(driver_name, &driver);
if(result != GLOBUS_SUCCESS)
{
goto error_load;
}
loaded = GLOBUS_TRUE;
}
list_ent = (globus_xio_driver_list_ent_t *)
globus_calloc(1, sizeof(globus_xio_driver_list_ent_t));
list_ent->opts = globus_libc_strdup(opts);
list_ent->driver = driver;
list_ent->driver_name = globus_libc_strdup(driver_name);
list_ent->loaded = loaded;
globus_list_insert(&list, list_ent);
}
globus_free(driver_str);
/* reverse list */
while(!globus_list_empty(list))
{
globus_list_insert(driver_list, globus_list_first(list));
globus_list_remove(&list, list);
}
return GLOBUS_SUCCESS;
error_load:
globus_free(driver_str);
while(!globus_list_empty(list))
{
list_ent = (globus_xio_driver_list_ent_t *)
globus_list_remove(&list, list);
if(list_ent->loaded)
{
globus_xio_driver_unload(list_ent->driver);
}
globus_free(list_ent->driver_name);
if(list_ent->opts != NULL)
{
globus_free(list_ent->opts);
}
globus_free(list_ent);
}
error_param:
return result;
}
static
int
globus_l_seg_stdout_activate(void)
{
globus_result_t result;
globus_xio_attr_t out_attr;
globus_xio_attr_t in_attr;
int rc;
globus_l_seg_output_handle = NULL;
globus_l_seg_input_handle = NULL;
globus_l_seg_file_stack = NULL;
globus_l_seg_file_driver = NULL;
globus_l_seg_timestamp = 0;
globus_l_seg_write_registered = GLOBUS_FALSE;
globus_l_seg_shutdown = 0;
rc = globus_module_activate(GLOBUS_COMMON_MODULE);
if (rc != GLOBUS_SUCCESS)
{
goto error;
}
rc = globus_module_activate(GLOBUS_SCHEDULER_EVENT_GENERATOR_MODULE);
if (rc != GLOBUS_SUCCESS)
{
goto deactivate_common_error;
}
rc = globus_fifo_init(&globus_l_seg_buffers);
if (rc != GLOBUS_SUCCESS)
{
goto deactivate_seg_error;
}
rc = globus_module_activate(GLOBUS_XIO_MODULE);
if (rc != GLOBUS_SUCCESS)
{
goto destroy_fifo_error;
}
result = globus_xio_driver_load("file", &globus_l_seg_file_driver);
if (result != GLOBUS_SUCCESS)
{
goto deactivate_xio_error;
}
result = globus_xio_stack_init(&globus_l_seg_file_stack, NULL);
if (result != GLOBUS_SUCCESS)
{
goto unload_driver_error;
}
result = globus_xio_stack_push_driver(globus_l_seg_file_stack,
globus_l_seg_file_driver);
if (result != GLOBUS_SUCCESS)
{
goto destroy_stack_error;
}
result = globus_xio_attr_init(&out_attr);
if (result != GLOBUS_SUCCESS)
{
goto destroy_stack_error;
}
result = globus_xio_attr_cntl(
out_attr,
globus_l_seg_file_driver,
GLOBUS_XIO_FILE_SET_FLAGS,
GLOBUS_XIO_FILE_WRONLY);
if (result != GLOBUS_SUCCESS)
{
goto destroy_out_attr_error;
}
result = globus_xio_attr_cntl(
out_attr,
globus_l_seg_file_driver,
GLOBUS_XIO_FILE_SET_HANDLE,
fileno(stdout));
if (result != GLOBUS_SUCCESS)
{
goto destroy_out_attr_error;
}
result = globus_xio_attr_init(&in_attr);
if (result != GLOBUS_SUCCESS)
{
goto destroy_out_attr_error;
}
result = globus_xio_attr_cntl(
in_attr,
globus_l_seg_file_driver,
GLOBUS_XIO_FILE_SET_FLAGS,
GLOBUS_XIO_FILE_RDONLY);
if (result != GLOBUS_SUCCESS)
{
goto destroy_in_attr_error;
}
result = globus_xio_attr_cntl(
in_attr,
globus_l_seg_file_driver,
GLOBUS_XIO_FILE_SET_HANDLE,
fileno(stdin));
if (result != GLOBUS_SUCCESS)
{
goto destroy_in_attr_error;
}
result = globus_xio_handle_create(
&globus_l_seg_output_handle,
globus_l_seg_file_stack);
if (result != GLOBUS_SUCCESS)
{
goto destroy_in_attr_error;
}
result = globus_xio_open(globus_l_seg_output_handle, "", out_attr);
if (result != GLOBUS_SUCCESS)
{
goto close_out_handle_error;
}
result = globus_xio_handle_create(
&globus_l_seg_input_handle,
globus_l_seg_file_stack);
if (result != GLOBUS_SUCCESS)
{
goto close_out_handle_error;
}
result = globus_xio_open(globus_l_seg_input_handle, "", in_attr);
if (result != GLOBUS_SUCCESS)
{
goto close_in_handle_error;
}
rc = globus_mutex_init(&globus_l_seg_mutex, NULL);
if (rc != GLOBUS_SUCCESS)
{
goto close_in_handle_error;
}
rc = globus_cond_init(&globus_l_seg_cond, NULL);
if (rc != GLOBUS_SUCCESS)
{
goto destroy_mutex_error;
}
result = globus_xio_register_read(
globus_l_seg_input_handle,
globus_l_seg_input_buffer,
sizeof(globus_l_seg_input_buffer),
1,
NULL,
globus_l_xio_read_eof_callback,
NULL);
if (result != GLOBUS_SUCCESS)
{
goto destroy_cond_error;
}
globus_xio_attr_destroy(in_attr);
globus_xio_attr_destroy(out_attr);
return 0;
destroy_cond_error:
globus_cond_destroy(&globus_l_seg_cond);
destroy_mutex_error:
globus_mutex_destroy(&globus_l_seg_mutex);
close_in_handle_error:
globus_xio_close(globus_l_seg_input_handle, NULL);
close_out_handle_error:
globus_xio_close(globus_l_seg_output_handle, NULL);
destroy_in_attr_error:
globus_xio_attr_destroy(in_attr);
destroy_out_attr_error:
globus_xio_attr_destroy(out_attr);
destroy_stack_error:
globus_xio_stack_destroy(globus_l_seg_file_stack);
unload_driver_error:
globus_xio_driver_unload(globus_l_seg_file_driver);
deactivate_xio_error:
globus_module_deactivate(GLOBUS_XIO_MODULE);
destroy_fifo_error:
globus_fifo_destroy(&globus_l_seg_buffers);
deactivate_seg_error:
globus_module_deactivate(GLOBUS_SCHEDULER_EVENT_GENERATOR_MODULE);
deactivate_common_error:
globus_module_deactivate(GLOBUS_COMMON_MODULE);
error:
return 1;
}
int
main(
int argc,
char * argv[])
{
int rc;
char * filename = NULL;
char * contact = NULL;
globus_bool_t server = GLOBUS_FALSE;
char gets_buffer[1024];
while ((rc = getopt(argc, argv, "hf:cst:b:v:i:")) != EOF)
{
switch (rc)
{
case 'h':
usage(argv[0]);
exit(0);
case 'f':
filename = optarg;
break;
case 'c':
server = GLOBUS_FALSE;
contact = fgets(gets_buffer, sizeof(gets_buffer), stdin);
break;
case 's':
server = GLOBUS_TRUE;
contact = NULL;
break;
case 't':
if ((strcmp(optarg, CHUNKED) == 0)
|| (strcmp(optarg, IDENTITY) == 0))
{
transfer_encoding = optarg;
}
else
{
usage(argv[0]);
exit(1);
}
break;
case 'b':
buffer_size = atoi(optarg);
if (buffer_size < 0)
{
usage(argv[0]);
exit(1);
}
break;
case 'v':
if (strcmp(optarg, HTTP_1_0) == 0)
{
version = GLOBUS_XIO_HTTP_VERSION_1_0;
}
else if (strcmp(optarg, HTTP_1_1) == 0)
{
version = GLOBUS_XIO_HTTP_VERSION_1_1;
}
else
{
usage(argv[0]);
exit(1);
}
break;
case 'i':
iterations = atoi(optarg);
if (iterations <= 0)
{
usage(argv[0]);
exit(1);
}
break;
default:
usage(argv[0]);
exit(1);
}
}
if (((!server) && (contact == NULL)) || (filename == NULL))
{
usage(argv[0]);
exit(1);
}
if (iterations > 1 && version == GLOBUS_XIO_HTTP_VERSION_1_0)
{
fprintf(stderr,
"Can't have multiple iterations with HTTP/1.0 server\n");
usage(argv[0]);
exit(1);
}
rc = http_test_initialize(&tcp_driver, &http_driver, &stack);
if (rc != 0)
{
goto error_exit;
}
if (server)
{
rc = server_main(
filename);
}
else
{
rc = client_main(
filename,
contact,
version);
}
globus_xio_stack_destroy(stack);
globus_xio_driver_unload(http_driver);
globus_xio_driver_unload(tcp_driver);
globus_module_deactivate_all();
error_exit:
return rc;
}
/*************************************************************************
* start
* -----
* This function is called when a new session is initialized, ie a user
* connects to the server. This hook gives the dsi an opportunity to
* set internal state that will be threaded through to all other
* function calls associated with this session. And an opportunity to
* reject the user.
*
* finished_info.info.session.session_arg should be set to an DSI
* defined data structure. This pointer will be passed as the void *
* user_arg parameter to all other interface functions.
*
* NOTE: at nice wrapper function should exist that hides the details
* of the finished_info structure, but it currently does not.
* The DSI developer should jsut follow this template for now
************************************************************************/
static
void
globus_l_dsi_rest_start(
globus_gfs_operation_t op,
globus_gfs_session_info_t * session_info)
{
globus_l_dsi_rest_handle_t *dsi_rest_handle;
globus_result_t result = GLOBUS_SUCCESS;
dsi_rest_handle = malloc(sizeof(globus_l_dsi_rest_handle_t));
if (dsi_rest_handle == NULL)
{
result = GlobusGFSErrorMemory("dsi_rest_handle");
goto handle_malloc_fail;
}
result = globus_xio_driver_load("tcp", &dsi_rest_handle->tcp_driver);
if (result != GLOBUS_SUCCESS)
{
goto tcp_load_fail;
}
result = globus_xio_driver_load("http", &dsi_rest_handle->http_driver);
if (result != GLOBUS_SUCCESS)
{
goto http_load_fail;
}
result = globus_xio_stack_init(&dsi_rest_handle->server_stack, NULL);
if (result != GLOBUS_SUCCESS)
{
goto stack_init_fail;
}
globus_mutex_init(&dsi_rest_handle->mutex, NULL);
globus_cond_init(&dsi_rest_handle->cond, NULL);
dsi_rest_handle->terminate = false;
dsi_rest_handle->terminate_complete = false;
result = globus_xio_stack_push_driver(
dsi_rest_handle->server_stack,
dsi_rest_handle->tcp_driver);
if (result != GLOBUS_SUCCESS)
{
goto stack_push_fail;
}
result = globus_xio_stack_push_driver(
dsi_rest_handle->server_stack,
dsi_rest_handle->http_driver);
if (result != GLOBUS_SUCCESS)
{
goto stack_push_fail;
}
globus_xio_attr_t attr;
result = globus_xio_attr_init(&attr);
globus_reltime_t delay;
GlobusTimeReltimeSet(delay, 1,0);
result = globus_xio_attr_cntl(
attr,
NULL,
GLOBUS_XIO_ATTR_SET_TIMEOUT_ACCEPT,
NULL,
&delay,
NULL);
result = globus_xio_server_create(
&dsi_rest_handle->xio_server,
attr,
dsi_rest_handle->server_stack);
if (result != GLOBUS_SUCCESS)
{
goto server_create_fail;
}
result = globus_xio_server_get_contact_string(
dsi_rest_handle->xio_server,
&dsi_rest_handle->contact_string);
if (result != GLOBUS_SUCCESS)
{
goto get_contact_fail;
}
globus_gridftp_server_get_config_string(
op,
&dsi_rest_handle->root);
if (dsi_rest_handle->root == NULL)
{
result = GlobusGFSErrorMemory("root");
goto get_root_fail;
}
globus_thread_create(
&dsi_rest_handle->server_thread,
NULL,
globus_l_dsi_rest_thread,
dsi_rest_handle);
if (result != GLOBUS_SUCCESS)
{
get_root_fail:
free(dsi_rest_handle->contact_string);
get_contact_fail:
globus_xio_server_close(dsi_rest_handle->xio_server);
server_create_fail:
stack_push_fail:
globus_xio_stack_destroy(dsi_rest_handle->server_stack);
stack_init_fail:
globus_xio_driver_unload(dsi_rest_handle->http_driver);
http_load_fail:
globus_xio_driver_unload(dsi_rest_handle->tcp_driver);
tcp_load_fail:
handle_malloc_fail:
free(dsi_rest_handle);
dsi_rest_handle = NULL;
}
globus_gridftp_server_finished_session_start(
op,
result,
dsi_rest_handle,
NULL,
NULL);
}
