globus_result_t
globus_error_put (globus_object_t * error)
{
globus_result_t new_result;
int err;
if (! s_error_cache_initialized || !error) return GLOBUS_SUCCESS;
err = local_mutex_lock (&s_result_to_object_mutex);
if (err) return GLOBUS_SUCCESS;
globus_i_error_output_error(error);
if ( globus_object_type_match (globus_object_get_type(error),
GLOBUS_ERROR_TYPE_BASE)
!= GLOBUS_TRUE ) {
error = GLOBUS_ERROR_NO_INFO;
}
do
{
new_result = s_next_available_result_count++;
} while(globus_object_cache_lookup(
&s_result_to_object_mapper, (void *) (intptr_t) new_result) != NULL);
globus_object_cache_insert (&s_result_to_object_mapper,
(void *) (intptr_t) new_result, error);
local_mutex_unlock (&s_result_to_object_mutex);
return new_result;
}
int
globus_error_ftp_error_get_code(
globus_object_t * error)
{
int code = 0;
globus_l_error_ftp_data_t * data;
do
{
if(globus_object_get_type(error) == GLOBUS_ERROR_TYPE_FTP)
{
data = (globus_l_error_ftp_data_t *)
globus_object_get_local_instance_data(error);
code = data->code;
}
} while(code == 0 && (error = globus_error_get_cause(error)));
return code;
}
globus_object_t *
globus_error_initialize_base (globus_object_t * error,
globus_module_descriptor_t * source_module,
globus_object_t * causal_error)
{
if ( (error == NULL) ||
(globus_object_is_static (error)
== GLOBUS_TRUE) ||
(globus_object_type_match (globus_object_get_type(error),
GLOBUS_ERROR_TYPE_BASE)
!= GLOBUS_TRUE) ) {
return NULL;
}
globus_error_base_set_source (error, source_module);
globus_error_base_set_cause (error, causal_error);
return error;
}
/**
* Check whether the error originated from a specific module and
* match a specific major status.
* @ingroup globus_gssapi_error_utility
*
* This function checks whether the error or any of it's causative
* errors originated from a specific module and contains a specific
* major status. If the module descriptor is left unspecified this
* function will check for any error of the specified major_status
* and vice versa.
*
* @param error
* The error object for which to perform the check
* @param module
* The module descriptor to check for
* @param major_status
* The major status to check for
* @return
* GLOBUS_TRUE - the error matched the module and major status
* GLOBUS_FALSE - the error failed to match the module and
* major status
*/
globus_bool_t
globus_error_gssapi_match(
globus_object_t * error,
globus_module_descriptor_t * module,
const OM_uint32 major_status)
{
globus_module_descriptor_t * source_module;
int current_major_status;
if(error == NULL)
{
return GLOBUS_FALSE;
}
if(globus_object_get_type(error) != GLOBUS_ERROR_TYPE_GSSAPI)
{
/* not our type, skip it */
return globus_error_gssapi_match(
globus_error_get_cause(error),
module,
major_status);
}
source_module = globus_error_get_source(error);
current_major_status = globus_error_gssapi_get_major_status(error);
if(source_module == module && current_major_status == major_status)
{
return GLOBUS_TRUE;
}
else
{
return globus_error_gssapi_match(
globus_error_get_cause(error),
module,
major_status);
}
}/* globus_error_gssapi_match */
/*
* 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;
}
/* default error strings for all types in the error hierarchy,
* which should be overridden w/ special code over time
*/
char *
globus_error_generic_string_func (globus_object_t * error)
{
char * string;
const globus_object_type_t * type;
type = globus_object_get_type (error);
if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_NO_CREDENTIALS)
== GLOBUS_TRUE ) {
string = _GCSL("no credentials were available");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_NO_TRUST)
== GLOBUS_TRUE ) {
string = _GCSL("no trust relationship exists");
}
else if ( globus_object_type_match (type,
GLOBUS_ERROR_TYPE_INVALID_CREDENTIALS)
== GLOBUS_TRUE ) {
string = _GCSL("the credentials were invalid");
}
else if ( globus_object_type_match (type,
GLOBUS_ERROR_TYPE_NO_AUTHENTICATION)
== GLOBUS_TRUE ) {
string = _GCSL("authentication failed");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_NO_AUTHORIZATION)
== GLOBUS_TRUE ) {
string = _GCSL("the operation was not authorized");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_OFFLINE)
== GLOBUS_TRUE ) {
string = _GCSL("the resource was offline");
}
else if ( globus_object_type_match (type,
GLOBUS_ERROR_TYPE_QUOTA_DEPLETED)
== GLOBUS_TRUE ) {
string = _GCSL("the resource quota was depleted");
}
else if ( globus_object_type_match (type,
GLOBUS_ERROR_TYPE_DEPLETED)
== GLOBUS_TRUE ) {
string = _GCSL("the resource was depleted");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_NOT_AVAILABLE)
== GLOBUS_TRUE ) {
string = _GCSL("the resource was not available");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_ACCESS_FAILED)
== GLOBUS_TRUE ) {
string = _GCSL("access failed");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_USER_CANCELLED)
== GLOBUS_TRUE ) {
string = _GCSL("the operation was cancelled by the user");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_INTERNAL_ERROR)
== GLOBUS_TRUE ) {
string = _GCSL("the operation was aborted due to an internal error");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_SYSTEM_ABORTED)
== GLOBUS_TRUE ) {
string = _GCSL("the operation was aborted by the system");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_ABORTED)
== GLOBUS_TRUE ) {
string = _GCSL("the operation was aborted");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_NULL_REFERENCE)
== GLOBUS_TRUE ) {
string = _GCSL("a NULL reference was encountered");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_TYPE_MISMATCH)
== GLOBUS_TRUE ) {
string = _GCSL("the data was not of the required type");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_NAME_UNKNOWN)
== GLOBUS_TRUE ) {
string = _GCSL("an unknown resource was encountered");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_BAD_FORMAT)
== GLOBUS_TRUE ) {
string = _GCSL("badly formatted data was encountered");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_TOO_LARGE)
== GLOBUS_TRUE ) {
string = _GCSL("the data was too large");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_TOO_SMALL)
== GLOBUS_TRUE ) {
string = _GCSL("the data was too small");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_OUT_OF_RANGE)
== GLOBUS_TRUE ) {
string = _GCSL("out-of-range data was encountered");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_BAD_DATA)
== GLOBUS_TRUE ) {
string = _GCSL("bad data was encountered");
}
else if ( globus_object_type_match (type,
GLOBUS_ERROR_TYPE_UNREACHABLE)
== GLOBUS_TRUE ) {
string = _GCSL("the destination was unreachable");
}
else if ( globus_object_type_match (type,
GLOBUS_ERROR_TYPE_PROTOCOL_MISMATCH)
== GLOBUS_TRUE ) {
string = _GCSL("no common protocol could be negotiated");
}
else if ( globus_object_type_match (type,
GLOBUS_ERROR_TYPE_PROTOCOL_VIOLATED)
== GLOBUS_TRUE ) {
string = _GCSL("the protocol was violated");
}
else if ( globus_object_type_match (type,
GLOBUS_ERROR_TYPE_COMMUNICATION_FAILED)
== GLOBUS_TRUE ) {
string = _GCSL("communication failed");
}
else if ( globus_object_type_match (type,
GLOBUS_ERROR_TYPE_ALREADY_REGISTERED)
== GLOBUS_TRUE ) {
string = _GCSL("the resource is already registered");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_ALREADY_CANCELLED)
== GLOBUS_TRUE ) {
string = _GCSL("a cancel was already issued");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_ALREADY_DONE)
== GLOBUS_TRUE ) {
string = _GCSL("the operation was already performed");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_NOT_INITIALIZED)
== GLOBUS_TRUE ) {
string = _GCSL("the mechanism was not initialized");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_INVALID_USE)
== GLOBUS_TRUE ) {
string = _GCSL("the use was invalid");
}
else if ( globus_object_type_match (type, GLOBUS_ERROR_TYPE_BASE)
== GLOBUS_TRUE ) {
string = _GCSL("an unknown error occurred");
}
else {
string = NULL;
}
return s_string_copy (string);
}
