/************************************************************************* * 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); }