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;
}
