int
main(
int argc,
char ** argv)
{
unsigned char buffer[LINE_LEN];
globus_size_t nbytes;
globus_result_t res;
globus_xio_attr_t attr;
char * opts = NULL;
if(argc < 2)
{
fprintf(stderr, "usage: %s url\n", argv[0]);
return -1;
}
if(argc > 2)
{
opts = argv[2];
}
globus_module_activate(GLOBUS_XIO_MODULE);
globus_xio_attr_init(&attr);
globus_xio_handle_t myhandle;
res = globus_xio_handle_create_from_url(
&myhandle,
argv[1],
attr,
opts);
test_res(res, __LINE__);
res = globus_xio_open(myhandle, argv[1], attr);
test_res(res, __LINE__);
while(res == GLOBUS_SUCCESS)
{
res = globus_xio_read(myhandle, buffer, LINE_LEN, 1, &nbytes, NULL);
buffer[nbytes] = '\0';
printf("%s", buffer);
}
if(!globus_xio_error_is_eof(res))
{
printf("Error before EOF\n");
test_res(res, __LINE__);
}
globus_xio_close(myhandle, NULL);
globus_xio_attr_destroy(attr);
globus_module_deactivate(GLOBUS_XIO_MODULE);
return 0;
}
static void
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)
{
test_info_t * info;
globus_result_t res;
if(!globus_xio_error_is_eof(result) &&
!globus_xio_error_is_canceled(result))
{
test_res(GLOBUS_XIO_TEST_FAIL_FINISH_READ, result, __LINE__, __FILE__);
}
info = (test_info_t *) user_arg;
globus_mutex_lock(&info->mutex);
{
if(len < nbytes)
{
failed_exit("read wait for has failed");
}
else if(nbytes > len)
{
failed_exit("too many bytes were read.");
}
info->nread += nbytes;
if(info->nread >= info->total_read_bytes && !info->read_done)
{
info->closed++;
info->read_done = GLOBUS_TRUE;
if(info->closed == 2 || info->write_count == 0)
{
res = globus_xio_register_close(
handle,
NULL,
close_cb,
user_arg);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
}
}
else if(!info->read_done)
{
res = globus_xio_register_read(
handle,
info->buffer,
info->buffer_length,
info->buffer_length,
NULL,
read_cb,
user_arg);
test_res(GLOBUS_XIO_TEST_FAIL_PASS_READ, res, __LINE__, __FILE__);
}
}
globus_mutex_unlock(&info->mutex);
}
void
globus_i_xio_http_server_read_request_callback(
globus_xio_operation_t op,
globus_result_t result,
globus_size_t nbytes,
void * user_arg)
{
globus_i_xio_http_handle_t * http_handle = user_arg;
globus_bool_t done;
globus_result_t eof_result = GLOBUS_SUCCESS;
globus_i_xio_http_attr_t * descriptor;
globus_bool_t registered_again = GLOBUS_FALSE;
GlobusXIOName(globus_i_xio_http_server_read_request_callback);
globus_mutex_lock(&http_handle->mutex);
if (result != GLOBUS_SUCCESS)
{
if (globus_xio_error_is_eof(result))
{
eof_result = result;
}
else
{
goto error_exit;
}
}
/* Haven't parsed request and headers yet */
http_handle->read_buffer_valid += nbytes;
result = globus_l_xio_http_server_parse_request(http_handle, &done);
if (result == GLOBUS_SUCCESS && !done)
{
goto reregister_read;
}
else if (result != GLOBUS_SUCCESS)
{
goto error_exit;
}
/* Determine whether we should expect an entity along with the
* request
*/
if ((http_handle->request_info.http_version == GLOBUS_XIO_HTTP_VERSION_1_1)
&& (http_handle->request_info.headers.transfer_encoding
== GLOBUS_XIO_HTTP_TRANSFER_ENCODING_CHUNKED))
{
http_handle->parse_state = GLOBUS_XIO_HTTP_CHUNK_LINE;
}
else if (GLOBUS_I_XIO_HTTP_HEADER_IS_CONTENT_LENGTH_SET(
&http_handle->request_info.headers))
{
http_handle->parse_state = GLOBUS_XIO_HTTP_IDENTITY_BODY;
}
if (GLOBUS_I_XIO_HTTP_HEADER_IS_CONNECTION_CLOSE(
&http_handle->request_info.headers))
{
http_handle->response_info.headers.flags |=
GLOBUS_I_XIO_HTTP_HEADER_CONNECTION_CLOSE;
}
http_handle->send_state = GLOBUS_XIO_HTTP_STATUS_LINE;
descriptor = globus_xio_operation_get_data_descriptor(op, GLOBUS_TRUE);
if (descriptor == NULL)
{
result = GlobusXIOErrorMemory("descriptor");
goto error_exit;
}
globus_i_xio_http_request_destroy(&descriptor->request);
result = globus_i_xio_http_request_copy(
&descriptor->request,
&http_handle->request_info);
if (result != GLOBUS_SUCCESS)
{
goto error_exit;
}
result = globus_i_xio_http_parse_residue(http_handle, ®istered_again);
if ((http_handle->read_operation.wait_for <= 0 && !registered_again) ||
result != GLOBUS_SUCCESS)
{
if (http_handle->response_info.headers.transfer_encoding !=
GLOBUS_XIO_HTTP_TRANSFER_ENCODING_CHUNKED &&
GLOBUS_I_XIO_HTTP_HEADER_IS_CONTENT_LENGTH_SET(
&http_handle->response_info.headers) &&
http_handle->response_info.headers.content_length == 0)
{
/* Synthesize EOF if we've read all of the entity content */
result = GlobusXIOErrorEOF();
}
/*
* Either we've read enough, hit end of chunk, no entity was present,
* or pass to transport failed. Call finished_read
*/
nbytes = http_handle->read_operation.nbytes;
globus_libc_free(http_handle->read_operation.iov);
http_handle->read_operation.iov = NULL;
http_handle->read_operation.iovcnt = 0;
http_handle->read_operation.operation = NULL;
http_handle->read_operation.driver_handle = NULL;
http_handle->read_operation.nbytes = 0;
globus_mutex_unlock(&http_handle->mutex);
globus_xio_driver_finished_read(op, result, nbytes);
return;
}
else if (registered_again)
{
globus_mutex_unlock(&http_handle->mutex);
return;
}
/* FALLSTHROUGH */
reregister_read:
globus_assert(op == http_handle->read_operation.operation);
if (eof_result != GLOBUS_SUCCESS)
{
/* Header block wasn't complete before eof */
result = eof_result;
goto error_exit;
}
result = globus_i_xio_http_clean_read_buffer(http_handle);
if (result != GLOBUS_SUCCESS)
{
goto error_exit;
}
result = globus_xio_driver_pass_read(
op,
&http_handle->read_iovec,
1,
1,
globus_i_xio_http_server_read_request_callback,
http_handle);
if (result != GLOBUS_SUCCESS)
{
goto error_exit;
}
globus_mutex_unlock(&http_handle->mutex);
return;
error_exit:
globus_libc_free(http_handle->read_operation.iov);
http_handle->read_operation.iov = NULL;
http_handle->read_operation.iovcnt = 0;
http_handle->read_operation.operation = NULL;
http_handle->read_operation.driver_handle = NULL;
http_handle->read_operation.nbytes = 0;
globus_mutex_unlock(&http_handle->mutex);
globus_xio_driver_finished_read(op, result, 0);
}
/**
* Operator: read
*/
ngemResult_t
ngrcOperatorRead(
ngrcOperator_t *op,
void *buf,
size_t size,
size_t *nRead,
bool *canceled)
{
ngemResult_t ret = NGEM_FAILED;
globus_result_t gResult;
ngLog_t *log = NULL;
bool locked = false;
ngrclOperatorCallbackArg_t arg;
NGEM_FNAME(ngrcOperatorRead);
log = ngemLogGetDefault();
NGEM_ASSERT(op != NULL);
NGEM_ASSERT(size >= 0);
NGEM_ASSERT(nRead != NULL);
NGEM_ASSERT(canceled != NULL);
*canceled = false;
gResult = globus_mutex_lock(&op->ngo_mutex);
if (gResult != GLOBUS_SUCCESS) {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"globus_mutex_lock", gResult);
goto finalize;
}
locked = true;
ngrclOperatorCallbackArgInitialize(&arg, op);
if (op->ngo_canceled) {
*canceled = true;
ret = NGEM_SUCCESS;
goto finalize;
}
gResult = globus_xio_register_read(
op->ngo_handle, buf, size, 1, NULL,
ngrclGlobusCallback, &arg);
if (gResult != GLOBUS_SUCCESS) {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"globus_xio_register_read", gResult);
goto finalize;
}
while (arg.ngoca_done == false) {
gResult = globus_cond_wait(&op->ngo_cond, &op->ngo_mutex);
if (gResult != GLOBUS_SUCCESS) {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"globus_cond_wait", gResult);
}
}
if (arg.ngoca_result != GLOBUS_SUCCESS) {
if (globus_xio_error_is_canceled(arg.ngoca_result) == GLOBUS_TRUE) {
*canceled = true;
} else if (globus_xio_error_is_eof(arg.ngoca_result) == GLOBUS_TRUE) {
*nRead = 0;
} else {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"Callback function for reading", arg.ngoca_result);
goto finalize;
}
} else {
*nRead = arg.ngoca_bytes;
NGEM_ASSERT(*nRead > 0);
}
ret = NGEM_SUCCESS;
finalize:
ngrclOperatorCallbackArgFinalize(&arg);
if (locked) {
gResult = globus_mutex_unlock(&op->ngo_mutex);
if (gResult != GLOBUS_SUCCESS) {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"globus_mutex_unlock", gResult);
ret = NGEM_FAILED;
}
locked = false;
}
return ret;
}
