/*
* read from a file
*/
static
globus_result_t
globus_l_xio_popen_read(
void * driver_specific_handle,
const globus_xio_iovec_t * iovec,
int iovec_count,
globus_xio_operation_t op)
{
xio_l_popen_handle_t * handle;
globus_size_t nbytes;
globus_result_t result;
globus_off_t offset;
GlobusXIOName(globus_l_xio_popen_read);
GlobusXIOPOpenDebugEnter();
handle = (xio_l_popen_handle_t *) driver_specific_handle;
offset = GlobusXIOPOpenPosition(handle);
/* if buflen and waitfor are both 0, we behave like register select */
if((globus_xio_operation_get_wait_for(op) == 0 &&
(iovec_count > 1 || iovec[0].iov_len > 0)) ||
(handle->use_blocking_io &&
globus_xio_driver_operation_is_blocking(op)))
{
result = globus_xio_system_file_read(
handle->in_system,
offset,
iovec,
iovec_count,
globus_xio_operation_get_wait_for(op),
&nbytes);
globus_l_xio_popen_update_position(handle, nbytes, SEEK_CUR);
globus_xio_driver_finished_read(op, result, nbytes);
result = GLOBUS_SUCCESS;
}
else
{
result = globus_xio_system_file_register_read(
op,
handle->in_system,
offset,
iovec,
iovec_count,
globus_xio_operation_get_wait_for(op),
globus_l_xio_popen_system_read_cb,
op);
}
GlobusXIOPOpenDebugExit();
return result;
}
/*
* write to a file
*/
static
globus_result_t
globus_l_xio_pipe_write(
void * driver_specific_handle,
const globus_xio_iovec_t * iovec,
int iovec_count,
globus_xio_operation_t op)
{
xio_l_pipe_handle_t * handle;
globus_size_t nbytes;
globus_result_t result;
GlobusXIOName(globus_l_xio_pipe_write);
GlobusXIOPipeDebugEnter();
handle = (xio_l_pipe_handle_t *) driver_specific_handle;
/* if buflen and waitfor are both 0, we behave like register select */
if((globus_xio_operation_get_wait_for(op) == 0 &&
(iovec_count > 1 || iovec[0].iov_len > 0)) ||
(handle->use_blocking_io &&
globus_xio_driver_operation_is_blocking(op)))
{
result = globus_xio_system_file_write(
handle->out_system,
0,
iovec,
iovec_count,
globus_xio_operation_get_wait_for(op),
&nbytes);
globus_xio_driver_finished_write(op, result, nbytes);
result = GLOBUS_SUCCESS;
}
else
{
result = globus_xio_system_file_register_write(
op,
handle->out_system,
0,
iovec,
iovec_count,
globus_xio_operation_get_wait_for(op),
globus_l_xio_pipe_system_write_cb,
op);
}
GlobusXIOPipeDebugExit();
return result;
}
static globus_result_t
globus_l_xio_bounce_write(
void * driver_handle,
const globus_xio_iovec_t * iovec,
int iovec_count,
globus_xio_operation_t op)
{
bounce_info_t * info;
globus_result_t res = GLOBUS_SUCCESS;
globus_size_t wait_for;
GlobusXIOName(globus_l_xio_bounce_write);
GlobusXIOTestDebugInternalEnter();
wait_for = globus_xio_operation_get_wait_for(op);
info = (bounce_info_t *)
globus_malloc(sizeof(bounce_info_t));
memset(info, '\0', sizeof(bounce_info_t));
info->next_op = TEST_WRITE;
info->bounce_count = 0;
info->max_count = MAX_COUNT;
info->start_op = TEST_WRITE;
info->wait_for = wait_for;
info->iovec = (globus_xio_iovec_t *)iovec;
info->iovec_count = iovec_count;
info->nbytes = 0;
info->handle = driver_handle;
res = test_bounce_next_op(info, op);
if(res != GLOBUS_SUCCESS)
{
goto err;
}
GlobusXIOTestDebugInternalExit();
return GLOBUS_SUCCESS;
err:
GlobusXIOTestDebugInternalExitWithError();
return res;
}
static globus_result_t
globus_l_xio_telnet_write(
void * driver_specific_handle,
const globus_xio_iovec_t * iovec,
int iovec_count,
globus_xio_operation_t op)
{
globus_result_t res;
res = globus_xio_driver_pass_write(
op,
(globus_xio_iovec_t *)iovec,
iovec_count,
globus_xio_operation_get_wait_for(op),
globus_l_xio_telnet_write_cb,
NULL);
return res;
}
/**
* Callback after writing response
* @ingroup globus_i_xio_http_server
*
* Frees the iovec array associated with the response and then if
* writing user data was used to trigger the response, write it to the
* transport. If an error occurs while writing, the operation will be
* finished. If the response was triggered by the
* GLOBUS_XIO_HTTP_HANDLE_SET_END_OF_ENTITY control, then the operation
* is simply destroyed.
*
* @return void
*/
static
void
globus_l_xio_http_server_write_response_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;
int i;
globus_mutex_lock(&http_handle->mutex);
for (i = 0; i < http_handle->header_iovcnt; i++)
{
globus_libc_free(http_handle->header_iovec[i].iov_base);
}
globus_libc_free(http_handle->header_iovec);
http_handle->header_iovec = NULL;
http_handle->header_iovcnt = 0;
if (http_handle->write_operation.iovcnt > 0)
{
/* User data to be sent */
if (http_handle->response_info.headers.transfer_encoding
== GLOBUS_XIO_HTTP_TRANSFER_ENCODING_CHUNKED)
{
result = globus_i_xio_http_write_chunk(
http_handle,
http_handle->write_operation.iov,
http_handle->write_operation.iovcnt,
op);
}
else
{
result = globus_xio_driver_pass_write(
op,
http_handle->write_operation.iov,
http_handle->write_operation.iovcnt,
globus_xio_operation_get_wait_for(op),
globus_i_xio_http_write_callback,
http_handle);
}
if (result != GLOBUS_SUCCESS)
{
globus_xio_driver_finished_write(op, result, 0);
http_handle->write_operation.operation = NULL;
http_handle->write_operation.driver_handle = NULL;
}
}
else
{
/* destroy synthesized operation */
globus_xio_driver_operation_destroy(
http_handle->write_operation.operation);
http_handle->write_operation.operation = NULL;
http_handle->write_operation.driver_handle = NULL;
}
if (http_handle->close_operation != NULL)
{
result = globus_xio_driver_pass_close(
http_handle->close_operation,
globus_i_xio_http_close_callback,
http_handle);
globus_mutex_unlock(&http_handle->mutex);
if (result != GLOBUS_SUCCESS)
{
globus_i_xio_http_close_callback(
http_handle->close_operation,
result,
http_handle);
}
}
else
{
http_handle->parse_state = GLOBUS_XIO_HTTP_PRE_REQUEST_LINE;
globus_mutex_unlock(&http_handle->mutex);
}
return;
}
