static
void
globus_l_xio_popen_system_write_cb(
globus_result_t result,
globus_size_t nbytes,
void * user_arg)
{
globus_xio_operation_t op;
xio_l_popen_handle_t * handle;
GlobusXIOName(globus_l_xio_popen_system_write_cb);
GlobusXIOPOpenDebugEnter();
op = (globus_xio_operation_t) user_arg;
handle = (xio_l_popen_handle_t *)
globus_xio_operation_get_driver_specific(op);
handle->canceled = globus_xio_operation_is_canceled(op);
globus_l_xio_popen_update_position(
handle,
nbytes,
SEEK_CUR);
globus_xio_driver_finished_write(op, result, nbytes);
GlobusXIOPOpenDebugExit();
}
static void
globus_l_xio_telnet_write_cb(
globus_xio_operation_t op,
globus_result_t result,
globus_size_t nbytes,
void * user_arg)
{
globus_xio_driver_finished_write(op, result, nbytes);
}
/*
* write to a file
*/
static
globus_result_t
globus_l_xio_popen_write(
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_write);
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_write(
handle->out_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_write(op, result, nbytes);
result = GLOBUS_SUCCESS;
}
else
{
result = globus_xio_system_file_register_write(
op,
handle->out_system,
offset,
iovec,
iovec_count,
globus_xio_operation_get_wait_for(op),
globus_l_xio_popen_system_write_cb,
op);
}
GlobusXIOPOpenDebugExit();
return result;
}
static
globus_result_t
globus_l_xio_wrapblock_write(
void * driver_specific_handle,
const globus_xio_iovec_t * iovec,
int iovec_count,
globus_xio_operation_t op)
{
globus_size_t nbytes;
globus_result_t result;
int i;
xio_l_wrapblock_wrapper_t * wrapper;
xio_l_wrapblock_handle_t * wrapblock_handle;
wrapblock_handle = (xio_l_wrapblock_handle_t *) driver_specific_handle;
if(globus_xio_driver_operation_is_blocking(op))
{
result = wrapblock_handle->wrapblock_driver->write_func(
wrapblock_handle->driver_handle,
iovec,
iovec_count,
&nbytes);
globus_xio_driver_finished_write(op, result, nbytes);
}
else
{
wrapper = (xio_l_wrapblock_wrapper_t *)
globus_calloc(1, sizeof(xio_l_wrapblock_wrapper_t));
wrapper->iovec = (globus_xio_iovec_t *)
globus_calloc(iovec_count, sizeof(globus_xio_iovec_t));
wrapper->iovec_count = iovec_count;
wrapper->op = op;
wrapper->wrapblock_handle = driver_specific_handle;
for(i = 0; i < iovec_count; i++)
{
wrapper->iovec[i].iov_base = iovec[i].iov_base;
wrapper->iovec[i].iov_len = iovec[i].iov_len;
}
globus_callback_register_oneshot(
NULL,
NULL,
globus_l_xio_wrapblock_write_kickout,
wrapper);
}
return GLOBUS_SUCCESS;
}
static
void
globus_l_xio_pipe_system_write_cb(
globus_result_t result,
globus_size_t nbytes,
void * user_arg)
{
globus_xio_operation_t op;
GlobusXIOName(globus_l_xio_pipe_system_write_cb);
GlobusXIOPipeDebugEnter();
op = (globus_xio_operation_t) user_arg;
globus_xio_driver_finished_write(op, result, nbytes);
GlobusXIOPipeDebugExit();
}
static void
test_bounce_finish_op(
bounce_info_t * info,
globus_xio_operation_t op)
{
GlobusXIOName(test_bounce_finish_op);
GlobusXIOTestDebugInternalEnter();
switch(info->start_op)
{
case TEST_READ:
globus_xio_driver_finished_read(op, info->res, info->nbytes);
break;
case TEST_WRITE:
globus_xio_driver_finished_write(op, info->res, info->nbytes);
break;
case TEST_OPEN:
if(info->res != GLOBUS_SUCCESS)
{
bounce_handle_destroy(info->handle);
info->handle = NULL;
}
globus_xio_driver_finished_open(
info->handle, op, info->res);
break;
case TEST_CLOSE:
globus_xio_driver_finished_close(op, info->res);
bounce_handle_destroy(info->handle);
break;
default:
globus_assert(0);
break;
}
globus_free(info);
GlobusXIOTestDebugInternalExit();
}
static
void
globus_l_xio_wrapblock_write_kickout(
void * user_arg)
{
globus_size_t nbytes;
globus_result_t result;
xio_l_wrapblock_wrapper_t * wrapper;
globus_thread_blocking_will_block();
wrapper = (xio_l_wrapblock_wrapper_t *) user_arg;
result = wrapper->wrapblock_handle->wrapblock_driver->write_func(
wrapper->wrapblock_handle->driver_handle,
wrapper->iovec,
wrapper->iovec_count,
&nbytes);
globus_xio_driver_finished_write(wrapper->op, result, nbytes);
xio_l_wrapblock_wrapper_destroy(wrapper);
}
/**
* 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;
}
