static void s_key_destructor_func( void * value) { globus_object_free((globus_object_t *) value); }
/** * Allocate and initialize an error of type GLOBUS_ERROR_TYPE_GSSAPI * @ingroup globus_gssapi_error_object * * @param base_source * Pointer to the originating module. * @param base_cause * The error object causing the error. If this is the original * error, this paramater may be NULL. * @param major_status * The GSSAPI major status * @param minor_status * The GSSAPI minor status * @return * The resulting error object. It is the user's responsibility * to eventually free this object using globus_object_free(). A * globus_result_t may be obtained by calling * globus_error_put() on this object. */ globus_object_t * globus_error_construct_gssapi_error( globus_module_descriptor_t * base_source, globus_object_t * base_cause, const OM_uint32 major_status, const OM_uint32 minor_status) { globus_object_t * error; globus_object_t * newerror; newerror = globus_object_construct(GLOBUS_ERROR_TYPE_GSSAPI); error = globus_error_initialize_gssapi_error( newerror, base_source, base_cause, major_status, minor_status); if (error == NULL) { globus_object_free(newerror); } return error; }/* globus_error_construct_gssapi_error() */
/** * This function destroys a globus_gsi_callback_data_t. * @ingroup globus_gsi_callback_data * * @param callback_data * The structure to be destroyed * * @return * GLOBUS_SUCCESS unless an error occurred, in which case, * a globus error object ID is returned */ globus_result_t globus_gsi_callback_data_destroy( globus_gsi_callback_data_t callback_data) { globus_result_t result = GLOBUS_SUCCESS; static char * _function_name_ = "globus_gsi_callback_data_destroy"; GLOBUS_I_GSI_CALLBACK_DEBUG_ENTER; if(!callback_data) { goto exit; } if(callback_data->cert_chain) { sk_X509_pop_free(callback_data->cert_chain, X509_free); } if(callback_data->cert_dir) { globus_libc_free(callback_data->cert_dir); } /* extension_oids have to be free independantly */ globus_object_free(globus_error_get(callback_data->error)); globus_libc_free(callback_data); exit: GLOBUS_I_GSI_CALLBACK_DEBUG_EXIT; return result; }
static void restart_marker_plugin_get_cb( globus_ftp_client_plugin_t * plugin, void * plugin_specific, globus_ftp_client_handle_t * handle, const char * url, const globus_ftp_client_operationattr_t * attr, globus_bool_t restart) { restart_marker_plugin_info_t * ps; ps = (restart_marker_plugin_info_t *) plugin_specific; if(ps->error_obj) { globus_object_free(ps->error_obj); ps->error_obj = GLOBUS_NULL; } if(ps->error_url) { globus_libc_free(ps->error_url); ps->error_url = GLOBUS_NULL; } if(restart) { /* we have been restarted.. previous fault disregarded */ return; } ps->use_data = GLOBUS_TRUE; ps->last_time = 0; if(ps->begin_cb) { restart = ps->begin_cb( ps->user_arg, handle, url, GLOBUS_NULL, &ps->restart_marker); } if(restart) { globus_ftp_client_plugin_restart_get( handle, url, attr, &ps->restart_marker, GLOBUS_NULL); } else { globus_ftp_client_restart_marker_init(&ps->restart_marker); } }
static void s_base_instance_destructor (void *instance_datavp) { globus_error_base_instance_t * instance_data; instance_data = ((globus_error_base_instance_t *) instance_datavp); if ( instance_data!=NULL ) { globus_object_free (instance_data->causal_error); globus_free (instance_data); } }
void globus_print_error( globus_result_t error_result) { globus_object_t * error_obj = NULL; char * error_string = NULL; error_obj = globus_error_get(error_result); error_string = globus_error_print_chain(error_obj); globus_libc_fprintf(stderr, "%s\n", error_string); globus_libc_free(error_string); globus_object_free(error_obj); }
/** * Allocate and initialize an error of type GLOBUS_ERROR_TYPE_GLOBUS * which contains a causal error of type GLOBUS_ERROR_TYPE_GSSAPI. * @ingroup globus_gssapi_error_utility * * @param base_source * Pointer to the originating module. * @param major_status * The major status to use when generating the causal error. * @param minor_status * The minor status to use when generating the causal error. * @param type * The error type. We may reserve part of this namespace for * common errors. Errors not in this space are assumed to be * local to the originating module. * @param source_file * Name of file. Use __FILE__ * @param source_func * Name of function. Use _globus_func_name and declare your func with * GlobusFuncName(<name>) * @param source_line * Line number. Use __LINE__ * @param short_desc_format * Short format string giving a succinct description * of the error. To be passed on to the user. * @param ... * Arguments for the format string. * @return * The resulting error object. It is the user's responsibility * to eventually free this object using globus_object_free(). A * globus_result_t may be obtained by calling * globus_error_put() on this object. */ globus_object_t * globus_error_wrap_gssapi_error( globus_module_descriptor_t * base_source, OM_uint32 major_status, OM_uint32 minor_status, int type, const char * source_file, const char * source_func, int source_line, const char * short_desc_format, ...) { globus_object_t * causal_error; globus_object_t * error; va_list ap; causal_error = globus_error_construct_gssapi_error( GLOBUS_GSI_GSSAPI_MODULE, NULL, major_status, minor_status); if(!causal_error) { return GLOBUS_NULL; } va_start(ap, short_desc_format); error = globus_error_v_construct_error( base_source, causal_error, type, source_file, source_func, source_line, short_desc_format, ap); va_end(ap); if(error == GLOBUS_NULL) { globus_object_free(causal_error); } return error; }/* globus_error_wrap_gssapi_error */
void test_monitor_reset( test_monitor_t * monitor) { globus_mutex_lock(&monitor->mutex); if(monitor->err) { globus_object_free(monitor->err); monitor->err = GLOBUS_NULL; } monitor->use_err = GLOBUS_FALSE; monitor->done = GLOBUS_FALSE; globus_mutex_unlock(&monitor->mutex); }
globus_result_t globus_ftp_client_restart_marker_plugin_destroy( globus_ftp_client_plugin_t * plugin) { globus_result_t result; restart_marker_plugin_info_t * ps; GlobusFuncName(globus_ftp_client_restart_marker_plugin_destroy); if(plugin == GLOBUS_NULL) { return globus_error_put(globus_error_construct_string( GLOBUS_FTP_CLIENT_MODULE, GLOBUS_NULL, "[%s] NULL plugin at %s\n", GLOBUS_FTP_CLIENT_MODULE->module_name, _globus_func_name)); } result = globus_ftp_client_plugin_get_plugin_specific( plugin, (void **) (void *) &ps); if(result != GLOBUS_SUCCESS) { return result; } if(ps->error_obj) { globus_object_free(ps->error_obj); ps->error_obj = GLOBUS_NULL; } if(ps->error_url) { globus_libc_free(ps->error_url); ps->error_url = GLOBUS_NULL; } globus_mutex_destroy(&ps->lock); globus_free(ps); return globus_ftp_client_plugin_destroy(plugin); }
globus_object_t * globus_error_construct_base (globus_module_descriptor_t * source_module, globus_object_t * causal_error) { globus_object_t * newerror; globus_object_t * initerror; newerror = globus_object_construct (GLOBUS_ERROR_TYPE_BASE); initerror = globus_error_initialize_base (newerror, source_module, causal_error); if ( initerror == NULL ) { if ( newerror != NULL ) { globus_object_free (newerror); } } return initerror; }
static int s_error_cache_destroy (void) { globus_object_t * cached; cached = (globus_object_t *) globus_thread_getspecific(s_peek_key); if(cached) { globus_object_free(cached); } globus_thread_key_delete(s_peek_key); globus_thread_key_delete(globus_i_error_verbose_key); globus_object_cache_destroy (&s_result_to_object_mapper); local_mutex_destroy (&s_result_to_object_mutex); s_error_cache_initialized = 0; globus_module_deactivate(GLOBUS_OBJECT_MODULE); return GLOBUS_SUCCESS; }
globus_object_t * globus_error_peek( globus_result_t result) { globus_object_t * error; int err; if (! s_error_cache_initialized ) return NULL; if ( result == GLOBUS_SUCCESS ) return NULL; err = local_mutex_lock (&s_result_to_object_mutex); if (err) return NULL; error = globus_object_cache_lookup (&s_result_to_object_mapper, (void *) (intptr_t) result); if (error!=NULL) { globus_object_t * cached; globus_object_reference(error); cached = (globus_object_t *) globus_thread_getspecific(s_peek_key); if(cached) { globus_object_free(cached); } globus_thread_setspecific(s_peek_key, error); } local_mutex_unlock (&s_result_to_object_mutex); if (error!=NULL) return error; else return GLOBUS_ERROR_NO_INFO; }
/* * Function: main * * Description: * * Parameters: * * Returns: */ int main(int argc, char **argv) { int rc; globus_result_t result; globus_object_t * error = NULL; char * errstring; globus_io_handle_t handle; globus_io_handle_t stdout_handle; globus_size_t bytes; globus_size_t i; globus_byte_t buf[1024]; #ifdef TARGET_ARCH_WIN32 HANDLE outputFile; globus_io_handle_t write_handle; if ( argc < 3 ) { usage( argv[0] ); return -1; } #endif globus_module_activate(GLOBUS_COMMON_MODULE); globus_module_activate(GLOBUS_IO_MODULE); #ifndef TARGET_ARCH_WIN32 result = globus_io_file_open("/etc/group", O_RDONLY, 0600, GLOBUS_NULL, &handle); #else result = globus_io_file_open( argv[1], O_RDONLY, 0600, GLOBUS_NULL, &handle); #endif if(result != GLOBUS_SUCCESS) { error = globus_error_get(result); errstring = globus_object_printable_to_string(error); #ifndef TARGET_ARCH_WIN32 globus_libc_printf("test failed to open /etc/group: %s\n", errstring); #else globus_libc_printf("test failed to open %s: %s\n", argv[1], errstring); #endif goto done; } #ifndef TARGET_ARCH_WIN32 result = globus_io_file_posix_convert( fileno(stdout), GLOBUS_NULL, &stdout_handle); #else outputFile= CreateFile( argv[2], GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_FLAG_OVERLAPPED, NULL ); if ( outputFile == INVALID_HANDLE_VALUE ) { printf( "An error occurred while trying to create the output file (error is %d)...exiting\n", GetLastError() ); return -1; } result= globus_io_file_windows_convert( outputFile, GLOBUS_NULL, &write_handle); #endif if(result != GLOBUS_SUCCESS) { error = globus_error_get(result); errstring = globus_object_printable_to_string(error); globus_libc_printf("test failed to convert stdout to io handle: %s\n", errstring); goto done; } do { result = globus_io_read(&handle, buf, sizeof(buf), sizeof(buf), &bytes); if(result == GLOBUS_SUCCESS || ((error = globus_error_get(result)) && (globus_object_type_match(globus_object_get_type(error), GLOBUS_IO_ERROR_TYPE_EOF)))) { globus_size_t nbytes2; #ifndef TARGET_ARCH_WIN32 globus_io_write(&stdout_handle, buf, bytes, &nbytes2); #else globus_io_write( &write_handle, buf, bytes, &nbytes2); #endif } else { errstring = globus_object_printable_to_string(error); globus_libc_printf("test failed to read /etc/group: %s\n", errstring); goto done; } } while(result == GLOBUS_SUCCESS); done: if(error) { globus_object_free(error); } globus_io_close(&handle); #ifndef TARGET_ARCH_WIN32 globus_io_close(&stdout_handle); #else globus_io_close( &write_handle); #endif globus_module_deactivate(GLOBUS_IO_MODULE); globus_module_deactivate(GLOBUS_COMMON_MODULE); return 0; }
/** * Dereference a request handle. * * This function decreases the reference count on an GASS Transfer * request handle. If the reference count becomes zero, then the * #globus_gass_transfer_request_struct_t associated with the handle * is destroyed. * * @note This function must be called with the request handle mutex locked. * * @param request * The request to destroy. * * @retval GLOBUS_SUCCESS * The request handle's reference count was decremented. The request * structure is freed if this was the final reference to the handle. * @retval GLOBUS_GASS_TRANSFER_ERROR_INVALID_USE * The request handle was not valid. * @see globus_gass_transfer_request_destroy() */ int globus_i_gass_transfer_request_destroy( globus_gass_transfer_request_t request) { globus_bool_t referenced; globus_gass_transfer_request_struct_t * req; req = globus_handle_table_lookup(&globus_i_gass_transfer_request_handles, request); if(req == GLOBUS_NULL) { return GLOBUS_GASS_TRANSFER_ERROR_INVALID_USE; } referenced = globus_handle_table_decrement_reference(&globus_i_gass_transfer_request_handles, request); if(!referenced) { int i; globus_list_t * tmp; tmp = globus_list_search(globus_i_gass_transfer_requests, (void *) (intptr_t) request); #if DEBUG_GASS_TRANSFER printf(_GTSL("removing from list\n")); #endif if (tmp) { globus_list_remove(&globus_i_gass_transfer_requests, tmp); globus_cond_signal(&globus_i_gass_transfer_shutdown_cond); if(req->attr) { globus_object_free(req->attr); } globus_fifo_destroy(&req->pending_data); if (req->url) { globus_free(req->url); } /* free referral */ for(i = 0; i < req->referral_count; i++) { globus_free(req->referral_url[i]); } if(req->referral_url) { globus_free(req->referral_url); } req->referral_url = GLOBUS_NULL; req->referral_count = 0; /* free deny message */ if(req->denial_message) { globus_free(req->denial_message); } /* free subject name */ if(req->subject) { globus_free(req->subject); } globus_free(req); request = GLOBUS_NULL_HANDLE; } return GLOBUS_SUCCESS; } else { return GLOBUS_SUCCESS; } }
int main() { OM_uint32 init_maj_stat; OM_uint32 accept_maj_stat; OM_uint32 maj_stat; OM_uint32 min_stat; OM_uint32 ret_flags; OM_uint32 req_flags = 0; OM_uint32 time_rec; gss_buffer_desc send_tok; gss_buffer_desc recv_tok; gss_buffer_desc * token_ptr; gss_OID mech_type; gss_name_t target_name; gss_ctx_id_t init_context; gss_ctx_id_t accept_context; gss_ctx_id_t del_init_context; gss_ctx_id_t del_accept_context; gss_cred_id_t delegated_cred; gss_cred_id_t imported_cred; gss_cred_id_t cred_handle; char * error_str; globus_result_t result; globus_gsi_cert_utils_cert_type_t cert_type; int rc = EXIT_SUCCESS; printf("1..1\n"); /* Activate Modules */ globus_module_activate(GLOBUS_GSI_GSSAPI_MODULE); /* Initialize variables */ token_ptr = GSS_C_NO_BUFFER; init_context = GSS_C_NO_CONTEXT; accept_context = GSS_C_NO_CONTEXT; del_init_context = GSS_C_NO_CONTEXT; del_accept_context = GSS_C_NO_CONTEXT; delegated_cred = GSS_C_NO_CREDENTIAL; accept_maj_stat = GSS_S_CONTINUE_NEEDED; ret_flags = 0; req_flags |= GSS_C_GLOBUS_LIMITED_DELEG_PROXY_FLAG; /* acquire the credential */ maj_stat = gss_acquire_cred(&min_stat, NULL, GSS_C_INDEFINITE, GSS_C_NO_OID_SET, GSS_C_BOTH, &cred_handle, NULL, NULL); if(maj_stat != GSS_S_COMPLETE) { globus_gsi_gssapi_test_print_error(stderr, maj_stat, min_stat); rc = EXIT_FAILURE; goto fail; } /* get the subject name */ maj_stat = gss_inquire_cred(&min_stat, cred_handle, &target_name, NULL, NULL, NULL); if(maj_stat != GSS_S_COMPLETE) { globus_gsi_gssapi_test_print_error(stderr, maj_stat, min_stat); rc = EXIT_FAILURE; goto fail; } /* set up the first security context */ init_maj_stat = gss_init_sec_context(&min_stat, cred_handle, &init_context, target_name, GSS_C_NULL_OID, 0, 0, GSS_C_NO_CHANNEL_BINDINGS, token_ptr, NULL, &send_tok, NULL, NULL); if(init_maj_stat != GSS_S_CONTINUE_NEEDED) { globus_gsi_gssapi_test_print_error(stderr, init_maj_stat, min_stat); rc = EXIT_FAILURE; goto fail; } while(1) { accept_maj_stat=gss_accept_sec_context(&min_stat, &accept_context, GSS_C_NO_CREDENTIAL, &send_tok, GSS_C_NO_CHANNEL_BINDINGS, NULL, &mech_type, &recv_tok, &ret_flags, /* ignore time_rec */ NULL, NULL); if(accept_maj_stat != GSS_S_COMPLETE && accept_maj_stat != GSS_S_CONTINUE_NEEDED) { globus_gsi_gssapi_test_print_error(stderr, accept_maj_stat, min_stat); rc = EXIT_FAILURE; goto fail; } else if(accept_maj_stat == GSS_S_COMPLETE) { break; } init_maj_stat = gss_init_sec_context(&min_stat, GSS_C_NO_CREDENTIAL, &init_context, target_name, GSS_C_NULL_OID, 0, 0, GSS_C_NO_CHANNEL_BINDINGS, &recv_tok, NULL, &send_tok, NULL, NULL); if(init_maj_stat != GSS_S_COMPLETE && init_maj_stat != GSS_S_CONTINUE_NEEDED) { globus_gsi_gssapi_test_print_error(stderr, init_maj_stat, min_stat); rc = EXIT_FAILURE; goto fail; } } printf("# %s:%d: Successfully established initial security context\n", __FILE__, __LINE__); /* delegate our credential over the initial security context and * insert a restriction extension into the delegated credential. * This is a post GT 2.0 feature. */ init_maj_stat = gss_init_delegation(&min_stat, init_context, cred_handle, GSS_C_NO_OID, GSS_C_NO_OID_SET, GSS_C_NO_BUFFER_SET, token_ptr, req_flags, 0, &send_tok); if(init_maj_stat != GSS_S_COMPLETE && init_maj_stat != GSS_S_CONTINUE_NEEDED) { globus_gsi_gssapi_test_print_error(stderr, init_maj_stat, min_stat); rc = EXIT_FAILURE; goto fail; } while(1) { accept_maj_stat=gss_accept_delegation(&min_stat, accept_context, GSS_C_NO_OID_SET, GSS_C_NO_BUFFER_SET, &send_tok, req_flags, 0, &time_rec, &delegated_cred, &mech_type, &recv_tok); if(accept_maj_stat != GSS_S_COMPLETE && accept_maj_stat != GSS_S_CONTINUE_NEEDED) { globus_gsi_gssapi_test_print_error(stderr, accept_maj_stat, min_stat); rc = EXIT_FAILURE; goto fail; } else if(accept_maj_stat == GSS_S_COMPLETE) { break; } init_maj_stat = gss_init_delegation(&min_stat, init_context, cred_handle, GSS_C_NO_OID, GSS_C_NO_OID_SET, GSS_C_NO_BUFFER_SET, &recv_tok, req_flags, 0, &send_tok); if(init_maj_stat != GSS_S_COMPLETE && init_maj_stat != GSS_S_CONTINUE_NEEDED) { globus_gsi_gssapi_test_print_error(stderr, init_maj_stat, min_stat); rc = EXIT_FAILURE; goto fail; } } printf("# %s:%d: Successfully delegated credential\n", __FILE__, __LINE__); /* export and import the delegated credential */ /* this can be done both to a buffer and to a file */ /* New in GT 2.0 */ maj_stat = gss_export_cred(&min_stat, delegated_cred, GSS_C_NO_OID, 0, &send_tok); if(maj_stat != GSS_S_COMPLETE) { globus_gsi_gssapi_test_print_error(stderr, maj_stat, min_stat); rc = EXIT_FAILURE; goto fail; } maj_stat = gss_import_cred(&min_stat, &imported_cred, GSS_C_NO_OID, 0, &send_tok, 0, &time_rec); if(maj_stat != GSS_S_COMPLETE) { globus_gsi_gssapi_test_print_error(stderr, maj_stat, min_stat); rc = EXIT_FAILURE; goto fail; } printf("# %s:%d: Successfully exported/imported the delegated credential\n", __FILE__, __LINE__); /* set up another security context using the delegated credential */ init_maj_stat = gss_init_sec_context(&min_stat, imported_cred, &del_init_context, target_name, GSS_C_NULL_OID, 0, 0, GSS_C_NO_CHANNEL_BINDINGS, token_ptr, NULL, &send_tok, NULL, NULL); if(init_maj_stat != GSS_S_COMPLETE && init_maj_stat != GSS_S_CONTINUE_NEEDED) { globus_gsi_gssapi_test_print_error(stderr, init_maj_stat, min_stat); rc = EXIT_FAILURE; goto fail; } while(1) { accept_maj_stat=gss_accept_sec_context(&min_stat, &del_accept_context, imported_cred, &send_tok, GSS_C_NO_CHANNEL_BINDINGS, NULL, &mech_type, &recv_tok, &ret_flags, /* ignore time_rec */ NULL, NULL); if(accept_maj_stat != GSS_S_COMPLETE && accept_maj_stat != GSS_S_CONTINUE_NEEDED) { globus_gsi_gssapi_test_print_error(stderr, accept_maj_stat, min_stat); rc = EXIT_FAILURE; goto fail; } else if(accept_maj_stat == GSS_S_COMPLETE) { break; } init_maj_stat = gss_init_sec_context(&min_stat, imported_cred, &del_init_context, target_name, GSS_C_NULL_OID, 0, 0, GSS_C_NO_CHANNEL_BINDINGS, &recv_tok, NULL, &send_tok, NULL, NULL); if(init_maj_stat != GSS_S_COMPLETE && init_maj_stat != GSS_S_CONTINUE_NEEDED) { globus_gsi_gssapi_test_print_error(stderr, init_maj_stat, min_stat); rc = EXIT_FAILURE; goto fail; } } /* got sec context based on delegated cred now */ printf("# %s:%d: Successfully established security context with delegated credential\n", __FILE__, __LINE__); /* Verify that the delegated credential is a limited proxy */ result = globus_gsi_cred_get_cert_type( ((gss_cred_id_desc *)imported_cred)->cred_handle, &cert_type); if(result != GLOBUS_SUCCESS) { char * error_str; globus_object_t * error_obj; error_obj = globus_error_get(result); error_str = globus_error_print_chain(error_obj); fprintf(stderr, "%s", error_str); globus_libc_free(error_str); globus_object_free(error_obj); rc = EXIT_FAILURE; goto fail; } if (! GLOBUS_GSI_CERT_UTILS_IS_LIMITED_PROXY(cert_type)) { fprintf(stderr, "Invalid certificate type. Expected a limited proxy, got %d\n", (int) cert_type); rc = EXIT_FAILURE; goto fail; } fail: printf("%s gssapi_limited_delegation_test\n", (rc==EXIT_SUCCESS) ? "ok" : "not ok"); globus_module_deactivate_all(); exit(rc); }
globus_object_t * globus_i_ftp_client_wrap_ftp_error( globus_module_descriptor_t * base_source, int code, const char * message, int error_type, const char * source_file, const char * source_func, int source_line, const char * format, ...) { va_list ap; globus_object_t * error; globus_object_t * causal_error; globus_l_error_ftp_data_t * data; causal_error = globus_object_construct(GLOBUS_ERROR_TYPE_FTP); if(!causal_error) { goto error_object; } data = (globus_l_error_ftp_data_t *) globus_malloc(sizeof(globus_l_error_ftp_data_t)); if(!data) { goto error_data; } data->code = code; data->message = globus_libc_strdup(message); globus_object_set_local_instance_data(causal_error, data); globus_error_initialize_base(causal_error, base_source, NULL); va_start(ap, format); error = globus_error_v_construct_error( base_source, causal_error, error_type, source_file, source_func, source_line, format, ap); va_end(ap); if(!error) { goto error_construct; } return error; error_construct: error_data: globus_object_free(causal_error); error_object: return NULL; }
int main(int argc, char **argv) { globus_ftp_client_handle_t handle; globus_ftp_client_operationattr_t attr; globus_result_t result; globus_ftp_client_handleattr_t handle_attr; char * src; char * dst; LTDL_SET_PRELOADED_SYMBOLS(); globus_module_activate(GLOBUS_FTP_CLIENT_MODULE); globus_ftp_client_handleattr_init(&handle_attr); globus_mutex_init(&lock, GLOBUS_NULL); globus_cond_init(&cond, GLOBUS_NULL); globus_ftp_client_operationattr_init(&attr); test_parse_args(argc, argv, &handle_attr, &attr, &src, &dst); globus_ftp_client_handle_init(&handle, &handle_attr); done = GLOBUS_FALSE; result = globus_ftp_client_third_party_transfer(&handle, src, &attr, dst, &attr, GLOBUS_NULL, done_cb, 0); if(result != GLOBUS_SUCCESS) { globus_object_t * err; char * tmpstr; err = globus_error_get(result); tmpstr = globus_object_printable_to_string(err); fprintf(stderr, "Error: %s", tmpstr); globus_object_free(err); globus_libc_free(tmpstr); error = GLOBUS_TRUE; done = GLOBUS_TRUE; } globus_mutex_lock(&lock); while(!done) { globus_cond_wait(&cond, &lock); } globus_mutex_unlock(&lock); globus_ftp_client_handle_destroy(&handle); globus_module_deactivate_all(); if(test_abort_count && error) { return 0; } return error; }
static void restart_marker_plugin_transfer_cb( globus_ftp_client_plugin_t * plugin, void * plugin_specific, globus_ftp_client_handle_t * handle, const char * source_url, const globus_ftp_client_operationattr_t * source_attr, const char * dest_url, const globus_ftp_client_operationattr_t * dest_attr, globus_bool_t restart) { restart_marker_plugin_info_t * ps; ps = (restart_marker_plugin_info_t *) plugin_specific; if(ps->error_obj) { globus_object_free(ps->error_obj); ps->error_obj = GLOBUS_NULL; } if(ps->error_url) { globus_libc_free(ps->error_url); ps->error_url = GLOBUS_NULL; } if(restart) { /* we have been restarted.. previous fault disregarded */ return; } ps->use_data = GLOBUS_FALSE; if(ps->begin_cb) { restart = ps->begin_cb( ps->user_arg, handle, source_url, dest_url, &ps->restart_marker); } if(restart) { globus_ftp_client_plugin_restart_third_party_transfer( handle, source_url, source_attr, dest_url, dest_attr, &ps->restart_marker, GLOBUS_NULL); } else { globus_ftp_client_restart_marker_init(&ps->restart_marker); } }
void test2(void) { globus_result_t result; globus_object_t * err; test_monitor_t monitor; globus_io_handle_t handle; globus_size_t bytes_read; char buf[6]; struct iovec iov[6]; test_monitor_initialize(&monitor, GLOBUS_NULL); /* simple connection to known services with read and write */ result = globus_io_tcp_connect( "antares.mcs.anl.gov", 25, GLOBUS_NULL, &handle); if(result != GLOBUS_SUCCESS) { globus_libc_printf("test 1 failed connecting\n"); goto finish; } result = globus_io_read(&handle, test_buffer, test_buffer_size, 1, &bytes_read); if(result != GLOBUS_SUCCESS) { globus_libc_printf("test 1 failed reading\n"); goto finish; } else { globus_libc_printf("test 1 read message:\n%s\n", test_buffer); } buf[0]='q'; buf[1]='u'; buf[2]='i'; buf[3]='t'; buf[4]='\r'; buf[5]='\n'; iov[0].iov_base=buf; iov[0].iov_len=1; iov[1].iov_base=buf+1; iov[1].iov_len=1; iov[2].iov_base=buf+2; iov[2].iov_len=1; iov[3].iov_base=buf+3; iov[3].iov_len=1; iov[4].iov_base=buf+4; iov[4].iov_len=1; iov[5].iov_base=buf+5; iov[5].iov_len=1; result = globus_io_register_writev(&handle, iov, 6, test2_writev_callback, &monitor); if(result != GLOBUS_SUCCESS) { globus_mutex_lock(&monitor.mutex); monitor.err = globus_error_get(result); monitor.use_err = GLOBUS_TRUE; monitor.done = GLOBUS_TRUE; globus_mutex_unlock(&monitor.mutex); } globus_mutex_lock(&monitor.mutex); while(!monitor.done) { globus_cond_wait(&monitor.cond, &monitor.mutex); } globus_mutex_unlock(&monitor.mutex); if(monitor.use_err) { globus_libc_printf("test 1 failed writing\n"); globus_object_free(monitor.err); goto finish; } else { globus_libc_printf("test 1 wrote message:\n%s\n", test_buffer); } test_monitor_reset(&monitor); result = globus_io_register_read(&handle, test_buffer, test_buffer_size, 1, test1_read_callback, &monitor); if(result != GLOBUS_SUCCESS) { globus_mutex_lock(&monitor.mutex); monitor.err = globus_error_get(result); monitor.use_err = GLOBUS_TRUE; monitor.done = GLOBUS_TRUE; globus_mutex_unlock(&monitor.mutex); } globus_mutex_lock(&monitor.mutex); while(!monitor.done) { globus_cond_wait(&monitor.cond, &monitor.mutex); } globus_mutex_unlock(&monitor.mutex); if(monitor.use_err) { globus_libc_printf("test 1 failed reading\n"); globus_object_free(monitor.err); goto finish; } else { globus_libc_printf("test 1 read message:\n%s\n", test_buffer); } test_monitor_reset(&monitor); result = globus_io_close(&handle); if(result != GLOBUS_SUCCESS) { err = globus_error_get(result); globus_libc_printf("test 1 failed closing\n"); } globus_libc_printf("test 1 successful\n"); finish: test_monitor_destroy(&monitor); }
void test1(void) { globus_result_t result; globus_object_t * err; test_monitor_t monitor; globus_io_handle_t handle; test_monitor_initialize(&monitor, GLOBUS_NULL); /* simple connection to known services with read and write */ result = globus_io_tcp_register_connect( "localhost", 25, GLOBUS_NULL, test1_connect_callback, (void *) &monitor, &handle); if(result != GLOBUS_SUCCESS) { globus_mutex_lock(&monitor.mutex); monitor.err = globus_error_get(result); monitor.use_err = GLOBUS_TRUE; monitor.done = GLOBUS_TRUE; globus_mutex_unlock(&monitor.mutex); } globus_mutex_lock(&monitor.mutex); while(!monitor.done) { globus_cond_wait(&monitor.cond, &monitor.mutex); } globus_mutex_unlock(&monitor.mutex); if(monitor.use_err) { globus_libc_printf("test 1 failed connecting\n"); globus_object_free(monitor.err); goto finish; } test_monitor_reset(&monitor); result = globus_io_register_read(&handle, test_buffer, test_buffer_size, 1, test1_read_callback, &monitor); if(result != GLOBUS_SUCCESS) { globus_mutex_lock(&monitor.mutex); monitor.err = globus_error_get(result); monitor.use_err = GLOBUS_TRUE; monitor.done = GLOBUS_TRUE; globus_mutex_unlock(&monitor.mutex); } globus_mutex_lock(&monitor.mutex); while(!monitor.done) { globus_cond_wait(&monitor.cond, &monitor.mutex); } globus_mutex_unlock(&monitor.mutex); if(monitor.use_err) { globus_libc_printf("test 1 failed reading\n"); globus_object_free(monitor.err); goto finish; } else { globus_libc_printf("test 1 read message:\n%s\n", test_buffer); } test_monitor_reset(&monitor); globus_libc_sprintf((char *) test_buffer, "quit\n"); result = globus_io_register_write(&handle, test_buffer, strlen((char *) test_buffer), test1_write_callback, &monitor); if(result != GLOBUS_SUCCESS) { globus_mutex_lock(&monitor.mutex); monitor.err = globus_error_get(result); monitor.use_err = GLOBUS_TRUE; monitor.done = GLOBUS_TRUE; globus_mutex_unlock(&monitor.mutex); } globus_mutex_lock(&monitor.mutex); while(!monitor.done) { globus_cond_wait(&monitor.cond, &monitor.mutex); } globus_mutex_unlock(&monitor.mutex); if(monitor.use_err) { globus_libc_printf("test 1 failed writing\n"); globus_object_free(monitor.err); goto finish; } else { globus_libc_printf("test 1 write message:\n%s\n", test_buffer); } test_monitor_reset(&monitor); result = globus_io_register_read(&handle, test_buffer, test_buffer_size, 1, test1_read_callback, &monitor); if(result != GLOBUS_SUCCESS) { globus_mutex_lock(&monitor.mutex); monitor.err = globus_error_get(result); monitor.use_err = GLOBUS_TRUE; monitor.done = GLOBUS_TRUE; globus_mutex_unlock(&monitor.mutex); } globus_mutex_lock(&monitor.mutex); while(!monitor.done) { globus_cond_wait(&monitor.cond, &monitor.mutex); } globus_mutex_unlock(&monitor.mutex); if(monitor.use_err) { globus_libc_printf("test 1 failed reading\n"); globus_object_free(monitor.err); goto finish; } else { globus_libc_printf("test 1 read message:\n%s\n", test_buffer); } test_monitor_reset(&monitor); result = globus_io_close(&handle); if(result != GLOBUS_SUCCESS) { err = globus_error_get(result); globus_libc_printf("test 1 failed closing\n"); } globus_libc_printf("test 1 successful\n"); finish: test_monitor_destroy(&monitor); }