public inbox for git-commits@fedoraproject.org
help / color / mirror / Atom feed
From: Mattias Ellert <mattias.ellert@physics.uu.se>
To: git-commits@fedoraproject.org
Subject: [rpms/globus-io] rawhide: Fix compiler warnings
Date: Sun, 14 Jun 2026 08:54:09 GMT [thread overview]
Message-ID: <178142724962.1.8591267008299697646.rpms-globus-io-91702c86c60a@fedoraproject.org> (raw)
A new commit has been pushed.
Repo : rpms/globus-io
Branch : rawhide
Commit : 91702c86c60a2c30e4e704e2fe6cf6ba19ac9a01
Author : Mattias Ellert <mattias.ellert@physics.uu.se>
Date : 2026-06-14T10:39:13+02:00
Stats : +4021/-1 in 3 file(s)
URL : https://src.fedoraproject.org/rpms/globus-io/c/91702c86c60a2c30e4e704e2fe6cf6ba19ac9a01?branch=rawhide
Log:
Fix compiler 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..aef7ef0
--- /dev/null
+++ b/0001-Untabify-and-remove-trailing-white-space.patch
@@ -0,0 +1,3972 @@
+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
+
+---
+ io/compat/globus_io_xio_compat.c | 1304 +++++++++++++++---------------
+ 1 file changed, 652 insertions(+), 652 deletions(-)
+
+diff --git a/io/compat/globus_io_xio_compat.c b/io/compat/globus_io_xio_compat.c
+index 84cf6264d..bac433a00 100644
+--- a/io/compat/globus_io_xio_compat.c
++++ b/io/compat/globus_io_xio_compat.c
+@@ -138,8 +138,8 @@ typedef struct globus_l_io_secure_authorization_data_s
+ {
+ gss_name_t identity;
+ globus_io_secure_authorization_callback_t callback;
+- void * callback_arg;
+-} globus_l_io_secure_authorization_data_t;
++ void * callback_arg;
++} globus_l_io_secure_authorization_data_t;
+
+ typedef struct globus_l_io_attr_s
+ {
+@@ -162,12 +162,12 @@ typedef struct globus_l_io_handle_s
+ globus_io_handle_t * io_handle;
+ globus_xio_handle_t xio_handle;
+ globus_callback_space_t space;
+-
++
+ globus_list_t * pending_ops;
+ globus_mutex_t pending_lock;
+ void * user_pointer;
+ globus_io_attr_t attr;
+-
++
+ /* used only for listener */
+ globus_xio_server_t xio_server;
+ globus_xio_handle_t accepted_handle;
+@@ -247,7 +247,7 @@ int
+ globus_l_io_activate(void)
+ {
+ globus_result_t result;
+-
++
+ if(globus_module_activate(GLOBUS_XIO_MODULE) != GLOBUS_SUCCESS)
+ {
+ goto error_activate;
+@@ -258,7 +258,7 @@ globus_l_io_activate(void)
+ {
+ goto error_load_file;
+ }
+-
++
+ if(globus_xio_driver_load(
+ "tcp", &globus_l_io_tcp_driver) != GLOBUS_SUCCESS)
+ {
+@@ -270,78 +270,78 @@ globus_l_io_activate(void)
+ {
+ goto error_load_gsi;
+ }
+-
++
+ result = globus_xio_stack_init(&globus_l_io_file_stack, GLOBUS_NULL);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_file_stack;
+ }
+-
++
+ result = globus_xio_stack_push_driver(
+ globus_l_io_file_stack, globus_l_io_file_driver);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_file_push;
+ }
+-
++
+ result = globus_xio_stack_init(&globus_l_io_tcp_stack, GLOBUS_NULL);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_tcp_stack;
+ }
+-
++
+ result = globus_xio_stack_push_driver(
+ globus_l_io_tcp_stack, globus_l_io_tcp_driver);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_tcp_push;
+ }
+-
++
+ result = globus_xio_stack_init(&globus_l_io_gsi_stack, GLOBUS_NULL);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_gsi_stack;
+ }
+-
++
+ result = globus_xio_stack_push_driver(
+ globus_l_io_gsi_stack, globus_l_io_tcp_driver);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_gsi_push;
+ }
+-
++
+ result = globus_xio_stack_push_driver(
+ globus_l_io_gsi_stack, globus_l_io_gsi_driver);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_gsi_push;
+ }
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_gsi_push:
+ globus_xio_stack_destroy(globus_l_io_gsi_stack);
+-
++
+ error_gsi_stack:
+ error_tcp_push:
+ globus_xio_stack_destroy(globus_l_io_tcp_stack);
+-
++
+ error_tcp_stack:
+ error_file_push:
+ globus_xio_stack_destroy(globus_l_io_file_stack);
+-
++
+ error_file_stack:
+ globus_xio_driver_unload(globus_l_io_gsi_driver);
+-
++
+ error_load_gsi:
+ globus_xio_driver_unload(globus_l_io_tcp_driver);
+
+ error_load_tcp:
+ globus_xio_driver_unload(globus_l_io_file_driver);
+-
++
+ error_load_file:
+ globus_module_deactivate(GLOBUS_XIO_MODULE);
+-
++
+ error_activate:
+ return GLOBUS_FAILURE;
+ }
+@@ -353,11 +353,11 @@ globus_l_io_deactivate(void)
+ globus_xio_stack_destroy(globus_l_io_gsi_stack);
+ globus_xio_stack_destroy(globus_l_io_tcp_stack);
+ globus_xio_stack_destroy(globus_l_io_file_stack);
+-
++
+ globus_xio_driver_unload(globus_l_io_gsi_driver);
+ globus_xio_driver_unload(globus_l_io_tcp_driver);
+ globus_xio_driver_unload(globus_l_io_file_driver);
+-
++
+ return globus_module_deactivate(GLOBUS_XIO_MODULE);
+ }
+
+@@ -372,13 +372,13 @@ globus_l_io_handle_init(
+ globus_result_t result;
+ globus_l_io_handle_t * ihandle;
+ GlobusIOName(globus_l_io_handle_init);
+-
++
+ result = GlobusLIOMalloc(ihandle, globus_l_io_handle_t);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_alloc;
+ }
+-
++
+ ihandle->type = type;
+ ihandle->refs = 1;
+ ihandle->io_handle = io_handle;
+@@ -391,11 +391,11 @@ globus_l_io_handle_init(
+ ihandle->user_pointer = GLOBUS_NULL;
+ globus_mutex_init(&ihandle->pending_lock, GLOBUS_NULL);
+ globus_callback_space_reference(ihandle->space);
+-
++
+ *_ihandle = ihandle;
+-
++
+ return GLOBUS_SUCCESS;
+-
++
+ error_alloc:
+ return result;
+ }
+@@ -407,7 +407,7 @@ globus_l_io_handle_destroy(
+ {
+ globus_bool_t destroy;
+ GlobusIOName(globus_l_io_handle_destroy);
+-
++
+ globus_mutex_lock(&ihandle->pending_lock);
+ {
+ if(--ihandle->refs == 0)
+@@ -420,7 +420,7 @@ globus_l_io_handle_destroy(
+ }
+ }
+ globus_mutex_unlock(&ihandle->pending_lock);
+-
++
+ if(destroy)
+ {
+ if(ihandle->attr)
+@@ -452,7 +452,7 @@ globus_l_io_attr_check(
+ const char * func_name)
+ {
+ globus_l_io_attr_t * iattr;
+-
++
+ if(!attr)
+ {
+ return globus_error_put(
+@@ -463,9 +463,9 @@ globus_l_io_attr_check(
+ 1,
+ (char *) func_name));
+ }
+-
++
+ iattr = (globus_l_io_attr_t *) *attr;
+-
++
+ if(!iattr || !(iattr->type & types))
+ {
+ return globus_error_put(
+@@ -476,7 +476,7 @@ globus_l_io_attr_check(
+ 1,
+ (char *) func_name));
+ }
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+@@ -491,17 +491,17 @@ globus_l_io_iattr_copy(
+ globus_io_secure_authorization_data_t data;
+ globus_result_t result;
+ GlobusIOName(globus_l_io_iattr_copy);
+-
++
+ source_iattr = (globus_l_io_attr_t *) *source;
+-
++
+ result = GlobusLIOMalloc(dest_iattr, globus_l_io_attr_t);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_alloc;
+ }
+-
++
+ memset(dest_iattr, 0, sizeof(globus_l_io_attr_t));
+-
++
+ dest_iattr->type = source_iattr->type;
+ if(dest_iattr->type == GLOBUS_I_IO_TCP_ATTR)
+ {
+@@ -517,7 +517,7 @@ globus_l_io_iattr_copy(
+ {
+ goto error_auth_copy;
+ }
+-
++
+ dest_iattr->authz_data.identity = data->identity;
+ dest_iattr->authz_data.callback = data->callback;
+ dest_iattr->authz_data.callback_arg = data->callback_arg;
+@@ -528,7 +528,7 @@ globus_l_io_iattr_copy(
+ globus_assert(dest_iattr->type == GLOBUS_I_IO_FILE_ATTR);
+ dest_iattr->file_flags = source_iattr->file_flags;
+ }
+-
++
+ result = globus_xio_attr_copy(&dest_iattr->attr, source_iattr->attr);
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -545,7 +545,7 @@ globus_l_io_iattr_copy(
+ }
+ dest_iattr->space = source_iattr->space;
+ globus_callback_space_reference(dest_iattr->space);
+-
++
+ *dest = dest_iattr;
+ return GLOBUS_SUCCESS;
+
+@@ -558,10 +558,10 @@ error_xio_copy:
+
+ gss_release_name(&minor_status, &dest_iattr->authz_data.identity);
+ }
+-
++
+ error_auth_copy:
+ globus_free(dest_iattr);
+-
++
+ error_alloc:
+ *dest = GLOBUS_NULL;
+ return result;
+@@ -584,9 +584,9 @@ globus_l_io_cancel_precallback(
+ {
+ globus_l_io_handle_t * ihandle;
+ globus_bool_t perform_callback;
+-
++
+ ihandle = bounce_info->handle;
+-
++
+ globus_mutex_lock(&ihandle->pending_lock);
+ {
+ perform_callback = GLOBUS_TRUE;
+@@ -605,7 +605,7 @@ globus_l_io_cancel_precallback(
+ }
+ }
+ globus_mutex_unlock(&ihandle->pending_lock);
+-
++
+ return perform_callback;
+ }
+
+@@ -615,9 +615,9 @@ globus_l_io_cancel_kickout(
+ void * user_arg)
+ {
+ globus_l_io_cancel_info_t * cancel_info;
+-
++
+ cancel_info = (globus_l_io_cancel_info_t *) user_arg;
+-
++
+ if(cancel_info->callback)
+ {
+ cancel_info->callback(
+@@ -625,7 +625,7 @@ globus_l_io_cancel_kickout(
+ cancel_info->handle,
+ GLOBUS_SUCCESS);
+ }
+-
++
+ globus_free(cancel_info);
+ }
+
+@@ -638,10 +638,10 @@ globus_l_io_cancel_complete(
+ globus_l_io_cancel_info_t * cancel_info;
+ globus_bool_t call_cancel;
+ GlobusIOName(globus_l_io_cancel_complete);
+-
++
+ ihandle = bounce_info->handle;
+ cancel_info = bounce_info->cancel_info;
+-
++
+ globus_mutex_lock(&ihandle->pending_lock);
+ {
+ if(cancel_info && --cancel_info->refs == 0)
+@@ -654,18 +654,18 @@ globus_l_io_cancel_complete(
+ }
+ }
+ globus_mutex_unlock(&ihandle->pending_lock);
+-
++
+ if(call_cancel)
+ {
+ globus_callback_space_t space;
+-
++
+ if(ihandle->space != GLOBUS_CALLBACK_GLOBAL_SPACE &&
+ globus_callback_space_get(&space) == GLOBUS_SUCCESS && (
+ (cancel_info->blocking && space != GLOBUS_CALLBACK_GLOBAL_SPACE) ||
+ (!cancel_info->blocking && space != ihandle->space)))
+ {
+ globus_result_t result;
+-
++
+ result = globus_callback_space_register_oneshot(
+ GLOBUS_NULL,
+ GLOBUS_NULL,
+@@ -692,11 +692,11 @@ globus_l_io_cancel_complete(
+ cancel_info->handle,
+ GLOBUS_SUCCESS);
+ }
+-
++
+ globus_free(cancel_info);
+ }
+ }
+-
++
+ /* removes reference added in cancel_insert and destroys if necessary */
+ globus_l_io_handle_destroy(ihandle);
+ }
+@@ -707,7 +707,7 @@ globus_l_io_should_bounce(
+ globus_l_io_bounce_t * bounce_info)
+ {
+ globus_callback_space_t space;
+-
++
+ if(bounce_info->handle->space != GLOBUS_CALLBACK_GLOBAL_SPACE &&
+ globus_callback_space_get(&space) == GLOBUS_SUCCESS &&
+ ((bounce_info->blocking && space != GLOBUS_CALLBACK_GLOBAL_SPACE) ||
+@@ -715,18 +715,18 @@ globus_l_io_should_bounce(
+ {
+ return GLOBUS_TRUE;
+ }
+-
++
+ return GLOBUS_FALSE;
+ }
+
+ static
+ void
+ globus_l_io_bounce_io_cb(
+- globus_xio_handle_t xio_handle,
++ globus_xio_handle_t xio_handle,
+ globus_result_t result,
+ globus_byte_t * buffer,
+ globus_size_t len,
+- globus_size_t nbytes,
++ globus_size_t nbytes,
+ globus_xio_data_descriptor_t data_desc,
+ void * user_arg);
+
+@@ -737,11 +737,11 @@ globus_l_io_bounce_io_kickout(
+ {
+ globus_l_io_bounce_t * bounce_info;
+ GlobusIOName(globus_l_io_bounce_io_kickout);
+-
++
+ bounce_info = (globus_l_io_bounce_t *) user_arg;
+ globus_l_io_bounce_io_cb(
+ GLOBUS_NULL,
+- bounce_info->error
++ bounce_info->error
+ ? globus_error_put(bounce_info->error) : GLOBUS_SUCCESS,
+ bounce_info->buffer,
+ 0,
+@@ -753,24 +753,24 @@ globus_l_io_bounce_io_kickout(
+ static
+ void
+ globus_l_io_bounce_io_cb(
+- globus_xio_handle_t xio_handle,
++ globus_xio_handle_t xio_handle,
+ globus_result_t result,
+ globus_byte_t * buffer,
+ globus_size_t len,
+- globus_size_t nbytes,
++ globus_size_t nbytes,
+ globus_xio_data_descriptor_t data_desc,
+ void * user_arg)
+ {
+ globus_l_io_bounce_t * bounce_info;
+ globus_l_io_handle_t * ihandle;
+ GlobusIOName(globus_l_io_bounce_io_cb);
+-
++
+ bounce_info = (globus_l_io_bounce_t *) user_arg;
+ ihandle = bounce_info->handle;
+-
++
+ if(globus_l_io_should_bounce(bounce_info))
+ {
+- bounce_info->error = result == GLOBUS_SUCCESS
++ bounce_info->error = result == GLOBUS_SUCCESS
+ ? GLOBUS_NULL : globus_error_get(result);
+ bounce_info->buffer = buffer;
+ bounce_info->nbytes = nbytes;
+@@ -791,7 +791,7 @@ globus_l_io_bounce_io_cb(
+ }
+ return;
+ }
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ if(globus_xio_error_is_eof(result))
+@@ -811,7 +811,7 @@ globus_l_io_bounce_io_cb(
+ ihandle->io_handle));
+ }
+ }
+-
++
+ if(globus_l_io_cancel_precallback(bounce_info))
+ {
+ bounce_info->cb.read_write(
+@@ -821,7 +821,7 @@ globus_l_io_bounce_io_cb(
+ buffer,
+ nbytes);
+ }
+-
++
+ globus_l_io_cancel_complete(bounce_info);
+ globus_free(bounce_info);
+ }
+@@ -844,11 +844,11 @@ globus_l_io_bounce_iovec_kickout(
+ {
+ globus_l_io_bounce_t * bounce_info;
+ GlobusIOName(globus_l_io_bounce_iovec_kickout);
+-
++
+ bounce_info = (globus_l_io_bounce_t *) user_arg;
+ globus_l_io_bounce_iovec_cb(
+ GLOBUS_NULL,
+- bounce_info->error
++ bounce_info->error
+ ? globus_error_put(bounce_info->error) : GLOBUS_SUCCESS,
+ bounce_info->iov,
+ bounce_info->iovc,
+@@ -871,13 +871,13 @@ globus_l_io_bounce_iovec_cb(
+ globus_l_io_bounce_t * bounce_info;
+ globus_l_io_handle_t * ihandle;
+ GlobusIOName(globus_l_io_bounce_iovec_cb);
+-
++
+ bounce_info = (globus_l_io_bounce_t *) user_arg;
+ ihandle = bounce_info->handle;
+-
++
+ if(globus_l_io_should_bounce(bounce_info))
+ {
+- bounce_info->error = result == GLOBUS_SUCCESS
++ bounce_info->error = result == GLOBUS_SUCCESS
+ ? GLOBUS_NULL : globus_error_get(result);
+ bounce_info->iov = iovec;
+ bounce_info->iovc = count;
+@@ -899,7 +899,7 @@ globus_l_io_bounce_iovec_cb(
+ }
+ return;
+ }
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ if(globus_xio_error_is_eof(result))
+@@ -919,7 +919,7 @@ globus_l_io_bounce_iovec_cb(
+ ihandle->io_handle));
+ }
+ }
+-
++
+ if(globus_l_io_cancel_precallback(bounce_info))
+ {
+ bounce_info->cb.writev(
+@@ -930,7 +930,7 @@ globus_l_io_bounce_iovec_cb(
+ count,
+ nbytes);
+ }
+-
++
+ globus_l_io_cancel_complete(bounce_info);
+ globus_free(bounce_info);
+ }
+@@ -949,12 +949,12 @@ globus_l_io_bounce_authz_kickout(
+ {
+ globus_l_io_bounce_t * bounce_info;
+ GlobusIOName(globus_l_io_bounce_authz_kickout);
+-
++
+ bounce_info = (globus_l_io_bounce_t *) user_arg;
+-
++
+ globus_l_io_bounce_authz_cb(
+ GLOBUS_NULL,
+- bounce_info->error
++ bounce_info->error
+ ? globus_error_put(bounce_info->error) : GLOBUS_SUCCESS,
+ user_arg);
+ }
+@@ -975,13 +975,13 @@ globus_l_io_bounce_authz_cb(
+ gss_ctx_id_t context;
+ globus_bool_t perform_callback;
+ GlobusIOName(globus_l_io_bounce_authz_cb);
+-
++
+ bounce_info = (globus_l_io_bounce_t *) user_arg;
+-
++
+ if(globus_l_io_should_bounce(bounce_info) ||
+ (handle != NULL && bounce_info->handle->attr->authz_data.callback))
+ {
+- bounce_info->error = result == GLOBUS_SUCCESS
++ bounce_info->error = result == GLOBUS_SUCCESS
+ ? GLOBUS_NULL : globus_error_get(result);
+ result = globus_callback_space_register_oneshot(
+ GLOBUS_NULL,
+@@ -1001,12 +1001,12 @@ globus_l_io_bounce_authz_cb(
+ }
+ return;
+ }
+-
++
+ ihandle = bounce_info->handle;
+ perform_callback = globus_l_io_cancel_precallback(bounce_info);
+-
++
+ if(result != GLOBUS_SUCCESS)
+- {
++ {
+ if(globus_xio_error_is_eof(result))
+ {
+ result = globus_error_put(
+@@ -1023,7 +1023,7 @@ globus_l_io_bounce_authz_cb(
+ globus_error_get(result),
+ ihandle->io_handle));
+ }
+- else
++ else
+ {
+ globus_object_t * error = globus_error_get(result);
+ if(globus_error_gssapi_match(error,
+@@ -1033,7 +1033,7 @@ globus_l_io_bounce_authz_cb(
+ globus_l_io_gsi_driver,
+ error,
+ GLOBUS_XIO_GSI_AUTHORIZATION_FAILED))
+- {
++ {
+ result = globus_error_put(
+ globus_io_error_construct_authorization_failed(
+ GLOBUS_IO_MODULE,
+@@ -1063,24 +1063,24 @@ globus_l_io_bounce_authz_cb(
+ {
+ result = globus_error_put(error);
+ }
+- }
++ }
+ goto done;
+ }
+
+ if(ihandle->attr->authorization_mode ==
+ GLOBUS_IO_SECURE_AUTHORIZATION_MODE_CALLBACK)
+- {
++ {
+ result = globus_xio_handle_cntl(
+ ihandle->xio_handle,
+ globus_l_io_gsi_driver,
+ GLOBUS_XIO_GSI_GET_PEER_NAME,
+ &peer_identity);
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto done;
+ }
+-
++
+ result = globus_xio_handle_cntl(
+ ihandle->xio_handle,
+ globus_l_io_gsi_driver,
+@@ -1104,7 +1104,7 @@ globus_l_io_bounce_authz_cb(
+ minor_status);
+ goto done;
+ }
+-
++
+ if(!perform_callback || !ihandle->attr->authz_data.callback(
+ ihandle->attr->authz_data.callback_arg,
+ ihandle->io_handle,
+@@ -1119,21 +1119,21 @@ globus_l_io_bounce_authz_cb(
+ ihandle->io_handle,
+ 0,
+ 0,
+- 0));
++ 0));
+ }
+
+ free(peer_name_buffer.value);
+ }
+-
++
+ done:
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ globus_xio_close(ihandle->xio_handle, GLOBUS_NULL);
+ ihandle->xio_handle = GLOBUS_NULL;
+ *ihandle->io_handle = GLOBUS_NULL;
+ }
+-
++
+ if(perform_callback)
+ {
+ bounce_info->cb.non_io(
+@@ -1141,10 +1141,10 @@ done:
+ ihandle->io_handle,
+ result);
+ }
+-
++
+ globus_l_io_cancel_complete(bounce_info);
+ globus_free(bounce_info);
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ globus_l_io_handle_destroy(ihandle);
+@@ -1166,13 +1166,13 @@ globus_l_io_bounce_listen_kickout(
+ {
+ globus_l_io_bounce_t * bounce_info;
+ GlobusIOName(globus_l_io_bounce_authz_kickout);
+-
++
+ bounce_info = (globus_l_io_bounce_t *) user_arg;
+-
++
+ globus_l_io_bounce_listen_cb(
+ GLOBUS_NULL,
+ bounce_info->handle->accepted_handle,
+- bounce_info->error
++ bounce_info->error
+ ? globus_error_put(bounce_info->error) : GLOBUS_SUCCESS,
+ user_arg);
+ }
+@@ -1188,14 +1188,14 @@ globus_l_io_bounce_listen_cb(
+ globus_l_io_bounce_t * bounce_info;
+ globus_l_io_handle_t * ihandle;
+ GlobusIOName(globus_l_io_bounce_listen_cb);
+-
++
+ bounce_info = (globus_l_io_bounce_t *) user_arg;
+ ihandle = bounce_info->handle;
+ ihandle->accepted_handle = handle;
+-
++
+ if(globus_l_io_should_bounce(bounce_info))
+ {
+- bounce_info->error = result == GLOBUS_SUCCESS
++ bounce_info->error = result == GLOBUS_SUCCESS
+ ? GLOBUS_NULL : globus_error_get(result);
+ result = globus_callback_space_register_oneshot(
+ GLOBUS_NULL,
+@@ -1215,7 +1215,7 @@ globus_l_io_bounce_listen_cb(
+ }
+ return;
+ }
+-
++
+ if(globus_l_io_cancel_precallback(bounce_info))
+ {
+ if(result != GLOBUS_SUCCESS && globus_xio_error_is_canceled(result))
+@@ -1226,7 +1226,7 @@ globus_l_io_bounce_listen_cb(
+ globus_error_get(result),
+ ihandle->io_handle));
+ }
+-
++
+ bounce_info->cb.non_io(
+ bounce_info->user_arg,
+ ihandle->io_handle,
+@@ -1246,9 +1246,9 @@ globus_l_io_blocking_cb(
+ {
+ globus_l_io_monitor_t * monitor;
+ GlobusIOName(globus_l_io_blocking_cb);
+-
++
+ monitor = (globus_l_io_monitor_t *) user_arg;
+-
++
+ globus_mutex_lock(&monitor->lock);
+ {
+ monitor->done = GLOBUS_TRUE;
+@@ -1264,13 +1264,13 @@ globus_io_attr_set_callback_space(
+ globus_callback_space_t space)
+ {
+ GlobusIOName(globus_io_attr_set_callback_space);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_FILE_ATTR | GLOBUS_I_IO_TCP_ATTR);
+-
++
+ globus_callback_space_destroy((*attr)->space);
+ globus_callback_space_reference(space);
+ (*attr)->space = space;
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+@@ -1280,10 +1280,10 @@ globus_io_attr_get_callback_space(
+ globus_callback_space_t * space)
+ {
+ GlobusIOName(globus_io_attr_get_callback_space);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_FILE_ATTR | GLOBUS_I_IO_TCP_ATTR);
+ GlobusLIOCheckNullParam(space);
+-
++
+ *space = (*attr)->space;
+ return GLOBUS_SUCCESS;
+ }
+@@ -1297,32 +1297,32 @@ globus_io_fileattr_init(
+ globus_l_io_attr_t * iattr;
+ globus_result_t result;
+ GlobusIOName(globus_io_fileattr_init);
+-
++
+ GlobusLIOCheckNullParam(attr);
+-
++
+ result = GlobusLIOMalloc(iattr, globus_l_io_attr_t);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_alloc;
+ }
+-
++
+ iattr->type = GLOBUS_I_IO_FILE_ATTR;
+ iattr->space = GLOBUS_CALLBACK_GLOBAL_SPACE;
+-
++
+ result = globus_xio_attr_init(&iattr->attr);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_attr;
+ }
+-
++
+ iattr->file_flags = GLOBUS_IO_FILE_TYPE_BINARY;
+ *attr = iattr;
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_attr:
+ globus_free(iattr);
+-
++
+ error_alloc:
+ *attr = GLOBUS_NULL;
+ return result;
+@@ -1334,11 +1334,11 @@ globus_io_fileattr_destroy(
+ {
+ globus_l_io_attr_t * iattr;
+ GlobusIOName(globus_io_fileattr_destroy);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_FILE_ATTR);
+-
++
+ iattr = (globus_l_io_attr_t *) *attr;
+-
++
+ globus_callback_space_destroy(iattr->space);
+ globus_xio_attr_destroy(iattr->attr);
+ if(iattr->stack)
+@@ -1347,7 +1347,7 @@ globus_io_fileattr_destroy(
+ }
+ globus_free(iattr);
+ *attr = GLOBUS_NULL;
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+@@ -1357,11 +1357,11 @@ globus_io_attr_set_file_type(
+ globus_io_file_type_t file_type)
+ {
+ GlobusIOName(globus_io_attr_set_file_type);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_FILE_ATTR);
+-
++
+ (*attr)->file_flags = file_type;
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+@@ -1371,11 +1371,11 @@ globus_io_attr_get_file_type(
+ globus_io_file_type_t * file_type)
+ {
+ GlobusIOName(globus_io_attr_get_file_type);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_FILE_ATTR);
+-
++
+ *file_type = (*attr)->file_flags;
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+@@ -1388,15 +1388,15 @@ globus_io_tcpattr_init(
+ globus_l_io_attr_t * iattr;
+ globus_result_t result;
+ GlobusIOName(globus_io_tcpattr_init);
+-
++
+ GlobusLIOCheckNullParam(attr);
+-
++
+ result = GlobusLIOMalloc(iattr, globus_l_io_attr_t);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_alloc;
+ }
+-
++
+ iattr->type = GLOBUS_I_IO_TCP_ATTR;
+ iattr->space = GLOBUS_CALLBACK_GLOBAL_SPACE;
+ iattr->file_flags = 0;
+@@ -1412,8 +1412,8 @@ globus_io_tcpattr_init(
+ }
+
+ result = globus_xio_attr_cntl(
+- iattr->attr,
+- globus_l_io_gsi_driver,
++ iattr->attr,
++ globus_l_io_gsi_driver,
+ GLOBUS_XIO_GSI_SET_PROTECTION_LEVEL,
+ GLOBUS_XIO_GSI_PROTECTION_LEVEL_NONE);
+
+@@ -1421,17 +1421,17 @@ globus_io_tcpattr_init(
+ {
+ goto error_xio_attr;
+ }
+-
++
+ *attr = iattr;
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_xio_attr:
+ globus_xio_attr_destroy(iattr->attr);
+-
++
+ error_attr:
+ globus_free(iattr);
+-
++
+ error_alloc:
+ *attr = GLOBUS_NULL;
+ return result;
+@@ -1443,18 +1443,18 @@ globus_io_tcpattr_destroy(
+ {
+ globus_l_io_attr_t * iattr;
+ GlobusIOName(globus_io_tcpattr_destroy);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ iattr = (globus_l_io_attr_t *) *attr;
+-
++
+ if(iattr->authz_data.identity != GSS_C_NO_NAME)
+ {
+ OM_uint32 minor_status;
+
+ gss_release_name(&minor_status, &iattr->authz_data.identity);
+ }
+-
++
+ globus_callback_space_destroy(iattr->space);
+ globus_xio_attr_destroy(iattr->attr);
+ if(iattr->stack)
+@@ -1463,7 +1463,7 @@ globus_io_tcpattr_destroy(
+ }
+ globus_free(iattr);
+ *attr = GLOBUS_NULL;
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+@@ -1473,13 +1473,13 @@ globus_io_attr_set_tcp_restrict_port(
+ globus_bool_t restrict_port)
+ {
+ GlobusIOName(globus_io_attr_set_tcp_restrict_port);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_tcp_driver,
+- GLOBUS_XIO_TCP_SET_RESTRICT_PORT,
++ (*attr)->attr,
++ globus_l_io_tcp_driver,
++ GLOBUS_XIO_TCP_SET_RESTRICT_PORT,
+ restrict_port);
+ }
+
+@@ -1489,13 +1489,13 @@ globus_io_attr_get_tcp_restrict_port(
+ globus_bool_t * restrict_port)
+ {
+ GlobusIOName(globus_io_attr_get_tcp_restrict_port);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_tcp_driver,
+- GLOBUS_XIO_TCP_GET_RESTRICT_PORT,
++ (*attr)->attr,
++ globus_l_io_tcp_driver,
++ GLOBUS_XIO_TCP_GET_RESTRICT_PORT,
+ restrict_port);
+ }
+
+@@ -1505,13 +1505,13 @@ globus_io_attr_set_tcp_nodelay(
+ globus_bool_t nodelay)
+ {
+ GlobusIOName(globus_io_attr_set_tcp_nodelay);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_tcp_driver,
+- GLOBUS_XIO_TCP_SET_NODELAY,
++ (*attr)->attr,
++ globus_l_io_tcp_driver,
++ GLOBUS_XIO_TCP_SET_NODELAY,
+ nodelay);
+ }
+
+@@ -1521,13 +1521,13 @@ globus_io_attr_get_tcp_nodelay(
+ globus_bool_t * nodelay)
+ {
+ GlobusIOName(globus_io_attr_get_tcp_nodelay);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_tcp_driver,
+- GLOBUS_XIO_TCP_GET_NODELAY,
++ (*attr)->attr,
++ globus_l_io_tcp_driver,
++ GLOBUS_XIO_TCP_GET_NODELAY,
+ nodelay);
+ }
+
+@@ -1537,13 +1537,13 @@ globus_io_attr_set_tcp_interface(
+ const char * interface_addr)
+ {
+ GlobusIOName(globus_io_attr_set_tcp_interface);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_tcp_driver,
+- GLOBUS_XIO_TCP_SET_INTERFACE,
++ (*attr)->attr,
++ globus_l_io_tcp_driver,
++ GLOBUS_XIO_TCP_SET_INTERFACE,
+ interface_addr);
+ }
+
+@@ -1553,13 +1553,13 @@ globus_io_attr_get_tcp_interface(
+ char ** interface_addr)
+ {
+ GlobusIOName(globus_io_attr_get_tcp_interface);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_tcp_driver,
+- GLOBUS_XIO_TCP_GET_INTERFACE,
++ (*attr)->attr,
++ globus_l_io_tcp_driver,
++ GLOBUS_XIO_TCP_GET_INTERFACE,
+ interface_addr);
+ }
+
+@@ -1570,9 +1570,9 @@ globus_io_attr_set_tcp_allow_ipv6(
+ {
+ globus_l_io_attr_t * iattr;
+ GlobusIOName(globus_io_attr_set_tcp_allow_ipv6);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ iattr = (globus_l_io_attr_t *) *attr;
+ iattr->allow_ipv6 = allow;
+
+@@ -1586,12 +1586,12 @@ globus_io_attr_set_socket_reuseaddr(
+ globus_bool_t reuseaddr)
+ {
+ GlobusIOName(globus_io_attr_set_socket_reuseaddr);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_tcp_driver,
++ (*attr)->attr,
++ globus_l_io_tcp_driver,
+ GLOBUS_XIO_TCP_SET_REUSEADDR,
+ reuseaddr);
+ }
+@@ -1602,12 +1602,12 @@ globus_io_attr_get_socket_reuseaddr(
+ globus_bool_t * reuseaddr)
+ {
+ GlobusIOName(globus_io_attr_get_socket_reuseaddr);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_tcp_driver,
++ (*attr)->attr,
++ globus_l_io_tcp_driver,
+ GLOBUS_XIO_TCP_GET_REUSEADDR,
+ reuseaddr);
+ }
+@@ -1618,13 +1618,13 @@ globus_io_attr_set_socket_keepalive(
+ globus_bool_t keepalive)
+ {
+ GlobusIOName(globus_io_attr_set_socket_keepalive);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_tcp_driver,
+- GLOBUS_XIO_TCP_SET_KEEPALIVE,
++ (*attr)->attr,
++ globus_l_io_tcp_driver,
++ GLOBUS_XIO_TCP_SET_KEEPALIVE,
+ keepalive);
+ }
+
+@@ -1634,13 +1634,13 @@ globus_io_attr_get_socket_keepalive(
+ globus_bool_t * keepalive)
+ {
+ GlobusIOName(globus_io_attr_get_socket_keepalive);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_tcp_driver,
+- GLOBUS_XIO_TCP_GET_KEEPALIVE,
++ (*attr)->attr,
++ globus_l_io_tcp_driver,
++ GLOBUS_XIO_TCP_GET_KEEPALIVE,
+ keepalive);
+ }
+
+@@ -1651,12 +1651,12 @@ globus_io_attr_set_socket_linger(
+ int linger_time)
+ {
+ GlobusIOName(globus_io_attr_set_socket_linger);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_tcp_driver,
++ (*attr)->attr,
++ globus_l_io_tcp_driver,
+ GLOBUS_XIO_TCP_SET_LINGER,
+ linger,
+ linger_time);
+@@ -1669,12 +1669,12 @@ globus_io_attr_get_socket_linger(
+ int * linger_time)
+ {
+ GlobusIOName(globus_io_attr_get_socket_linger);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_tcp_driver,
++ (*attr)->attr,
++ globus_l_io_tcp_driver,
+ GLOBUS_XIO_TCP_GET_LINGER,
+ linger,
+ linger_time);
+@@ -1686,12 +1686,12 @@ globus_io_attr_set_socket_oobinline(
+ globus_bool_t oobinline)
+ {
+ GlobusIOName(globus_io_attr_set_socket_oobinline);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_tcp_driver,
++ (*attr)->attr,
++ globus_l_io_tcp_driver,
+ GLOBUS_XIO_TCP_SET_OOBINLINE,
+ oobinline);
+ }
+@@ -1702,13 +1702,13 @@ globus_io_attr_get_socket_oobinline(
+ globus_bool_t * oobinline)
+ {
+ GlobusIOName(globus_io_attr_get_socket_oobinline);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_tcp_driver,
+- GLOBUS_XIO_TCP_GET_OOBINLINE,
++ (*attr)->attr,
++ globus_l_io_tcp_driver,
++ GLOBUS_XIO_TCP_GET_OOBINLINE,
+ oobinline);
+ }
+
+@@ -1718,12 +1718,12 @@ globus_io_attr_set_socket_sndbuf(
+ int sndbuf)
+ {
+ GlobusIOName(globus_io_attr_set_socket_sndbuf);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_tcp_driver,
++ (*attr)->attr,
++ globus_l_io_tcp_driver,
+ GLOBUS_XIO_TCP_SET_SNDBUF,
+ sndbuf);
+ }
+@@ -1734,12 +1734,12 @@ globus_io_attr_get_socket_sndbuf(
+ int * sndbuf)
+ {
+ GlobusIOName(globus_io_attr_get_socket_sndbuf);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_tcp_driver,
++ (*attr)->attr,
++ globus_l_io_tcp_driver,
+ GLOBUS_XIO_TCP_GET_SNDBUF,
+ sndbuf);
+ }
+@@ -1750,12 +1750,12 @@ globus_io_attr_set_socket_rcvbuf(
+ int rcvbuf)
+ {
+ GlobusIOName(globus_io_attr_set_socket_rcvbuf);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_tcp_driver,
++ (*attr)->attr,
++ globus_l_io_tcp_driver,
+ GLOBUS_XIO_TCP_SET_RCVBUF,
+ rcvbuf);
+ }
+@@ -1766,12 +1766,12 @@ globus_io_attr_get_socket_rcvbuf(
+ int * rcvbuf)
+ {
+ GlobusIOName(globus_io_attr_get_socket_rcvbuf);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_tcp_driver,
++ (*attr)->attr,
++ globus_l_io_tcp_driver,
+ GLOBUS_XIO_TCP_GET_RCVBUF,
+ rcvbuf);
+ }
+@@ -1784,7 +1784,7 @@ globus_io_handle_get_socket_buf(
+ {
+ globus_result_t res = GLOBUS_SUCCESS;
+ GlobusIOName(globus_io_handle_get_socket_buf);
+-
++
+ GlobusLIOCheckHandle(handle, GLOBUS_I_IO_TCP_HANDLE);
+
+ if(rcvbuf != NULL)
+@@ -1835,10 +1835,10 @@ globus_l_io_file_open(
+ globus_l_io_attr_t * iattr;
+ globus_l_io_handle_t * ihandle;
+ GlobusIOName(globus_l_io_file_open);
+-
++
+ GlobusLIOCheckNullParam(handle);
+ *handle = GLOBUS_NULL;
+-
++
+ if(attr)
+ {
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_FILE_ATTR);
+@@ -1853,7 +1853,7 @@ globus_l_io_file_open(
+ goto error_attr;
+ }
+ iattr = (globus_l_io_attr_t *) myattr;
+-
++
+ if(path)
+ {
+ result = globus_xio_attr_cntl(
+@@ -1865,7 +1865,7 @@ globus_l_io_file_open(
+ {
+ goto error_cntl;
+ }
+-
++
+ result = globus_xio_attr_cntl(
+ iattr->attr,
+ globus_l_io_file_driver,
+@@ -1902,21 +1902,21 @@ globus_l_io_file_open(
+ goto error_cntl;
+ }
+ }
+-
++
+ result = globus_l_io_handle_init(
+ &ihandle, handle, GLOBUS_I_IO_FILE_HANDLE, iattr->space);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_alloc;
+ }
+-
++
+ result = globus_xio_handle_create(
+ &ihandle->xio_handle, globus_l_io_file_stack);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_handle;
+ }
+-
++
+ result = globus_xio_open(
+ ihandle->xio_handle,
+ path,
+@@ -1925,10 +1925,10 @@ globus_l_io_file_open(
+ {
+ goto error_open;
+ }
+-
++
+ *handle = ihandle;
+ globus_io_fileattr_destroy(&myattr);
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_open:
+@@ -1951,9 +1951,9 @@ globus_io_file_open(
+ globus_io_handle_t * handle)
+ {
+ GlobusIOName(globus_io_file_open);
+-
++
+ GlobusLIOCheckNullParam(path);
+-
++
+ return globus_l_io_file_open(handle, attr, path, flags, mode, -1, 0);
+ }
+
+@@ -1964,9 +1964,9 @@ globus_io_file_seek(
+ globus_io_whence_t whence)
+ {
+ GlobusIOName(globus_io_file_seek);
+-
++
+ GlobusLIOCheckHandle(handle, GLOBUS_I_IO_FILE_HANDLE);
+-
++
+ return globus_xio_handle_cntl(
+ (*handle)->xio_handle,
+ globus_l_io_file_driver,
+@@ -1982,7 +1982,7 @@ globus_io_file_posix_convert(
+ globus_io_handle_t * handle)
+ {
+ GlobusIOName(globus_io_file_posix_convert);
+-
++
+ return globus_l_io_file_open(
+ handle,
+ attr,
+@@ -2001,7 +2001,7 @@ globus_io_file_windows_convert(
+ globus_io_handle_t * handle)
+ {
+ GlobusIOName(globus_io_file_posix_convert);
+-
++
+ return globus_l_io_file_open(
+ handle,
+ attr,
+@@ -2064,21 +2064,21 @@ globus_l_io_tcp_register_connect(
+ globus_xio_stack_t stack;
+ char * cs = GLOBUS_NULL;
+ GlobusIOName(globus_l_io_tcp_register_connect);
+-
++
+ GlobusLIOCheckNullParam(handle);
+ GlobusLIOCheckNullParam(callback);
+-
++
+ if(attr)
+ {
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+ }
+-
++
+ result = GlobusLIOMalloc(bounce_info, globus_l_io_bounce_t);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_bounce;
+ }
+-
++
+ result = globus_l_io_handle_init(
+ &ihandle, handle, GLOBUS_I_IO_TCP_HANDLE,
+ attr ? (*attr)->space : GLOBUS_CALLBACK_GLOBAL_SPACE);
+@@ -2116,7 +2116,7 @@ globus_l_io_tcp_register_connect(
+ goto error_attr;
+ }
+ }
+-
++
+ if(!ihandle->attr->allow_ipv6)
+ {
+ result = globus_xio_attr_cntl(
+@@ -2129,7 +2129,7 @@ globus_l_io_tcp_register_connect(
+ goto error_attr;
+ }
+ }
+-
++
+ result = globus_xio_attr_cntl(
+ ihandle->attr->attr,
+ GLOBUS_NULL,
+@@ -2141,7 +2141,7 @@ globus_l_io_tcp_register_connect(
+ {
+ goto error_attr;
+ }
+-
++
+ if(host)
+ {
+ if(strchr(host, ':'))
+@@ -2166,7 +2166,7 @@ globus_l_io_tcp_register_connect(
+ goto error_attr;
+ }
+ }
+-
++
+ result = globus_xio_handle_create(&ihandle->xio_handle, stack);
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -2179,7 +2179,7 @@ globus_l_io_tcp_register_connect(
+ bounce_info->blocking = blocking;
+ bounce_info->cancel_info = GLOBUS_NULL;
+ *handle = ihandle;
+-
++
+ globus_mutex_lock(&ihandle->pending_lock);
+ {
+ result = globus_xio_register_open(
+@@ -2193,11 +2193,11 @@ globus_l_io_tcp_register_connect(
+ globus_mutex_unlock(&ihandle->pending_lock);
+ goto error_open;
+ }
+-
++
+ globus_l_io_cancel_insert(bounce_info);
+ }
+ globus_mutex_unlock(&ihandle->pending_lock);
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_open:
+@@ -2222,9 +2222,9 @@ globus_io_tcp_register_connect(
+ globus_io_handle_t * handle)
+ {
+ GlobusIOName(globus_io_tcp_register_connect);
+-
++
+ GlobusLIOCheckNullParam(host);
+-
++
+ return globus_l_io_tcp_register_connect(
+ host,
+ port,
+@@ -2248,11 +2248,11 @@ globus_l_io_tcp_connect(
+ globus_result_t result;
+ globus_l_io_monitor_t monitor;
+ GlobusIOName(globus_l_io_tcp_connect);
+-
++
+ monitor.done = GLOBUS_FALSE;
+ globus_mutex_init(&monitor.lock, GLOBUS_NULL);
+ globus_cond_init(&monitor.cond, GLOBUS_NULL);
+-
++
+ result = globus_l_io_tcp_register_connect(
+ host,
+ port,
+@@ -2267,7 +2267,7 @@ globus_l_io_tcp_connect(
+ monitor.done = GLOBUS_TRUE;
+ monitor.error = globus_error_get(result);
+ }
+-
++
+ globus_mutex_lock(&monitor.lock);
+ {
+ while(!monitor.done)
+@@ -2276,18 +2276,18 @@ globus_l_io_tcp_connect(
+ }
+ }
+ globus_mutex_unlock(&monitor.lock);
+-
++
+ globus_mutex_destroy(&monitor.lock);
+ globus_cond_destroy(&monitor.cond);
+-
++
+ if(monitor.error != GLOBUS_NULL)
+ {
+ result = globus_error_put(monitor.error);
+ goto error_register;
+ }
+-
++
+ return GLOBUS_SUCCESS;
+-
++
+ error_register:
+ *handle = GLOBUS_NULL;
+ return result;
+@@ -2301,9 +2301,9 @@ globus_io_tcp_connect(
+ globus_io_handle_t * handle)
+ {
+ GlobusIOName(globus_io_tcp_connect);
+-
++
+ GlobusLIOCheckNullParam(host);
+-
++
+ return globus_l_io_tcp_connect(host, port, -1, attr, handle);
+ }
+
+@@ -2322,9 +2322,9 @@ globus_l_io_tcp_create_listener(
+ globus_l_io_handle_t * ihandle;
+ globus_xio_stack_t stack;
+ GlobusIOName(globus_l_io_tcp_create_listener);
+-
++
+ GlobusLIOCheckNullParam(handle);
+-
++
+ if(attr)
+ {
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+@@ -2334,12 +2334,12 @@ globus_l_io_tcp_create_listener(
+ {
+ result = globus_io_tcpattr_init(&myattr);
+ }
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_attr;
+ }
+-
++
+ iattr = (globus_l_io_attr_t *) myattr;
+ if(port)
+ {
+@@ -2352,7 +2352,7 @@ globus_l_io_tcp_create_listener(
+ {
+ goto error_cntl;
+ }
+-
++
+ result = globus_xio_attr_cntl(
+ iattr->attr,
+ globus_l_io_tcp_driver,
+@@ -2371,7 +2371,7 @@ globus_l_io_tcp_create_listener(
+ {
+ goto error_cntl;
+ }
+-
++
+ if(!iattr->allow_ipv6)
+ {
+ result = globus_xio_attr_cntl(
+@@ -2384,7 +2384,7 @@ globus_l_io_tcp_create_listener(
+ goto error_cntl;
+ }
+ }
+-
++
+ result = globus_l_io_handle_init(
+ &ihandle, handle, GLOBUS_I_IO_TCP_HANDLE, iattr->space);
+ if(result != GLOBUS_SUCCESS)
+@@ -2395,7 +2395,7 @@ globus_l_io_tcp_create_listener(
+ if(iattr->stack != NULL)
+ {
+ stack = iattr->stack;
+- }
++ }
+ else if(iattr->authentication_mode ==
+ GLOBUS_IO_SECURE_AUTHENTICATION_MODE_NONE)
+ {
+@@ -2405,48 +2405,48 @@ globus_l_io_tcp_create_listener(
+ {
+ stack = globus_l_io_gsi_stack;
+ }
+-
++
+ result = globus_xio_server_create(
+ &ihandle->xio_server, iattr->attr, stack);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_server;
+ }
+-
++
+ if(port && !*port)
+ {
+ char * contact_string;
+ char * s;
+-
++
+ result = globus_xio_server_get_contact_string(
+ ihandle->xio_server, &contact_string);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_server_cntl;
+ }
+-
++
+ s = strrchr(contact_string, ':');
+ globus_assert(s);
+ *port = atoi(s + 1);
+-
++
+ globus_free(contact_string);
+ }
+-
++
+ ihandle->attr = iattr;
+ *handle = ihandle;
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_server_cntl:
+ globus_xio_server_close(ihandle->xio_server);
+-
++
+ error_server:
+ globus_l_io_handle_destroy(ihandle);
+-
++
+ error_alloc:
+ error_cntl:
+ globus_io_tcpattr_destroy(&myattr);
+-
++
+ error_attr:
+ *handle = GLOBUS_NULL;
+ return result;
+@@ -2460,9 +2460,9 @@ globus_io_tcp_create_listener(
+ globus_io_handle_t * handle)
+ {
+ GlobusIOName(globus_io_tcp_create_listener);
+-
++
+ GlobusLIOCheckNullParam(port);
+-
++
+ return globus_l_io_tcp_create_listener(
+ port, backlog, -1, attr, handle);
+ }
+@@ -2479,10 +2479,10 @@ globus_l_io_tcp_register_listen(
+ globus_l_io_handle_t * ihandle;
+ globus_l_io_bounce_t * bounce_info;
+ GlobusIOName(globus_l_io_tcp_register_listen);
+-
++
+ GlobusLIOCheckNullParam(callback);
+ GlobusLIOCheckHandle(handle, GLOBUS_I_IO_TCP_HANDLE);
+-
++
+ ihandle = *handle;
+ if(ihandle->accepted_handle)
+ {
+@@ -2492,22 +2492,22 @@ globus_l_io_tcp_register_listen(
+ GLOBUS_IO_MODULE,
+ GLOBUS_NULL,
+ ihandle->io_handle));
+-
++
+ goto error_registered;
+ }
+-
++
+ result = GlobusLIOMalloc(bounce_info, globus_l_io_bounce_t);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_bounce;
+ }
+-
++
+ bounce_info->handle = ihandle;
+ bounce_info->cb.non_io = callback;
+ bounce_info->user_arg = callback_arg;
+ bounce_info->blocking = blocking;
+ bounce_info->cancel_info = GLOBUS_NULL;
+-
++
+ globus_mutex_lock(&ihandle->pending_lock);
+ {
+ result = globus_xio_server_register_accept(
+@@ -2519,16 +2519,16 @@ globus_l_io_tcp_register_listen(
+ globus_mutex_unlock(&ihandle->pending_lock);
+ goto error_register;
+ }
+-
++
+ globus_l_io_cancel_insert(bounce_info);
+ }
+ globus_mutex_unlock(&ihandle->pending_lock);
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_register:
+ globus_free(bounce_info);
+-
++
+ error_bounce:
+ error_registered:
+ return result;
+@@ -2551,11 +2551,11 @@ globus_io_tcp_listen(
+ globus_result_t result;
+ globus_l_io_monitor_t monitor;
+ GlobusIOName(globus_io_tcp_listen);
+-
++
+ monitor.done = GLOBUS_FALSE;
+ globus_mutex_init(&monitor.lock, GLOBUS_NULL);
+ globus_cond_init(&monitor.cond, GLOBUS_NULL);
+-
++
+ result = globus_l_io_tcp_register_listen(
+ handle, globus_l_io_blocking_cb, &monitor, GLOBUS_TRUE);
+ if(result != GLOBUS_SUCCESS)
+@@ -2563,7 +2563,7 @@ globus_io_tcp_listen(
+ monitor.done = GLOBUS_TRUE;
+ monitor.error = globus_error_get(result);
+ }
+-
++
+ globus_mutex_lock(&monitor.lock);
+ {
+ while(!monitor.done)
+@@ -2572,18 +2572,18 @@ globus_io_tcp_listen(
+ }
+ }
+ globus_mutex_unlock(&monitor.lock);
+-
++
+ globus_mutex_destroy(&monitor.lock);
+ globus_cond_destroy(&monitor.cond);
+-
++
+ if(monitor.error != GLOBUS_NULL)
+ {
+ result = globus_error_put(monitor.error);
+ goto error_register;
+ }
+-
++
+ return GLOBUS_SUCCESS;
+-
++
+ error_register:
+ return result;
+ }
+@@ -2609,11 +2609,11 @@ globus_l_io_tcp_register_accept(
+ globus_l_io_bounce_t * bounce_info;
+ char * contact_string = GLOBUS_NULL;
+ GlobusIOName(globus_io_tcp_register_accept);
+-
++
+ GlobusLIOCheckNullParam(new_handle);
+ GlobusLIOCheckNullParam(callback);
+ GlobusLIOCheckHandle(listener_handle, GLOBUS_I_IO_TCP_HANDLE);
+-
++
+ ilistener_handle = *listener_handle;
+ if(!ilistener_handle->accepted_handle)
+ {
+@@ -2624,15 +2624,15 @@ globus_l_io_tcp_register_accept(
+ "listener_handle",
+ 1,
+ (char *) _io_name));
+-
++
+ goto error_handle;
+ }
+-
++
+ if(attr)
+ {
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+ }
+-
++
+ result = globus_l_io_handle_init(
+ &ihandle, new_handle, GLOBUS_I_IO_TCP_HANDLE,
+ attr ? (*attr)->space : ilistener_handle->space);
+@@ -2640,20 +2640,20 @@ globus_l_io_tcp_register_accept(
+ {
+ goto error_handle;
+ }
+-
++
+ result = GlobusLIOMalloc(bounce_info, globus_l_io_bounce_t);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_bounce;
+ }
+-
++
+ bounce_info->handle = ihandle;
+ bounce_info->cb.non_io = callback;
+ bounce_info->user_arg = callback_arg;
+ bounce_info->blocking = blocking;
+ bounce_info->cancel_info = GLOBUS_NULL;
+ *new_handle = ihandle;
+-
++
+ if(attr)
+ {
+ result = globus_l_io_iattr_copy(&ihandle->attr, attr);
+@@ -2661,12 +2661,12 @@ globus_l_io_tcp_register_accept(
+ {
+ goto error_gsi;
+ }
+-
+- if((ilistener_handle->attr->authentication_mode ==
++
++ if((ilistener_handle->attr->authentication_mode ==
+ GLOBUS_IO_SECURE_AUTHENTICATION_MODE_NONE ||
+- ihandle->attr->authentication_mode ==
++ ihandle->attr->authentication_mode ==
+ GLOBUS_IO_SECURE_AUTHENTICATION_MODE_NONE) &&
+- ilistener_handle->attr->authentication_mode !=
++ ilistener_handle->attr->authentication_mode !=
+ ihandle->attr->authentication_mode)
+ {
+ result = globus_error_put(
+@@ -2693,7 +2693,7 @@ globus_l_io_tcp_register_accept(
+ goto error_gsi;
+ }
+ }
+-
++
+ ihandle->xio_handle = ilistener_handle->accepted_handle;
+ ilistener_handle->accepted_handle = GLOBUS_NULL;
+
+@@ -2708,7 +2708,7 @@ globus_l_io_tcp_register_accept(
+ {
+ goto error_gsi;
+ }
+-
++
+ globus_mutex_lock(&ihandle->pending_lock);
+ {
+ result = globus_xio_register_open(
+@@ -2719,20 +2719,20 @@ globus_l_io_tcp_register_accept(
+ bounce_info);
+
+ if(contact_string != GLOBUS_NULL)
+- {
++ {
+ globus_free(contact_string);
+ }
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ globus_mutex_unlock(&ihandle->pending_lock);
+ goto error_open;
+ }
+-
++
+ globus_l_io_cancel_insert(bounce_info);
+ }
+ globus_mutex_unlock(&ihandle->pending_lock);
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_open:
+@@ -2772,11 +2772,11 @@ globus_io_tcp_accept(
+ globus_result_t result;
+ globus_l_io_monitor_t monitor;
+ GlobusIOName(globus_io_tcp_accept);
+-
++
+ monitor.done = GLOBUS_FALSE;
+ globus_mutex_init(&monitor.lock, GLOBUS_NULL);
+ globus_cond_init(&monitor.cond, GLOBUS_NULL);
+-
++
+ result = globus_l_io_tcp_register_accept(
+ listener_handle,
+ attr,
+@@ -2789,7 +2789,7 @@ globus_io_tcp_accept(
+ monitor.done = GLOBUS_TRUE;
+ monitor.error = globus_error_get(result);
+ }
+-
++
+ globus_mutex_lock(&monitor.lock);
+ {
+ while(!monitor.done)
+@@ -2798,18 +2798,18 @@ globus_io_tcp_accept(
+ }
+ }
+ globus_mutex_unlock(&monitor.lock);
+-
++
+ globus_mutex_destroy(&monitor.lock);
+ globus_cond_destroy(&monitor.cond);
+-
++
+ if(monitor.error != GLOBUS_NULL)
+ {
+ result = globus_error_put(monitor.error);
+ goto error_register;
+ }
+-
++
+ return GLOBUS_SUCCESS;
+-
++
+ error_register:
+ return result;
+ }
+@@ -2827,12 +2827,12 @@ globus_io_tcp_get_local_address_ex(
+ globus_result_t result;
+ char * cs;
+ GlobusIOName(globus_io_tcp_get_local_address_ex);
+-
++
+ GlobusLIOCheckNullParam(host);
+ GlobusLIOCheckNullParam(count);
+ GlobusLIOCheckNullParam(port);
+ GlobusLIOCheckHandle(handle, GLOBUS_I_IO_TCP_HANDLE);
+-
++
+ if((*handle)->xio_handle)
+ {
+ result = globus_xio_handle_cntl(
+@@ -2853,20 +2853,20 @@ globus_io_tcp_get_local_address_ex(
+ {
+ goto error_cntl;
+ }
+-
++
+ result = globus_libc_contact_string_to_ints(cs, host, count, port);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_parse;
+ }
+-
++
+ globus_free(cs);
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_parse:
+ globus_free(cs);
+-
++
+ error_cntl:
+ return result;
+ }
+@@ -2881,12 +2881,12 @@ globus_io_tcp_get_remote_address_ex(
+ globus_result_t result;
+ char * cs;
+ GlobusIOName(globus_io_tcp_get_remote_address_ex);
+-
++
+ GlobusLIOCheckNullParam(host);
+ GlobusLIOCheckNullParam(count);
+ GlobusLIOCheckNullParam(port);
+ GlobusLIOCheckHandle(handle, GLOBUS_I_IO_TCP_HANDLE);
+-
++
+ if((*handle)->xio_handle)
+ {
+ result = globus_xio_handle_cntl(
+@@ -2907,20 +2907,20 @@ globus_io_tcp_get_remote_address_ex(
+ {
+ goto error_cntl;
+ }
+-
++
+ result = globus_libc_contact_string_to_ints(cs, host, count, port);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_parse;
+ }
+-
++
+ globus_free(cs);
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_parse:
+ globus_free(cs);
+-
++
+ error_cntl:
+ return result;
+ }
+@@ -2935,17 +2935,17 @@ globus_io_tcp_get_local_address(
+ int count;
+ globus_result_t result;
+ GlobusIOName(globus_io_tcp_get_local_address);
+-
++
+ GlobusLIOCheckNullParam(host);
+ GlobusLIOCheckNullParam(port);
+ GlobusLIOCheckHandle(handle, GLOBUS_I_IO_TCP_HANDLE);
+-
++
+ result = globus_io_tcp_get_local_address_ex(handle, myhost, &count, port);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_cntl;
+ }
+-
++
+ if(count != 4)
+ {
+ /* interface doesnt support ipv6 addresses */
+@@ -2954,15 +2954,15 @@ globus_io_tcp_get_local_address(
+ GLOBUS_IO_MODULE,
+ GLOBUS_NULL,
+ (char *) _io_name));
+-
++
+ goto error_ipv6;
+ }
+-
++
+ while(count--)
+ {
+ host[count] = myhost[count];
+ }
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_ipv6:
+@@ -2980,17 +2980,17 @@ globus_io_tcp_get_remote_address(
+ int count;
+ globus_result_t result;
+ GlobusIOName(globus_io_tcp_get_remote_address);
+-
++
+ GlobusLIOCheckNullParam(host);
+ GlobusLIOCheckNullParam(port);
+ GlobusLIOCheckHandle(handle, GLOBUS_I_IO_TCP_HANDLE);
+-
++
+ result = globus_io_tcp_get_remote_address_ex(handle, myhost, &count, port);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_cntl;
+ }
+-
++
+ if(count != 4)
+ {
+ /* interface doesnt support ipv6 addresses */
+@@ -2999,15 +2999,15 @@ globus_io_tcp_get_remote_address(
+ GLOBUS_IO_MODULE,
+ GLOBUS_NULL,
+ (char *) _io_name));
+-
++
+ goto error_ipv6;
+ }
+-
++
+ while(count--)
+ {
+ host[count] = myhost[count];
+ }
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_ipv6:
+@@ -3030,23 +3030,23 @@ globus_io_register_read(
+ globus_l_io_handle_t * ihandle;
+ globus_result_t result;
+ GlobusIOName(globus_io_register_read);
+-
++
+ GlobusLIOCheckNullParam(callback);
+ GlobusLIOCheckHandle(handle, 0);
+-
++
+ ihandle = *handle;
+ result = GlobusLIOMalloc(bounce_info, globus_l_io_bounce_t);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_alloc;
+ }
+-
++
+ bounce_info->handle = ihandle;
+ bounce_info->cb.read_write = callback;
+ bounce_info->user_arg = callback_arg;
+ bounce_info->blocking = GLOBUS_FALSE;
+ bounce_info->cancel_info = GLOBUS_NULL;
+-
++
+ globus_mutex_lock(&ihandle->pending_lock);
+ {
+ result = globus_xio_register_read(
+@@ -3062,16 +3062,16 @@ globus_io_register_read(
+ globus_mutex_unlock(&ihandle->pending_lock);
+ goto error_register;
+ }
+-
++
+ globus_l_io_cancel_insert(bounce_info);
+ }
+ globus_mutex_unlock(&ihandle->pending_lock);
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_register:
+ globus_free(bounce_info);
+-
++
+ error_alloc:
+ return result;
+ }
+@@ -3085,11 +3085,11 @@ globus_io_try_read(
+ {
+ globus_result_t result;
+ GlobusIOName(globus_io_try_read);
+-
++
+ GlobusLIOCheckNullParam(nbytes_read);
+ *nbytes_read = 0;
+ GlobusLIOCheckHandle(handle, 0);
+-
++
+ result = globus_xio_read(
+ (*handle)->xio_handle,
+ buf,
+@@ -3101,9 +3101,9 @@ globus_io_try_read(
+ {
+ goto error_read;
+ }
+-
++
+ return GLOBUS_SUCCESS;
+-
++
+ error_read:
+ if(globus_xio_error_is_eof(result))
+ {
+@@ -3121,7 +3121,7 @@ error_read:
+ globus_error_get(result),
+ (*handle)->io_handle));
+ }
+-
++
+ return result;
+ }
+
+@@ -3135,11 +3135,11 @@ globus_io_read(
+ {
+ globus_result_t result;
+ GlobusIOName(globus_io_read);
+-
++
+ GlobusLIOCheckNullParam(nbytes_read);
+ *nbytes_read = 0;
+ GlobusLIOCheckHandle(handle, 0);
+-
++
+ result = globus_xio_read(
+ (*handle)->xio_handle,
+ buf,
+@@ -3151,9 +3151,9 @@ globus_io_read(
+ {
+ goto error_read;
+ }
+-
++
+ return GLOBUS_SUCCESS;
+-
++
+ error_read:
+ if(globus_xio_error_is_eof(result))
+ {
+@@ -3171,7 +3171,7 @@ error_read:
+ globus_error_get(result),
+ (*handle)->io_handle));
+ }
+-
++
+ return result;
+ }
+
+@@ -3189,23 +3189,23 @@ globus_io_register_write(
+ globus_l_io_handle_t * ihandle;
+ globus_result_t result;
+ GlobusIOName(globus_io_register_write);
+-
++
+ GlobusLIOCheckNullParam(write_callback);
+ GlobusLIOCheckHandle(handle, 0);
+-
++
+ ihandle = *handle;
+ result = GlobusLIOMalloc(bounce_info, globus_l_io_bounce_t);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_alloc;
+ }
+-
++
+ bounce_info->handle = ihandle;
+ bounce_info->cb.read_write = write_callback;
+ bounce_info->user_arg = callback_arg;
+ bounce_info->blocking = GLOBUS_FALSE;
+ bounce_info->cancel_info = GLOBUS_NULL;
+-
++
+ globus_mutex_lock(&ihandle->pending_lock);
+ {
+ result = globus_xio_register_write(
+@@ -3221,16 +3221,16 @@ globus_io_register_write(
+ globus_mutex_unlock(&ihandle->pending_lock);
+ goto error_register;
+ }
+-
++
+ globus_l_io_cancel_insert(bounce_info);
+ }
+ globus_mutex_unlock(&ihandle->pending_lock);
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_register:
+ globus_free(bounce_info);
+-
++
+ error_alloc:
+ return result;
+ }
+@@ -3249,17 +3249,17 @@ globus_io_register_send(
+ globus_result_t result;
+ globus_xio_data_descriptor_t dd;
+ GlobusIOName(globus_io_register_send);
+-
++
+ GlobusLIOCheckNullParam(write_callback);
+ GlobusLIOCheckHandle(handle, GLOBUS_I_IO_TCP_HANDLE);
+-
++
+ ihandle = *handle;
+ result = GlobusLIOMalloc(bounce_info, globus_l_io_bounce_t);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_alloc;
+ }
+-
++
+ if(flags)
+ {
+ result = globus_xio_data_descriptor_init(&dd, ihandle->xio_handle);
+@@ -3267,7 +3267,7 @@ globus_io_register_send(
+ {
+ goto error_dd;
+ }
+-
++
+ result = globus_xio_data_descriptor_cntl(
+ dd,
+ globus_l_io_tcp_driver,
+@@ -3282,13 +3282,13 @@ globus_io_register_send(
+ {
+ dd = GLOBUS_NULL;
+ }
+-
++
+ bounce_info->handle = ihandle;
+ bounce_info->cb.read_write = write_callback;
+ bounce_info->user_arg = callback_arg;
+ bounce_info->blocking = GLOBUS_FALSE;
+ bounce_info->cancel_info = GLOBUS_NULL;
+-
++
+ globus_mutex_lock(&ihandle->pending_lock);
+ {
+ result = globus_xio_register_write(
+@@ -3305,11 +3305,11 @@ globus_io_register_send(
+ globus_mutex_unlock(&ihandle->pending_lock);
+ goto error_register;
+ }
+-
++
+ globus_l_io_cancel_insert(bounce_info);
+ }
+ globus_mutex_unlock(&ihandle->pending_lock);
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_register:
+@@ -3318,10 +3318,10 @@ error_dd_cntl:
+ {
+ globus_xio_data_descriptor_destroy(dd);
+ }
+-
++
+ error_dd:
+ globus_free(bounce_info);
+-
++
+ error_alloc:
+ return result;
+ }
+@@ -3340,30 +3340,30 @@ globus_io_register_writev(
+ int i;
+ globus_size_t nbytes;
+ GlobusIOName(globus_io_register_writev);
+-
++
+ GlobusLIOCheckNullParam(writev_callback);
+ GlobusLIOCheckNullParam(iov);
+ GlobusLIOCheckHandle(handle, 0);
+-
++
+ ihandle = *handle;
+ result = GlobusLIOMalloc(bounce_info, globus_l_io_bounce_t);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_alloc;
+ }
+-
++
+ bounce_info->handle = ihandle;
+ bounce_info->cb.writev = writev_callback;
+ bounce_info->user_arg = callback_arg;
+ bounce_info->blocking = GLOBUS_FALSE;
+ bounce_info->cancel_info = GLOBUS_NULL;
+-
++
+ nbytes = 0;
+ for(i = 0; i < iovcnt; i++)
+ {
+ nbytes += iov[i].iov_len;
+ }
+-
++
+ globus_mutex_lock(&ihandle->pending_lock);
+ {
+ result = globus_xio_register_writev(
+@@ -3379,16 +3379,16 @@ globus_io_register_writev(
+ globus_mutex_unlock(&ihandle->pending_lock);
+ goto error_register;
+ }
+-
++
+ globus_l_io_cancel_insert(bounce_info);
+ }
+ globus_mutex_unlock(&ihandle->pending_lock);
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_register:
+ globus_free(bounce_info);
+-
++
+ error_alloc:
+ return result;
+ }
+@@ -3402,11 +3402,11 @@ globus_io_try_write(
+ {
+ globus_result_t result;
+ GlobusIOName(globus_io_try_write);
+-
++
+ GlobusLIOCheckNullParam(nbytes_written);
+ *nbytes_written = 0;
+ GlobusLIOCheckHandle(handle, 0);
+-
++
+ result = globus_xio_write(
+ (*handle)->xio_handle,
+ buf,
+@@ -3418,9 +3418,9 @@ globus_io_try_write(
+ {
+ goto error_write;
+ }
+-
++
+ return GLOBUS_SUCCESS;
+-
++
+ error_write:
+ if(globus_xio_error_is_canceled(result))
+ {
+@@ -3430,7 +3430,7 @@ error_write:
+ globus_error_get(result),
+ (*handle)->io_handle));
+ }
+-
++
+ return result;
+ }
+
+@@ -3445,11 +3445,11 @@ globus_io_try_send(
+ globus_result_t result;
+ globus_xio_data_descriptor_t dd;
+ GlobusIOName(globus_io_try_send);
+-
++
+ GlobusLIOCheckNullParam(nbytes_sent);
+ *nbytes_sent = 0;
+ GlobusLIOCheckHandle(handle, GLOBUS_I_IO_TCP_HANDLE);
+-
++
+ if(flags)
+ {
+ result = globus_xio_data_descriptor_init(&dd, (*handle)->xio_handle);
+@@ -3457,7 +3457,7 @@ globus_io_try_send(
+ {
+ goto error_dd;
+ }
+-
++
+ result = globus_xio_data_descriptor_cntl(
+ dd,
+ globus_l_io_tcp_driver,
+@@ -3472,7 +3472,7 @@ globus_io_try_send(
+ {
+ dd = GLOBUS_NULL;
+ }
+-
++
+ result = globus_xio_write(
+ (*handle)->xio_handle,
+ buf,
+@@ -3486,7 +3486,7 @@ globus_io_try_send(
+ goto error_write;
+ }
+ return GLOBUS_SUCCESS;
+-
++
+ error_write:
+ if(globus_xio_error_is_canceled(result))
+ {
+@@ -3502,7 +3502,7 @@ error_dd_cntl:
+ {
+ globus_xio_data_descriptor_destroy(dd);
+ }
+-
++
+ error_dd:
+ return result;
+ }
+@@ -3516,11 +3516,11 @@ globus_io_write(
+ {
+ globus_result_t result;
+ GlobusIOName(globus_io_write);
+-
++
+ GlobusLIOCheckNullParam(nbytes_written);
+ *nbytes_written = 0;
+ GlobusLIOCheckHandle(handle, 0);
+-
++
+ result = globus_xio_write(
+ (*handle)->xio_handle,
+ buf,
+@@ -3532,9 +3532,9 @@ globus_io_write(
+ {
+ goto error_write;
+ }
+-
++
+ return GLOBUS_SUCCESS;
+-
++
+ error_write:
+ if(globus_xio_error_is_canceled(result))
+ {
+@@ -3544,7 +3544,7 @@ error_write:
+ globus_error_get(result),
+ (*handle)->io_handle));
+ }
+-
++
+ return result;
+ }
+
+@@ -3559,11 +3559,11 @@ globus_io_send(
+ globus_result_t result;
+ globus_xio_data_descriptor_t dd;
+ GlobusIOName(globus_io_send);
+-
++
+ GlobusLIOCheckNullParam(nbytes_sent);
+ *nbytes_sent = 0;
+ GlobusLIOCheckHandle(handle, GLOBUS_I_IO_TCP_HANDLE);
+-
++
+ if(flags)
+ {
+ result = globus_xio_data_descriptor_init(&dd, (*handle)->xio_handle);
+@@ -3571,7 +3571,7 @@ globus_io_send(
+ {
+ goto error_dd;
+ }
+-
++
+ result = globus_xio_data_descriptor_cntl(
+ dd,
+ globus_l_io_tcp_driver,
+@@ -3586,7 +3586,7 @@ globus_io_send(
+ {
+ dd = GLOBUS_NULL;
+ }
+-
++
+ result = globus_xio_write(
+ (*handle)->xio_handle,
+ buf,
+@@ -3601,7 +3601,7 @@ globus_io_send(
+ }
+
+ return GLOBUS_SUCCESS;
+-
++
+ error_write:
+ if(globus_xio_error_is_canceled(result))
+ {
+@@ -3617,7 +3617,7 @@ error_dd_cntl:
+ {
+ globus_xio_data_descriptor_destroy(dd);
+ }
+-
++
+ error_dd:
+ return result;
+ }
+@@ -3633,18 +3633,18 @@ globus_io_writev(
+ int i;
+ globus_size_t nbytes;
+ GlobusIOName(globus_io_writev);
+-
++
+ GlobusLIOCheckNullParam(bytes_written);
+ *bytes_written = 0;
+ GlobusLIOCheckNullParam(iov);
+ GlobusLIOCheckHandle(handle, 0);
+-
++
+ nbytes = 0;
+ for(i = 0; i < iovcnt; i++)
+ {
+ nbytes += iov[i].iov_len;
+ }
+-
++
+ result = globus_xio_writev(
+ (*handle)->xio_handle,
+ iov,
+@@ -3656,9 +3656,9 @@ globus_io_writev(
+ {
+ goto error_write;
+ }
+-
++
+ return GLOBUS_SUCCESS;
+-
++
+ error_write:
+ if(globus_xio_error_is_canceled(result))
+ {
+@@ -3668,7 +3668,7 @@ error_write:
+ globus_error_get(result),
+ (*handle)->io_handle));
+ }
+-
++
+ return result;
+ }
+
+@@ -3680,7 +3680,7 @@ globus_l_io_bounce_close_cb(
+ globus_xio_handle_t handle,
+ globus_result_t result,
+ void * user_arg);
+-
++
+ static
+ void
+ globus_l_io_bounce_close_kickout(
+@@ -3688,12 +3688,12 @@ globus_l_io_bounce_close_kickout(
+ {
+ globus_l_io_bounce_t * bounce_info;
+ GlobusIOName(globus_l_io_bounce_close_kickout);
+-
++
+ bounce_info = (globus_l_io_bounce_t *) user_arg;
+-
++
+ globus_l_io_bounce_close_cb(
+ GLOBUS_NULL,
+- bounce_info->error
++ bounce_info->error
+ ? globus_error_put(bounce_info->error) : GLOBUS_SUCCESS,
+ user_arg);
+ }
+@@ -3707,12 +3707,12 @@ globus_l_io_bounce_close_cb(
+ {
+ globus_l_io_bounce_t * bounce_info;
+ GlobusIOName(globus_l_io_bounce_close_cb);
+-
++
+ bounce_info = (globus_l_io_bounce_t *) user_arg;
+-
++
+ if(globus_l_io_should_bounce(bounce_info))
+ {
+- bounce_info->error = result == GLOBUS_SUCCESS
++ bounce_info->error = result == GLOBUS_SUCCESS
+ ? GLOBUS_NULL : globus_error_get(result);
+ result = globus_callback_space_register_oneshot(
+ GLOBUS_NULL,
+@@ -3732,18 +3732,18 @@ globus_l_io_bounce_close_cb(
+ }
+ return;
+ }
+-
++
+ bounce_info->cb.non_io(
+ bounce_info->user_arg,
+ bounce_info->handle->io_handle,
+ result);
+-
++
+ globus_mutex_lock(&bounce_info->handle->pending_lock);
+ {
+ bounce_info->handle->refs--;
+ }
+ globus_mutex_unlock(&bounce_info->handle->pending_lock);
+-
++
+ globus_l_io_handle_destroy(bounce_info->handle);
+ globus_free(bounce_info);
+ }
+@@ -3753,7 +3753,7 @@ void
+ globus_l_io_server_close_cb(
+ globus_xio_server_t xio_server,
+ void * user_arg);
+-
++
+ static
+ void
+ globus_l_io_server_close_kickout(
+@@ -3761,9 +3761,9 @@ globus_l_io_server_close_kickout(
+ {
+ globus_l_io_bounce_t * bounce_info;
+ GlobusIOName(globus_l_io_server_close_kickout);
+-
++
+ bounce_info = (globus_l_io_bounce_t *) user_arg;
+-
++
+ globus_l_io_server_close_cb(GLOBUS_NULL, user_arg);
+ }
+
+@@ -3775,13 +3775,13 @@ globus_l_io_server_close_cb(
+ {
+ globus_l_io_bounce_t * bounce_info;
+ GlobusIOName(globus_l_io_server_close_cb);
+-
++
+ bounce_info = (globus_l_io_bounce_t *) user_arg;
+-
++
+ if(globus_l_io_should_bounce(bounce_info))
+ {
+ globus_result_t result;
+-
++
+ result = globus_callback_space_register_oneshot(
+ GLOBUS_NULL,
+ GLOBUS_NULL,
+@@ -3800,18 +3800,18 @@ globus_l_io_server_close_cb(
+ }
+ return;
+ }
+-
++
+ bounce_info->cb.non_io(
+ bounce_info->user_arg,
+ bounce_info->handle->io_handle,
+ GLOBUS_SUCCESS);
+-
++
+ globus_mutex_lock(&bounce_info->handle->pending_lock);
+ {
+ bounce_info->handle->refs--;
+ }
+ globus_mutex_unlock(&bounce_info->handle->pending_lock);
+-
++
+ globus_l_io_handle_destroy(bounce_info->handle);
+ globus_free(bounce_info);
+ }
+@@ -3827,31 +3827,31 @@ globus_l_io_register_close(
+ globus_l_io_handle_t * ihandle;
+ globus_result_t result;
+ GlobusIOName(globus_io_register_close);
+-
++
+ GlobusLIOCheckNullParam(callback);
+ GlobusLIOCheckHandle(handle, 0);
+ ihandle = *handle;
+-
++
+ result = GlobusLIOMalloc(bounce_info, globus_l_io_bounce_t);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_alloc;
+ }
+-
++
+ bounce_info->handle = ihandle;
+ bounce_info->cb.non_io = callback;
+ bounce_info->user_arg = callback_arg;
+ bounce_info->blocking = blocking;
+-
++
+ globus_mutex_lock(&ihandle->pending_lock);
+ {
+ if(ihandle->xio_handle)
+ {
+ globus_xio_handle_t xio_handle;
+-
++
+ xio_handle = ihandle->xio_handle;
+ ihandle->xio_handle = GLOBUS_NULL;
+-
++
+ result = globus_xio_register_close(
+ xio_handle,
+ GLOBUS_NULL,
+@@ -3861,10 +3861,10 @@ globus_l_io_register_close(
+ else if(ihandle->xio_server)
+ {
+ globus_xio_server_t xio_server;
+-
++
+ xio_server = ihandle->xio_server;
+ ihandle->xio_server = GLOBUS_NULL;
+-
++
+ result = globus_xio_server_register_close(
+ xio_server,
+ globus_l_io_server_close_cb,
+@@ -3880,24 +3880,24 @@ globus_l_io_register_close(
+ 1,
+ (char *) _io_name));
+ }
+-
++
+ if(result == GLOBUS_SUCCESS)
+ {
+ ihandle->refs++;
+ }
+ }
+ globus_mutex_unlock(&ihandle->pending_lock);
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_register;
+ }
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_register:
+ globus_free(bounce_info);
+-
++
+ error_alloc:
+ *handle = GLOBUS_NULL;
+ return result;
+@@ -3920,11 +3920,11 @@ globus_io_close(
+ globus_result_t result;
+ globus_l_io_monitor_t monitor;
+ GlobusIOName(globus_io_close);
+-
++
+ monitor.done = GLOBUS_FALSE;
+ globus_mutex_init(&monitor.lock, GLOBUS_NULL);
+ globus_cond_init(&monitor.cond, GLOBUS_NULL);
+-
++
+ result = globus_l_io_register_close(
+ handle, globus_l_io_blocking_cb, &monitor, GLOBUS_TRUE);
+ if(result != GLOBUS_SUCCESS)
+@@ -3932,7 +3932,7 @@ globus_io_close(
+ monitor.done = GLOBUS_TRUE;
+ monitor.error = globus_error_get(result);
+ }
+-
++
+ globus_mutex_lock(&monitor.lock);
+ {
+ while(!monitor.done)
+@@ -3941,18 +3941,18 @@ globus_io_close(
+ }
+ }
+ globus_mutex_unlock(&monitor.lock);
+-
++
+ globus_mutex_destroy(&monitor.lock);
+ globus_cond_destroy(&monitor.cond);
+-
++
+ if(monitor.error != GLOBUS_NULL)
+ {
+ result = globus_error_put(monitor.error);
+ goto error_register;
+ }
+-
++
+ return GLOBUS_SUCCESS;
+-
++
+ error_register:
+ return result;
+ }
+@@ -3962,7 +3962,7 @@ globus_io_eof(
+ globus_object_t * eof)
+ {
+ GlobusIOName(globus_io_eof);
+-
++
+ if(eof && globus_object_get_type(eof) == GLOBUS_IO_ERROR_TYPE_EOF)
+ {
+ return GLOBUS_TRUE;
+@@ -3980,7 +3980,7 @@ globus_io_tcp_posix_convert(
+ globus_io_handle_t * handle)
+ {
+ GlobusIOName(globus_io_tcp_posix_convert);
+-
++
+ return globus_l_io_tcp_connect(GLOBUS_NULL, 0, socket, attr, handle);
+ }
+
+@@ -3991,7 +3991,7 @@ globus_io_tcp_posix_convert_listener(
+ globus_io_handle_t * handle)
+ {
+ GlobusIOName(globus_io_tcp_posix_convert_listener);
+-
++
+ return globus_l_io_tcp_create_listener(
+ GLOBUS_NULL, 0, socket, attr, handle);
+ }
+@@ -4010,23 +4010,23 @@ globus_l_io_register_cancel(
+ globus_l_io_cancel_info_t * cancel_info;
+ globus_l_io_bounce_t * bounce_info;
+ GlobusIOName(globus_io_register_cancel);
+-
++
+ GlobusLIOCheckHandle(handle, 0);
+ ihandle = *handle;
+-
++
+ result = GlobusLIOMalloc(cancel_info, globus_l_io_cancel_info_t);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_cancel_info;
+ }
+-
++
+ cancel_info->handle = handle;
+ cancel_info->refs = 0;
+ cancel_info->blocking = blocking;
+ cancel_info->perform_callbacks = perform_callbacks;
+ cancel_info->callback = cancel_callback;
+ cancel_info->user_arg = cancel_arg;
+-
++
+ globus_mutex_lock(&ihandle->pending_lock);
+ {
+ if(ihandle->xio_handle)
+@@ -4048,16 +4048,16 @@ globus_l_io_register_cancel(
+ GLOBUS_NULL,
+ "handle",
+ 1,
+- (char *) _io_name));
++ (char *) _io_name));
+ }
+-
++
+ if(result == GLOBUS_SUCCESS)
+ {
+ globus_list_t * pending;
+-
++
+ pending = ihandle->pending_ops;
+ ihandle->pending_ops = GLOBUS_NULL;
+-
++
+ while(!globus_list_empty(pending))
+ {
+ bounce_info = globus_list_remove(&pending, pending);
+@@ -4065,7 +4065,7 @@ globus_l_io_register_cancel(
+ cancel_info->refs++;
+ }
+ }
+-
++
+ if(cancel_info->refs == 0)
+ {
+ result = globus_callback_space_register_oneshot(
+@@ -4082,13 +4082,13 @@ globus_l_io_register_cancel(
+ }
+ }
+ globus_mutex_unlock(&ihandle->pending_lock);
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_oneshot:
+ globus_mutex_unlock(&ihandle->pending_lock);
+ globus_free(cancel_info);
+-
++
+ error_cancel_info:
+ return result;
+ }
+@@ -4112,11 +4112,11 @@ globus_io_cancel(
+ globus_result_t result;
+ globus_l_io_monitor_t monitor;
+ GlobusIOName(globus_io_cancel);
+-
++
+ monitor.done = GLOBUS_FALSE;
+ globus_mutex_init(&monitor.lock, GLOBUS_NULL);
+ globus_cond_init(&monitor.cond, GLOBUS_NULL);
+-
++
+ result = globus_l_io_register_cancel(
+ handle,
+ perform_callbacks,
+@@ -4128,7 +4128,7 @@ globus_io_cancel(
+ monitor.done = GLOBUS_TRUE;
+ monitor.error = globus_error_get(result);
+ }
+-
++
+ globus_mutex_lock(&monitor.lock);
+ {
+ while(!monitor.done)
+@@ -4137,18 +4137,18 @@ globus_io_cancel(
+ }
+ }
+ globus_mutex_unlock(&monitor.lock);
+-
++
+ globus_mutex_destroy(&monitor.lock);
+ globus_cond_destroy(&monitor.cond);
+-
++
+ if(monitor.error != GLOBUS_NULL)
+ {
+ result = globus_error_put(monitor.error);
+ goto error_register;
+ }
+-
++
+ return GLOBUS_SUCCESS;
+-
++
+ error_register:
+ return result;
+ }
+@@ -4163,10 +4163,10 @@ globus_l_io_bounce_select_cb(
+ globus_size_t nbytes)
+ {
+ globus_io_callback_t cb;
+-
++
+ /* callback is buried in buffer... bad me */
+ cb = (globus_io_callback_t) buf;
+-
++
+ cb(arg, handle, result);
+ }
+
+@@ -4183,10 +4183,10 @@ globus_io_register_select(
+ globus_l_io_handle_t * ihandle;
+ globus_result_t result;
+ GlobusIOName(globus_io_register_select);
+-
++
+ GlobusLIOCheckHandle(handle, 0);
+ ihandle = *handle;
+-
++
+ if(except_callback_func)
+ {
+ result = globus_error_put(
+@@ -4200,7 +4200,7 @@ globus_io_register_select(
+ _IOSL("Globus IO-XIO does not support use of the except callback")));
+ goto error_notsupported;
+ }
+-
++
+ if(read_callback_func)
+ {
+ result = globus_io_register_read(
+@@ -4215,7 +4215,7 @@ globus_io_register_select(
+ goto error_register;
+ }
+ }
+-
++
+ if(write_callback_func)
+ {
+ result = globus_io_register_write(
+@@ -4232,7 +4232,7 @@ globus_io_register_select(
+ goto error_register;
+ }
+ }
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_register:
+@@ -4246,10 +4246,10 @@ globus_io_get_handle_type(
+ {
+ globus_l_io_handle_t * ihandle;
+ GlobusIOName(globus_io_get_handle_type);
+-
++
+ GlobusLIOCheckHandle(handle, 0);
+ ihandle = *handle;
+-
++
+ if(ihandle->type == GLOBUS_I_IO_FILE_HANDLE)
+ return GLOBUS_IO_HANDLE_TYPE_FILE;
+ else
+@@ -4262,12 +4262,12 @@ globus_io_handle_get_user_pointer(
+ void ** user_pointer)
+ {
+ GlobusIOName(globus_io_handle_get_user_pointer);
+-
++
+ GlobusLIOCheckHandle(handle, 0);
+ GlobusLIOCheckNullParam(user_pointer);
+-
++
+ *user_pointer = (*handle)->user_pointer;
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+@@ -4277,11 +4277,11 @@ globus_io_handle_set_user_pointer(
+ void * user_pointer)
+ {
+ GlobusIOName(globus_io_handle_set_user_pointer);
+-
++
+ GlobusLIOCheckHandle(handle, 0);
+-
++
+ (*handle)->user_pointer = user_pointer;
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+@@ -4291,12 +4291,12 @@ globus_io_handle_get_xio_handle(
+ globus_xio_handle_t * xio_handle)
+ {
+ GlobusIOName(globus_io_handle_get_xio_handle);
+-
++
+ GlobusLIOCheckHandle(handle, 0);
+ GlobusLIOCheckNullParam(xio_handle);
+-
++
+ *xio_handle = (*handle)->xio_handle;
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+@@ -4306,10 +4306,10 @@ globus_io_tcp_get_security_context(
+ gss_ctx_id_t * context)
+ {
+ GlobusIOName(globus_io_tcp_get_security_context);
+-
++
+ GlobusLIOCheckHandle(handle, GLOBUS_I_IO_TCP_HANDLE);
+ GlobusLIOCheckNullParam(context);
+-
++
+ return globus_xio_handle_cntl(
+ (*handle)->xio_handle,
+ globus_l_io_gsi_driver,
+@@ -4323,10 +4323,10 @@ globus_io_tcp_get_delegated_credential(
+ gss_cred_id_t * cred)
+ {
+ GlobusIOName(globus_io_tcp_get_delegated_credential);
+-
++
+ GlobusLIOCheckHandle(handle, GLOBUS_I_IO_TCP_HANDLE);
+ GlobusLIOCheckNullParam(cred);
+-
++
+ return globus_xio_handle_cntl(
+ (*handle)->xio_handle,
+ globus_l_io_gsi_driver,
+@@ -4341,23 +4341,23 @@ globus_io_tcp_set_credential(
+ gss_cred_id_t credential)
+ {
+ GlobusIOName(globus_io_tcp_set_credential);
+-
++
+ GlobusLIOCheckHandle(handle, GLOBUS_I_IO_TCP_HANDLE);
+-
++
+ if ((*handle)->xio_handle)
+ {
+ return globus_xio_handle_cntl(
+- (*handle)->xio_handle,
+- globus_l_io_gsi_driver,
+- GLOBUS_XIO_GSI_SET_CREDENTIAL,
++ (*handle)->xio_handle,
++ globus_l_io_gsi_driver,
++ GLOBUS_XIO_GSI_SET_CREDENTIAL,
+ credential);
+ }
+ else
+ {
+ return globus_xio_attr_cntl(
+- (*handle)->attr->attr,
+- globus_l_io_gsi_driver,
+- GLOBUS_XIO_GSI_SET_CREDENTIAL,
++ (*handle)->attr->attr,
++ globus_l_io_gsi_driver,
++ GLOBUS_XIO_GSI_SET_CREDENTIAL,
+ credential);
+ }
+ }
+@@ -4369,22 +4369,22 @@ globus_io_tcp_get_credential(
+ gss_cred_id_t * credential)
+ {
+ GlobusIOName(globus_io_tcp_get_credential);
+-
++
+ GlobusLIOCheckHandle(handle, GLOBUS_I_IO_TCP_HANDLE);
+ GlobusLIOCheckNullParam(credential);
+-
++
+ return globus_xio_handle_cntl(
+- (*handle)->xio_handle,
+- globus_l_io_gsi_driver,
++ (*handle)->xio_handle,
++ globus_l_io_gsi_driver,
+ GLOBUS_XIO_GSI_GET_CREDENTIAL,
+ credential);
+ }
+
+ static
+-void
++void
+ globus_l_io_init_delegation_cb(
+- globus_result_t result,
+- void * user_arg)
++ globus_result_t result,
++ void * user_arg)
+ {
+ globus_l_io_delegation_cb_arg_t * wrapper;
+ GlobusIOName(globus_l_io_init_delegation_cb);
+@@ -4403,16 +4403,16 @@ globus_l_io_init_delegation_cb(
+ }
+
+ static
+-void
++void
+ globus_l_io_accept_delegation_cb(
+- globus_result_t result,
++ globus_result_t result,
+ gss_cred_id_t delegated_cred,
+ OM_uint32 time_rec,
+- void * user_arg)
++ void * user_arg)
+ {
+ globus_l_io_delegation_cb_arg_t * wrapper;
+ GlobusIOName(globus_l_io_accept_delegation_cb);
+-
++
+ wrapper = (globus_l_io_delegation_cb_arg_t *) user_arg;
+
+ wrapper->callback(wrapper->user_arg,
+@@ -4454,7 +4454,7 @@ globus_io_register_init_delegation(
+ wrapper->handle = handle;
+ wrapper->user_arg = callback_arg;
+ wrapper->callback = callback;
+-
++
+ result = globus_xio_handle_cntl(
+ ihandle->xio_handle,
+ globus_l_io_gsi_driver,
+@@ -4469,7 +4469,7 @@ globus_io_register_init_delegation(
+ {
+ free(wrapper);
+ }
+-
++
+ return result;
+ }
+
+@@ -4482,12 +4482,12 @@ globus_io_init_delegation(
+ OM_uint32 time_req)
+ {
+ globus_result_t result;
+- globus_l_io_handle_t * ihandle;
++ globus_l_io_handle_t * ihandle;
+ GlobusIOName(globus_io_init_delegation);
+-
++
+ GlobusLIOCheckHandle(handle, GLOBUS_I_IO_TCP_HANDLE);
+ ihandle = *handle;
+-
++
+ result = globus_xio_handle_cntl(
+ ihandle->xio_handle,
+ globus_l_io_gsi_driver,
+@@ -4495,8 +4495,8 @@ globus_io_init_delegation(
+ cred_handle,
+ restriction_oids,
+ restriction_buffers,
+- time_req);
+-
++ time_req);
++
+ return result;
+ }
+
+@@ -4513,7 +4513,7 @@ globus_io_register_accept_delegation(
+ globus_l_io_handle_t * ihandle;
+ globus_l_io_delegation_cb_arg_t * wrapper;
+ GlobusIOName(globus_io_register_accept_delegation);
+-
++
+ GlobusLIOCheckNullParam(callback);
+ GlobusLIOCheckHandle(handle, GLOBUS_I_IO_TCP_HANDLE);
+ ihandle = *handle;
+@@ -4536,7 +4536,7 @@ globus_io_register_accept_delegation(
+ restriction_buffers,
+ time_req,
+ globus_l_io_accept_delegation_cb,
+- wrapper);
++ wrapper);
+ if(result != GLOBUS_SUCCESS)
+ {
+ free(wrapper);
+@@ -4555,12 +4555,12 @@ globus_io_accept_delegation(
+ OM_uint32 * time_rec)
+ {
+ globus_result_t result;
+- globus_l_io_handle_t * ihandle;
++ globus_l_io_handle_t * ihandle;
+ GlobusIOName(globus_io_accept_delegation);
+-
++
+ GlobusLIOCheckHandle(handle, GLOBUS_I_IO_TCP_HANDLE);
+ ihandle = *handle;
+-
++
+ result = globus_xio_handle_cntl(
+ ihandle->xio_handle,
+ globus_l_io_gsi_driver,
+@@ -4570,9 +4570,9 @@ globus_io_accept_delegation(
+ restriction_buffers,
+ time_req,
+ time_rec);
+-
++
+ return result;
+-
++
+ }
+
+ globus_result_t
+@@ -4584,7 +4584,7 @@ globus_io_attr_set_secure_authentication_mode(
+ {
+ globus_result_t result = GLOBUS_SUCCESS;
+ GlobusIOName(globus_io_attr_set_secure_authentication_mode);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+ (*attr)->authentication_mode = mode;
+
+@@ -4593,18 +4593,18 @@ globus_io_attr_set_secure_authentication_mode(
+ case GLOBUS_IO_SECURE_AUTHENTICATION_MODE_GSSAPI:
+ case GLOBUS_IO_SECURE_AUTHENTICATION_MODE_MUTUAL:
+ if(credential != GSS_C_NO_CREDENTIAL)
+- {
++ {
+ result = globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
+- GLOBUS_XIO_GSI_SET_CREDENTIAL,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
++ GLOBUS_XIO_GSI_SET_CREDENTIAL,
+ credential);
+ }
+ break;
+ case GLOBUS_IO_SECURE_AUTHENTICATION_MODE_ANONYMOUS:
+ result = globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
+ GLOBUS_XIO_GSI_SET_ANON);
+ break;
+ case GLOBUS_IO_SECURE_AUTHENTICATION_MODE_NONE:
+@@ -4613,7 +4613,7 @@ globus_io_attr_set_secure_authentication_mode(
+ globus_assert(0 && "Unexpected state");
+ break;
+ }
+-
++
+ return result;
+ }
+
+@@ -4625,10 +4625,10 @@ globus_io_attr_get_secure_authentication_mode(
+ gss_cred_id_t * credential)
+ {
+ GlobusIOName(globus_io_attr_get_secure_authentication_mode);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+ GlobusLIOCheckNullParam(mode);
+-
++
+ *mode = (*attr)->authentication_mode;
+ return GLOBUS_SUCCESS;
+ }
+@@ -4645,7 +4645,7 @@ globus_io_attr_set_secure_authorization_mode(
+ OM_uint32 major_status;
+ OM_uint32 minor_status;
+ GlobusIOName(globus_io_attr_set_secure_authorization_mode);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+ (*attr)->authorization_mode = mode;
+
+@@ -4661,9 +4661,9 @@ globus_io_attr_set_secure_authorization_mode(
+ (*attr)->authz_data.identity = GSS_C_NO_NAME;
+ }
+ result = globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
+- GLOBUS_XIO_GSI_SET_AUTHORIZATION_MODE,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
++ GLOBUS_XIO_GSI_SET_AUTHORIZATION_MODE,
+ mode);
+ break;
+ case GLOBUS_IO_SECURE_AUTHORIZATION_MODE_IDENTITY:
+@@ -4672,7 +4672,7 @@ globus_io_attr_set_secure_authorization_mode(
+ {
+ gss_release_name(&minor_status,
+ &(*attr)->authz_data.identity);
+- }
++ }
+
+ major_status = gss_duplicate_name(&minor_status,
+ (*data)->identity,
+@@ -4685,34 +4685,34 @@ globus_io_attr_set_secure_authorization_mode(
+ minor_status);
+ goto error;
+ }
+-
++
+ result = globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
+- GLOBUS_XIO_GSI_SET_AUTHORIZATION_MODE,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
++ GLOBUS_XIO_GSI_SET_AUTHORIZATION_MODE,
+ mode);
+
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error;
+ }
+-
++
+ result = globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
+- GLOBUS_XIO_GSI_SET_TARGET_NAME,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
++ GLOBUS_XIO_GSI_SET_TARGET_NAME,
+ (*attr)->authz_data.identity);
+- break;
++ break;
+ case GLOBUS_IO_SECURE_AUTHORIZATION_MODE_CALLBACK:
+ GlobusLIOCheckNullParam(data);
+- (*attr)->authz_data.callback = (*data)->callback;
+- (*attr)->authz_data.callback_arg = (*data)->callback_arg;
++ (*attr)->authz_data.callback = (*data)->callback;
++ (*attr)->authz_data.callback_arg = (*data)->callback_arg;
+ result = globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
+- GLOBUS_XIO_GSI_SET_AUTHORIZATION_MODE,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
++ GLOBUS_XIO_GSI_SET_AUTHORIZATION_MODE,
+ GLOBUS_IO_SECURE_AUTHORIZATION_MODE_NONE);
+- break;
++ break;
+ }
+
+ error:
+@@ -4731,28 +4731,28 @@ globus_io_attr_get_secure_authorization_mode(
+ OM_uint32 major_status;
+ OM_uint32 minor_status;
+ GlobusIOName(globus_io_attr_get_secure_authorization_mode);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+ GlobusLIOCheckNullParam(data);
+ GlobusLIOCheckNullParam(mode);
+-
++
+ result = GlobusLIOMalloc(*data, globus_l_io_secure_authorization_data_t);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto done;
+ }
+-
++
+ memset(*data, 0, sizeof(globus_l_io_secure_authorization_data_t));
+ *mode = (*attr)->authorization_mode;
+
+ switch((*attr)->authorization_mode)
+ {
+ case GLOBUS_IO_SECURE_AUTHORIZATION_MODE_NONE:
+- break;
++ break;
+ case GLOBUS_IO_SECURE_AUTHORIZATION_MODE_SELF:
+- break;
++ break;
+ case GLOBUS_IO_SECURE_AUTHORIZATION_MODE_HOST:
+- break;
++ break;
+ case GLOBUS_IO_SECURE_AUTHORIZATION_MODE_IDENTITY:
+ major_status = gss_duplicate_name(&minor_status,
+ (*attr)->authz_data.identity,
+@@ -4763,15 +4763,15 @@ globus_io_attr_get_secure_authorization_mode(
+ major_status,
+ minor_status);
+ }
+- break;
++ break;
+ case GLOBUS_IO_SECURE_AUTHORIZATION_MODE_CALLBACK:
+- (*data)->callback = (*attr)->authz_data.callback;
+- (*data)->callback_arg = (*attr)->authz_data.callback_arg;
+- break;
++ (*data)->callback = (*attr)->authz_data.callback;
++ (*data)->callback_arg = (*attr)->authz_data.callback_arg;
++ break;
+ }
+
+ done:
+-
++
+ return result;
+ }
+
+@@ -4781,7 +4781,7 @@ globus_io_attr_set_secure_extension_oids(
+ gss_OID_set extension_oids)
+ {
+ GlobusIOName(globus_io_attr_set_secure_extension_oids);
+- return GLOBUS_SUCCESS;
++ return GLOBUS_SUCCESS;
+ }
+
+ globus_result_t
+@@ -4790,7 +4790,7 @@ globus_io_attr_get_secure_extension_oids(
+ gss_OID_set * extension_oids)
+ {
+ GlobusIOName(globus_io_attr_get_secure_extension_oids);
+- return GLOBUS_SUCCESS;
++ return GLOBUS_SUCCESS;
+ }
+
+ globus_result_t
+@@ -4801,13 +4801,13 @@ globus_io_secure_authorization_data_initialize(
+ GlobusIOName(globus_io_secure_authorization_data_initialize);
+
+ GlobusLIOCheckNullParam(data);
+-
++
+ result = GlobusLIOMalloc(*data, globus_l_io_secure_authorization_data_t);
+ if(result == GLOBUS_SUCCESS)
+ {
+ memset(*data, 0, sizeof(globus_l_io_secure_authorization_data_t));
+ }
+-
++
+ return result;
+ }
+
+@@ -4817,9 +4817,9 @@ globus_io_secure_authorization_data_destroy(
+ data)
+ {
+ GlobusIOName(globus_io_secure_authorization_data_destroy);
+-
++
+ GlobusLIOCheckNullParam(data);
+-
++
+ if((*data)->identity != GSS_C_NO_NAME)
+ {
+ OM_uint32 minor_status;
+@@ -4830,7 +4830,7 @@ globus_io_secure_authorization_data_destroy(
+
+ globus_free(*data);
+ *data = GLOBUS_NULL;
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+@@ -4849,7 +4849,7 @@ globus_io_secure_authorization_data_set_identity(
+
+ GlobusLIOCheckNullParam(data);
+ GlobusLIOCheckNullParam(identity);
+-
++
+ if(!strncmp("GSI-NO-TARGET", identity, 13))
+ {
+ (*data)->identity = GSS_C_NO_NAME;
+@@ -4858,24 +4858,24 @@ globus_io_secure_authorization_data_set_identity(
+ {
+ name_buffer.value = identity;
+ name_buffer.length = strlen(identity);
+-
+- /*
++
++ /*
+ * A GSS_C_NT_HOSTBASED_SERVICE is of the form service@FQDN
+- * At least the Globus gssapi, and the Kerberos gssapi
+- * use the same form. We will check for
++ * At least the Globus gssapi, and the Kerberos gssapi
++ * use the same form. We will check for
+ * two special forms here: host@FQDN and ftp@FQDN
+ */
+
+- if (strchr(identity,'@') &&
++ if (strchr(identity,'@') &&
+ !strstr(identity,"CN="))
+- {
++ {
+ name_type = GSS_C_NT_HOSTBASED_SERVICE;
+ }
+ else if(!strncmp("<anonymous>",identity, 11))
+ {
+ name_type = GSS_C_NT_ANONYMOUS;
+ }
+-
++
+ major_status = gss_import_name(&minor_status,
+ &name_buffer,
+ name_type,
+@@ -4887,7 +4887,7 @@ globus_io_secure_authorization_data_set_identity(
+ minor_status);
+ }
+ }
+-
++
+ return result;
+ }
+
+@@ -4899,16 +4899,16 @@ globus_io_secure_authorization_data_get_identity(
+ {
+ globus_result_t result = GLOBUS_SUCCESS;
+ GlobusIOName(globus_io_secure_authorization_data_get_identity);
+-
++
+ GlobusLIOCheckNullParam(data);
+ GlobusLIOCheckNullParam(identity);
+-
++
+ if((*data)->identity != GSS_C_NO_NAME)
+- {
++ {
+ OM_uint32 major_status;
+ OM_uint32 minor_status;
+ gss_buffer_desc name_buffer;
+-
++
+ major_status = gss_display_name(&minor_status,
+ (*data)->identity,
+ &name_buffer,
+@@ -4922,7 +4922,7 @@ globus_io_secure_authorization_data_get_identity(
+ }
+
+ /* could probably just realloc the buffer contents */
+-
++
+ result = GlobusLIOMallocSize(*identity, name_buffer.length + 1);
+
+ if(result != GLOBUS_SUCCESS)
+@@ -4945,7 +4945,7 @@ globus_io_secure_authorization_data_get_identity(
+ }
+
+ done:
+-
++
+ return result;
+ }
+
+@@ -4958,12 +4958,12 @@ globus_io_secure_authorization_data_set_callback(
+ void * callback_arg)
+ {
+ GlobusIOName(globus_io_secure_authorization_data_set_callback);
+-
++
+ GlobusLIOCheckNullParam(data);
+-
++
+ (*data)->callback = callback;
+ (*data)->callback_arg = callback_arg;
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+@@ -4976,14 +4976,14 @@ globus_io_secure_authorization_data_get_callback(
+ void ** callback_arg)
+ {
+ GlobusIOName(globus_io_secure_authorization_data_get_callback);
+-
++
+ GlobusLIOCheckNullParam(data);
+ GlobusLIOCheckNullParam(callback);
+ GlobusLIOCheckNullParam(callback_arg);
+-
++
+ *callback = (*data)->callback;
+ *callback_arg = (*data)->callback_arg;
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+@@ -4994,18 +4994,18 @@ globus_io_attr_set_secure_channel_mode(
+ {
+ globus_result_t result = GLOBUS_SUCCESS;
+ globus_xio_gsi_protection_level_t protection_level;
+-
++
+ GlobusIOName(globus_io_attr_set_secure_channel_mode);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ (*attr)->channel_mode = mode;
+ switch(mode)
+ {
+ case GLOBUS_IO_SECURE_CHANNEL_MODE_CLEAR:
+ result = globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
+ GLOBUS_XIO_GSI_SET_SSL_COMPATIBLE,
+ GLOBUS_FALSE);
+ if(result != GLOBUS_SUCCESS)
+@@ -5014,8 +5014,8 @@ globus_io_attr_set_secure_channel_mode(
+ }
+
+ result = globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
+ GLOBUS_XIO_GSI_SET_PROTECTION_LEVEL,
+ GLOBUS_XIO_GSI_PROTECTION_LEVEL_NONE);
+ break;
+@@ -5032,18 +5032,18 @@ globus_io_attr_set_secure_channel_mode(
+
+ case GLOBUS_IO_SECURE_CHANNEL_MODE_GSI_WRAP:
+ result = globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
+ GLOBUS_XIO_GSI_SET_WRAP_MODE,
+ GLOBUS_TRUE);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error;
+ }
+-
++
+ result = globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
+ GLOBUS_XIO_GSI_GET_PROTECTION_LEVEL,
+ &protection_level);
+
+@@ -5053,10 +5053,10 @@ globus_io_attr_set_secure_channel_mode(
+ }
+
+ if(protection_level == GLOBUS_XIO_GSI_PROTECTION_LEVEL_NONE)
+- {
++ {
+ result = globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
+ GLOBUS_XIO_GSI_SET_PROTECTION_LEVEL,
+ GLOBUS_XIO_GSI_PROTECTION_LEVEL_INTEGRITY);
+ }
+@@ -5064,18 +5064,18 @@ globus_io_attr_set_secure_channel_mode(
+
+ case GLOBUS_IO_SECURE_CHANNEL_MODE_SSL_WRAP:
+ result = globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
+ GLOBUS_XIO_GSI_SET_SSL_COMPATIBLE,
+ GLOBUS_TRUE);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error;
+ }
+-
++
+ result = globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
+ GLOBUS_XIO_GSI_GET_PROTECTION_LEVEL,
+ &protection_level);
+
+@@ -5085,16 +5085,16 @@ globus_io_attr_set_secure_channel_mode(
+ }
+
+ if(protection_level == GLOBUS_XIO_GSI_PROTECTION_LEVEL_NONE)
+- {
++ {
+ result = globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
+ GLOBUS_XIO_GSI_SET_PROTECTION_LEVEL,
+ GLOBUS_XIO_GSI_PROTECTION_LEVEL_INTEGRITY);
+ }
+ break;
+ }
+-
++
+ error:
+ return result;
+ }
+@@ -5105,10 +5105,10 @@ globus_io_attr_get_secure_channel_mode(
+ globus_io_secure_channel_mode_t * mode)
+ {
+ GlobusIOName(globus_io_attr_get_secure_channel_mode);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+ GlobusLIOCheckNullParam(mode);
+-
++
+ *mode = (*attr)->channel_mode;
+ return GLOBUS_SUCCESS;
+ }
+@@ -5119,12 +5119,12 @@ globus_io_attr_set_secure_protection_mode(
+ globus_io_secure_protection_mode_t mode)
+ {
+ GlobusIOName(globus_io_attr_set_secure_protection_mode);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
+ GLOBUS_XIO_GSI_SET_PROTECTION_LEVEL,
+ mode);
+ }
+@@ -5135,13 +5135,13 @@ globus_io_attr_get_secure_protection_mode(
+ globus_io_secure_protection_mode_t *mode)
+ {
+ GlobusIOName(globus_io_attr_get_secure_protection_mode);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+ GlobusLIOCheckNullParam(mode);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
+ GLOBUS_XIO_GSI_GET_PROTECTION_LEVEL,
+ mode);
+ }
+@@ -5152,12 +5152,12 @@ globus_io_attr_set_secure_delegation_mode(
+ globus_io_secure_delegation_mode_t mode)
+ {
+ GlobusIOName(globus_io_attr_set_secure_delegation_mode);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
+ GLOBUS_XIO_GSI_SET_DELEGATION_MODE,
+ mode);
+ }
+@@ -5170,13 +5170,13 @@ globus_io_attr_get_secure_delegation_mode(
+ mode)
+ {
+ GlobusIOName(globus_io_attr_set_secure_delegation_mode);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+ GlobusLIOCheckNullParam(mode);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
+ GLOBUS_XIO_GSI_GET_DELEGATION_MODE,
+ mode);
+ }
+@@ -5187,12 +5187,12 @@ globus_io_attr_set_secure_proxy_mode(
+ globus_io_secure_proxy_mode_t mode)
+ {
+ GlobusIOName(globus_io_attr_set_secure_proxy_mode);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
+ GLOBUS_XIO_GSI_SET_PROXY_MODE,
+ mode);
+ }
+@@ -5203,13 +5203,13 @@ globus_io_attr_get_secure_proxy_mode(
+ globus_io_secure_proxy_mode_t * mode)
+ {
+ GlobusIOName(globus_io_attr_get_secure_proxy_mode);
+-
++
+ GlobusLIOCheckAttr(attr, GLOBUS_I_IO_TCP_ATTR);
+ GlobusLIOCheckNullParam(mode);
+-
++
+ return globus_xio_attr_cntl(
+- (*attr)->attr,
+- globus_l_io_gsi_driver,
++ (*attr)->attr,
++ globus_l_io_gsi_driver,
+ GLOBUS_XIO_GSI_GET_PROXY_MODE,
+ mode);
+ }
+--
+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..666aaeb
--- /dev/null
+++ b/0002-Fix-compiler-and-doxygen-warnings.patch
@@ -0,0 +1,41 @@
+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
+
+---
+ io/compat/globus_io_xio_compat.c | 5 -----
+ 1 file changed, 5 deletions(-)
+
+diff --git a/io/compat/globus_io_xio_compat.c b/io/compat/globus_io_xio_compat.c
+index bac433a00..5cda08232 100644
+--- a/io/compat/globus_io_xio_compat.c
++++ b/io/compat/globus_io_xio_compat.c
+@@ -3759,11 +3759,8 @@ void
+ globus_l_io_server_close_kickout(
+ void * user_arg)
+ {
+- globus_l_io_bounce_t * bounce_info;
+ GlobusIOName(globus_l_io_server_close_kickout);
+
+- bounce_info = (globus_l_io_bounce_t *) user_arg;
+-
+ globus_l_io_server_close_cb(GLOBUS_NULL, user_arg);
+ }
+
+@@ -4180,12 +4177,10 @@ globus_io_register_select(
+ globus_io_callback_t except_callback_func,
+ void * except_callback_arg)
+ {
+- globus_l_io_handle_t * ihandle;
+ globus_result_t result;
+ GlobusIOName(globus_io_register_select);
+
+ GlobusLIOCheckHandle(handle, 0);
+- ihandle = *handle;
+
+ if(except_callback_func)
+ {
+--
+2.54.0
+
diff --git a/globus-io.spec b/globus-io.spec
index bb01382..bc2166e 100644
--- a/globus-io.spec
+++ b/globus-io.spec
@@ -1,13 +1,15 @@
Name: globus-io
%global _name %(tr - _ <<< %{name})
Version: 12.4
-Release: 10%{?dist}
+Release: 11%{?dist}
Summary: Grid Community Toolkit - uniform I/O interface
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
@@ -54,6 +56,8 @@ uniform I/O interface Development Files
%prep
%setup -q -n %{_name}-%{version}
+%patch -P0 -p3
+%patch -P1 -p3
%build
# Reduce overlinking
@@ -98,6 +102,9 @@ GLOBUS_HOSTNAME=localhost %make_build check
%{_libdir}/pkgconfig/%{name}.pc
%changelog
+* Sun Jun 14 2026 Mattias Ellert <mattias.ellert@physics.uu.se> - 12.4-11
+- Fix compiler warnings
+
* Fri Jan 16 2026 Fedora Release Engineering <releng@fedoraproject.org> - 12.4-10
- Rebuilt for https://fedoraproject.org/wiki/Fedora_44_Mass_Rebuild
reply other threads:[~2026-06-14 8:54 UTC|newest]
Thread overview: [no followups] expand[flat|nested] mbox.gz Atom feed
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=178142724962.1.8591267008299697646.rpms-globus-io-91702c86c60a@fedoraproject.org \
--to=mattias.ellert@physics.uu.se \
--cc=git-commits@fedoraproject.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox