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