int main( int argc, char ** argv) { globus_xio_driver_t tcp_driver; globus_xio_driver_t ftp_driver; globus_xio_stack_t stack; globus_xio_handle_t xio_handle; char * cs; globus_result_t res; char line[LINE_LEN]; globus_bool_t done = GLOBUS_FALSE; globus_size_t nbytes; globus_xio_server_t server_handle; globus_module_activate(GLOBUS_XIO_MODULE); globus_xio_stack_init(&stack, NULL); res = globus_xio_driver_load("tcp", &tcp_driver); test_res(res, __LINE__); res = globus_xio_stack_push_driver(stack, tcp_driver); test_res(res, __LINE__); res = globus_xio_driver_load("gssapi_ftp", &ftp_driver); test_res(res, __LINE__); res = globus_xio_stack_push_driver(stack, ftp_driver); test_res(res, __LINE__); globus_xio_server_create(&server_handle, NULL, stack); globus_xio_server_get_contact_string(server_handle, &cs); fprintf(stdout, "Contact: %s\n", cs); globus_xio_server_accept(&xio_handle, server_handle); res = globus_xio_open(xio_handle, NULL, NULL); test_res(res, __LINE__); res = globus_xio_write(xio_handle, "220 hello\r\n", strlen("220 hello\r\n"), strlen("220 hello\r\n"), &nbytes, NULL); test_res(res, __LINE__); while(!done) { res = globus_xio_read( xio_handle, line, LINE_LEN, 1, &nbytes, NULL); test_res(res, __LINE__); line[nbytes] = '\0'; fprintf(stdout, "%s", line); } globus_xio_close(xio_handle, NULL); globus_module_activate(GLOBUS_XIO_MODULE); return 0; }
static void open_cb( globus_xio_handle_t handle, globus_result_t result, void * user_arg) { globus_result_t res; globus_byte_t * buffer; globus_size_t buffer_length; globus_size_t nbytes; int ctr; buffer = globus_l_test_info.buffer; buffer_length = globus_l_test_info.buffer_length; globus_mutex_lock(&globus_l_mutex); { for(ctr = 0; ctr < OP_COUNT; ctr++) { res = globus_xio_register_write( handle, buffer, buffer_length, buffer_length, NULL, data_cb, user_arg); test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__); res = globus_xio_register_read( handle, buffer, buffer_length, buffer_length, NULL, data_cb, user_arg); test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__); res = globus_xio_write( handle, buffer, buffer_length, buffer_length, &nbytes, NULL); res = globus_xio_read( handle, buffer, buffer_length, buffer_length, &nbytes, NULL); } } globus_mutex_unlock(&globus_l_mutex); }
globus_result_t globus_l_usage_stats_write_packet( globus_usage_stats_handle_t handle) { globus_result_t result = GLOBUS_SUCCESS; #ifndef TARGET_ARCH_ARM globus_result_t save_result = GLOBUS_SUCCESS; globus_list_t * targets_list; globus_list_t * server_list; globus_abstime_t stamp; uint32_t nstamp; globus_size_t written; GlobusTimeAbstimeGetCurrent(stamp); nstamp = htonl(stamp.tv_sec); memcpy(handle->data + GLOBUS_L_USAGE_STATS_TIMESTAMP_OFFSET, (void *)&nstamp, 4); targets_list = handle->xio_desc_list; server_list = handle->targets; while(targets_list) { GlobusUsageStatsDebugPrintf( GLOBUS_L_USAGE_STATS_DEBUG_MESSAGES, ("\n==========SENDING USAGE INFO: %s==(length: %d)===\n", (char *)globus_list_first(server_list), handle->data_length)); GlobusUsageStatsDebugDump( GLOBUS_L_USAGE_STATS_DEBUG_MESSAGES, handle->data, handle->data_length); GlobusUsageStatsDebugPrintf( GLOBUS_L_USAGE_STATS_DEBUG_MESSAGES, ("\n=========================================================\n")); result = globus_xio_write( handle->xio_handle, handle->data, handle->data_length, 0, &written, *(globus_xio_data_descriptor_t *) globus_list_first(targets_list)); if(result != GLOBUS_SUCCESS) { save_result = result; } targets_list = globus_list_rest(targets_list); server_list = globus_list_rest(server_list); } result = save_result; #endif return result; }
static globus_result_t globus_l_xio_test_write_buffer( globus_xio_handle_t handle, globus_byte_t * message, globus_size_t message_size, globus_size_t buffer_size) { globus_byte_t * ptr = message; globus_size_t left = message_size; globus_size_t to_write; globus_size_t nbytes; globus_result_t result = GLOBUS_SUCCESS; GlobusXIOName(globus_l_xio_test_write_buffer); if (buffer_size == 0) { buffer_size = 1024; } while ((left > 0) && (result == GLOBUS_SUCCESS)) { to_write = (left > buffer_size) ? buffer_size : left; result = globus_xio_write( handle, ptr, to_write, to_write, &nbytes, NULL); if (result == GLOBUS_SUCCESS) { if (nbytes != to_write) { fprintf(stderr, "Didn't write all I expected.\n"); result = GlobusXIOErrorEOF(); } left -= nbytes; ptr += nbytes; } else { fprintf(stderr, "Error writing data: %s\n", globus_object_printable_to_string(globus_error_peek(result))); } } globus_xio_handle_cntl( handle, http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_END_OF_ENTITY); return result; }
static globus_result_t globus_l_xio_test_write_buffer( globus_xio_handle_t handle, globus_byte_t * msg, globus_size_t msg_size, globus_xio_driver_t http_driver) { globus_size_t nbytes; globus_result_t result; GlobusXIOName(globus_l_xio_test_write_buffer); result = globus_xio_write( handle, msg, msg_size, msg_size, &nbytes, NULL); if (result == GLOBUS_SUCCESS) { if (nbytes != msg_size) { fprintf(stderr, "Didn't write all I expected.\n"); result = GlobusXIOErrorEOF(); } } else { fprintf(stderr, "Error writing data: %s\n", globus_object_printable_to_string(globus_error_peek(result))); } globus_xio_handle_cntl( handle, http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_END_OF_ENTITY); return result; }
int main( int argc, char ** argv) { globus_xio_driver_t tcp_driver; globus_xio_driver_t ftp_driver; globus_xio_stack_t stack; globus_xio_handle_t xio_handle; char * cs; char * subject; globus_result_t res; char line[LINE_LEN]; globus_bool_t done = GLOBUS_FALSE; globus_size_t nbytes; globus_xio_attr_t attr; int len; if(argc < 2) { fprintf(stderr, "arg error: <contact string> <subject>\n"); return 1; } globus_module_activate(GLOBUS_XIO_MODULE); globus_xio_stack_init(&stack, NULL); res = globus_xio_driver_load("tcp", &tcp_driver); test_res(res, __LINE__); res = globus_xio_stack_push_driver(stack, tcp_driver); test_res(res, __LINE__); res = globus_xio_driver_load("gssapi_ftp", &ftp_driver); test_res(res, __LINE__); res = globus_xio_stack_push_driver(stack, ftp_driver); test_res(res, __LINE__); cs = argv[argc - 1]; subject = argv[argc - 2]; res = globus_xio_handle_create(&xio_handle, stack); test_res(res, __LINE__); res = globus_xio_attr_init(&attr); test_res(res, __LINE__); res = globus_xio_attr_cntl(attr, ftp_driver, GLOBUS_XIO_GSSAPI_ATTR_TYPE_SUBJECT, subject); test_res(res, __LINE__); res = globus_xio_open(xio_handle, cs, attr); test_res(res, __LINE__); while(!done) { if(fgets(line, LINE_LEN, stdin) == NULL) { done = GLOBUS_TRUE; } else { len = strlen(line); line[len] = '\r'; len++; line[len] = '\n'; len++; res = globus_xio_write( xio_handle, line, len, len, &nbytes, NULL); test_res(res, __LINE__); } } globus_xio_close(xio_handle, NULL); globus_module_deactivate(GLOBUS_XIO_MODULE); return 0; }
int client_test( http_test_info_t * info, int timer) { int rc = 0; globus_result_t result; int header_cnt = 0; char content_length_buffer[64]; globus_xio_http_header_t headers[2]; globus_xio_handle_t handle; int i; size_t nbytes; globus_xio_data_descriptor_t descriptor; int status_code; char * reason_phrase; globus_utp_start_timer(timer); if (info->transfer_encoding != NULL) { headers[header_cnt].name = "Transfer-Encoding"; headers[header_cnt].value = info->transfer_encoding; header_cnt++; } if ((info->version == GLOBUS_XIO_HTTP_VERSION_1_0) || ((info->transfer_encoding != NULL) && strcmp(info->transfer_encoding, IDENTITY) == 0)) { sprintf(content_length_buffer, "%lu", (unsigned long) info->size); headers[header_cnt].name = "Content-Length"; headers[header_cnt].value = &content_length_buffer[0]; header_cnt++; } handle = NULL; result = http_test_client_request( &handle, info->tcp_driver, info->http_driver, info->stack, info->contact, "%2fpost-test", "POST", info->version, headers, header_cnt); if (result != GLOBUS_SUCCESS) { fprintf(stderr, "Error making request: %s\n", globus_object_printable_to_string( globus_error_get(result))); rc = 50; goto error_exit; } for (i = 0; i < info->iterations; i++) { result = globus_xio_write( handle, info->buffer, info->size, info->size, &nbytes, NULL); if (result == GLOBUS_SUCCESS) { if (nbytes != info->size) { fprintf(stderr, "Didn't write all I expected.\n"); } } else { fprintf(stderr, "Error writing data: %s\n", globus_object_printable_to_string(globus_error_peek(result))); } } globus_xio_handle_cntl( handle, info->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_END_OF_ENTITY); /* READ RESPONSE */ result = globus_xio_data_descriptor_init(&descriptor, handle); if (result != GLOBUS_SUCCESS) { rc = 51; goto close_exit; } result = globus_xio_read( handle, info->buffer, 0, 0, NULL, descriptor); if (result != GLOBUS_SUCCESS) { rc = 51; goto close_exit; } result = globus_xio_data_descriptor_cntl( descriptor, info->http_driver, GLOBUS_XIO_HTTP_GET_RESPONSE, &status_code, &reason_phrase, NULL, NULL); if (result != GLOBUS_SUCCESS || status_code < 200 || status_code > 299) { fprintf(stderr, "Get failed with \"%03d %s\"\n", status_code, reason_phrase); rc = 51; goto close_exit; } result = globus_xio_read( handle, info->buffer, info->size, 1, &nbytes, NULL); if (result && !http_is_eof(result)) { fprintf(stderr, "Error reading eof from http: %s\n", globus_error_print_friendly(globus_error_get(result))); } close_exit: globus_xio_close(handle, NULL); globus_utp_stop_timer(timer); error_exit: return rc; }
static void globus_l_xio_test_server_request_callback( void * user_arg, globus_result_t result, const char * method, const char * uri, globus_xio_http_version_t http_version, globus_hashtable_t headers) { http_test_server_t * test_server; http_test_info_t * info; globus_xio_http_header_t response_headers[2]; globus_size_t header_cnt=0; char content_length_buffer[64]; int rc=0; int i; size_t nbytes; test_server = (http_test_server_t*) user_arg; info = test_server->info; if (result == GLOBUS_SUCCESS && method != NULL && uri != NULL && (strcmp(method, "POST") == 0) && (strcmp(uri, "/post-test") == 0)) { for (i = 0; i < info->iterations; i++) { result = globus_xio_read( test_server->handle, info->buffer, info->size, info->size, &nbytes, NULL); if (result != GLOBUS_SUCCESS || nbytes != info->size) { fprintf(stderr, "Error reading from http: %s\n", globus_object_printable_to_string( globus_error_peek(result))); } } } else { rc = 404; goto error_respond_exit; } result = globus_xio_read( test_server->handle, info->buffer, info->size, 1, &nbytes, NULL); if (result && !http_is_eof(result)) { fprintf(stderr, "Error reading eof from http: %s\n", globus_error_print_friendly(globus_error_get(result))); } if (info->transfer_encoding != NULL) { response_headers[header_cnt].name = "Transfer-Encoding"; response_headers[header_cnt].value = info->transfer_encoding; header_cnt++; } if ((http_version == GLOBUS_XIO_HTTP_VERSION_1_0) || ((info->transfer_encoding != NULL) && strcmp(info->transfer_encoding, IDENTITY) == 0)) { sprintf(content_length_buffer, "%lu", (unsigned long) info->size); response_headers[header_cnt].name = "Content-Length"; response_headers[header_cnt].value = &content_length_buffer[0]; header_cnt++; } result = http_test_server_respond( test_server, rc, NULL, response_headers, header_cnt); if (result != GLOBUS_SUCCESS) { goto error_exit; } result = globus_xio_write( test_server->handle, info->buffer, 1, 1, &nbytes, NULL); globus_xio_handle_cntl( test_server->handle, info->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_END_OF_ENTITY); info->size = throughput_next_size(info->size); if (info->size == -1) { http_test_server_close_handle(test_server); http_test_server_shutdown(test_server); } return; error_respond_exit: http_test_server_respond( test_server, rc, NULL, NULL, 0); error_exit: http_test_server_close_handle(test_server); http_test_server_shutdown(test_server); }
int main( int argc, char ** argv) { globus_xio_driver_t driver; globus_xio_driver_t transport_driver = NULL; globus_xio_stack_t stack; globus_xio_handle_t xio_handle; char * cs; globus_result_t res; char line[LINE_LEN]; char writeline[LINE_LEN]; int len; int ctr; globus_bool_t done = GLOBUS_FALSE; globus_size_t nbytes; globus_size_t pbytes; globus_xio_server_t server_handle; globus_xio_attr_t attr=NULL; globus_size_t port; /*if(argc < 2) { help(); return 1; }*/ globus_module_activate(GLOBUS_XIO_MODULE); globus_xio_stack_init(&stack, NULL); for(ctr = 1; ctr < argc; ctr++) { if(strcmp(argv[ctr], "-h") == 0) { help(); return 0; } else if(strcmp(argv[ctr], "-p") == 0 && ctr + 1 < argc) { port = atoi(argv[ctr+1]); globus_xio_driver_load("bidi", &driver); globus_xio_attr_init(&attr); res = globus_xio_attr_cntl( attr, driver, GLOBUS_XIO_BIDI_SET_PORT, port); } } globus_xio_stack_push_driver(stack, driver); globus_xio_server_create(&server_handle, attr, stack); globus_xio_server_get_contact_string(server_handle, &cs); fprintf(stdout, "\n\n %s\n\n", cs); globus_xio_server_accept(&xio_handle, server_handle); globus_xio_open(xio_handle, NULL, NULL); while(!done) { res = globus_xio_read( xio_handle, line, LINE_LEN, 1, &nbytes, NULL); if(res != GLOBUS_SUCCESS) { done = 1; } line[nbytes] = '\0'; fprintf(stdout, "%s", line); sprintf(writeline, "%s", line); len=strlen(line); res = globus_xio_write( xio_handle, writeline, len, len, &pbytes, NULL); if(res != GLOBUS_SUCCESS) { done = 1; } } globus_xio_close(xio_handle, NULL); globus_module_activate(GLOBUS_XIO_MODULE); return 0; }
int main( int argc, char ** argv) { globus_result_t result; int rc; globus_byte_t buffer[GF_DYN_PACKET_LEN]; uint32_t tmp32; char * be_cs; char * reg_cs; globus_size_t nbytes; LTDL_SET_PRELOADED_SYMBOLS(); rc = globus_module_activate(GLOBUS_XIO_MODULE); if(rc != 0) { goto error_activate; } result = gfs_l_dynclient_master_options(argc, argv); if(result != GLOBUS_SUCCESS) { goto error_opts; } if(argc < 3) { fprintf(stderr, "%s [options] <backend contact string>" " <frontend contact string>\n", argv[0]); fprintf(stderr, "Use -help for more information\n"); exit(0); } be_cs = argv[argc - 2]; reg_cs = argv[argc - 1]; result = gfs_l_dynclient_xio_setup(); if(result != GLOBUS_SUCCESS) { goto error_xio; } memset(buffer, '\0', GF_DYN_PACKET_LEN); buffer[GF_VERSION_NDX] = GF_VERSION; buffer[GF_MSG_TYPE_NDX] = GFS_GFORK_MSG_TYPE_DYNBE; tmp32 = htonl(g_at_once); memcpy(&buffer[GF_DYN_AT_ONCE_NDX], &tmp32, sizeof(uint32_t)); tmp32 = htonl(g_total_cons); memcpy(&buffer[GF_DYN_TOTAL_NDX], &tmp32, sizeof(uint32_t)); tmp32 = htonl(1); memcpy(&buffer[GF_DYN_ENTRY_COUNT_NDX], &tmp32, sizeof(uint32_t)); strncpy((char *) &buffer[GF_DYN_CS_NDX], be_cs, GF_DYN_CS_LEN); result = globus_xio_open(g_xio_handle, reg_cs, NULL); if(result != GLOBUS_SUCCESS) { goto error_open; } result = globus_xio_write( g_xio_handle, buffer, GF_DYN_PACKET_LEN, GF_DYN_PACKET_LEN, &nbytes, NULL); if(result != GLOBUS_SUCCESS) { goto error_write; } /* read reply */ result = globus_xio_read( g_xio_handle, buffer, GF_DYN_PACKET_LEN, GF_DYN_PACKET_LEN, &nbytes, NULL); if(result != GLOBUS_SUCCESS) { gfs_l_dynclient_log(GLOBUS_SUCCESS, 0, "Read failed\n"); goto error_read; } result = globus_xio_close(g_xio_handle, NULL); if(result != GLOBUS_SUCCESS) { gfs_l_dynclient_log(GLOBUS_SUCCESS, 0, "Close failed\n"); goto error_close; } gfs_l_dynclient_log(GLOBUS_SUCCESS, 1, "proper net commication with %s\n", reg_cs); if(buffer[GF_MSG_TYPE_NDX] == GFS_GFORK_MSG_TYPE_ACK) { gfs_l_dynclient_log(GLOBUS_SUCCESS, 0, "SUCCESS: registered %s to %s", be_cs, reg_cs); rc = 0; } else { gfs_l_dynclient_log(GLOBUS_SUCCESS, 0, "ERROR: %s rejected registration of %s", reg_cs, be_cs); rc = 1; } return rc; error_close: error_read: error_write: error_open: error_xio: error_opts: error_activate: gfs_l_dynclient_log(result, 0, ""); return 2; }
int main( int argc, char ** argv) { globus_xio_driver_t driver; globus_xio_stack_t stack; globus_xio_handle_t xio_handle; char * cs; globus_result_t res; char line[LINE_LEN]; int ctr; globus_bool_t done = GLOBUS_FALSE; globus_size_t nbytes; if(argc < 2) { help(); return 1; } globus_module_activate(GLOBUS_XIO_MODULE); globus_xio_stack_init(&stack, NULL); for(ctr = 1; ctr < argc - 1; ctr++) { if(strcmp(argv[ctr], "-h") == 0) { help(); return 0; } else if(strcmp(argv[ctr], "-D") == 0 && ctr + 1 < argc - 1) { ctr++; globus_xio_driver_load(argv[ctr], &driver); globus_xio_stack_push_driver(stack, driver); } } cs = argv[argc - 1]; res = globus_xio_handle_create(&xio_handle, stack); test_res(res); globus_xio_open(xio_handle, cs, NULL); while(!done) { if(fgets(line, LINE_LEN, stdin) == NULL) { done = GLOBUS_TRUE; } else { int len; len = strlen(line); res = globus_xio_write( xio_handle, line, len, len, &nbytes, NULL); test_res(res); } } globus_xio_close(xio_handle, NULL); globus_module_activate(GLOBUS_XIO_MODULE); return 0; }
static void * globus_l_dsi_rest_thread( void *arg) { globus_l_dsi_rest_handle_t *dsi_rest_handle = arg; globus_xio_data_descriptor_t descriptor; size_t buf_size = 256; unsigned char *buf = malloc(buf_size); globus_size_t nbytes; char *encoded_uri; globus_mutex_lock(&dsi_rest_handle->mutex); while (!dsi_rest_handle->terminate) { char *method; char *uri; globus_xio_http_version_t http_version; globus_hashtable_t headers; globus_result_t result; globus_mutex_unlock(&dsi_rest_handle->mutex); result = globus_xio_server_accept( &dsi_rest_handle->xio_handle, dsi_rest_handle->xio_server); globus_mutex_lock(&dsi_rest_handle->mutex); if (result != GLOBUS_SUCCESS) { continue; } result = globus_xio_open( dsi_rest_handle->xio_handle, NULL, NULL); if (result != GLOBUS_SUCCESS) { goto end_this_socket; } result = globus_xio_data_descriptor_init(&descriptor, dsi_rest_handle->xio_handle); if (result != GLOBUS_SUCCESS) { goto end_this_socket; } result = globus_xio_read( dsi_rest_handle->xio_handle, buf, 0, 0, &nbytes, descriptor); if (result != GLOBUS_SUCCESS) { goto end_this_socket; } result = globus_xio_data_descriptor_cntl( descriptor, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_GET_REQUEST, &method, &uri, &http_version, &headers); globus_dsi_rest_uri_escape(uri, &encoded_uri); char *uripath = globus_common_create_string("%s/%s", dsi_rest_handle->root, encoded_uri); if (strcmp(method, "GET") == 0) { int fd; fd = open(uripath, O_RDONLY); if (fd < 0) { globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER, "Connection", "Close"); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER, "Content-Length", "0"); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_STATUS_CODE, 404); } else { globus_size_t read_amt = 0; globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER, "Connection", "Close"); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_STATUS_CODE, 200); do { read_amt = read(fd, buf, buf_size); if (read_amt > 0) { globus_size_t written_amt = 0; while (written_amt < read_amt) { globus_size_t this_write; result = globus_xio_write( dsi_rest_handle->xio_handle, buf+written_amt, read_amt-written_amt, read_amt-written_amt, &this_write, NULL); if (this_write > 0) { written_amt += this_write; } else if (result != GLOBUS_SUCCESS) { break; } } } } while (read_amt > 0); close(fd); } } else { int fd = open(uripath, O_WRONLY|O_CREAT, 0700); if (fd < 0) { globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_STATUS_CODE, 500); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER, "Content-Length", "0"); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER, "Connection", "Close"); } else { off_t total_written=0; if (nbytes > 0) { globus_size_t written_amt = 0; while (written_amt < nbytes) { globus_size_t this_write; this_write = write(fd, buf+written_amt, nbytes-written_amt); if (this_write > 0) { written_amt += this_write; total_written += this_write; } } } do { result = globus_xio_read( dsi_rest_handle->xio_handle, buf, buf_size, 1, &nbytes, NULL); if (nbytes > 0) { globus_size_t written_amt = 0; while (written_amt < nbytes) { globus_size_t this_write; this_write = write(fd, buf+written_amt, nbytes-written_amt); if (this_write > 0) { written_amt += this_write; total_written += this_write; } } } if (result != GLOBUS_SUCCESS) { if (globus_error_match( globus_error_peek(result), GLOBUS_XIO_MODULE, GLOBUS_XIO_ERROR_EOF) || globus_xio_driver_error_match( dsi_rest_handle->http_driver, globus_error_peek(result), GLOBUS_XIO_HTTP_ERROR_EOF)) { result = GLOBUS_SUCCESS; break; } else { globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_STATUS_CODE, 500); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER, "Content-Length", "0"); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER, "Connection", "Close"); goto xio_error; } } } while (nbytes > 0); close(fd); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_STATUS_CODE, 204); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER, "Content-Length", "0"); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER, "Connection", "Close"); } } xio_error: free(uripath); result = globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_END_OF_ENTITY); end_this_socket: result = globus_xio_close( dsi_rest_handle->xio_handle, NULL); dsi_rest_handle->xio_handle = NULL; } dsi_rest_handle->terminate_complete = true; globus_cond_signal(&dsi_rest_handle->cond); globus_mutex_unlock(&dsi_rest_handle->mutex); return NULL; }