public inbox for git-commits@fedoraproject.org
help / color / mirror / Atom feed
* [rpms/globus-xio] rawhide: Fix compiler and doxygen warnings
@ 2026-06-14 8:55 Mattias Ellert
0 siblings, 0 replies; only message in thread
From: Mattias Ellert @ 2026-06-14 8:55 UTC (permalink / raw)
To: git-commits
A new commit has been pushed.
Repo : rpms/globus-xio
Branch : rawhide
Commit : 3ade60289d979a7445ab1a328b31a4d63435fe58
Author : Mattias Ellert <mattias.ellert@physics.uu.se>
Date : 2026-06-14T10:39:13+02:00
Stats : +5695/-1 in 3 file(s)
URL : https://src.fedoraproject.org/rpms/globus-xio/c/3ade60289d979a7445ab1a328b31a4d63435fe58?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..3b1e25c
--- /dev/null
+++ b/0001-Untabify-and-remove-trailing-white-space.patch
@@ -0,0 +1,4910 @@
+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
+
+---
+ xio/src/builtins/http/globus_i_xio_http.h | 16 +-
+ xio/src/builtins/http/globus_xio_http.c | 12 +-
+ xio/src/builtins/http/globus_xio_http_attr.c | 2 +-
+ .../builtins/http/globus_xio_http_client.c | 34 +-
+ .../builtins/http/globus_xio_http_handle.c | 6 +-
+ .../builtins/http/globus_xio_http_header.c | 2 +-
+ .../http/globus_xio_http_header_info.c | 4 +-
+ .../builtins/http/globus_xio_http_server.c | 14 +-
+ .../builtins/http/globus_xio_http_target.c | 2 +-
+ .../builtins/http/globus_xio_http_transform.c | 66 +-
+ .../mode_e/globus_xio_mode_e_driver.c | 422 +++++------
+ xio/src/globus_xio_driver.c | 198 ++---
+ xio/src/globus_xio_system_select.c | 270 +++----
+ xio/src/test/drivers/globus_xio_smtp.c | 12 +-
+ xio/src/test/globus_utp_main.c | 690 +++++++++---------
+ 15 files changed, 875 insertions(+), 875 deletions(-)
+
+diff --git a/xio/src/builtins/http/globus_i_xio_http.h b/xio/src/builtins/http/globus_i_xio_http.h
+index b4e396819..155dfde34 100644
+--- a/xio/src/builtins/http/globus_i_xio_http.h
++++ b/xio/src/builtins/http/globus_i_xio_http.h
+@@ -102,7 +102,7 @@ typedef struct
+ /**
+ * buffer to hold the chunk size line
+ */
+- globus_byte_t chunk_size_buffer[64];
++ globus_byte_t chunk_size_buffer[64];
+ }
+ globus_i_xio_http_operation_info_t;
+
+@@ -335,12 +335,12 @@ typedef struct globus_i_xio_http_handle_s
+ * contain unparsed data
+ */
+ globus_size_t read_buffer_valid;
+-
++
+ /**
+ * Operation used for closing, when an error occurs at open time.
+ */
+ globus_xio_operation_t close_operation;
+-
++
+ /**
+ * Remaining-to-be-read chunk.
+ */
+@@ -372,7 +372,7 @@ typedef struct globus_i_xio_http_handle_s
+ */
+ globus_xio_operation_t response_read_operation;
+
+-
++
+ globus_i_xio_http_operation_info_t read_operation;
+ globus_i_xio_http_operation_info_t write_operation;
+
+@@ -402,7 +402,7 @@ typedef struct globus_i_xio_http_handle_s
+ * drops us
+ */
+ globus_bool_t reopen_in_progress;
+-
++
+ /* error from internal response read, usually with a broken persistent
+ * connection
+ */
+@@ -662,7 +662,7 @@ globus_result_t
+ globus_i_xio_http_server_read_next_request(
+ globus_i_xio_http_handle_t * http_handle);
+
+-/* globus_xio_http_target.c */
++/* globus_xio_http_target.c */
+ extern
+ globus_result_t
+ globus_i_xio_http_target_init(
+@@ -711,7 +711,7 @@ globus_result_t
+ globus_l_xio_http_client_parse_response(
+ globus_i_xio_http_handle_t * http_handle,
+ globus_bool_t * done);
+-
++
+ void
+ globus_l_xio_http_client_read_response_callback(
+ globus_xio_operation_t op,
+@@ -748,7 +748,7 @@ globus_i_xio_http_close(
+ void * attr,
+ globus_xio_operation_t op);
+
+-extern
++extern
+ globus_result_t
+ globus_i_xio_http_close_internal(
+ globus_i_xio_http_handle_t * http_handle);
+diff --git a/xio/src/builtins/http/globus_xio_http.c b/xio/src/builtins/http/globus_xio_http.c
+index 1b7d71a24..c3535e024 100644
+--- a/xio/src/builtins/http/globus_xio_http.c
++++ b/xio/src/builtins/http/globus_xio_http.c
+@@ -71,7 +71,7 @@ globus_l_xio_http_init(
+ globus_i_xio_http_read,
+ globus_i_xio_http_write,
+ globus_i_xio_http_handle_cntl,
+- NULL);
++ NULL);
+
+ globus_xio_driver_set_server(
+ driver,
+@@ -280,7 +280,7 @@ globus_i_xio_http_find_eol(
+ char * result;
+ globus_size_t skip = 0;
+
+- while (((skip + 1) < blob_length) &&
++ while (((skip + 1) < blob_length) &&
+ (result = memchr(blob + skip, '\r', blob_length-skip)) != NULL)
+ {
+ if (result+1 == (blob + skip + blob_length))
+@@ -291,7 +291,7 @@ globus_i_xio_http_find_eol(
+ {
+ return result;
+ }
+- else
++ else
+ {
+ skip += (result - blob + 1);
+ }
+@@ -368,7 +368,7 @@ globus_i_xio_http_clean_read_buffer(
+ + http_handle->read_buffer_offset
+ + http_handle->read_buffer_valid;
+
+- http_handle->read_iovec.iov_len =
++ http_handle->read_iovec.iov_len =
+ http_handle->read_buffer.iov_len
+ - http_handle->read_buffer_offset
+ - http_handle->read_buffer_valid;
+@@ -409,9 +409,9 @@ globus_l_xio_http_deactivate(void)
+ {
+ globus_i_xio_http_handle_t * http_handle;
+ globus_result_t result;
+-
++
+ GlobusXIOUnRegisterDriver(http);
+-
++
+ globus_mutex_lock(&globus_i_xio_http_cached_handle_mutex);
+ while (!globus_list_empty(globus_i_xio_http_cached_handles))
+ {
+diff --git a/xio/src/builtins/http/globus_xio_http_attr.c b/xio/src/builtins/http/globus_xio_http_attr.c
+index e58a8db75..2d3d3d7bd 100644
+--- a/xio/src/builtins/http/globus_xio_http_attr.c
++++ b/xio/src/builtins/http/globus_xio_http_attr.c
+@@ -31,7 +31,7 @@
+ * driver via globus_xio_attr_init().
+ *
+ * @param out_attr
+- * Pointer value will be set to point to a
++ * Pointer value will be set to point to a
+ * newly allocated and initilized #globus_i_xio_http_attr_t
+ * structure.
+ *
+diff --git a/xio/src/builtins/http/globus_xio_http_client.c b/xio/src/builtins/http/globus_xio_http_client.c
+index da6fa218b..75a018172 100644
+--- a/xio/src/builtins/http/globus_xio_http_client.c
++++ b/xio/src/builtins/http/globus_xio_http_client.c
+@@ -47,13 +47,13 @@ globus_l_xio_http_cleanup_cancel(
+ * If this function succeeds, the open will remain unfinished until that
+ * write completes. If an error happens, this function will close the handle
+ * internally and call globus_xio_driver_finished_open() before returning.
+- *
++ *
+ * @param op
+ * operation associated with the open call.
+ * @param result
+ * Lower-level protocol result from open.
+ * @param user_arg
+- * A void pointer pointing to a #globus_i_xio_http_driver_t
++ * A void pointer pointing to a #globus_i_xio_http_driver_t
+ *
+ * @return void
+ */
+@@ -291,7 +291,7 @@ globus_i_xio_http_client_write_request(
+ strlen(http_handle->target_info.host),
+ free_iovecs_exit);
+
+- if (http_handle->target_info.port != 0 &&
++ if (http_handle->target_info.port != 0 &&
+ http_handle->target_info.port != 80)
+ {
+ char port_buffer[7];
+@@ -316,7 +316,7 @@ globus_i_xio_http_client_write_request(
+ &http_handle->request_info.headers))
+ {
+ if ((http_handle->request_info.http_version ==
+- GLOBUS_XIO_HTTP_VERSION_1_0) ||
++ GLOBUS_XIO_HTTP_VERSION_1_0) ||
+ ((http_handle->request_info.headers.transfer_encoding ==
+ GLOBUS_XIO_HTTP_TRANSFER_ENCODING_IDENTITY) &&
+ GLOBUS_I_XIO_HTTP_HEADER_IS_CONTENT_LENGTH_SET(
+@@ -339,7 +339,7 @@ globus_i_xio_http_client_write_request(
+ size_buffer = globus_common_create_string(
+ "%"GLOBUS_OFF_T_FORMAT"\r\n",
+ http_handle->request_info.headers.content_length);
+-
++
+ if (size_buffer == NULL)
+ {
+ result = GlobusXIOErrorMemory("iovec.iov_base");
+@@ -457,7 +457,7 @@ error_exit:
+ /* globus_i_xio_http_client_write_request() */
+
+ /**
+- * Request Written Callback
++ * Request Written Callback
+ * @ingroup globus_i_xio_http_write_request_callback
+ *
+ * Called when the response has been completely written by the transport.
+@@ -694,7 +694,7 @@ globus_l_xio_http_client_read_response_callback(
+ response_error = globus_error_get(result);
+
+ http_handle->response_info.status_code = 500;
+- http_handle->response_info.reason_phrase =
++ http_handle->response_info.reason_phrase =
+ globus_error_print_friendly(response_error);
+
+ if (http_handle->write_operation.operation != NULL)
+@@ -716,7 +716,7 @@ globus_l_xio_http_client_read_response_callback(
+ http_handle->pending_error = globus_object_copy(response_error);
+ http_handle->parse_state = GLOBUS_XIO_HTTP_EOF;
+ http_handle->send_state = GLOBUS_XIO_HTTP_EOF;
+-
++
+ /* Set metadata on this read to contain the response info */
+ descriptor = globus_xio_operation_get_data_descriptor(op, GLOBUS_TRUE);
+ if (descriptor != NULL)
+@@ -726,7 +726,7 @@ globus_l_xio_http_client_read_response_callback(
+ &descriptor->response,
+ &http_handle->response_info);
+ }
+-
++
+ /* don't go to error exit yet because we may need to clean up
+ * the cancel info
+ */
+@@ -823,13 +823,13 @@ globus_l_xio_http_client_read_response_callback(
+ }
+ }
+
+- if(http_handle->response_info.status_code > 199 ||
++ if(http_handle->response_info.status_code > 199 ||
+ http_handle->response_info.status_code < 100)
+ {
+ globus_xio_driver_operation_destroy(http_handle->response_read_operation);
+ http_handle->response_read_operation = NULL;
+ }
+-
++
+ globus_mutex_unlock(&http_handle->mutex);
+
+ if (finish_read)
+@@ -938,7 +938,7 @@ error_exit:
+ * @ingroup globus_i_xio_http_client
+ *
+ * Parses the response line and then uses globus_i_xio_http_header_parse() to
+- * parse the header block. If the entire response header section is read,
++ * parse the header block. If the entire response header section is read,
+ * the boolean pointed to by @a done will be modified to be GLOBUS_TRUE.
+ *
+ * Called with mutex locked.
+@@ -951,7 +951,7 @@ error_exit:
+ * globus_i_xio_http_header_parse().
+ * @retval GLOBUS_SUCCESS
+ * No parsing errors occurred while parsing the status line or headers.
+- * Parsing may still be incomplete, depending on the final value of
++ * Parsing may still be incomplete, depending on the final value of
+ * @a done.
+ * @retval <driver>::GLOBUS_XIO_HTTP_ERROR_PARSE
+ * Parse error reading the HTTP Status line
+@@ -1005,7 +1005,7 @@ globus_l_xio_http_client_parse_response(
+ goto error_exit;
+ }
+
+- http_handle->response_info.http_version =
++ http_handle->response_info.http_version =
+ globus_i_xio_http_guess_version(http_major, http_minor);
+
+ current_offset += parsed;
+@@ -1023,7 +1023,7 @@ globus_l_xio_http_client_parse_response(
+
+ goto error_exit;
+ }
+-
++
+ current_offset += parsed;
+
+ /* Reason Phrase */
+@@ -1054,7 +1054,7 @@ globus_l_xio_http_client_parse_response(
+ {
+ http_handle->parse_state = GLOBUS_XIO_HTTP_STATUS_LINE;
+ }
+-
++
+ return result;
+
+ error_exit:
+@@ -1120,7 +1120,7 @@ globus_l_xio_http_cleanup_cancel(
+ else
+ {
+ /* Cancel callback occurred in another thread. That thread will
+- * try to cancel this operation. We are obliged to free the
++ * try to cancel this operation. We are obliged to free the
+ * cancel info.
+ */
+
+diff --git a/xio/src/builtins/http/globus_xio_http_handle.c b/xio/src/builtins/http/globus_xio_http_handle.c
+index 1111ad278..104cee0db 100644
+--- a/xio/src/builtins/http/globus_xio_http_handle.c
++++ b/xio/src/builtins/http/globus_xio_http_handle.c
+@@ -282,7 +282,7 @@ globus_i_xio_http_handle_destroy(
+ * @retval GLOBUS_XIO_ERROR_MEMORY
+ * The command failed due to memory constraints.
+ * @retval GLOBUS_XIO_ERROR_PARAMETER
+- * Invalid @a cmd parameter or invlaid value of cmd-specific parameters
++ * Invalid @a cmd parameter or invlaid value of cmd-specific parameters
+ * in @a ap
+ */
+ globus_result_t
+@@ -448,7 +448,7 @@ globus_i_xio_http_set_end_of_entity(
+ globus_result_t result = GLOBUS_SUCCESS;
+ globus_i_xio_http_header_info_t * headers;
+ static globus_xio_iovec_t end_of_body_iovec = {
+- .iov_base = "0\r\n\r\n",
++ .iov_base = "0\r\n\r\n",
+ .iov_len = 5
+ };
+ GlobusXIOName(globus_i_xio_http_set_end_of_entity);
+@@ -467,7 +467,7 @@ globus_i_xio_http_set_end_of_entity(
+ {
+ headers = &http_handle->response_info.headers;
+ }
+-
++
+ if (http_handle->send_state == GLOBUS_XIO_HTTP_STATUS_LINE)
+ {
+ /* To send an empty response from server */
+diff --git a/xio/src/builtins/http/globus_xio_http_header.c b/xio/src/builtins/http/globus_xio_http_header.c
+index f5819e783..d4c687a65 100644
+--- a/xio/src/builtins/http/globus_xio_http_header.c
++++ b/xio/src/builtins/http/globus_xio_http_header.c
+@@ -264,7 +264,7 @@ globus_i_xio_http_header_parse(
+ {
+ http_handle->parse_state = GLOBUS_XIO_HTTP_CHUNK_LINE;
+ }
+- else if ((http_handle->target_info.is_client &&
++ else if ((http_handle->target_info.is_client &&
+ http_handle->response_info.http_version
+ == GLOBUS_XIO_HTTP_VERSION_1_0) ||
+ GLOBUS_I_XIO_HTTP_HEADER_IS_CONTENT_LENGTH_SET(headers))
+diff --git a/xio/src/builtins/http/globus_xio_http_header_info.c b/xio/src/builtins/http/globus_xio_http_header_info.c
+index 64ca01e97..75367887b 100644
+--- a/xio/src/builtins/http/globus_xio_http_header_info.c
++++ b/xio/src/builtins/http/globus_xio_http_header_info.c
+@@ -142,7 +142,7 @@ error_exit:
+ * Adds a new header to a header info structure, or updates the value of an
+ * existing header. Copies of the name and value will be stored in a
+ * #globus_xio_http_header_t in a hashtable in the header info structure.
+- *
++ *
+ * @param headers
+ * Pointer to the header info structure.
+ * @param header_name
+@@ -229,7 +229,7 @@ globus_i_xio_http_header_info_set_header(
+ {
+ store = GLOBUS_TRUE;
+ }
+-
++
+ if(store)
+ {
+ /*
+diff --git a/xio/src/builtins/http/globus_xio_http_server.c b/xio/src/builtins/http/globus_xio_http_server.c
+index 99736b3b5..5d3ad0ab7 100644
+--- a/xio/src/builtins/http/globus_xio_http_server.c
++++ b/xio/src/builtins/http/globus_xio_http_server.c
+@@ -48,7 +48,7 @@ globus_l_xio_http_server_write_response_callback(
+ * Accept an HTTP request
+ * @ingroup globus_i_xio_http_server
+ *
+- * Passes the request to the transport driver. In the callback,
++ * Passes the request to the transport driver. In the callback,
+ * the request target information will be generated.
+ *
+ * @param driver_server
+@@ -103,7 +103,7 @@ globus_l_xio_http_accept_callback(
+ {
+ globus_i_xio_http_target_t * target_info = NULL;
+ GlobusXIOName(globus_l_xio_http_accept_callback);
+-
++
+ if (result == GLOBUS_SUCCESS)
+ {
+ target_info = globus_i_xio_http_target_new();
+@@ -194,7 +194,7 @@ globus_i_xio_http_server_open_callback(
+ *
+ * @retval GLOBUS_SUCCESS
+ * Response was passed to the transport for writing. If this was generated
+- * by a user writing data, then the write will occur after the
++ * by a user writing data, then the write will occur after the
+ * globus_l_xio_http_server_write_response_callback() has been called.
+ * @retval GLOBUS_XIO_ERROR_MEMORY
+ * Unable to compose the response due to memory constraints.
+@@ -299,7 +299,7 @@ globus_i_xio_http_server_write_response(
+ GLOBUS_I_XIO_HTTP_HEADER_IS_CONTENT_LENGTH_SET(
+ &http_handle->response_info.headers)))
+ {
+- http_handle->response_info.headers.flags |=
++ http_handle->response_info.headers.flags |=
+ GLOBUS_I_XIO_HTTP_HEADER_CONNECTION_CLOSE;
+
+ GLOBUS_XIO_HTTP_COPY_BLOB(&iovecs,
+@@ -683,7 +683,7 @@ globus_l_xio_http_server_parse_request(
+ globus_assert(rc == 1);
+
+ current_offset += parsed;
+-
++
+ rc = sscanf(current_offset, "%*s %n", &parsed);
+ if (rc < 0)
+ {
+@@ -809,7 +809,7 @@ globus_i_xio_http_server_read_request_callback(
+ if (descriptor == NULL)
+ {
+ result = GlobusXIOErrorMemory("descriptor");
+-
++
+ goto error_exit;
+ }
+ globus_i_xio_http_request_destroy(&descriptor->request);
+@@ -848,7 +848,7 @@ globus_i_xio_http_server_read_request_callback(
+ http_handle->read_operation.nbytes = 0;
+
+ globus_mutex_unlock(&http_handle->mutex);
+-
++
+ globus_xio_driver_finished_read(op, result, nbytes);
+
+ return;
+diff --git a/xio/src/builtins/http/globus_xio_http_target.c b/xio/src/builtins/http/globus_xio_http_target.c
+index 58732ae78..6e8d22f34 100644
+--- a/xio/src/builtins/http/globus_xio_http_target.c
++++ b/xio/src/builtins/http/globus_xio_http_target.c
+@@ -108,7 +108,7 @@ globus_i_xio_http_target_init(
+ else
+ {
+ res = GlobusXIOErrorParameter("port");
+-
++
+ goto free_target_exit;
+ }
+ }
+diff --git a/xio/src/builtins/http/globus_xio_http_transform.c b/xio/src/builtins/http/globus_xio_http_transform.c
+index 6a31a3e90..6a4556d23 100644
+--- a/xio/src/builtins/http/globus_xio_http_transform.c
++++ b/xio/src/builtins/http/globus_xio_http_transform.c
+@@ -96,7 +96,7 @@ globus_l_xio_http_read_timeout_callback(
+
+ /**
+ * Open an HTTP URI
+- * @ingroup globus_i_xio_http_transform
++ * @ingroup globus_i_xio_http_transform
+ *
+ * Opens a new connection to handle an HTTP request. Allocates a handle
+ * and then passes the open on to the transport. In the callback called
+@@ -131,7 +131,7 @@ globus_i_xio_http_open(
+ globus_i_xio_http_target_t * target = NULL;
+ globus_i_xio_http_handle_t * http_handle;
+ GlobusXIOName(globus_i_xio_http_open);
+-
++
+ if(link)
+ {
+ target = (globus_i_xio_http_target_t *) link;
+@@ -144,7 +144,7 @@ globus_i_xio_http_open(
+ goto error;
+ }
+ }
+-
++
+ http_handle = globus_l_xio_http_find_cached_handle(target, attr);
+
+ if (http_handle != NULL)
+@@ -155,7 +155,7 @@ globus_i_xio_http_open(
+ {
+ result = globus_l_xio_http_open(contact_info, target, attr, op);
+ }
+-
++
+ if(!link && target)
+ {
+ globus_i_xio_http_target_destroy(target);
+@@ -279,11 +279,11 @@ globus_l_xio_http_open(
+ open_callback = globus_i_xio_http_server_open_callback;
+ http_handle->send_state = GLOBUS_XIO_HTTP_STATUS_LINE;
+ }
+-
++
+ memcpy(&new_contact_info, contact_info, sizeof(new_contact_info));
+ snprintf(port_buf, sizeof(port_buf), "%hu", http_handle->target_info.port);
+ new_contact_info.port = port_buf;
+-
++
+ http_handle->handle = globus_xio_operation_get_driver_handle(op);
+
+ result = globus_xio_driver_pass_open(
+@@ -377,7 +377,7 @@ globus_l_xio_http_find_cached_handle(
+ * Operation associated with the read.
+ *
+ * @return
+- * This function returns GLOBUS_SUCCESS,
++ * This function returns GLOBUS_SUCCESS,
+ * GLOBUS_XIO_ERROR_ALREADY_REGISTERED, and GLOBUS_XIO_ERROR_EOF
+ * errors directly.
+ *
+@@ -425,7 +425,7 @@ globus_i_xio_http_read(
+ globus_object_copy(http_handle->pending_error));
+ goto error_exit;
+ }
+-
++
+ if (http_handle->read_operation.operation != NULL)
+ {
+ /* Only one read in progress per handle, sorry */
+@@ -447,7 +447,7 @@ globus_i_xio_http_read(
+
+ for (i = 0; i < iovec_count; i++)
+ {
+- http_handle->read_operation.iov[i].iov_base =
++ http_handle->read_operation.iov[i].iov_base =
+ iovec[i].iov_base;
+ http_handle->read_operation.iov[i].iov_len =
+ iovec[i].iov_len;
+@@ -475,7 +475,7 @@ globus_i_xio_http_read(
+ }
+
+ http_handle->cancellation->user_read_op = op;
+- http_handle->cancellation->internal_op =
++ http_handle->cancellation->internal_op =
+ http_handle->response_read_operation;
+ http_handle->cancellation->http_handle = http_handle;
+ http_handle->cancellation->driver_handle =
+@@ -523,7 +523,7 @@ globus_i_xio_http_read(
+ if (http_handle->read_buffer.iov_base == NULL)
+ {
+ result = GlobusXIOErrorMemory("read_buffer");
+-
++
+ goto error_exit;
+ }
+ }
+@@ -537,7 +537,7 @@ globus_i_xio_http_read(
+ }
+ http_handle->parse_state = GLOBUS_XIO_HTTP_REQUEST_LINE;
+ }
+-
++
+ result = globus_xio_driver_pass_read(
+ op,
+ &http_handle->read_buffer,
+@@ -578,7 +578,7 @@ globus_i_xio_http_read(
+ }
+ /*
+ * Either we've read enough, hit end of chunk, no entity was present,
+- * or pass to transport failed. Call finished_read
++ * or pass to transport failed. Call finished_read
+ */
+ op = http_handle->read_operation.operation;
+
+@@ -645,7 +645,7 @@ error_exit:
+ * @param registered_again
+ * Set to GLOBUS_TRUE by this function if the read operation was passed
+ * down again as a result of a partial read of data.
+- *
++ *
+ * @return void
+ */
+ globus_result_t
+@@ -672,10 +672,10 @@ globus_i_xio_http_parse_residue(
+ headers = &http_handle->request_info.headers;
+ }
+
+- if (http_handle->read_operation.iovcnt == 0 ||
++ if (http_handle->read_operation.iovcnt == 0 ||
+ http_handle->parse_state == GLOBUS_XIO_HTTP_EOF)
+ {
+- http_handle->read_operation.wait_for = 0;
++ http_handle->read_operation.wait_for = 0;
+ goto finish;
+ }
+
+@@ -779,7 +779,7 @@ globus_i_xio_http_parse_residue(
+ {
+ nbytes = http_handle->read_operation.wait_for;
+ }
+-
++
+ result = globus_xio_driver_pass_read(
+ http_handle->read_operation.operation,
+ http_handle->read_operation.iov,
+@@ -790,8 +790,8 @@ globus_i_xio_http_parse_residue(
+ if (result == GLOBUS_SUCCESS)
+ {
+ *registered_again = GLOBUS_TRUE;
+- }
+-
++ }
++
+ }
+ break;
+ case GLOBUS_XIO_HTTP_STATUS_LINE:
+@@ -808,7 +808,7 @@ globus_i_xio_http_parse_residue(
+ {
+ goto finish;
+ }
+-
++
+ result = globus_xio_driver_pass_read(
+ http_handle->response_read_operation,
+ &http_handle->read_iovec,
+@@ -816,7 +816,7 @@ globus_i_xio_http_parse_residue(
+ 1,
+ globus_l_xio_http_client_read_response_callback,
+ http_handle);
+-
++
+ if (result != GLOBUS_SUCCESS)
+ {
+ goto finish;
+@@ -1111,7 +1111,7 @@ globus_l_xio_http_read_chunk_header_callback(
+ }
+ /*
+ * Either we've read enough, hit end of chunk, no entity was present,
+- * or pass to transport failed. Call finished_read
++ * or pass to transport failed. Call finished_read
+ */
+ op = http_handle->read_operation.operation;
+
+@@ -1138,7 +1138,7 @@ globus_l_xio_http_read_chunk_header_callback(
+ * @ingroup globus_i_xio_http_transform
+ *
+ * Parse the chunk size, end-of-chunk CRLF, or chunk footers, out of the
+- * handle's read buffer, depending on the current parse state.
++ * handle's read buffer, depending on the current parse state.
+ *
+ * @param http_handle
+ * Handle associated with this parsing.
+@@ -1211,7 +1211,7 @@ globus_l_xio_http_parse_chunk_header(
+
+ break;
+ }
+-
++
+ /* FALLSTHROUGH */
+ case GLOBUS_XIO_HTTP_CHUNK_LINE:
+ *eol = '\0';
+@@ -1367,7 +1367,7 @@ globus_l_xio_http_parse_chunk_header(
+ * Operation associated with the write.
+ *
+ * @return
+- * This function returns GLOBUS_SUCCESS,
++ * This function returns GLOBUS_SUCCESS,
+ * GLOBUS_XIO_ERROR_ALREADY_REGISTERED, and GLOBUS_XIO_ERROR_EOF
+ * errors directly. Other errors may be returned from
+ * globus_i_xio_http_server_write_response(),
+@@ -1414,7 +1414,7 @@ globus_i_xio_http_write(
+ }
+ else
+ {
+-
++
+ switch (http_handle->send_state)
+ {
+ case GLOBUS_XIO_HTTP_STATUS_LINE:
+@@ -1428,7 +1428,7 @@ globus_i_xio_http_write(
+ case GLOBUS_XIO_HTTP_CLOSE:
+ result = GlobusXIOHttpErrorNoEntity();
+ break;
+-
++
+ case GLOBUS_XIO_HTTP_CHUNK_BODY:
+ if (http_handle->write_operation.operation != NULL)
+ {
+@@ -1455,13 +1455,13 @@ globus_i_xio_http_write(
+ globus_i_xio_http_write_callback,
+ http_handle);
+ break;
+-
++
+ case GLOBUS_XIO_HTTP_PRE_REQUEST_LINE:
+ if(http_handle->delay_write_header)
+ {
+ http_handle->first_write_iovec = iovec;
+ http_handle->first_write_iovec_count = iovec_count;
+-
++
+ result = globus_i_xio_http_client_write_request(
+ op,
+ http_handle);
+@@ -1552,7 +1552,7 @@ globus_i_xio_http_write_chunk(
+ }
+ http_handle->write_operation.operation = op;
+ http_handle->write_operation.driver_handle = globus_xio_operation_get_driver_handle(op);
+- http_handle->write_operation.iov = globus_libc_malloc((iovec_count + 2) *
++ http_handle->write_operation.iov = globus_libc_malloc((iovec_count + 2) *
+ sizeof(globus_xio_iovec_t));
+
+ if (http_handle->write_operation.iov == NULL)
+@@ -1615,7 +1615,7 @@ error_exit:
+ * In chunked mode, we will adjust the nbytes to remove the size of the
+ * chunk framing, otherwise we will finish the write with the value passed
+ * to this callback.
+- *
++ *
+ * @param op
+ * Operation associated with the write.
+ * @param result
+@@ -1692,10 +1692,10 @@ globus_i_xio_http_write_callback(
+ globus_object_t * err;
+
+ err = globus_error_get(result);
+-
++
+ if(http_handle->reopen_in_progress)
+ {
+- http_handle->pending_error =
++ http_handle->pending_error =
+ GlobusXIOHTTPErrorObjPersistentConnectionDropped(err);
+ }
+ else
+diff --git a/xio/src/builtins/mode_e/globus_xio_mode_e_driver.c b/xio/src/builtins/mode_e/globus_xio_mode_e_driver.c
+index 7f4baa419..65952a036 100644
+--- a/xio/src/builtins/mode_e/globus_xio_mode_e_driver.c
++++ b/xio/src/builtins/mode_e/globus_xio_mode_e_driver.c
+@@ -78,7 +78,7 @@ typedef struct
+ globus_xio_stack_t stack;
+ int max_connection_count;
+ int eod_count;
+- globus_xio_attr_t xio_attr;
++ globus_xio_attr_t xio_attr;
+ globus_bool_t send_eod;
+ globus_bool_t manual_eodc;
+ globus_off_t offset;
+@@ -89,7 +89,7 @@ static globus_l_xio_mode_e_attr_t globus_l_xio_mode_e_attr_default =
+ {
+ GLOBUS_NULL,
+ 1,
+- 0,
++ 0,
+ GLOBUS_NULL,
+ GLOBUS_FALSE,
+ GLOBUS_FALSE,
+@@ -109,7 +109,7 @@ typedef struct
+ globus_xio_server_t server;
+ globus_xio_handle_t accepted_handle;
+ globus_l_xio_mode_e_attr_t * attr;
+- globus_i_xio_mode_e_state_t state;
++ globus_i_xio_mode_e_state_t state;
+ globus_memory_t requestor_memory;
+ globus_memory_t header_memory;
+ char * cs;
+@@ -137,7 +137,7 @@ typedef struct
+ globus_object_t * error;
+ } globus_l_xio_mode_e_handle_t;
+
+-typedef struct
++typedef struct
+ {
+ globus_xio_operation_t op;
+ globus_xio_iovec_t * iovec;
+@@ -154,11 +154,11 @@ typedef struct
+ globus_i_xio_mode_e_requestor_t * requestor;
+ int iovec_index;
+ globus_size_t iovec_index_len;
+- globus_off_t outstanding_data_len;
+- globus_off_t outstanding_data_offset;
++ globus_off_t outstanding_data_len;
++ globus_off_t outstanding_data_offset;
+ globus_bool_t eod;
+ globus_bool_t close;
+-} globus_l_xio_mode_e_connection_handle_t;
++} globus_l_xio_mode_e_connection_handle_t;
+
+ static
+ int
+@@ -302,18 +302,18 @@ error_xio_system_activate:
+ static
+ int
+ globus_l_xio_mode_e_deactivate(void)
+-{
++{
+ int rc;
+ GlobusXIOName(globus_l_xio_mode_e_deactivate);
+-
++
+ GlobusXIOModeEDebugEnter();
+ GlobusXIOUnRegisterDriver(mode_e);
+ rc = globus_module_deactivate(GLOBUS_XIO_MODULE);
+ if (rc != GLOBUS_SUCCESS)
+- {
++ {
+ goto error_deactivate;
+ }
+-
++
+ GlobusXIOModeEDebugExit();
+ GlobusDebugDestroy(GLOBUS_XIO_MODE_E);
+ return GLOBUS_SUCCESS;
+@@ -336,7 +336,7 @@ globus_l_xio_mode_e_hashtable_offset_hash(
+ int i;
+ globus_size_t size;
+ GlobusXIOName(globus_l_xio_mode_e_hashtable_offset_hash);
+-
++
+ GlobusXIOModeEDebugEnter();
+ key = (char *) offsetp;
+ size = sizeof(globus_off_t);
+@@ -347,8 +347,8 @@ globus_l_xio_mode_e_hashtable_offset_hash(
+ {
+ h ^= g >> 24;
+ h ^= g;
+- }
+- }
++ }
++ }
+ GlobusXIOModeEDebugExit();
+ return h % limit;
+ }
+@@ -438,7 +438,7 @@ globus_i_xio_mode_e_header_encode(
+ GlobusXIOModeEDebugEnter();
+ offset_size = sizeof(globus_off_t);
+ /*
+- * buf[0] contains most significant byte and buf[7] contains the
++ * buf[0] contains most significant byte and buf[7] contains the
+ * least significant byte
+ */
+ globus_assert(GLOBUS_XIO_MODE_E_MAX_OFFSET_SIZE >= offset_size);
+@@ -470,12 +470,12 @@ globus_i_xio_mode_e_header_decode(
+ GlobusXIOModeEDebugEnter();
+ offset_size = sizeof(globus_off_t);
+ for (i = GLOBUS_XIO_MODE_E_MAX_OFFSET_SIZE; i > offset_size; i--)
+- {
+- /*
++ {
++ /*
+ * if offset_size < MAX_OFFSET_SIZE; then the most significant
+ * (MAX_OFFSET_SIZE - offset_size) number of bytes should be zero;
+ * otherwise there is an overflow
+- */
++ */
+ if (buf[GLOBUS_XIO_MODE_E_MAX_OFFSET_SIZE - i] != 0)
+ {
+ result = GlobusXIOModeEHeaderError("offset overflow");
+@@ -485,7 +485,7 @@ globus_i_xio_mode_e_header_decode(
+ if (offset_size > GLOBUS_XIO_MODE_E_MAX_OFFSET_SIZE)
+ {
+ offset_size = GLOBUS_XIO_MODE_E_MAX_OFFSET_SIZE;
+- }
++ }
+ for (i = 0; i < offset_size; i++)
+ {
+ x += ((globus_off_t) buf[i]) << (offset_size - i - 1) * 8;
+@@ -503,7 +503,7 @@ overflow:
+ /*
+ * allocate the memory for and initialize an internal handle
+ */
+-static
++static
+ globus_result_t
+ globus_l_xio_mode_e_handle_create(
+ globus_l_xio_mode_e_handle_t ** out_handle,
+@@ -526,7 +526,7 @@ globus_l_xio_mode_e_handle_create(
+ memset(handle, 0, sizeof(globus_l_xio_mode_e_handle_t));
+ if (!attr)
+ {
+- result = globus_l_xio_mode_e_attr_init((void**)(void*)&handle->attr);
++ result = globus_l_xio_mode_e_attr_init((void**)(void*)&handle->attr);
+ if (result != GLOBUS_SUCCESS)
+ {
+ result = GlobusXIOErrorWrapFailed(
+@@ -577,23 +577,23 @@ globus_l_xio_mode_e_handle_create(
+ if (result != GLOBUS_SUCCESS)
+ {
+ goto error_eod_q_init;
+- }
++ }
+ result = globus_fifo_init(&handle->io_q);
+ if (result != GLOBUS_SUCCESS)
+ {
+ goto error_io_q_init;
+ }
+- node_size = sizeof(globus_i_xio_mode_e_requestor_t);
+- node_count = GLOBUS_XIO_MODE_E_IO_Q_SIZE;
++ node_size = sizeof(globus_i_xio_mode_e_requestor_t);
++ node_count = GLOBUS_XIO_MODE_E_IO_Q_SIZE;
+ globus_memory_init(&handle->requestor_memory, node_size, node_count);
+ node_size = sizeof(globus_l_xio_mode_e_header_t);
+- node_count = GLOBUS_XIO_MODE_E_HEADER_COUNT;
++ node_count = GLOBUS_XIO_MODE_E_HEADER_COUNT;
+ globus_memory_init(&handle->header_memory, node_size, node_count);
+ globus_mutex_init(&handle->mutex, NULL);
+- /*
++ /*
+ * As I did memset(handle, 0) in the beginning, here i initialize only the
+ * fields that has to initialized with a non-zero value
+- */
++ */
+ handle->eod_count = -1;
+ handle->ref_count = 1;
+ *out_handle = handle;
+@@ -608,7 +608,7 @@ error_connection_q_init:
+ error_push_driver:
+ if (!handle->attr->stack)
+ {
+- globus_xio_stack_destroy(handle->stack);
++ globus_xio_stack_destroy(handle->stack);
+ }
+ error_stack_init:
+ if (!handle->attr->stack)
+@@ -635,7 +635,7 @@ globus_l_xio_mode_e_server_init(
+ globus_l_xio_mode_e_handle_t * handle;
+ globus_l_xio_mode_e_attr_t * attr;
+ globus_xio_contact_t my_contact_info;
+- char * cs;
++ char * cs;
+ globus_result_t result;
+ GlobusXIOName(globus_l_xio_mode_e_server_init);
+
+@@ -645,7 +645,7 @@ globus_l_xio_mode_e_server_init(
+ if (result != GLOBUS_SUCCESS)
+ {
+ goto error_handle_create;
+- }
++ }
+ if (!attr)
+ {
+ attr = handle->attr;
+@@ -657,19 +657,19 @@ globus_l_xio_mode_e_server_init(
+ {
+ goto error_attr_init;
+ }
+- }
++ }
+ result = globus_xio_server_create(
+ &handle->server, attr->xio_attr, handle->stack);
+ if (result != GLOBUS_SUCCESS)
+ {
+ goto error_server_create;
+- }
++ }
+ result = globus_xio_server_get_contact_string(handle->server, &cs);
+ if (result != GLOBUS_SUCCESS)
+ {
+ goto error_get_cs;
+ }
+- result = globus_xio_contact_parse(&my_contact_info, cs);
++ result = globus_xio_contact_parse(&my_contact_info, cs);
+ if (result != GLOBUS_SUCCESS)
+ {
+ goto error_parse_cs;
+@@ -692,7 +692,7 @@ error_attr_init:
+ globus_l_xio_mode_e_handle_destroy(handle);
+ error_handle_create:
+ GlobusXIOModeEDebugExitWithError();
+- return result;
++ return result;
+ }
+
+
+@@ -703,12 +703,12 @@ globus_l_xio_mode_e_save_error(
+ globus_result_t result)
+ {
+ GlobusXIOName(globus_l_xio_mode_e_save_error);
+-
++
+ GlobusXIOModeEDebugEnter();
+ handle->state = GLOBUS_XIO_MODE_E_ERROR;
+ if (handle->error == GLOBUS_NULL)
+ {
+- handle->error = globus_object_copy(globus_error_peek(result));
++ handle->error = globus_object_copy(globus_error_peek(result));
+ }
+ GlobusXIOModeEDebugExit();
+ }
+@@ -722,14 +722,14 @@ globus_l_xio_mode_e_server_accept_cb(
+ globus_result_t result,
+ void * user_arg)
+ {
+- globus_l_xio_mode_e_handle_t * handle;
++ globus_l_xio_mode_e_handle_t * handle;
+ globus_xio_operation_t op;
+ GlobusXIOName(globus_l_xio_mode_e_server_accept_cb);
+
+ GlobusXIOModeEDebugEnter();
+ handle = (globus_l_xio_mode_e_handle_t *)user_arg;
+ globus_xio_operation_disable_cancel(handle->outstanding_op);
+- globus_mutex_lock(&handle->mutex);
++ globus_mutex_lock(&handle->mutex);
+ op = handle->outstanding_op;
+ if (result == GLOBUS_SUCCESS)
+ {
+@@ -740,13 +740,13 @@ globus_l_xio_mode_e_server_accept_cb(
+ {
+ goto error_accept;
+ }
+- globus_mutex_unlock(&handle->mutex);
++ globus_mutex_unlock(&handle->mutex);
+ globus_xio_driver_finished_accept(op, handle, result);
+ GlobusXIOModeEDebugExit();
+ return;
+
+ error_accept:
+- globus_mutex_unlock(&handle->mutex);
++ globus_mutex_unlock(&handle->mutex);
+ globus_xio_driver_finished_accept(op, handle, result);
+ GlobusXIOModeEDebugExitWithError();
+ return;
+@@ -754,9 +754,9 @@ error_accept:
+
+
+ /*
+- * At any instance, there would be a globus_xio_server_register_accept
++ * At any instance, there would be a globus_xio_server_register_accept
+ * outstanding to accept any new incoming connection. For the very first
+- * register accept (done in globus_l_xio_mode_e_server_accept),
++ * register accept (done in globus_l_xio_mode_e_server_accept),
+ * globus_l_xio_mode_e_server_accept_cb is used. For the subsequent
+ * register accpets, this function is used
+ */
+@@ -768,39 +768,39 @@ globus_i_xio_mode_e_server_accept_cb(
+ globus_result_t result,
+ void * user_arg)
+ {
+- globus_l_xio_mode_e_handle_t * handle;
++ globus_l_xio_mode_e_handle_t * handle;
+ globus_result_t res;
+ GlobusXIOName(globus_i_xio_mode_e_server_accept_cb);
+
+ GlobusXIOModeEDebugEnter();
+ handle = (globus_l_xio_mode_e_handle_t *)user_arg;
+- globus_mutex_lock(&handle->mutex);
++ globus_mutex_lock(&handle->mutex);
+ if (result != GLOBUS_SUCCESS)
+- {
++ {
+ res = result;
+ goto error_accept;
+- }
++ }
+ switch (handle->state)
+ {
+ case GLOBUS_XIO_MODE_E_OPEN:
+ {
+ res = globus_xio_register_open(
+- xio_handle,
+- NULL,
++ xio_handle,
++ NULL,
+ handle->attr->xio_attr,
+ globus_i_xio_mode_e_server_open_cb,
+ handle);
+ if (res != GLOBUS_SUCCESS)
+ {
+ globus_xio_register_close(
+- xio_handle,
+- NULL,
++ xio_handle,
++ NULL,
+ NULL,
+ NULL);
+ goto error_register_open;
+ }
+ res = globus_xio_server_register_accept(
+- server,
++ server,
+ globus_i_xio_mode_e_server_accept_cb,
+ handle);
+ if (res != GLOBUS_SUCCESS)
+@@ -812,8 +812,8 @@ globus_i_xio_mode_e_server_accept_cb(
+ default:
+ res = GlobusXIOErrorInvalidState(handle->state);
+ goto error_invalid_state;
+- }
+- globus_mutex_unlock(&handle->mutex);
++ }
++ globus_mutex_unlock(&handle->mutex);
+ GlobusXIOModeEDebugExit();
+ return;
+
+@@ -822,7 +822,7 @@ error_register_open:
+ error_invalid_state:
+ error_accept:
+ globus_l_xio_mode_e_save_error(handle, res);
+- globus_mutex_unlock(&handle->mutex);
++ globus_mutex_unlock(&handle->mutex);
+ GlobusXIOModeEDebugExitWithError();
+ return;
+ }
+@@ -840,8 +840,8 @@ globus_i_xio_mode_e_cancel_operations(
+ GlobusXIOName(globus_i_xio_mode_e_cancel_operations);
+
+ GlobusXIOModeEDebugEnter();
+- /*
+- * If user cancels close on the client side, both register_write (eods)
++ /*
++ * If user cancels close on the client side, both register_write (eods)
+ * and register_close can be outstanding
+ */
+ mask = GLOBUS_XIO_CANCEL_WRITE;
+@@ -851,9 +851,9 @@ globus_i_xio_mode_e_cancel_operations(
+ globus_list_remove(&handle->eod_list, handle->eod_list);
+ result = globus_xio_handle_cancel_operations(xio_handle, mask);
+ if (result != GLOBUS_SUCCESS)
+- {
++ {
+ goto error;
+- }
++ }
+ }
+ mask = GLOBUS_XIO_CANCEL_CLOSE;
+ while (!globus_list_empty(handle->close_list))
+@@ -862,9 +862,9 @@ globus_i_xio_mode_e_cancel_operations(
+ globus_list_remove(&handle->close_list, handle->close_list);
+ result = globus_xio_handle_cancel_operations(xio_handle, mask);
+ if (result != GLOBUS_SUCCESS)
+- {
++ {
+ goto error;
+- }
++ }
+ }
+ GlobusXIOModeEDebugExit();
+ return GLOBUS_SUCCESS;
+@@ -924,11 +924,11 @@ globus_l_xio_mode_e_cancel_cb(
+ if (globus_fifo_empty(&handle->io_q) ||
+ !globus_fifo_remove(&handle->io_q, requestor))
+ {
+- /*
+- * requestor->xio_handle would be NULL if cancel was called
+- * after enable_cancel is called in read/write and before the
+- * lock is required in read/write. In that case an xio
+- * operation would not have been initiated. So I don't do
++ /*
++ * requestor->xio_handle would be NULL if cancel was called
++ * after enable_cancel is called in read/write and before the
++ * lock is required in read/write. In that case an xio
++ * operation would not have been initiated. So I don't do
+ * anything here.
+ */
+ if (requestor->xio_handle)
+@@ -969,7 +969,7 @@ globus_l_xio_mode_e_cancel_cb(
+ default:
+ result = GlobusXIOErrorInvalidState(handle->state);
+ goto error;
+-
++
+ }
+ globus_mutex_unlock(&handle->mutex);
+ if (finish)
+@@ -1025,13 +1025,13 @@ globus_l_xio_mode_e_server_accept(
+ goto error_operation_canceled;
+ }
+ result = globus_xio_server_register_accept(
+- handle->server,
++ handle->server,
+ globus_l_xio_mode_e_server_accept_cb,
+ handle);
+ if (result != GLOBUS_SUCCESS)
+ {
+ goto error_register_accept;
+- }
++ }
+ globus_mutex_unlock(&handle->mutex);
+ GlobusXIOModeEDebugExit();
+ return GLOBUS_SUCCESS;
+@@ -1054,19 +1054,19 @@ globus_l_xio_mode_e_server_destroy(
+ {
+ globus_l_xio_mode_e_handle_t * handle;
+ GlobusXIOName(globus_l_xio_mode_e_server_destroy);
+-
++
+ GlobusXIOModeEDebugEnter();
+ handle = (globus_l_xio_mode_e_handle_t *)driver_server;
+- globus_mutex_lock(&handle->mutex);
++ globus_mutex_lock(&handle->mutex);
+ --handle->ref_count;
+ if (handle->ref_count == 0)
+ {
+- globus_mutex_unlock(&handle->mutex);
++ globus_mutex_unlock(&handle->mutex);
+ globus_l_xio_mode_e_handle_destroy(handle);
+ }
+ else
+ {
+- globus_mutex_unlock(&handle->mutex);
++ globus_mutex_unlock(&handle->mutex);
+ }
+ GlobusXIOModeEDebugExit();
+ return GLOBUS_SUCCESS;
+@@ -1114,7 +1114,7 @@ globus_l_xio_mode_e_link_destroy(
+ --handle->ref_count;
+ if (handle->ref_count == 0)
+ {
+- globus_mutex_unlock(&handle->mutex);
++ globus_mutex_unlock(&handle->mutex);
+ globus_l_xio_mode_e_handle_destroy(handle);
+ }
+ else
+@@ -1148,7 +1148,7 @@ static
+ globus_result_t
+ globus_l_xio_mode_e_process_header(
+ globus_l_xio_mode_e_header_t * header,
+- globus_l_xio_mode_e_connection_handle_t *
++ globus_l_xio_mode_e_connection_handle_t *
+ connection_handle)
+ {
+ globus_result_t result;
+@@ -1161,7 +1161,7 @@ globus_l_xio_mode_e_process_header(
+ }
+ if (header->descriptor & GLOBUS_XIO_MODE_E_DATA_DESCRIPTOR_CLOSE)
+ {
+- /* sending CLOSE before EOD is a protocol violation */
++ /* sending CLOSE before EOD is a protocol violation */
+ globus_assert(connection_handle->eod);
+ connection_handle->close = GLOBUS_TRUE;
+ }
+@@ -1216,15 +1216,15 @@ globus_l_xio_mode_e_process_outstanding_data(
+ if (!globus_fifo_empty(&handle->io_q))
+ {
+ requestor = (globus_i_xio_mode_e_requestor_t *)
+- globus_fifo_dequeue(&handle->io_q);
++ globus_fifo_dequeue(&handle->io_q);
+ if (handle->attr->offset_reads)
+ {
+ /* wait_for of this requestor should be zero */
+- requestor->dd->offset =
++ requestor->dd->offset =
+ connection_handle->outstanding_data_offset;
+ globus_hashtable_insert(
+- &handle->offset_ht,
+- (void *) &connection_handle->outstanding_data_offset,
++ &handle->offset_ht,
++ (void *) &connection_handle->outstanding_data_offset,
+ (void *) connection_handle);
+ }
+ else
+@@ -1265,7 +1265,7 @@ globus_l_xio_mode_e_process_eod(
+ NULL,
+ globus_l_xio_mode_e_close_cb,
+ handle);
+- globus_list_remove(&handle->connection_list,
++ globus_list_remove(&handle->connection_list,
+ globus_list_search(handle->connection_list, connection_handle));
+ globus_free(connection_handle);
+ }
+@@ -1320,7 +1320,7 @@ globus_l_xio_mode_e_read_header_cb(
+ offset = connection_handle->outstanding_data_offset;
+ globus_mutex_lock(&handle->mutex);
+ if (result == GLOBUS_SUCCESS)
+- {
++ {
+ header = (globus_l_xio_mode_e_header_t *) buffer;
+ result = globus_l_xio_mode_e_process_header(header, connection_handle);
+ if (result != GLOBUS_SUCCESS)
+@@ -1337,16 +1337,16 @@ globus_l_xio_mode_e_read_header_cb(
+ * If EOF is set in header, data len will be zero. If EOD alone is
+ * set, there can be data present. If EOD is set on header and also
+ * there is data present, i process EOD in read_cb. If I process it
+- * here and if it so happens that eods_received == eod_count,
++ * here and if it so happens that eods_received == eod_count,
+ * process_eod will return true (eof) and the state would be set to
+ * GLOBUS_XIO_MODE_E_EOF_RECEIVED or DELIVERED and there would be no
+- * way for the user to read the data that had EOD set on the header.
++ * way for the user to read the data that had EOD set on the header.
+ */
+ else if (connection_handle->eod)
+ {
+ eof = globus_l_xio_mode_e_process_eod(
+ connection_handle, &requestor_q);
+- if (eof)
++ if (eof)
+ {
+ if (globus_fifo_empty(&requestor_q))
+ {
+@@ -1357,12 +1357,12 @@ globus_l_xio_mode_e_read_header_cb(
+ }
+ else
+ {
+- requestor = (globus_i_xio_mode_e_requestor_t *)
++ requestor = (globus_i_xio_mode_e_requestor_t *)
+ globus_fifo_peek(&requestor_q);
+ globus_xio_driver_set_eof_received(requestor->op);
+ /*
+ * If this part of the code is executed, finished_read
+- * happen only in if (finish) {} block below. The
++ * happen only in if (finish) {} block below. The
+ * finished_read in if (requestor) {} block below should
+ * happen only if process_outstanding_data called above
+ * returns a non NULL requestor value. Thats why requestor
+@@ -1388,13 +1388,13 @@ globus_l_xio_mode_e_read_header_cb(
+ }
+ }
+ else if(globus_error_match(
+- globus_error_peek(result),
+- GLOBUS_XIO_MODULE,
++ globus_error_peek(result),
++ GLOBUS_XIO_MODULE,
+ GLOBUS_XIO_ERROR_CANCELED))
+ {
+- /*
+- * if there are outstanding header reads and user calls close, the
+- * header reads are canceled in close
++ /*
++ * if there are outstanding header reads and user calls close, the
++ * header reads are canceled in close
+ */
+ if (!handle->close_canceled)
+ {
+@@ -1445,12 +1445,12 @@ globus_l_xio_mode_e_read_header_cb(
+ op = requestor->op;
+ /*
+ * Earlier I had this push_node inside process_eod but then i moved
+- * here to avoid a race. process_eod is called with lock held and
++ * here to avoid a race. process_eod is called with lock held and
+ * when lock is released above, sometimes cancel_cb gets called and
+ * it tries to access the requestor which is no more. To get rid
+ * of that, I moved the push_node to here after disable_cancel.
+- * Since requestor is removed from the handle->io_q and put in
+- * requestor_q by process_eod function, cancel_cb will not do
++ * Since requestor is removed from the handle->io_q and put in
++ * requestor_q by process_eod function, cancel_cb will not do
+ * finished_read on requestor->op. Similar thing is done in read_cb
+ * too
+ */
+@@ -1460,7 +1460,7 @@ globus_l_xio_mode_e_read_header_cb(
+ NULL,
+ GLOBUS_XIO_DD_SET_OFFSET,
+ offset);
+- res = GlobusXIOErrorEOF();
++ res = GlobusXIOErrorEOF();
+ globus_xio_driver_finished_read(op, res, 0);
+ }
+ }
+@@ -1531,7 +1531,7 @@ globus_l_xio_mode_e_open_cb(
+ globus_mutex_unlock(&handle->mutex);
+ globus_xio_driver_finished_open(handle, op, res);
+ GlobusXIOModeEDebugExit();
+- return;
++ return;
+
+ error_connection_handle:
+ globus_xio_register_close(xio_handle, NULL, NULL, NULL);
+@@ -1540,7 +1540,7 @@ error:
+ globus_xio_attr_destroy(handle->attr->xio_attr);
+ if (--handle->ref_count == 0)
+ {
+- globus_mutex_unlock(&handle->mutex);
++ globus_mutex_unlock(&handle->mutex);
+ globus_l_xio_mode_e_handle_destroy(handle);
+ }
+ else
+@@ -1550,7 +1550,7 @@ error:
+ }
+ globus_xio_driver_finished_open(handle, op, res);
+ GlobusXIOModeEDebugExitWithError();
+- return;
++ return;
+ }
+
+
+@@ -1573,12 +1573,12 @@ globus_i_xio_mode_e_open_cb(
+ handle = (globus_l_xio_mode_e_handle_t *)user_arg;
+ globus_mutex_lock(&handle->mutex);
+ if (result == GLOBUS_SUCCESS)
+- {
++ {
+ globus_size_t connection_handle_size;
+- connection_handle_size =
++ connection_handle_size =
+ sizeof(globus_l_xio_mode_e_connection_handle_t);
+ connection_handle = (globus_l_xio_mode_e_connection_handle_t *)
+- globus_malloc(connection_handle_size);
++ globus_malloc(connection_handle_size);
+ if (!connection_handle)
+ {
+ res = GlobusXIOErrorMemory("connection_handle");
+@@ -1614,7 +1614,7 @@ globus_i_xio_mode_e_open_cb(
+ }
+ globus_mutex_unlock(&handle->mutex);
+ GlobusXIOModeEDebugExit();
+- return;
++ return;
+
+ error_register_write:
+ error_connection_handle:
+@@ -1634,7 +1634,7 @@ error_open:
+ globus_xio_driver_finished_write(write_op, res, 0);
+ }
+ GlobusXIOModeEDebugExitWithError();
+- return;
++ return;
+ }
+
+
+@@ -1717,7 +1717,7 @@ globus_l_xio_mode_e_server_open_cb(
+ error:
+ if (--handle->ref_count == 0)
+ {
+- globus_mutex_unlock(&handle->mutex);
++ globus_mutex_unlock(&handle->mutex);
+ globus_l_xio_mode_e_handle_destroy(handle);
+ }
+ else
+@@ -1733,12 +1733,12 @@ error:
+
+ /* called locked (if handle->state == GLOBUS_XIO_MODE_E_OPEN) */
+ static
+-globus_result_t
++globus_result_t
+ globus_l_xio_mode_e_open_new_stream(
+ globus_l_xio_mode_e_handle_t * handle,
+ globus_xio_callback_t open_cb)
+ {
+- globus_xio_handle_t xio_handle;
++ globus_xio_handle_t xio_handle;
+ globus_l_xio_mode_e_attr_t * attr;
+ globus_i_xio_mode_e_requestor_t * requestor;
+ globus_xio_operation_t op;
+@@ -1781,8 +1781,8 @@ globus_l_xio_mode_e_open_new_stream(
+ }
+ }
+ result = globus_xio_register_open(
+- xio_handle,
+- handle->cs,
++ xio_handle,
++ handle->cs,
+ handle->attr->xio_attr,
+ open_cb,
+ handle);
+@@ -1833,10 +1833,10 @@ globus_l_xio_mode_e_server_open(
+ GlobusXIOModeEDebugEnter();
+ globus_mutex_lock(&handle->mutex);
+ handle->outstanding_op = op;
+- if (handle->attr->offset_reads)
++ if (handle->attr->offset_reads)
+ {
+ result = globus_hashtable_init(
+- &handle->offset_ht,
++ &handle->offset_ht,
+ GLOBUS_XIO_MODE_E_OFFSET_HT_SIZE,
+ globus_l_xio_mode_e_hashtable_offset_hash,
+ globus_l_xio_mode_e_hashtable_offset_keyeq);
+@@ -1953,7 +1953,7 @@ globus_l_xio_mode_e_open(
+ if (result != GLOBUS_SUCCESS)
+ {
+ globus_l_xio_mode_e_save_error(handle, result);
+- goto error_server_open;
++ goto error_server_open;
+ }
+ }
+ GlobusXIOModeEDebugExit();
+@@ -1961,7 +1961,7 @@ globus_l_xio_mode_e_open(
+
+ error_open_new_stream:
+ error_contact_info_to_string:
+- globus_l_xio_mode_e_handle_destroy(handle);
++ globus_l_xio_mode_e_handle_destroy(handle);
+ error_handle_create:
+ error_server_open:
+ GlobusXIOModeEDebugExitWithError();
+@@ -2011,7 +2011,7 @@ globus_l_xio_mode_e_read_cb(
+ void * user_arg)
+ {
+ globus_result_t res = result;
+- globus_l_xio_mode_e_connection_handle_t *
++ globus_l_xio_mode_e_connection_handle_t *
+ connection_handle;
+ globus_l_xio_mode_e_handle_t * handle;
+ globus_bool_t eof;
+@@ -2025,20 +2025,20 @@ globus_l_xio_mode_e_read_cb(
+ connection_handle = (globus_l_xio_mode_e_connection_handle_t *) user_arg;
+ op = connection_handle->requestor->op;
+ globus_xio_operation_disable_cancel(op);
+- handle = connection_handle->mode_e_handle;
++ handle = connection_handle->mode_e_handle;
+ globus_fifo_init(&requestor_q);
+ offset = connection_handle->outstanding_data_offset;
+ if (connection_handle->iovec_index != -1)
+ {
+- iovec[connection_handle->iovec_index].iov_len =
++ iovec[connection_handle->iovec_index].iov_len =
+ connection_handle->iovec_index_len;
+ connection_handle->iovec_index = -1;
+ }
+- globus_mutex_lock(&handle->mutex);
++ globus_mutex_lock(&handle->mutex);
+ globus_memory_push_node(
+ &handle->requestor_memory, (void*)connection_handle->requestor);
+ if (result == GLOBUS_SUCCESS)
+- {
++ {
+ connection_handle->outstanding_data_len -= nbytes;
+ if (connection_handle->outstanding_data_len > 0)
+ {
+@@ -2046,7 +2046,7 @@ globus_l_xio_mode_e_read_cb(
+ requestor = globus_l_xio_mode_e_process_outstanding_data(
+ connection_handle);
+ }
+- else if (connection_handle->eod)
++ else if (connection_handle->eod)
+ {
+ eof = globus_l_xio_mode_e_process_eod(
+ connection_handle, &requestor_q);
+@@ -2080,7 +2080,7 @@ globus_l_xio_mode_e_read_cb(
+ }
+ goto error;
+ }
+- globus_mutex_unlock(&handle->mutex);
++ globus_mutex_unlock(&handle->mutex);
+ globus_xio_driver_data_descriptor_cntl(
+ op,
+ NULL,
+@@ -2109,7 +2109,7 @@ globus_l_xio_mode_e_read_cb(
+
+ error:
+ globus_l_xio_mode_e_save_error(handle, result);
+- globus_mutex_unlock(&handle->mutex);
++ globus_mutex_unlock(&handle->mutex);
+ while (!globus_fifo_empty(&requestor_q))
+ {
+ requestor = (globus_i_xio_mode_e_requestor_t*)
+@@ -2131,7 +2131,7 @@ globus_i_xio_mode_e_register_read(
+ globus_l_xio_mode_e_connection_handle_t *
+ connection_handle)
+ {
+- globus_size_t iovec_len;
++ globus_size_t iovec_len;
+ globus_result_t result;
+ globus_xio_iovec_t * iovec;
+ int iovec_count;
+@@ -2141,14 +2141,14 @@ globus_i_xio_mode_e_register_read(
+ iovec = connection_handle->requestor->iovec;
+ iovec_count = connection_handle->requestor->iovec_count;
+ GlobusXIOUtilIovTotalLength(iovec_len, iovec, iovec_count);
+- /*
+- * Upto iovec_len amount of data would be read from the channel. If
++ /*
++ * Upto iovec_len amount of data would be read from the channel. If
+ * iovec_len > outstanding_data_len, this read might possibly get the next
+ * header that has arrived on this channel. So I modify iovec (and later
+ * restore in the read_cb) such that the amount of data read would be
+ * min(outstanding_data_len, iovec_len)
+ */
+- if (connection_handle->outstanding_data_len < iovec_len)
++ if (connection_handle->outstanding_data_len < iovec_len)
+ {
+ globus_size_t size = 0;
+ int i;
+@@ -2168,7 +2168,7 @@ globus_i_xio_mode_e_register_read(
+ }
+ result = globus_xio_register_readv(
+ connection_handle->xio_handle,
+- (globus_xio_iovec_t*)iovec,
++ (globus_xio_iovec_t*)iovec,
+ iovec_count,
+ iovec_len,
+ NULL,
+@@ -2176,7 +2176,7 @@ globus_i_xio_mode_e_register_read(
+ connection_handle);
+ GlobusXIOModeEDebugExit();
+ return result;
+-}
++}
+
+
+ /* called locked */
+@@ -2187,7 +2187,7 @@ globus_l_xio_mode_e_reset_connections(
+ {
+ globus_l_xio_mode_e_connection_handle_t *
+ connection_handle;
+- globus_result_t result;
++ globus_result_t result;
+ GlobusXIOName(globus_l_xio_mode_e_reset_connections);
+ GlobusXIOModeEDebugEnter();
+ handle->eod_count = -1;
+@@ -2278,17 +2278,17 @@ globus_l_xio_mode_e_read(
+ case GLOBUS_XIO_MODE_E_EOF_RECEIVED:
+ globus_xio_driver_set_eof_received(op);
+ handle->state = GLOBUS_XIO_MODE_E_EOF_DELIVERED;
+- globus_memory_push_node(
+- &handle->requestor_memory, (void*)requestor);
++ globus_memory_push_node(
++ &handle->requestor_memory, (void*)requestor);
+ result = GlobusXIOErrorEOF();
+ finish = GLOBUS_TRUE;
+ break;
+ case GLOBUS_XIO_MODE_E_EOF_DELIVERED:
+- if (globus_xio_driver_eof_received(op) ||
++ if (globus_xio_driver_eof_received(op) ||
+ handle->connection_count == 0)
+ {
+- globus_memory_push_node(
+- &handle->requestor_memory, (void*)requestor);
++ globus_memory_push_node(
++ &handle->requestor_memory, (void*)requestor);
+ result = GlobusXIOErrorEOF();
+ finish = GLOBUS_TRUE;
+ break;
+@@ -2296,7 +2296,7 @@ globus_l_xio_mode_e_read(
+ else
+ {
+ globus_l_xio_mode_e_reset_connections(handle);
+- /*
++ /*
+ * connection_q will be empty at this point. I let this
+ * fall through to enqueue the request in the io_q
+ */
+@@ -2309,29 +2309,29 @@ globus_l_xio_mode_e_read(
+ }
+ else
+ {
+- globus_l_xio_mode_e_connection_handle_t *
++ globus_l_xio_mode_e_connection_handle_t *
+ connection_handle;
+ if (wait_for == 0)
+ {
+ globus_memory_push_node(
+ &handle->requestor_memory, (void*)requestor);
+- connection_handle =
+- (globus_l_xio_mode_e_connection_handle_t*)
++ connection_handle =
++ (globus_l_xio_mode_e_connection_handle_t*)
+ globus_fifo_dequeue(&handle->connection_q);
+ globus_hashtable_insert(
+- &handle->offset_ht,
+- (void *)&connection_handle->outstanding_data_offset,
++ &handle->offset_ht,
++ (void *)&connection_handle->outstanding_data_offset,
+ (void *)connection_handle);
+ dd->offset = connection_handle->outstanding_data_offset;
+ result = GLOBUS_SUCCESS;
+ finish = GLOBUS_TRUE;
+ }
+- else
++ else
+ {
+ if (handle->attr->offset_reads)
+ {
+- connection_handle =
+- (globus_l_xio_mode_e_connection_handle_t*)
++ connection_handle =
++ (globus_l_xio_mode_e_connection_handle_t*)
+ globus_hashtable_remove(
+ &handle->offset_ht, &dd->offset);
+ if (!connection_handle)
+@@ -2342,8 +2342,8 @@ globus_l_xio_mode_e_read(
+ }
+ else
+ {
+- connection_handle =
+- (globus_l_xio_mode_e_connection_handle_t*)
++ connection_handle =
++ (globus_l_xio_mode_e_connection_handle_t*)
+ globus_fifo_dequeue(&handle->connection_q);
+ }
+ connection_handle->requestor = requestor;
+@@ -2428,8 +2428,8 @@ globus_l_xio_mode_e_write_cb(
+ requestor_result = globus_i_xio_mode_e_register_write(
+ connection_handle);
+ if (requestor_result != GLOBUS_SUCCESS)
+- {
+- requestor_op = requestor->op;
++ {
++ requestor_op = requestor->op;
+ requestor_offset = connection_handle->outstanding_data_offset;
+ finish_next = GLOBUS_TRUE;
+ globus_memory_push_node(
+@@ -2442,10 +2442,10 @@ globus_l_xio_mode_e_write_cb(
+ if (handle->state == GLOBUS_XIO_MODE_E_SENDING_EOD)
+ {
+ globus_byte_t descriptor;
+- /*
++ /*
+ * I'll get this cb with eod_sent == TRUE for one connection alone
+ * and I send EOF (if need be) on this connection alone. If I don't
+- * need to send EOF and eods_sent == connection_count, I need to
++ * need to send EOF and eods_sent == connection_count, I need to
+ * finish the write (that had SEND_EOD set on dd)
+ */
+ if (!connection_handle->eod)
+@@ -2458,7 +2458,7 @@ globus_l_xio_mode_e_write_cb(
+ goto error_register_eod;
+ }
+ }
+- else
++ else
+ {
+ connection_handle->eod = GLOBUS_FALSE;
+ if (handle->eod_count > -1)
+@@ -2558,13 +2558,13 @@ globus_l_xio_mode_e_write_header_cb(
+ globus_mutex_lock(&handle->mutex);
+ if (result == GLOBUS_SUCCESS)
+ {
+- /*
++ /*
+ * if handle->eod_count != -1, then register_eod will be called (either
+- * in here or in write_cb) to send EOF and eods_sent will be
++ * in here or in write_cb) to send EOF and eods_sent will be
+ * incremented in eod_cb
+ */
+ if (header->descriptor & GLOBUS_XIO_MODE_E_DATA_DESCRIPTOR_EOD &&
+- handle->eod_count == -1)
++ handle->eod_count == -1)
+ {
+ ++handle->eods_sent;
+ }
+@@ -2590,7 +2590,7 @@ globus_l_xio_mode_e_write_header_cb(
+ else if (handle->eod_count > -1)
+ {
+ globus_byte_t descriptor;
+- /*
++ /*
+ * handle->iovec can be NULL only when the user sets SEND_EOD
+ * on the dd. So I just wrote EOD on this channel and now i check
+ * to see if i need to send EOF
+@@ -2603,13 +2603,13 @@ globus_l_xio_mode_e_write_header_cb(
+ goto error;
+ }
+ }
+- else
++ else
+ {
+ globus_fifo_enqueue(&handle->connection_q, connection_handle);
+ if (handle->eods_sent == handle->connection_count)
+ {
+- /*
+- * user is allowed to do a write with buffer = NULL and
++ /*
++ * user is allowed to do a write with buffer = NULL and
+ * SEND_EOD set on dd
+ */
+ handle->state = GLOBUS_XIO_MODE_E_OPEN;
+@@ -2617,17 +2617,17 @@ globus_l_xio_mode_e_write_header_cb(
+ handle->attr->eod_count = -1;
+ handle->offset = 0;
+ finish = GLOBUS_TRUE;
+- /*
++ /*
+ * handle->eod_offset also has same value. if i have to finish
+ * in eod_cb, connection_handle->outstanding_data_offset cant
+- * be used coz i don't know which connection_handle is
++ * be used coz i don't know which connection_handle is
+ * associated with the user_write (that had SEND_EOD set).
+ */
+ offset = connection_handle->outstanding_data_offset;
+ /* the op is stored in handle->outstanding_op too */
+ op = connection_handle->requestor->op;
+ globus_memory_push_node(
+- &handle->requestor_memory,
++ &handle->requestor_memory,
+ (void*)connection_handle->requestor);
+ }
+ }
+@@ -2668,7 +2668,7 @@ error:
+ static
+ globus_result_t
+ globus_i_xio_mode_e_register_write(
+- globus_l_xio_mode_e_connection_handle_t *
++ globus_l_xio_mode_e_connection_handle_t *
+ connection_handle)
+ {
+ globus_l_xio_mode_e_handle_t * handle;
+@@ -2686,8 +2686,8 @@ globus_i_xio_mode_e_register_write(
+ header_size = sizeof(globus_l_xio_mode_e_header_t);
+ memset(header, 0, header_size);
+ GlobusXIOUtilIovTotalLength(
+- size,
+- connection_handle->requestor->iovec,
++ size,
++ connection_handle->requestor->iovec,
+ connection_handle->requestor->iovec_count);
+ globus_i_xio_mode_e_header_encode(header->count, size);
+ result = globus_xio_driver_data_descriptor_cntl(
+@@ -2699,7 +2699,7 @@ globus_i_xio_mode_e_register_write(
+ {
+ offset = handle->offset;
+ }
+- if (handle->state == GLOBUS_XIO_MODE_E_SENDING_EOD &&
++ if (handle->state == GLOBUS_XIO_MODE_E_SENDING_EOD &&
+ globus_fifo_empty(&handle->io_q))
+ {
+ header->descriptor = GLOBUS_XIO_MODE_E_DATA_DESCRIPTOR_EOD;
+@@ -2713,8 +2713,8 @@ globus_i_xio_mode_e_register_write(
+ handle->offset = offset;
+ }
+ result = globus_xio_register_write(
+- connection_handle->xio_handle,
+- (globus_byte_t*)header,
++ connection_handle->xio_handle,
++ (globus_byte_t*)header,
+ header_size,
+ header_size,
+ GLOBUS_NULL,
+@@ -2723,7 +2723,7 @@ globus_i_xio_mode_e_register_write(
+ if (result != GLOBUS_SUCCESS)
+ {
+ goto error;
+- }
++ }
+ if (header->descriptor & GLOBUS_XIO_MODE_E_DATA_DESCRIPTOR_EOD)
+ {
+ connection_handle->eod = GLOBUS_TRUE;
+@@ -2753,10 +2753,10 @@ globus_l_xio_mode_e_write(
+
+ GlobusXIOModeEDebugEnter();
+ handle = (globus_l_xio_mode_e_handle_t *) driver_specific_handle;
+- /*
++ /*
+ * Mode E is unidirectional. Server can only read and client can only write
+ */
+- globus_assert(handle->server == GLOBUS_NULL);
++ globus_assert(handle->server == GLOBUS_NULL);
+ dd = (globus_l_xio_mode_e_attr_t *)
+ globus_xio_operation_get_data_descriptor(op, GLOBUS_FALSE);
+ requestor = (globus_i_xio_mode_e_requestor_t *)
+@@ -2782,9 +2782,9 @@ globus_l_xio_mode_e_write(
+ switch (handle->state)
+ {
+ case GLOBUS_XIO_MODE_E_OPEN:
+- /*
++ /*
+ * I reset eods_sent here (and not right after i send all the eods)
+- * coz i use 'eods_sent == connection_count' in close to check if
++ * coz i use 'eods_sent == connection_count' in close to check if
+ * eods have been sent or not
+ */
+ if (handle->eods_sent == handle->connection_count)
+@@ -2811,7 +2811,7 @@ globus_l_xio_mode_e_write(
+ if (!globus_fifo_empty(&handle->connection_q))
+ {
+ globus_l_xio_mode_e_connection_handle_t *
+- connection_handle;
++ connection_handle;
+ connection_handle = (globus_l_xio_mode_e_connection_handle_t *)
+ globus_fifo_dequeue(&handle->connection_q);
+ connection_handle->requestor = requestor;
+@@ -2827,7 +2827,7 @@ globus_l_xio_mode_e_write(
+ descriptor = GLOBUS_XIO_MODE_E_DATA_DESCRIPTOR_EOD;
+ while (!globus_fifo_empty(&handle->connection_q))
+ {
+- connection_handle =
++ connection_handle =
+ (globus_l_xio_mode_e_connection_handle_t *)
+ globus_fifo_dequeue(&handle->connection_q);
+ globus_l_xio_mode_e_register_eod(
+@@ -2837,7 +2837,7 @@ globus_l_xio_mode_e_write(
+ }
+ else
+ {
+- if (handle->connection_count <
++ if (handle->connection_count <
+ handle->attr->max_connection_count)
+ {
+ result = globus_l_xio_mode_e_open_new_stream(
+@@ -2897,8 +2897,8 @@ globus_l_xio_mode_e_close_cb(
+ goto error;
+ }
+ if(globus_error_match(
+- globus_error_peek(result),
+- GLOBUS_XIO_MODULE,
++ globus_error_peek(result),
++ GLOBUS_XIO_MODULE,
+ GLOBUS_XIO_ERROR_CANCELED))
+ {
+ ++handle->close_count;
+@@ -2914,7 +2914,7 @@ globus_l_xio_mode_e_close_cb(
+ if (!globus_list_empty(handle->close_list))
+ {
+ globus_list_remove(
+- &handle->close_list,
++ &handle->close_list,
+ globus_list_search(handle->close_list, xio_handle));
+ }
+ }
+@@ -2973,7 +2973,7 @@ globus_l_xio_mode_e_write_eod_cb(
+ globus_l_xio_mode_e_connection_handle_t *
+ connection_handle;
+ globus_l_xio_mode_e_handle_t * handle;
+- globus_l_xio_mode_e_header_t * header;
++ globus_l_xio_mode_e_header_t * header;
+ globus_xio_operation_t op;
+ globus_off_t offset;
+ globus_bool_t finish = GLOBUS_FALSE;
+@@ -2991,18 +2991,18 @@ globus_l_xio_mode_e_write_eod_cb(
+ res = result;
+ goto error;
+ }
+- ++handle->eods_sent;
+- /*
+- * If CLOSE is set on header, then it implies that user has called
+- * close and I allow users to cancel close until all the channels are
++ ++handle->eods_sent;
++ /*
++ * If CLOSE is set on header, then it implies that user has called
++ * close and I allow users to cancel close until all the channels are
+ * closed
+ */
+ if (header->descriptor & GLOBUS_XIO_MODE_E_DATA_DESCRIPTOR_CLOSE)
+ {
+ /* I don't register_close, if user has canceled the close already */
+ if (!globus_error_match(
+- globus_error_peek(result),
+- GLOBUS_XIO_MODULE,
++ globus_error_peek(result),
++ GLOBUS_XIO_MODULE,
+ GLOBUS_XIO_ERROR_CANCELED))
+ {
+ res = globus_xio_register_close(
+@@ -3016,13 +3016,13 @@ globus_l_xio_mode_e_write_eod_cb(
+ }
+ globus_list_insert(
+ &handle->close_list, connection_handle->xio_handle);
+- /*
++ /*
+ * If it was canceled, then the xio_handle would have been removed
+ * from the eod_list before the canceling the write eod. So I do
+- * not have to this removal in the else below.
++ * not have to this removal in the else below.
+ */
+ globus_list_remove(
+- &handle->eod_list,
++ &handle->eod_list,
+ globus_list_search(
+ handle->eod_list, connection_handle->xio_handle));
+ }
+@@ -3039,10 +3039,10 @@ globus_l_xio_mode_e_write_eod_cb(
+ }
+ else
+ {
+- /*
++ /*
+ * getting here implies that register_eod (associated with this cb) is
+ * called in response to the dd 'SEND_EOD' on write
+- */
++ */
+ if (header->descriptor & GLOBUS_XIO_MODE_E_DATA_DESCRIPTOR_EOF)
+ {
+ handle->eof_sent = GLOBUS_TRUE;
+@@ -3059,17 +3059,17 @@ globus_l_xio_mode_e_write_eod_cb(
+ finish = GLOBUS_TRUE;
+ }
+ if (!globus_error_match(
+- globus_error_peek(result),
+- GLOBUS_XIO_MODULE,
++ globus_error_peek(result),
++ GLOBUS_XIO_MODULE,
+ GLOBUS_XIO_ERROR_CANCELED))
+ {
+ globus_list_remove(
+- &handle->eod_list,
++ &handle->eod_list,
+ globus_list_search(
+ handle->eod_list, connection_handle->xio_handle));
+ }
+-
+- }
++
++ }
+ globus_memory_push_node(&handle->header_memory, (void*)header);
+ globus_mutex_unlock(&handle->mutex);
+ if (finish)
+@@ -3143,7 +3143,7 @@ globus_l_xio_mode_e_register_eod(
+ return GLOBUS_SUCCESS;
+
+ error:
+- globus_memory_push_node(&handle->header_memory, (void*)header);
++ globus_memory_push_node(&handle->header_memory, (void*)header);
+ GlobusXIOModeEDebugExitWithError();
+ return result;
+ }
+@@ -3161,7 +3161,7 @@ globus_l_xio_mode_e_close_connections(
+ GlobusXIOName(globus_l_xio_mode_e_close_connections);
+
+ GlobusXIOModeEDebugEnter();
+- /*
++ /*
+ * handle->connection_list contains all the connections whereas the q's
+ * (connection_q, eod_q contain only those connections that are free (idle)
+ */
+@@ -3173,17 +3173,17 @@ globus_l_xio_mode_e_close_connections(
+ globus_fifo_remove(&handle->connection_q, connection_handle);
+ if (!idle_connection_handle)
+ {
+- idle_connection_handle =
++ idle_connection_handle =
+ (globus_l_xio_mode_e_connection_handle_t *)
+ globus_fifo_remove(&handle->eod_q, connection_handle);
+-
++
+ }
+ if (idle_connection_handle)
+ {
+ /* connection_handle and idle_connection_handle are same here */
+ globus_xio_register_close(
+- connection_handle->xio_handle,
+- NULL,
++ connection_handle->xio_handle,
++ NULL,
+ globus_l_xio_mode_e_close_cb,
+ connection_handle->mode_e_handle);
+ globus_list_insert(
+@@ -3219,7 +3219,7 @@ globus_l_xio_mode_e_close(
+
+ GlobusXIOModeEDebugEnter();
+ handle = (globus_l_xio_mode_e_handle_t *) driver_specific_handle;
+- attr = (globus_l_xio_mode_e_attr_t *)
++ attr = (globus_l_xio_mode_e_attr_t *)
+ driver_attr ? driver_attr : handle->attr;
+ requestor = (globus_i_xio_mode_e_requestor_t *)
+ globus_memory_pop_node(&handle->requestor_memory);
+@@ -3244,7 +3244,7 @@ globus_l_xio_mode_e_close(
+ descriptor = GLOBUS_XIO_MODE_E_DATA_DESCRIPTOR_CLOSE;
+ handle->state = GLOBUS_XIO_MODE_E_CLOSING;
+
+- /* this implies eods are not sent yet */
++ /* this implies eods are not sent yet */
+ if (handle->eods_sent != handle->connection_count)
+ {
+ descriptor |= GLOBUS_XIO_MODE_E_DATA_DESCRIPTOR_EOD;
+@@ -3308,7 +3308,7 @@ globus_l_xio_mode_e_close(
+ globus_xio_driver_finished_close(op, GLOBUS_SUCCESS);
+ }
+ GlobusXIOModeEDebugExit();
+- return GLOBUS_SUCCESS;
++ return GLOBUS_SUCCESS;
+
+ error_register_eod:
+ error_operation_canceled:
+@@ -3317,7 +3317,7 @@ error_operation_canceled:
+ error_cancel_enable:
+ globus_memory_push_node(&handle->requestor_memory, (void*)requestor);
+ GlobusXIOModeEDebugExitWithError();
+- return result;
++ return result;
+ }
+
+
+@@ -3359,8 +3359,8 @@ globus_l_xio_mode_e_cntl(
+ goto error;
+ default:
+ result = GlobusXIOErrorInvalidCommand(cmd);
+- goto error;
+- }
++ goto error;
++ }
+ GlobusXIOModeEDebugExit();
+ return GLOBUS_SUCCESS;
+
+@@ -3383,14 +3383,14 @@ globus_l_xio_mode_e_attr_init(
+ /*
+ * create a mode_e attr structure and intialize its values
+ */
+- attr = (globus_l_xio_mode_e_attr_t *)
++ attr = (globus_l_xio_mode_e_attr_t *)
+ globus_malloc(sizeof(globus_l_xio_mode_e_attr_t));
+ if(!attr)
+ {
+ result = GlobusXIOErrorMemory("attr");
+ goto error_attr;
+ }
+- memcpy(attr, &globus_l_xio_mode_e_attr_default,
++ memcpy(attr, &globus_l_xio_mode_e_attr_default,
+ sizeof(globus_l_xio_mode_e_attr_t));
+ *out_attr = attr;
+ GlobusXIOModeEDebugExit();
+@@ -3451,7 +3451,7 @@ globus_l_xio_mode_e_attr_cntl(
+ }
+ case GLOBUS_XIO_MODE_E_SET_MANUAL_EODC:
+ attr->manual_eodc = va_arg(ap, globus_bool_t);
+- break;
++ break;
+ case GLOBUS_XIO_MODE_E_GET_MANUAL_EODC:
+ {
+ globus_bool_t * manual_eodc_out = va_arg(ap, globus_bool_t*);
+@@ -3496,11 +3496,11 @@ globus_l_xio_mode_e_attr_cntl(
+ default:
+ result = GlobusXIOErrorInvalidCommand(cmd);
+ goto error;
+- }
++ }
+ GlobusXIOModeEDebugExit();
+ return GLOBUS_SUCCESS;
+
+-error:
++error:
+ GlobusXIOModeEDebugExitWithError();
+ return result;
+ }
+@@ -3518,7 +3518,7 @@ globus_l_xio_mode_e_attr_copy(
+ GlobusXIOName(globus_l_xio_mode_e_attr_copy);
+
+ GlobusXIOModeEDebugEnter();
+- dst_attr = (globus_l_xio_mode_e_attr_t *)
++ dst_attr = (globus_l_xio_mode_e_attr_t *)
+ globus_malloc(sizeof(globus_l_xio_mode_e_attr_t));
+ if(!dst_attr)
+ {
+@@ -3526,7 +3526,7 @@ globus_l_xio_mode_e_attr_copy(
+ goto error_dst_attr;
+ }
+ src_attr = (globus_l_xio_mode_e_attr_t *) src;
+- memcpy(dst_attr, src_attr, sizeof(globus_l_xio_mode_e_attr_t));
++ memcpy(dst_attr, src_attr, sizeof(globus_l_xio_mode_e_attr_t));
+ if(src_attr->stack != NULL)
+ {
+ globus_xio_stack_copy(&dst_attr->stack, src_attr->stack);
+diff --git a/xio/src/globus_xio_driver.c b/xio/src/globus_xio_driver.c
+index a267b0806..18503394e 100644
+--- a/xio/src/globus_xio_driver.c
++++ b/xio/src/globus_xio_driver.c
+@@ -64,7 +64,7 @@ globus_l_xio_op_restarted(
+ {
+ globus_i_xio_handle_destroy(handle);
+ }
+-
++
+ GlobusXIODebugInternalExit();
+ }
+
+@@ -152,7 +152,7 @@ globus_i_xio_repass_read(
+ return res;
+ }
+
+-void
++void
+ globus_i_xio_pass_failed(
+ globus_i_xio_op_t * op,
+ globus_i_xio_context_entry_t * my_context,
+@@ -244,7 +244,7 @@ globus_i_xio_handle_destroy(
+ GlobusXIODebugInternalExit();
+ }
+
+-/*
++/*
+ * called in the context lock
+ */
+ void
+@@ -260,7 +260,7 @@ globus_i_xio_handle_dec(
+
+ *destroy_handle = GLOBUS_FALSE;
+
+- handle->ref--;
++ handle->ref--;
+ GlobusXIODebugPrintf(
+ GLOBUS_XIO_DEBUG_INFO_VERBOSE,
+ (_XIOSL("[globus_i_xio_handle_dec] :: handle ref at %d.\n"), handle->ref));
+@@ -291,8 +291,8 @@ globus_i_xio_handle_dec(
+ GlobusXIODebugInternalExit();
+ }
+
+-/*
+- * called locked
++/*
++ * called locked
+ */
+ void
+ globus_i_xio_op_destroy(
+@@ -333,7 +333,7 @@ globus_i_xio_op_destroy(
+ op->entry[ctr].close_attr = NULL;
+ }
+ }
+-
++
+ if(op->user_open_sbj)
+ {
+ globus_free(op->user_open_sbj);
+@@ -381,7 +381,7 @@ globus_i_xio_driver_resume_op(
+ case GLOBUS_XIO_OPERATION_TYPE_WRITE:
+ globus_l_xio_driver_op_write_kickout(op);
+ break;
+-
++
+ case GLOBUS_XIO_OPERATION_TYPE_CLOSE:
+ globus_l_xio_driver_op_close_kickout(op);
+ break;
+@@ -456,7 +456,7 @@ globus_i_xio_will_block_cb(
+ {
+ GlobusXIOOpInc(op);
+ deliver_type = *op->entry[ndx].deliver_type;
+- *op->entry[ndx].deliver_type =
++ *op->entry[ndx].deliver_type =
+ GLOBUS_XIO_OPERATION_TYPE_FINISHED;
+ op->entry[ndx].deliver_type = NULL;
+ }
+@@ -535,7 +535,7 @@ globus_l_xio_driver_op_write_kickout(
+ GlobusIXIOClearCancel(op);
+
+ /*
+- * before releasing the op back to the user we can safely set this
++ * before releasing the op back to the user we can safely set this
+ * outside of a mutex. Once the users callbcak is called the value
+ * on the local stack may be changed, theus the magic.
+ */
+@@ -554,20 +554,20 @@ globus_l_xio_driver_op_write_kickout(
+
+ my_op->_op_ent_data_cb(op, GlobusXIOObjToResult(op->cached_obj),
+ my_op->_op_ent_nbytes, my_op->user_arg);
+-
++
+ globus_thread_blocking_callback_pop(&wb_ndx);
+ }
+ else
+ {
+ if(my_op->_op_ent_data_cb == NULL)
+ {
+- globus_xio_driver_finished_write(op,
+- GlobusXIOObjToResult(op->cached_obj),
++ globus_xio_driver_finished_write(op,
++ GlobusXIOObjToResult(op->cached_obj),
+ my_op->_op_ent_nbytes);
+ }
+ else
+ {
+- my_op->_op_ent_data_cb(op,
++ my_op->_op_ent_data_cb(op,
+ GlobusXIOObjToResult(op->cached_obj),
+ my_op->_op_ent_nbytes, my_op->user_arg);
+ }
+@@ -576,8 +576,8 @@ globus_l_xio_driver_op_write_kickout(
+ globus_xio_driver_write_delivered(op, ndx, &deliver_type);
+
+ GlobusXIODebugInternalExit();
+-}
+-
++}
++
+ void
+ globus_l_xio_driver_op_read_kickout(
+ void * user_arg)
+@@ -600,9 +600,9 @@ globus_l_xio_driver_op_read_kickout(
+ handle = op->_op_handle;
+
+ GlobusIXIOClearCancel(op);
+-
++
+ /*
+- * before releasing the op back to the user we can safely set this
++ * before releasing the op back to the user we can safely set this
+ * outside of a mutex. Once the users callbcak is called the value
+ * on the local stack may be changed, theus the magic.
+ */
+@@ -621,20 +621,20 @@ globus_l_xio_driver_op_read_kickout(
+
+ my_op->_op_ent_data_cb(op, GlobusXIOObjToResult(op->cached_obj),
+ my_op->_op_ent_nbytes, my_op->user_arg);
+-
++
+ globus_thread_blocking_callback_pop(&wb_ndx);
+ }
+ else
+ {
+ if(my_op->_op_ent_data_cb == NULL)
+ {
+- globus_xio_driver_finished_read(op,
+- GlobusXIOObjToResult(op->cached_obj),
++ globus_xio_driver_finished_read(op,
++ GlobusXIOObjToResult(op->cached_obj),
+ my_op->_op_ent_nbytes);
+ }
+ else
+ {
+- my_op->_op_ent_data_cb(op,
++ my_op->_op_ent_data_cb(op,
+ GlobusXIOObjToResult(op->cached_obj),
+ my_op->_op_ent_nbytes, my_op->user_arg);
+ }
+@@ -643,8 +643,8 @@ globus_l_xio_driver_op_read_kickout(
+ globus_xio_driver_read_delivered(op, ndx, &deliver_type);
+
+ GlobusXIODebugInternalExit();
+-}
+-
++}
++
+ void
+ globus_l_xio_driver_purge_read_eof(
+ globus_i_xio_context_entry_t * my_context)
+@@ -655,7 +655,7 @@ globus_l_xio_driver_purge_read_eof(
+ GlobusXIODebugInternalEnter();
+ while(!globus_list_empty(my_context->eof_op_list))
+ {
+- /* we can only get here if a eof has been received */
++ /* we can only get here if a eof has been received */
+ globus_assert(my_context->state ==
+ GLOBUS_XIO_CONTEXT_STATE_EOF_RECEIVED ||
+ my_context->state ==
+@@ -728,7 +728,7 @@ globus_i_xio_driver_start_close(
+ globus_xio_driver_finished_close(op, res);
+ my_op->in_register = GLOBUS_FALSE;
+ }
+-
++
+ if((res == GLOBUS_SUCCESS || !can_fail) && my_op->prev_ndx == 0)
+ {
+ while(op->finished_delayed)
+@@ -746,7 +746,7 @@ globus_i_xio_driver_start_close(
+ {
+ globus_i_xio_op_destroy(op, &destroy_handle);
+ }
+-
++
+ context->ref--;
+ if(context->ref == 0)
+ {
+@@ -761,7 +761,7 @@ globus_i_xio_driver_start_close(
+ }
+ if(destroy_context)
+ {
+- /* the only way we'll be destroying the context is if this was a
++ /* the only way we'll be destroying the context is if this was a
+ * driver op and the handle no longer exists
+ */
+ globus_assert(!destroy_handle);
+@@ -820,19 +820,19 @@ globus_l_xio_driver_op_accept_kickout(
+ globus_i_xio_op_t * op;
+ globus_i_xio_op_entry_t * my_op;
+ GlobusXIOName(globus_l_xio_driver_op_accept_kickout);
+-
++
+ GlobusXIODebugInternalEnter();
+ op = (globus_i_xio_op_t *) user_arg;
+-
++
+ my_op = &op->entry[op->ndx - 1];
+ op->ndx = my_op->prev_ndx;
+-
++
+ /* driver's can't cancel accept ops yet, dont need this
+ * this call only works for regular ops, anyway
+- *
++ *
+ GlobusIXIOClearCancel(op);
+ */
+-
++
+ if(my_op->cb != NULL)
+ {
+ my_op->cb(
+@@ -860,7 +860,7 @@ globus_l_xio_driver_open_op_kickout(
+ globus_i_xio_op_t * op;
+ globus_xio_operation_type_t deliver_type;
+ GlobusXIOName(globus_l_xio_driver_open_op_kickout);
+-
++
+ GlobusXIODebugInternalEnter();
+
+ op = (globus_i_xio_op_t *) user_arg;
+@@ -891,12 +891,12 @@ globus_l_xio_driver_open_op_kickout(
+ {
+ if(my_op->cb == NULL)
+ {
+- globus_xio_driver_finished_open(NULL, op,
++ globus_xio_driver_finished_open(NULL, op,
+ GlobusXIOObjToResult(op->cached_obj));
+ }
+ else
+ {
+- my_op->cb(op,
++ my_op->cb(op,
+ GlobusXIOObjToResult(op->cached_obj), my_op->user_arg);
+ }
+ }
+@@ -922,15 +922,15 @@ globus_i_xio_context_destroy(
+ globus_assert(xio_context->ref == 0);
+
+ GlobusXIODebugPrintf(
+- GLOBUS_XIO_DEBUG_INFO_VERBOSE,
+- (_XIOSL(" context @ 0x%x: ref=%d size=%d\n"),
++ GLOBUS_XIO_DEBUG_INFO_VERBOSE,
++ (_XIOSL(" context @ 0x%x: ref=%d size=%d\n"),
+ xio_context, xio_context->ref, xio_context->stack_size));
+-
++
+ for(ctr = 0; ctr < xio_context->stack_size; ctr++)
+ {
+ globus_fifo_destroy(&xio_context->entry[ctr].pending_read_queue);
+ }
+-
++
+ globus_mutex_destroy(&xio_context->mutex);
+ globus_mutex_destroy(&xio_context->cancel_mutex);
+ globus_memory_destroy(&xio_context->op_memory);
+@@ -1000,7 +1000,7 @@ globus_i_xio_attr_get_ds(
+ /*
+ * read ahead stuff
+ */
+-void
++void
+ globus_xio_driver_operation_destroy(
+ globus_xio_operation_t operation)
+ {
+@@ -1060,16 +1060,16 @@ globus_xio_driver_operation_create(
+ index++)
+ {
+ }
+-
++
+ if(index == context->stack_size)
+ {
+ res = GlobusXIOErrorParameter("driver_handle");
+ goto err;
+ }
+-
++
+ /* driver_handles are to the drivers below the current one */
+ index--;
+-
++
+ GlobusXIOOperationCreate(op, context);
+ if(op == NULL)
+ {
+@@ -1090,7 +1090,7 @@ globus_xio_driver_operation_create(
+ my_op->_op_ent_wait_for = 0;
+ my_op->prev_ndx = -1;
+ my_op->type = GLOBUS_XIO_OPERATION_TYPE_DRIVER;
+-
++
+ globus_mutex_lock(&context->mutex);
+ context->ref++;
+ globus_mutex_unlock(&context->mutex);
+@@ -1147,12 +1147,12 @@ globus_i_xio_driver_attr_cntl(
+ attr->ndx++;
+ }
+
+- /* if the driver is capable of parsing the strings
++ /* if the driver is capable of parsing the strings
+ and this is the string parser command, if there is
+ no table defined the SET_STRING command will be passed
+ to the driver. this is fine. they may want to parse it
+ in their own way */
+- if(driver->string_table != NULL &&
++ if(driver->string_table != NULL &&
+ cmd == GLOBUS_XIO_SET_STRING_OPTIONS)
+ {
+ char * opt_str;
+@@ -1174,7 +1174,7 @@ globus_i_xio_driver_attr_cntl(
+ {
+ res = driver->attr_cntl_func(ds, cmd, ap);
+ }
+-
++
+ if(res != GLOBUS_SUCCESS)
+ {
+ goto err;
+@@ -1295,7 +1295,7 @@ globus_i_xio_driver_attr_cntl(
+ tmp_str = va_arg(ap, char *);
+ attr->user_open_pw = globus_libc_strdup(tmp_str);
+ break;
+-
++
+ default:
+ res = GlobusXIOErrorInvalidCommand(general_cmd);
+ goto err;
+@@ -1339,7 +1339,7 @@ globus_i_xio_driver_dd_cntl(
+ {
+ if(op->entry[ctr].open_attr == NULL)
+ {
+- res =
++ res =
+ op->_op_server->entry[ctr].driver->attr_init_func(
+ &op->entry[ctr].open_attr);
+ }
+@@ -1355,7 +1355,7 @@ globus_i_xio_driver_dd_cntl(
+ case GLOBUS_XIO_OPERATION_TYPE_OPEN:
+ if(op->entry[ctr].open_attr == NULL)
+ {
+- res =
++ res =
+ op->_op_context->entry[ctr].driver->attr_init_func(
+ &op->entry[ctr].open_attr);
+ }
+@@ -1365,7 +1365,7 @@ globus_i_xio_driver_dd_cntl(
+ case GLOBUS_XIO_OPERATION_TYPE_CLOSE:
+ if(op->entry[ctr].close_attr == NULL)
+ {
+- res =
++ res =
+ op->_op_context->entry[ctr].driver->attr_init_func(
+ &op->entry[ctr].close_attr);
+ }
+@@ -1375,7 +1375,7 @@ globus_i_xio_driver_dd_cntl(
+ default:
+ if(op->entry[ctr].dd == NULL)
+ {
+- res =
++ res =
+ op->_op_context->entry[ctr].driver->attr_init_func(
+ &op->entry[ctr].dd);
+ }
+@@ -1408,16 +1408,16 @@ globus_i_xio_driver_dd_cntl(
+
+ if (attr_cntl_func)
+ {
+- /* if the driver is capable of parsing the strings
++ /* if the driver is capable of parsing the strings
+ and this is the string parser command, if there is
+ no table defined the SET_STRING command will be passed
+ to the driver. this is fine. they may want to parse it
+ in their own way */
+- if(driver->string_table != NULL &&
++ if(driver->string_table != NULL &&
+ cmd == GLOBUS_XIO_SET_STRING_OPTIONS)
+ {
+ char * opt_str;
+-
++
+ opt_str = va_arg(ap, char *);
+ res = globus_i_xio_string_cntl_parser(
+ opt_str,
+@@ -1453,7 +1453,7 @@ globus_i_xio_driver_dd_cntl(
+ else
+ {
+ globus_off_t * out_offt;
+-
++
+ /* could end up here with non-dd attr cntls... none supported at driver
+ * level yet, so no biggie
+ */
+@@ -1462,12 +1462,12 @@ globus_i_xio_driver_dd_cntl(
+ case GLOBUS_XIO_DD_SET_OFFSET:
+ op->_op_ent_offset = va_arg(ap, globus_off_t);
+ break;
+-
++
+ case GLOBUS_XIO_DD_GET_OFFSET:
+ out_offt = va_arg(ap, globus_off_t *);
+ *out_offt = op->_op_ent_offset;
+ break;
+-
++
+ default:
+ res = GlobusXIOErrorInvalidCommand(cmd);
+ goto err;
+@@ -1593,7 +1593,7 @@ globus_i_xio_driver_handle_cntl(
+ for(ctr = start_ndx; ctr < context->stack_size; ctr++)
+ {
+ called = GLOBUS_FALSE;
+-
++
+ if(driver == context->entry[ctr].driver ||
+ driver == GLOBUS_XIO_QUERY)
+ {
+@@ -1609,7 +1609,7 @@ globus_i_xio_driver_handle_cntl(
+ ap);
+ called = GLOBUS_TRUE;
+ }
+- else if(context->entry[ctr].state !=
++ else if(context->entry[ctr].state !=
+ GLOBUS_XIO_CONTEXT_STATE_NONE &&
+ context->entry[ctr].driver->handle_cntl_func)
+ {
+@@ -1619,12 +1619,12 @@ globus_i_xio_driver_handle_cntl(
+ ap);
+ called = GLOBUS_TRUE;
+ }
+-
++
+ if(called && res == GLOBUS_SUCCESS)
+ {
+ break;
+ }
+-
++
+ if(driver == GLOBUS_XIO_QUERY)
+ {
+ if(called && res != GLOBUS_SUCCESS &&
+@@ -1639,7 +1639,7 @@ globus_i_xio_driver_handle_cntl(
+ res = GlobusXIOErrorInvalidDriver(
+ _XIOSL("handle_cntl not supported"));
+ }
+-
++
+ if(res != GLOBUS_SUCCESS)
+ {
+ goto err;
+@@ -1723,7 +1723,7 @@ globus_xio_driver_merge_handle(
+ goto err;
+ }
+ dst_context->entry[ctr].whos_my_daddy = dst_context;
+- dst_context->entry[ctr].driver_handle =
++ dst_context->entry[ctr].driver_handle =
+ src_context->entry[ctr].driver_handle;
+
+ GlobusXIOContextStateChange(&dst_context->entry[ctr],
+@@ -1774,7 +1774,7 @@ globus_xio_driver_handle_cntl(
+ {
+ }
+ }
+-
++
+ res = globus_i_xio_driver_handle_cntl(context, start_ndx, driver, cmd, ap);
+ va_end(ap);
+ if(res != GLOBUS_SUCCESS)
+@@ -1818,22 +1818,22 @@ globus_xio_driver_operation_cancel(
+ source_ndx++)
+ {
+ }
+-
++
+ if(source_ndx == context->stack_size)
+ {
+ res = GlobusXIOErrorParameter("driver_handle");
+ goto err;
+ }
+-
++
+ /* driver_handles are to the drivers below the current one */
+ source_ndx--;
+-
++
+ globus_mutex_lock(&context->cancel_mutex);
+ {
+ res = globus_i_xio_operation_cancel(op, source_ndx);
+ }
+ globus_mutex_unlock(&context->cancel_mutex);
+-
++
+ GlobusXIODebugExit();
+ return GLOBUS_SUCCESS;
+
+@@ -1853,10 +1853,10 @@ globus_xio_driver_set_eof_received(
+ GlobusXIOName(globus_xio_driver_set_eof_received);
+
+ GlobusXIODebugEnter();
+-
++
+ context = op->_op_context;
+ my_context = &context->entry[op->entry[op->ndx - 1].prev_ndx];
+-
++
+ globus_mutex_lock(&context->mutex);
+ {
+ globus_assert(
+@@ -1865,9 +1865,9 @@ globus_xio_driver_set_eof_received(
+ globus_assert(
+ my_context->state == GLOBUS_XIO_CONTEXT_STATE_OPEN ||
+ my_context->state == GLOBUS_XIO_CONTEXT_STATE_EOF_RECEIVED ||
+- my_context->state ==
++ my_context->state ==
+ GLOBUS_XIO_CONTEXT_STATE_EOF_RECEIVED_AND_CLOSING);
+-
++
+ if(my_context->state == GLOBUS_XIO_CONTEXT_STATE_OPEN)
+ {
+ GlobusXIOContextStateChange(my_context,
+@@ -1875,7 +1875,7 @@ globus_xio_driver_set_eof_received(
+ }
+ }
+ globus_mutex_unlock(&context->mutex);
+-
++
+ GlobusXIODebugExit();
+ }
+
+@@ -1889,10 +1889,10 @@ globus_xio_driver_eof_received(
+ GlobusXIOName(globus_xio_driver_eof_received);
+
+ GlobusXIODebugEnter();
+-
++
+ context = op->_op_context;
+ my_context = &context->entry[op->entry[op->ndx - 1].prev_ndx];
+-
++
+ globus_mutex_lock(&context->mutex);
+ {
+ globus_assert(
+@@ -1901,20 +1901,20 @@ globus_xio_driver_eof_received(
+ globus_assert(
+ my_context->state == GLOBUS_XIO_CONTEXT_STATE_OPEN ||
+ my_context->state == GLOBUS_XIO_CONTEXT_STATE_EOF_RECEIVED ||
+- my_context->state ==
++ my_context->state ==
+ GLOBUS_XIO_CONTEXT_STATE_EOF_RECEIVED_AND_CLOSING);
+-
++
+ if(my_context->state == GLOBUS_XIO_CONTEXT_STATE_EOF_RECEIVED ||
+- my_context->state ==
++ my_context->state ==
+ GLOBUS_XIO_CONTEXT_STATE_EOF_RECEIVED_AND_CLOSING)
+ {
+ received = GLOBUS_TRUE;
+ }
+ }
+ globus_mutex_unlock(&context->mutex);
+-
++
+ GlobusXIODebugExit();
+-
++
+ return received;
+ }
+
+@@ -1942,7 +1942,7 @@ globus_xio_driver_init(
+ goto err;
+ }
+ memset(driver, '\0', sizeof(globus_i_xio_driver_t));
+-
++
+ driver->name = globus_libc_strdup(driver_name);
+ if(!driver->name)
+ {
+@@ -1950,7 +1950,7 @@ globus_xio_driver_init(
+ res = GlobusXIOErrorMemory("driver->name");
+ goto err;
+ }
+-
++
+ driver->user_data = user_data;
+
+ *out_driver = driver;
+@@ -2089,7 +2089,7 @@ globus_xio_driver_set_server(
+ * @details
+ * This function adds a callback to a driver that will be called before
+ * a server handle is created by XIO. This function has the same signature
+- * as the server_init_func in the driver, but is always called with a
++ * as the server_init_func in the driver, but is always called with a
+ * NULL contact string. There is no support for calling a pass() or finished()
+ * function for this interface. It may inspect and modify its attributes
+ * and operation, but can not directly return any data or set a driver-specific
+@@ -2269,7 +2269,7 @@ globus_xio_operation_enable_cancel(
+ {
+ mutex = &op->_op_context->cancel_mutex;
+ }
+-
++
+ globus_mutex_lock(mutex);
+ {
+ already_canceled = op->canceled != 0;
+@@ -2280,7 +2280,7 @@ globus_xio_operation_enable_cancel(
+ }
+ }
+ globus_mutex_unlock(mutex);
+-
++
+ return already_canceled;
+ }
+
+@@ -2298,7 +2298,7 @@ globus_xio_operation_disable_cancel(
+ {
+ mutex = &op->_op_context->cancel_mutex;
+ }
+-
++
+ globus_mutex_lock(mutex);
+ {
+ op->cancel_cb = NULL;
+@@ -2400,7 +2400,7 @@ globus_xio_operation_attr_cntl(
+ gss_cred_id_t * out_cred;
+ va_list ap;
+ GlobusXIOName(globus_xio_operation_attr_cntl);
+-
++
+ if(op == NULL)
+ {
+ result = GlobusXIOErrorParameter("op");
+@@ -2465,7 +2465,7 @@ globus_xio_operation_get_data_descriptor(
+ op->entry[op->ndx - 1].dd = NULL;
+ }
+ }
+-
++
+ return op->entry[op->ndx - 1].dd;
+ }
+
+@@ -2488,14 +2488,14 @@ globus_xio_operation_copy_stack(
+ {
+ goto error_init;
+ }
+-
++
+ istack = *stack;
+-
++
+ switch(op->type)
+ {
+ case GLOBUS_XIO_OPERATION_TYPE_SERVER_INIT:
+ server = op->_op_server;
+-
++
+ for(ndx = op->stack_size - 1; ndx > op->ndx; ndx--)
+ {
+ istack->size++;
+@@ -2503,10 +2503,10 @@ globus_xio_operation_copy_stack(
+ &istack->driver_stack, server->entry[ndx].driver);
+ }
+ break;
+-
++
+ case GLOBUS_XIO_OPERATION_TYPE_ACCEPT:
+ server = op->_op_server;
+-
++
+ for(ndx = op->stack_size - 1; ndx >= op->ndx; ndx--)
+ {
+ istack->size++;
+@@ -2514,10 +2514,10 @@ globus_xio_operation_copy_stack(
+ &istack->driver_stack, server->entry[ndx].driver);
+ }
+ break;
+-
++
+ default:
+ context = op->_op_context;
+-
++
+ for(ndx = op->stack_size - 1; ndx >= op->ndx; ndx--)
+ {
+ istack->size++;
+@@ -2526,10 +2526,10 @@ globus_xio_operation_copy_stack(
+ }
+ break;
+ }
+-
++
+ GlobusXIODebugExit();
+ return GLOBUS_SUCCESS;
+-
++
+ error_init:
+ GlobusXIODebugExitWithError();
+ return result;
+diff --git a/xio/src/globus_xio_system_select.c b/xio/src/globus_xio_system_select.c
+index dd1d5eff0..b2cd56475 100644
+--- a/xio/src/globus_xio_system_select.c
++++ b/xio/src/globus_xio_system_select.c
+@@ -157,7 +157,7 @@ globus_l_xio_system_wakeup_handler(
+ GlobusXIOName(globus_l_xio_system_wakeup_handler);
+
+ GlobusXIOSystemDebugEnter();
+-
++
+ if(!globus_l_xio_system_shutdown_called)
+ {
+ byte = 0;
+@@ -167,7 +167,7 @@ globus_l_xio_system_wakeup_handler(
+ globus_l_xio_system_wakeup_pipe[1], &byte, sizeof(byte));
+ } while(rc < 0 && errno == EINTR);
+ }
+-
++
+ GlobusXIOSystemDebugExit();
+ }
+
+@@ -180,12 +180,12 @@ globus_l_xio_system_activate(void)
+ globus_result_t result;
+ globus_reltime_t period;
+ GlobusXIOName(globus_l_xio_system_activate);
+-
++
+ if(globus_i_xio_system_common_activate() != GLOBUS_SUCCESS)
+ {
+ goto error_activate;
+ }
+-
++
+ GlobusXIOSystemDebugEnter();
+
+ globus_cond_init(&globus_l_xio_system_cond, GLOBUS_NULL);
+@@ -245,7 +245,7 @@ globus_l_xio_system_activate(void)
+ }
+ fcntl(globus_l_xio_system_wakeup_pipe[0], F_SETFD, FD_CLOEXEC);
+ fcntl(globus_l_xio_system_wakeup_pipe[1], F_SETFD, FD_CLOEXEC);
+-
++
+ globus_l_xio_system_highest_fd = globus_l_xio_system_wakeup_pipe[0];
+ FD_SET(globus_l_xio_system_wakeup_pipe[0], globus_l_xio_system_read_fds);
+
+@@ -262,7 +262,7 @@ globus_l_xio_system_activate(void)
+ "globus_callback_register_periodic", result);
+ goto error_register;
+ }
+-
++
+ globus_callback_add_wakeup_handler(
+ globus_l_xio_system_wakeup_handler, GLOBUS_NULL);
+
+@@ -283,7 +283,7 @@ error_fdsets:
+ globus_mutex_destroy(&globus_l_xio_system_cancel_mutex);
+ globus_mutex_destroy(&globus_l_xio_system_fdset_mutex);
+ globus_cond_destroy(&globus_l_xio_system_cond);
+-
++
+ GlobusXIOSystemDebugExitWithError();
+ globus_i_xio_system_common_deactivate();
+ error_activate:
+@@ -297,9 +297,9 @@ globus_l_xio_system_unregister_periodic_cb(
+ {
+ globus_bool_t * signaled;
+ GlobusXIOName(globus_l_xio_system_unregister_periodic_cb);
+-
++
+ GlobusXIOSystemDebugEnter();
+-
++
+ signaled = (globus_bool_t *) user_args;
+ globus_mutex_lock(&globus_l_xio_system_fdset_mutex);
+ {
+@@ -322,7 +322,7 @@ globus_l_xio_system_deactivate(void)
+ globus_mutex_lock(&globus_l_xio_system_fdset_mutex);
+ {
+ globus_bool_t signaled;
+-
++
+ globus_l_xio_system_shutdown_called = GLOBUS_TRUE;
+ signaled = GLOBUS_FALSE;
+ globus_callback_unregister(
+@@ -354,7 +354,7 @@ globus_l_xio_system_deactivate(void)
+ globus_cond_destroy(&globus_l_xio_system_cond);
+
+ GlobusXIOSystemDebugExit();
+-
++
+ globus_i_xio_system_common_deactivate();
+
+ return GLOBUS_SUCCESS;
+@@ -381,25 +381,25 @@ globus_l_xio_system_handle_init(
+ result = GlobusXIOErrorMemory("handle");
+ goto error_alloc;
+ }
+-
++
+ handle->type = type;
+ handle->fd = fd;
+-
++
+ handle->file_position = globus_xio_system_file_get_position(fd);
+-
++
+ rc = globus_l_xio_system_add_nonblocking(handle);
+ if(rc < 0)
+ {
+ result = GlobusXIOErrorSystemError("fcntl", errno);
+ goto error_fcntl;
+ }
+-
++
+ globus_mutex_init(&handle->lock, NULL);
+-
++
+ *u_handle = handle;
+ GlobusXIOSystemDebugExitFD(fd);
+ return GLOBUS_SUCCESS;
+-
++
+ error_fcntl:
+ globus_free(handle);
+ error_alloc:
+@@ -439,7 +439,7 @@ globus_l_xio_system_handle_destroy(
+
+ globus_l_xio_system_remove_nonblocking(handle);
+ globus_free(handle);
+-
++
+ GlobusXIOSystemDebugExitFD(fd);
+ }
+
+@@ -473,21 +473,21 @@ globus_l_xio_system_cancel_cb(
+
+ globus_mutex_lock(&globus_l_xio_system_cancel_mutex);
+ {
+- if(op_info->state != GLOBUS_I_XIO_SYSTEM_OP_COMPLETE &&
++ if(op_info->state != GLOBUS_I_XIO_SYSTEM_OP_COMPLETE &&
+ op_info->state != GLOBUS_I_XIO_SYSTEM_OP_CANCELED)
+ {
+ op_info->error = reason == GLOBUS_XIO_ERROR_TIMEOUT
+ ? GlobusXIOErrorObjTimeout()
+ : GlobusXIOErrorObjCanceled();
+-
++
+ globus_mutex_lock(&globus_l_xio_system_fdset_mutex);
+ {
+ globus_bool_t pend;
+-
++
+ if(op_info->state == GLOBUS_I_XIO_SYSTEM_OP_NEW)
+ {
+ op_info->state = GLOBUS_I_XIO_SYSTEM_OP_CANCELED;
+-
++
+ GlobusXIOSystemDebugPrintf(
+ GLOBUS_I_XIO_SYSTEM_DEBUG_INFO,
+ (_XIOSL("[%s] fd=%d, Canceling NEW\n"),
+@@ -498,12 +498,12 @@ globus_l_xio_system_cancel_cb(
+ if(globus_l_xio_system_select_active)
+ {
+ op_info->state = GLOBUS_I_XIO_SYSTEM_OP_CANCELED;
+-
++
+ GlobusXIOSystemDebugPrintf(
+ GLOBUS_I_XIO_SYSTEM_DEBUG_INFO,
+ (_XIOSL("[%s] fd=%d, Canceling Active\n"),
+ _xio_name, op_info->handle->fd));
+-
++
+ /* pend the cancel for after select wakes up */
+ if(!globus_l_xio_system_wakeup_pending)
+ {
+@@ -518,12 +518,12 @@ globus_l_xio_system_cancel_cb(
+ globus_result_t result;
+
+ op_info->state = GLOBUS_I_XIO_SYSTEM_OP_COMPLETE;
+-
++
+ GlobusXIOSystemDebugPrintf(
+ GLOBUS_I_XIO_SYSTEM_DEBUG_INFO,
+ (_XIOSL("[%s] fd=%d, Canceling Pending\n"),
+ _xio_name, op_info->handle->fd));
+-
++
+ /* unregister and kickout now */
+ result = globus_callback_register_oneshot(
+ GLOBUS_NULL,
+@@ -621,7 +621,7 @@ globus_l_xio_system_register_read_fd(
+ result = GlobusXIOErrorNotActivated();
+ goto error_deactivated;
+ }
+-
++
+ if(fd >= globus_l_xio_system_max_fds)
+ {
+ result = GlobusXIOErrorSystemResource(_XIOSL("too many fds"));
+@@ -661,7 +661,7 @@ globus_l_xio_system_register_read_fd(
+ */
+ globus_l_xio_system_select_wakeup();
+ }
+-
++
+ GlobusXIOSystemDebugExitFD(fd);
+ return GLOBUS_SUCCESS;
+
+@@ -706,13 +706,13 @@ globus_l_xio_system_register_write_fd(
+ result = globus_error_put(write_info->error);
+ goto error_canceled;
+ }
+-
++
+ if(globus_l_xio_system_shutdown_called)
+ {
+ result = GlobusXIOErrorNotActivated();
+ goto error_deactivated;
+ }
+-
++
+ if(fd >= globus_l_xio_system_max_fds)
+ {
+ result = GlobusXIOErrorSystemResource(_XIOSL("too many fds"));
+@@ -743,7 +743,7 @@ globus_l_xio_system_register_write_fd(
+ write_info->state = GLOBUS_I_XIO_SYSTEM_OP_PENDING;
+ }
+ globus_mutex_unlock(&globus_l_xio_system_fdset_mutex);
+-
++
+ if(do_wakeup)
+ {
+ /* I do this outside the lock because the select thread is likely
+@@ -752,7 +752,7 @@ globus_l_xio_system_register_write_fd(
+ */
+ globus_l_xio_system_select_wakeup();
+ }
+-
++
+ GlobusXIOSystemDebugExitFD(fd);
+ return GLOBUS_SUCCESS;
+
+@@ -885,7 +885,7 @@ globus_l_xio_system_kickout(
+ op_info->sop.data.start_iov);
+ break;
+ }
+-
++
+ GlobusXIOSystemDebugExitFD(fd);
+ GlobusIXIOSystemFreeOperation(op_info);
+ }
+@@ -899,7 +899,7 @@ globus_l_xio_system_select_wakeup(void)
+ GlobusXIOName(globus_l_xio_system_select_wakeup);
+
+ GlobusXIOSystemDebugEnter();
+-
++
+ byte = 0;
+
+ do
+@@ -993,7 +993,7 @@ globus_l_xio_system_handle_read(
+ tmp_handle.type = GLOBUS_XIO_SYSTEM_TCP;
+
+ rc = globus_l_xio_system_remove_nonblocking(&tmp_handle);
+-
++
+ read_info->nbytes++;
+ GlobusXIOSystemDebugPrintf(
+ GLOBUS_I_XIO_SYSTEM_DEBUG_INFO,
+@@ -1026,12 +1026,12 @@ globus_l_xio_system_handle_read(
+ return GLOBUS_FALSE;
+ break;
+ }
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ read_info->error = globus_error_get(result);
+ }
+-
++
+ /* always true for accept operations */
+ if(read_info->nbytes >= read_info->waitforbytes ||
+ result != GLOBUS_SUCCESS)
+@@ -1133,12 +1133,12 @@ globus_l_xio_system_handle_write(
+ return GLOBUS_FALSE;
+ break;
+ }
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ write_info->error = globus_error_get(result);
+ }
+-
++
+ /* always true for connect operations */
+ if(write_info->nbytes >= write_info->waitforbytes ||
+ result != GLOBUS_SUCCESS)
+@@ -1186,7 +1186,7 @@ globus_l_xio_system_bad_apple(void)
+ GlobusXIOName(globus_l_xio_system_bad_apple);
+
+ GlobusXIOSystemDebugEnter();
+-
++
+ globus_mutex_lock(&globus_l_xio_system_fdset_mutex);
+ {
+ for(fd = 0; fd <= globus_l_xio_system_highest_fd; fd++)
+@@ -1199,9 +1199,9 @@ globus_l_xio_system_bad_apple(void)
+ {
+ GlobusXIOSystemDebugPrintf(
+ GLOBUS_I_XIO_SYSTEM_DEBUG_INFO,
+- (_XIOSL("[%s] fd=%d, Canceling read bad apple\n"),
++ (_XIOSL("[%s] fd=%d, Canceling read bad apple\n"),
+ _xio_name, fd));
+-
++
+ op_info = globus_l_xio_system_read_operations[fd];
+ if(op_info->state == GLOBUS_I_XIO_SYSTEM_OP_PENDING)
+ {
+@@ -1213,7 +1213,7 @@ globus_l_xio_system_bad_apple(void)
+ }
+ }
+ }
+-
++
+ if(FD_ISSET(fd, globus_l_xio_system_write_fds))
+ {
+ rc = fstat(fd, &stat_buf);
+@@ -1224,7 +1224,7 @@ globus_l_xio_system_bad_apple(void)
+ GLOBUS_I_XIO_SYSTEM_DEBUG_INFO,
+ (_XIOSL("[%s] fd=%d, Canceling write bad apple\n"),
+ _xio_name, fd));
+-
++
+ op_info = globus_l_xio_system_write_operations[fd];
+ if(op_info->state == GLOBUS_I_XIO_SYSTEM_OP_PENDING)
+ {
+@@ -1239,7 +1239,7 @@ globus_l_xio_system_bad_apple(void)
+ }
+ }
+ globus_mutex_unlock(&globus_l_xio_system_fdset_mutex);
+-
++
+ GlobusXIOSystemDebugExit();
+ }
+
+@@ -1264,7 +1264,7 @@ globus_l_xio_system_poll(
+ int nready;
+ int fd;
+ int save_errno;
+-
++
+ time_left_is_zero = GLOBUS_FALSE;
+ time_left_is_infinity = GLOBUS_FALSE;
+
+@@ -1294,11 +1294,11 @@ globus_l_xio_system_poll(
+ globus_l_xio_system_select_active = GLOBUS_TRUE;
+ }
+ globus_mutex_unlock(&globus_l_xio_system_fdset_mutex);
+-
++
+ GlobusXIOSystemDebugPrintf(
+ GLOBUS_I_XIO_SYSTEM_DEBUG_INFO,
+ (_XIOSL("[%s] Before select\n"), _xio_name));
+-
++
+ nready = select(
+ num,
+ globus_l_xio_system_ready_reads,
+@@ -1308,7 +1308,7 @@ globus_l_xio_system_poll(
+
+ GlobusXIOSystemUpdateErrno();
+ save_errno = errno;
+-
++
+ GlobusXIOSystemDebugPrintf(
+ GLOBUS_I_XIO_SYSTEM_DEBUG_INFO,
+ (_XIOSL("[%s] After select\n"), _xio_name));
+@@ -1339,7 +1339,7 @@ globus_l_xio_system_poll(
+ {
+ globus_l_xio_system_bad_apple();
+ }
+-
++
+ /*
+ * can't really do anything about other errors
+ * so, set ready fds to known state in case there are things
+@@ -1361,11 +1361,11 @@ globus_l_xio_system_poll(
+ fd = (int) (intptr_t) globus_list_remove(
+ &globus_l_xio_system_canceled_reads,
+ globus_l_xio_system_canceled_reads);
+-
++
+ GlobusXIOSystemDebugPrintf(
+ GLOBUS_I_XIO_SYSTEM_DEBUG_INFO,
+ (_XIOSL("[%s] fd=%d, Setting canceled read\n"), _xio_name, fd));
+-
++
+ if(!FD_ISSET(fd, globus_l_xio_system_ready_reads))
+ {
+ FD_SET(fd, globus_l_xio_system_ready_reads);
+@@ -1378,11 +1378,11 @@ globus_l_xio_system_poll(
+ fd = (int) (intptr_t) globus_list_remove(
+ &globus_l_xio_system_canceled_writes,
+ globus_l_xio_system_canceled_writes);
+-
++
+ GlobusXIOSystemDebugPrintf(
+ GLOBUS_I_XIO_SYSTEM_DEBUG_INFO,
+ (_XIOSL("[%s] fd=%d, Setting canceled read\n"), _xio_name, fd));
+-
++
+ if(!FD_ISSET(fd, globus_l_xio_system_ready_writes))
+ {
+ FD_SET(fd, globus_l_xio_system_ready_writes);
+@@ -1486,7 +1486,7 @@ globus_xio_system_socket_register_connect(
+ goto error_register;
+
+ }
+-
++
+ /* handle could be destroyed by time we get here - no touch! */
+ GlobusXIOSystemDebugExitFD(fd);
+ return GLOBUS_SUCCESS;
+@@ -1514,7 +1514,7 @@ globus_xio_system_socket_register_accept(
+ GlobusXIOName(globus_xio_system_socket_register_accept);
+
+ GlobusXIOSystemDebugEnterFD(fd);
+-
++
+ GlobusIXIOSystemAllocOperation(op_info);
+ if(!op_info)
+ {
+@@ -1539,7 +1539,7 @@ globus_xio_system_socket_register_accept(
+ _XIOSL("globus_l_xio_system_register_read_fd"), result);
+ goto error_register;
+ }
+-
++
+ /* handle could be destroyed by time we get here - no touch! */
+ GlobusXIOSystemDebugExitFD(fd);
+ return GLOBUS_SUCCESS;
+@@ -1576,23 +1576,23 @@ globus_l_xio_system_register_read(
+ GlobusXIOSystemDebugPrintf(
+ GLOBUS_I_XIO_SYSTEM_DEBUG_DATA,
+ (_XIOSL("[%s] Waiting for %u bytes\n"), _xio_name, (unsigned) waitforbytes));
+-
++
+ GlobusIXIOSystemAllocOperation(op_info);
+ if(!op_info)
+ {
+ result = GlobusXIOErrorMemory("op_info");
+ goto error_op_info;
+ }
+-
++
+ GlobusIXIOSystemAllocIovec(u_iovc, iov);
+ if(!iov)
+ {
+ result = GlobusXIOErrorMemory("iov");
+ goto error_iovec;
+ }
+-
++
+ GlobusIXIOUtilTransferIovec(iov, u_iov, u_iovc);
+-
++
+ op_info->type = GLOBUS_I_XIO_SYSTEM_OP_READ;
+ op_info->sop.data.start_iov = iov;
+ op_info->sop.data.start_iovc = u_iovc;
+@@ -1600,7 +1600,7 @@ globus_l_xio_system_register_read(
+ op_info->sop.data.iovc = u_iovc;
+ op_info->sop.data.addr = from;
+ op_info->sop.data.flags = flags;
+-
++
+ op_info->state = GLOBUS_I_XIO_SYSTEM_OP_NEW;
+ op_info->op = op;
+ op_info->handle = handle;
+@@ -1608,7 +1608,7 @@ globus_l_xio_system_register_read(
+ op_info->sop.data.callback = callback;
+ op_info->waitforbytes = waitforbytes;
+ op_info->offset = offset;
+-
++
+ result = globus_l_xio_system_register_read_fd(fd, op_info);
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -1616,7 +1616,7 @@ globus_l_xio_system_register_read(
+ "globus_l_xio_system_register_read_fd", result);
+ goto error_register;
+ }
+-
++
+ /* handle could be destroyed by time we get here - no touch! */
+ GlobusXIOSystemDebugExitFD(fd);
+ return GLOBUS_SUCCESS;
+@@ -1705,14 +1705,14 @@ globus_l_xio_system_register_write(
+ GlobusXIOSystemDebugPrintf(
+ GLOBUS_I_XIO_SYSTEM_DEBUG_DATA,
+ (_XIOSL("[%s] Waiting for %u bytes\n"), _xio_name, (unsigned) waitforbytes));
+-
++
+ GlobusIXIOSystemAllocOperation(op_info);
+ if(!op_info)
+ {
+ result = GlobusXIOErrorMemory("op_info");
+ goto error_op_info;
+ }
+-
++
+ GlobusIXIOSystemAllocIovec(u_iovc, iov);
+ if(!iov)
+ {
+@@ -1721,7 +1721,7 @@ globus_l_xio_system_register_write(
+ }
+
+ GlobusIXIOUtilTransferIovec(iov, u_iov, u_iovc);
+-
++
+ op_info->type = GLOBUS_I_XIO_SYSTEM_OP_WRITE;
+ op_info->sop.data.start_iov = iov;
+ op_info->sop.data.start_iovc = u_iovc;
+@@ -1729,7 +1729,7 @@ globus_l_xio_system_register_write(
+ op_info->sop.data.iovc = u_iovc;
+ op_info->sop.data.addr = to;
+ op_info->sop.data.flags = flags;
+-
++
+ op_info->state = GLOBUS_I_XIO_SYSTEM_OP_NEW;
+ op_info->op = op;
+ op_info->handle = handle;
+@@ -1737,7 +1737,7 @@ globus_l_xio_system_register_write(
+ op_info->sop.data.callback = callback;
+ op_info->waitforbytes = waitforbytes;
+ op_info->offset = offset;
+-
++
+ result = globus_l_xio_system_register_write_fd(fd, op_info);
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -1745,7 +1745,7 @@ globus_l_xio_system_register_write(
+ "globus_l_xio_system_register_write_fd", result);
+ goto error_register;
+ }
+-
++
+ /* handle could be destroyed by time we get here - no touch! */
+ GlobusXIOSystemDebugExitFD(fd);
+ return GLOBUS_SUCCESS;
+@@ -1824,7 +1824,7 @@ globus_l_xio_system_try_read(
+ if(handle->type == GLOBUS_XIO_SYSTEM_FILE)
+ {
+ globus_result_t result;
+-
++
+ globus_mutex_lock(&handle->lock);
+ {
+ if(handle->file_position != offset &&
+@@ -1835,19 +1835,19 @@ globus_l_xio_system_try_read(
+ ("[globus_l_xio_system_try_read] fd=%d, "
+ "Changing file position to %" GLOBUS_OFF_T_FORMAT "\n",
+ handle->fd, offset));
+-
++
+ /* assume success as possible failures are ignorable */
+ lseek(handle->fd, offset, SEEK_SET);
+ handle->file_position = offset;
+ }
+-
++
+ result = globus_i_xio_system_file_try_read(
+ handle->fd, iov, iovc, nbytes);
+-
++
+ handle->file_position += *nbytes;
+ }
+ globus_mutex_unlock(&handle->lock);
+-
++
+ return result;
+ }
+ else
+@@ -1877,14 +1877,14 @@ globus_l_xio_system_read(
+
+ result = globus_l_xio_system_try_read(
+ handle, offset, u_iov, u_iovc, flags, from, u_nbytes);
+-
++
+ if(result == GLOBUS_SUCCESS && *u_nbytes < waitforbytes)
+ {
+ struct iovec * iov;
+ int iovc;
+ globus_size_t nbytes = *u_nbytes;
+ globus_size_t total = nbytes;
+-
++
+ /*
+ * XXX this is not thread safe... both reads and writes are mucking
+ * with blocking status.
+@@ -1902,7 +1902,7 @@ globus_l_xio_system_read(
+ GlobusIXIOUtilTransferIovec(iov, u_iov, u_iovc);
+ u_iov = iov;
+ iovc = u_iovc;
+-
++
+ do
+ {
+ if(total > 0)
+@@ -1910,16 +1910,16 @@ globus_l_xio_system_read(
+ /* only capture source first time around */
+ from = GLOBUS_NULL;
+ }
+-
++
+ offset += nbytes;
+ GlobusIXIOUtilAdjustIovec(iov, iovc, nbytes);
+ result = globus_l_xio_system_try_read(
+ handle, offset, iov, iovc, flags, from, &nbytes);
+ total += nbytes;
+ } while(result == GLOBUS_SUCCESS && nbytes && total < waitforbytes);
+-
++
+ *u_nbytes = total;
+-
++
+ GlobusIXIOSystemFreeIovec(u_iovc, (globus_xio_iovec_t *) u_iov);
+ rc = globus_l_xio_system_add_nonblocking(handle);
+ }
+@@ -1974,7 +1974,7 @@ globus_l_xio_system_try_write(
+ if(handle->type == GLOBUS_XIO_SYSTEM_FILE)
+ {
+ globus_result_t result;
+-
++
+ globus_mutex_lock(&handle->lock);
+ {
+ if(handle->file_position != offset &&
+@@ -1985,19 +1985,19 @@ globus_l_xio_system_try_write(
+ ("[globus_l_xio_system_try_write] fd=%d, "
+ "Changing file position to %" GLOBUS_OFF_T_FORMAT "\n",
+ handle->fd, offset));
+-
++
+ /* assume success as possible failures are ignorable */
+ lseek(handle->fd, offset, SEEK_SET);
+ handle->file_position = offset;
+ }
+-
++
+ result = globus_i_xio_system_file_try_write(
+ handle->fd, iov, iovc, nbytes);
+-
++
+ handle->file_position += *nbytes;
+ }
+ globus_mutex_unlock(&handle->lock);
+-
++
+ return result;
+ }
+ else
+@@ -2027,14 +2027,14 @@ globus_l_xio_system_write(
+
+ result = globus_l_xio_system_try_write(
+ handle, offset, u_iov, u_iovc, flags, to, u_nbytes);
+-
++
+ if(result == GLOBUS_SUCCESS && *u_nbytes < waitforbytes)
+ {
+ struct iovec * iov;
+ int iovc;
+ globus_size_t nbytes = *u_nbytes;
+ globus_size_t total = nbytes;
+-
++
+ /*
+ * XXX this is not thread safe... both reads and writes are mucking
+ * with blocking status
+@@ -2050,7 +2050,7 @@ globus_l_xio_system_write(
+ GlobusIXIOUtilTransferIovec(iov, u_iov, u_iovc);
+ u_iov = iov;
+ iovc = u_iovc;
+-
++
+ do
+ {
+ offset += nbytes;
+@@ -2059,9 +2059,9 @@ globus_l_xio_system_write(
+ handle, offset, iov, iovc, flags, to, &nbytes);
+ total += nbytes;
+ } while(result == GLOBUS_SUCCESS && nbytes && total < waitforbytes);
+-
++
+ *u_nbytes = total;
+-
++
+ GlobusIXIOSystemFreeIovec(u_iovc, (globus_xio_iovec_t *) u_iov);
+ rc = globus_l_xio_system_add_nonblocking(handle);
+ }
+@@ -2112,19 +2112,19 @@ globus_l_xio_system_close(
+ GlobusXIOName(globus_l_xio_system_close);
+
+ GlobusXIOSystemDebugEnterFD(fd);
+-
++
+ do
+ {
+ rc = close(fd);
+ GlobusXIOSystemUpdateErrno();
+ } while(rc < 0 && errno == EINTR);
+-
++
+ if(rc < 0)
+ {
+ result = GlobusXIOErrorSystemError("close", errno);
+ goto error_close;
+ }
+-
++
+ GlobusXIOSystemDebugExitFD(fd);
+ return GLOBUS_SUCCESS;
+
+@@ -2139,18 +2139,18 @@ globus_xio_system_file_get_position(
+ {
+ globus_off_t offset;
+ GlobusXIOName(globus_xio_system_file_get_position);
+-
++
+ GlobusXIOSystemDebugEnterFD(fd);
+-
++
+ /* ignore errors, may be a pipe or other unseekable */
+ offset = lseek(fd, 0, SEEK_CUR);
+ if(offset == -1)
+ {
+ offset = 0;
+ }
+-
++
+ GlobusXIOSystemDebugExitFD(fd);
+-
++
+ return offset;
+ }
+
+@@ -2161,16 +2161,16 @@ globus_xio_system_file_get_size(
+ globus_off_t size = -1;
+ struct stat buf;
+ GlobusXIOName(globus_xio_system_file_get_size);
+-
++
+ GlobusXIOSystemDebugEnterFD(fd);
+-
++
+ if(fstat(fd, &buf) == 0)
+ {
+ size = buf.st_size;
+ }
+-
++
+ GlobusXIOSystemDebugExitFD(fd);
+-
++
+ return size;
+ }
+
+@@ -2190,7 +2190,7 @@ globus_xio_system_convert_stdio(
+ {
+ return fileno(stderr);
+ }
+-
++
+ return GLOBUS_XIO_SYSTEM_INVALID_FILE;
+ }
+
+@@ -2202,9 +2202,9 @@ globus_xio_system_file_truncate(
+ globus_result_t result;
+ int rc;
+ GlobusXIOName(globus_xio_system_file_truncate);
+-
++
+ GlobusXIOSystemDebugEnterFD(fd);
+-
++
+ #ifdef TARGET_ARCH_ARM
+ setErrno(EINVAL);
+
+@@ -2217,7 +2217,7 @@ globus_xio_system_file_truncate(
+ result = GlobusXIOErrorSystemError("ftruncate", errno);
+ goto error_truncate;
+ }
+-
++
+ GlobusXIOSystemDebugExitFD(fd);
+ return GLOBUS_SUCCESS;
+
+@@ -2236,10 +2236,10 @@ globus_xio_system_file_open(
+ {
+ globus_result_t result;
+ GlobusXIOName(globus_xio_system_file_open);
+-
++
+ *fd = -1;
+ GlobusXIOSystemDebugEnterFD(*fd);
+-
++
+ do
+ {
+ *fd = open(filename, flags, mode);
+@@ -2251,10 +2251,10 @@ globus_xio_system_file_open(
+ result = GlobusXIOErrorSystemError("open", errno);
+ goto error_open;
+ }
+-
++
+ /* all handles created by me are closed on exec */
+ fcntl(*fd, F_SETFD, FD_CLOEXEC);
+-
++
+ GlobusXIOSystemDebugPrintf(
+ GLOBUS_I_XIO_SYSTEM_DEBUG_INFO,
+ ("[%s] Opened file, %s fd=%d\n", _xio_name, filename, *fd));
+@@ -2283,10 +2283,10 @@ globus_xio_system_socket_create(
+ {
+ globus_result_t result;
+ GlobusXIOName(globus_xio_system_socket_create);
+-
++
+ *fd = -1;
+ GlobusXIOSystemDebugEnterFD(*fd);
+-
++
+ *fd = socket(domain, type, protocol);
+ GlobusXIOSystemUpdateErrno();
+ if(*fd == -1)
+@@ -2294,7 +2294,7 @@ globus_xio_system_socket_create(
+ result = GlobusXIOErrorSystemError("socket", errno);
+ goto error_socket;
+ }
+-
++
+ /* all handles created by me are closed on exec */
+ fcntl(*fd, F_SETFD, FD_CLOEXEC);
+
+@@ -2316,16 +2316,16 @@ globus_xio_system_socket_setsockopt(
+ {
+ globus_result_t result;
+ GlobusXIOName(globus_xio_system_socket_setsockopt);
+-
++
+ GlobusXIOSystemDebugEnterFD(socket);
+-
++
+ if(setsockopt(socket, level, optname, (void *) optval, optlen) < 0)
+ {
+ GlobusXIOSystemUpdateErrno();
+ result = GlobusXIOErrorSystemError("setsockopt", errno);
+ goto error_setsockopt;
+ }
+-
++
+ GlobusXIOSystemDebugExitFD(socket);
+ return GLOBUS_SUCCESS;
+
+@@ -2344,16 +2344,16 @@ globus_xio_system_socket_getsockopt(
+ {
+ globus_result_t result;
+ GlobusXIOName(globus_xio_system_socket_getsockopt);
+-
++
+ GlobusXIOSystemDebugEnterFD(socket);
+-
++
+ if(getsockopt(socket, level, optname, optval, optlen) < 0)
+ {
+ GlobusXIOSystemUpdateErrno();
+ result = GlobusXIOErrorSystemError("getsockopt", errno);
+ goto error_getsockopt;
+ }
+-
++
+ GlobusXIOSystemDebugExitFD(socket);
+ return GLOBUS_SUCCESS;
+
+@@ -2370,16 +2370,16 @@ globus_xio_system_socket_getsockname(
+ {
+ globus_result_t result;
+ GlobusXIOName(globus_xio_system_socket_getsockname);
+-
++
+ GlobusXIOSystemDebugEnterFD(socket);
+-
++
+ if(getsockname(socket, name, namelen) < 0)
+ {
+ GlobusXIOSystemUpdateErrno();
+ result = GlobusXIOErrorSystemError("getsockname", errno);
+ goto error_getsockname;
+ }
+-
++
+ GlobusXIOSystemDebugExitFD(socket);
+ return GLOBUS_SUCCESS;
+
+@@ -2396,16 +2396,16 @@ globus_xio_system_socket_getpeername(
+ {
+ globus_result_t result;
+ GlobusXIOName(globus_xio_system_socket_getpeername);
+-
++
+ GlobusXIOSystemDebugEnterFD(socket);
+-
++
+ if(getpeername(socket, name, namelen) < 0)
+ {
+ GlobusXIOSystemUpdateErrno();
+ result = GlobusXIOErrorSystemError("getpeername", errno);
+ goto error_getpeername;
+ }
+-
++
+ GlobusXIOSystemDebugExitFD(socket);
+ return GLOBUS_SUCCESS;
+
+@@ -2422,16 +2422,16 @@ globus_xio_system_socket_bind(
+ {
+ globus_result_t result;
+ GlobusXIOName(globus_xio_system_socket_bind);
+-
++
+ GlobusXIOSystemDebugEnterFD(socket);
+-
++
+ if(bind(socket, addr, addrlen) < 0)
+ {
+ GlobusXIOSystemUpdateErrno();
+ result = GlobusXIOErrorSystemError("bind", errno);
+ goto error_bind;
+ }
+-
++
+ GlobusXIOSystemDebugExitFD(socket);
+ return GLOBUS_SUCCESS;
+
+@@ -2447,16 +2447,16 @@ globus_xio_system_socket_listen(
+ {
+ globus_result_t result;
+ GlobusXIOName(globus_xio_system_socket_listen);
+-
++
+ GlobusXIOSystemDebugEnterFD(socket);
+-
++
+ if(listen(socket, backlog) < 0)
+ {
+ GlobusXIOSystemUpdateErrno();
+ result = GlobusXIOErrorSystemError("listen", errno);
+ goto error_listen;
+ }
+-
++
+ GlobusXIOSystemDebugExitFD(socket);
+ return GLOBUS_SUCCESS;
+
+@@ -2474,21 +2474,21 @@ globus_xio_system_socket_connect(
+ globus_result_t result;
+ int rc;
+ GlobusXIOName(globus_xio_system_socket_connect);
+-
++
+ GlobusXIOSystemDebugEnterFD(socket);
+-
++
+ do
+ {
+ rc = connect(socket, addr, addrlen);
+ GlobusXIOSystemUpdateErrno();
+ } while(rc < 0 && errno == EINTR);
+-
++
+ if(rc < 0)
+ {
+ result = GlobusXIOErrorSystemError("connect", errno);
+ goto error_connect;
+ }
+-
++
+ GlobusXIOSystemDebugExitFD(socket);
+ return GLOBUS_SUCCESS;
+
+diff --git a/xio/src/test/drivers/globus_xio_smtp.c b/xio/src/test/drivers/globus_xio_smtp.c
+index 08569c056..84003f93d 100644
+--- a/xio/src/test/drivers/globus_xio_smtp.c
++++ b/xio/src/test/drivers/globus_xio_smtp.c
+@@ -123,7 +123,7 @@ globus_l_xio_smtp_attr_cntl(
+ if(cmd == 1)
+ {
+ to_addr = (char *) va_arg(ap, char *);
+- sprintf(info->to_address, "%s", to_addr);
++ sprintf(info->to_address, "%s", to_addr);
+ }
+
+ return GLOBUS_SUCCESS;
+@@ -224,7 +224,7 @@ globus_l_xio_smtp_read_header_cb(
+ {
+ /* if we have not recieved the entire message repost */
+ info->read_offset += nbytes;
+- if(info->read_offset < 2 ||
++ if(info->read_offset < 2 ||
+ info->message[info->read_offset - 2] != '\r' ||
+ info->message[info->read_offset - 1] != '\n')
+ {
+@@ -318,7 +318,7 @@ globus_l_xio_smtp_open_cb(
+ {
+ next_state(info, op);
+ }
+-}
++}
+
+ static
+ globus_result_t
+@@ -352,9 +352,9 @@ globus_l_xio_smtp_close_cb(
+ globus_xio_operation_t op,
+ globus_result_t result,
+ void * user_arg)
+-{
++{
+ globus_xio_driver_finished_close(op, result);
+-}
++}
+
+ void
+ globus_l_xio_smtp_write_close_cb(
+@@ -515,7 +515,7 @@ globus_l_xio_smtp_activate(void)
+
+ globus_l_return_address = globus_common_create_string("%s@%s",
+ username, globus_l_hostname);
+-
++
+ if(rc == GLOBUS_SUCCESS)
+ {
+ GlobusXIORegisterDriver(smtp);
+diff --git a/xio/src/test/globus_utp_main.c b/xio/src/test/globus_utp_main.c
+index 698e4b318..184b395a7 100644
+--- a/xio/src/test/globus_utp_main.c
++++ b/xio/src/test/globus_utp_main.c
+@@ -45,7 +45,7 @@ Public functions for the Unnamed Timing Package (UTP).
+ #include "globus_utp_private.h"
+
+ /******************************************************************************
+- Module activation structure
++ Module activation structure
+ ******************************************************************************/
+ static int
+ globus_l_utp_activate(void);
+@@ -54,7 +54,7 @@ static int
+ globus_l_utp_deactivate(void);
+
+
+-globus_module_descriptor_t globus_i_utp_module =
++globus_module_descriptor_t globus_i_utp_module =
+ {
+ "globus_utp",
+ globus_l_utp_activate,
+@@ -64,7 +64,7 @@ globus_module_descriptor_t globus_i_utp_module =
+
+
+ /******************************************************************************
+- globus_utp module activation functions
++ globus_utp module activation functions
+ ******************************************************************************/
+
+ static int
+@@ -72,14 +72,14 @@ globus_l_utp_activate(void)
+ {
+ if (globus_module_activate(GLOBUS_COMMON_MODULE) != GLOBUS_SUCCESS)
+ {
+- return GLOBUS_FAILURE;
++ return GLOBUS_FAILURE;
+ }
+
+ /* Initialize some global variables */
+ globus_utp_attributes = GLOBUS_NULL;
+ globus_utp_numTimers = 0;
+ globus_utp_timers = GLOBUS_NULL;
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+@@ -93,7 +93,7 @@ globus_l_utp_deactivate(void)
+ globus_utp_Attribute_t *tmpAttr;
+
+ rc = GLOBUS_SUCCESS;
+-
++
+ /*
+ * Free up any storage
+ */
+@@ -101,18 +101,18 @@ globus_l_utp_deactivate(void)
+ while (curAttr)
+ {
+
+- tmpAttr = curAttr;
+- curAttr = curAttr->next;
+- globus_free(tmpAttr);
++ tmpAttr = curAttr;
++ curAttr = curAttr->next;
++ globus_free(tmpAttr);
+ }
+ globus_utp_attributes = GLOBUS_NULL;
+
+ for (i = 0; i < globus_utp_numTimers; i++)
+ {
+- if (globus_utp_timers[i].name)
+- {
+- globus_free(globus_utp_timers[i].name);
+- }
++ if (globus_utp_timers[i].name)
++ {
++ globus_free(globus_utp_timers[i].name);
++ }
+ }
+ globus_free(globus_utp_timers);
+ globus_utp_numTimers = 0;
+@@ -123,11 +123,11 @@ globus_l_utp_deactivate(void)
+ */
+ if (globus_module_deactivate(GLOBUS_COMMON_MODULE) != GLOBUS_SUCCESS)
+ {
+- rc = GLOBUS_FAILURE;
++ rc = GLOBUS_FAILURE;
+ }
+
+ return rc;
+-
++
+ }
+
+
+@@ -137,53 +137,53 @@ Public UTP functions.
+
+ int globus_utp_init(unsigned numTimers, int mode)
+ {
+- unsigned i;
+- int sharingMode = mode & GLOBUS_UTP_MODE_SHARING_FIELD;
+- char hostnameBuff[MAXHOSTNAMELEN];
+- time_t theTime;
++ unsigned i;
++ int sharingMode = mode & GLOBUS_UTP_MODE_SHARING_FIELD;
++ char hostnameBuff[MAXHOSTNAMELEN];
++ time_t theTime;
+ const char *username;
+- char theTimeStr[27];
+-
+- if (sharingMode == GLOBUS_UTP_MODE_PRIVATE)
+- {
+- globus_utp_warn("globus_utp_init: mode GLOBUS_UTP_MODE_PRIVATE not yet "
+- "implemented");
+- return 1;
+- } else if (sharingMode != GLOBUS_UTP_MODE_SHARED)
+- {
+- globus_utp_warn("globus_utp_init: invalid sharing mode %#X specified",
+- sharingMode);
+- return 1;
+- }
+-
+- if (!(globus_utp_timers = globus_malloc(numTimers * sizeof(globus_utp_Timer_t))))
+- {
+- globus_utp_warn("globus_utp_init: globus_malloc() failed for timers");
+- globus_utp_numTimers = 0;
+- return 1;
+- }
+-
+- globus_utp_numTimers = numTimers;
+-
+- /* This loop not only initializes every
+- field; by "touching" everything, it also
+- makes sure it is paged in. */
+- for (i = 0; i < numTimers; i++) {
+- globus_utp_timers[i].state = GLOBUS_UTP_TIMER_STOPPED;
+- globus_utp_timeZero(&globus_utp_timers[i].startTime);
+- globus_utp_timeZero(&globus_utp_timers[i].accumulatedTime);
+- globus_utp_timers[i].numEvents = 0;
+- /* If name is still NULL when
+- globus_utp_write_file() is called,
+- globus_utp_DEFAULT_TIMER_NAME is printed. */
+- globus_utp_timers[i].name = NULL;
+- }
+-
+- /* Make key/value linked list empty. */
+- globus_utp_attributes = NULL;
+-
+- /* Set attributes for "user", "hostname",
+- and "timestamp". */
++ char theTimeStr[27];
++
++ if (sharingMode == GLOBUS_UTP_MODE_PRIVATE)
++ {
++ globus_utp_warn("globus_utp_init: mode GLOBUS_UTP_MODE_PRIVATE not yet "
++ "implemented");
++ return 1;
++ } else if (sharingMode != GLOBUS_UTP_MODE_SHARED)
++ {
++ globus_utp_warn("globus_utp_init: invalid sharing mode %#X specified",
++ sharingMode);
++ return 1;
++ }
++
++ if (!(globus_utp_timers = globus_malloc(numTimers * sizeof(globus_utp_Timer_t))))
++ {
++ globus_utp_warn("globus_utp_init: globus_malloc() failed for timers");
++ globus_utp_numTimers = 0;
++ return 1;
++ }
++
++ globus_utp_numTimers = numTimers;
++
++ /* This loop not only initializes every
++ field; by "touching" everything, it also
++ makes sure it is paged in. */
++ for (i = 0; i < numTimers; i++) {
++ globus_utp_timers[i].state = GLOBUS_UTP_TIMER_STOPPED;
++ globus_utp_timeZero(&globus_utp_timers[i].startTime);
++ globus_utp_timeZero(&globus_utp_timers[i].accumulatedTime);
++ globus_utp_timers[i].numEvents = 0;
++ /* If name is still NULL when
++ globus_utp_write_file() is called,
++ globus_utp_DEFAULT_TIMER_NAME is printed. */
++ globus_utp_timers[i].name = NULL;
++ }
++
++ /* Make key/value linked list empty. */
++ globus_utp_attributes = NULL;
++
++ /* Set attributes for "user", "hostname",
++ and "timestamp". */
+
+ # ifdef _WIN32
+ {
+@@ -198,31 +198,31 @@ int globus_utp_init(unsigned numTimers, int mode)
+ struct passwd *passwdEntry;
+ passwdEntry = getpwuid(getuid());
+ if (!passwdEntry) {
+- return 1;
++ return 1;
+ }
+ username = passwdEntry->pw_name;
+ }
+- globus_utp_set_attribute("%s", "user", username);
++ globus_utp_set_attribute("%s", "user", username);
+ #endif
+
+- if (globus_libc_gethostname(hostnameBuff, MAXHOSTNAMELEN)) {
+- /* globus_utp_warn("globus_utp_init: gethostname() failed; system error is "
+- "\"%s\"", sys_errlist[errno]); */
+- return 1;
+- }
+- globus_utp_set_attribute("%s", "hostname", hostnameBuff);
+-
+- if ((theTime = time(NULL)) == (time_t) -1) {
+- /* globus_utp_warn("globus_utp_init: time(3) failed; system error is "
+- "\"%s\"", sys_errlist[errno]); */
+- return 1;
+- }
+- strcpy(theTimeStr, ctime(&theTime));
+- /* Remove trailing '\n'. */
+- theTimeStr[strlen(theTimeStr) - 1] = 0;
+- globus_utp_set_attribute("%s", "timestamp", theTimeStr);
+-
+- return 0;
++ if (globus_libc_gethostname(hostnameBuff, MAXHOSTNAMELEN)) {
++ /* globus_utp_warn("globus_utp_init: gethostname() failed; system error is "
++ "\"%s\"", sys_errlist[errno]); */
++ return 1;
++ }
++ globus_utp_set_attribute("%s", "hostname", hostnameBuff);
++
++ if ((theTime = time(NULL)) == (time_t) -1) {
++ /* globus_utp_warn("globus_utp_init: time(3) failed; system error is "
++ "\"%s\"", sys_errlist[errno]); */
++ return 1;
++ }
++ strcpy(theTimeStr, ctime(&theTime));
++ /* Remove trailing '\n'. */
++ theTimeStr[strlen(theTimeStr) - 1] = 0;
++ globus_utp_set_attribute("%s", "timestamp", theTimeStr);
++
++ return 0;
+ }
+
+ void
+@@ -235,306 +235,306 @@ globus_utp_write_file(const char *outFilename)
+
+ if (!(outFile = fopen(outFilename, "w")))
+ {
+- /* globus_utp_warn("globus_utp_write_file: fopen() on file \"%s\" failed",
+- outFilename);
+- globus_utp_warn("globus_utp_write_file: system error message is \"%s\"",
+- sys_errlist[errno]); */
+- return;
++ /* globus_utp_warn("globus_utp_write_file: fopen() on file \"%s\" failed",
++ outFilename);
++ globus_utp_warn("globus_utp_write_file: system error message is \"%s\"",
++ sys_errlist[errno]); */
++ return;
+ }
+
+ curAttr = globus_utp_attributes;
+ while (curAttr)
+ {
+- globus_utp_Attribute_t *tmp = curAttr;
+- fprintf(outFile, "attribute\t\"%s\"\t\"%s\"\n",
+- curAttr->key, curAttr->value);
+- curAttr = curAttr->next;
+- globus_free(tmp->key);
+- globus_free(tmp->value);
+- globus_free(tmp);
++ globus_utp_Attribute_t *tmp = curAttr;
++ fprintf(outFile, "attribute\t\"%s\"\t\"%s\"\n",
++ curAttr->key, curAttr->value);
++ curAttr = curAttr->next;
++ globus_free(tmp->key);
++ globus_free(tmp->value);
++ globus_free(tmp);
+ }
+ globus_utp_attributes = NULL;
+
+ for (i = 0; i < globus_utp_numTimers; i++)
+ {
+- const char *name = globus_utp_timers[i].name;
+-
+- if (globus_utp_timers[i].state == GLOBUS_UTP_TIMER_RUNNING)
+- {
+- globus_utp_warn("globus_utp_write_file: timer %d still running",
+- i);
+- globus_utp_stop_timer(i);
+- }
+-
+- globus_utp_timeToString(buff,
+- &globus_utp_timers[i].accumulatedTime);
+-
+- fprintf(outFile, "timer\t%u\t%s\t%lu\t\"%s\"\n",
+- (unsigned) i,
+- buff,
+- globus_utp_timers[i].numEvents,
+- name ? name : GLOBUS_UTP_DEFAULT_TIMER_NAME);
++ const char *name = globus_utp_timers[i].name;
++
++ if (globus_utp_timers[i].state == GLOBUS_UTP_TIMER_RUNNING)
++ {
++ globus_utp_warn("globus_utp_write_file: timer %d still running",
++ i);
++ globus_utp_stop_timer(i);
++ }
++
++ globus_utp_timeToString(buff,
++ &globus_utp_timers[i].accumulatedTime);
++
++ fprintf(outFile, "timer\t%u\t%s\t%lu\t\"%s\"\n",
++ (unsigned) i,
++ buff,
++ globus_utp_timers[i].numEvents,
++ name ? name : GLOBUS_UTP_DEFAULT_TIMER_NAME);
+ }
+
+ if (fclose(outFile))
+ {
+- /* globus_utp_warn("globus_utp_write_file: fclose() on file \"%s\" failed",
+- outFilename);
+- globus_utp_warn("globus_utp_write_file: system error message is \"%s\"",
+- sys_errlist[errno]); */
+- return;
++ /* globus_utp_warn("globus_utp_write_file: fclose() on file \"%s\" failed",
++ outFilename);
++ globus_utp_warn("globus_utp_write_file: system error message is \"%s\"",
++ sys_errlist[errno]); */
++ return;
+ }
+ }
+
+ void
+ globus_utp_set_attribute(const char *keyStr, const char *keyArg,
+- const char *valueStr, ...)
++ const char *valueStr, ...)
+ {
+- globus_utp_Attribute_t *newAttr; /* New key/value pair. */
+- globus_utp_Attribute_t **lastNext; /* Final "next" pointer in list. */
+- char *newKey = globus_malloc(sizeof(char) * GLOBUS_UTP_MAX_NAME_LENGTH);
+- char *newValue = globus_malloc(sizeof(char) * GLOBUS_UTP_MAX_NAME_LENGTH);
+- va_list ap;
+-
+- if (!newKey || !newValue) {
+- globus_utp_warn("globus_utp_set_attribute: globus_malloc() failed");
+- return;
+- }
+- sprintf(newKey, keyStr, keyArg); /* Compute new key. */
+- va_start(ap, valueStr); /* Compute new value. */
+- vsprintf(newValue, valueStr, ap);
+-
+- newAttr = globus_utp_attributes;
+- lastNext = &globus_utp_attributes;
+- /* Search for same key in list. */
+- while (newAttr && strcmp(newAttr->key, newKey) != 0) {
+- lastNext = &newAttr->next;
+- newAttr = newAttr->next;
+- }
+-
+- if (newAttr) { /* Key already exists in list. */
+- /* Just replace the old value. */
+- strcpy(newAttr->value, newValue);
+- globus_free(newKey);
+- globus_free(newValue);
+- return;
+- }
+-
+- /* Add new key/value pair to list. */
+- *lastNext = newAttr = globus_malloc(sizeof(globus_utp_Attribute_t));
+- if (!newAttr) {
+- globus_utp_warn("globus_utp_set_attribute: globus_malloc() failed");
+- return;
+- }
+- newAttr->key = newKey;
+- newAttr->value = newValue;
+- newAttr->next = NULL;
++ globus_utp_Attribute_t *newAttr; /* New key/value pair. */
++ globus_utp_Attribute_t **lastNext; /* Final "next" pointer in list. */
++ char *newKey = globus_malloc(sizeof(char) * GLOBUS_UTP_MAX_NAME_LENGTH);
++ char *newValue = globus_malloc(sizeof(char) * GLOBUS_UTP_MAX_NAME_LENGTH);
++ va_list ap;
++
++ if (!newKey || !newValue) {
++ globus_utp_warn("globus_utp_set_attribute: globus_malloc() failed");
++ return;
++ }
++ sprintf(newKey, keyStr, keyArg); /* Compute new key. */
++ va_start(ap, valueStr); /* Compute new value. */
++ vsprintf(newValue, valueStr, ap);
++
++ newAttr = globus_utp_attributes;
++ lastNext = &globus_utp_attributes;
++ /* Search for same key in list. */
++ while (newAttr && strcmp(newAttr->key, newKey) != 0) {
++ lastNext = &newAttr->next;
++ newAttr = newAttr->next;
++ }
++
++ if (newAttr) { /* Key already exists in list. */
++ /* Just replace the old value. */
++ strcpy(newAttr->value, newValue);
++ globus_free(newKey);
++ globus_free(newValue);
++ return;
++ }
++
++ /* Add new key/value pair to list. */
++ *lastNext = newAttr = globus_malloc(sizeof(globus_utp_Attribute_t));
++ if (!newAttr) {
++ globus_utp_warn("globus_utp_set_attribute: globus_malloc() failed");
++ return;
++ }
++ newAttr->key = newKey;
++ newAttr->value = newValue;
++ newAttr->next = NULL;
+ }
+
+
+ /**********************************************************************
+-Timer state transition diagram. If timer is in "Current State", and
++Timer state transition diagram. If timer is in "Current State", and
+ "State Change Function" is called, result is either the indicated new state
+ or "Invalid" (in which case globus_utp_warn() is called).
+
+- State Change Function
++ State Change Function
+ Current
+-State start() stop() reset() disable() enable()
+-------- ------- ------ ------- --------- ---------
+-STOPPED RUNNING Invalid STOPPED DISABLED STOPPED
++State start() stop() reset() disable() enable()
++------- ------- ------ ------- --------- ---------
++STOPPED RUNNING Invalid STOPPED DISABLED STOPPED
+
+-RUNNING Invalid STOPPED STOPPED Invalid RUNNING
++RUNNING Invalid STOPPED STOPPED Invalid RUNNING
+
+-DISABLED DISABLED DISABLED DISABLED DISABLED STOPPED
++DISABLED DISABLED DISABLED DISABLED DISABLED STOPPED
+ **********************************************************************/
+
+ void globus_utp_start_timer(unsigned timerNumber)
+ {
+- globus_utp_Timer_t *theTimer;
++ globus_utp_Timer_t *theTimer;
+
+- /* Don't compile run-time checks into fully-optimized
+- version of the library. */
++ /* Don't compile run-time checks into fully-optimized
++ version of the library. */
+ #ifndef NDEBUG
+- if (timerNumber >= globus_utp_numTimers) {
+- globus_utp_warn("globus_utp_start_timer: illegal timer %d",
+- (int) timerNumber);
+- return;
+- }
++ if (timerNumber >= globus_utp_numTimers) {
++ globus_utp_warn("globus_utp_start_timer: illegal timer %d",
++ (int) timerNumber);
++ return;
++ }
+ #endif /* #ifndef NDEBUG */
+
+- theTimer = &globus_utp_timers[timerNumber];
+- if (theTimer->state == GLOBUS_UTP_TIMER_DISABLED)
+- return;
++ theTimer = &globus_utp_timers[timerNumber];
++ if (theTimer->state == GLOBUS_UTP_TIMER_DISABLED)
++ return;
+
+ #ifndef NDEBUG
+- if (theTimer->state == GLOBUS_UTP_TIMER_RUNNING) {
+- globus_utp_warn("globus_utp_start_timer: timer %d already running",
+- (int) timerNumber);
+- return;
+- }
++ if (theTimer->state == GLOBUS_UTP_TIMER_RUNNING) {
++ globus_utp_warn("globus_utp_start_timer: timer %d already running",
++ (int) timerNumber);
++ return;
++ }
+ #endif /* #ifndef NDEBUG */
+
+- theTimer->state = GLOBUS_UTP_TIMER_RUNNING;
+- globus_utp_readTime(&theTimer->startTime);
++ theTimer->state = GLOBUS_UTP_TIMER_RUNNING;
++ globus_utp_readTime(&theTimer->startTime);
+ }
+
+ void globus_utp_stop_timer(unsigned timerNumber)
+ {
+- globus_utp_Timer_t *theTimer;
+- globus_utp_TimeValue_t stopTime, elapsedTime;
++ globus_utp_Timer_t *theTimer;
++ globus_utp_TimeValue_t stopTime, elapsedTime;
+
+ #ifndef NDEBUG
+- if (timerNumber >= globus_utp_numTimers) {
+- globus_utp_warn("globus_utp_stop_timer: illegal timer %d",
+- (int) timerNumber);
+- return;
+- }
++ if (timerNumber >= globus_utp_numTimers) {
++ globus_utp_warn("globus_utp_stop_timer: illegal timer %d",
++ (int) timerNumber);
++ return;
++ }
+ #endif /* #ifndef NDEBUG */
+
+- theTimer = &globus_utp_timers[timerNumber];
+- if (theTimer->state == GLOBUS_UTP_TIMER_DISABLED)
+- return;
++ theTimer = &globus_utp_timers[timerNumber];
++ if (theTimer->state == GLOBUS_UTP_TIMER_DISABLED)
++ return;
+
+ #ifndef NDEBUG
+- if (theTimer->state == GLOBUS_UTP_TIMER_STOPPED) {
+- globus_utp_warn("globus_utp_stop_timer: timer %d not running",
+- (int) timerNumber);
+- return;
+- }
++ if (theTimer->state == GLOBUS_UTP_TIMER_STOPPED) {
++ globus_utp_warn("globus_utp_stop_timer: timer %d not running",
++ (int) timerNumber);
++ return;
++ }
+ #endif /* #ifndef NDEBUG */
+
+- theTimer->state = GLOBUS_UTP_TIMER_STOPPED;
+- globus_utp_readTime(&stopTime);
+- globus_utp_timeDifference(&elapsedTime, &theTimer->startTime, &stopTime);
+- globus_utp_timeAdd(&theTimer->accumulatedTime, &elapsedTime);
+- theTimer->numEvents++;
++ theTimer->state = GLOBUS_UTP_TIMER_STOPPED;
++ globus_utp_readTime(&stopTime);
++ globus_utp_timeDifference(&elapsedTime, &theTimer->startTime, &stopTime);
++ globus_utp_timeAdd(&theTimer->accumulatedTime, &elapsedTime);
++ theTimer->numEvents++;
+ }
+
+ void globus_utp_reset_timer(unsigned timerNumber)
+ {
+- globus_utp_Timer_t *theTimer;
++ globus_utp_Timer_t *theTimer;
+
+ #ifndef NDEBUG
+- if (timerNumber >= globus_utp_numTimers) {
+- globus_utp_warn("globus_utp_reset_timer: illegal timer %d",
+- (int) timerNumber);
+- return;
+- }
++ if (timerNumber >= globus_utp_numTimers) {
++ globus_utp_warn("globus_utp_reset_timer: illegal timer %d",
++ (int) timerNumber);
++ return;
++ }
+ #endif /* #ifndef NDEBUG */
+
+- theTimer = &globus_utp_timers[timerNumber];
+- if (theTimer->state == GLOBUS_UTP_TIMER_DISABLED)
+- return;
++ theTimer = &globus_utp_timers[timerNumber];
++ if (theTimer->state == GLOBUS_UTP_TIMER_DISABLED)
++ return;
+
+- theTimer->state = GLOBUS_UTP_TIMER_STOPPED;
+- globus_utp_timeZero(&theTimer->startTime);
+- globus_utp_timeZero(&theTimer->accumulatedTime);
+- theTimer->numEvents = 0;
++ theTimer->state = GLOBUS_UTP_TIMER_STOPPED;
++ globus_utp_timeZero(&theTimer->startTime);
++ globus_utp_timeZero(&theTimer->accumulatedTime);
++ theTimer->numEvents = 0;
+ }
+
+ void globus_utp_disable_timer(unsigned timerNumber)
+ {
+- globus_utp_Timer_t *theTimer;
++ globus_utp_Timer_t *theTimer;
+
+ #ifndef NDEBUG
+- if (timerNumber >= globus_utp_numTimers) {
+- globus_utp_warn("globus_utp_disable_timer: illegal timer %d",
+- (int) timerNumber);
+- return;
+- }
++ if (timerNumber >= globus_utp_numTimers) {
++ globus_utp_warn("globus_utp_disable_timer: illegal timer %d",
++ (int) timerNumber);
++ return;
++ }
+ #endif /* #ifndef NDEBUG */
+
+- theTimer = &globus_utp_timers[timerNumber];
++ theTimer = &globus_utp_timers[timerNumber];
+
+ #ifndef NDEBUG
+- if (theTimer->state == GLOBUS_UTP_TIMER_RUNNING) {
+- globus_utp_warn("globus_utp_disable_timer: timer %d is running",
+- (int) timerNumber);
+- return;
+- }
++ if (theTimer->state == GLOBUS_UTP_TIMER_RUNNING) {
++ globus_utp_warn("globus_utp_disable_timer: timer %d is running",
++ (int) timerNumber);
++ return;
++ }
+ #endif /* #ifndef NDEBUG */
+
+- theTimer->state = GLOBUS_UTP_TIMER_DISABLED;
++ theTimer->state = GLOBUS_UTP_TIMER_DISABLED;
+ }
+
+ void globus_utp_enable_timer(unsigned timerNumber)
+ {
+- globus_utp_Timer_t *theTimer;
++ globus_utp_Timer_t *theTimer;
+
+ #ifndef NDEBUG
+- if (timerNumber >= globus_utp_numTimers) {
+- globus_utp_warn("globus_utp_disable_timer: illegal timer %d",
+- (int) timerNumber);
+- return;
+- }
++ if (timerNumber >= globus_utp_numTimers) {
++ globus_utp_warn("globus_utp_disable_timer: illegal timer %d",
++ (int) timerNumber);
++ return;
++ }
+ #endif /* #ifndef NDEBUG */
+
+- theTimer = &globus_utp_timers[timerNumber];
++ theTimer = &globus_utp_timers[timerNumber];
+
+- /* If STOPPED or RUNNING, already enabled.
+- Otherwise, can only get to DISABLED from
+- STOPPED, so go there. */
+- if (theTimer->state == GLOBUS_UTP_TIMER_DISABLED)
+- theTimer->state = GLOBUS_UTP_TIMER_STOPPED;
++ /* If STOPPED or RUNNING, already enabled.
++ Otherwise, can only get to DISABLED from
++ STOPPED, so go there. */
++ if (theTimer->state == GLOBUS_UTP_TIMER_DISABLED)
++ theTimer->state = GLOBUS_UTP_TIMER_STOPPED;
+ }
+
+ void globus_utp_disable_all_timers(void)
+ {
+- unsigned i;
++ unsigned i;
+
+- for (i = 0; i < globus_utp_numTimers; i++)
+- globus_utp_disable_timer(i);
++ for (i = 0; i < globus_utp_numTimers; i++)
++ globus_utp_disable_timer(i);
+ }
+
+ void globus_utp_enable_all_timers(void)
+ {
+- unsigned i;
++ unsigned i;
+
+- for (i = 0; i < globus_utp_numTimers; i++)
+- globus_utp_enable_timer(i);
++ for (i = 0; i < globus_utp_numTimers; i++)
++ globus_utp_enable_timer(i);
+ }
+
+ const char *
+ globus_utp_name_timer(unsigned timerNumber, const char *nameStr, ...)
+ {
+- char *name;
+- va_list ap;
++ char *name;
++ va_list ap;
+
+ #ifndef NDEBUG
+- if (timerNumber >= globus_utp_numTimers) {
+- globus_utp_warn("globus_utp_name_timer: illegal timer %d",
+- (int) timerNumber);
+- return NULL;
+- }
++ if (timerNumber >= globus_utp_numTimers) {
++ globus_utp_warn("globus_utp_name_timer: illegal timer %d",
++ (int) timerNumber);
++ return NULL;
++ }
+ #endif /* #ifndef NDEBUG */
+- if (!(name = globus_malloc(sizeof(char) * GLOBUS_UTP_MAX_NAME_LENGTH))) {
+- globus_utp_warn("globus_utp_name_timer: globus_malloc() failed");
+- return NULL;
+- }
++ if (!(name = globus_malloc(sizeof(char) * GLOBUS_UTP_MAX_NAME_LENGTH))) {
++ globus_utp_warn("globus_utp_name_timer: globus_malloc() failed");
++ return NULL;
++ }
+
+- va_start(ap, nameStr);
+- vsprintf(name, nameStr, ap);
+- globus_utp_timers[timerNumber].name = name;
++ va_start(ap, nameStr);
++ vsprintf(name, nameStr, ap);
++ globus_utp_timers[timerNumber].name = name;
+
+- return name;
++ return name;
+ }
+
+ void
+ globus_utp_get_accum_time(unsigned timerNumber, double *time, int *precision)
+ {
+- globus_utp_Timer_t *theTimer;
++ globus_utp_Timer_t *theTimer;
+
+ #ifndef NDEBUG
+- if (timerNumber >= globus_utp_numTimers) {
+- globus_utp_warn("globus_utp_get_accum_time: illegal timer %d",
+- (int) timerNumber);
+- return;
+- }
++ if (timerNumber >= globus_utp_numTimers) {
++ globus_utp_warn("globus_utp_get_accum_time: illegal timer %d",
++ (int) timerNumber);
++ return;
++ }
+ #endif /* #ifndef NDEBUG */
+
+- theTimer = &globus_utp_timers[timerNumber];
++ theTimer = &globus_utp_timers[timerNumber];
+
+- globus_utp_timeToDouble(time, precision, &theTimer->accumulatedTime);
++ globus_utp_timeToDouble(time, precision, &theTimer->accumulatedTime);
+ }
+
+
+@@ -542,30 +542,30 @@ globus_utp_get_accum_time(unsigned timerNumber, double *time, int *precision)
+ Private UTP functions.
+ **********************************************************************/
+
+- /* Use external assembler routine for RS6000 by
+- default, unless RS6000_GETTIMER is defined. */
++ /* Use external assembler routine for RS6000 by
++ default, unless RS6000_GETTIMER is defined. */
+ #if !defined(RS6000) || (defined(RS6000) && defined(RS6000_GETTIMER))
+
+ void
+ globus_utp_readTime(globus_utp_TimeValue_t *tv)
+ {
+ #ifdef UNIX
+- int flag;
++ int flag;
+
+- flag = gettimeofday(tv, NULL);
++ flag = gettimeofday(tv, NULL);
+
+ #ifdef DEBUG
+- if (flag) {
+- globus_utp_warn("globus_utp_readTime: gettimeofday() failed");
+- globus_utp_warn("globus_utp_readTime: system error message is \"%s\"",
+- sys_errlist[errno]);
+- }
++ if (flag) {
++ globus_utp_warn("globus_utp_readTime: gettimeofday() failed");
++ globus_utp_warn("globus_utp_readTime: system error message is \"%s\"",
++ sys_errlist[errno]);
++ }
+ #endif /* #ifdef DEBUG */
+ #endif /* #ifdef UNIX */
+
+
+ #ifdef SOLHR
+- *tv = gethrtime();
++ *tv = gethrtime();
+ #endif
+
+ #ifdef RS6000
+@@ -577,95 +577,95 @@ on p. 59 of the "Optimizing and Tuning Guide for FORTRAN, C, and C++", and
+ seems to work just fine.
+ */
+
+- int flag;
++ int flag;
+
+- flag = gettimer(TIMEOFDAY, tv);
++ flag = gettimer(TIMEOFDAY, tv);
+
+ #ifdef DEBUG
+- if (flag) {
+- globus_utp_warn("globus_utp_readTime: gettimer() failed");
+- globus_utp_warn("globus_utp_readTime: system error message is \"%s\"",
+- sys_errlist[errno]);
+- }
++ if (flag) {
++ globus_utp_warn("globus_utp_readTime: gettimer() failed");
++ globus_utp_warn("globus_utp_readTime: system error message is \"%s\"",
++ sys_errlist[errno]);
++ }
+ #endif /* #ifdef DEBUG */
+
+ #endif /* #ifdef RS6000 */
+
+ #ifdef PARAGON
+- *tv = dclock();
+-#endif /* #ifdef PARAGON */
++ *tv = dclock();
++#endif /* #ifdef PARAGON */
+ }
+
+-#endif /* #if !defined(RS6000) || .... */
++#endif /* #if !defined(RS6000) || .... */
+
+
+ void
+ globus_utp_timeDifference(globus_utp_TimeValue_t *diff, const globus_utp_TimeValue_t *start,
+- const globus_utp_TimeValue_t *end)
++ const globus_utp_TimeValue_t *end)
+ {
+ #ifdef UNIX
+- diff->tv_sec = end->tv_sec - start->tv_sec;
++ diff->tv_sec = end->tv_sec - start->tv_sec;
+
+- if (end->tv_usec < start->tv_usec) {
+- diff->tv_sec--; /* "Borrow" from seconds. */
+- diff->tv_usec = 1000000 + end->tv_usec - start->tv_usec;
+- } else
+- diff->tv_usec = end->tv_usec - start->tv_usec;
++ if (end->tv_usec < start->tv_usec) {
++ diff->tv_sec--; /* "Borrow" from seconds. */
++ diff->tv_usec = 1000000 + end->tv_usec - start->tv_usec;
++ } else
++ diff->tv_usec = end->tv_usec - start->tv_usec;
+ #endif /* #ifdef UNIX */
+
+ #ifdef RS6000
+- diff->tv_sec = end->tv_sec - start->tv_sec;
++ diff->tv_sec = end->tv_sec - start->tv_sec;
+
+- if (end->tv_nsec < start->tv_nsec) {
+- diff->tv_sec--; /* "Borrow" from seconds. */
+- diff->tv_nsec = 1000000000 + end->tv_nsec - start->tv_nsec;
+- } else
+- diff->tv_nsec = end->tv_nsec - start->tv_nsec;
++ if (end->tv_nsec < start->tv_nsec) {
++ diff->tv_sec--; /* "Borrow" from seconds. */
++ diff->tv_nsec = 1000000000 + end->tv_nsec - start->tv_nsec;
++ } else
++ diff->tv_nsec = end->tv_nsec - start->tv_nsec;
+ #endif /* #ifdef RS6000 */
+
+ #ifdef SOLHR
+- *diff = *end - *start;
++ *diff = *end - *start;
+ #endif
+
+ #ifdef PARAGON
+- *diff = *end - *start;
+-#endif /* #ifdef PARAGON */
++ *diff = *end - *start;
++#endif /* #ifdef PARAGON */
+ }
+
+
+ void
+ globus_utp_timeAdd(globus_utp_TimeValue_t *oldElapsed,
+- const globus_utp_TimeValue_t *newElapsed)
++ const globus_utp_TimeValue_t *newElapsed)
+ {
+ #ifdef UNIX
+- oldElapsed->tv_usec += newElapsed->tv_usec;
++ oldElapsed->tv_usec += newElapsed->tv_usec;
+
+- if (oldElapsed->tv_usec >= 1000000) {
+- oldElapsed->tv_sec++; /* "Carry" into seconds. */
+- oldElapsed->tv_usec -= 1000000;
+- }
++ if (oldElapsed->tv_usec >= 1000000) {
++ oldElapsed->tv_sec++; /* "Carry" into seconds. */
++ oldElapsed->tv_usec -= 1000000;
++ }
+
+- oldElapsed->tv_sec += newElapsed->tv_sec;
++ oldElapsed->tv_sec += newElapsed->tv_sec;
+ #endif /* #ifdef UNIX */
+
+ #ifdef RS6000
+- oldElapsed->tv_nsec += newElapsed->tv_nsec;
++ oldElapsed->tv_nsec += newElapsed->tv_nsec;
+
+- if (oldElapsed->tv_nsec >= 1000000000) {
+- oldElapsed->tv_sec++; /* "Carry" into seconds. */
+- oldElapsed->tv_nsec -= 1000000000;
+- }
++ if (oldElapsed->tv_nsec >= 1000000000) {
++ oldElapsed->tv_sec++; /* "Carry" into seconds. */
++ oldElapsed->tv_nsec -= 1000000000;
++ }
+
+- oldElapsed->tv_sec += newElapsed->tv_sec;
++ oldElapsed->tv_sec += newElapsed->tv_sec;
+ #endif /* #ifdef RS6000 */
+
+ #ifdef SOLHR
+- *oldElapsed += *newElapsed;
++ *oldElapsed += *newElapsed;
+ #endif
+
+ #ifdef PARAGON
+- *oldElapsed += *newElapsed;
+-#endif /* #ifdef PARAGON */
++ *oldElapsed += *newElapsed;
++#endif /* #ifdef PARAGON */
+ }
+
+
+@@ -673,22 +673,22 @@ void
+ globus_utp_timeZero(globus_utp_TimeValue_t *tv)
+ {
+ #ifdef UNIX
+- tv->tv_sec = 0;
+- tv->tv_usec = 0;
++ tv->tv_sec = 0;
++ tv->tv_usec = 0;
+ #endif /* #ifdef UNIX */
+
+ #ifdef RS6000
+- tv->tv_sec = 0;
+- tv->tv_nsec = 0;
++ tv->tv_sec = 0;
++ tv->tv_nsec = 0;
+ #endif /* #ifdef RS6000 */
+
+ #ifdef SOLHR
+- *tv = 0;
++ *tv = 0;
+ #endif
+
+ #ifdef PARAGON
+- *tv = 0.0;
+-#endif /* #ifdef PARAGON */
++ *tv = 0.0;
++#endif /* #ifdef PARAGON */
+ }
+
+
+@@ -696,37 +696,37 @@ void
+ globus_utp_timeToDouble(double *time, int *precision, const globus_utp_TimeValue_t *tv)
+ {
+ #ifdef UNIX
+- *time = (double) tv->tv_sec + ((double) tv->tv_usec) / 1000000.0;
+- *precision = 6;
++ *time = (double) tv->tv_sec + ((double) tv->tv_usec) / 1000000.0;
++ *precision = 6;
+ #endif /* #ifdef UNIX */
+
+ #ifdef RS6000
+- *time = (double) tv->tv_sec + ((double) tv->tv_nsec) /
+- 1000000000.0;
+- *precision = 7;
++ *time = (double) tv->tv_sec + ((double) tv->tv_nsec) /
++ 1000000000.0;
++ *precision = 7;
+ #endif /* #ifdef RS6000 */
+
+ #ifdef SOLHR
+- *time = ((double)*tv) / 1000000000.0;
+- *precision = 6;
++ *time = ((double)*tv) / 1000000000.0;
++ *precision = 6;
+ #endif
+
+ #ifdef PARAGON
+- *time = *tv;
+- *precision = 7;
+-#endif /* #ifdef PARAGON */
++ *time = *tv;
++ *precision = 7;
++#endif /* #ifdef PARAGON */
+ }
+
+
+ void
+ globus_utp_timeToString(char timeString[], const globus_utp_TimeValue_t *tv)
+ {
+- double tvAsDouble;
+- int precision;
++ double tvAsDouble;
++ int precision;
+
+- globus_utp_timeToDouble(&tvAsDouble, &precision, tv);
++ globus_utp_timeToDouble(&tvAsDouble, &precision, tv);
+
+- sprintf(timeString, "%.*f", precision, tvAsDouble);
++ sprintf(timeString, "%.*f", precision, tvAsDouble);
+ }
+
+
+@@ -735,13 +735,13 @@ globus_utp_warn(const char *messageStr, ...)
+ {
+ # if defined(DEBUG)
+ {
+- va_list ap;
++ va_list ap;
+
+- va_start(ap, messageStr);
++ va_start(ap, messageStr);
+
+- vfprintf(stderr, messageStr, ap);
+- fprintf(stderr, "\n");
+- fflush(stderr); /* Just to be safe. */
++ vfprintf(stderr, messageStr, ap);
++ fprintf(stderr, "\n");
++ fflush(stderr); /* Just to be safe. */
+ }
+ # endif
+ }
+--
+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..41f0d67
--- /dev/null
+++ b/0002-Fix-compiler-and-doxygen-warnings.patch
@@ -0,0 +1,777 @@
+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
+
+---
+ xio/src/builtins/http/globus_i_xio_http.h | 2 +-
+ xio/src/builtins/http/globus_xio_http.c | 6 +++-
+ xio/src/builtins/http/globus_xio_http_attr.c | 4 +++
+ .../builtins/http/globus_xio_http_client.c | 11 +++----
+ .../builtins/http/globus_xio_http_handle.c | 15 +++------
+ .../builtins/http/globus_xio_http_header.c | 8 ++---
+ .../http/globus_xio_http_header_info.c | 6 ++--
+ .../builtins/http/globus_xio_http_request.c | 6 ++--
+ .../builtins/http/globus_xio_http_response.c | 6 ++--
+ .../builtins/http/globus_xio_http_server.c | 10 +++---
+ .../builtins/http/globus_xio_http_target.c | 4 +++
+ .../builtins/http/globus_xio_http_transform.c | 32 +++----------------
+ .../mode_e/globus_xio_mode_e_driver.c | 4 +--
+ xio/src/globus_xio_driver.c | 2 +-
+ xio/src/globus_xio_system_select.c | 17 ++++------
+ xio/src/test/drivers/globus_xio_smtp.c | 7 ++--
+ xio/src/test/globus_utp_main.c | 8 +++--
+ xio/src/test/http_timeout_test.c | 22 ++++++-------
+ 18 files changed, 74 insertions(+), 96 deletions(-)
+
+diff --git a/xio/src/builtins/http/globus_i_xio_http.h b/xio/src/builtins/http/globus_i_xio_http.h
+index 155dfde34..c8b93f28b 100644
+--- a/xio/src/builtins/http/globus_i_xio_http.h
++++ b/xio/src/builtins/http/globus_i_xio_http.h
+@@ -437,7 +437,7 @@ globus_i_xio_http_copy_blob(
+ extern
+ char *
+ globus_i_xio_http_find_eol(
+- const char * blob,
++ char * blob,
+ globus_size_t blob_length);
+
+ extern
+diff --git a/xio/src/builtins/http/globus_xio_http.c b/xio/src/builtins/http/globus_xio_http.c
+index c3535e024..14841c526 100644
+--- a/xio/src/builtins/http/globus_xio_http.c
++++ b/xio/src/builtins/http/globus_xio_http.c
+@@ -171,6 +171,8 @@ globus_i_xio_http_copy_blob(
+ }
+ /* globus_l_xio_http_copy_blob() */
+
++#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
++
+ /**
+ * Determine whether an HTTP method should contain an entity.
+ * @ingroup globus_i_xio_http_util
+@@ -274,7 +276,7 @@ globus_i_xio_http_guess_version(
+ */
+ char *
+ globus_i_xio_http_find_eol(
+- const char * blob,
++ char * blob,
+ globus_size_t blob_length)
+ {
+ char * result;
+@@ -379,6 +381,8 @@ error_exit:
+ }
+ /* globus_i_xio_http_cleanup_read_buffer() */
+
++#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
++
+ GlobusXIODefineDriver(
+ http,
+ globus_l_xio_http_init,
+diff --git a/xio/src/builtins/http/globus_xio_http_attr.c b/xio/src/builtins/http/globus_xio_http_attr.c
+index 2d3d3d7bd..94de4ee2d 100644
+--- a/xio/src/builtins/http/globus_xio_http_attr.c
++++ b/xio/src/builtins/http/globus_xio_http_attr.c
+@@ -23,6 +23,8 @@
+ */
+ #endif
+
++#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
++
+ /**
+ * Allocate and initialize an HTTP attribute
+ * @ingroup globus_i_xio_http_attr
+@@ -355,3 +357,5 @@ globus_i_xio_http_attr_destroy(
+ return GLOBUS_SUCCESS;
+ }
+ /* globus_i_xio_http_attr_destroy() */
++
++#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
+diff --git a/xio/src/builtins/http/globus_xio_http_client.c b/xio/src/builtins/http/globus_xio_http_client.c
+index 75a018172..225083a20 100644
+--- a/xio/src/builtins/http/globus_xio_http_client.c
++++ b/xio/src/builtins/http/globus_xio_http_client.c
+@@ -36,6 +36,8 @@ globus_result_t
+ globus_l_xio_http_cleanup_cancel(
+ globus_i_xio_http_handle_t * http_handle);
+
++#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
++
+ /**
+ * Client-side connection open callback
+ * @ingroup globus_i_xio_http_client
+@@ -54,8 +56,6 @@ globus_l_xio_http_cleanup_cancel(
+ * Lower-level protocol result from open.
+ * @param user_arg
+ * A void pointer pointing to a #globus_i_xio_http_driver_t
+- *
+- * @return void
+ */
+ void
+ globus_i_xio_http_client_open_callback(
+@@ -476,8 +476,6 @@ error_exit:
+ * Number of bytes in the message that were written.
+ * @param user_arg
+ * Void pointer containing the #globus_i_xio_http_handle_t.
+- *
+- * @return void
+ */
+ static
+ void
+@@ -660,10 +658,7 @@ error_exit:
+ * @param user_arg
+ * Void * pointing to the #globus_i_xio_http_handle_t associated
+ * with this response.
+- *
+- * @return void
+ */
+-
+ void
+ globus_l_xio_http_client_read_response_callback(
+ globus_xio_operation_t op,
+@@ -1133,3 +1128,5 @@ globus_l_xio_http_cleanup_cancel(
+
+ return result;
+ }
++
++#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
+diff --git a/xio/src/builtins/http/globus_xio_http_handle.c b/xio/src/builtins/http/globus_xio_http_handle.c
+index 104cee0db..6261e5c82 100644
+--- a/xio/src/builtins/http/globus_xio_http_handle.c
++++ b/xio/src/builtins/http/globus_xio_http_handle.c
+@@ -31,6 +31,8 @@ globus_l_xio_http_write_eof_callback(
+ globus_size_t nbytes,
+ void * user_arg);
+
++#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
++
+ /**
+ * Allocate and initialize an HTTP handle
+ * @ingroup globus_i_xio_http_handle
+@@ -227,8 +229,6 @@ free_mutex_exit:
+ *
+ * @param http_handle
+ * Handle to be destroyed.
+- *
+- * @return void
+ */
+ void
+ globus_i_xio_http_handle_destroy(
+@@ -438,6 +438,8 @@ globus_i_xio_http_handle_cntl(
+ }
+ /* globus_i_xio_http_handle_cntl() */
+
++#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
++
+ /**
+ * Called with mutex locked
+ */
+@@ -446,7 +448,6 @@ globus_i_xio_http_set_end_of_entity(
+ globus_i_xio_http_handle_t * http_handle)
+ {
+ globus_result_t result = GLOBUS_SUCCESS;
+- globus_i_xio_http_header_info_t * headers;
+ static globus_xio_iovec_t end_of_body_iovec = {
+ .iov_base = "0\r\n\r\n",
+ .iov_len = 5
+@@ -459,14 +460,6 @@ globus_i_xio_http_set_end_of_entity(
+
+ goto error_exit;
+ }
+- else if (http_handle->target_info.is_client)
+- {
+- headers = &http_handle->request_info.headers;
+- }
+- else
+- {
+- headers = &http_handle->response_info.headers;
+- }
+
+ if (http_handle->send_state == GLOBUS_XIO_HTTP_STATUS_LINE)
+ {
+diff --git a/xio/src/builtins/http/globus_xio_http_header.c b/xio/src/builtins/http/globus_xio_http_header.c
+index d4c687a65..5b53e2725 100644
+--- a/xio/src/builtins/http/globus_xio_http_header.c
++++ b/xio/src/builtins/http/globus_xio_http_header.c
+@@ -23,6 +23,8 @@
+ */
+ #endif
+
++#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
++
+ /**
+ * Destroy an HTTP Header
+ * @ingroup globus_i_xio_http_header
+@@ -33,8 +35,6 @@
+ *
+ * @param header
+ * A <code>void *</code> pointing to the header to be freed.
+- *
+- * @return void
+ */
+ extern
+ void
+@@ -76,8 +76,6 @@ globus_i_xio_http_header_destroy(
+ * @param src_datum
+ * A <code>void *</code> pointing to the HTTP header structure in the
+ * original hashtable to copy.
+- *
+- * @return void
+ */
+ extern
+ void
+@@ -295,3 +293,5 @@ error_exit:
+ return result;
+ }
+ /* globus_i_xio_http_header_parse() */
++
++#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
+diff --git a/xio/src/builtins/http/globus_xio_http_header_info.c b/xio/src/builtins/http/globus_xio_http_header_info.c
+index 75367887b..af1189260 100644
+--- a/xio/src/builtins/http/globus_xio_http_header_info.c
++++ b/xio/src/builtins/http/globus_xio_http_header_info.c
+@@ -23,6 +23,8 @@
+ */
+ #endif
+
++#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
++
+ /**
+ * Initialize an HTTP header info structure
+ * @ingroup globus_i_xio_http_header_info
+@@ -71,8 +73,6 @@ globus_i_xio_http_header_info_init(
+ *
+ * @param header_info
+ * Header information structure to destroy.
+- *
+- * @return void
+ */
+ void
+ globus_i_xio_http_header_info_destroy(
+@@ -308,3 +308,5 @@ error_exit:
+ return result;
+ }
+ /* globus_l_xio_http_header_info_set_header() */
++
++#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
+diff --git a/xio/src/builtins/http/globus_xio_http_request.c b/xio/src/builtins/http/globus_xio_http_request.c
+index 067875940..d4a1e8f23 100644
+--- a/xio/src/builtins/http/globus_xio_http_request.c
++++ b/xio/src/builtins/http/globus_xio_http_request.c
+@@ -23,6 +23,8 @@
+ */
+ #endif
+
++#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
++
+ /**
+ * Initialize an HTTP request
+ * @ingroup globus_i_xio_http_request
+@@ -57,8 +59,6 @@ globus_i_xio_http_request_init(
+ *
+ * @param request
+ * Request structure to destroy.
+- *
+- * @return void
+ */
+ void
+ globus_i_xio_http_request_destroy(
+@@ -168,3 +168,5 @@ error_exit:
+ return res;
+ }
+ /* globus_i_xio_http_request_copy() */
++
++#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
+diff --git a/xio/src/builtins/http/globus_xio_http_response.c b/xio/src/builtins/http/globus_xio_http_response.c
+index ec477477a..0951ae16a 100644
+--- a/xio/src/builtins/http/globus_xio_http_response.c
++++ b/xio/src/builtins/http/globus_xio_http_response.c
+@@ -23,6 +23,8 @@
+ */
+ #endif
+
++#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
++
+ /**
+ * Initialize an HTTP response
+ * @ingroup globus_i_xio_http_response
+@@ -65,8 +67,6 @@ globus_i_xio_http_response_init(
+ *
+ * @param response
+ * Response structure to destroy.
+- *
+- * @return void
+ */
+ void
+ globus_i_xio_http_response_destroy(
+@@ -153,3 +153,5 @@ error_exit:
+ return res;
+ }
+ /* globus_i_xio_http_response_copy() */
++
++#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
+diff --git a/xio/src/builtins/http/globus_xio_http_server.c b/xio/src/builtins/http/globus_xio_http_server.c
+index 5d3ad0ab7..41db9f877 100644
+--- a/xio/src/builtins/http/globus_xio_http_server.c
++++ b/xio/src/builtins/http/globus_xio_http_server.c
+@@ -44,6 +44,8 @@ globus_l_xio_http_server_write_response_callback(
+ globus_size_t nbytes,
+ void * user_arg);
+
++#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
++
+ /**
+ * Accept an HTTP request
+ * @ingroup globus_i_xio_http_server
+@@ -87,8 +89,6 @@ globus_i_xio_http_accept(
+ * @param user_arg
+ * Not used.
+ *
+- * @return void
+- *
+ * @todo When implemented in the XIO driver framework, parse the request
+ * header before returning from this, so the target is populated with
+ * meaningful information for the user. This will help enable persistent
+@@ -134,8 +134,6 @@ globus_l_xio_http_accept_callback(
+ * @param user_arg
+ * Void * pointing to a #globus_i_xio_http_handle_t associated with
+ * this open.
+- *
+- * @return void
+ */
+ void
+ globus_i_xio_http_server_open_callback(
+@@ -498,8 +496,6 @@ error_exit:
+ * finished. If the response was triggered by the
+ * GLOBUS_XIO_HTTP_HANDLE_SET_END_OF_ENTITY control, then the operation
+ * is simply destroyed.
+- *
+- * @return void
+ */
+ static
+ void
+@@ -740,6 +736,8 @@ error_exit_init:
+ }
+ /* globus_l_xio_http_server_parse_request() */
+
++#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
++
+ void
+ globus_i_xio_http_server_read_request_callback(
+ globus_xio_operation_t op,
+diff --git a/xio/src/builtins/http/globus_xio_http_target.c b/xio/src/builtins/http/globus_xio_http_target.c
+index 6e8d22f34..c87486efd 100644
+--- a/xio/src/builtins/http/globus_xio_http_target.c
++++ b/xio/src/builtins/http/globus_xio_http_target.c
+@@ -23,6 +23,8 @@
+ */
+ #endif
+
++#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
++
+ /**
+ * Allocate a new target
+ * @ingroup globus_i_xio_http_target
+@@ -219,6 +221,8 @@ globus_i_xio_http_target_destroy(
+ }
+ /* globus_i_xio_http_target_destroy() */
+
++#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
++
+ extern
+ void
+ globus_i_xio_http_target_destroy_internal(
+diff --git a/xio/src/builtins/http/globus_xio_http_transform.c b/xio/src/builtins/http/globus_xio_http_transform.c
+index 6a4556d23..cc1162e77 100644
+--- a/xio/src/builtins/http/globus_xio_http_transform.c
++++ b/xio/src/builtins/http/globus_xio_http_transform.c
+@@ -94,6 +94,8 @@ void
+ globus_l_xio_http_read_timeout_callback(
+ void * user_arg);
+
++#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
++
+ /**
+ * Open an HTTP URI
+ * @ingroup globus_i_xio_http_transform
+@@ -645,8 +647,6 @@ error_exit:
+ * @param registered_again
+ * Set to GLOBUS_TRUE by this function if the read operation was passed
+ * down again as a result of a partial read of data.
+- *
+- * @return void
+ */
+ globus_result_t
+ globus_i_xio_http_parse_residue(
+@@ -969,8 +969,6 @@ globus_l_xio_http_copy_residue(
+ * Number of bytes read by the transport.
+ * @param user_arg
+ * Void pointer pointing to an HTTP handle.
+- *
+- * @return void
+ */
+ static
+ void
+@@ -1057,8 +1055,6 @@ globus_l_xio_http_read_callback(
+ * Number of bytes read by the transport.
+ * @param user_arg
+ * Void pointer pointing to an HTTP handle.
+- *
+- * @return void
+ */
+ static
+ void
+@@ -1393,18 +1389,8 @@ globus_i_xio_http_write(
+ {
+ globus_i_xio_http_handle_t * http_handle = handle;
+ globus_result_t result = GLOBUS_SUCCESS;
+- globus_i_xio_http_header_info_t * headers;
+ GlobusXIOName(globus_i_xio_http_write);
+
+- if (http_handle->target_info.is_client)
+- {
+- headers = &http_handle->request_info.headers;
+- }
+- else
+- {
+- headers = &http_handle->response_info.headers;
+- }
+-
+ globus_mutex_lock(&http_handle->mutex);
+
+ if (http_handle->pending_error)
+@@ -1624,8 +1610,6 @@ error_exit:
+ * Number of bytes written by the transport.
+ * @param user_arg
+ * Void pointer to a globus_i_xio_http_handle_t.
+- *
+- * @return void
+ */
+ void
+ globus_i_xio_http_write_callback(
+@@ -1851,19 +1835,9 @@ globus_result_t
+ globus_i_xio_http_close_internal(
+ globus_i_xio_http_handle_t * http_handle)
+ {
+- globus_i_xio_http_header_info_t * headers;
+ globus_result_t result;
+ globus_reltime_t delay;
+
+- if (http_handle->target_info.is_client)
+- {
+- headers = &http_handle->request_info.headers;
+- }
+- else
+- {
+- headers = &http_handle->response_info.headers;
+- }
+-
+ http_handle->send_state = GLOBUS_XIO_HTTP_CLOSE;
+
+ if (http_handle->target_info.is_client &&
+@@ -1900,6 +1874,8 @@ finish:
+ }
+ /* globus_i_xio_http_close_internal() */
+
++#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
++
+ void
+ globus_i_xio_http_close_callback(
+ globus_xio_operation_t op,
+diff --git a/xio/src/builtins/mode_e/globus_xio_mode_e_driver.c b/xio/src/builtins/mode_e/globus_xio_mode_e_driver.c
+index 65952a036..a8ce5994f 100644
+--- a/xio/src/builtins/mode_e/globus_xio_mode_e_driver.c
++++ b/xio/src/builtins/mode_e/globus_xio_mode_e_driver.c
+@@ -1740,8 +1740,8 @@ globus_l_xio_mode_e_open_new_stream(
+ {
+ globus_xio_handle_t xio_handle;
+ globus_l_xio_mode_e_attr_t * attr;
+- globus_i_xio_mode_e_requestor_t * requestor;
+- globus_xio_operation_t op;
++ globus_i_xio_mode_e_requestor_t * requestor = GLOBUS_NULL;
++ globus_xio_operation_t op = GLOBUS_XIO_OPERATION_TYPE_NONE;
+ globus_result_t result;
+ GlobusXIOName(globus_l_xio_mode_e_open_new_stream);
+
+diff --git a/xio/src/globus_xio_driver.c b/xio/src/globus_xio_driver.c
+index 18503394e..3504792de 100644
+--- a/xio/src/globus_xio_driver.c
++++ b/xio/src/globus_xio_driver.c
+@@ -2347,7 +2347,7 @@ globus_xio_operation_get_user_driver(
+
+ /**
+ * @brief Get the XIO transport driver associated with an op
+- * @ingroup globus_xio_driver_programming
++ * @ingroup string_globus_xio_driver_programming
+ */
+ globus_xio_driver_t
+ globus_xio_operation_get_transport_user_driver(
+diff --git a/xio/src/globus_xio_system_select.c b/xio/src/globus_xio_system_select.c
+index b2cd56475..f5059535f 100644
+--- a/xio/src/globus_xio_system_select.c
++++ b/xio/src/globus_xio_system_select.c
+@@ -985,14 +985,13 @@ globus_l_xio_system_handle_read(
+ }
+ else
+ {
+- int rc;
+ globus_l_xio_system_t tmp_handle;
+
+ *read_info->sop.non_data.out_fd = new_fd;
+ tmp_handle.fd = new_fd;
+ tmp_handle.type = GLOBUS_XIO_SYSTEM_TCP;
+
+- rc = globus_l_xio_system_remove_nonblocking(&tmp_handle);
++ globus_l_xio_system_remove_nonblocking(&tmp_handle);
+
+ read_info->nbytes++;
+ GlobusXIOSystemDebugPrintf(
+@@ -1870,7 +1869,6 @@ globus_l_xio_system_read(
+ globus_size_t * u_nbytes)
+ {
+ globus_result_t result;
+- int rc;
+ GlobusXIOName(globus_l_xio_system_read);
+
+ GlobusXIOSystemDebugEnter();
+@@ -1891,7 +1889,7 @@ globus_l_xio_system_read(
+ * worst case, we read 0 bytes in the loop below, return, and xio
+ * calls us again to finish up.
+ */
+- rc = globus_l_xio_system_remove_nonblocking(handle);
++ globus_l_xio_system_remove_nonblocking(handle);
+ GlobusIXIOSystemAllocIovec(u_iovc, iov);
+ if(!iov)
+ {
+@@ -1921,14 +1919,14 @@ globus_l_xio_system_read(
+ *u_nbytes = total;
+
+ GlobusIXIOSystemFreeIovec(u_iovc, (globus_xio_iovec_t *) u_iov);
+- rc = globus_l_xio_system_add_nonblocking(handle);
++ globus_l_xio_system_add_nonblocking(handle);
+ }
+
+ GlobusXIOSystemDebugExit();
+ return result;
+
+ error_iovec:
+- rc = globus_l_xio_system_add_nonblocking(handle);
++ globus_l_xio_system_add_nonblocking(handle);
+ GlobusXIOSystemDebugExitWithError();
+ return result;
+ }
+@@ -2020,7 +2018,6 @@ globus_l_xio_system_write(
+ globus_size_t * u_nbytes)
+ {
+ globus_result_t result;
+- int rc;
+ GlobusXIOName(globus_l_xio_system_write);
+
+ GlobusXIOSystemDebugEnter();
+@@ -2039,7 +2036,7 @@ globus_l_xio_system_write(
+ * XXX this is not thread safe... both reads and writes are mucking
+ * with blocking status
+ */
+- rc = globus_l_xio_system_remove_nonblocking(handle);
++ globus_l_xio_system_remove_nonblocking(handle);
+ GlobusIXIOSystemAllocIovec(u_iovc, iov);
+ if(!iov)
+ {
+@@ -2063,14 +2060,14 @@ globus_l_xio_system_write(
+ *u_nbytes = total;
+
+ GlobusIXIOSystemFreeIovec(u_iovc, (globus_xio_iovec_t *) u_iov);
+- rc = globus_l_xio_system_add_nonblocking(handle);
++ globus_l_xio_system_add_nonblocking(handle);
+ }
+
+ GlobusXIOSystemDebugExit();
+ return result;
+
+ error_iovec:
+- rc = globus_l_xio_system_add_nonblocking(handle);
++ globus_l_xio_system_add_nonblocking(handle);
+ GlobusXIOSystemDebugExitWithError();
+ return result;
+ }
+diff --git a/xio/src/test/drivers/globus_xio_smtp.c b/xio/src/test/drivers/globus_xio_smtp.c
+index 84003f93d..72851c858 100644
+--- a/xio/src/test/drivers/globus_xio_smtp.c
++++ b/xio/src/test/drivers/globus_xio_smtp.c
+@@ -274,7 +274,6 @@ globus_l_xio_smtp_write_header_cb(
+ globus_size_t nbytes,
+ void * user_arg)
+ {
+- globus_result_t res;
+ l_smtp_info_t * info;
+
+ info = (l_smtp_info_t *) user_arg;
+@@ -291,7 +290,7 @@ globus_l_xio_smtp_write_header_cb(
+ */
+ else
+ {
+- res = globus_xio_driver_pass_read(op, &info->iovec, 1,
++ globus_xio_driver_pass_read(op, &info->iovec, 1,
+ 1, globus_l_xio_smtp_read_header_cb, (void *) info);
+ }
+ }
+@@ -363,9 +362,7 @@ globus_l_xio_smtp_write_close_cb(
+ globus_size_t nbytes,
+ void * user_arg)
+ {
+- globus_result_t res;
+-
+- res = globus_xio_driver_pass_close(
++ globus_xio_driver_pass_close(
+ op, globus_l_xio_smtp_close_cb, user_arg);
+ }
+
+diff --git a/xio/src/test/globus_utp_main.c b/xio/src/test/globus_utp_main.c
+index 184b395a7..43f59d467 100644
+--- a/xio/src/test/globus_utp_main.c
++++ b/xio/src/test/globus_utp_main.c
+@@ -550,16 +550,18 @@ void
+ globus_utp_readTime(globus_utp_TimeValue_t *tv)
+ {
+ #ifdef UNIX
++#ifdef DEBUG
+ int flag;
+
+ flag = gettimeofday(tv, NULL);
+
+-#ifdef DEBUG
+ if (flag) {
+ globus_utp_warn("globus_utp_readTime: gettimeofday() failed");
+ globus_utp_warn("globus_utp_readTime: system error message is \"%s\"",
+ sys_errlist[errno]);
+ }
++#else
++ gettimeofday(tv, NULL);
+ #endif /* #ifdef DEBUG */
+ #endif /* #ifdef UNIX */
+
+@@ -577,16 +579,18 @@ on p. 59 of the "Optimizing and Tuning Guide for FORTRAN, C, and C++", and
+ seems to work just fine.
+ */
+
++#ifdef DEBUG
+ int flag;
+
+ flag = gettimer(TIMEOFDAY, tv);
+
+-#ifdef DEBUG
+ if (flag) {
+ globus_utp_warn("globus_utp_readTime: gettimer() failed");
+ globus_utp_warn("globus_utp_readTime: system error message is \"%s\"",
+ sys_errlist[errno]);
+ }
++#else
++ gettimer(TIMEOFDAY, tv);
+ #endif /* #ifdef DEBUG */
+
+ #endif /* #ifdef RS6000 */
+diff --git a/xio/src/test/http_timeout_test.c b/xio/src/test/http_timeout_test.c
+index a1a4ed635..d5335a7b0 100644
+--- a/xio/src/test/http_timeout_test.c
++++ b/xio/src/test/http_timeout_test.c
+@@ -108,7 +108,6 @@ main(
+ {
+ int rc;
+ char * contact = NULL;
+- globus_result_t result;
+ globus_l_timeout_info_t client_timeout_info;
+ globus_l_timeout_info_t server_timeout_info;
+ globus_reltime_t timeout;
+@@ -314,12 +313,12 @@ main(
+ server_timeout_info.handle = NULL;
+ server_timeout_info.result = GLOBUS_SUCCESS;
+ server_timeout_info.contact = NULL;
+- result = globus_xio_server_create(
++ globus_xio_server_create(
+ &server_timeout_info.server,
+ server_timeout_info.attr,
+ globus_l_http_stack);
+
+- result = globus_xio_server_get_contact_string(
++ globus_xio_server_get_contact_string(
+ server_timeout_info.server,
+ &contact);
+
+@@ -333,19 +332,19 @@ main(
+ client_timeout_info.result = GLOBUS_SUCCESS;
+ client_timeout_info.server = NULL;
+
+- result = globus_xio_handle_create(
++ globus_xio_handle_create(
+ &client_timeout_info.handle,
+ globus_l_http_stack);
+
+ /* oneshot to start server state machine */
+- result = globus_callback_register_oneshot(
++ globus_callback_register_oneshot(
+ NULL,
+ &globus_i_reltime_zero,
+ state_machine,
+ &server_timeout_info);
+
+ /* oneshot to start client state machine */
+- result = globus_callback_register_oneshot(
++ globus_callback_register_oneshot(
+ NULL,
+ &globus_i_reltime_zero,
+ state_machine,
+@@ -534,7 +533,6 @@ state_machine(
+ void * user_arg)
+ {
+ globus_reltime_t delay;
+- globus_result_t result;
+ globus_l_timeout_info_t * info = user_arg;
+
+ /* If the timeout is to be caused by this side of the transfer, then check
+@@ -568,14 +566,14 @@ state_machine(
+ {
+ case GLOBUS_XIO_OPERATION_TYPE_ACCEPT:
+ globus_assert(info->server);
+- result = globus_xio_server_register_accept(
++ globus_xio_server_register_accept(
+ info->server,
+ accept_callback,
+ info);
+ break;
+
+ case GLOBUS_XIO_OPERATION_TYPE_OPEN:
+- result = globus_xio_register_open(
++ globus_xio_register_open(
+ info->handle,
+ info->contact,
+ info->attr,
+@@ -584,7 +582,7 @@ state_machine(
+ break;
+
+ case GLOBUS_XIO_OPERATION_TYPE_READ:
+- result = globus_xio_register_read(
++ globus_xio_register_read(
+ info->handle,
+ info->buffer,
+ sizeof(info->buffer),
+@@ -597,7 +595,7 @@ state_machine(
+ case GLOBUS_XIO_OPERATION_TYPE_WRITE:
+ strcpy((char *) info->buffer, "ok\n");
+
+- result = globus_xio_register_write(
++ globus_xio_register_write(
+ info->handle,
+ info->buffer,
+ strlen((char *) info->buffer),
+@@ -608,7 +606,7 @@ state_machine(
+ break;
+
+ case GLOBUS_XIO_OPERATION_TYPE_CLOSE:
+- result = globus_xio_register_close(
++ globus_xio_register_close(
+ info->handle,
+ NULL,
+ open_close_callback,
+--
+2.54.0
+
diff --git a/globus-xio.spec b/globus-xio.spec
index a75c0cb..b64c507 100644
--- a/globus-xio.spec
+++ b/globus-xio.spec
@@ -1,13 +1,15 @@
Name: globus-xio
%global _name %(tr - _ <<< %{name})
Version: 6.6
-Release: 10%{?dist}
+Release: 11%{?dist}
Summary: Grid Community Toolkit - Globus XIO Framework
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
@@ -63,6 +65,8 @@ Globus XIO Framework Documentation Files
%prep
%setup -q -n %{_name}-%{version}
+%patch -P0 -p3
+%patch -P1 -p3
%build
# Reduce overlinking
@@ -114,6 +118,9 @@ GLOBUS_HOSTNAME=localhost %make_build check
%license GLOBUS_LICENSE
%changelog
+* Sun Jun 14 2026 Mattias Ellert <mattias.ellert@physics.uu.se> - 6.6-11
+- Fix compiler and doxygen warnings
+
* Fri Jan 16 2026 Fedora Release Engineering <releng@fedoraproject.org> - 6.6-10
- 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:55 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:55 [rpms/globus-xio] 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