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; }