static
globus_result_t
globus_l_xio_wrapblock_open(
const globus_xio_contact_t * contact_info,
void * driver_link,
void * driver_attr,
globus_xio_operation_t op)
{
globus_result_t result;
xio_l_wrapblock_wrapper_t * wrapper;
xio_l_wrapblock_handle_t * wrapblock_handle;
globus_xio_driver_t driver;
globus_i_xio_op_t * xio_op;
xio_op = (globus_i_xio_op_t *) op;
driver = xio_op->_op_context->entry[op->ndx - 1].driver;
wrapblock_handle = globus_calloc(1, sizeof(xio_l_wrapblock_handle_t));
wrapblock_handle->wrapblock_driver = driver->wrap_data;
if(globus_xio_driver_operation_is_blocking(op))
{
result = wrapblock_handle->wrapblock_driver->open_func(
contact_info,
driver_link,
driver_attr,
&wrapblock_handle->driver_handle);
globus_xio_driver_finished_open(wrapblock_handle, op, result);
}
else
{
wrapper = (xio_l_wrapblock_wrapper_t *)
globus_calloc(1, sizeof(xio_l_wrapblock_wrapper_t));
wrapper->wrapblock_handle = wrapblock_handle;
wrapper->link = driver_link;
wrapper->op = op;
wrapper->driver = driver;
if(driver_attr != NULL && driver->attr_copy_func != NULL)
{
driver->attr_copy_func(&wrapper->attr, driver_attr);
}
/* gotta copy contact info the hard way */
globus_xio_contact_copy(&wrapper->ci, contact_info);
globus_callback_register_oneshot(
NULL,
NULL,
globus_l_xio_wrapblock_open_kickout,
wrapper);
}
return GLOBUS_SUCCESS;
}
/*
* 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_wrapblock_read(
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->read_func(
wrapblock_handle->driver_handle,
iovec,
iovec_count,
&nbytes);
globus_xio_driver_finished_read(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_read_kickout,
wrapper);
}
return GLOBUS_SUCCESS;
}
/*
* close a file
*/
static
globus_result_t
globus_l_xio_popen_close(
void * driver_specific_handle,
void * attr,
globus_xio_operation_t op)
{
xio_l_popen_handle_t * handle;
GlobusXIOName(globus_l_xio_popen_close);
GlobusXIOPOpenDebugEnter();
handle = (xio_l_popen_handle_t *) driver_specific_handle;
handle->close_op = op;
globus_xio_system_file_destroy(handle->in_system);
globus_xio_system_file_close(handle->infd);
#if !defined(USE_SOCKET_PAIR)
globus_xio_system_file_close(handle->outfd);
globus_xio_system_file_destroy(handle->out_system);
#endif
if(globus_xio_driver_operation_is_blocking(op))
{
globus_l_popen_waitpid(handle, 0);
}
else
{
globus_l_popen_waitpid(handle, WNOHANG);
}
GlobusXIOPOpenDebugExit();
return GLOBUS_SUCCESS;
}
static
globus_result_t
globus_l_xio_wrapblock_close(
void * driver_specific_handle,
void * attr,
globus_xio_operation_t op)
{
globus_result_t result;
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->close_func(
wrapblock_handle->driver_handle,
attr);
globus_xio_driver_finished_close(op, result);
globus_free(wrapblock_handle);
}
else
{
wrapper = (xio_l_wrapblock_wrapper_t *)
globus_calloc(1, sizeof(xio_l_wrapblock_wrapper_t));
wrapper->attr = attr;
wrapper->op = op;
wrapper->wrapblock_handle = driver_specific_handle;
globus_callback_register_oneshot(
NULL,
NULL,
globus_l_xio_wrapblock_close_kickout,
wrapper);
}
return GLOBUS_SUCCESS;
}
