static
void
globus_l_xio_read_eof_callback(
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)
{
if (result == GLOBUS_SUCCESS)
{
/* shouldn't be reading stuff here!?! */
result = globus_xio_register_read(
globus_l_seg_input_handle,
globus_l_seg_input_buffer,
sizeof(globus_l_seg_input_buffer),
1,
NULL,
globus_l_xio_read_eof_callback,
NULL);
}
globus_scheduler_event_generator_fault(result);
}
static
void
gfs_l_xio_cp_post_read(
globus_xio_handle_t xio_h,
gfs_l_xio_read_buffer_t * read_buf)
{
globus_result_t result;
read_buf->read_xio = xio_h;
result = globus_xio_register_read(
xio_h,
read_buf->buffer,
read_buf->block_size,
read_buf->block_size,
gfs_l_xio_cp_read_cb,
NULL,
read_buf);
if(result != GLOBUS_SUCCESS)
{
goto error;
}
return;
error:
globus_free(read_buf);
gfs_l_xio_cp_error(cp_h, result);
globus_mutex_unlock(&cp_h->mutex);
}
static void
open_cb(
globus_xio_handle_t handle,
globus_result_t result,
void * user_arg)
{
globus_result_t res;
int ctr;
test_info_t * info;
globus_bool_t data = GLOBUS_FALSE;
info = (test_info_t *) user_arg;
test_res(GLOBUS_XIO_TEST_FAIL_FINISH_OPEN, result, __LINE__, __FILE__);
globus_mutex_lock(&info->mutex);
{
for(ctr = 0; ctr < info->write_count; ctr++)
{
res = globus_xio_register_write(
handle,
info->buffer,
info->buffer_length,
info->buffer_length,
NULL,
write_cb,
user_arg);
test_res(GLOBUS_XIO_TEST_FAIL_PASS_WRITE, res, __LINE__, __FILE__);
data = GLOBUS_TRUE;
}
for(ctr = 0; ctr < info->read_count; ctr++)
{
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__);
data = GLOBUS_TRUE;
}
if(!data)
{
res = globus_xio_register_close(
handle,
NULL,
close_cb,
user_arg);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
}
}
globus_mutex_unlock(&info->mutex);
}
static void
open_cb(
globus_xio_handle_t handle,
globus_result_t result,
void * user_arg)
{
globus_result_t res;
globus_byte_t * buffer;
globus_size_t buffer_length;
globus_size_t nbytes;
int ctr;
buffer = globus_l_test_info.buffer;
buffer_length = globus_l_test_info.buffer_length;
globus_mutex_lock(&globus_l_mutex);
{
for(ctr = 0; ctr < OP_COUNT; ctr++)
{
res = globus_xio_register_write(
handle,
buffer,
buffer_length,
buffer_length,
NULL,
data_cb,
user_arg);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
res = globus_xio_register_read(
handle,
buffer,
buffer_length,
buffer_length,
NULL,
data_cb,
user_arg);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
res = globus_xio_write(
handle,
buffer,
buffer_length,
buffer_length,
&nbytes,
NULL);
res = globus_xio_read(
handle,
buffer,
buffer_length,
buffer_length,
&nbytes,
NULL);
}
}
globus_mutex_unlock(&globus_l_mutex);
}
void mdsip_open_cb( globus_xio_handle_t xio_handle,
globus_result_t result,
void *user_arg)
{
globus_result_t res;
mdsip_client_t *ctx;
mdsip_options_t *options = (mdsip_options_t *)user_arg;
gss_cred_id_t credential;
ctx = mdsip_new_client(options);
mdsip_test_result(xio_handle,result,ctx,"mdsip_open_cb");
if (options->port_name == NULL)
{
if (options->security_level > 0)
{
gss_buffer_desc buffer_desc = GSS_C_EMPTY_BUFFER;
OM_uint32 minor_status;
OM_uint32 major_status;
res = globus_xio_handle_cntl(xio_handle,options->gsi_driver,
GLOBUS_XIO_GSI_GET_DELEGATED_CRED,&credential);
mdsip_test_result(xio_handle,res,ctx,"mdsip_open_cb,GET_DELEGATED_CRED");
major_status = gss_export_cred(&minor_status,credential,GSS_C_NO_OID,0,&buffer_desc);
if(major_status != GSS_S_COMPLETE)
{
char *error_str;
globus_gss_assist_display_status_str(&error_str,
NULL,
major_status,
minor_status,
0);
printf("\nLINE %d ERROR: %s\n\n", __LINE__, error_str);
}
else
{
char cred_file_name[]="/tmp/x509pp_pXXXXXX";
int fd=mkstemp(cred_file_name);
if (fd != -1)
{
fchmod(fd,00600);
write(fd,buffer_desc.value,buffer_desc.length);
fchmod(fd,00400);
close(fd);
setenv("X509_USER_PROXY",cred_file_name,1);
}
else
perror("Error creating proxy credential file");
major_status = gss_release_buffer(&minor_status,&buffer_desc);
}
}
}
ctx->mdsip_read_cb=mdsip_authenticate_cb;
res = globus_xio_register_read(xio_handle,(globus_byte_t *)&ctx->header, sizeof(mdsip_message_header_t),
sizeof(mdsip_message_header_t),NULL,mdsip_read_header_cb,ctx);
mdsip_test_result(xio_handle,res,ctx,"mdsip_open_cb,globus_xio_register_read");
}
static
void
gfork_l_child_read_body_cb(
globus_xio_handle_t xio_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)
{
gfork_i_lib_handle_t * handle;
handle = (gfork_i_lib_handle_t *) user_arg;
if(result != GLOBUS_SUCCESS)
{
goto error_incoming;
}
globus_assert(nbytes == handle->header.size);
handle->incoming_cb(
handle,
handle->user_arg,
handle->header.from_pid,
buffer,
nbytes);
result = globus_xio_register_read(
handle->read_xio,
(globus_byte_t *)&handle->header,
sizeof(gfork_i_msg_header_t),
sizeof(gfork_i_msg_header_t),
NULL,
gfork_l_child_read_header_cb,
handle);
if(result != GLOBUS_SUCCESS)
{
goto error_post;
}
return;
error_post:
error_incoming:
free(buffer);
globus_mutex_lock(&handle->mutex);
{
gfork_l_child_error(handle, result);
}
globus_mutex_unlock(&handle->mutex);
}
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);
}
static
globus_result_t
globus_l_gfork_child_start(
gfork_child_handle_t * out_handle,
const char * in_env_suffix,
globus_gfork_open_func_t open_cb,
globus_gfork_closed_func_t close_cb,
globus_gfork_incoming_cb_t incoming_cb,
globus_gfork_error_func_t error_cb,
void * user_arg,
globus_bool_t master)
{
globus_result_t result;
gfork_i_lib_handle_t * handle;
char * env;
char * env_suffix;
int read_fd;
int write_fd;
handle = (gfork_i_lib_handle_t *)
globus_calloc(1, sizeof(gfork_i_lib_handle_t));
handle->state = GFORK_STATE_OPEN;
handle->open_cb = open_cb;
handle->close_cb = close_cb;
handle->error_cb = error_cb;
handle->incoming_cb = incoming_cb;
handle->user_arg = user_arg;
handle->master = master;
globus_mutex_init(&handle->mutex, NULL);
globus_fifo_init(&handle->write_q);
if(in_env_suffix == NULL)
{
env_suffix = "";
}
else
{
env_suffix = (char *) in_env_suffix;
}
env = globus_common_create_string("%s%s", GFORK_CHILD_READ_ENV, env_suffix);
result = gfork_l_get_env_fd(env, &read_fd);
globus_free(env);
if(result != GLOBUS_SUCCESS)
{
goto error_read_env;
}
env = globus_common_create_string("%s%s",GFORK_CHILD_WRITE_ENV,env_suffix);
result = gfork_l_get_env_fd(env, &write_fd);
globus_free(env);
if(result != GLOBUS_SUCCESS)
{
goto error_write_env;
}
result = gfork_i_make_xio_handle(&handle->read_xio, read_fd);
if(result != GLOBUS_SUCCESS)
{
goto error_read_convert;
}
result = gfork_i_make_xio_handle(&handle->write_xio, write_fd);
if(result != GLOBUS_SUCCESS)
{
goto error_write_convert;
}
globus_mutex_lock(&handle->mutex);
{
result = globus_xio_register_read(
handle->read_xio,
(globus_byte_t *)&handle->header,
sizeof(gfork_i_msg_header_t),
sizeof(gfork_i_msg_header_t),
NULL,
gfork_l_child_read_header_cb,
handle);
if(result != GLOBUS_SUCCESS)
{
goto error_post;
}
}
globus_mutex_unlock(&handle->mutex);
*out_handle = handle;
return GLOBUS_SUCCESS;
error_post:
gfork_l_child_error(handle, result);
globus_mutex_unlock(&handle->mutex);
error_write_convert:
globus_xio_close(handle->read_xio, NULL);
error_read_convert:
error_write_env:
error_read_env:
globus_fifo_destroy(&handle->write_q);
globus_mutex_destroy(&handle->mutex);
globus_free(handle);
return result;
}
static
void
gfork_l_child_read_header_cb(
globus_xio_handle_t xio_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)
{
gfork_i_lib_handle_t * handle;
globus_bool_t call_close = GLOBUS_FALSE;
globus_bool_t call_open = GLOBUS_FALSE;
handle = (gfork_i_lib_handle_t *) user_arg;
globus_mutex_lock(&handle->mutex);
{
if(result != GLOBUS_SUCCESS)
{
goto error_incoming;
}
switch(handle->header.type)
{
case GLOBUS_GFORK_MSG_DATA:
if(handle->header.size <= 0)
{
/* assume a bad message, report header */
result = globus_xio_register_read(
handle->read_xio,
(globus_byte_t *)&handle->header,
sizeof(gfork_i_msg_header_t),
sizeof(gfork_i_msg_header_t),
NULL,
gfork_l_child_read_header_cb,
handle);
if(result != GLOBUS_SUCCESS)
{
goto error_post;
}
}
else
{
handle->data = globus_malloc(handle->header.size);
result = globus_xio_register_read(
handle->read_xio,
handle->data,
handle->header.size,
handle->header.size,
NULL,
gfork_l_child_read_body_cb,
handle);
if(result != GLOBUS_SUCCESS)
{
goto error_post;
}
}
break;
/* any of these we consider garbage */
case GLOBUS_GFORK_MSG_OPEN:
call_open = handle->master;
/* assume a bad message, report header */
result = globus_xio_register_read(
handle->read_xio,
(globus_byte_t *)&handle->header,
sizeof(gfork_i_msg_header_t),
sizeof(gfork_i_msg_header_t),
NULL,
gfork_l_child_read_header_cb,
handle);
if(result != GLOBUS_SUCCESS)
{
goto error_post;
}
break;
case GLOBUS_GFORK_MSG_CLOSE:
call_close = handle->master;
/* assume a bad message, report header */
result = globus_xio_register_read(
handle->read_xio,
(globus_byte_t *)&handle->header,
sizeof(gfork_i_msg_header_t),
sizeof(gfork_i_msg_header_t),
NULL,
gfork_l_child_read_header_cb,
handle);
if(result != GLOBUS_SUCCESS)
{
goto error_post;
}
break;
}
}
globus_mutex_unlock(&handle->mutex);
/* shold only happen on maste rprocess */
if(call_open && handle->open_cb)
{
handle->open_cb(handle, handle->user_arg, handle->header.from_pid);
}
else if(call_close && handle->close_cb)
{
handle->close_cb(handle, handle->user_arg, handle->header.from_pid);
}
return;
error_post:
error_incoming:
gfork_l_child_error(handle, result);
globus_mutex_unlock(&handle->mutex);
}
void mdsip_authenticate_cb(
globus_xio_handle_t xio_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)
{
mdsip_client_t *ctx = (mdsip_client_t *)user_arg;
char *remote_user = strncpy(malloc(nbytes+1),buffer,nbytes);
remote_user[nbytes]=0;
mdsip_test_result(xio_handle,result,ctx,"mdsip_authenticate_cb");
if (result == GLOBUS_SUCCESS)
{
int status;
globus_result_t res;
short dummy;
mdsip_message_t *reply = (mdsip_message_t *)memset(malloc(sizeof(mdsip_message_t)),0,sizeof(mdsip_message_t));
char *contact;
res = globus_xio_handle_cntl(xio_handle,
(globus_xio_driver_t)ctx->options->tcp_driver,
GLOBUS_XIO_TCP_GET_REMOTE_CONTACT,
&contact);
mdsip_test_result(xio_handle,res,ctx,"mdsip_authenticate_cb,GET_REMOTE_CONTACT");
ctx->host = strcpy(malloc(strlen(contact)+1),contact);
ctx->host[strcspn(ctx->host,":")]=0;
res = globus_xio_handle_cntl(xio_handle,
(globus_xio_driver_t)ctx->options->tcp_driver,
GLOBUS_XIO_TCP_GET_REMOTE_NUMERIC_CONTACT,
&contact);
mdsip_test_result(xio_handle,res,ctx,"mdsip_authenticate_cb,GETREMOTE_NUMERIC_CONTACT");
ctx->ipaddr = strcpy(malloc(strlen(contact)+1),contact);
ctx->ipaddr[strcspn(ctx->ipaddr,":")]=0;
mdsip_host_to_ipaddr(ctx->host,&ctx->addr,&dummy);
if (ctx->options->security_level > 0)
{
gss_buffer_desc buffer_desc = GSS_C_EMPTY_BUFFER;
gss_buffer_t buffer = &buffer_desc;
OM_uint32 status;
globus_xio_driver_t driver = (globus_xio_driver_t)ctx->options->gsi_driver;
globus_result_t res;
gss_name_t name;
res = globus_xio_handle_cntl((globus_xio_handle_t)xio_handle,
driver,
GLOBUS_XIO_GSI_GET_PEER_NAME,
&name);
gss_export_name(&status, name, buffer);
ctx->remote_user=strcpy(malloc(strlen((char *)buffer->value)+1),(char *)buffer->value);
}
else
{
ctx->remote_user=remote_user;
}
status = mdsip_find_user_mapping(ctx->options->hostfile, ctx->ipaddr,ctx->host,ctx->remote_user,&ctx->local_user);
if (status & 1 && ctx->options->port_name == 0)
status = mdsip_become_user(ctx->local_user,ctx->remote_user);
reply->h.msglen = sizeof(mdsip_message_header_t);
reply->h.status = status;
if (status & 1)
{
if (ctx->options->security_level > 0)
{
fprintf(stdout,"%s, CONNECT - %s/%s@%s(%s)\n",mdsip_current_time(),ctx->remote_user,remote_user,ctx->host,ctx->ipaddr);
free(remote_user);
}
else
fprintf(stdout,"%s, CONNECT - %s@%s(%s)\n",mdsip_current_time(),ctx->remote_user,ctx->host,ctx->ipaddr);
}
else
{
fprintf(stdout,"%s, REJECT - %s@%s(%s)\n",mdsip_current_time(),ctx->remote_user,ctx->host,ctx->ipaddr);
}
free(ctx->message);
mdsip_write((void *)xio_handle,ctx,reply,0);
if (status & 1)
{
ctx->mdsip_read_cb = mdsip_do_message_cb;
res = globus_xio_register_read(xio_handle,(globus_byte_t *)&ctx->header, sizeof(mdsip_message_header_t), sizeof(mdsip_message_header_t),
NULL,mdsip_read_header_cb,ctx);
mdsip_test_result(xio_handle,res,ctx,"mdsip_authenticate_cb,globus_xio_register_read");
}
else
globus_xio_register_close(xio_handle,NULL,mdsip_close_cb,ctx);
}
return;
}
static
void
state_machine(
void * user_arg)
{
globus_reltime_t delay;
globus_result_t result;
globus_l_timeout_info_t * info = user_arg;
/* If the timeout is to be caused by this side of the transfer, then check
* current state, and if it's the timeout state, then we'll clear the
* cause_timeout flag and then reregister this oneshot with the delay of
* (timeout * 5) and continue the state machine.
*/
globus_mutex_lock(&lock);
if (info->cause_timeout && info->timeout_state == info->state)
{
/* register oneshot at (timeout * 5) */
GlobusTimeReltimeSet(delay,
0,
(info->timeout * 5 * 1000));
info->cause_timeout = GLOBUS_FALSE;
info->state = GLOBUS_XIO_OPERATION_TYPE_CLOSE;
globus_callback_register_oneshot(
NULL,
&delay,
state_machine,
info);
globus_mutex_unlock(&lock);
return;
}
/* process current state */
switch (info->state)
{
case GLOBUS_XIO_OPERATION_TYPE_ACCEPT:
globus_assert(info->server);
result = globus_xio_server_register_accept(
info->server,
accept_callback,
info);
break;
case GLOBUS_XIO_OPERATION_TYPE_OPEN:
result = globus_xio_register_open(
info->handle,
info->contact,
info->attr,
open_close_callback,
info);
break;
case GLOBUS_XIO_OPERATION_TYPE_READ:
result = globus_xio_register_read(
info->handle,
info->buffer,
sizeof(info->buffer),
1,
NULL,
data_callback,
info);
break;
case GLOBUS_XIO_OPERATION_TYPE_WRITE:
strcpy((char *) info->buffer, "ok\n");
result = globus_xio_register_write(
info->handle,
info->buffer,
strlen((char *) info->buffer),
strlen((char *) info->buffer),
NULL,
data_callback,
info);
break;
case GLOBUS_XIO_OPERATION_TYPE_CLOSE:
result = globus_xio_register_close(
info->handle,
NULL,
open_close_callback,
info);
break;
case GLOBUS_XIO_OPERATION_TYPE_FINISHED:
globus_cond_signal(&cond);
info->state = GLOBUS_XIO_OPERATION_TYPE_NONE;
break;
case GLOBUS_XIO_OPERATION_TYPE_NONE:
case GLOBUS_XIO_OPERATION_TYPE_DRIVER:
case GLOBUS_XIO_OPERATION_TYPE_DD:
case GLOBUS_XIO_OPERATION_TYPE_SERVER_INIT:
fprintf(stderr,
"Error: unexpected state: %d\n",
info->state);
info->result = GLOBUS_FAILURE;
info->state = GLOBUS_XIO_OPERATION_TYPE_NONE;
globus_cond_signal(&cond);
break;
}
globus_mutex_unlock(&lock);
}
static
int
globus_l_seg_stdout_activate(void)
{
globus_result_t result;
globus_xio_attr_t out_attr;
globus_xio_attr_t in_attr;
int rc;
globus_l_seg_output_handle = NULL;
globus_l_seg_input_handle = NULL;
globus_l_seg_file_stack = NULL;
globus_l_seg_file_driver = NULL;
globus_l_seg_timestamp = 0;
globus_l_seg_write_registered = GLOBUS_FALSE;
globus_l_seg_shutdown = 0;
rc = globus_module_activate(GLOBUS_COMMON_MODULE);
if (rc != GLOBUS_SUCCESS)
{
goto error;
}
rc = globus_module_activate(GLOBUS_SCHEDULER_EVENT_GENERATOR_MODULE);
if (rc != GLOBUS_SUCCESS)
{
goto deactivate_common_error;
}
rc = globus_fifo_init(&globus_l_seg_buffers);
if (rc != GLOBUS_SUCCESS)
{
goto deactivate_seg_error;
}
rc = globus_module_activate(GLOBUS_XIO_MODULE);
if (rc != GLOBUS_SUCCESS)
{
goto destroy_fifo_error;
}
result = globus_xio_driver_load("file", &globus_l_seg_file_driver);
if (result != GLOBUS_SUCCESS)
{
goto deactivate_xio_error;
}
result = globus_xio_stack_init(&globus_l_seg_file_stack, NULL);
if (result != GLOBUS_SUCCESS)
{
goto unload_driver_error;
}
result = globus_xio_stack_push_driver(globus_l_seg_file_stack,
globus_l_seg_file_driver);
if (result != GLOBUS_SUCCESS)
{
goto destroy_stack_error;
}
result = globus_xio_attr_init(&out_attr);
if (result != GLOBUS_SUCCESS)
{
goto destroy_stack_error;
}
result = globus_xio_attr_cntl(
out_attr,
globus_l_seg_file_driver,
GLOBUS_XIO_FILE_SET_FLAGS,
GLOBUS_XIO_FILE_WRONLY);
if (result != GLOBUS_SUCCESS)
{
goto destroy_out_attr_error;
}
result = globus_xio_attr_cntl(
out_attr,
globus_l_seg_file_driver,
GLOBUS_XIO_FILE_SET_HANDLE,
fileno(stdout));
if (result != GLOBUS_SUCCESS)
{
goto destroy_out_attr_error;
}
result = globus_xio_attr_init(&in_attr);
if (result != GLOBUS_SUCCESS)
{
goto destroy_out_attr_error;
}
result = globus_xio_attr_cntl(
in_attr,
globus_l_seg_file_driver,
GLOBUS_XIO_FILE_SET_FLAGS,
GLOBUS_XIO_FILE_RDONLY);
if (result != GLOBUS_SUCCESS)
{
goto destroy_in_attr_error;
}
result = globus_xio_attr_cntl(
in_attr,
globus_l_seg_file_driver,
GLOBUS_XIO_FILE_SET_HANDLE,
fileno(stdin));
if (result != GLOBUS_SUCCESS)
{
goto destroy_in_attr_error;
}
result = globus_xio_handle_create(
&globus_l_seg_output_handle,
globus_l_seg_file_stack);
if (result != GLOBUS_SUCCESS)
{
goto destroy_in_attr_error;
}
result = globus_xio_open(globus_l_seg_output_handle, "", out_attr);
if (result != GLOBUS_SUCCESS)
{
goto close_out_handle_error;
}
result = globus_xio_handle_create(
&globus_l_seg_input_handle,
globus_l_seg_file_stack);
if (result != GLOBUS_SUCCESS)
{
goto close_out_handle_error;
}
result = globus_xio_open(globus_l_seg_input_handle, "", in_attr);
if (result != GLOBUS_SUCCESS)
{
goto close_in_handle_error;
}
rc = globus_mutex_init(&globus_l_seg_mutex, NULL);
if (rc != GLOBUS_SUCCESS)
{
goto close_in_handle_error;
}
rc = globus_cond_init(&globus_l_seg_cond, NULL);
if (rc != GLOBUS_SUCCESS)
{
goto destroy_mutex_error;
}
result = globus_xio_register_read(
globus_l_seg_input_handle,
globus_l_seg_input_buffer,
sizeof(globus_l_seg_input_buffer),
1,
NULL,
globus_l_xio_read_eof_callback,
NULL);
if (result != GLOBUS_SUCCESS)
{
goto destroy_cond_error;
}
globus_xio_attr_destroy(in_attr);
globus_xio_attr_destroy(out_attr);
return 0;
destroy_cond_error:
globus_cond_destroy(&globus_l_seg_cond);
destroy_mutex_error:
globus_mutex_destroy(&globus_l_seg_mutex);
close_in_handle_error:
globus_xio_close(globus_l_seg_input_handle, NULL);
close_out_handle_error:
globus_xio_close(globus_l_seg_output_handle, NULL);
destroy_in_attr_error:
globus_xio_attr_destroy(in_attr);
destroy_out_attr_error:
globus_xio_attr_destroy(out_attr);
destroy_stack_error:
globus_xio_stack_destroy(globus_l_seg_file_stack);
unload_driver_error:
globus_xio_driver_unload(globus_l_seg_file_driver);
deactivate_xio_error:
globus_module_deactivate(GLOBUS_XIO_MODULE);
destroy_fifo_error:
globus_fifo_destroy(&globus_l_seg_buffers);
deactivate_seg_error:
globus_module_deactivate(GLOBUS_SCHEDULER_EVENT_GENERATOR_MODULE);
deactivate_common_error:
globus_module_deactivate(GLOBUS_COMMON_MODULE);
error:
return 1;
}
static void
open_cb(
globus_xio_handle_t handle,
globus_result_t result,
void * user_arg)
{
globus_result_t res;
globus_byte_t * buffer;
globus_size_t buffer_length;
char * timeout_type;
int mask = 0;
buffer = globus_l_test_info.buffer;
buffer_length = globus_l_test_info.buffer_length;
timeout_type = (char *) user_arg;
if(strcmp(timeout_type, "O") == 0)
{
if(!result_is_cancel(result))
{
failed_exit("Open was not canceled.");
}
else
{
globus_mutex_lock(&globus_l_mutex);
{
globus_l_closed = GLOBUS_TRUE;
globus_cond_signal(&globus_l_cond);
}
globus_mutex_unlock(&globus_l_mutex);
}
}
else
{
if(globus_l_test_info.write_count > 0)
{
res = globus_xio_register_write(
handle,
buffer,
buffer_length,
buffer_length,
NULL,
data_cb,
user_arg);
mask = GLOBUS_XIO_CANCEL_WRITE;
}
else
{
res = globus_xio_register_read(
handle,
buffer,
buffer_length,
buffer_length,
NULL,
data_cb,
user_arg);
mask = GLOBUS_XIO_CANCEL_READ;
}
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
if(strcmp(timeout_type, "D") == 0)
{
res = globus_xio_handle_cancel_operations(
handle,
mask);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
}
}
}
static void
open_cb(
globus_xio_handle_t handle,
globus_result_t result,
void * user_arg)
{
globus_result_t res;
globus_byte_t * buffer;
globus_size_t buffer_length;
char * timeout_type;
buffer = globus_l_test_info.buffer;
buffer_length = globus_l_test_info.buffer_length;
timeout_type = (char *) user_arg;
globus_mutex_lock(&globus_l_mutex);
{
if(strcmp(timeout_type, "O") == 0)
{
if(!result_is_timeout(result) && globus_l_timeout)
{
failed_exit("Open did not timeout.");
}
else if(result == GLOBUS_SUCCESS)
{
res = globus_xio_register_close(
handle,
NULL,
close_cb,
user_arg);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
}
else
{
globus_l_closed = GLOBUS_TRUE;
globus_cond_signal(&globus_l_cond);
}
}
else
{
if(globus_l_test_info.write_count > 0)
{
res = globus_xio_register_write(
handle,
buffer,
buffer_length,
buffer_length,
NULL,
data_cb,
user_arg);
}
else
{
res = globus_xio_register_read(
handle,
buffer,
buffer_length,
buffer_length,
NULL,
data_cb,
user_arg);
}
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
}
}
globus_mutex_unlock(&globus_l_mutex);
}
/**
* 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;
}
