void mdsip_open_cb( globus_xio_handle_t xio_handle,
globus_result_t result,
void *user_arg)
{
globus_result_t res;
mdsip_client_t *ctx;
mdsip_options_t *options = (mdsip_options_t *)user_arg;
gss_cred_id_t credential;
ctx = mdsip_new_client(options);
mdsip_test_result(xio_handle,result,ctx,"mdsip_open_cb");
if (options->port_name == NULL)
{
if (options->security_level > 0)
{
gss_buffer_desc buffer_desc = GSS_C_EMPTY_BUFFER;
OM_uint32 minor_status;
OM_uint32 major_status;
res = globus_xio_handle_cntl(xio_handle,options->gsi_driver,
GLOBUS_XIO_GSI_GET_DELEGATED_CRED,&credential);
mdsip_test_result(xio_handle,res,ctx,"mdsip_open_cb,GET_DELEGATED_CRED");
major_status = gss_export_cred(&minor_status,credential,GSS_C_NO_OID,0,&buffer_desc);
if(major_status != GSS_S_COMPLETE)
{
char *error_str;
globus_gss_assist_display_status_str(&error_str,
NULL,
major_status,
minor_status,
0);
printf("\nLINE %d ERROR: %s\n\n", __LINE__, error_str);
}
else
{
char cred_file_name[]="/tmp/x509pp_pXXXXXX";
int fd=mkstemp(cred_file_name);
if (fd != -1)
{
fchmod(fd,00600);
write(fd,buffer_desc.value,buffer_desc.length);
fchmod(fd,00400);
close(fd);
setenv("X509_USER_PROXY",cred_file_name,1);
}
else
perror("Error creating proxy credential file");
major_status = gss_release_buffer(&minor_status,&buffer_desc);
}
}
}
ctx->mdsip_read_cb=mdsip_authenticate_cb;
res = globus_xio_register_read(xio_handle,(globus_byte_t *)&ctx->header, sizeof(mdsip_message_header_t),
sizeof(mdsip_message_header_t),NULL,mdsip_read_header_cb,ctx);
mdsip_test_result(xio_handle,res,ctx,"mdsip_open_cb,globus_xio_register_read");
}
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
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);
}
void mdsip_authenticate_cb(
globus_xio_handle_t xio_handle,
globus_result_t result,
globus_byte_t *buffer,
globus_size_t len,
globus_size_t nbytes,
globus_xio_data_descriptor_t data_desc,
void *user_arg)
{
mdsip_client_t *ctx = (mdsip_client_t *)user_arg;
char *remote_user = strncpy(malloc(nbytes+1),buffer,nbytes);
remote_user[nbytes]=0;
mdsip_test_result(xio_handle,result,ctx,"mdsip_authenticate_cb");
if (result == GLOBUS_SUCCESS)
{
int status;
globus_result_t res;
short dummy;
mdsip_message_t *reply = (mdsip_message_t *)memset(malloc(sizeof(mdsip_message_t)),0,sizeof(mdsip_message_t));
char *contact;
res = globus_xio_handle_cntl(xio_handle,
(globus_xio_driver_t)ctx->options->tcp_driver,
GLOBUS_XIO_TCP_GET_REMOTE_CONTACT,
&contact);
mdsip_test_result(xio_handle,res,ctx,"mdsip_authenticate_cb,GET_REMOTE_CONTACT");
ctx->host = strcpy(malloc(strlen(contact)+1),contact);
ctx->host[strcspn(ctx->host,":")]=0;
res = globus_xio_handle_cntl(xio_handle,
(globus_xio_driver_t)ctx->options->tcp_driver,
GLOBUS_XIO_TCP_GET_REMOTE_NUMERIC_CONTACT,
&contact);
mdsip_test_result(xio_handle,res,ctx,"mdsip_authenticate_cb,GETREMOTE_NUMERIC_CONTACT");
ctx->ipaddr = strcpy(malloc(strlen(contact)+1),contact);
ctx->ipaddr[strcspn(ctx->ipaddr,":")]=0;
mdsip_host_to_ipaddr(ctx->host,&ctx->addr,&dummy);
if (ctx->options->security_level > 0)
{
gss_buffer_desc buffer_desc = GSS_C_EMPTY_BUFFER;
gss_buffer_t buffer = &buffer_desc;
OM_uint32 status;
globus_xio_driver_t driver = (globus_xio_driver_t)ctx->options->gsi_driver;
globus_result_t res;
gss_name_t name;
res = globus_xio_handle_cntl((globus_xio_handle_t)xio_handle,
driver,
GLOBUS_XIO_GSI_GET_PEER_NAME,
&name);
gss_export_name(&status, name, buffer);
ctx->remote_user=strcpy(malloc(strlen((char *)buffer->value)+1),(char *)buffer->value);
}
else
{
ctx->remote_user=remote_user;
}
status = mdsip_find_user_mapping(ctx->options->hostfile, ctx->ipaddr,ctx->host,ctx->remote_user,&ctx->local_user);
if (status & 1 && ctx->options->port_name == 0)
status = mdsip_become_user(ctx->local_user,ctx->remote_user);
reply->h.msglen = sizeof(mdsip_message_header_t);
reply->h.status = status;
if (status & 1)
{
if (ctx->options->security_level > 0)
{
fprintf(stdout,"%s, CONNECT - %s/%s@%s(%s)\n",mdsip_current_time(),ctx->remote_user,remote_user,ctx->host,ctx->ipaddr);
free(remote_user);
}
else
fprintf(stdout,"%s, CONNECT - %s@%s(%s)\n",mdsip_current_time(),ctx->remote_user,ctx->host,ctx->ipaddr);
}
else
{
fprintf(stdout,"%s, REJECT - %s@%s(%s)\n",mdsip_current_time(),ctx->remote_user,ctx->host,ctx->ipaddr);
}
free(ctx->message);
mdsip_write((void *)xio_handle,ctx,reply,0);
if (status & 1)
{
ctx->mdsip_read_cb = mdsip_do_message_cb;
res = globus_xio_register_read(xio_handle,(globus_byte_t *)&ctx->header, sizeof(mdsip_message_header_t), sizeof(mdsip_message_header_t),
NULL,mdsip_read_header_cb,ctx);
mdsip_test_result(xio_handle,res,ctx,"mdsip_authenticate_cb,globus_xio_register_read");
}
else
globus_xio_register_close(xio_handle,NULL,mdsip_close_cb,ctx);
}
return;
}
int
main(
int argc,
char ** argv)
{
globus_xio_driver_t tcp_driver;
globus_xio_stack_t stack;
globus_xio_handle_t xio_handle;
globus_xio_server_t xio_server;
globus_result_t res;
char * cs;
globus_gridftp_server_control_attr_t ftp_attr;
globus_gridftp_server_control_t ftp_server;
globus_xio_system_socket_t system_handle;
globus_module_activate(GLOBUS_XIO_MODULE);
globus_module_activate(GLOBUS_GRIDFTP_SERVER_CONTROL_MODULE);
globus_mutex_init(&gs_l_mutex, NULL);
globus_cond_init(&gs_l_cond, NULL);
/*
* set up the xio handle
*/
res = globus_xio_driver_load("tcp", &tcp_driver);
test_res(res, __LINE__);
res = globus_xio_stack_init(&stack, NULL);
test_res(res, __LINE__);
res = globus_xio_stack_push_driver(stack, tcp_driver);
test_res(res, __LINE__);
res = globus_xio_server_create(&xio_server, NULL, stack);
test_res(res, __LINE__);
globus_xio_stack_destroy(stack);
res = globus_xio_server_get_contact_string(xio_server, &cs);
test_res(res, __LINE__);
fprintf(stdout, "%s\n", cs);
globus_free(cs);
res = globus_xio_server_accept(&xio_handle, xio_server);
test_res(res, __LINE__);
fprintf(stdout, "xio connection esstablished.\n");
/*
* server connection is all set up, hand it to server_lib
*/
res = globus_gridftp_server_control_init(&ftp_server);
test_res(res, __LINE__);
res = globus_gridftp_server_control_attr_init(&ftp_attr);
test_res(res, __LINE__);
globus_xio_server_close(xio_server);
if(argc > 1)
{
globus_gridftp_server_control_attr_set_security(
ftp_attr, GLOBUS_GRIDFTP_SERVER_LIBRARY_GSSAPI |
GLOBUS_GRIDFTP_SERVER_LIBRARY_NONE);
}
else
{
globus_gridftp_server_control_attr_set_security(
ftp_attr, GLOBUS_GRIDFTP_SERVER_LIBRARY_NONE);
}
res = globus_gridftp_server_control_attr_set_auth(
ftp_attr, auth_func, NULL);
test_res(res, __LINE__);
res = globus_gridftp_server_control_attr_set_resource(
ftp_attr, globus_l_resource_cb, NULL);
test_res(res, __LINE__);
res = globus_gridftp_server_control_attr_set_list(
ftp_attr, list_cb, NULL);
test_res(res, __LINE__);
res = globus_gridftp_server_control_attr_set_idle_time(
ftp_attr, 900, 60);
test_res(res, __LINE__);
res = globus_gridftp_server_control_attr_set_banner(
ftp_attr, "This is 1 line of banner\nthis is line 2\nline 3");
test_res(res, __LINE__);
res = globus_gridftp_server_control_attr_set_message(
ftp_attr, "Setting the message after login, 1 line\n");
test_res(res, __LINE__);
res = globus_gridftp_server_control_attr_set_log(
ftp_attr, logging_func, GLOBUS_GRIDFTP_SERVER_CONTROL_LOG_ALL, NULL);
test_res(res, __LINE__);
res = globus_gridftp_server_control_attr_data_functions(
ftp_attr, active_connect, NULL,
passive_connect, NULL, data_destroy_cb, NULL);
res = globus_gridftp_server_control_attr_add_send(
ftp_attr, NULL, transfer, NULL);
test_res(res, __LINE__);
res = globus_gridftp_server_control_attr_add_recv(
ftp_attr, NULL, transfer, NULL);
test_res(res, __LINE__);
res = globus_xio_handle_cntl(xio_handle, tcp_driver,
GLOBUS_XIO_TCP_GET_HANDLE, &system_handle);
test_res(res, __LINE__);
globus_gsc_959_command_add(
ftp_server,
"SITE MINE",
globus_gs_cmd_site,
GLOBUS_GSC_COMMAND_POST_AUTH,
2,
2,
"SITE <sp> MINE!!!!",
NULL);
globus_mutex_lock(&globus_l_mutex);
{
res = globus_gridftp_server_control_start(
ftp_server, ftp_attr, system_handle,
globus_l_done_cb, FTP_USER_ARG);
test_res(res, __LINE__);
while(!globus_l_done)
{
globus_cond_wait(&globus_l_cond, &globus_l_mutex);
}
}
globus_mutex_unlock(&globus_l_mutex);
globus_xio_close(xio_handle, NULL);
fprintf(stdout, "Ending...\n");
res = globus_gridftp_server_control_attr_destroy(ftp_attr);
test_res(res, __LINE__);
res = globus_gridftp_server_control_destroy(ftp_server);
test_res(res, __LINE__);
globus_module_deactivate(GLOBUS_GRIDFTP_SERVER_CONTROL_MODULE);
globus_module_deactivate(GLOBUS_XIO_MODULE);
return 0;
}
static
void
gfs_l_xio_cp_read_cb(
globus_xio_handle_t handle,
globus_result_t result,
globus_byte_t * buffer,
globus_size_t len,
globus_size_t nbytes,
globus_xio_data_descriptor_t data_desc,
void * user_arg)
{
gfs_l_xio_read_buffer_t * read_buf;
gfs_i_xio_cp_handle_t * cp_h;
read_buf = (gfs_l_xio_read_buffer_t *) user_arg;
cp_h = read_buf->whos_my_daddy;
globus_mutex_lock(&cp_h->mutex);
{
read_buf->nbytes = nbytes;
if(result != GLOBUS_SUCCESS)
{
if(eof)
{
read_buf->eof = GLOBUS_TRUE;
}
else
{
/* what if this is just EOF */
goto error;
}
}
/* it is possible to get here in the CLOSING state without an error */
if(cp_h->state == GFS_CIO_CP_STATE_ERROR)
{
goto error;
}
/* XXX need to get an offset for this buffer */
read_buf->nbytes = nbytes;
result = globus_xio_data_descriptor_cntl(
data_desc,
NULL,
GLOBUS_XIO_DD_GET_OFFSET,
&offset);
if(result != GLOBUS_SUCCESS)
{
goto error;
}
read_buf->offset = offset;
if(!globus_fifo_empty(cp_h->write_q))
{
read_buf->write_xio =
(globus_xio_handle_t) globus_fifo_dequeue(cp_h->write_q);
result = globus_xio_handle_cntl(
read_buf->write_xio,
GLOBUS_XIO_QUERY,
GLOBUS_XIO_SEEK,
read_buf->offset);
if(result != GLOBUS_SUCCESS)
{
goto error;
}
result = globus_xio_register_write(
read_buf->write_xio,
read_buf->buffer,
read_buf->nbytes,
read_buf->nbytes,
NULL,
gfs_l_xio_cp_write_cb,
read_buf);
if(result != GLOBUS_SUCCESS)
{
goto error;
}
}
else
{
/* stick this one in the queue */
globus_fifo_enqueue(&cp_h->read_buffer_q, read_buf);
}
if(!eof)
{
/* make and post a new one */
read_buf = (gfs_l_xio_read_buffer_t *)
globus_calloc(sizeof(gfs_l_xio_read_buffer_t)+block_size, 1);
read_buf->block_size = cp_h->block_size;
read_buf->whos_my_daddy = cp_h;
/* do this last since it can inspire the CLOSING state */
gfs_l_xio_cp_post_read(xio_h, read_buf);
}
else
{
/* remove it from close q and close */
globus_fifo_remove(cp_h->read_all_q, read_buf->read_xio);
result = globus_xio_register_close(
read_buf->read_xio,
NULL,
gfs_l_xio_cp_close_cb,
cp_h);
if(result != GLOBUS_SUCCESS)
{
cp_h->read_handle_count--;
}
if(cp_h->read_handle_count <= 0)
{
gfs_l_xio_close_write_handles(cp_h);
}
}
}
globus_mutex_unlock(&cp_h->mutex);
return;
error:
globus_free(read_buf);
gfs_l_xio_cp_error(cp_h, result);
globus_mutex_unlock(&cp_h->mutex);
}
static
void
gfs_l_xio_cp_write_cb(
globus_xio_handle_t handle,
globus_result_t result,
globus_byte_t * buffer,
globus_size_t len,
globus_size_t nbytes,
globus_xio_data_descriptor_t data_desc,
void * user_arg)
{
gfs_l_xio_read_buffer_t * read_buf;
gfs_i_xio_cp_handle_t * cp_h;
read_buf = (gfs_l_xio_read_buffer_t *) user_arg;
cp_h = read_buf->whos_my_daddy;
globus_free(read_buf);
globus_mutex_lock(&cp_h->mutex);
{
if(result != GLOBUS_SUCCESS)
{
goto error;
}
if(cp_h->state == GFS_CIO_CP_STATE_ERROR)
{
goto error;
}
/* if there are outstanding read buffers left use this handle
to write one */
if(!globus_fifo_empty(cp_h->read_buffer_q))
{
read_buf = (gfs_l_xio_read_buffer_t *)
globus_fifo_dequeue(&cp_h->write_q);
globus_xio_handle_cntl(
read_buf->write_xio,
NULL, /* QUERY MAYBE? */
GLOBUS_XIO_SEEK,
read_buf->offset);
result = globus_xio_register_write(
read_buf->write_xio,
read_buf->buffer,
read_buf->nbytes,
read_buf->nbytes,
NULL,
gfs_l_xio_cp_write_cb,
read_buf);
if(result != GLOBUS_SUCCESS)
{
goto error;
}
}
/* if read buffers are gone and all read handles are gone
then we are at eof and can start cloising the writes */
else if(globus_fifo_empty(cp_h->read_all_q))
{
gfs_l_xio_close_write_handles(cp_h);
}
/* if still going but nothing to write just put this back in the
queue */
else
{
globus_fifo_enqueue(&cp_h->write_q, read_buf->write_xio);
}
}
globus_mutex_unlock(&cp_h->mutex);
if(cp_h->update_cb)
{
cp_h->update_cb(offset, nbytes, cp_h->user_arg);
}
return;
error:
globus_free(read_buf);
gfs_l_xio_cp_error(cp_h, result);
globus_mutex_unlock(&cp_h->mutex);
}
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;
}
