public inbox for git-commits@fedoraproject.org
help / color / mirror / Atom feed
* [rpms/globus-common] rawhide: Fix compiler and doxygen warnings
@ 2026-06-14 8:45 Mattias Ellert
0 siblings, 0 replies; only message in thread
From: Mattias Ellert @ 2026-06-14 8:45 UTC (permalink / raw)
To: git-commits
A new commit has been pushed.
Repo : rpms/globus-common
Branch : rawhide
Commit : 8633960d1dffe8121fadc7f41b3edb9fe67dd119
Author : Mattias Ellert <mattias.ellert@physics.uu.se>
Date : 2026-06-14T10:39:12+02:00
Stats : +5512/-1 in 3 file(s)
URL : https://src.fedoraproject.org/rpms/globus-common/c/8633960d1dffe8121fadc7f41b3edb9fe67dd119?branch=rawhide
Log:
Fix compiler and doxygen warnings
---
diff --git a/0001-Untabify-and-remove-trailing-white-space.patch b/0001-Untabify-and-remove-trailing-white-space.patch
new file mode 100644
index 0000000..393c8bb
--- /dev/null
+++ b/0001-Untabify-and-remove-trailing-white-space.patch
@@ -0,0 +1,5219 @@
+From 3ccdaa0236230bbcbcbf339e7dfdfaf23c10bd6f Mon Sep 17 00:00:00 2001
+From: Mattias Ellert <mattias.ellert@physics.uu.se>
+Date: Wed, 20 May 2026 00:15:37 +0200
+Subject: [PATCH 1/2] Untabify and remove trailing white-space
+
+---
+ common/source/library/globus_args.c | 368 +++---
+ common/source/library/globus_callback.h | 98 +-
+ common/source/library/globus_error_errno.c | 40 +-
+ common/source/library/globus_error_generic.c | 202 ++--
+ common/source/library/globus_libc.c | 1082 +++++++++---------
+ common/source/library/globus_logging.c | 40 +-
+ common/source/library/globus_module.c | 624 +++++-----
+ 7 files changed, 1227 insertions(+), 1227 deletions(-)
+
+diff --git a/common/source/library/globus_args.c b/common/source/library/globus_args.c
+index ca9ff24ba..fab932f3f 100644
+--- a/common/source/library/globus_args.c
++++ b/common/source/library/globus_args.c
+@@ -33,34 +33,34 @@
+
+ /* ----------------------------------------------------------------------
+ globus_l_args_create_msg()
+-
++
+ creates (and possibly prints) a message
+ ---------------------------------------------------------------------- */
+
+ int
+ globus_l_args_create_msg( char ** msg_storage,
+- char * message )
++ char * message )
+ {
+ if (msg_storage)
+- *msg_storage = message;
++ *msg_storage = message;
+ else
+- globus_libc_fprintf( stderr, "%s", message );
++ globus_libc_fprintf( stderr, "%s", message );
+
+ return GLOBUS_SUCCESS;
+ }
+
+ /* ----------------------------------------------------------------------
+ globus_l_args_create_error_msg()
+-
++
+ creates (and possibly prints) an error message
+ ---------------------------------------------------------------------- */
+
+ int
+ globus_l_args_create_error_msg( char ** error_msg,
+- int current_argc,
+- char * current_argv,
+- char * error_string,
+- const char * oneline_usage )
++ int current_argc,
++ char * current_argv,
++ char * error_string,
++ const char * oneline_usage )
+ {
+ char * my_error_string;
+ char * p;
+@@ -78,15 +78,15 @@ globus_l_args_create_error_msg( char ** error_msg,
+ + strlen(my_error_string)
+ + strlen(oneline_usage)
+ + strlen(error_epilogue)
+- + 10;
++ + 10;
+
+ p = globus_l_args_malloc( char, len );
+ globus_assert( p );
+ globus_libc_sprintf( p,
+- error_format,
+- current_argc,
+- current_argv,
+- my_error_string );
++ error_format,
++ current_argc,
++ current_argv,
++ my_error_string );
+
+ usage_len = strlen( oneline_usage );
+
+@@ -95,11 +95,11 @@ globus_l_args_create_error_msg( char ** error_msg,
+ sprintf( &p[len+usage_len], "%s", error_epilogue );
+
+ if (error_msg)
+- *error_msg = p;
++ *error_msg = p;
+ else
+ {
+- globus_libc_fprintf( stderr, "%s", p );
+- free(p);
++ globus_libc_fprintf( stderr, "%s", p );
++ free(p);
+ }
+
+ return GLOBUS_SUCCESS;
+@@ -119,12 +119,12 @@ globus_l_args_create_error_msg( char ** error_msg,
+
+
+ int
+-globus_l_args_validate( globus_args_option_descriptor_t * option,
+- int start_argc,
+- char ** argv,
+- char *** values,
+- const char * oneline_usage,
+- char ** msg_storage )
++globus_l_args_validate( globus_args_option_descriptor_t * option,
++ int start_argc,
++ char ** argv,
++ char *** values,
++ const char * oneline_usage,
++ char ** msg_storage )
+ {
+ int rc;
+ int i;
+@@ -134,43 +134,43 @@ globus_l_args_validate( globus_args_option_descriptor_t * option,
+
+ *values = globus_l_args_malloc(char*, option->arity);
+ globus_assert(*values);
+-
++
+ rc = GLOBUS_SUCCESS;
+
+ for (i=0; !rc && i<option->arity; i++)
+ {
+- argp = argv[start_argc+1+i];
+- if (option->tests && option->tests[i] )
+- {
+- p = GLOBUS_NULL;
+- if ( option->test_parms && option->test_parms[i] )
+- p = option->test_parms[i];
+-
+- validation_error = GLOBUS_NULL;
+- rc = option->tests[i]( argp,
+- p,
+- &validation_error );
+-
+- /* API defines non-zero return as an error */
+- if (rc)
+- {
+- globus_l_args_create_error_msg( msg_storage,
+- start_argc+1+i,
+- argp,
+- validation_error,
+- oneline_usage );
+- continue;
+- }
+- } /* if */
+-
+- (*values)[i] = argp;
++ argp = argv[start_argc+1+i];
++ if (option->tests && option->tests[i] )
++ {
++ p = GLOBUS_NULL;
++ if ( option->test_parms && option->test_parms[i] )
++ p = option->test_parms[i];
++
++ validation_error = GLOBUS_NULL;
++ rc = option->tests[i]( argp,
++ p,
++ &validation_error );
++
++ /* API defines non-zero return as an error */
++ if (rc)
++ {
++ globus_l_args_create_error_msg( msg_storage,
++ start_argc+1+i,
++ argp,
++ validation_error,
++ oneline_usage );
++ continue;
++ }
++ } /* if */
++
++ (*values)[i] = argp;
+
+ } /* for */
+
+ if (rc)
+ {
+- free(*values);
+- rc = GLOBUS_FAILURE;
++ free(*values);
++ rc = GLOBUS_FAILURE;
+ }
+
+ return rc;
+@@ -180,15 +180,15 @@ globus_l_args_validate( globus_args_option_descriptor_t * option,
+
+ /* ---------------------------------------------------------------------
+ globus_l_args_add_instance()
+-
++
+ help function : creates an option instance and inserts in the fifo list.
+ */
+-
++
+
+ int
+ globus_l_args_add_instance( globus_fifo_t * fifo,
+- globus_args_option_descriptor_t * option,
+- char ** values )
++ globus_args_option_descriptor_t * option,
++ char ** values )
+ {
+ globus_args_option_instance_t * t;
+
+@@ -209,7 +209,7 @@ globus_l_args_add_instance( globus_fifo_t * fifo,
+ globus_l_args_check_options()
+
+ (7) The argument flags "-help", "-usage", "-version", and "-versions" are
+- reserved, and if they are detected the library will create an
++ reserved, and if they are detected the library will create an
+ appropriate message and signal an error.
+
+ */
+@@ -229,27 +229,27 @@ globus_l_args_check_options(
+
+ rc = GLOBUS_SUCCESS;
+ for (i=0; !rc && i<option_count; i++)
+- {
+- if (options[i].id_number == 0)
+- {
+- globus_l_args_create_msg( error_msg, ERRORID0 );
+- rc = GLOBUS_FAILURE;
+- }
+- else
+- {
+- for (alias=options[i].names; (*alias); alias++)
+- {
+- if (!strcmp(*alias, "-help") ||
+- !strcmp(*alias, "-usage") ||
+- !strcmp(*alias, "-version")||
+- !strcmp(*alias, "-versions"))
+- {
+- globus_l_args_create_msg( error_msg, ERROR7 );
+- rc = GLOBUS_FAILURE;
+- break;
+- }
+- }
+- }
++ {
++ if (options[i].id_number == 0)
++ {
++ globus_l_args_create_msg( error_msg, ERRORID0 );
++ rc = GLOBUS_FAILURE;
++ }
++ else
++ {
++ for (alias=options[i].names; (*alias); alias++)
++ {
++ if (!strcmp(*alias, "-help") ||
++ !strcmp(*alias, "-usage") ||
++ !strcmp(*alias, "-version")||
++ !strcmp(*alias, "-versions"))
++ {
++ globus_l_args_create_msg( error_msg, ERROR7 );
++ rc = GLOBUS_FAILURE;
++ break;
++ }
++ }
++ }
+ }
+
+ return rc;
+@@ -265,7 +265,7 @@ globus_l_args_check_options(
+
+ */
+
+-int
++int
+ globus_args_scan(
+ int * argc,
+ char *** argv,
+@@ -294,11 +294,11 @@ globus_args_scan(
+ globus_libc_lock();
+ if (!args_mutex_initialized)
+ {
+- globus_mutex_init(&args_mutex,
+- (globus_mutexattr_t *) GLOBUS_NULL);
+- args_mutex_initialized = GLOBUS_TRUE;
++ globus_mutex_init(&args_mutex,
++ (globus_mutexattr_t *) GLOBUS_NULL);
++ args_mutex_initialized = GLOBUS_TRUE;
+ }
+- globus_libc_unlock();
++ globus_libc_unlock();
+
+ globus_mutex_lock(&args_mutex);
+
+@@ -306,7 +306,7 @@ globus_args_scan(
+ globus_fifo_init(&fifo);
+ *options_found = GLOBUS_NULL;
+ if (error_msg)
+- *error_msg = GLOBUS_NULL;
++ *error_msg = GLOBUS_NULL;
+
+ /* precheck : are the options correct? */
+ rc = globus_l_args_check_options(option_count, options, error_msg);
+@@ -315,7 +315,7 @@ globus_args_scan(
+ my_argc=1;
+ while (!done)
+ {
+- /* any more options? */
++ /* any more options? */
+ if (my_argc == *argc)
+ {
+ done=GLOBUS_TRUE;
+@@ -327,7 +327,7 @@ globus_args_scan(
+
+ if (my_arg[0]!='-' || len<2)
+ {
+- /* unrecognized option */
++ /* unrecognized option */
+ done=GLOBUS_TRUE;
+ continue;
+ }
+@@ -345,11 +345,11 @@ globus_args_scan(
+ {
+ rc = GLOBUS_FAILURE;
+ globus_l_args_create_error_msg(
+- error_msg,
+- my_argc,
+- my_arg,
+- _GCSL("double-dashed option syntax is not allowed"),
+- oneline_usage );
++ error_msg,
++ my_argc,
++ my_arg,
++ _GCSL("double-dashed option syntax is not allowed"),
++ oneline_usage );
+ }
+ done = GLOBUS_TRUE;
+ continue;
+@@ -359,16 +359,16 @@ globus_args_scan(
+ if (!strcmp("-help",my_arg))
+ {
+ globus_l_args_create_msg( error_msg ,
+- (char *) long_usage );
+- rc = GLOBUS_ARGS_HELP;
++ (char *) long_usage );
++ rc = GLOBUS_ARGS_HELP;
+ done = GLOBUS_TRUE;
+ continue;
+ }
+ if(!strcmp("-usage",my_arg))
+ {
+ globus_l_args_create_msg( error_msg ,
+- (char *) oneline_usage );
+- rc = GLOBUS_ARGS_HELP;
++ (char *) oneline_usage );
++ rc = GLOBUS_ARGS_HELP;
+ done = GLOBUS_TRUE;
+ continue;
+ }
+@@ -379,26 +379,26 @@ globus_args_scan(
+ version,
+ stderr,
+ GLOBUS_FALSE);
+-
+- rc = GLOBUS_ARGS_VERSION;
++
++ rc = GLOBUS_ARGS_VERSION;
+ done = GLOBUS_TRUE;
+ continue;
+ }
+ if (!strcmp("-versions",my_arg))
+ {
+- globus_version_print(
++ globus_version_print(
+ name,
+ version,
+ stderr,
+ GLOBUS_TRUE);
+-
++
+ globus_module_print_activated_versions(stderr, GLOBUS_TRUE);
+-
+- rc = GLOBUS_ARGS_VERSION;
++
++ rc = GLOBUS_ARGS_VERSION;
+ done = GLOBUS_TRUE;
+ continue;
+ }
+-
++
+ /* is it a known flag? */
+ found=GLOBUS_FALSE;
+ for (i=0; !found && !rc && i<option_count; i++)
+@@ -414,27 +414,27 @@ globus_args_scan(
+ if (my_argc+options[i].arity >= *argc)
+ {
+ globus_l_args_create_error_msg(
+- error_msg,
+- my_argc,
+- my_arg,
+- _GCSL("not enough arguments"),
+- oneline_usage );
++ error_msg,
++ my_argc,
++ my_arg,
++ _GCSL("not enough arguments"),
++ oneline_usage );
+
+ rc = GLOBUS_FAILURE;
+ continue;
+ }
+
+- rc = globus_l_args_validate( &options[i],
+- my_argc,
+- (*argv),
+- &arglist,
+- oneline_usage,
+- error_msg );
++ rc = globus_l_args_validate( &options[i],
++ my_argc,
++ (*argv),
++ &arglist,
++ oneline_usage,
++ error_msg );
+ } /* if */
+
+ if (rc==GLOBUS_SUCCESS)
+ {
+- /* option successfully detected: add it */
++ /* option successfully detected: add it */
+ globus_l_args_add_instance( &fifo,
+ &options[i],
+ arglist );
+@@ -443,16 +443,16 @@ globus_args_scan(
+ } /* strcmp(my_arg,*alias)) */
+ } /* alias */
+ } /* i */
+- if (!found)
+- {
+- /* my_arg contains an unregistered option */
+- rc = GLOBUS_FAILURE;
+- globus_l_args_create_error_msg( error_msg,
+- my_argc,
+- my_arg,
+- _GCSL("unknown option"),
+- oneline_usage );
+- }
++ if (!found)
++ {
++ /* my_arg contains an unregistered option */
++ rc = GLOBUS_FAILURE;
++ globus_l_args_create_error_msg( error_msg,
++ my_argc,
++ my_arg,
++ _GCSL("unknown option"),
++ oneline_usage );
++ }
+ if (rc!=GLOBUS_SUCCESS)
+ {
+ done = GLOBUS_TRUE;
+@@ -462,20 +462,20 @@ globus_args_scan(
+
+ if (rc==GLOBUS_SUCCESS)
+ {
+- /* if successful, return number of options found */
+- rc = globus_fifo_size(&fifo);
++ /* if successful, return number of options found */
++ rc = globus_fifo_size(&fifo);
+ *options_found = globus_fifo_convert_to_list( &fifo );
+
+- /* modify argc/argv */
+- if (my_argc>1)
+- {
+- for (i = my_argc; i < *argc; i++)
+- (*argv)[i-my_argc+1] = (*argv)[i];
++ /* modify argc/argv */
++ if (my_argc>1)
++ {
++ for (i = my_argc; i < *argc; i++)
++ (*argv)[i-my_argc+1] = (*argv)[i];
+
+- *argc -= my_argc - 1;
+- }
++ *argc -= my_argc - 1;
++ }
+ }
+-
++
+ globus_fifo_destroy(&fifo);
+ globus_mutex_unlock(&args_mutex);
+ return rc;
+@@ -498,18 +498,18 @@ void
+ globus_args_option_instance_list_free( globus_list_t ** list )
+ {
+ globus_args_option_instance_t * t;
+-
++
+ while(!globus_list_empty(*list))
+ {
+ t = (globus_args_option_instance_t *)
+ globus_list_remove(list, *list);
+- globus_assert(t);
+- if (t->values)
+- free( t->values );
+- globus_free(t);
+-
++ globus_assert(t);
++ if (t->values)
++ free( t->values );
++ globus_free(t);
++
+ }
+-
++
+ return;
+ }
+
+@@ -546,8 +546,8 @@ globus_validate_int( char * value,
+
+ if (!parms)
+ {
+- *error_msg = _GCSL(globus_l_validate_error_null_parms);
+- return GLOBUS_FAILURE;
++ *error_msg = _GCSL(globus_l_validate_error_null_parms);
++ return GLOBUS_FAILURE;
+ }
+
+ format = "%d";
+@@ -579,18 +579,18 @@ globus_validate_int( char * value,
+ if ((range->range_type & GLOBUS_VALIDATE_INT_MIN) &&
+ (range->range_min > val))
+ {
+- globus_libc_sprintf(globus_l_validate_error_buf,
+- _GCSL("value is smaller than allowed min=%d"),
+- range->range_min);
+- *error_msg = globus_l_validate_error_buf;
++ globus_libc_sprintf(globus_l_validate_error_buf,
++ _GCSL("value is smaller than allowed min=%d"),
++ range->range_min);
++ *error_msg = globus_l_validate_error_buf;
+ return GLOBUS_FAILURE;
+ }
+ if ((range->range_type & GLOBUS_VALIDATE_INT_MAX) &&
+ (range->range_max < val))
+ {
+- globus_libc_sprintf(globus_l_validate_error_buf,
+- _GCSL("value is larger than allowed max=%d"),
+- range->range_max);
++ globus_libc_sprintf(globus_l_validate_error_buf,
++ _GCSL("value is larger than allowed max=%d"),
++ range->range_max);
+ *error_msg = globus_l_validate_error_buf;
+ return GLOBUS_FAILURE;
+ }
+@@ -618,8 +618,8 @@ globus_validate_filename( char * value,
+
+ if (!parms)
+ {
+- *error_msg = _GCSL(globus_l_validate_error_null_parms);
+- return GLOBUS_FAILURE;
++ *error_msg = _GCSL(globus_l_validate_error_null_parms);
++ return GLOBUS_FAILURE;
+ }
+
+ mode = *((int *)(parms));
+@@ -627,8 +627,8 @@ globus_validate_filename( char * value,
+ my_errno = errno;
+ if (fd < 0)
+ {
+- *error_msg = globus_libc_system_error_string(my_errno);
+- return GLOBUS_FAILURE;
++ *error_msg = globus_libc_system_error_string(my_errno);
++ return GLOBUS_FAILURE;
+ }
+
+ globus_libc_close(fd);
+@@ -640,54 +640,54 @@ globus_validate_filename( char * value,
+ /* ----------------------------------------------------------------------------
+ globus_bytestr_to_num()
+
+- converts a string such as 40M, 256K, 2G to an equivalent off_t.
++ converts a string such as 40M, 256K, 2G to an equivalent off_t.
+ Valid multipliers are G,g, M,m, K,k, B,b.
+-
++
+ Returns 0 on success, nonzero on error.
+
+ */
+
+ int
+-globus_args_bytestr_to_num(
++globus_args_bytestr_to_num(
+ const char * str,
+- globus_off_t * out)
+-{
+- char * end = NULL;
++ globus_off_t * out)
++{
++ char * end = NULL;
+ globus_off_t size = 0;
+ int consumed;
+ int rc;
+-
++
+ if(str == NULL || !(isdigit(*str) || *str == '-'))
+ {
+ return 1;
+ }
+-
++
+ rc = globus_libc_scan_off_t((char *)str, &size, &consumed);
+ end = (char *)str + consumed;
+ if(size && end && *end)
+- {
+- switch(*end)
+- {
+- case 'g':
+- case 'G':
+- size *= 1024;
+- case 'm':
+- case 'M':
+- size *= 1024;
+- case 'k':
+- case 'K':
+- size *= 1024;
+- case 'b':
+- case 'B':
+- break;
+-
+- default:
++ {
++ switch(*end)
++ {
++ case 'g':
++ case 'G':
++ size *= 1024;
++ case 'm':
++ case 'M':
++ size *= 1024;
++ case 'k':
++ case 'K':
++ size *= 1024;
++ case 'b':
++ case 'B':
++ break;
++
++ default:
+ return 1;
+- break;
+- }
+- }
+-
++ break;
++ }
++ }
++
+ *out = size;
+-
++
+ return 0;
+-}
++}
+diff --git a/common/source/library/globus_callback.h b/common/source/library/globus_callback.h
+index bb4e58077..810665c43 100644
+--- a/common/source/library/globus_callback.h
++++ b/common/source/library/globus_callback.h
+@@ -127,7 +127,7 @@ typedef struct globus_l_callback_space_attr_s * globus_callback_space_attr_t;
+ */
+
+ /**
+- * @name Convenience Macros
++ * @name Convenience Macros
+ */
+
+ /* @{ */
+@@ -285,16 +285,16 @@ typedef struct globus_l_callback_space_attr_s * globus_callback_space_attr_t;
+ * @ingroup globus_callback_api
+ *
+ * @details
+- * This is the signature of the function registered with the
++ * This is the signature of the function registered with the
+ * globus_callback_register_* calls.
+ *
+ * If this is a periodic callback, it is guaranteed that the call canNOT
+ * be reentered unless globus_thread_blocking_space_will_block() is called
+ * (explicitly, or implicitly via globus_cond_wait()). Also, if
+- * globus_callback_unregister() is called to cancel this periodic from within
++ * globus_callback_unregister() is called to cancel this periodic from within
+ * this callback, it is guaranteed that the callback will NOT be requeued again
+- *
+- * If the function will block at all, the user should call
++ *
++ * If the function will block at all, the user should call
+ * globus_callback_get_timeout() to see how long this function can safely block
+ * or call globus_thread_blocking_space_will_block()
+ *
+@@ -324,7 +324,7 @@ void
+ *
+ * @details
+ * This function registers the callback_func to start some delay_time from
+- * now.
++ * now.
+ *
+ * @param callback_handle
+ * Storage for a handle. This may be NULL. If it is NOT NULL, you
+@@ -347,7 +347,7 @@ void
+ * - GLOBUS_CALLBACK_ERROR_INVALID_ARGUMENT
+ * - GLOBUS_CALLBACK_ERROR_MEMORY_ALLOC
+ * - GLOBUS_SUCCESS
+- *
++ *
+ * @see globus_callback_func_t
+ * @see globus_callback_spaces
+ */
+@@ -371,7 +371,7 @@ globus_callback_space_register_oneshot(
+ * @ingroup globus_callback_api
+ *
+ * @details
+- * This function registers a periodic callback_func to start some delay_time
++ * This function registers a periodic callback_func to start some delay_time
+ * and run every period from then.
+ *
+ * @param callback_handle
+@@ -398,7 +398,7 @@ globus_callback_space_register_oneshot(
+ * - GLOBUS_CALLBACK_ERROR_INVALID_ARGUMENT
+ * - GLOBUS_CALLBACK_ERROR_MEMORY_ALLOC
+ * - GLOBUS_SUCCESS
+- *
++ *
+ * @see #globus_callback_unregister()
+ * @see #globus_callback_func_t
+ * @see @link globus_callback_spaces @endlink
+@@ -452,7 +452,7 @@ globus_callback_space_register_periodic(
+ * - GLOBUS_CALLBACK_ERROR_INVALID_CALLBACK_HANDLE
+ * - GLOBUS_CALLBACK_ERROR_ALREADY_CANCELED
+ * - GLOBUS_SUCCESS
+- *
++ *
+ * @see #globus_callback_space_register_periodic()
+ * @see #globus_callback_func_t
+ */
+@@ -487,7 +487,7 @@ globus_callback_unregister(
+ * - GLOBUS_CALLBACK_ERROR_INVALID_CALLBACK_HANDLE
+ * - GLOBUS_CALLBACK_ERROR_ALREADY_CANCELED
+ * - GLOBUS_SUCCESS
+- *
++ *
+ * @see globus_callback_space_register_periodic()
+ */
+ globus_result_t
+@@ -508,7 +508,7 @@ globus_callback_adjust_oneshot(
+ * until another time by passing a period of NULL. The callback can later
+ * be resumed by passing in a new period.
+ *
+- * Note that the callback will not be fired sooner than 'new_period' from now.
++ * Note that the callback will not be fired sooner than 'new_period' from now.
+ * A 'suspended' callback must still be unregistered to free its resources.
+ *
+ * @param callback_handle
+@@ -524,7 +524,7 @@ globus_callback_adjust_oneshot(
+ * - GLOBUS_CALLBACK_ERROR_INVALID_CALLBACK_HANDLE
+ * - GLOBUS_CALLBACK_ERROR_ALREADY_CANCELED
+ * - GLOBUS_SUCCESS
+- *
++ *
+ * @see globus_callback_space_register_periodic()
+ */
+ globus_result_t
+@@ -543,25 +543,25 @@ globus_callback_adjust_period(
+ * @ingroup globus_callback_api
+ *
+ * @details
+- * This function is used to poll for registered callbacks.
++ * This function is used to poll for registered callbacks.
+ *
+ * For non-threaded builds, callbacks are not/can not be delivered unless this
+- * is called. Any call to this can cause callbacks registered with the
+- * 'global' space to be fired. Whereas callbacks registered with a user's
++ * is called. Any call to this can cause callbacks registered with the
++ * 'global' space to be fired. Whereas callbacks registered with a user's
+ * space will only be delivered when this is called with that space.
+ *
+ * For threaded builds, this only needs to be called to poll user spaces with
+ * behavior == GLOBUS_CALLBACK_SPACE_BEHAVIOR_SINGLE. The 'global' space
+- * and other user spaces are constantly polled in a separate thread.
++ * and other user spaces are constantly polled in a separate thread.
+ * (If it is called in a threaded build for these spaces, it will just yield
+ * its thread)
+ *
+ * In general, you never need to call this function directly. It is called
+ * (when necessary) by globus_cond_wait(). The only case in which a user may
+- * wish to call this explicitly is if the application has no aspirations of
++ * wish to call this explicitly is if the application has no aspirations of
+ * ever being built threaded.
+ *
+- * This function (when not yielding) will block up to timestop or until
++ * This function (when not yielding) will block up to timestop or until
+ * globus_callback_signal_poll() is called by one of the fired callbacks. It
+ * will always try and kick out ready callbacks, regardless of the timestop.
+ *
+@@ -591,12 +591,12 @@ globus_callback_space_poll(
+ *
+ * In general, you never need to call this function directly. It is called
+ * (when necessary) by globus_cond_signal() or globus_cond_broadcast. The only
+- * case in which a user may wish to call this explicitly is if the application
++ * case in which a user may wish to call this explicitly is if the application
+ * has no aspirations of ever being built threaded.
+ *
+ * @return
+ * - void
+- *
++ *
+ * @see globus_callback_space_poll()
+ */
+ void
+@@ -615,8 +615,8 @@ globus_callback_signal_poll();
+ * @details
+ * This function retrieves the remaining time a callback is allowed to run.
+ * If a callback has already timed out, time_left will be set to zero and
+- * GLOBUS_TRUE returned. This function is intended to be called within a
+- * callback's stack, but is harmless to call anywhere (will return
++ * GLOBUS_TRUE returned. This function is intended to be called within a
++ * callback's stack, but is harmless to call anywhere (will return
+ * GLOBUS_FALSE and an infinite time_left)
+ *
+ * @param time_left
+@@ -651,8 +651,8 @@ globus_callback_has_time_expired();
+ * @ingroup globus_callback_api
+ *
+ * @details
+- * If the callback is a oneshot, this merely means the callback called
+- * globus_thread_blocking_space_will_block (or globus_cond_wait() at
++ * If the callback is a oneshot, this merely means the callback called
++ * globus_thread_blocking_space_will_block (or globus_cond_wait() at
+ * some point.
+ *
+ * For a periodic, it signifies the same and also that the periodic has been
+@@ -682,7 +682,7 @@ globus_callback_was_restarted();
+ * @details
+ * The 'global' space handle.
+ *
+- * This is the default space handle implied if no spaces are
++ * This is the default space handle implied if no spaces are
+ * explicitly created.
+ */
+ #define GLOBUS_CALLBACK_GLOBAL_SPACE -2
+@@ -695,25 +695,25 @@ globus_callback_was_restarted();
+ * In a non-threaded build all spaces exhibit a
+ * behavior == _BEHAVIOR_SINGLE. Setting a specific behavior in this case
+ * is ignored.
+- *
++ *
+ * In a threaded build, _BEHAVIOR_SINGLE retains all the rules and
+ * behaviors of a non-threaded build while _BEHAVIOR_THREADED makes the
+ * space act as the global space.
+ *
+- * Setting a space's behavior to _BEHAVIOR_SINGLE guarantees that the
++ * Setting a space's behavior to _BEHAVIOR_SINGLE guarantees that the
+ * poll protection will always be there and all callbacks are serialized and
+ * only kicked out when polled for. In a threaded build, it is still necessary
+ * to poll for callbacks in a _BEHAVIOR_SINGLE space. (globus_cond_wait()
+ * will take care of this for you also)
+ *
+- * Setting a space's behavior to _BEHAVIOR_SERIALIZED guarantees that the
++ * Setting a space's behavior to _BEHAVIOR_SERIALIZED guarantees that the
+ * poll protection will always be there and all callbacks are serialized. In a
+- * threaded build, it is NOT necessary to poll for callbacks in a
++ * threaded build, it is NOT necessary to poll for callbacks in a
+ * _BEHAVIOR_SERIALIZED space. Callbacks in this space will be delivered as
+ * soon as possible, but only one outstanding (and unblocked) callback will be
+ * allowed at any time.
+ *
+- * Setting a space's behavior to _BEHAVIOR_THREADED allows the user to
++ * Setting a space's behavior to _BEHAVIOR_THREADED allows the user to
+ * have the poll protection provided by spaces when built non-threaded, yet,
+ * be fully threaded when built threaded (where poll protection is not needed)
+ */
+@@ -723,7 +723,7 @@ typedef enum
+ * and single threaded behavior (callbacks need to be explicitly polled for
+ */
+ GLOBUS_CALLBACK_SPACE_BEHAVIOR_SINGLE,
+- /** Indicates that you want poll protection and all callbacks to be
++ /** Indicates that you want poll protection and all callbacks to be
+ * serialized (but they do not need to be polled for in a threaded build)
+ */
+ GLOBUS_CALLBACK_SPACE_BEHAVIOR_SERIALIZED,
+@@ -788,20 +788,20 @@ globus_callback_space_reference(
+ *
+ * @details
+ * This will destroy a reference to a previously initialized space. Space will
+- * not actually be destroyed until all callbacks registered with this space
++ * not actually be destroyed until all callbacks registered with this space
+ * have been run and unregistered (if the user has a handle to that callback)
+ * AND all references (from globus_callback_space_reference()) have been
+ * destroyed.
+ *
+ * @param space
+- * space to destroy, previously initialized by
+- * globus_callback_space_init() or referenced with
++ * space to destroy, previously initialized by
++ * globus_callback_space_init() or referenced with
+ * globus_callback_space_reference()
+ *
+ * @return
+ * - GLOBUS_CALLBACK_ERROR_INVALID_SPACE
+ * - GLOBUS_SUCCESS
+- *
++ *
+ * @see globus_callback_space_init()
+ * @see globus_callback_space_reference()
+ */
+@@ -835,13 +835,13 @@ globus_callback_space_attr_init(
+ * @ingroup globus_callback_spaces
+ * @details
+ * @param attr
+- * attr to destroy, previously initialized with
++ * attr to destroy, previously initialized with
+ * globus_callback_space_attr_init()
+ *
+ * @return
+ * - GLOBUS_CALLBACK_ERROR_INVALID_ARGUMENT on NULL attr
+ * - GLOBUS_SUCCESS
+- *
++ *
+ * @see globus_callback_space_attr_init()
+ */
+ globus_result_t
+@@ -861,7 +861,7 @@ globus_callback_space_attr_destroy(
+ * @return
+ * - GLOBUS_CALLBACK_ERROR_INVALID_ARGUMENT
+ * - GLOBUS_SUCCESS
+- *
++ *
+ * @see globus_callback_space_behavior_t
+ */
+ globus_result_t
+@@ -925,7 +925,7 @@ globus_callback_space_get_depth(
+ globus_callback_space_t space);
+
+ /**
+- * @brief See if the specified space is a single threaded behavior space
++ * @brief See if the specified space is a single threaded behavior space
+ * @ingroup globus_callback_spaces
+ *
+ * @param space
+@@ -949,7 +949,7 @@ globus_callback_space_is_single(
+ /**
+ * @hideinitializer
+ * @ingroup globus_callback_signal
+- *
++ *
+ * @details
+ * Use this to trap interrupts (SIGINT on unix). In the future, this will
+ * also map to handle ctrl-C on win32.
+@@ -963,7 +963,7 @@ globus_callback_space_is_single(
+ /**
+ * @brief Fire a callback when the specified signal is received.
+ * @ingroup globus_callback_signal
+- *
++ *
+ * @details
+ * Note that there is a tiny delay between the time this call returns
+ * and the signal is actually handled by this library. It is likely that, if
+@@ -1006,7 +1006,7 @@ globus_callback_space_register_signal_handler(
+ /**
+ * @brief Unregister a signal handling callback
+ * @ingroup globus_callback_signal
+- *
++ *
+ * @param signum
+ * The signal to unregister.
+ *
+@@ -1036,29 +1036,29 @@ globus_callback_unregister_signal_handler(
+ /**
+ * @brief Register a wakeup handler with callback library
+ * @ingroup globus_callback_signal
+- *
++ *
+ * @details
+ * This is really only needed in non-threaded builds, but for cross builds
+ * should be used everywhere that a callback may sleep for an extended period
+ * of time.
+- *
++ *
+ * An example use is for an io poller that sleeps indefinitely on select(). If
+ * the callback library receives a signal that it needs to deliver asap, it
+ * will call the wakeup handler(s), These wakeup handlers must run as though
+ * they were called from a signal handler (don't use any thread utilities).
+ * The io poll example will likely write a single byte to a pipe that select()
+ * is monitoring.
+- *
++ *
+ * This handler will not be unregistered until the callback library is
+ * deactivated (via common).
+- *
++ *
+ * @param wakeup
+ * function to call when callback library needs you to return asap
+ * from any blocked callbacks.
+- *
++ *
+ * @param user_arg
+ * user data that will be passed along in the wakeup handler
+- *
++ *
+ */
+ void
+ globus_callback_add_wakeup_handler(
+diff --git a/common/source/library/globus_error_errno.c b/common/source/library/globus_error_errno.c
+index 90c703384..47017bced 100644
+--- a/common/source/library/globus_error_errno.c
++++ b/common/source/library/globus_error_errno.c
+@@ -49,7 +49,7 @@
+ * 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_error_put() on this object.
+ */
+ globus_object_t *
+ globus_error_construct_errno_error(
+@@ -83,7 +83,7 @@ globus_error_construct_errno_error(
+ /**
+ * Initialize a previously allocated error of type
+ * GLOBUS_ERROR_TYPE_ERRNO
+- * @ingroup globus_errno_error_object
++ * @ingroup globus_errno_error_object
+ *
+ * @param error
+ * The previously allocated error object.
+@@ -125,7 +125,7 @@ globus_error_initialize_errno_error(
+ /*@{*/
+ /**
+ * Retrieve the system errno from a errno error object.
+- * @ingroup globus_errno_error_accessor
++ * @ingroup globus_errno_error_accessor
+ *
+ * @param error
+ * The error from which to retrieve the errno
+@@ -151,7 +151,7 @@ globus_error_errno_get_errno(
+ /*@{*/
+ /**
+ * Set the errno in a errno error object.
+- * @ingroup globus_errno_error_accessor
++ * @ingroup globus_errno_error_accessor
+ *
+ * @param error
+ * The error object for which to set the errno
+@@ -181,7 +181,7 @@ globus_error_errno_set_errno(
+ /**
+ * Check whether the error originated from a specific module and
+ * matches a specific errno.
+- * @ingroup globus_errno_error_utility
++ * @ingroup globus_errno_error_utility
+ *
+ * This function checks whether the error or any of it's causative
+ * errors originated from a specific module and contains a specific
+@@ -207,7 +207,7 @@ globus_error_errno_match(
+ globus_object_t * errno_error = NULL;
+ globus_module_descriptor_t * source_module;
+ int current_errno;
+-
++
+ if(error == NULL)
+ {
+ return GLOBUS_FALSE;
+@@ -226,7 +226,7 @@ globus_error_errno_match(
+
+ source_module = globus_error_get_source(errno_error);
+ current_errno = globus_error_errno_get_errno(errno_error);
+-
++
+ if(source_module == module && current_errno == system_errno)
+ {
+ return GLOBUS_TRUE;
+@@ -244,7 +244,7 @@ globus_error_errno_match(
+ /*@{*/
+ /**
+ * @brief Search for an errno value in an error chain
+- * @ingroup globus_errno_error_utility
++ * @ingroup globus_errno_error_utility
+ * @details
+ * This function searches the error object and its causal errors for
+ * an error of type GLOBUS_ERROR_TYPE_ERRNO and returns the errno
+@@ -256,14 +256,14 @@ globus_error_errno_match(
+ * @return
+ * This function returns 0 if no errorno is found, otherwise the
+ * error.
+- *
++ *
+ */
+ int
+ globus_error_errno_search(
+ globus_object_t * error)
+ {
+ int current_errno;
+-
++
+ if(error == NULL)
+ {
+ return 0;
+@@ -289,7 +289,7 @@ globus_error_errno_search(
+ /**
+ * Allocate and initialize an error of type GLOBUS_ERROR_TYPE_GLOBUS
+ * which contains a causal error of type GLOBUS_ERROR_TYPE_ERRNO.
+- * @ingroup globus_errno_error_utility
++ * @ingroup globus_errno_error_utility
+ *
+ * @param base_source
+ * Pointer to the originating module.
+@@ -315,7 +315,7 @@ globus_error_errno_search(
+ * 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_error_put() on this object.
+ */
+ globus_object_t *
+ globus_error_wrap_errno_error(
+@@ -343,9 +343,9 @@ globus_error_wrap_errno_error(
+ {
+ return GLOBUS_NULL;
+ }
+-
++
+ va_start(ap, short_desc_format);
+-
++
+ sys_error = strerror(system_errno);
+ if(sys_error)
+ {
+@@ -356,12 +356,12 @@ globus_error_wrap_errno_error(
+ sprintf(fmt, "%s: %s", short_desc_format, sys_error);
+ }
+ }
+-
++
+ if(!fmt)
+ {
+ fmt = (char *) short_desc_format;
+ }
+-
++
+ error = globus_error_v_construct_error(
+ base_source,
+ causal_error,
+@@ -373,19 +373,19 @@ globus_error_wrap_errno_error(
+ ap);
+
+ va_end(ap);
+-
++
+ if(fmt != short_desc_format)
+ {
+ globus_free(fmt);
+ }
+-
++
+ if(error == GLOBUS_NULL)
+ {
+ globus_object_free(causal_error);
+ }
+-
++
+ return error;
+-
++
+ }/* globus_error_wrap_errno_error */
+ /*@}*/
+
+diff --git a/common/source/library/globus_error_generic.c b/common/source/library/globus_error_generic.c
+index 1c11b84b7..bc788403a 100644
+--- a/common/source/library/globus_error_generic.c
++++ b/common/source/library/globus_error_generic.c
+@@ -79,7 +79,7 @@ typedef struct
+ * 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_error_put() on this object.
+ */
+ globus_object_t *
+ globus_error_construct_error(
+@@ -148,7 +148,7 @@ globus_error_construct_error(
+ * 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_error_put() on this object.
+ */
+ globus_object_t *
+ globus_error_v_construct_error(
+@@ -192,7 +192,7 @@ globus_error_v_construct_error(
+ /**
+ * Initialize a previously allocated error of type
+ * GLOBUS_ERROR_TYPE_GLOBUS
+- * @ingroup globus_generic_error_object
++ * @ingroup globus_generic_error_object
+ *
+ * @param error
+ * The previously allocated error object.
+@@ -241,7 +241,7 @@ globus_error_initialize_error(
+ {
+ return NULL;
+ }
+-
++
+ instance_data = (globus_l_error_data_t *)
+ malloc(sizeof(globus_l_error_data_t));
+
+@@ -263,12 +263,12 @@ globus_error_initialize_error(
+ va_end(ap_copy);
+
+ size++;
+-
++
+ if ((instance_data->short_desc = malloc (size)) == NULL)
+ {
+ return NULL;
+ }
+-
++
+ globus_libc_vsnprintf(instance_data->short_desc,
+ size,
+ short_desc_format,
+@@ -289,7 +289,7 @@ globus_error_initialize_error(
+ /*@{*/
+ /**
+ * Retrieve the originating module descriptor from a error object.
+- * @ingroup globus_generic_error_accessor
++ * @ingroup globus_generic_error_accessor
+ *
+ * @param error
+ * The error from which to retrieve the module descriptor
+@@ -310,7 +310,7 @@ globus_error_get_source(
+ /*@{*/
+ /**
+ * Set the originating module descriptor in a error object.
+- * @ingroup globus_generic_error_accessor
++ * @ingroup globus_generic_error_accessor
+ *
+ * @param error
+ * The error object for which to set the causative error
+@@ -334,7 +334,7 @@ globus_error_set_source(
+ /*@{*/
+ /**
+ * Retrieve the underlying error from a error object.
+- * @ingroup globus_generic_error_accessor
++ * @ingroup globus_generic_error_accessor
+ *
+ * @param error
+ * The error from which to retrieve the causative error.
+@@ -357,7 +357,7 @@ globus_error_get_cause (
+ /*@{*/
+ /**
+ * Set the causative error in a error object.
+- * @ingroup globus_generic_error_accessor
++ * @ingroup globus_generic_error_accessor
+ *
+ * @param error
+ * The error object for which to set the causative error.
+@@ -382,7 +382,7 @@ globus_error_set_cause (
+ /*@{*/
+ /**
+ * Retrieve the error type from a generic globus error object.
+- * @ingroup globus_generic_error_accessor
++ * @ingroup globus_generic_error_accessor
+ *
+ * @param error
+ * The error from which to retrieve the error type
+@@ -394,7 +394,7 @@ globus_error_get_type(
+ globus_object_t * error)
+ {
+ globus_object_t * tmp;
+-
++
+ if ((tmp = globus_object_upcast(error, GLOBUS_ERROR_TYPE_GLOBUS)) != NULL)
+ {
+ return ((globus_l_error_data_t *)
+@@ -418,7 +418,7 @@ globus_error_get_type(
+ /*@{*/
+ /**
+ * Set the error type in a generic globus error object.
+- * @ingroup globus_generic_error_accessor
++ * @ingroup globus_generic_error_accessor
+ *
+ * @param error
+ * The error object for which to set the error type
+@@ -449,8 +449,8 @@ globus_error_set_type(
+ /*@{*/
+ /**
+ * Retrieve the short error description from a generic globus error
+- * object.
+- * @ingroup globus_generic_error_accessor
++ * object.
++ * @ingroup globus_generic_error_accessor
+ *
+ * @param error
+ * The error from which to retrieve the description
+@@ -479,8 +479,8 @@ globus_error_get_short_desc(
+ */
+ /*@{*/
+ /**
+- * Set the short error description in a generic globus error object.
+- * @ingroup globus_generic_error_accessor
++ * Set the short error description in a generic globus error object.
++ * @ingroup globus_generic_error_accessor
+ *
+ * @param error
+ * The error object for which to set the description
+@@ -501,7 +501,7 @@ globus_error_set_short_desc(
+ char ** instance_short_desc;
+ va_list ap;
+ int size;
+-
++
+ if ((error = globus_object_upcast(error, GLOBUS_ERROR_TYPE_GLOBUS)) == NULL)
+ {
+ return;
+@@ -509,7 +509,7 @@ globus_error_set_short_desc(
+ instance_short_desc =
+ &((globus_l_error_data_t *)
+ globus_object_get_local_instance_data(error))->short_desc;
+-
++
+ if(*instance_short_desc != NULL)
+ {
+ globus_libc_free(*instance_short_desc);
+@@ -522,7 +522,7 @@ globus_error_set_short_desc(
+ size = globus_libc_vprintf_length(short_desc_format,ap);
+
+ va_end(ap);
+-
++
+ size++;
+
+ if ((*instance_short_desc = malloc (size)) == NULL)
+@@ -531,14 +531,14 @@ globus_error_set_short_desc(
+ }
+
+ va_start(ap, short_desc_format);
+-
++
+ globus_libc_vsnprintf(*instance_short_desc,
+ size,
+ short_desc_format,
+ ap);
+
+ va_end(ap);
+-
++
+ return;
+ }/* globus_error_set_short_desc */
+ /*@}*/
+@@ -550,8 +550,8 @@ globus_error_set_short_desc(
+ /*@{*/
+ /**
+ * Retrieve the long error description from a generic globus error
+- * object.
+- * @ingroup globus_generic_error_accessor
++ * object.
++ * @ingroup globus_generic_error_accessor
+ *
+ * @param error
+ * The error from which to retrieve the description
+@@ -578,13 +578,13 @@ globus_error_get_long_desc(
+ /*@{*/
+ /**
+ * Set the long error description in a generic globus error object.
+- * @ingroup globus_generic_error_accessor
++ * @ingroup globus_generic_error_accessor
+ *
+ * @param error
+ * The error object for which to set the description
+ * @param long_desc_format
+ * Longer format string giving a more detailed explanation of
+- * the error.
++ * the error.
+ * @return
+ * void
+ */
+@@ -597,7 +597,7 @@ globus_error_set_long_desc(
+ char ** instance_long_desc;
+ va_list ap;
+ int size;
+-
++
+ if ((error = globus_object_upcast(error, GLOBUS_ERROR_TYPE_GLOBUS)) == NULL)
+ {
+ return;
+@@ -605,7 +605,7 @@ globus_error_set_long_desc(
+ instance_long_desc =
+ &((globus_l_error_data_t *)
+ globus_object_get_local_instance_data(error))->long_desc;
+-
++
+ if(*instance_long_desc != NULL)
+ {
+ globus_libc_free(*instance_long_desc);
+@@ -633,7 +633,7 @@ globus_error_set_long_desc(
+ long_desc_format,
+ ap);
+ va_end(ap);
+-
++
+ return;
+ }/* globus_error_set_long_desc */
+ /*@}*/
+@@ -646,7 +646,7 @@ globus_error_set_long_desc(
+ /**
+ * Check whether the error originated from a specific module and is of
+ * a specific type.
+- * @ingroup globus_generic_error_utility
++ * @ingroup globus_generic_error_utility
+ *
+ * This function checks whether the error or any of it's causative
+ * errors originated from a specific module and is of a specific
+@@ -672,12 +672,12 @@ globus_error_match(
+ globus_module_descriptor_t * source_module;
+ int error_type;
+ globus_object_t * tmp;
+-
++
+ if(error == NULL)
+ {
+ return GLOBUS_FALSE;
+ }
+-
++
+ if ((tmp = globus_object_upcast(error, GLOBUS_ERROR_TYPE_GLOBUS)) != NULL)
+ {
+ error = tmp;
+@@ -696,7 +696,7 @@ globus_error_match(
+ }
+ source_module = globus_error_get_source(error);
+ error_type = globus_error_get_type(error);
+-
++
+ if(source_module == module && error_type == type)
+ {
+ return GLOBUS_TRUE;
+@@ -719,7 +719,7 @@ globus_error_match(
+ /**
+ * Return a string containing all printable errors found in a error
+ * object and it's causative error chain.
+- * @ingroup globus_generic_error_utility
++ * @ingroup globus_generic_error_utility
+ *
+ * If the GLOBUS_ERROR_VERBOSE env is set, file, line and function info will
+ * also be printed (where available). Otherwise, only the module name will
+@@ -739,7 +739,7 @@ globus_error_print_chain(
+ char * tmp;
+ int length = 0;
+ globus_object_t * current_error;
+-
++
+ current_error = error;
+ error_string = (char *) globus_libc_malloc(1);
+
+@@ -749,12 +749,12 @@ globus_error_print_chain(
+ if(tmp != NULL)
+ {
+ int l;
+-
++
+ l = strlen(tmp);
+ if(l)
+ {
+ char * ns;
+-
++
+ ns = (char *) globus_libc_realloc(
+ error_string, length + l + 2);
+ if(ns)
+@@ -769,15 +769,15 @@ globus_error_print_chain(
+ }
+ }
+ while((current_error = globus_error_get_cause(current_error)));
+-
++
+ error_string[length] = '\0';
+-
++
+ if(length == 0)
+ {
+ globus_libc_free(error_string);
+ error_string = NULL;
+ }
+-
++
+ return error_string;
+ }/* globus_error_print_chain */
+ /*@}*/
+@@ -794,7 +794,7 @@ globus_l_error_multiple_print(
+ char ** free_ptrs = NULL;
+ char * error_string;
+ int i = 0;
+-
++
+ if ((error = globus_object_upcast(error, GLOBUS_ERROR_TYPE_MULTIPLE)) == NULL)
+ {
+ return NULL;
+@@ -810,28 +810,28 @@ globus_l_error_multiple_print(
+ {
+ globus_list_t * tmp;
+ int j = 0;
+-
++
+ if(data->desc && *data->desc)
+ {
+ layout[i++] = data->desc;
+ layout[i++] = "\n";
+ }
+-
++
+ for(tmp = data->chains;
+- !globus_list_empty(tmp);
++ !globus_list_empty(tmp);
+ tmp = globus_list_rest(tmp))
+ {
+ globus_l_error_multiple_chain_t * instance;
+-
++
+ instance = (globus_l_error_multiple_chain_t *)
+ globus_list_first(tmp);
+-
++
+ if(instance->desc && *instance->desc)
+ {
+ layout[i++] = instance->desc;
+ layout[i++] = "\n";
+ }
+-
++
+ if(friendly)
+ {
+ free_ptrs[j++] = layout[i++] =
+@@ -839,13 +839,13 @@ globus_l_error_multiple_print(
+ }
+ else
+ {
+- free_ptrs[j++] = layout[i++] =
++ free_ptrs[j++] = layout[i++] =
+ globus_error_print_chain(instance->chain);
+ }
+ }
+ }
+ }
+-
++
+ error_string = layout ? globus_libc_join((const char **) layout, i) : NULL;
+ if(layout)
+ {
+@@ -892,7 +892,7 @@ globus_l_add_error_string(
+ layout[(*idx)++] = "\n";
+ }
+ }
+-
++
+ return msg;
+ }
+
+@@ -908,7 +908,7 @@ globus_l_add_error_string(
+ * @ingroup globus_generic_error_utility
+ *
+ * If the GLOBUS_ERROR_VERBOSE env is set, then the result from
+- * globus_error_print_chain() will be used.
++ * globus_error_print_chain() will be used.
+ *
+ * @param error
+ * The error to print
+@@ -932,16 +932,16 @@ globus_error_print_friendly(
+ char * bottom3 = NULL;
+ char * verbose = NULL;
+ globus_bool_t verbose_allowed = GLOBUS_TRUE;
+-
++
+ if(!error)
+ {
+ return NULL;
+ }
+-
++
+ if(globus_i_error_verbose)
+ {
+ int * in_progress;
+-
++
+ in_progress = (int *)
+ globus_thread_getspecific(globus_i_error_verbose_key);
+ if(in_progress)
+@@ -954,7 +954,7 @@ globus_error_print_friendly(
+ globus_i_error_verbose_key, (int *) 0x01);
+ }
+ }
+-
++
+ if(globus_i_error_verbose && verbose_allowed)
+ {
+ verbose = globus_error_print_chain(error);
+@@ -962,7 +962,7 @@ globus_error_print_friendly(
+ {
+ layout[i++] = verbose;
+ }
+-
++
+ globus_thread_setspecific(globus_i_error_verbose_key, NULL);
+ }
+ else
+@@ -970,7 +970,7 @@ globus_error_print_friendly(
+ globus_object_t * source_error1 = NULL;
+ globus_object_t * source_error2 = NULL;
+ globus_object_t * source_error3;
+-
++
+ /* here we only take the top error and the bottom 3 */
+ current_error = error;
+ do
+@@ -986,9 +986,9 @@ globus_error_print_friendly(
+ globus_object_get_type(current_error));
+ }
+ } while((current_error = globus_error_get_cause(current_error)));
+-
++
+ top = globus_l_add_error_string(layout, &i, error);
+-
++
+ if(error != source_error1)
+ {
+ if(error != source_error2)
+@@ -998,22 +998,22 @@ globus_error_print_friendly(
+ bottom3 = globus_l_add_error_string(
+ layout, &i, source_error3);
+ }
+-
++
+ bottom2 = globus_l_add_error_string(layout, &i, source_error2);
+ }
+-
++
+ bottom1 = globus_l_add_error_string(layout, &i, source_error1);
+ }
+-
++
+ if(friendly && *friendly)
+ {
+ layout[i++] = friendly;
+ layout[i++] = "\n";
+ }
+ }
+-
++
+ error_string = globus_libc_join((const char **) layout, i);
+-
++
+ if(top)
+ {
+ globus_free(top);
+@@ -1038,7 +1038,7 @@ globus_error_print_friendly(
+ {
+ globus_free(verbose);
+ }
+-
++
+ return error_string;
+ }/* globus_error_print_friendly */
+ /*@}*/
+@@ -1053,7 +1053,7 @@ globus_error_print_friendly(
+ * Construct a container object for multiple error chains. Useful when
+ * an application tries many things (and each fails) before finally
+ * giving up;
+- *
++ *
+ * Use globus_error_mutliple_add_chain() to add error objects/chains to this
+ * object.
+ *
+@@ -1071,7 +1071,7 @@ globus_error_print_friendly(
+ * 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_error_put() on this object.
+ */
+ globus_object_t *
+ globus_error_construct_multiple(
+@@ -1083,58 +1083,58 @@ globus_error_construct_multiple(
+ globus_object_t * newerror;
+ globus_object_t * error;
+ globus_l_error_multiple_t * data;
+-
++
+ newerror = globus_object_construct(GLOBUS_ERROR_TYPE_MULTIPLE);
+ if(!newerror)
+ {
+ goto error_object;
+ }
+-
++
+ data = (globus_l_error_multiple_t *)
+ globus_malloc(sizeof(globus_l_error_multiple_t));
+ if(!data)
+ {
+ goto error_data;
+ }
+-
++
+ data->type = type;
+ data->chains = NULL;
+ data->desc = NULL;
+-
++
+ if(fmt)
+ {
+ int size;
+ va_list ap;
+ va_list ap_copy;
+-
++
+ va_start(ap, fmt);
+-
++
+ globus_libc_va_copy(ap_copy, ap);
+ size = globus_libc_vprintf_length(fmt, ap_copy);
+ va_end(ap_copy);
+-
++
+ data->desc = (char *) globus_malloc(size + 1);
+ if(data->desc)
+ {
+ globus_libc_vsnprintf(data->desc, size + 1, fmt, ap);
+ }
+-
++
+ va_end(ap);
+ }
+-
++
+ globus_object_set_local_instance_data(newerror, data);
+ error = globus_error_initialize_base(newerror, base_source, NULL);
+ if(!error)
+ {
+ goto error_construct;
+ }
+-
++
+ return error;
+
+ error_construct:
+ error_data:
+ globus_object_free(newerror);
+-
++
+ error_object:
+ return NULL;
+ }
+@@ -1162,7 +1162,7 @@ globus_error_mutliple_add_chain(
+ {
+ globus_l_error_multiple_t * data;
+ globus_l_error_multiple_chain_t * instance;
+-
++
+ data = (globus_l_error_multiple_t *)
+ globus_object_get_local_instance_data(multiple_error);
+ if(data && chain)
+@@ -1173,28 +1173,28 @@ globus_error_mutliple_add_chain(
+ {
+ instance->chain = chain;
+ instance->desc = NULL;
+-
++
+ if(fmt)
+ {
+ int size;
+ va_list ap;
+ va_list ap_copy;
+-
++
+ va_start(ap, fmt);
+-
++
+ globus_libc_va_copy(ap_copy, ap);
+ size = globus_libc_vprintf_length(fmt, ap_copy);
+ va_end(ap_copy);
+-
++
+ instance->desc = (char *) globus_malloc(size + 1);
+ if(instance->desc)
+ {
+ globus_libc_vsnprintf(instance->desc, size + 1, fmt, ap);
+ }
+-
++
+ va_end(ap);
+ }
+-
++
+ globus_list_insert(&data->chains, instance);
+ }
+ }
+@@ -1215,13 +1215,13 @@ globus_error_multiple_remove_chain(
+ {
+ globus_l_error_multiple_t * data;
+ globus_object_t * chain = NULL;
+-
++
+ data = (globus_l_error_multiple_t *)
+ globus_object_get_local_instance_data(multiple_error);
+ if(data && data->chains)
+ {
+ globus_l_error_multiple_chain_t * instance;
+-
++
+ instance = (globus_l_error_multiple_chain_t *)
+ globus_list_remove(&data->chains, data->chains);
+ chain = instance->chain;
+@@ -1231,7 +1231,7 @@ globus_error_multiple_remove_chain(
+ }
+ globus_free(instance);
+ }
+-
++
+ return chain;
+ }
+
+@@ -1243,28 +1243,28 @@ globus_l_error_multiple_copy(
+ {
+ globus_l_error_multiple_t * copy;
+ globus_l_error_multiple_t * source;
+-
++
+ source = (globus_l_error_multiple_t *) src;
+- copy = (globus_l_error_multiple_t *)
++ copy = (globus_l_error_multiple_t *)
+ globus_malloc(sizeof(globus_l_error_multiple_t));
+ if(copy)
+ {
+ globus_list_t * tmp;
+-
++
+ copy->type = source->type;
+ copy->chains = globus_list_copy(source->chains);
+ copy->desc = source->desc ? globus_libc_strdup(source->desc) : NULL;
+-
++
+ for(tmp = copy->chains;
+- !globus_list_empty(tmp);
++ !globus_list_empty(tmp);
+ tmp = globus_list_rest(tmp))
+ {
+ globus_l_error_multiple_chain_t * instance;
+ globus_l_error_multiple_chain_t * new_instance;
+-
++
+ instance = (globus_l_error_multiple_chain_t *)
+ globus_list_first(tmp);
+-
++
+ new_instance = (globus_l_error_multiple_chain_t *)
+ globus_malloc(sizeof(globus_l_error_multiple_chain_t));
+ if(new_instance)
+@@ -1276,7 +1276,7 @@ globus_l_error_multiple_copy(
+ globus_list_replace_first(tmp, new_instance);
+ }
+ }
+-
++
+ *dst = copy;
+ }
+
+@@ -1286,14 +1286,14 @@ globus_l_error_multiple_destroy_all(
+ void * data)
+ {
+ globus_l_error_multiple_chain_t * instance;
+-
++
+ if(!data)
+ {
+ return;
+ }
+-
++
+ instance = (globus_l_error_multiple_chain_t *) data;
+-
++
+ globus_object_free(instance->chain);
+ if(instance->desc)
+ {
+@@ -1308,7 +1308,7 @@ globus_l_error_multiple_free(
+ void * data)
+ {
+ globus_l_error_multiple_t * d;
+-
++
+ d = (globus_l_error_multiple_t *) data;
+ if(d->chains)
+ {
+@@ -1330,7 +1330,7 @@ globus_l_error_multiple_printable(
+ return globus_l_error_multiple_print(error, GLOBUS_FALSE);
+ }
+
+-const globus_object_type_t GLOBUS_ERROR_TYPE_MULTIPLE_DEFINITION =
++const globus_object_type_t GLOBUS_ERROR_TYPE_MULTIPLE_DEFINITION =
+ globus_error_type_static_initializer (
+ GLOBUS_ERROR_TYPE_BASE,
+ globus_l_error_multiple_copy,
+diff --git a/common/source/library/globus_libc.c b/common/source/library/globus_libc.c
+index 03327dce3..e9e818967 100644
+--- a/common/source/library/globus_libc.c
++++ b/common/source/library/globus_libc.c
+@@ -22,7 +22,7 @@
+ #endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
+
+ /******************************************************************************
+- Include header files
++ Include header files
+ ******************************************************************************/
+ #include "globus_i_common_config.h"
+ #include "globus_common.h"
+@@ -56,13 +56,13 @@ extern int h_errno;
+
+ extern globus_bool_t globus_i_module_initialized;
+ /******************************************************************************
+- Define module specific variables
++ Define module specific variables
+ ******************************************************************************/
+ /* mutex to make globus_libc reentrant */
+ globus_mutex_t globus_libc_mutex;
+
+ /******************************************************************************
+- Module specific function prototypes
++ Module specific function prototypes
+ ******************************************************************************/
+ static int
+ globus_l_libc_copy_hostent_data_to_buffer(
+@@ -122,9 +122,9 @@ Returns:
+ ******************************************************************************/
+ int
+ globus_libc_strncasecmp(
+- const char * s1,
+- const char * s2,
+- globus_size_t n)
++ const char * s1,
++ const char * s2,
++ globus_size_t n)
+ {
+ int rc;
+ int save_errno;
+@@ -144,35 +144,35 @@ globus_libc_strncasecmp(
+
+ for(ctr = 0; ctr < n; ctr++)
+ {
+- if(s2[ctr] == '\0' && s1[ctr] == '\0')
+- {
+- rc = 0;
+- goto exit;
+- }
+- else if(s2[ctr] == '\0')
+- {
+- rc = -1;
+- goto exit;
+- }
+- else if(s1[ctr] == '\0')
+- {
+- rc = 1;
+- goto exit;
+- }
++ if(s2[ctr] == '\0' && s1[ctr] == '\0')
++ {
++ rc = 0;
++ goto exit;
++ }
++ else if(s2[ctr] == '\0')
++ {
++ rc = -1;
++ goto exit;
++ }
++ else if(s1[ctr] == '\0')
++ {
++ rc = 1;
++ goto exit;
++ }
+ else
+- {
++ {
+ ch1 = toupper(s2[ctr]);
+ ch2 = toupper(s1[ctr]);
+ if(ch2 > ch1)
+- {
++ {
+ rc = 1;
+ goto exit;
+- }
++ }
+ else if(ch2 < ch1)
+- {
++ {
+ rc = -1;
+ goto exit;
+- }
++ }
+ }
+ }
+ rc = 0;
+@@ -215,26 +215,26 @@ globus_l_libc_vsnprintf(char *s, size_t n, const char *format, va_list ap)
+
+ if ( rc < 0 )
+ {
+- return rc;
++ return rc;
+ }
+ else if ( rc < n )
+ {
+- return vsprintf( s, format, ap );
++ return vsprintf( s, format, ap );
+ }
+ else
+ {
+- char *buf = malloc( rc + 1 );
+- if (buf == NULL)
+- {
+- return -1;
+- }
+- rc = vsprintf( buf, format, ap );
+- save_errno = errno;
+- strncpy( s, buf, n - 1 );
+- s[n - 1] = '\0';
+- free( buf );
+- errno = save_errno;
+- return rc;
++ char *buf = malloc( rc + 1 );
++ if (buf == NULL)
++ {
++ return -1;
++ }
++ rc = vsprintf( buf, format, ap );
++ save_errno = errno;
++ strncpy( s, buf, n - 1 );
++ s[n - 1] = '\0';
++ free( buf );
++ errno = save_errno;
++ return rc;
+ }
+ }
+
+@@ -297,7 +297,7 @@ globus_libc_scan_off_t(char * s, globus_off_t * off, int * consumed)
+
+ if(consumed == GLOBUS_NULL)
+ {
+- consumed = &dummy;
++ consumed = &dummy;
+ }
+ globus_libc_lock();
+
+@@ -324,7 +324,7 @@ globus_libc_gethostname(char *name, int len)
+ static globus_mutex_t gethostname_mutex;
+ static int initialized = GLOBUS_FALSE;
+ char * env;
+-
++
+ globus_libc_lock();
+ if(initialized == GLOBUS_FALSE)
+ {
+@@ -333,7 +333,7 @@ globus_libc_gethostname(char *name, int len)
+ initialized = GLOBUS_TRUE;
+ }
+ globus_libc_unlock();
+-
++
+ globus_mutex_lock(&gethostname_mutex);
+
+ /* ToDo: This change should perhaps be applied to unix side as well?
+@@ -346,23 +346,23 @@ globus_libc_gethostname(char *name, int len)
+ if ((env = getenv("GLOBUS_HOSTNAME")) != GLOBUS_NULL)
+ {
+ size_t hlen = strlen(env);
+- if (hlen < (size_t) len)
+- {
+- size_t i;
+- strcpy(name, env);
+- for (i=0; i < hlen; i++)
+- name[i] = tolower(name[i]);
+- globus_mutex_unlock(&gethostname_mutex);
+- return 0;
+- }
+- else
+- {
+- globus_mutex_unlock(&gethostname_mutex);
+- errno=EFAULT;
+- return(-1);
+- }
+- }
+- #else
++ if (hlen < (size_t) len)
++ {
++ size_t i;
++ strcpy(name, env);
++ for (i=0; i < hlen; i++)
++ name[i] = tolower(name[i]);
++ globus_mutex_unlock(&gethostname_mutex);
++ return 0;
++ }
++ else
++ {
++ globus_mutex_unlock(&gethostname_mutex);
++ errno=EFAULT;
++ return(-1);
++ }
++ }
++ #else
+ if (hostname_length == 0U &&
+ (env = getenv("GLOBUS_HOSTNAME")) != GLOBUS_NULL)
+ {
+@@ -382,7 +382,7 @@ globus_libc_gethostname(char *name, int len)
+ globus_mutex_unlock(&gethostname_mutex);
+ return(-1);
+ }
+-
++
+ hostname_length = strlen(hostname);
+ if(strchr(hostname, '.') != GLOBUS_NULL)
+ {
+@@ -395,13 +395,13 @@ globus_libc_gethostname(char *name, int len)
+ globus_mutex_unlock(&gethostname_mutex);
+ return 0;
+ }
+-
++
+ memset(&hints, 0, sizeof(globus_addrinfo_t));
+ hints.ai_flags = GLOBUS_AI_CANONNAME;
+ hints.ai_family = AF_UNSPEC;
+ hints.ai_socktype = SOCK_STREAM;
+ hints.ai_protocol = 0;
+-
++
+ result = globus_libc_getaddrinfo(hostname, NULL, &hints, &addrinfo);
+ if(result == GLOBUS_SUCCESS)
+ {
+@@ -410,7 +410,7 @@ globus_libc_gethostname(char *name, int len)
+ strncpy(hostname, addrinfo->ai_canonname, sizeof(hostname));
+ hostname[sizeof(hostname) - 1] = 0;
+ }
+-
++
+ globus_libc_freeaddrinfo(addrinfo);
+ }
+ }
+@@ -461,19 +461,19 @@ globus_libc_gethostaddr_by_family(
+ globus_addrinfo_t * save_addrinfo;
+ globus_addrinfo_t * addrinfo;
+ globus_result_t result;
+-
++
+ rc = globus_libc_gethostname(hostname, sizeof(hostname));
+ if(rc < 0)
+ {
+ return rc;
+ }
+-
++
+ memset(&hints, 0, sizeof(globus_addrinfo_t));
+ hints.ai_flags = 0;
+ hints.ai_family = family;
+ hints.ai_socktype = SOCK_STREAM;
+ hints.ai_protocol = 0;
+-
++
+ result = globus_libc_getaddrinfo(
+ hostname, GLOBUS_NULL, &hints, &save_addrinfo);
+ if(result != GLOBUS_SUCCESS)
+@@ -486,13 +486,13 @@ globus_libc_gethostaddr_by_family(
+ if(GlobusLibcProtocolFamilyIsIP(addrinfo->ai_family))
+ {
+ memcpy(addr, addrinfo->ai_addr, addrinfo->ai_addrlen);
+-
++
+ break;
+ }
+ }
+-
++
+ globus_libc_freeaddrinfo(save_addrinfo);
+-
++
+ return 0;
+ }
+
+@@ -757,8 +757,8 @@ globus_libc_gethostbyname_r(
+ {
+
+ hp = gethostbyname(hostname);
+- if(hp != GLOBUS_NULL)
+- {
++ if(hp != GLOBUS_NULL)
++ {
+ memcpy(result, hp, sizeof(struct hostent));
+ if(globus_l_libc_copy_hostent_data_to_buffer(
+ result,
+@@ -768,28 +768,28 @@ globus_libc_gethostbyname_r(
+ hp = GLOBUS_NULL;
+ }
+ else
+- {
++ {
+ hp = result;
+ }
+-
+- if (h_errnop != GLOBUS_NULL)
+- {
+- *h_errnop = 0;
+- }
+- }
+- else
+- {
+- if (h_errnop != GLOBUS_NULL)
+- {
+- *h_errnop = h_errno;
+- }
+- }
++
++ if (h_errnop != GLOBUS_NULL)
++ {
++ *h_errnop = 0;
++ }
++ }
++ else
++ {
++ if (h_errnop != GLOBUS_NULL)
++ {
++ *h_errnop = h_errno;
++ }
++ }
+ }
+ # elif defined(GLOBUS_HAVE_GETHOSTBYNAME_R_3)
+ {
+- rc = gethostbyname_r(hostname,
+- result,
+- &hp_data);
++ rc = gethostbyname_r(hostname,
++ result,
++ &hp_data);
+ if(rc == 0)
+ {
+ if(globus_l_libc_copy_hostent_data_to_buffer(
+@@ -798,7 +798,7 @@ globus_libc_gethostbyname_r(
+ hp = GLOBUS_NULL;
+ }
+ else
+- {
++ {
+ hp = result;
+ }
+ if(h_errnop != GLOBUS_NULL)
+@@ -818,23 +818,23 @@ globus_libc_gethostbyname_r(
+ # elif defined(GLOBUS_HAVE_GETHOSTBYNAME_R_5)
+ {
+ hp = gethostbyname_r(hostname,
+- result,
+- buffer,
+- buflen,
+- h_errnop);
++ result,
++ buffer,
++ buflen,
++ h_errnop);
+ }
+ # elif defined(GLOBUS_HAVE_GETHOSTBYNAME_R_6)
+ {
+ rc = gethostbyname_r(hostname,
+- result,
+- buffer,
+- buflen,
+- &hp,
+- h_errnop);
++ result,
++ buffer,
++ buflen,
++ &hp,
++ h_errnop);
+ }
+ # else
+ {
+- GLOBUS_HAVE_GETHOSTBYNAME symbol must be defined!!!;
++ GLOBUS_HAVE_GETHOSTBYNAME symbol must be defined!!!;
+ }
+ # endif
+
+@@ -847,23 +847,23 @@ globus_libc_gethostbyname_r(
+ */
+ if (hp == GLOBUS_NULL)
+ {
+- if(isdigit(hostname[0]))
+- {
+- struct in_addr addr;
+-
+- addr.s_addr = inet_addr(hostname);
+- if ((int) addr.s_addr != -1)
+- {
+- hp = globus_libc_gethostbyaddr_r(
+- (void *) &addr,
+- sizeof(addr),
+- AF_INET,
+- result,
+- buffer,
+- buflen,
+- h_errnop);
+- }
+- }
++ if(isdigit(hostname[0]))
++ {
++ struct in_addr addr;
++
++ addr.s_addr = inet_addr(hostname);
++ if ((int) addr.s_addr != -1)
++ {
++ hp = globus_libc_gethostbyaddr_r(
++ (void *) &addr,
++ sizeof(addr),
++ AF_INET,
++ result,
++ buffer,
++ buflen,
++ h_errnop);
++ }
++ }
+ }
+
+ return hp;
+@@ -881,24 +881,24 @@ Returns:
+ ******************************************************************************/
+ struct hostent *
+ globus_libc_gethostbyaddr_r(char *addr,
+- int length,
+- int type,
+- struct hostent *result,
+- char *buffer,
+- int buflen,
+- int *h_errnop)
++ int length,
++ int type,
++ struct hostent *result,
++ char *buffer,
++ int buflen,
++ int *h_errnop)
+ {
+ struct hostent *hp=GLOBUS_NULL;
+ # if defined(GLOBUS_HAVE_GETHOSTBYADDR_R_5)
+ struct hostent_data hp_data;
+- int rc;
++ int rc;
+ # endif
+
+ # if defined(GLOBUS_HAVE_GETHOSTBYADDR_R_8)
+- int rc;
++ int rc;
+ # endif
+ # if defined(GLOBUS_HAVE_GETHOSTBYADDR_R_7)
+- int rc;
++ int rc;
+ # endif
+
+
+@@ -907,8 +907,8 @@ globus_libc_gethostbyaddr_r(char *addr,
+ # if !defined(HAVE_GETHOSTBYADDR_R)
+ {
+ hp = gethostbyaddr(addr, length, type);
+- if(hp != GLOBUS_NULL)
+- {
++ if(hp != GLOBUS_NULL)
++ {
+ memcpy(result, hp, sizeof(struct hostent));
+ if(globus_l_libc_copy_hostent_data_to_buffer(
+ result, buffer, buflen) == -1)
+@@ -916,31 +916,31 @@ globus_libc_gethostbyaddr_r(char *addr,
+ hp = GLOBUS_NULL;
+ }
+ else
+- {
++ {
+ hp = result;
+ }
+- if (h_errnop != GLOBUS_NULL)
+- {
+- *h_errnop = h_errno;
+- }
+- }
+- else
+- {
+- if (h_errnop != GLOBUS_NULL)
+- {
+- *h_errnop = h_errno;
+- }
+- }
++ if (h_errnop != GLOBUS_NULL)
++ {
++ *h_errnop = h_errno;
++ }
++ }
++ else
++ {
++ if (h_errnop != GLOBUS_NULL)
++ {
++ *h_errnop = h_errno;
++ }
++ }
+ }
+ # elif defined(GLOBUS_HAVE_GETHOSTBYADDR_R_5)
+ {
+- rc = gethostbyaddr_r(addr,
+- length,
+- type,
+- result,
+- &hp_data);
++ rc = gethostbyaddr_r(addr,
++ length,
++ type,
++ result,
++ &hp_data);
+ if(rc == 0)
+- {
++ {
+ if(globus_l_libc_copy_hostent_data_to_buffer(
+ result, buffer, buflen) == -1)
+ {
+@@ -950,45 +950,45 @@ globus_libc_gethostbyaddr_r(char *addr,
+ {
+ hp = result;
+ }
+-
+- if (h_errnop != GLOBUS_NULL)
+- {
+- *h_errnop = h_errno;
+- }
++
++ if (h_errnop != GLOBUS_NULL)
++ {
++ *h_errnop = h_errno;
++ }
+ }
+- else
+- {
+- hp = GLOBUS_NULL;
+- if (h_errnop != GLOBUS_NULL)
+- {
+- *h_errnop = h_errno;
+- }
++ else
++ {
++ hp = GLOBUS_NULL;
++ if (h_errnop != GLOBUS_NULL)
++ {
++ *h_errnop = h_errno;
++ }
+ }
+ }
+ # elif defined(GLOBUS_HAVE_GETHOSTBYADDR_R_7)
+ {
+ hp = gethostbyaddr_r(addr,
+- length,
+- type,
+- result,
+- buffer,
+- buflen,
+- h_errnop);
++ length,
++ type,
++ result,
++ buffer,
++ buflen,
++ h_errnop);
+ }
+ # elif defined(GLOBUS_HAVE_GETHOSTBYADDR_R_8)
+ {
+ rc = gethostbyaddr_r(addr,
+- length,
+- type,
+- result,
+- buffer,
+- buflen,
+- &hp,
+- h_errnop);
++ length,
++ type,
++ result,
++ buffer,
++ buflen,
++ &hp,
++ h_errnop);
+ }
+ # else
+ {
+- GLOBUS_HAVE_GETHOSTBYADDR symbol must be defined!!!;
++ GLOBUS_HAVE_GETHOSTBYADDR symbol must be defined!!!;
+ }
+ # endif
+
+@@ -1009,35 +1009,35 @@ Returns:
+ ******************************************************************************/
+ char *
+ globus_libc_ctime_r(time_t *clock,
+- char *buf,
+- int buflen)
++ char *buf,
++ int buflen)
+ {
+ char *tmp_buf;
+
+ # if !defined(HAVE_CTIME_R)
+ {
+- globus_libc_lock();
+- tmp_buf = ctime(clock);
++ globus_libc_lock();
++ tmp_buf = ctime(clock);
+
+- if(tmp_buf != GLOBUS_NULL)
+- {
+- strncpy(buf,tmp_buf,buflen);
+- }
+- globus_libc_unlock();
++ if(tmp_buf != GLOBUS_NULL)
++ {
++ strncpy(buf,tmp_buf,buflen);
++ }
++ globus_libc_unlock();
+
+- tmp_buf = buf;
++ tmp_buf = buf;
+ }
+ # endif
+
+ # if defined(GLOBUS_HAVE_CTIME_R_2)
+ {
+- tmp_buf = ctime_r(clock, buf);
++ tmp_buf = ctime_r(clock, buf);
+ }
+ # endif
+
+ # if defined(GLOBUS_HAVE_CTIME_R_3)
+ {
+- tmp_buf = ctime_r(clock, buf, buflen);
++ tmp_buf = ctime_r(clock, buf, buflen);
+ }
+ # endif
+
+@@ -1056,23 +1056,23 @@ Returns:
+ ******************************************************************************/
+ struct tm *
+ globus_libc_localtime_r(
+- const time_t *timep,
++ const time_t *timep,
+ struct tm *result)
+ {
+ struct tm * tmp_tm;
+-
++
+ # if !defined(HAVE_LOCALTIME_R)
+ {
+- globus_libc_lock();
+- tmp_tm = localtime(timep);
++ globus_libc_lock();
++ tmp_tm = localtime(timep);
+
+- if(tmp_tm != GLOBUS_NULL)
+- {
+- memcpy(result, tmp_tm, sizeof(struct tm));
+- }
+- globus_libc_unlock();
++ if(tmp_tm != GLOBUS_NULL)
++ {
++ memcpy(result, tmp_tm, sizeof(struct tm));
++ }
++ globus_libc_unlock();
+
+- tmp_tm = result;
++ tmp_tm = result;
+ }
+ # else
+ {
+@@ -1095,23 +1095,23 @@ Returns:
+ ******************************************************************************/
+ struct tm *
+ globus_libc_gmtime_r(
+- const time_t *timep,
++ const time_t *timep,
+ struct tm *result)
+ {
+ struct tm * tmp_tm;
+-
++
+ # if !defined(HAVE_GMTIME_R)
+ {
+- globus_libc_lock();
+- tmp_tm = gmtime(timep);
++ globus_libc_lock();
++ tmp_tm = gmtime(timep);
+
+- if(tmp_tm != GLOBUS_NULL)
+- {
+- memcpy(result, tmp_tm, sizeof(struct tm));
+- }
+- globus_libc_unlock();
++ if(tmp_tm != GLOBUS_NULL)
++ {
++ memcpy(result, tmp_tm, sizeof(struct tm));
++ }
++ globus_libc_unlock();
+
+- tmp_tm = result;
++ tmp_tm = result;
+ }
+ # else
+ {
+@@ -1140,10 +1140,10 @@ Returns:
+ ******************************************************************************/
+ int
+ globus_libc_getpwnam_r(char *name,
+- struct passwd *pwd,
+- char *buffer,
+- int buflen,
+- struct passwd **result)
++ struct passwd *pwd,
++ char *buffer,
++ int buflen,
++ struct passwd **result)
+ {
+ return getpwnam_r(name, pwd, buffer, buflen, result);
+ } /* globus_libc_getpwnam_r */
+@@ -1162,10 +1162,10 @@ Returns:
+ #endif
+ int
+ globus_libc_getpwuid_r(uid_t uid,
+- struct passwd *pwd,
+- char *buffer,
+- int buflen,
+- struct passwd **result)
++ struct passwd *pwd,
++ char *buffer,
++ int buflen,
++ struct passwd **result)
+ {
+ return getpwuid_r(uid, pwd, buffer, buflen, result);
+ } /* globus_libc_getpwuid_r */
+@@ -1191,25 +1191,25 @@ globus_l_libc_copy_hostent_data_to_buffer(
+ char ** ptr;
+ char ** ptr_buffer = (char **) buffer;
+ int num_ptrs=0;
+-
++
+ /* list of addresses from name server */
+ if(h->h_addr_list != GLOBUS_NULL)
+ {
+- for(ptr = h->h_addr_list; (*ptr) != GLOBUS_NULL; ptr++)
+- {
+- num_ptrs++;
+- }
+- num_ptrs++;
++ for(ptr = h->h_addr_list; (*ptr) != GLOBUS_NULL; ptr++)
++ {
++ num_ptrs++;
++ }
++ num_ptrs++;
+ }
+
+ if(h->h_aliases != GLOBUS_NULL)
+ {
+- /* host aliases */
+- for(ptr = h->h_aliases; *ptr != GLOBUS_NULL; ptr++)
+- {
+- num_ptrs++;
+- }
+- num_ptrs++;
++ /* host aliases */
++ for(ptr = h->h_aliases; *ptr != GLOBUS_NULL; ptr++)
++ {
++ num_ptrs++;
++ }
++ num_ptrs++;
+ }
+
+ offset += num_ptrs * sizeof(char *);
+@@ -1218,68 +1218,68 @@ globus_l_libc_copy_hostent_data_to_buffer(
+ {
+ return -1;
+ }
+-
++
+ /* official hostname of host */
+ if(h->h_name != NULL)
+- {
+- size_t name_len;
++ {
++ size_t name_len;
+
+- name_len = strlen(h->h_name);
+- if(name_len + 1 + offset > buflen)
+- {
++ name_len = strlen(h->h_name);
++ if(name_len + 1 + offset > buflen)
++ {
+ return -1;
+- }
++ }
+
+ strncpy(&buffer[offset], h->h_name, name_len);
+- buffer[offset + name_len] = '\0';
+- h->h_name = &buffer[offset];
++ buffer[offset + name_len] = '\0';
++ h->h_name = &buffer[offset];
+ offset += name_len + 1;
+ }
+
+ /* list of addresses from name server */
+ if(h->h_addr_list != GLOBUS_NULL)
+ {
+- size_t addrsize = h->h_length;
++ size_t addrsize = h->h_length;
+
+- ptr = h->h_addr_list;
+- h->h_addr_list = ptr_buffer;
++ ptr = h->h_addr_list;
++ h->h_addr_list = ptr_buffer;
+
+- for(; (*ptr) != GLOBUS_NULL; ptr++)
+- {
+- if(offset + addrsize > buflen)
+- {
++ for(; (*ptr) != GLOBUS_NULL; ptr++)
++ {
++ if(offset + addrsize > buflen)
++ {
+ return -1;
+- }
++ }
+
+ memcpy(&buffer[offset], *ptr, addrsize);
+ *ptr_buffer = &buffer[offset];
+ ptr_buffer++;
+ offset += addrsize;
+- }
+- *ptr_buffer = GLOBUS_NULL;
+- ptr_buffer++;
+- }
++ }
++ *ptr_buffer = GLOBUS_NULL;
++ ptr_buffer++;
++ }
+
+ if(h->h_aliases != GLOBUS_NULL)
+ {
+- ptr = h->h_aliases;
+- h->h_aliases = ptr_buffer;
++ ptr = h->h_aliases;
++ h->h_aliases = ptr_buffer;
+
+- /* host aliases */
+- for(; *ptr != GLOBUS_NULL; ptr++)
+- {
+- if(strlen(*ptr) + offset + 1 > buflen)
+- {
++ /* host aliases */
++ for(; *ptr != GLOBUS_NULL; ptr++)
++ {
++ if(strlen(*ptr) + offset + 1 > buflen)
++ {
+ return -1;
+- }
+-
++ }
++
+ strcpy(&buffer[offset], *ptr);
+ *ptr_buffer = &buffer[offset];
+ ptr_buffer++;
+ offset += strlen(*ptr) + 1;
+- }
+- *ptr_buffer = GLOBUS_NULL;
+- ptr_buffer++;
++ }
++ *ptr_buffer = GLOBUS_NULL;
++ ptr_buffer++;
+ }
+ return 0;
+ } /* globus_l_libc_copy_hostent_data_to_buffer() */
+@@ -1342,59 +1342,59 @@ globus_libc_gethomedir(char *result, int bufsize)
+ char * p;
+ struct passwd * pwres;
+
+-
++
+ globus_libc_lock();
+ if (!initialized)
+ {
+- globus_mutex_init(&gethomedir_mutex,
+- (globus_mutexattr_t *) GLOBUS_NULL);
+- initialized = GLOBUS_TRUE;
++ globus_mutex_init(&gethomedir_mutex,
++ (globus_mutexattr_t *) GLOBUS_NULL);
++ initialized = GLOBUS_TRUE;
+ }
+ globus_libc_unlock();
+
+ globus_mutex_lock(&gethomedir_mutex);
+ {
+- rc = 0;
+-
+- if (homedir_len == 0)
+- {
+- p = getenv("HOME");
+- if (!p || strlen(p)==0)
+- {
+- p = GLOBUS_NULL;
+- rc = globus_libc_getpwuid_r(geteuid(),
+- &pw,
+- buf,
+- 1024,
+- &pwres);
+-
+- if (!rc && pwres && pwres->pw_dir)
+- p = pwres->pw_dir;
+- }
+-
+- if (!rc && p)
+- {
+- len = strlen(p);
+- homedir = globus_malloc(len + 1);
+- if (homedir)
+- {
+- memcpy(homedir, p, len);
+- homedir[len] = '\0';
+- homedir_len = strlen(homedir);
+- }
+- else
+- rc = -1;
+- }
+- }
+-
+- if (homedir_len > bufsize)
+- rc = -1;
+-
+- if (!rc)
+- {
+- memcpy(result, homedir, homedir_len);
+- result[homedir_len] = '\0';
+- }
++ rc = 0;
++
++ if (homedir_len == 0)
++ {
++ p = getenv("HOME");
++ if (!p || strlen(p)==0)
++ {
++ p = GLOBUS_NULL;
++ rc = globus_libc_getpwuid_r(geteuid(),
++ &pw,
++ buf,
++ 1024,
++ &pwres);
++
++ if (!rc && pwres && pwres->pw_dir)
++ p = pwres->pw_dir;
++ }
++
++ if (!rc && p)
++ {
++ len = strlen(p);
++ homedir = globus_malloc(len + 1);
++ if (homedir)
++ {
++ memcpy(homedir, p, len);
++ homedir[len] = '\0';
++ homedir_len = strlen(homedir);
++ }
++ else
++ rc = -1;
++ }
++ }
++
++ if (homedir_len > bufsize)
++ rc = -1;
++
++ if (!rc)
++ {
++ memcpy(result, homedir, homedir_len);
++ result[homedir_len] = '\0';
++ }
+ }
+ globus_mutex_unlock(&gethomedir_mutex);
+
+@@ -1472,13 +1472,13 @@ globus_libc_strdup(const char * string)
+
+ if(string)
+ {
+- l = strlen(string);
++ l = strlen(string);
+
+- ns = globus_malloc(sizeof(char) * (l + 1));
+- if(ns)
+- {
+- memcpy(ns, string, l + 1);
+- }
++ ns = globus_malloc(sizeof(char) * (l + 1));
++ if(ns)
++ {
++ memcpy(ns, string, l + 1);
++ }
+ }
+
+ return ns;
+@@ -1500,7 +1500,7 @@ globus_libc_strndup(const char * string, globus_size_t length)
+ {
+ for(i = 0; i < length && string[i] != '\0'; i++)
+ ns[i] = string[i];
+-
++
+ ns[i] = '\0';
+ }
+ }
+@@ -1526,8 +1526,8 @@ Returns:
+
+ int
+ globus_libc_lseek(int fd,
+- globus_off_t offset,
+- int whence)
++ globus_off_t offset,
++ int whence)
+ {
+ int rc;
+ int save_errno;
+@@ -1574,19 +1574,19 @@ globus_libc_telldir(DIR *dirp)
+
+ if(dirp != GLOBUS_NULL)
+ {
+- globus_libc_lock();
++ globus_libc_lock();
+
+- pos = telldir(dirp);
+- save_errno=errno;
++ pos = telldir(dirp);
++ save_errno=errno;
+
+- globus_libc_unlock();
+- errno = save_errno;
++ globus_libc_unlock();
++ errno = save_errno;
+
+- return pos;
++ return pos;
+ }
+ else
+ {
+- return pos;
++ return pos;
+ }
+ }
+ #endif /* defined(HAVE_TELLDIR) */
+@@ -1595,21 +1595,21 @@ globus_libc_telldir(DIR *dirp)
+ #undef globus_libc_seekdir
+ extern void
+ globus_libc_seekdir(DIR *dirp,
+- long loc)
++ long loc)
+ {
+ int save_errno;
+
+ if(dirp != GLOBUS_NULL)
+ {
+- globus_libc_lock();
++ globus_libc_lock();
+
+- seekdir(dirp, loc);
++ seekdir(dirp, loc);
+
+- save_errno = errno;
++ save_errno = errno;
+
+- globus_libc_unlock();
+- errno = save_errno;
+- return;
++ globus_libc_unlock();
++ errno = save_errno;
++ return;
+ }
+ }
+ #endif /* defined(HAVE_SEEKDIR) */
+@@ -1623,15 +1623,15 @@ globus_libc_rewinddir(DIR *dirp)
+
+ if(dirp != GLOBUS_NULL)
+ {
+- globus_libc_lock();
++ globus_libc_lock();
+
+- rewinddir(dirp);
++ rewinddir(dirp);
+
+- save_errno = errno;
++ save_errno = errno;
+
+- globus_libc_unlock();
+- errno = save_errno;
+- return;
++ globus_libc_unlock();
++ errno = save_errno;
++ return;
+ }
+ #else
+ errno = EINVAL;
+@@ -1664,116 +1664,116 @@ globus_libc_closedir(DIR *dirp)
+ #undef globus_libc_readdir_r
+ extern int
+ globus_libc_readdir_r(DIR *dirp,
+- struct dirent **result)
++ struct dirent **result)
+ {
+ #if HAVE_DIRENT_H
+ #if !defined(HAVE_READDIR_R)
+ {
+- struct dirent *tmpdir, *entry;
+- int save_errno;
++ struct dirent *tmpdir, *entry;
++ int save_errno;
+
+- globus_libc_lock();
++ globus_libc_lock();
+
+- tmpdir = readdir(dirp);
+- save_errno = errno;
++ tmpdir = readdir(dirp);
++ save_errno = errno;
+
+- if(tmpdir == GLOBUS_NULL)
+- {
+- *result = GLOBUS_NULL;
++ if(tmpdir == GLOBUS_NULL)
++ {
++ *result = GLOBUS_NULL;
+
+- globus_libc_unlock();
++ globus_libc_unlock();
+
+- errno = save_errno;
++ errno = save_errno;
+
+- return -1;
+- }
++ return -1;
++ }
+
+- entry = (struct dirent *) globus_malloc(offsetof(struct dirent, d_name)
+- + strlen(tmpdir->d_name)
+- + 1);
++ entry = (struct dirent *) globus_malloc(offsetof(struct dirent, d_name)
++ + strlen(tmpdir->d_name)
++ + 1);
+
+- /* copy returned buffer into data structure */
+- entry->d_ino = tmpdir->d_ino;
++ /* copy returned buffer into data structure */
++ entry->d_ino = tmpdir->d_ino;
+ # if defined(GLOBUS_HAVE_DIRENT_OFF)
+- {
+- entry->d_off = tmpdir->d_off;
+- }
++ {
++ entry->d_off = tmpdir->d_off;
++ }
+ # endif
+ # if defined(GLOBUS_HAVE_DIRENT_OFFSET)
+- {
+- entry->d_offset = tmpdir->d_offset;
+- }
++ {
++ entry->d_offset = tmpdir->d_offset;
++ }
+ # endif
+ # if defined(GLOBUS_HAVE_DIRENT_TYPE)
+- {
+- entry->d_type = tmpdir->d_type;
+- }
++ {
++ entry->d_type = tmpdir->d_type;
++ }
+ # endif
+-# if defined(GLOBUS_HAVE_DIRENT_RECLEN)
+- {
+- entry->d_reclen = tmpdir->d_reclen;
+- }
++# if defined(GLOBUS_HAVE_DIRENT_RECLEN)
++ {
++ entry->d_reclen = tmpdir->d_reclen;
++ }
+ # endif
+- strcpy(&entry->d_name[0], &tmpdir->d_name[0]);
++ strcpy(&entry->d_name[0], &tmpdir->d_name[0]);
+
+- *result = entry;
+- globus_libc_unlock();
+- errno = save_errno;
+- return 0;
++ *result = entry;
++ globus_libc_unlock();
++ errno = save_errno;
++ return 0;
+ }
+ # else
+ {
+- int errno;
++ int errno;
+
+ # if defined(GLOBUS_HAVE_READDIR_R_3)
+- {
+- int rc = 0;
+- struct dirent *entry = globus_malloc(offsetof(struct dirent, d_name)
+- + NAME_MAX
+- + 1);
++ {
++ int rc = 0;
++ struct dirent *entry = globus_malloc(offsetof(struct dirent, d_name)
++ + NAME_MAX
++ + 1);
+
+- rc = readdir_r(dirp, entry, result);
++ rc = readdir_r(dirp, entry, result);
+
+ if(rc != 0 || *result == NULL)
+ {
+- globus_free(entry);
+- *result = GLOBUS_NULL;
++ globus_free(entry);
++ *result = GLOBUS_NULL;
+ }
+ return rc;
+- }
++ }
+ # elif defined(GLOBUS_HAVE_READDIR_R_2)
+- {
+- struct dirent *entry = globus_malloc(offsetof(struct dirent, d_name)
+- + NAME_MAX
+- + 1);
+- int rc=0;
++ {
++ struct dirent *entry = globus_malloc(offsetof(struct dirent, d_name)
++ + NAME_MAX
++ + 1);
++ int rc=0;
+
+ # if defined(TARGET_ARCH_SOLARIS)
+- {
+- *result = readdir_r(dirp, entry);
+- if(*result == GLOBUS_NULL)
+- {
+- rc = -1;
+- }
+- }
++ {
++ *result = readdir_r(dirp, entry);
++ if(*result == GLOBUS_NULL)
++ {
++ rc = -1;
++ }
++ }
+ # elif defined(TARGET_ARCH_HPUX)
+- {
+- rc = readdir_r(dirp, entry);
+- *result = entry;
+- }
++ {
++ rc = readdir_r(dirp, entry);
++ *result = entry;
++ }
+ # endif
+
+- if(rc != GLOBUS_SUCCESS)
+- {
+- globus_free(entry);
+- *result = GLOBUS_NULL;
+- return rc;
+- }
+- else
+- {
+- return 0;
+- }
+- }
++ if(rc != GLOBUS_SUCCESS)
++ {
++ globus_free(entry);
++ *result = GLOBUS_NULL;
++ return rc;
++ }
++ else
++ {
++ return 0;
++ }
++ }
+ # endif
+ }
+ # endif
+@@ -1787,14 +1787,14 @@ globus_libc_readdir_r(DIR *dirp,
+ int
+ globus_libc_vprintf_length(const char * fmt, va_list ap)
+ {
+- static FILE * devnull = GLOBUS_NULL;
++ static FILE * devnull = GLOBUS_NULL;
+ int save_errno;
+
+ globus_libc_lock();
+ if(devnull == GLOBUS_NULL)
+ {
+ #ifndef _WIN32
+- devnull = fopen("/dev/null", "w");
++ devnull = fopen("/dev/null", "w");
+
+ if(devnull == GLOBUS_NULL)
+ {
+@@ -1805,7 +1805,7 @@ globus_libc_vprintf_length(const char * fmt, va_list ap)
+ }
+ fcntl(fileno(devnull), F_SETFD, FD_CLOEXEC);
+ #else
+- devnull = fopen("NUL", "w");
++ devnull = fopen("NUL", "w");
+ if(devnull == GLOBUS_NULL)
+ {
+ save_errno = errno;
+@@ -1881,7 +1881,7 @@ globus_common_v_create_string(
+ va_list ap_copy;
+
+ globus_libc_va_copy(ap_copy,ap);
+-
++
+ len = globus_libc_vprintf_length(format,ap_copy);
+
+ va_end(ap_copy);
+@@ -1890,19 +1890,19 @@ globus_common_v_create_string(
+ {
+ return NULL;
+ }
+-
++
+ len++;
+
+ if((new_string = malloc(len)) == NULL)
+ {
+ return NULL;
+ }
+-
++
+ globus_libc_vsnprintf(new_string,
+ len,
+ format,
+ ap);
+-
++
+ return new_string;
+ }
+
+@@ -1970,37 +1970,37 @@ globus_libc_vsnprintf(char *s, size_t n, const char *format, va_list ap)
+ STACK_DIRECTION = 0 => direction of growth unknown */
+
+ #ifndef STACK_DIRECTION
+-#define STACK_DIRECTION 0 /* Direction unknown. */
++#define STACK_DIRECTION 0 /* Direction unknown. */
+ #endif
+
+ #if STACK_DIRECTION != 0
+
+-#define STACK_DIR STACK_DIRECTION /* Known at compile-time. */
++#define STACK_DIR STACK_DIRECTION /* Known at compile-time. */
+
+ #else /* STACK_DIRECTION == 0; need run-time code. */
+
+-static int stack_dir=0; /* 1 or -1 once known. */
+-#define STACK_DIR stack_dir
++static int stack_dir=0; /* 1 or -1 once known. */
++#define STACK_DIR stack_dir
+
+ static void
+ find_stack_direction ()
+ {
+- static char *addr = GLOBUS_NULL; /* Address of first `dummy', once known. */
+- auto char dummy; /* To get stack address. */
++ static char *addr = GLOBUS_NULL; /* Address of first `dummy', once known. */
++ auto char dummy; /* To get stack address. */
+
+ if (addr == GLOBUS_NULL)
+- { /* Initial entry. */
++ { /* Initial entry. */
+ addr = ADDRESS_FUNCTION (dummy);
+
+- find_stack_direction (); /* Recurse once. */
++ find_stack_direction (); /* Recurse once. */
+ }
+ else
+ {
+ /* Second entry. */
+ if (ADDRESS_FUNCTION (dummy) > addr)
+- stack_dir = 1; /* Stack grew upward. */
++ stack_dir = 1; /* Stack grew upward. */
+ else
+- stack_dir = -1; /* Stack grew downward. */
++ stack_dir = -1; /* Stack grew downward. */
+ }
+ }
+
+@@ -2012,21 +2012,21 @@ find_stack_direction ()
+ It is very important that sizeof(header) agree with malloc
+ alignment chunk size. The following default should work okay. */
+
+-#ifndef ALIGN_SIZE
+-#define ALIGN_SIZE sizeof(double)
++#ifndef ALIGN_SIZE
++#define ALIGN_SIZE sizeof(double)
+ #endif
+
+ typedef union hdr
+ {
+- char align[ALIGN_SIZE]; /* To force sizeof(header). */
++ char align[ALIGN_SIZE]; /* To force sizeof(header). */
+ struct
+ {
+- union hdr *next; /* For chaining headers. */
+- char *deep; /* For stack depth measure. */
++ union hdr *next; /* For chaining headers. */
++ char *deep; /* For stack depth measure. */
+ } h;
+ } header;
+
+-static header *last_alloca_header = GLOBUS_NULL; /* -> last alloca header. */
++static header *last_alloca_header = GLOBUS_NULL; /* -> last alloca header. */
+
+ /* Return a pointer to at least SIZE bytes of storage,
+ which will be automatically reclaimed upon exit from
+@@ -2039,11 +2039,11 @@ void *
+ alloca (size)
+ unsigned size;
+ {
+- auto char probe; /* Probes stack depth: */
++ auto char probe; /* Probes stack depth: */
+ register char *depth = ADDRESS_FUNCTION (probe);
+
+ #if STACK_DIRECTION == 0
+- if (STACK_DIR == 0) /* Unknown growth direction. */
++ if (STACK_DIR == 0) /* Unknown growth direction. */
+ find_stack_direction ();
+ #endif
+
+@@ -2051,7 +2051,7 @@ alloca (size)
+ was allocated from deeper in the stack than currently. */
+
+ {
+- register header *hp; /* Traverses linked list. */
++ register header *hp; /* Traverses linked list. */
+
+ #ifdef emacs
+ BLOCK_INPUT;
+@@ -2059,18 +2059,18 @@ alloca (size)
+
+ for (hp = last_alloca_header; hp != GLOBUS_NULL;)
+ if ((STACK_DIR > 0 && hp->h.deep > depth)
+- || (STACK_DIR < 0 && hp->h.deep < depth))
+- {
+- register header *np = hp->h.next;
++ || (STACK_DIR < 0 && hp->h.deep < depth))
++ {
++ register header *np = hp->h.next;
+
+- free ((void *) hp); /* Collect garbage. */
++ free ((void *) hp); /* Collect garbage. */
+
+- hp = np; /* -> next header. */
+- }
++ hp = np; /* -> next header. */
++ }
+ else
+- break; /* Rest are not deeper. */
++ break; /* Rest are not deeper. */
+
+- last_alloca_header = hp; /* -> last valid storage. */
++ last_alloca_header = hp; /* -> last valid storage. */
+
+ #ifdef emacs
+ UNBLOCK_INPUT;
+@@ -2078,7 +2078,7 @@ alloca (size)
+ }
+
+ if (size == 0)
+- return GLOBUS_NULL; /* No allocation required. */
++ return GLOBUS_NULL; /* No allocation required. */
+
+ /* Allocate combined header + user data storage. */
+
+@@ -2107,10 +2107,10 @@ alloca (size)
+ /* Stack structures for CRAY-1, CRAY X-MP, and CRAY Y-MP */
+ struct stack_control_header
+ {
+- long shgrow:32; /* Number of times stack has grown. */
+- long shaseg:32; /* Size of increments to stack. */
+- long shhwm:32; /* High water mark of stack. */
+- long shsize:32; /* Current size of stack (all segments). */
++ long shgrow:32; /* Number of times stack has grown. */
++ long shaseg:32; /* Size of increments to stack. */
++ long shhwm:32; /* High water mark of stack. */
++ long shsize:32; /* Current size of stack (all segments). */
+ };
+
+ /* The stack segment linkage control information occurs at
+@@ -2122,21 +2122,21 @@ struct stack_control_header
+
+ struct stack_segment_linkage
+ {
+- long ss[0200]; /* 0200 overflow words. */
+- long sssize:32; /* Number of words in this segment. */
+- long ssbase:32; /* Offset to stack base. */
++ long ss[0200]; /* 0200 overflow words. */
++ long sssize:32; /* Number of words in this segment. */
++ long ssbase:32; /* Offset to stack base. */
+ long:32;
+- long sspseg:32; /* Offset to linkage control of previous
+- segment of stack. */
++ long sspseg:32; /* Offset to linkage control of previous
++ segment of stack. */
+ long:32;
+- long sstcpt:32; /* Pointer to task common address block. */
+- long sscsnm; /* Private control structure number for
+- microtasking. */
+- long ssusr1; /* Reserved for user. */
+- long ssusr2; /* Reserved for user. */
+- long sstpid; /* Process ID for pid based multi-tasking. */
+- long ssgvup; /* Pointer to multitasking thread giveup. */
+- long sscray[7]; /* Reserved for Cray Research. */
++ long sstcpt:32; /* Pointer to task common address block. */
++ long sscsnm; /* Private control structure number for
++ microtasking. */
++ long ssusr1; /* Reserved for user. */
++ long ssusr2; /* Reserved for user. */
++ long sstpid; /* Process ID for pid based multi-tasking. */
++ long ssgvup; /* Pointer to multitasking thread giveup. */
++ long sscray[7]; /* Reserved for Cray Research. */
+ long ssa0;
+ long ssa1;
+ long ssa2;
+@@ -2160,27 +2160,27 @@ struct stack_segment_linkage
+ returned by the STKSTAT library routine. */
+ struct stk_stat
+ {
+- long now; /* Current total stack size. */
+- long maxc; /* Amount of contiguous space which would
+- be required to satisfy the maximum
+- stack demand to date. */
+- long high_water; /* Stack high-water mark. */
+- long overflows; /* Number of stack overflow ($STKOFEN) calls. */
+- long hits; /* Number of internal buffer hits. */
+- long extends; /* Number of block extensions. */
+- long stko_mallocs; /* Block allocations by $STKOFEN. */
+- long underflows; /* Number of stack underflow calls ($STKRETN). */
+- long stko_free; /* Number of deallocations by $STKRETN. */
+- long stkm_free; /* Number of deallocations by $STKMRET. */
+- long segments; /* Current number of stack segments. */
+- long maxs; /* Maximum number of stack segments so far. */
+- long pad_size; /* Stack pad size. */
+- long current_address; /* Current stack segment address. */
+- long current_size; /* Current stack segment size. This
+- number is actually corrupted by STKSTAT to
+- include the fifteen word trailer area. */
+- long initial_address; /* Address of initial segment. */
+- long initial_size; /* Size of initial segment. */
++ long now; /* Current total stack size. */
++ long maxc; /* Amount of contiguous space which would
++ be required to satisfy the maximum
++ stack demand to date. */
++ long high_water; /* Stack high-water mark. */
++ long overflows; /* Number of stack overflow ($STKOFEN) calls. */
++ long hits; /* Number of internal buffer hits. */
++ long extends; /* Number of block extensions. */
++ long stko_mallocs; /* Block allocations by $STKOFEN. */
++ long underflows; /* Number of stack underflow calls ($STKRETN). */
++ long stko_free; /* Number of deallocations by $STKRETN. */
++ long stkm_free; /* Number of deallocations by $STKMRET. */
++ long segments; /* Current number of stack segments. */
++ long maxs; /* Maximum number of stack segments so far. */
++ long pad_size; /* Stack pad size. */
++ long current_address; /* Current stack segment address. */
++ long current_size; /* Current stack segment size. This
++ number is actually corrupted by STKSTAT to
++ include the fifteen word trailer area. */
++ long initial_address; /* Address of initial segment. */
++ long initial_size; /* Size of initial segment. */
+ };
+
+ /* The following structure describes the data structure which trails
+@@ -2189,13 +2189,13 @@ struct stk_stat
+
+ struct stk_trailer
+ {
+- long this_address; /* Address of this block. */
+- long this_size; /* Size of this block (does not include
+- this trailer). */
++ long this_address; /* Address of this block. */
++ long this_size; /* Size of this block (does not include
++ this trailer). */
+ long unknown2;
+ long unknown3;
+- long link; /* Address of trailer block of previous
+- segment. */
++ long link; /* Address of trailer block of previous
++ segment. */
+ long unknown5;
+ long unknown6;
+ long unknown7;
+@@ -2233,8 +2233,8 @@ globus_l_libc_i00afunc (long *address)
+ /* Set up the iteration. */
+
+ trailer = (struct stk_trailer *) (status.current_address
+- + status.current_size
+- - 15);
++ + status.current_size
++ - 15);
+
+ /* There must be at least one stack segment. Therefore it is
+ a fatal error if "trailer" is null. */
+@@ -2249,10 +2249,10 @@ globus_l_libc_i00afunc (long *address)
+ block = (long *) trailer->this_address;
+ size = trailer->this_size;
+ if (block == 0 || size == 0)
+- abort ();
++ abort ();
+ trailer = (struct stk_trailer *) trailer->link;
+ if ((block <= address) && (address < (block + size)))
+- break;
++ break;
+ }
+
+ /* Set the result to the offset in this segment and add the sizes
+@@ -2268,7 +2268,7 @@ globus_l_libc_i00afunc (long *address)
+ do
+ {
+ if (trailer->this_size <= 0)
+- abort ();
++ abort ();
+ result += trailer->this_size;
+ trailer = (struct stk_trailer *) trailer->link;
+ }
+@@ -2331,7 +2331,7 @@ globus_l_libc_i00afunc (long address)
+ fprintf (stderr, "%011o %011o %011o\n", this_segment, address, stkl);
+ #endif
+ if (pseg == 0)
+- break;
++ break;
+ stkl = stkl - pseg;
+ ssptr = (struct stack_segment_linkage *) stkl;
+ size = ssptr->sssize;
+@@ -2377,11 +2377,11 @@ globus_l_libc_copy_addrinfo(
+ globus_addrinfo_t * new_addrinfo;
+ globus_addrinfo_t * addrinfo;
+ char * canonname = NULL;
+-
++
+ addrinfo = in_addrinfo;
+ if(addrinfo)
+ {
+- new_addrinfo = (globus_addrinfo_t *)
++ new_addrinfo = (globus_addrinfo_t *)
+ globus_malloc(sizeof(globus_addrinfo_t));
+ memcpy(new_addrinfo, addrinfo, sizeof(globus_addrinfo_t));
+ new_addrinfo->ai_addr = (struct sockaddr *)
+@@ -2397,19 +2397,19 @@ globus_l_libc_copy_addrinfo(
+ addrinfo;
+ addrinfo = addrinfo->ai_next)
+ {
+- new_addrinfo->ai_next = (globus_addrinfo_t *)
++ new_addrinfo->ai_next = (globus_addrinfo_t *)
+ globus_malloc(sizeof(globus_addrinfo_t));
+ new_addrinfo = new_addrinfo->ai_next;
+ memcpy(new_addrinfo, addrinfo, sizeof(globus_addrinfo_t));
+ new_addrinfo->ai_addr = (struct sockaddr *)
+ globus_malloc(addrinfo->ai_addrlen);
+- memcpy(new_addrinfo->ai_addr, addrinfo->ai_addr,
++ memcpy(new_addrinfo->ai_addr, addrinfo->ai_addr,
+ addrinfo->ai_addrlen);
+ new_addrinfo->ai_canonname = canonname;
+ }
+ }
+-
+- return 0;
++
++ return 0;
+ }
+ #endif
+
+@@ -2423,7 +2423,7 @@ globus_libc_getaddrinfo(
+ int rc;
+ globus_result_t result;
+ const char * port_str = service;
+-
++
+ #ifdef TARGET_ARCH_AIX5
+ if(port_str && port_str[0] == '0' && port_str[1] == '\0')
+ {
+@@ -2434,7 +2434,7 @@ globus_libc_getaddrinfo(
+ port_str = "56789";
+ }
+ #endif
+-
++
+ result = GLOBUS_SUCCESS;
+
+ rc = getaddrinfo(node, port_str, hints, res);
+@@ -2474,7 +2474,7 @@ globus_libc_getaddrinfo(
+ #ifdef TARGET_ARCH_AIX5
+ {
+ globus_addrinfo_t * addrinfo;
+-
++
+ /* aix's getaddrinfo also doesnt fill in the family and len fields of
+ * the sockaddrs
+ */
+@@ -2526,7 +2526,7 @@ globus_libc_getnameinfo(
+ /*
+ * Code to work around a bug in getnameinfo() on OS X on Intel (bug
+ * #4292 in Globus bugzilla).
+- * Problem observed on OS X 10.4.8:
++ * Problem observed on OS X 10.4.8:
+ * getnameinfo() fails to convert port number to host byte order
+ * when generating service port string. If the host is requested
+ * in numeric form, a different code path in getnameinfo() is used
+@@ -2685,7 +2685,7 @@ globus_libc_addr_is_loopback(
+ switch(_addr->sa_family)
+ {
+ case AF_INET:
+- if(*(uint8_t *) &((struct sockaddr_in *)
++ if(*(uint8_t *) &((struct sockaddr_in *)
+ _addr)->sin_addr.s_addr == 127)
+ {
+ result = GLOBUS_TRUE;
+@@ -2695,8 +2695,8 @@ globus_libc_addr_is_loopback(
+ case AF_INET6:
+ if(IN6_IS_ADDR_LOOPBACK(&((struct sockaddr_in6 *) _addr)->sin6_addr) ||
+ (IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *) _addr)->sin6_addr) &&
+- *(uint8_t *) &((struct sockaddr_in6 *)
+- _addr)->sin6_addr.s6_addr[12] == 127))
++ *(uint8_t *) &((struct sockaddr_in6 *)
++ _addr)->sin6_addr.s6_addr[12] == 127))
+ {
+ result = GLOBUS_TRUE;
+ }
+@@ -2717,7 +2717,7 @@ globus_libc_addr_is_wildcard(
+ {
+ struct sockaddr * _addr = (struct sockaddr *) addr;
+ globus_bool_t result = GLOBUS_FALSE;
+-
++
+ switch(_addr->sa_family)
+ {
+ case AF_INET:
+@@ -2740,7 +2740,7 @@ globus_libc_addr_is_wildcard(
+ break;
+ #endif
+ default:
+- printf("%d\n%d\n", _addr->sa_family, AF_INET6);
++ printf("%d\n%d\n", _addr->sa_family, AF_INET6);
+ globus_assert(0 &&
+ "Unknown family in globus_libc_addr_is_wildcard");
+ break;
+@@ -2859,7 +2859,7 @@ globus_libc_addr_to_contact_string(
+ int port_no;
+ int ni_flags = 0;
+ char * cs;
+-
++
+ if(!GlobusLibcProtocolFamilyIsIP(GlobusLibcSockaddrGetFamily(*addr)))
+ {
+ result = globus_error_put(
+@@ -2873,12 +2873,12 @@ globus_libc_addr_to_contact_string(
+ "Invalid addr family"));
+ goto error_nameinfo;
+ }
+-
++
+ if(opts_mask & GLOBUS_LIBC_ADDR_LOCAL ||
+ globus_libc_addr_is_wildcard(addr))
+ {
+ int family;
+-
++
+ #if AF_INET6
+ family = (opts_mask & GLOBUS_LIBC_ADDR_IPV6)
+ ? AF_INET6 : ((opts_mask & GLOBUS_LIBC_ADDR_IPV4)
+@@ -2887,7 +2887,7 @@ globus_libc_addr_to_contact_string(
+ family = (opts_mask & GLOBUS_LIBC_ADDR_IPV4)
+ ? AF_INET : AF_UNSPEC;
+ #endif
+-
++
+ if(globus_libc_gethostaddr_by_family(&myaddr, family) != 0)
+ {
+ result = globus_error_put(
+@@ -2901,12 +2901,12 @@ globus_libc_addr_to_contact_string(
+ "globus_libc_gethostaddr failed"));
+ goto error_nameinfo;
+ }
+-
++
+ GlobusLibcSockaddrGetPort(*addr, port_no);
+ GlobusLibcSockaddrSetPort(myaddr, port_no);
+ addr = &myaddr;
+ }
+-
++
+ ni_flags = GLOBUS_NI_NUMERICSERV;
+
+ if(opts_mask & GLOBUS_LIBC_ADDR_NUMERIC)
+@@ -2920,7 +2920,7 @@ globus_libc_addr_to_contact_string(
+ {
+ goto error_nameinfo;
+ }
+-
++
+ cs = globus_malloc(strlen(host) + strlen(port) + 4);
+ if(!cs)
+ {
+@@ -2935,7 +2935,7 @@ globus_libc_addr_to_contact_string(
+ "malloc failed"));
+ goto error_memory;
+ }
+-
++
+ if(strchr(host, ':'))
+ {
+ sprintf(cs, "[%s]:%s", host, port);
+@@ -2944,9 +2944,9 @@ globus_libc_addr_to_contact_string(
+ {
+ sprintf(cs, "%s:%s", host, port);
+ }
+-
++
+ *contact_string = cs;
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_memory:
+@@ -2955,7 +2955,7 @@ error_nameinfo:
+ }
+
+ /** convert a numeric contact string to an array of ints
+- *
++ *
+ * (port is optional and may be NULL. 0 will be passed back if no port is
+ * found)
+ * host needs to have room for at least 16 ints
+@@ -2977,13 +2977,13 @@ globus_libc_contact_string_to_ints(
+ struct in6_addr addr6;
+ #endif
+ unsigned char * paddr;
+-#ifdef WIN32
++#ifdef WIN32
+ int rc;
+ struct addrinfo hints;
+ struct addrinfo * pres = NULL;
+ struct sockaddr_in6 sockaddr6;
+ #endif
+-
++
+ memset(host, 0, sizeof(int) * 16);
+ strncpy(buf, contact_string, sizeof(buf));
+ buf[255] = 0;
+@@ -3014,7 +3014,7 @@ globus_libc_contact_string_to_ints(
+ else
+ {
+ char * pbuf = buf;
+-
++
+ *count = 16;
+ if(*pbuf == '[')
+ {
+@@ -3028,7 +3028,7 @@ globus_libc_contact_string_to_ints(
+ if(*(s++) != ':')
+ {
+ s = NULL;
+- }
++ }
+ }
+ else
+ {
+@@ -3057,7 +3057,7 @@ globus_libc_contact_string_to_ints(
+ {
+ goto error_parse;
+ }
+-
++
+ paddr = (unsigned char *) &((struct sockaddr_in6*)pres->ai_addr)->sin6_addr;
+ #else
+ #ifdef AF_INET6
+@@ -3071,7 +3071,7 @@ globus_libc_contact_string_to_ints(
+ #endif
+ #endif
+ }
+-
++
+ if(port)
+ {
+ *port = 0;
+@@ -3080,7 +3080,7 @@ globus_libc_contact_string_to_ints(
+ sscanf(s, "%hu", port);
+ }
+ }
+-
++
+ for(i = 0; i < *count; i++)
+ {
+ host[i] = paddr[i];
+@@ -3092,9 +3092,9 @@ globus_libc_contact_string_to_ints(
+ }
+ #endif
+
+-
++
+ return GLOBUS_SUCCESS;
+-
++
+ error_parse:
+ return globus_error_put(
+ globus_error_construct_error(
+@@ -3121,7 +3121,7 @@ globus_libc_ints_to_contact_string(
+ int b = 0;
+ globus_bool_t need_bracket = GLOBUS_FALSE;
+ globus_bool_t compressed = GLOBUS_FALSE;
+-
++
+ if(count == 16)
+ {
+ if(port)
+@@ -3129,7 +3129,7 @@ globus_libc_ints_to_contact_string(
+ layout[l++] = "[";
+ need_bracket = GLOBUS_TRUE;
+ }
+-
++
+ /* count up leading zeros */
+ while(h < 16 && host[h] == 0) h++;
+ if(h == 12)
+@@ -3166,7 +3166,7 @@ globus_libc_ints_to_contact_string(
+ {
+ layout[l++] = ":";
+ }
+-
++
+ h += 6;
+ while(h < 15 && host[h] == 0 && host[h + 1] == 0) h += 2;
+ }
+@@ -3181,43 +3181,43 @@ globus_libc_ints_to_contact_string(
+ snprintf(bufs[b], 10, "%X%.2X",
+ host[h] & 0xff, host[h + 1] & 0xff);
+ }
+-
++
+ layout[l++] = bufs[b++];
+ if(h < 14)
+ {
+ layout[l++] = ":";
+ }
+-
++
+ h += 2;
+ }
+ }
+ }
+ }
+-
++
+ if(count == 4)
+ {
+ snprintf(ipv4, sizeof(ipv4),
+ "%d.%d.%d.%d", host[h + 0], host[h + 1], host[h + 2], host[h + 3]);
+ layout[l++] = ipv4;
+ }
+-
++
+ if(need_bracket)
+ {
+ layout[l++] = "]";
+ }
+-
++
+ if(port && l > 0)
+ {
+ sprintf(bufs[b], ":%d", (int) port);
+ layout[l++] = bufs[b++];
+ }
+-
++
+ return globus_libc_join((const char **)layout, l);
+ }
+
+ /**
+ * create a new string from all of the strings in array
+- *
++ *
+ * @param array
+ * an array of strings to concatenate (null entries are skipped)
+ * @param count
+@@ -3232,24 +3232,24 @@ globus_libc_join(
+ int len;
+ char * s;
+ int i;
+-
++
+ if(count <= 0)
+ {
+ return NULL;
+ }
+-
++
+ lens = (int *) globus_malloc(sizeof(int) * count);
+ if(!lens)
+ {
+ return NULL;
+ }
+-
++
+ len = 0;
+ for(i = 0; i < count; i++)
+ {
+ len += lens[i] = array[i] ? strlen(array[i]) : 0;
+ }
+-
++
+ if(len)
+ {
+ s = (char *) globus_malloc(sizeof(char) * (len + 1));
+@@ -3264,7 +3264,7 @@ globus_libc_join(
+ len += lens[i];
+ }
+ }
+-
++
+ s[len] = '\0';
+ }
+ }
+@@ -3272,9 +3272,9 @@ globus_libc_join(
+ {
+ s = NULL;
+ }
+-
++
+ globus_free(lens);
+-
++
+ return s;
+ }
+
+diff --git a/common/source/library/globus_logging.c b/common/source/library/globus_logging.c
+index 2a09c25a7..1e023389c 100644
+--- a/common/source/library/globus_logging.c
++++ b/common/source/library/globus_logging.c
+@@ -121,7 +121,7 @@ globus_l_logging_periodic(
+
+ globus_mutex_lock(&handle->mutex);
+ {
+- globus_l_logging_flush(handle);
++ globus_l_logging_flush(handle);
+ }
+ globus_mutex_unlock(&handle->mutex);
+ }
+@@ -145,7 +145,7 @@ globus_logging_init(
+ globus_logging_handle_t * out_handle,
+ globus_reltime_t * flush_period,
+ int buffer_length_in,
+- int log_type,
++ int log_type,
+ globus_logging_module_t * module,
+ void * user_arg)
+ {
+@@ -171,7 +171,7 @@ globus_logging_init(
+ {
+ buffer_length = GLOBUS_L_LOGGING_MAX_MESSAGE;
+ }
+-
++
+ if(module == NULL || module->write_func == NULL)
+ {
+ res = GlobusLoggingErrorParameter("module");
+@@ -187,7 +187,7 @@ globus_logging_init(
+ }
+
+ globus_l_logging_pid = getpid();
+-
++
+ handle->module.open_func = module->open_func;
+ handle->module.write_func = module->write_func;
+ handle->module.close_func = module->close_func;
+@@ -203,7 +203,7 @@ globus_logging_init(
+ {
+ handle->module.open_func(handle->user_arg);
+ }
+-
++
+ GlobusTimeReltimeSet(zero, 0, 0);
+ if(flush_period != NULL && globus_reltime_cmp(flush_period, &zero) != 0)
+ {
+@@ -276,7 +276,7 @@ globus_logging_vwrite(
+ handle->used_length += nbytes;
+ remain -= nbytes;
+ }
+- rc = vsnprintf((char *) &handle->buffer[handle->used_length],
++ rc = vsnprintf((char *) &handle->buffer[handle->used_length],
+ remain, fmt, ap);
+ if (rc < 0)
+ {
+@@ -289,24 +289,24 @@ globus_logging_vwrite(
+ if(nbytes > remain)
+ {
+ char suffix[64];
+-
++
+ globus_libc_snprintf(
+- suffix,
+- sizeof(suffix),
+- " *** TRUNCATED %lu bytes\n",
++ suffix,
++ sizeof(suffix),
++ " *** TRUNCATED %lu bytes\n",
+ (unsigned long) (nbytes - remain + sizeof(suffix)));
+-
++
+ memcpy(
+- &handle->buffer[handle->buffer_length - sizeof(suffix)],
++ &handle->buffer[handle->buffer_length - sizeof(suffix)],
+ suffix,
+ sizeof(suffix));
+-
++
+ nbytes = remain - sizeof(suffix) + strlen(suffix);
+ }
+ handle->used_length += nbytes;
+ remain -= nbytes;
+
+- if(type & GLOBUS_LOGGING_INLINE ||
++ if(type & GLOBUS_LOGGING_INLINE ||
+ handle->type_mask & GLOBUS_LOGGING_INLINE ||
+ remain < GLOBUS_L_LOGGING_MAX_MESSAGE)
+ {
+@@ -321,7 +321,7 @@ globus_logging_vwrite(
+ err:
+ return res;
+ }
+-
++
+ globus_result_t
+ globus_logging_write(
+ globus_logging_handle_t handle,
+@@ -447,14 +447,14 @@ globus_logging_ng_header_func(
+ if(gettimeofday(&tv, NULL) == 0)
+ {
+ globus_libc_gmtime_r(&tv.tv_sec, &tm);
+- nbytes = snprintf(buf, *len, "ts=%04d-%02d-%02dT%02d:%02d:%02d.%06dZ id=%d ",
+- tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+- tm.tm_hour, tm.tm_min, tm.tm_sec , (int) tv.tv_usec,
++ nbytes = snprintf(buf, *len, "ts=%04d-%02d-%02dT%02d:%02d:%02d.%06dZ id=%d ",
++ tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
++ tm.tm_hour, tm.tm_min, tm.tm_sec , (int) tv.tv_usec,
+ globus_l_logging_pid);
+ }
+ else
+ {
+- nbytes = snprintf(buf, *len, "ts=0000-00-00T00:00:00.000000Z id=%d ",
++ nbytes = snprintf(buf, *len, "ts=0000-00-00T00:00:00.000000Z id=%d ",
+ globus_l_logging_pid);
+ }
+ if(nbytes < 0)
+@@ -481,7 +481,7 @@ globus_logging_syslog_close_func(
+ {
+ closelog();
+ }
+-
++
+ void
+ globus_logging_syslog_write_func(
+ globus_byte_t * buf,
+diff --git a/common/source/library/globus_module.c b/common/source/library/globus_module.c
+index 838005f49..e9e9b8cac 100644
+--- a/common/source/library/globus_module.c
++++ b/common/source/library/globus_module.c
+@@ -22,7 +22,7 @@
+ #endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
+
+ /******************************************************************************
+- Include header files
++ Include header files
+ ******************************************************************************/
+ #include "globus_i_common_config.h"
+ #include "globus_common_include.h"
+@@ -36,7 +36,7 @@
+ #include "globus_thread.h"
+
+ /******************************************************************************
+- Type definitions
++ Type definitions
+ ******************************************************************************/
+
+ /*
+@@ -52,10 +52,10 @@ static globus_thread_key_t globus_l_deactivate_parent_key;
+ */
+ typedef struct
+ {
+- globus_mutex_t mutex;
+- globus_cond_t cond;
+- globus_thread_t thread_id;
+- int level;
++ globus_mutex_t mutex;
++ globus_cond_t cond;
++ globus_thread_t thread_id;
++ int level;
+ } globus_l_module_mutex_t;
+
+ /*
+@@ -64,15 +64,15 @@ typedef struct
+ typedef globus_module_activation_func_t globus_l_module_key_t;
+ typedef struct
+ {
+- globus_module_descriptor_t * descriptor;
+- globus_list_t * clients;
+- int reference_count;
++ globus_module_descriptor_t * descriptor;
++ globus_list_t * clients;
++ int reference_count;
+ globus_module_deactivate_proxy_cb_t deactivate_cb;
+ void * user_arg;
+ } globus_l_module_entry_t;
+
+ /******************************************************************************
+- Define module specific variables
++ Define module specific variables
+ ******************************************************************************/
+
+ globus_bool_t
+@@ -84,59 +84,59 @@ static globus_bool_t
+ globus_l_environ_mutex_initialized = GLOBUS_FALSE;
+
+ /* Recursive mutex to protect internal data structures */
+-static globus_l_module_mutex_t globus_l_module_mutex;
++static globus_l_module_mutex_t globus_l_module_mutex;
+
+ /* Hash table and list to maintain a table of registered modules */
+ const int GLOBUS_L_MODULE_TABLE_SIZE = 13;
+-static globus_hashtable_t globus_l_module_table;
+-static globus_list_t * globus_l_module_list;
++static globus_hashtable_t globus_l_module_table;
++static globus_list_t * globus_l_module_list;
+
+ /* Hash table for globus_environ*/
+ const int GLOBUS_L_ENVIRON_TABLE_SIZE = 13;
+-static globus_mutex_t globus_l_environ_hashtable_mutex;
+-static globus_hashtable_t globus_l_environ_table;
++static globus_mutex_t globus_l_environ_hashtable_mutex;
++static globus_hashtable_t globus_l_environ_table;
+
+ globus_list_t *globus_l_module_atexit_funcs = GLOBUS_NULL;
+
+ /******************************************************************************
+- Module specific function prototypes
++ Module specific function prototypes
+ ******************************************************************************/
+ static void
+ globus_l_module_initialize();
+
+ static globus_bool_t
+ globus_l_module_increment(
+- globus_module_descriptor_t * module_descriptor,
+- globus_l_module_key_t parent_key,
++ globus_module_descriptor_t * module_descriptor,
++ globus_l_module_key_t parent_key,
+ globus_module_deactivate_proxy_cb_t deactivate_cb,
+ void * user_arg);
+
+ static globus_l_module_entry_t *
+ globus_l_module_decrement(
+- globus_module_descriptor_t * module_descriptor,
+- globus_l_module_key_t parent_key);
++ globus_module_descriptor_t * module_descriptor,
++ globus_l_module_key_t parent_key);
+
+ static
+ int
+ globus_l_module_reference_count(
+- globus_module_descriptor_t * module_descriptor);
++ globus_module_descriptor_t * module_descriptor);
+ /******************************************************************************
+- Recursive mutex function prototypes
++ Recursive mutex function prototypes
+ ******************************************************************************/
+ static void
+ globus_l_module_mutex_init(
+- globus_l_module_mutex_t * mutex);
++ globus_l_module_mutex_t * mutex);
+
+ static void
+ globus_l_module_mutex_lock(
+- globus_l_module_mutex_t * mutex);
++ globus_l_module_mutex_t * mutex);
+
+ static void
+ globus_l_module_mutex_unlock(
+- globus_l_module_mutex_t * mutex);
+-
++ globus_l_module_mutex_t * mutex);
++
+ /******************************************************************************
+- API function definitions
++ API function definitions
+ ******************************************************************************/
+
+ #if USE_SYMBOL_LABELS
+@@ -167,14 +167,14 @@ __attribute__ ((externally_visible))
+ #endif
+ int
+ globus_module_activate_proxy(
+- globus_module_descriptor_t * module_descriptor,
++ globus_module_descriptor_t * module_descriptor,
+ globus_module_deactivate_proxy_cb_t deactivate_cb,
+ void * user_arg)
+ {
+ globus_l_module_key_t parent_key;
+ int ret_val;
+ globus_l_module_key_t parent_key_save;
+-
++
+ /*
+ * If this is the first time this routine has been called, then we need to
+ * initialize the internal data structures and activate the threads
+@@ -182,10 +182,10 @@ globus_module_activate_proxy(
+ */
+ if (globus_i_module_initialized == GLOBUS_FALSE)
+ {
+- globus_i_module_initialized = GLOBUS_TRUE;
+- globus_l_module_initialize();
++ globus_i_module_initialized = GLOBUS_TRUE;
++ globus_l_module_initialize();
+ }
+-
++
+ parent_key = (globus_l_module_key_t)
+ globus_thread_getspecific(globus_l_activate_parent_key);
+ /*
+@@ -195,22 +195,22 @@ globus_module_activate_proxy(
+ */
+ globus_l_module_mutex_lock(&globus_l_module_mutex);
+ {
+- ret_val = GLOBUS_SUCCESS;
+-
+- if (module_descriptor->activation_func != GLOBUS_NULL)
+- {
+- if (globus_l_module_increment(module_descriptor,
+- parent_key,
+- deactivate_cb,
+- user_arg) == GLOBUS_TRUE)
+- {
+- parent_key_save = parent_key;
+- globus_thread_setspecific(
+- globus_l_activate_parent_key,
+- module_descriptor->activation_func);
+-
+- ret_val = module_descriptor->activation_func();
+-
++ ret_val = GLOBUS_SUCCESS;
++
++ if (module_descriptor->activation_func != GLOBUS_NULL)
++ {
++ if (globus_l_module_increment(module_descriptor,
++ parent_key,
++ deactivate_cb,
++ user_arg) == GLOBUS_TRUE)
++ {
++ parent_key_save = parent_key;
++ globus_thread_setspecific(
++ globus_l_activate_parent_key,
++ module_descriptor->activation_func);
++
++ ret_val = module_descriptor->activation_func();
++
+ if(ret_val != GLOBUS_SUCCESS)
+ {
+ globus_l_module_decrement(
+@@ -218,9 +218,9 @@ globus_module_activate_proxy(
+ }
+ else
+ {
+- /*
+- * Set up the exit handler
+- */
++ /*
++ * Set up the exit handler
++ */
+ if(module_descriptor->atexit_func != GLOBUS_NULL)
+ {
+ /* only call the atexit function once */
+@@ -236,11 +236,11 @@ globus_module_activate_proxy(
+ }
+ }
+ }
+-
++
+ globus_thread_setspecific(
+- globus_l_activate_parent_key, parent_key_save);
+- }
+- }
++ globus_l_activate_parent_key, parent_key_save);
++ }
++ }
+ }
+ globus_l_module_mutex_unlock(&globus_l_module_mutex);
+
+@@ -264,7 +264,7 @@ __attribute__ ((externally_visible))
+ #endif
+ int
+ globus_module_activate(
+- globus_module_descriptor_t * module_descriptor)
++ globus_module_descriptor_t * module_descriptor)
+ {
+ return globus_module_activate_proxy(module_descriptor, NULL, NULL);
+ }
+@@ -276,7 +276,7 @@ globus_module_activate(
+ * Activate an NULL-terminated array of modules. If any fail to activate, all
+ * are deactivated and the error from the failed activation is returned. If
+ * nonzero is returned, and failed_module is non-NULL, it will be set to point
+- * to the 1st module which failed to activate.
++ * to the 1st module which failed to activate.
+ * @param module_array
+ * NULL-terminated array of module descriptors to activate.
+ * @param failed_module
+@@ -329,7 +329,7 @@ __attribute__ ((externally_visible))
+ #endif
+ int
+ globus_module_activate_proxy_compat(
+- globus_module_descriptor_t * module_descriptor,
++ globus_module_descriptor_t * module_descriptor,
+ globus_module_deactivate_proxy_cb_t deactivate_cb,
+ void * user_arg)
+ {
+@@ -350,7 +350,7 @@ __attribute__ ((externally_visible))
+ #endif
+ int
+ globus_module_activate_compat(
+- globus_module_descriptor_t * module_descriptor)
++ globus_module_descriptor_t * module_descriptor)
+ {
+ int rc;
+ rc = globus_thread_set_model("pthread");
+@@ -393,11 +393,11 @@ globus_module_activate_array_compat(
+ */
+ int
+ globus_module_deactivate(
+- globus_module_descriptor_t * module_descriptor)
++ globus_module_descriptor_t * module_descriptor)
+ {
+ globus_l_module_key_t parent_key;
+- int ret_val;
+- globus_l_module_key_t parent_key_save;
++ int ret_val;
++ globus_l_module_key_t parent_key_save;
+
+
+ /*
+@@ -405,9 +405,9 @@ globus_module_deactivate(
+ */
+ if (!globus_i_module_initialized)
+ {
+- return GLOBUS_FAILURE;
++ return GLOBUS_FAILURE;
+ }
+-
++
+ parent_key = (globus_l_module_key_t)
+ globus_thread_getspecific(globus_l_deactivate_parent_key);
+ /*
+@@ -419,19 +419,19 @@ globus_module_deactivate(
+ if (module_descriptor->activation_func != GLOBUS_NULL)
+ {
+ globus_l_module_entry_t * entry;
+-
++
+ globus_l_module_mutex_lock(&globus_l_module_mutex);
+-
++
+ entry = globus_l_module_decrement(module_descriptor, parent_key);
+ if (entry && entry->reference_count == 0)
+ {
+ globus_l_module_mutex_unlock(&globus_l_module_mutex);
+-
++
+ parent_key_save = parent_key;
+ globus_thread_setspecific(
+ globus_l_deactivate_parent_key,
+ module_descriptor->activation_func);
+-
++
+ if(entry->deactivate_cb)
+ {
+ ret_val = entry->deactivate_cb(
+@@ -441,7 +441,7 @@ globus_module_deactivate(
+ {
+ ret_val = module_descriptor->deactivation_func();
+ }
+-
++
+ globus_thread_setspecific(
+ globus_l_deactivate_parent_key, parent_key_save);
+ }
+@@ -470,39 +470,39 @@ globus_module_deactivate_all(void)
+ */
+ if (!globus_i_module_initialized)
+ {
+- return GLOBUS_FAILURE;
++ return GLOBUS_FAILURE;
+ }
+-
++
+ globus_l_module_mutex_lock(&globus_l_module_mutex);
+ {
+- globus_bool_t deactivated_one;
+-
+- deactivated_one = GLOBUS_TRUE;
+-
+- while(deactivated_one)
+- {
+- globus_list_t * module_list;
+-
+- module_list = globus_l_module_list;
+- deactivated_one = GLOBUS_FALSE;
+-
+- while(!globus_list_empty(module_list))
+- {
+- globus_l_module_entry_t *module_entry;
+-
+- module_entry = globus_list_first(module_list);
+- module_list = globus_list_rest(module_list);
+-
+- if(globus_list_empty(module_entry->clients) &&
+- module_entry->reference_count > 0)
+- {
+- globus_l_module_mutex_unlock(&globus_l_module_mutex);
+- globus_module_deactivate(module_entry->descriptor);
+- globus_l_module_mutex_lock(&globus_l_module_mutex);
+- deactivated_one = GLOBUS_TRUE;
+- }
+- }
+- }
++ globus_bool_t deactivated_one;
++
++ deactivated_one = GLOBUS_TRUE;
++
++ while(deactivated_one)
++ {
++ globus_list_t * module_list;
++
++ module_list = globus_l_module_list;
++ deactivated_one = GLOBUS_FALSE;
++
++ while(!globus_list_empty(module_list))
++ {
++ globus_l_module_entry_t *module_entry;
++
++ module_entry = globus_list_first(module_list);
++ module_list = globus_list_rest(module_list);
++
++ if(globus_list_empty(module_entry->clients) &&
++ module_entry->reference_count > 0)
++ {
++ globus_l_module_mutex_unlock(&globus_l_module_mutex);
++ globus_module_deactivate(module_entry->descriptor);
++ globus_l_module_mutex_lock(&globus_l_module_mutex);
++ deactivated_one = GLOBUS_TRUE;
++ }
++ }
++ }
+ }
+ globus_l_module_mutex_unlock(&globus_l_module_mutex);
+
+@@ -517,7 +517,7 @@ globus_module_deactivate_all(void)
+
+ void *
+ globus_module_get_module_pointer(
+- globus_module_descriptor_t * structptr)
++ globus_module_descriptor_t * structptr)
+ {
+ void * retptr;
+ void * (*module_func)();
+@@ -525,7 +525,7 @@ globus_module_get_module_pointer(
+ module_func=structptr->get_pointer_func;
+
+ if (module_func!=NULL)
+- {
++ {
+ retptr=(*module_func)();
+ }
+ else
+@@ -534,20 +534,20 @@ globus_module_get_module_pointer(
+ }
+
+ return(retptr);
+-}
++}
+ /*globus_module_get_module_pointer();*/
+
+
+ /*
+ * globus_module_setenv();
+- */
++ */
+
+ void
+ globus_module_setenv(
+ const char * name,
+ const char * value)
+ {
+- int rc;
++ int rc;
+
+ /*
+ * First, check to see if the environment mutex has been initialized
+@@ -555,38 +555,38 @@ globus_module_setenv(
+
+ if(globus_l_environ_mutex_initialized == GLOBUS_FALSE)
+ {
+- if(globus_i_module_initialized == GLOBUS_TRUE)
+- {
+- rc = globus_mutex_init(&globus_l_environ_hashtable_mutex,
++ if(globus_i_module_initialized == GLOBUS_TRUE)
++ {
++ rc = globus_mutex_init(&globus_l_environ_hashtable_mutex,
+ (globus_mutexattr_t *) GLOBUS_NULL);
+ globus_assert (rc == 0);
+- globus_l_environ_mutex_initialized = GLOBUS_TRUE;
+- }
++ globus_l_environ_mutex_initialized = GLOBUS_TRUE;
++ }
+ }
+-
++
+ /*
+ * then, check to see if the environment hash table has been initialized
+ */
+-
++
+
+ if(globus_l_environ_initialized == GLOBUS_FALSE)
+ {
+- if(globus_i_module_initialized==GLOBUS_TRUE)
+- {
+- globus_mutex_lock(&globus_l_environ_hashtable_mutex);
+- }
++ if(globus_i_module_initialized==GLOBUS_TRUE)
++ {
++ globus_mutex_lock(&globus_l_environ_hashtable_mutex);
++ }
+
+ globus_hashtable_init(&globus_l_environ_table,
+ GLOBUS_L_ENVIRON_TABLE_SIZE,
+ globus_hashtable_string_hash,
+ globus_hashtable_string_keyeq);
+
+- globus_l_environ_initialized = GLOBUS_TRUE;
++ globus_l_environ_initialized = GLOBUS_TRUE;
+
+- if(globus_i_module_initialized == GLOBUS_TRUE)
+- {
+- globus_mutex_unlock(&globus_l_environ_hashtable_mutex);
+- }
++ if(globus_i_module_initialized == GLOBUS_TRUE)
++ {
++ globus_mutex_unlock(&globus_l_environ_hashtable_mutex);
++ }
+ }
+
+ /*
+@@ -595,12 +595,12 @@ globus_module_setenv(
+
+ if(globus_i_module_initialized == GLOBUS_TRUE)
+ {
+- globus_mutex_lock(&globus_l_environ_hashtable_mutex);
++ globus_mutex_lock(&globus_l_environ_hashtable_mutex);
+ }
+
+ globus_hashtable_remove(
+- &globus_l_environ_table,
+- (void *) name);
++ &globus_l_environ_table,
++ (void *) name);
+ globus_hashtable_insert(
+ &globus_l_environ_table,
+ (void *) name,
+@@ -608,7 +608,7 @@ globus_module_setenv(
+
+ if(globus_i_module_initialized == GLOBUS_TRUE)
+ {
+- globus_mutex_unlock(&globus_l_environ_hashtable_mutex);
++ globus_mutex_unlock(&globus_l_environ_hashtable_mutex);
+ }
+
+ }
+@@ -618,31 +618,31 @@ globus_module_setenv(
+ * globus_module_getenv();
+ */
+
+-char *
++char *
+ globus_module_getenv(
+ const char * name)
+ {
+- char * entry;
++ char * entry;
+
+ if(globus_l_environ_initialized == GLOBUS_TRUE)
+ {
+- if((globus_i_module_initialized == GLOBUS_TRUE)
+- &&(globus_l_environ_mutex_initialized == GLOBUS_TRUE))
+- {
+- globus_mutex_lock(&globus_l_environ_hashtable_mutex);
+- }
++ if((globus_i_module_initialized == GLOBUS_TRUE)
++ &&(globus_l_environ_mutex_initialized == GLOBUS_TRUE))
++ {
++ globus_mutex_lock(&globus_l_environ_hashtable_mutex);
++ }
+
+ entry =
+ globus_hashtable_lookup(
+ &globus_l_environ_table,
+- (void *) name);
++ (void *) name);
+
+
+- if((globus_i_module_initialized == GLOBUS_TRUE)
+- &&(globus_l_environ_mutex_initialized == GLOBUS_TRUE))
+- {
+- globus_mutex_unlock(&globus_l_environ_hashtable_mutex);
+- }
++ if((globus_i_module_initialized == GLOBUS_TRUE)
++ &&(globus_l_environ_mutex_initialized == GLOBUS_TRUE))
++ {
++ globus_mutex_unlock(&globus_l_environ_hashtable_mutex);
++ }
+ }
+ else
+ {
+@@ -655,7 +655,7 @@ globus_module_getenv(
+
+ if (entry!=GLOBUS_NULL)
+ {
+- return(entry);
++ return(entry);
+ }
+
+ /*
+@@ -666,7 +666,7 @@ globus_module_getenv(
+
+ if (entry!=NULL)
+ {
+- return(entry);
++ return(entry);
+ }
+
+ return(GLOBUS_NULL);
+@@ -695,22 +695,22 @@ globus_module_getenv(
+
+ int
+ globus_module_get_version(
+- globus_module_descriptor_t * module_descriptor,
++ globus_module_descriptor_t * module_descriptor,
+ globus_version_t * version)
+ {
+ globus_version_t * module_version;
+-
++
+ module_version = module_descriptor->version;
+-
++
+ if(!module_version)
+ {
+ return GLOBUS_FAILURE;
+ }
+-
+- version->major = module_version->major;
+- version->minor = module_version->minor;
+- version->timestamp = module_version->timestamp;
+- version->branch_id = module_version->branch_id;
++
++ version->major = module_version->major;
++ version->minor = module_version->minor;
++ version->timestamp = module_version->timestamp;
++ version->branch_id = module_version->branch_id;
+
+ return GLOBUS_SUCCESS;
+ }
+@@ -719,7 +719,7 @@ globus_module_get_version(
+ /**
+ * print module's version
+ *
+- * This function prints a modules version info using the standard form
++ * This function prints a modules version info using the standard form
+ * provided by globus_version_print
+ *
+ * @param module_descriptor
+@@ -729,7 +729,7 @@ globus_module_get_version(
+ * stream to print on (stdout, stderr, etc)
+ *
+ * @param verbose
+- * If GLOBUS_TRUE, then all available version info is printed
++ * If GLOBUS_TRUE, then all available version info is printed
+ * (ex: globus_module: 1.1 (1013708618-5))
+ * else, only the major.minor is printed (ex: globus_module: 1.1)
+ *
+@@ -739,7 +739,7 @@ globus_module_get_version(
+
+ void
+ globus_module_print_version(
+- globus_module_descriptor_t * module_descriptor,
++ globus_module_descriptor_t * module_descriptor,
+ FILE * stream,
+ globus_bool_t verbose)
+ {
+@@ -753,14 +753,14 @@ globus_module_print_version(
+ /**
+ * print all activated modules' versions
+ *
+- * This function prints all activated modules' version info using the standard
++ * This function prints all activated modules' version info using the standard
+ * form provided by globus_version_print
+ *
+ * @param stream
+ * stream to print on (stdout, stderr, etc)
+ *
+ * @param verbose
+- * If GLOBUS_TRUE, then all available version info is printed
++ * If GLOBUS_TRUE, then all available version info is printed
+ * (ex: globus_module: 1.1 (1013708618-5))
+ * else, only the major.minor is printed (ex: globus_module: 1.1)
+ *
+@@ -781,19 +781,19 @@ globus_module_print_activated_versions(
+ {
+ return;
+ }
+-
++
+ globus_l_module_mutex_lock(&globus_l_module_mutex);
+ {
+- globus_list_t * module_list;
+-
++ globus_list_t * module_list;
++
+ module_list = globus_l_module_list;
+ while(!globus_list_empty(module_list))
+ {
+ globus_l_module_entry_t * module_entry;
+-
++
+ module_entry = globus_list_first(module_list);
+ module_list = globus_list_rest(module_list);
+-
++
+ if(module_entry->reference_count > 0)
+ {
+ globus_version_print(
+@@ -818,7 +818,7 @@ globus_module_print_activated_versions(
+ * name: major.minor if verbose = false
+ * name: major.minor.timestamp-branch_id if verbose = true
+ *
+- * In either case, if name is NULL, then only the numerical version will be
++ * In either case, if name is NULL, then only the numerical version will be
+ * printed.
+ *
+ * @param name
+@@ -832,7 +832,7 @@ globus_module_print_activated_versions(
+ * stream to print on (stdout, stderr, etc)
+ *
+ * @param verbose
+- * If GLOBUS_TRUE, then all available version info is printed
++ * If GLOBUS_TRUE, then all available version info is printed
+ * (ex: globus_module: 1.1 (1013708618-5))
+ * else, only the major.minor is printed (ex: globus_module: 1.1)
+ *
+@@ -851,14 +851,14 @@ globus_version_print(
+ {
+ globus_libc_fprintf(stream, "%s: ", name);
+ }
+-
++
+ if(version)
+ {
+ if(verbose)
+ {
+ globus_libc_fprintf(
+- stream,
+- "%d.%d (%lu-%d)\n",
++ stream,
++ "%d.%d (%lu-%d)\n",
+ version->major,
+ version->minor,
+ version->timestamp,
+@@ -867,8 +867,8 @@ globus_version_print(
+ else
+ {
+ globus_libc_fprintf(
+- stream,
+- "%d.%d\n",
++ stream,
++ "%d.%d\n",
+ version->major,
+ version->minor);
+ }
+@@ -881,7 +881,7 @@ globus_version_print(
+
+
+ /******************************************************************************
+- Module specific function definitions
++ Module specific function definitions
+ ******************************************************************************/
+
+ /*
+@@ -900,20 +900,20 @@ globus_l_module_initialize()
+ * Initialize the registered module table and list
+ */
+ globus_hashtable_init(&globus_l_module_table,
+- GLOBUS_L_MODULE_TABLE_SIZE,
+- globus_hashtable_voidp_hash,
+- globus_hashtable_voidp_keyeq);
++ GLOBUS_L_MODULE_TABLE_SIZE,
++ globus_hashtable_voidp_hash,
++ globus_hashtable_voidp_keyeq);
+
+ globus_l_module_list = GLOBUS_NULL;
+-
++
+ /*
+ * Initialize the recursive mutex
+ */
+ globus_l_module_mutex_init(&globus_l_module_mutex);
+-
++
+ globus_thread_key_create(&globus_l_activate_parent_key, NULL);
+ globus_thread_key_create(&globus_l_deactivate_parent_key, NULL);
+-
++
+ /*
+ * Now finish initializing the threads package
+ */
+@@ -927,71 +927,71 @@ globus_l_module_initialize()
+ */
+ static globus_bool_t
+ globus_l_module_increment(
+- globus_module_descriptor_t * module_descriptor,
+- globus_l_module_key_t parent_key,
++ globus_module_descriptor_t * module_descriptor,
++ globus_l_module_key_t parent_key,
+ globus_module_deactivate_proxy_cb_t deactivate_cb,
+ void * user_arg)
+ {
+- globus_l_module_entry_t * entry;
+-
++ globus_l_module_entry_t * entry;
++
+ entry =
+- globus_hashtable_lookup(
+- &globus_l_module_table,
+- (void *) module_descriptor->activation_func);
++ globus_hashtable_lookup(
++ &globus_l_module_table,
++ (void *) module_descriptor->activation_func);
+
+ if (entry != GLOBUS_NULL)
+ {
+- /*
+- * The module has already been registered. Increment its reference
+- * counter and add any new clients to the dependency list
+- */
+- entry->reference_count++;
+- if (parent_key != GLOBUS_NULL
+- && globus_list_search(entry->clients,
+- (void *) parent_key) == GLOBUS_NULL)
+- {
+- globus_list_insert(&entry->clients, (void *) parent_key);
+- }
+-
+- if(entry->reference_count == 1)
+- {
+- entry->deactivate_cb = deactivate_cb;
+- entry->user_arg = user_arg;
+- return GLOBUS_TRUE;
+- }
+- else
+- {
+- return GLOBUS_FALSE;
+- }
++ /*
++ * The module has already been registered. Increment its reference
++ * counter and add any new clients to the dependency list
++ */
++ entry->reference_count++;
++ if (parent_key != GLOBUS_NULL
++ && globus_list_search(entry->clients,
++ (void *) parent_key) == GLOBUS_NULL)
++ {
++ globus_list_insert(&entry->clients, (void *) parent_key);
++ }
++
++ if(entry->reference_count == 1)
++ {
++ entry->deactivate_cb = deactivate_cb;
++ entry->user_arg = user_arg;
++ return GLOBUS_TRUE;
++ }
++ else
++ {
++ return GLOBUS_FALSE;
++ }
+ }
+ else
+ {
+- /*
+- * This is the first time this module has been registered. Create a
+- * new entry in the modules table.
+- */
+- entry = (globus_l_module_entry_t *)
+- globus_malloc(sizeof(globus_l_module_entry_t));
+- globus_assert(entry != GLOBUS_NULL);
+-
+- entry->descriptor = module_descriptor;
+- entry->reference_count = 1;
+- entry->clients = GLOBUS_NULL;
+- entry->deactivate_cb = deactivate_cb;
+- entry->user_arg = user_arg;
+- if (parent_key != GLOBUS_NULL)
+- {
+- globus_list_insert(&entry->clients, (void *) parent_key);
+- }
+-
+- globus_hashtable_insert(
+- &globus_l_module_table,
+- (void *) module_descriptor->activation_func,
+- entry);
+-
+- globus_list_insert(&globus_l_module_list, entry);
+-
+- return GLOBUS_TRUE;
++ /*
++ * This is the first time this module has been registered. Create a
++ * new entry in the modules table.
++ */
++ entry = (globus_l_module_entry_t *)
++ globus_malloc(sizeof(globus_l_module_entry_t));
++ globus_assert(entry != GLOBUS_NULL);
++
++ entry->descriptor = module_descriptor;
++ entry->reference_count = 1;
++ entry->clients = GLOBUS_NULL;
++ entry->deactivate_cb = deactivate_cb;
++ entry->user_arg = user_arg;
++ if (parent_key != GLOBUS_NULL)
++ {
++ globus_list_insert(&entry->clients, (void *) parent_key);
++ }
++
++ globus_hashtable_insert(
++ &globus_l_module_table,
++ (void *) module_descriptor->activation_func,
++ entry);
++
++ globus_list_insert(&globus_l_module_list, entry);
++
++ return GLOBUS_TRUE;
+ }
+ }
+ /* globus_l_module_increment() */
+@@ -999,17 +999,17 @@ globus_l_module_increment(
+ static
+ int
+ globus_l_module_reference_count(
+- globus_module_descriptor_t * module_descriptor)
++ globus_module_descriptor_t * module_descriptor)
+ {
+- globus_l_module_entry_t * entry;
+-
++ globus_l_module_entry_t * entry;
++
+ entry =
+- globus_hashtable_lookup(
+- &globus_l_module_table,
+- (void *) module_descriptor->activation_func);
++ globus_hashtable_lookup(
++ &globus_l_module_table,
++ (void *) module_descriptor->activation_func);
+ if (entry == GLOBUS_NULL || entry->reference_count <= 0)
+ {
+- return 0;
++ return 0;
+ }
+ else
+ {
+@@ -1022,34 +1022,34 @@ globus_l_module_reference_count(
+ */
+ static globus_l_module_entry_t *
+ globus_l_module_decrement(
+- globus_module_descriptor_t * module_descriptor,
+- globus_l_module_key_t parent_key)
++ globus_module_descriptor_t * module_descriptor,
++ globus_l_module_key_t parent_key)
+ {
+- globus_l_module_entry_t * entry;
+-
++ globus_l_module_entry_t * entry;
++
+ entry =
+- globus_hashtable_lookup(
+- &globus_l_module_table,
+- (void *) module_descriptor->activation_func);
++ globus_hashtable_lookup(
++ &globus_l_module_table,
++ (void *) module_descriptor->activation_func);
+ if (entry == GLOBUS_NULL || entry->reference_count <= 0)
+ {
+- return NULL;
++ return NULL;
+ }
+
+ entry->reference_count--;
+-
++
+ if (parent_key != GLOBUS_NULL)
+ {
+- globus_list_t * client_entry;
++ globus_list_t * client_entry;
+
+-
+- client_entry = globus_list_search(entry->clients,
+- (void *) parent_key);
+- if(client_entry != GLOBUS_NULL)
++
++ client_entry = globus_list_search(entry->clients,
++ (void *) parent_key);
++ if(client_entry != GLOBUS_NULL)
+ {
+- globus_list_remove(&entry->clients, client_entry);
+- }
+- /* else module was activated outside this parent */
++ globus_list_remove(&entry->clients, client_entry);
++ }
++ /* else module was activated outside this parent */
+ }
+
+ return entry;
+@@ -1059,52 +1059,52 @@ globus_l_module_decrement(
+
+ void
+ globus_i_module_dump(
+- FILE * out_f)
++ FILE * out_f)
+ {
+- globus_list_t * module_list;
++ globus_list_t * module_list;
+
+ globus_libc_fprintf(out_f, "==========\nModule List\n----------\n");
+-
++
+ module_list = globus_l_module_list;
+ while(!globus_list_empty(module_list))
+ {
+- globus_list_t * client_list;
+- globus_l_module_entry_t * module_entry;
+-
+- module_entry = globus_list_first(module_list);
+- module_list = globus_list_rest(module_list);
+-
+- globus_libc_fprintf(out_f, "%s; cnt=%d",
+- module_entry->descriptor->module_name,
+- module_entry->reference_count);
+-
+- client_list = module_entry->clients;
+-
+- if (!globus_list_empty(client_list))
+- {
+- void * client_entry;
+- globus_l_module_entry_t * client_module_entry;
+-
+- client_entry = globus_list_first(client_list);
+- client_list = globus_list_rest(client_list);
+- client_module_entry =
+- globus_hashtable_lookup(&globus_l_module_table, client_entry);
+- globus_libc_fprintf(out_f, "; clients=%s",
+- client_module_entry->descriptor->module_name);
+-
+- while(!globus_list_empty(client_list))
+- {
+- client_entry = globus_list_first(client_list);
+- client_list = globus_list_rest(client_list);
+- client_module_entry =
+- globus_hashtable_lookup(&globus_l_module_table,
+- client_entry);
+- globus_libc_fprintf(out_f, ",%s",
+- client_module_entry->descriptor->module_name);
+- }
+- }
+-
+- globus_libc_fprintf(out_f, "\n");
++ globus_list_t * client_list;
++ globus_l_module_entry_t * module_entry;
++
++ module_entry = globus_list_first(module_list);
++ module_list = globus_list_rest(module_list);
++
++ globus_libc_fprintf(out_f, "%s; cnt=%d",
++ module_entry->descriptor->module_name,
++ module_entry->reference_count);
++
++ client_list = module_entry->clients;
++
++ if (!globus_list_empty(client_list))
++ {
++ void * client_entry;
++ globus_l_module_entry_t * client_module_entry;
++
++ client_entry = globus_list_first(client_list);
++ client_list = globus_list_rest(client_list);
++ client_module_entry =
++ globus_hashtable_lookup(&globus_l_module_table, client_entry);
++ globus_libc_fprintf(out_f, "; clients=%s",
++ client_module_entry->descriptor->module_name);
++
++ while(!globus_list_empty(client_list))
++ {
++ client_entry = globus_list_first(client_list);
++ client_list = globus_list_rest(client_list);
++ client_module_entry =
++ globus_hashtable_lookup(&globus_l_module_table,
++ client_entry);
++ globus_libc_fprintf(out_f, ",%s",
++ client_module_entry->descriptor->module_name);
++ }
++ }
++
++ globus_libc_fprintf(out_f, "\n");
+ }
+
+ globus_libc_fprintf(out_f, "==========\n");
+@@ -1112,7 +1112,7 @@ globus_i_module_dump(
+
+
+ /******************************************************************************
+- Recursive mutex function definitions
++ Recursive mutex function definitions
+ ******************************************************************************/
+
+ /*
+@@ -1120,7 +1120,7 @@ globus_i_module_dump(
+ */
+ static void
+ globus_l_module_mutex_init(
+- globus_l_module_mutex_t * mutex)
++ globus_l_module_mutex_t * mutex)
+ {
+ globus_mutex_init(&mutex->mutex, (globus_mutexattr_t *) GLOBUS_NULL);
+ globus_cond_init(&mutex->cond, (globus_condattr_t *) GLOBUS_NULL);
+@@ -1134,20 +1134,20 @@ globus_l_module_mutex_init(
+ */
+ static void
+ globus_l_module_mutex_lock(
+- globus_l_module_mutex_t * mutex)
++ globus_l_module_mutex_t * mutex)
+ {
+ globus_mutex_lock(&mutex->mutex);
+ {
+- globus_assert(mutex->level >= 0);
+- while (mutex->level > 0
+- && !globus_thread_equal( mutex->thread_id, globus_thread_self()) )
+- {
+- globus_cond_wait(&mutex->cond, &mutex->mutex);
+- }
+-
+- mutex->level++;
+- mutex->thread_id = globus_thread_self();
+-
++ globus_assert(mutex->level >= 0);
++ while (mutex->level > 0
++ && !globus_thread_equal( mutex->thread_id, globus_thread_self()) )
++ {
++ globus_cond_wait(&mutex->cond, &mutex->mutex);
++ }
++
++ mutex->level++;
++ mutex->thread_id = globus_thread_self();
++
+ }
+ globus_mutex_unlock(&mutex->mutex);
+ }
+@@ -1158,18 +1158,18 @@ globus_l_module_mutex_lock(
+ */
+ static void
+ globus_l_module_mutex_unlock(
+- globus_l_module_mutex_t * mutex)
++ globus_l_module_mutex_t * mutex)
+ {
+ globus_mutex_lock(&mutex->mutex);
+ {
+- globus_assert(mutex->level > 0);
+- globus_assert( globus_thread_equal( mutex->thread_id, globus_thread_self() ) );
+-
+- mutex->level--;
+- if (mutex->level == 0)
+- {
+- globus_cond_signal(&mutex->cond);
+- }
++ globus_assert(mutex->level > 0);
++ globus_assert( globus_thread_equal( mutex->thread_id, globus_thread_self() ) );
++
++ mutex->level--;
++ if (mutex->level == 0)
++ {
++ globus_cond_signal(&mutex->cond);
++ }
+ }
+ globus_mutex_unlock(&mutex->mutex);
+ }
+--
+2.54.0
+
diff --git a/0002-Fix-compiler-and-doxygen-warnings.patch b/0002-Fix-compiler-and-doxygen-warnings.patch
new file mode 100644
index 0000000..c3976a2
--- /dev/null
+++ b/0002-Fix-compiler-and-doxygen-warnings.patch
@@ -0,0 +1,285 @@
+From 4ee08d13e2963309e2063dc45dedd067337d3b76 Mon Sep 17 00:00:00 2001
+From: Mattias Ellert <mattias.ellert@physics.uu.se>
+Date: Wed, 20 May 2026 00:15:37 +0200
+Subject: [PATCH 2/2] Fix compiler and doxygen warnings
+
+---
+ common/source/library/globus_args.c | 3 +-
+ common/source/library/globus_callback.h | 3 --
+ common/source/library/globus_error_errno.c | 2 -
+ common/source/library/globus_error_generic.c | 12 ------
+ common/source/library/globus_libc.c | 39 +++++++-------------
+ common/source/library/globus_logging.c | 3 +-
+ common/source/library/globus_module.c | 9 -----
+ common/source/test/error_test.c | 4 +-
+ common/source/test/handle_table_test.c | 3 +-
+ 9 files changed, 18 insertions(+), 60 deletions(-)
+
+diff --git a/common/source/library/globus_args.c b/common/source/library/globus_args.c
+index fab932f3f..b91f2e468 100644
+--- a/common/source/library/globus_args.c
++++ b/common/source/library/globus_args.c
+@@ -655,14 +655,13 @@ globus_args_bytestr_to_num(
+ char * end = NULL;
+ globus_off_t size = 0;
+ int consumed;
+- int rc;
+
+ if(str == NULL || !(isdigit(*str) || *str == '-'))
+ {
+ return 1;
+ }
+
+- rc = globus_libc_scan_off_t((char *)str, &size, &consumed);
++ globus_libc_scan_off_t((char *)str, &size, &consumed);
+ end = (char *)str + consumed;
+ if(size && end && *end)
+ {
+diff --git a/common/source/library/globus_callback.h b/common/source/library/globus_callback.h
+index 810665c43..d36c4bf32 100644
+--- a/common/source/library/globus_callback.h
++++ b/common/source/library/globus_callback.h
+@@ -594,9 +594,6 @@ globus_callback_space_poll(
+ * case in which a user may wish to call this explicitly is if the application
+ * has no aspirations of ever being built threaded.
+ *
+- * @return
+- * - void
+- *
+ * @see globus_callback_space_poll()
+ */
+ void
+diff --git a/common/source/library/globus_error_errno.c b/common/source/library/globus_error_errno.c
+index 47017bced..62fff6b3f 100644
+--- a/common/source/library/globus_error_errno.c
++++ b/common/source/library/globus_error_errno.c
+@@ -157,8 +157,6 @@ globus_error_errno_get_errno(
+ * The error object for which to set the errno
+ * @param system_errno
+ * The system errno
+- * @return
+- * void
+ */
+ void
+ globus_error_errno_set_errno(
+diff --git a/common/source/library/globus_error_generic.c b/common/source/library/globus_error_generic.c
+index bc788403a..21dac77d5 100644
+--- a/common/source/library/globus_error_generic.c
++++ b/common/source/library/globus_error_generic.c
+@@ -316,8 +316,6 @@ globus_error_get_source(
+ * The error object for which to set the causative error
+ * @param source_module
+ * The originating module descriptor
+- * @return
+- * void
+ */
+ void
+ globus_error_set_source(
+@@ -363,8 +361,6 @@ globus_error_get_cause (
+ * The error object for which to set the causative error.
+ * @param causal_error
+ * The causative error.
+- * @return
+- * void
+ */
+ void
+ globus_error_set_cause (
+@@ -424,8 +420,6 @@ globus_error_get_type(
+ * The error object for which to set the error type
+ * @param type
+ * The error type
+- * @return
+- * void
+ */
+ void
+ globus_error_set_type(
+@@ -489,8 +483,6 @@ globus_error_get_short_desc(
+ * of the error. To be passed on to the user.
+ * @param ...
+ * Arguments for the format string.
+- * @return
+- * void
+ */
+ void
+ globus_error_set_short_desc(
+@@ -585,8 +577,6 @@ globus_error_get_long_desc(
+ * @param long_desc_format
+ * Longer format string giving a more detailed explanation of
+ * the error.
+- * @return
+- * void
+ */
+ void
+ globus_error_set_long_desc(
+@@ -1150,8 +1140,6 @@ error_object:
+ * over 'chain''s memory after this call.
+ * @param fmt
+ * a printf style format string describing this chain
+- * @return
+- * void
+ */
+ void
+ globus_error_mutliple_add_chain(
+diff --git a/common/source/library/globus_libc.c b/common/source/library/globus_libc.c
+index e9e818967..8d2ccfe29 100644
+--- a/common/source/library/globus_libc.c
++++ b/common/source/library/globus_libc.c
+@@ -747,9 +747,6 @@ globus_libc_gethostbyname_r(
+ struct hostent_data hp_data;
+ int rc;
+ # endif
+-# if defined(GLOBUS_HAVE_GETHOSTBYNAME_R_6)
+- int rc;
+-# endif
+
+ globus_libc_lock();
+
+@@ -825,12 +822,12 @@ globus_libc_gethostbyname_r(
+ }
+ # elif defined(GLOBUS_HAVE_GETHOSTBYNAME_R_6)
+ {
+- rc = gethostbyname_r(hostname,
+- result,
+- buffer,
+- buflen,
+- &hp,
+- h_errnop);
++ gethostbyname_r(hostname,
++ result,
++ buffer,
++ buflen,
++ &hp,
++ h_errnop);
+ }
+ # else
+ {
+@@ -894,14 +891,6 @@ globus_libc_gethostbyaddr_r(char *addr,
+ int rc;
+ # endif
+
+-# if defined(GLOBUS_HAVE_GETHOSTBYADDR_R_8)
+- int rc;
+-# endif
+-# if defined(GLOBUS_HAVE_GETHOSTBYADDR_R_7)
+- int rc;
+-# endif
+-
+-
+ globus_libc_lock();
+
+ # if !defined(HAVE_GETHOSTBYADDR_R)
+@@ -977,14 +966,14 @@ globus_libc_gethostbyaddr_r(char *addr,
+ }
+ # elif defined(GLOBUS_HAVE_GETHOSTBYADDR_R_8)
+ {
+- rc = gethostbyaddr_r(addr,
+- length,
+- type,
+- result,
+- buffer,
+- buflen,
+- &hp,
+- h_errnop);
++ gethostbyaddr_r(addr,
++ length,
++ type,
++ result,
++ buffer,
++ buflen,
++ &hp,
++ h_errnop);
+ }
+ # else
+ {
+diff --git a/common/source/library/globus_logging.c b/common/source/library/globus_logging.c
+index 1e023389c..9239d8cbb 100644
+--- a/common/source/library/globus_logging.c
++++ b/common/source/library/globus_logging.c
+@@ -411,13 +411,12 @@ globus_logging_stdio_header_func(
+ globus_size_t * len)
+ {
+ char str[256];
+- char * tmp;
+ time_t tm;
+ globus_size_t str_len;
+ int nbytes;
+
+ tm = time(NULL);
+- tmp = globus_libc_ctime_r(&tm, str, sizeof(str));
++ globus_libc_ctime_r(&tm, str, sizeof(str));
+ str_len = strlen(str);
+ if(str[str_len - 1] == '\n')
+ {
+diff --git a/common/source/library/globus_module.c b/common/source/library/globus_module.c
+index e9e9b8cac..bebd04548 100644
+--- a/common/source/library/globus_module.c
++++ b/common/source/library/globus_module.c
+@@ -732,9 +732,6 @@ globus_module_get_version(
+ * If GLOBUS_TRUE, then all available version info is printed
+ * (ex: globus_module: 1.1 (1013708618-5))
+ * else, only the major.minor is printed (ex: globus_module: 1.1)
+- *
+- * @return
+- * - void
+ */
+
+ void
+@@ -763,9 +760,6 @@ globus_module_print_version(
+ * If GLOBUS_TRUE, then all available version info is printed
+ * (ex: globus_module: 1.1 (1013708618-5))
+ * else, only the major.minor is printed (ex: globus_module: 1.1)
+- *
+- * @return
+- * - void
+ */
+
+ void
+@@ -835,9 +829,6 @@ globus_module_print_activated_versions(
+ * If GLOBUS_TRUE, then all available version info is printed
+ * (ex: globus_module: 1.1 (1013708618-5))
+ * else, only the major.minor is printed (ex: globus_module: 1.1)
+- *
+- * @return
+- * - void
+ */
+
+ void
+diff --git a/common/source/test/error_test.c b/common/source/test/error_test.c
+index 99a184e6e..951b9f1c3 100644
+--- a/common/source/test/error_test.c
++++ b/common/source/test/error_test.c
+@@ -102,9 +102,7 @@ main()
+
+ for (i = 0; i <= MAX_ERROR_NUM; i++)
+ {
+- globus_result_t result;
+-
+- result = throw_error(i);
++ throw_error(i);
+ }
+
+ for (i = 1; i <= MAX_ERROR_NUM; i++)
+diff --git a/common/source/test/handle_table_test.c b/common/source/test/handle_table_test.c
+index ca33fedf3..33f031412 100644
+--- a/common/source/test/handle_table_test.c
++++ b/common/source/test/handle_table_test.c
+@@ -35,7 +35,6 @@ destructor(void *datum)
+ int
+ main(void)
+ {
+- globus_bool_t rc;
+ int *data,
+ i;
+ globus_handle_table_t handle_table;
+@@ -106,7 +105,7 @@ main(void)
+ (i == object3_count-1), "decrement_object_3_%d", i);
+ }
+ object3_count = 0;
+- rc = globus_handle_table_decrement_reference(&handle_table, object2_handle);
++ globus_handle_table_decrement_reference(&handle_table, object2_handle);
+ object2_count--;
+
+ /* perform additional lookups */
+--
+2.54.0
+
diff --git a/globus-common.spec b/globus-common.spec
index ef1279a..2d9d462 100644
--- a/globus-common.spec
+++ b/globus-common.spec
@@ -1,13 +1,15 @@
Name: globus-common
%global _name %(tr - _ <<< %{name})
Version: 18.15
-Release: 2%{?dist}
+Release: 3%{?dist}
Summary: Grid Community Toolkit - Common Library
License: Apache-2.0
URL: https://github.com/gridcf/gct/
Source: https://repo.gridcf.org/gct6/sources/%{_name}-%{version}.tar.gz
Source8: README
+Patch0: 0001-Untabify-and-remove-trailing-white-space.patch
+Patch1: 0002-Fix-compiler-and-doxygen-warnings.patch
BuildRequires: make
BuildRequires: gcc
@@ -76,6 +78,8 @@ Common Library Documentation Files
%prep
%setup -q -n %{_name}-%{version}
+%patch -P0 -p3
+%patch -P1 -p3
%build
# Reduce overlinking
@@ -163,6 +167,9 @@ rm %{buildroot}%{_datadir}/globus-user-env.sh
%license GLOBUS_LICENSE
%changelog
+* Sat Jun 13 2026 Mattias Ellert <mattias.ellert@physics.uu.se> - 18.15-3
+- Fix compiler and doxygen warnings
+
* Fri Jan 16 2026 Fedora Release Engineering <releng@fedoraproject.org> - 18.15-2
- Rebuilt for https://fedoraproject.org/wiki/Fedora_44_Mass_Rebuild
^ permalink raw reply related [flat|nested] only message in thread
only message in thread, other threads:[~2026-06-14 8:45 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-06-14 8:45 [rpms/globus-common] rawhide: Fix compiler and doxygen warnings Mattias Ellert
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox