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;
}
/*
* open a file
*/
static
globus_result_t
globus_l_xio_pipe_open(
const globus_xio_contact_t * contact_info,
void * driver_link,
void * driver_attr,
globus_xio_operation_t op)
{
xio_l_pipe_handle_t * handle;
xio_l_pipe_attr_t * attr;
globus_result_t result;
GlobusXIOName(globus_l_xio_pipe_open);
GlobusXIOPipeDebugEnter();
attr = (xio_l_pipe_attr_t *)
(driver_attr ? driver_attr : &xio_l_pipe_attr_default);
result = globus_l_xio_pipe_handle_init(&handle, attr);
if(result != GLOBUS_SUCCESS)
{
result = GlobusXIOErrorWrapFailed(
"globus_l_xio_pipe_handle_init", result);
goto error_handle;
}
result = globus_xio_system_file_init(&handle->out_system, handle->outfd);
if(result != GLOBUS_SUCCESS)
{
result = GlobusXIOErrorWrapFailed(
"globus_xio_system_file_init", result);
goto error_init;
}
result = globus_xio_system_file_init(&handle->in_system, handle->infd);
if(result != GLOBUS_SUCCESS)
{
result = GlobusXIOErrorWrapFailed(
"globus_xio_system_file_init", result);
goto error_init;
}
globus_xio_driver_finished_open(handle, op, GLOBUS_SUCCESS);
GlobusXIOPipeDebugExit();
return GLOBUS_SUCCESS;
error_init:
globus_l_xio_pipe_handle_destroy(handle);
error_handle:
GlobusXIOPipeDebugExitWithError();
return result;
}
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();
}
/************************************************************************
* iface functions
* ---------------
*
***********************************************************************/
static void
globus_l_xio_telnet_open_cb(
globus_xio_operation_t op,
globus_result_t result,
void * user_arg)
{
globus_l_xio_telnet_handle_t * handle;
handle = (globus_l_xio_telnet_handle_t *) user_arg;
if(result != GLOBUS_SUCCESS)
{
globus_fifo_destroy(&handle->write_q);
globus_free(handle->read_buffer);
globus_mutex_destroy(&handle->mutex);
globus_free(handle);
}
globus_xio_driver_finished_open(handle, op, result);
}
/**
* Server-side connection open callback
* @ingroup globus_i_xio_http_server
*
* Called as a result of open at the transport level. If this was successful,
* we will finish the open operation. If an error happens, this function will
* close the * handle internally and call globus_xio_driver_finished_open() to
* propagate the error.
*
* @param op
* Operation associated with the open.
* @param result
* Result from the transport's attempt to open the new connection.
* @param user_arg
* Void * pointing to a #globus_i_xio_http_handle_t associated with
* this open.
*
* @return void
*/
void
globus_i_xio_http_server_open_callback(
globus_xio_operation_t op,
globus_result_t result,
void * user_arg)
{
globus_i_xio_http_handle_t * http_handle = user_arg;
GlobusXIOName(globus_i_xio_http_server_open_callback);
if (result != GLOBUS_SUCCESS)
{
globus_i_xio_http_handle_destroy(http_handle);
globus_libc_free(http_handle);
http_handle = NULL;
}
globus_xio_driver_finished_open(
http_handle,
op,
result);
return;
}
static
void
globus_l_xio_wrapblock_open_kickout(
void * user_arg)
{
globus_result_t res;
xio_l_wrapblock_wrapper_t * wrapper;
globus_thread_blocking_will_block();
wrapper = (xio_l_wrapblock_wrapper_t *) user_arg;
res = wrapper->wrapblock_handle->wrapblock_driver->open_func(
&wrapper->ci,
wrapper->link,
wrapper->attr,
&wrapper->wrapblock_handle->driver_handle);
globus_xio_driver_finished_open(
wrapper->wrapblock_handle, wrapper->op, res);
xio_l_wrapblock_wrapper_destroy(wrapper);
}
/*
* open a file
*/
static
globus_result_t
globus_l_xio_popen_open(
const globus_xio_contact_t * contact_info,
void * driver_link,
void * driver_attr,
globus_xio_operation_t op)
{
int rc;
int s_fds[2];
int infds[2];
int outfds[2];
int errfds[2];
xio_l_popen_handle_t * handle;
const xio_l_popen_attr_t * attr;
globus_result_t result;
GlobusXIOName(globus_l_xio_popen_open);
GlobusXIOPOpenDebugEnter();
#ifdef WIN32
result = GlobusXIOErrorSystemResource("not available for windows");
#else
attr = (const xio_l_popen_attr_t *)
driver_attr ? driver_attr : &xio_l_popen_attr_default;
/* check that program exists and is exec=able first */
rc = access(attr->program_name, R_OK | X_OK);
if(rc != 0)
{
result = GlobusXIOErrorSystemError("access check", errno);
goto error_handle;
}
result = globus_l_xio_popen_handle_init(&handle);
if(result != GLOBUS_SUCCESS)
{
result = GlobusXIOErrorWrapFailed(
"globus_l_xio_popen_handle_init", result);
goto error_handle;
}
handle->ignore_program_errors = attr->ignore_program_errors;
handle->use_blocking_io = attr->use_blocking_io;
# if defined(USE_SOCKET_PAIR)
{
rc = socketpair(AF_UNIX, SOCK_STREAM, 0, s_fds);
if(rc != 0)
{
result = GlobusXIOErrorSystemError("socketpair", errno);
goto error_in_pipe;
}
/* trick the rest of the code into thinking it is using pipe */
outfds[0] = s_fds[0];
outfds[1] = s_fds[1];
infds[0] = s_fds[0];
infds[1] = s_fds[1];
}
# else
{
rc = pipe(infds);
if(rc != 0)
{
result = GlobusXIOErrorSystemError("pipe", errno);
goto error_in_pipe;
}
rc = pipe(outfds);
if(rc != 0)
{
result = GlobusXIOErrorSystemError("pipe", errno);
goto error_out_pipe;
}
}
# endif
rc = pipe(errfds);
if(rc != 0)
{
result = GlobusXIOErrorSystemError("pipe", errno);
goto error_err_pipe;
}
fcntl(errfds[0], F_SETFL, O_NONBLOCK);
fcntl(errfds[1], F_SETFL, O_NONBLOCK);
handle->pid = fork();
if(handle->pid < 0)
{
result = GlobusXIOErrorSystemError("fork", errno);
goto error_fork;
}
else if(handle->pid == 0)
{
globus_l_xio_popen_child(attr, contact_info, infds, outfds, errfds);
}
# if defined(USE_SOCKET_PAIR)
{
handle->infd = s_fds[0];
handle->outfd = s_fds[0];
result = globus_l_xio_popen_init_child_pipe(
handle->infd,
&handle->in_system);
if(result != GLOBUS_SUCCESS)
{
goto error_init;
}
handle->out_system = handle->in_system;
close(s_fds[1]);
}
# else
{
handle->infd = infds[0];
handle->outfd = outfds[1];
result = globus_l_xio_popen_init_child_pipe(
handle->outfd,
&handle->out_system);
if(result != GLOBUS_SUCCESS)
{
goto error_init;
}
result = globus_l_xio_popen_init_child_pipe(
handle->infd,
&handle->in_system);
if(result != GLOBUS_SUCCESS)
{
goto error_init;
}
close(outfds[0]);
close(infds[1]);
}
# endif
handle->errfd = errfds[0];
result = globus_l_xio_popen_init_child_pipe(
handle->errfd,
&handle->err_system);
if(result != GLOBUS_SUCCESS)
{
goto error_init;
}
close(errfds[1]);
globus_xio_driver_finished_open(handle, op, GLOBUS_SUCCESS);
GlobusXIOPOpenDebugExit();
return GLOBUS_SUCCESS;
error_init:
error_fork:
close(errfds[0]);
close(errfds[1]);
# if defined(USE_SOCKET_PAIR)
error_err_pipe:
close(s_fds[0]);
close(s_fds[1]);
# else
error_err_pipe:
close(outfds[0]);
close(outfds[1]);
error_out_pipe:
close(infds[0]);
close(infds[1]);
# endif
error_in_pipe:
globus_l_xio_popen_handle_destroy(handle);
error_handle:
#endif
GlobusXIOPOpenDebugExitWithError();
return result;
}
static
void
globus_l_xio_net_manager_accept_callback(
globus_xio_operation_t op,
globus_result_t result,
void *callback_arg)
{
globus_l_xio_net_manager_link_t *link = callback_arg;
globus_l_xio_net_manager_handle_t *handle = NULL;
char *string_opts = NULL;
globus_net_manager_attr_t *attrs = NULL, *attr_array_out = NULL;
globus_xio_driver_handle_t driver_handle =
globus_xio_operation_get_driver_handle(op);
if (result)
{
goto failed_accept;
}
if (link == NULL)
{
goto no_link;
}
handle = malloc(sizeof(globus_l_xio_net_manager_handle_t));
if (handle == NULL)
{
result = GlobusNetManagerErrorMemory("handle");
goto malloc_handle_fail;
}
handle->passive = GLOBUS_TRUE;
handle->transport_driver = link->transport_driver;
handle->transport_name = link->transport_name;
handle->local_contact = link->local_contact;
link->local_contact = NULL;
result = globus_xio_driver_handle_cntl(
driver_handle,
handle->transport_driver,
GLOBUS_XIO_GET_REMOTE_NUMERIC_CONTACT,
&handle->remote_contact);
if (result)
{
goto get_remote_contact_fail;
}
if (!handle->remote_contact)
{
result = GlobusNetManagerErrorInit(
handle->transport_name, "Unable to get remote contact.");
goto get_remote_contact_fail;
}
handle->attr = link->attr;
link->attr = NULL;
result = globus_xio_driver_attr_cntl(
op,
handle->transport_driver,
GLOBUS_XIO_GET_STRING_OPTIONS,
&string_opts);
if (result)
{
goto get_string_opts_fail;
}
result = globus_net_manager_attr_array_from_string(
&attrs,
handle->transport_name,
string_opts);
if (result)
{
goto array_from_string_fail;
}
result = globus_net_manager_context_post_accept(
handle->attr->context,
handle->attr->task_id ? handle->attr->task_id : "unset",
handle->transport_name,
handle->local_contact,
handle->remote_contact,
attrs,
&attr_array_out);
if (result != GLOBUS_SUCCESS)
{
goto post_accept_fail;
}
if (attr_array_out)
{
globus_net_manager_attr_array_delete(handle->attr->attr_array);
handle->attr->attr_array = attr_array_out;
attr_array_out = NULL;
result = globus_l_xio_net_manager_transport_handle_apply(
handle, op, attr_array_out);
if (result != GLOBUS_SUCCESS)
{
goto attr_apply_fail;
}
}
attr_apply_fail:
post_accept_fail:
globus_net_manager_attr_array_delete(attr_array_out);
globus_net_manager_attr_array_delete(attrs);
array_from_string_fail:
free(string_opts);
if (result)
{
get_string_opts_fail:
globus_l_xio_net_manager_attr_destroy(handle->attr);
free(handle->remote_contact);
get_remote_contact_fail:
free(handle->local_contact);
free(handle);
handle = NULL;
}
malloc_handle_fail:
no_link:
failed_accept:
globus_xio_driver_finished_open(handle, op, result);
}
static
void
globus_l_xio_net_manager_connect_callback(
globus_xio_operation_t op,
globus_result_t result,
void * user_arg)
{
globus_l_xio_net_manager_handle_t *handle = user_arg;
globus_net_manager_attr_t *transport_opts = NULL,
*new_transport_opts = NULL;
globus_xio_driver_handle_t driver_handle =
globus_xio_operation_get_driver_handle(op);
if (handle == NULL)
{
goto no_handle;
}
if (result)
{
goto failed_open;
}
/* Connect-side, call post-connect */
result = globus_l_xio_net_manager_get_attr_array(
op,
handle->transport_driver,
handle->transport_name,
&transport_opts);
if (result)
{
goto get_transport_opts_fail;
}
result = globus_xio_driver_handle_cntl(
driver_handle,
handle->transport_driver,
GLOBUS_XIO_GET_LOCAL_NUMERIC_CONTACT,
&handle->local_contact);
if (result)
{
goto get_local_contact_fail;
}
result = globus_net_manager_context_post_connect(
handle->attr->context,
handle->attr->task_id ? handle->attr->task_id : "unset",
handle->transport_name,
handle->local_contact,
handle->remote_contact,
transport_opts,
&new_transport_opts);
if (result)
{
goto post_connect_fail;
}
if (new_transport_opts)
{
result = globus_l_xio_net_manager_transport_handle_apply(
handle, op, new_transport_opts);
}
globus_net_manager_attr_array_delete(new_transport_opts);
if (result)
{
post_connect_fail:
free(handle->remote_contact);
free(handle->local_contact);
}
get_local_contact_fail:
globus_net_manager_attr_array_delete(transport_opts);
get_transport_opts_fail:
failed_open:
if (result)
{
globus_l_xio_net_manager_attr_destroy(handle->attr);
free(handle);
handle = NULL;
}
no_handle:
globus_xio_driver_finished_open(handle, op, result);
}
