public inbox for git-commits@fedoraproject.org
help / color / mirror / Atom feed
* [rpms/globus-gass-copy] rawhide: Compile with OpenSSL 4
@ 2026-06-14 8:46 Mattias Ellert
0 siblings, 0 replies; only message in thread
From: Mattias Ellert @ 2026-06-14 8:46 UTC (permalink / raw)
To: git-commits
A new commit has been pushed.
Repo : rpms/globus-gass-copy
Branch : rawhide
Commit : ed5db135bf90242f2e4bf7f5301fb20e4e12582b
Author : Mattias Ellert <mattias.ellert@physics.uu.se>
Date : 2026-06-14T10:39:13+02:00
Stats : +9470/-1 in 4 file(s)
URL : https://src.fedoraproject.org/rpms/globus-gass-copy/c/ed5db135bf90242f2e4bf7f5301fb20e4e12582b?branch=rawhide
Log:
Compile with OpenSSL 4
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..46a8bc5
--- /dev/null
+++ b/0001-Untabify-and-remove-trailing-white-space.patch
@@ -0,0 +1,9240 @@
+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/3] Untabify and remove trailing white-space
+
+---
+ gass/copy/source/globus_gass_copy.c | 3562 +++++++++++++--------------
+ gass/copy/source/globus_url_copy.c | 1202 ++++-----
+ 2 files changed, 2382 insertions(+), 2382 deletions(-)
+
+diff --git a/gass/copy/source/globus_gass_copy.c b/gass/copy/source/globus_gass_copy.c
+index 264ed28e8..3debc7ae3 100644
+--- a/gass/copy/source/globus_gass_copy.c
++++ b/gass/copy/source/globus_gass_copy.c
+@@ -94,7 +94,7 @@ globus_result_t
+ globus_l_gass_copy_state_free_targets(
+ globus_gass_copy_state_t * state);
+
+-static
++static
+ globus_result_t
+ globus_l_gass_copy_verify_cksm(
+ globus_gass_copy_handle_t * copy_handle,
+@@ -118,7 +118,7 @@ globus_l_gass_copy_verify_cksm(
+ globus_object_t *tmp_err; \
+ tmp_err = globus_error_get(result); \
+ handle->err = globus_object_copy(tmp_err); \
+- result = globus_error_put(tmp_err); \
++ result = globus_error_put(tmp_err); \
+ } \
+ }
+
+@@ -153,30 +153,30 @@ globus_l_gass_copy_activate(void)
+ rc = globus_module_activate(GLOBUS_GASS_TRANSFER_MODULE);
+ if (rc != GLOBUS_SUCCESS)
+ {
+- return(rc);
++ return(rc);
+ }
+
+ rc = globus_module_activate(GLOBUS_COMMON_MODULE);
+ if (rc != GLOBUS_SUCCESS)
+ {
+- return(rc);
++ return(rc);
+ }
+
+ rc = globus_module_activate(GLOBUS_IO_MODULE);
+ if (rc != GLOBUS_SUCCESS)
+ {
+- return(rc);
++ return(rc);
+ }
+ rc = globus_module_activate(GLOBUS_FTP_CLIENT_MODULE);
+ if (rc != GLOBUS_SUCCESS)
+ {
+- return(rc);
++ return(rc);
+ }
+
+ rc = globus_module_activate(GLOBUS_FTP_CLIENT_THROUGHPUT_PLUGIN_MODULE);
+ if (rc != GLOBUS_SUCCESS)
+ {
+- return(rc);
++ return(rc);
+ }
+
+ return 0;
+@@ -197,7 +197,7 @@ globus_l_gass_copy_deactivate(void)
+
+ if (rc != GLOBUS_SUCCESS)
+ {
+- return(rc);
++ return(rc);
+ }
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+@@ -207,7 +207,7 @@ globus_l_gass_copy_deactivate(void)
+ rc = globus_module_deactivate(GLOBUS_COMMON_MODULE);
+ if (rc != GLOBUS_SUCCESS)
+ {
+- return(rc);
++ return(rc);
+ }
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+@@ -217,7 +217,7 @@ globus_l_gass_copy_deactivate(void)
+ rc = globus_module_deactivate(GLOBUS_IO_MODULE);
+ if (rc != GLOBUS_SUCCESS)
+ {
+- return(rc);
++ return(rc);
+ }
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+@@ -227,7 +227,7 @@ globus_l_gass_copy_deactivate(void)
+ rc = globus_module_deactivate(GLOBUS_GASS_TRANSFER_MODULE);
+ if (rc != GLOBUS_SUCCESS)
+ {
+- return(rc);
++ return(rc);
+ }
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ globus_libc_fprintf(stderr,"GASS_COPY: done globus_module_deactivate(GLOBUS_GASS_TRANSFER_MODULE) \n");
+@@ -236,7 +236,7 @@ globus_l_gass_copy_deactivate(void)
+ rc = globus_module_deactivate(GLOBUS_FTP_CLIENT_THROUGHPUT_PLUGIN_MODULE);
+ if (rc != GLOBUS_SUCCESS)
+ {
+- return(rc);
++ return(rc);
+ }
+ return 0;
+ } /* globus_i_gass_copy_deactivate() */
+@@ -259,8 +259,8 @@ globus_l_gass_copy_monitor_callback(
+ monitor->done = GLOBUS_TRUE;
+ if(error != GLOBUS_NULL)
+ {
+- monitor->err = globus_object_copy(error);
+- monitor->use_err = GLOBUS_TRUE;
++ monitor->err = globus_object_copy(error);
++ monitor->use_err = GLOBUS_TRUE;
+ }
+ globus_cond_signal(&monitor->cond);
+ globus_mutex_unlock(&monitor->mutex);
+@@ -315,13 +315,13 @@ globus_gass_copy_handle_init(
+
+ if(handle != GLOBUS_NULL)
+ {
+- globus_ftp_client_handleattr_t * ftp_attr;
++ globus_ftp_client_handleattr_t * ftp_attr;
+
+- ftp_attr = (attr && attr->ftp_attr) ? attr->ftp_attr : GLOBUS_NULL;
++ ftp_attr = (attr && attr->ftp_attr) ? attr->ftp_attr : GLOBUS_NULL;
+
+ result = globus_ftp_client_handle_init(&handle->ftp_handle_2,
+ ftp_attr);
+-
++
+ if (result != GLOBUS_SUCCESS)
+ return result;
+
+@@ -350,13 +350,13 @@ globus_gass_copy_handle_init(
+ }
+ else
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, handle is NULL",
+- myname);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, handle is NULL",
++ myname);
+
+- return globus_error_put(err);
++ return globus_error_put(err);
+ }
+ }
+
+@@ -395,7 +395,7 @@ globus_gass_copy_handle_destroy(
+
+ result = globus_ftp_client_handle_destroy(&handle->ftp_handle);
+
+- if(handle->err != GLOBUS_NULL)
++ if(handle->err != GLOBUS_NULL)
+ globus_object_free(handle->err);
+
+ handle->err = GLOBUS_NULL;
+@@ -408,24 +408,24 @@ globus_gass_copy_handle_destroy(
+ globus_free(handle->performance);
+ handle->performance = GLOBUS_NULL;
+ }
+-
++
+ if(handle->state)
+ {
+ globus_l_gass_copy_state_free(handle->state);
+ handle->state = GLOBUS_NULL;
+ }
+-
++
+ return result;
+ }
+ else
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, handle is NULL",
+- myname);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, handle is NULL",
++ myname);
+
+- return globus_error_put(err);
++ return globus_error_put(err);
+ }
+ }
+
+@@ -438,19 +438,19 @@ globus_gass_copy_handleattr_init(
+
+ if(handle_attr)
+ {
+- handle_attr->ftp_attr = GLOBUS_NULL;
++ handle_attr->ftp_attr = GLOBUS_NULL;
+
+- return GLOBUS_SUCCESS;
++ return GLOBUS_SUCCESS;
+ }
+ else
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, handle_attr is NULL",
+- myname);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, handle_attr is NULL",
++ myname);
+
+- return globus_error_put(err);
++ return globus_error_put(err);
+ }
+ }
+
+@@ -463,19 +463,19 @@ globus_gass_copy_handleattr_destroy(
+
+ if(handle_attr != GLOBUS_NULL)
+ {
+- handle_attr->ftp_attr = GLOBUS_NULL;
++ handle_attr->ftp_attr = GLOBUS_NULL;
+
+ return GLOBUS_SUCCESS;
+ }
+ else
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, handle_attr is NULL",
+- myname);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, handle_attr is NULL",
++ myname);
+
+- return globus_error_put(err);
++ return globus_error_put(err);
+ }
+ }
+
+@@ -489,19 +489,19 @@ globus_gass_copy_handleattr_set_ftp_attr(
+
+ if(handle_attr != GLOBUS_NULL)
+ {
+- handle_attr->ftp_attr = ftp_attr;
++ handle_attr->ftp_attr = ftp_attr;
+
+ return GLOBUS_SUCCESS;
+ }
+ else
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, handle_attr is NULL",
+- myname);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, handle_attr is NULL",
++ myname);
+
+- return globus_error_put(err);
++ return globus_error_put(err);
+ }
+ }
+
+@@ -532,18 +532,18 @@ globus_gass_copy_set_buffer_length(
+ static char * myname="globus_gass_copy_set_buffer_length";
+ if (handle)
+ {
+- handle->buffer_length = length;
+- return GLOBUS_SUCCESS;
++ handle->buffer_length = length;
++ return GLOBUS_SUCCESS;
+ }
+ else
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, handle is NULL",
+- myname);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, handle is NULL",
++ myname);
+
+- return globus_error_put(err);
++ return globus_error_put(err);
+ }
+ } /* globus_gass_copy_set_buffer_length() */
+
+@@ -572,18 +572,18 @@ globus_gass_copy_get_buffer_length(
+ static char * myname="globus_gass_copy_get_buffer_length";
+ if (handle)
+ {
+- *length = handle->buffer_length;
+- return GLOBUS_SUCCESS;
++ *length = handle->buffer_length;
++ return GLOBUS_SUCCESS;
+ }
+ else
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, handle is NULL",
+- myname);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, handle is NULL",
++ myname);
+
+- return globus_error_put(err);
++ return globus_error_put(err);
+ }
+ } /* globus_gass_copy_get_buffer_length() */
+
+@@ -620,29 +620,29 @@ globus_gass_copy_set_no_third_party_transfers(
+
+ if(current_status == GLOBUS_GASS_COPY_STATUS_PENDING)
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: Cannot change the value of no_third_party_transfers,"
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: Cannot change the value of no_third_party_transfers,"
+ "\tthere is a transfer currently pending on this handle",
+- myname);
+- return globus_error_put(err);
++ myname);
++ return globus_error_put(err);
+ }
+ else
+ {
+- handle->no_third_party_transfers = no_third_party_transfers;
+- return GLOBUS_SUCCESS;
++ handle->no_third_party_transfers = no_third_party_transfers;
++ return GLOBUS_SUCCESS;
+ }
+ }
+ else
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, handle is NULL",
+- myname);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, handle is NULL",
++ myname);
+
+- return globus_error_put(err);
++ return globus_error_put(err);
+ }
+ } /* globus_gass_copy_set_no_third_party_transfers() */
+
+@@ -674,18 +674,18 @@ globus_gass_copy_get_no_third_party_transfers(
+ static char * myname="globus_gass_copy_get_no_third_party_transfers";
+ if (handle)
+ {
+- *no_third_party_transfers = handle->no_third_party_transfers;
+- return GLOBUS_SUCCESS;
++ *no_third_party_transfers = handle->no_third_party_transfers;
++ return GLOBUS_SUCCESS;
+ }
+ else
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, handle is NULL",
+- myname);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, handle is NULL",
++ myname);
+
+- return globus_error_put(err);
++ return globus_error_put(err);
+ }
+ } /* globus_gass_copy_get_no_third_party_transfers() */
+
+@@ -700,7 +700,7 @@ globus_gass_copy_set_allocate(
+ globus_bool_t send_allo)
+ {
+ handle->send_allo = send_allo;
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+@@ -714,20 +714,20 @@ globus_gass_copy_set_stat_on_expand(
+ globus_bool_t always_stat)
+ {
+ handle->always_stat_on_expand = always_stat;
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+ /**
+- * @brief Stores the checksum algorithm to use with all
++ * @brief Stores the checksum algorithm to use with all
+ * checksum operations.
+ * @ingroup globus_gass_copy
+ * @details
+- * This function sets the checksum algorithm and the handle
++ * This function sets the checksum algorithm and the handle
+ * to be used for checksum calculations to the passed in handle.
+- *
++ *
+ * @param handle
+- * This is the handle to which the checksum algorithm and
++ * This is the handle to which the checksum algorithm and
+ * handle are set.
+ * @param algo
+ * This is the algorithm to set in the handle.
+@@ -737,7 +737,7 @@ globus_gass_copy_set_stat_on_expand(
+ * @return
+ * This function always returns GLOBUS_SUCCESS
+ */
+-globus_result_t
++globus_result_t
+ globus_gass_copy_set_checksum_algo(
+ globus_gass_copy_handle_t * handle,
+ char * algo,
+@@ -757,19 +757,19 @@ globus_gass_copy_set_checksum_algo(
+ * @brief Copies the checksum to the handle's checksum parameter.
+ * @ingroup globus_gass_copy
+ * @details
+- * This function frees any existing checksum value stored in the
++ * This function frees any existing checksum value stored in the
+ * handle, then copies the passed in checksum to the handle.
+- *
++ *
+ * @param handle
+- * The handle to the object to which the checksum shall be set.
++ * The handle to the object to which the checksum shall be set.
+ * @param cksm
+ * The checksum string to be set to the handle.
+ * @return
+ * This function always returns GLOBUS_SUCCESS
+ */
+-globus_result_t
++globus_result_t
+ globus_gass_copy_set_checksum(
+- globus_gass_copy_handle_t * handle,
++ globus_gass_copy_handle_t * handle,
+ char * cksm)
+ {
+ if(handle->state->checksum != GLOBUS_NULL)
+@@ -811,20 +811,20 @@ globus_gass_copy_set_partial_offsets(
+ static char * myname="globus_gass_copy_set_partial_offsets";
+ if (handle)
+ {
+- handle->partial_offset = offset;
+- handle->partial_end_offset = end_offset;
+-
+- return GLOBUS_SUCCESS;
++ handle->partial_offset = offset;
++ handle->partial_end_offset = end_offset;
++
++ return GLOBUS_SUCCESS;
+ }
+ else
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, handle is NULL",
+- myname);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, handle is NULL",
++ myname);
+
+- return globus_error_put(err);
++ return globus_error_put(err);
+ }
+ } /* globus_gass_copy_set_partial_offsets() */
+
+@@ -857,19 +857,19 @@ globus_gass_copy_get_partial_offsets(
+ static char * myname="globus_gass_copy_get_partial_offsets";
+ if (handle)
+ {
+- *offset = handle->partial_offset;
+- *end_offset = handle->partial_end_offset;
+- return GLOBUS_SUCCESS;
++ *offset = handle->partial_offset;
++ *end_offset = handle->partial_end_offset;
++ return GLOBUS_SUCCESS;
+ }
+ else
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, handle is NULL",
+- myname);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, handle is NULL",
++ myname);
+
+- return globus_error_put(err);
++ return globus_error_put(err);
+ }
+ } /* globus_gass_copy_get_partial_offsets() */
+
+@@ -932,19 +932,19 @@ globus_gass_copy_attr_init(
+ static char * myname="globus_gass_copy_attr_init";
+ if(attr!=GLOBUS_NULL)
+ {
+- attr->ftp_attr = GLOBUS_NULL;
+- attr->io = GLOBUS_NULL;
+- attr->gass_requestattr = GLOBUS_NULL;
+- return GLOBUS_SUCCESS;
++ attr->ftp_attr = GLOBUS_NULL;
++ attr->io = GLOBUS_NULL;
++ attr->gass_requestattr = GLOBUS_NULL;
++ return GLOBUS_SUCCESS;
+ }
+ else
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, attr is NULL",
+- myname);
+- return globus_error_put(err);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, attr is NULL",
++ myname);
++ return globus_error_put(err);
+ }
+ }
+
+@@ -983,17 +983,17 @@ globus_gass_copy_attr_set_ftp(
+
+ if(attr != GLOBUS_NULL)
+ {
+- attr->ftp_attr = ftp_attr;
+- return GLOBUS_SUCCESS;
++ attr->ftp_attr = ftp_attr;
++ return GLOBUS_SUCCESS;
+ }
+ else
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, attr is NULL",
+- myname);
+- return globus_error_put(err);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, attr is NULL",
++ myname);
++ return globus_error_put(err);
+ }
+ } /* globus_gass_copy_attr_set_ftp() */
+
+@@ -1031,17 +1031,17 @@ globus_gass_copy_attr_set_io(
+ static char * myname="globus_gass_copy_attr_set_io";
+ if(attr != GLOBUS_NULL)
+ {
+- attr->io = io_attr;
+- return GLOBUS_SUCCESS;
++ attr->io = io_attr;
++ return GLOBUS_SUCCESS;
+ }
+ else
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, attr is NULL",
+- myname);
+- return globus_error_put(err);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, attr is NULL",
++ myname);
++ return globus_error_put(err);
+ }
+ } /* globus_gass_copy_attr_set_io() */
+
+@@ -1080,24 +1080,24 @@ globus_gass_copy_attr_set_gass(
+ static char * myname="globus_gass_copy_attr_set_gass";
+ if(attr != GLOBUS_NULL)
+ {
+- attr->gass_requestattr = gass_attr;
+- return GLOBUS_SUCCESS;
++ attr->gass_requestattr = gass_attr;
++ return GLOBUS_SUCCESS;
+ }
+ else
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, attr is NULL",
+- myname);
+- return globus_error_put(err);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, attr is NULL",
++ myname);
++ return globus_error_put(err);
+ }
+ }
+
+
+
+ /**
+- * @brief Get URL scheme
++ * @brief Get URL scheme
+ * @ingroup globus_gass_copy
+ * @details
+ * This function enables the user to determine what protocol will be used to
+@@ -1131,37 +1131,37 @@ globus_gass_copy_get_url_mode(
+ if ((rc = globus_url_parse(url, &url_info)) != GLOBUS_SUCCESS)
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "copy_url_mode(): globus_url_parse returned !GLOBUS_SUCCESS for url: %s\n", url);
++ globus_libc_fprintf(stderr, "copy_url_mode(): globus_url_parse returned !GLOBUS_SUCCESS for url: %s\n", url);
+ #endif
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: globus_url_parse returned error code: %d for url: %s",
+- myname,
+- rc,
+- url);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: globus_url_parse returned error code: %d for url: %s",
++ myname,
++ rc,
++ url);
+
+- return globus_error_put(err);
++ return globus_error_put(err);
+ }
+
+ if ( (url_info.scheme_type == GLOBUS_URL_SCHEME_FTP) ||
+- (url_info.scheme_type == GLOBUS_URL_SCHEME_SSHFTP) ||
+- (url_info.scheme_type == GLOBUS_URL_SCHEME_GSIFTP) )
++ (url_info.scheme_type == GLOBUS_URL_SCHEME_SSHFTP) ||
++ (url_info.scheme_type == GLOBUS_URL_SCHEME_GSIFTP) )
+ {
+- *mode = GLOBUS_GASS_COPY_URL_MODE_FTP;
++ *mode = GLOBUS_GASS_COPY_URL_MODE_FTP;
+ }
+ else if ( (url_info.scheme_type == GLOBUS_URL_SCHEME_HTTP) ||
+ (url_info.scheme_type == GLOBUS_URL_SCHEME_HTTPS) )
+ {
+- *mode = GLOBUS_GASS_COPY_URL_MODE_GASS;
++ *mode = GLOBUS_GASS_COPY_URL_MODE_GASS;
+ }
+ else if ( url_info.scheme_type == GLOBUS_URL_SCHEME_FILE)
+ {
+- *mode = GLOBUS_GASS_COPY_URL_MODE_IO;
++ *mode = GLOBUS_GASS_COPY_URL_MODE_IO;
+ }
+ else
+ {
+- *mode = GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED;
++ *mode = GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED;
+ }
+
+ globus_url_destroy(&url_info);
+@@ -1207,23 +1207,23 @@ globus_gass_copy_register_performance_cb(
+
+ if(handle == GLOBUS_NULL)
+ {
+- return globus_error_put(
+- globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, handle is NULL",
+- myname));
++ return globus_error_put(
++ globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, handle is NULL",
++ myname));
+ }
+
+ if(handle->status > GLOBUS_GASS_COPY_STATUS_NONE &&
+ handle->status < GLOBUS_GASS_COPY_STATUS_DONE_SUCCESS)
+ {
+ return globus_error_put(
+- globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: There is a transfer active on this handle",
+- myname));
++ globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: There is a transfer active on this handle",
++ myname));
+ }
+
+ if(callback == GLOBUS_NULL)
+@@ -1248,11 +1248,11 @@ globus_gass_copy_register_performance_cb(
+ if(handle->performance == GLOBUS_NULL)
+ {
+ return globus_error_put(
+- globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: Memory allocation error",
+- myname));
++ globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: Memory allocation error",
++ myname));
+ }
+
+ handle->performance->copy_handle = handle;
+@@ -1303,7 +1303,7 @@ globus_l_gass_copy_perf_local_cb(
+ long usecs;
+ globus_gass_copy_handle_t * handle;
+ globus_gass_copy_performance_cb_t callback;
+-
++
+ perf_info = (globus_gass_copy_perf_info_t *) user_arg;
+
+ globus_mutex_lock(&perf_info->lock);
+@@ -1311,37 +1311,37 @@ globus_l_gass_copy_perf_local_cb(
+ GlobusTimeAbstimeGetCurrent(timebuf);
+ GlobusTimeAbstimeGet(timebuf, secs, usecs);
+ time_now = secs + (usecs / 1000000.0);
+-
++
+ bytes_now = perf_info->live_bytes;
+-
++
+ time_elapsed = time_now - perf_info->prev_time;
+ if(time_elapsed < 0.1)
+ {
+ /* shouldnt be possible (callback delay is 2 secs) */
+ time_elapsed = 0.1;
+ }
+-
++
+ instantaneous_throughput =
+ (bytes_now - perf_info->prev_bytes) /
+ time_elapsed;
+-
++
+ time_elapsed = time_now - perf_info->start_time;
+ if(time_elapsed < 0.1)
+ {
+ /* shouldnt be possible (callback delay is 2 secs) */
+ time_elapsed = 0.1;
+ }
+-
++
+ avg_throughput =
+ bytes_now /
+ time_elapsed;
+-
++
+ perf_info->prev_time = time_now;
+ perf_info->prev_bytes = bytes_now;
+-
++
+ handle = perf_info->copy_handle;
+ user_arg = perf_info->user_arg;
+-
++
+ callback = perf_info->callback;
+ }
+ globus_mutex_unlock(&perf_info->lock);
+@@ -1385,11 +1385,11 @@ globus_l_gass_copy_perf_setup_local_callback(
+ globus_abstime_t timebuf;
+ long secs;
+ long usecs;
+-
++
+ GlobusTimeAbstimeGetCurrent(timebuf);
+ GlobusTimeAbstimeGet(timebuf, secs, usecs);
+ perf_info->start_time = secs + (usecs / 1000000.0);
+-
++
+ perf_info->prev_time = perf_info->start_time;
+ perf_info->prev_bytes = 0;
+ perf_info->live_bytes = 0;
+@@ -1513,7 +1513,7 @@ globus_l_gass_copy_ftp_read_callback(
+ globus_byte_t * bytes,
+ globus_size_t nbytes,
+ globus_off_t offset,
+- globus_bool_t eof);
++ globus_bool_t eof);
+
+ globus_result_t
+ globus_l_gass_copy_io_setup_get(
+@@ -1535,13 +1535,13 @@ void
+ globus_l_gass_copy_ftp_get_done_callback(
+ void * callback_arg,
+ globus_ftp_client_handle_t * handle,
+- globus_object_t * error);
++ globus_object_t * error);
+
+ void
+ globus_l_gass_copy_ftp_put_done_callback(
+ void * callback_arg,
+ globus_ftp_client_handle_t * handle,
+- globus_object_t * error);
++ globus_object_t * error);
+
+ void
+ globus_l_gass_copy_io_cancel_callback(
+@@ -1587,7 +1587,7 @@ globus_l_gass_copy_ftp_write_callback(
+ globus_byte_t * bytes,
+ globus_size_t nbytes,
+ globus_off_t offset,
+- globus_bool_t eof);
++ globus_bool_t eof);
+
+ globus_result_t
+ globus_i_gass_copy_attr_duplicate(globus_gass_copy_attr_t ** attr);
+@@ -1661,50 +1661,50 @@ globus_gass_copy_get_status(
+ static char * myname="globus_gass_copy_get_status";
+ if(handle != GLOBUS_NULL)
+ {
+- switch(handle->status)
+- {
+- case GLOBUS_GASS_COPY_STATUS_NONE:
+- *status = GLOBUS_GASS_COPY_STATUS_NONE;
+- break;
+- case GLOBUS_GASS_COPY_STATUS_INITIAL:
+- case GLOBUS_GASS_COPY_STATUS_SOURCE_READY:
+- *status = GLOBUS_GASS_COPY_STATUS_PENDING;
+- break;
+- case GLOBUS_GASS_COPY_STATUS_TRANSFER_IN_PROGRESS:
+- case GLOBUS_GASS_COPY_STATUS_READ_COMPLETE:
+- case GLOBUS_GASS_COPY_STATUS_WRITE_COMPLETE:
+- case GLOBUS_GASS_COPY_STATUS_DONE:
+- *status = GLOBUS_GASS_COPY_STATUS_TRANSFER_IN_PROGRESS;
+- break;
+- case GLOBUS_GASS_COPY_STATUS_FAILURE:
+- *status = GLOBUS_GASS_COPY_STATUS_FAILURE;
+- break;
+- case GLOBUS_GASS_COPY_STATUS_CANCEL:
+- *status = GLOBUS_GASS_COPY_STATUS_CANCEL;
+- break;
+- case GLOBUS_GASS_COPY_STATUS_DONE_SUCCESS:
+- *status = GLOBUS_GASS_COPY_STATUS_DONE_SUCCESS;
+- break;
+- case GLOBUS_GASS_COPY_STATUS_DONE_FAILURE:
+- *status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
+- break;
+- case GLOBUS_GASS_COPY_STATUS_DONE_CANCELLED:
+- *status = GLOBUS_GASS_COPY_STATUS_DONE_CANCELLED;
+- break;
+- default:
+- break;
+- }
+- return GLOBUS_SUCCESS;
++ switch(handle->status)
++ {
++ case GLOBUS_GASS_COPY_STATUS_NONE:
++ *status = GLOBUS_GASS_COPY_STATUS_NONE;
++ break;
++ case GLOBUS_GASS_COPY_STATUS_INITIAL:
++ case GLOBUS_GASS_COPY_STATUS_SOURCE_READY:
++ *status = GLOBUS_GASS_COPY_STATUS_PENDING;
++ break;
++ case GLOBUS_GASS_COPY_STATUS_TRANSFER_IN_PROGRESS:
++ case GLOBUS_GASS_COPY_STATUS_READ_COMPLETE:
++ case GLOBUS_GASS_COPY_STATUS_WRITE_COMPLETE:
++ case GLOBUS_GASS_COPY_STATUS_DONE:
++ *status = GLOBUS_GASS_COPY_STATUS_TRANSFER_IN_PROGRESS;
++ break;
++ case GLOBUS_GASS_COPY_STATUS_FAILURE:
++ *status = GLOBUS_GASS_COPY_STATUS_FAILURE;
++ break;
++ case GLOBUS_GASS_COPY_STATUS_CANCEL:
++ *status = GLOBUS_GASS_COPY_STATUS_CANCEL;
++ break;
++ case GLOBUS_GASS_COPY_STATUS_DONE_SUCCESS:
++ *status = GLOBUS_GASS_COPY_STATUS_DONE_SUCCESS;
++ break;
++ case GLOBUS_GASS_COPY_STATUS_DONE_FAILURE:
++ *status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
++ break;
++ case GLOBUS_GASS_COPY_STATUS_DONE_CANCELLED:
++ *status = GLOBUS_GASS_COPY_STATUS_DONE_CANCELLED;
++ break;
++ default:
++ break;
++ }
++ return GLOBUS_SUCCESS;
+ }
+ else
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, handle is NULL",
+- myname);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, handle is NULL",
++ myname);
+
+- return globus_error_put(err);
++ return globus_error_put(err);
+ }
+ } /* globus_gass_copy_get_status() */
+
+@@ -1765,7 +1765,7 @@ static char *
+ }
+ else
+ {
+- return "[globus_gass_copy_get_status_string]: BAD_PARAMETER, handle is NULL";
++ return "[globus_gass_copy_get_status_string]: BAD_PARAMETER, handle is NULL";
+ }
+ }
+
+@@ -1781,7 +1781,7 @@ globus_i_gass_copy_ftp_client_op_done_callback(
+ globus_i_gass_copy_monitor_t * monitor;
+
+ monitor = (globus_i_gass_copy_monitor_t *) user_arg;
+-
++
+ globus_mutex_lock(&monitor->mutex);
+ if (err && !monitor->err)
+ {
+@@ -1790,7 +1790,7 @@ globus_i_gass_copy_ftp_client_op_done_callback(
+ monitor->done = GLOBUS_TRUE;
+ globus_cond_signal(&monitor->cond);
+ globus_mutex_unlock(&monitor->mutex);
+-
++
+ return;
+ }
+
+@@ -1803,19 +1803,19 @@ globus_l_gass_copy_size_ftp(
+ {
+ globus_i_gass_copy_monitor_t monitor;
+ globus_result_t result;
+-
++
+ memset(&monitor, 0, sizeof(globus_i_gass_copy_monitor_t));
+
+ globus_cond_init(&monitor.cond, GLOBUS_NULL);
+ globus_mutex_init(&monitor.mutex, GLOBUS_NULL);
+-
++
+ result = globus_ftp_client_size(
+ &handle->ftp_handle,
+ url,
+ attr->ftp_attr,
+ out_size,
+ globus_i_gass_copy_ftp_client_op_done_callback,
+- &monitor);
++ &monitor);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error;
+@@ -1833,7 +1833,7 @@ globus_l_gass_copy_size_ftp(
+ result = globus_error_put(monitor.err);
+ monitor.err = GLOBUS_NULL;
+ }
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error;
+@@ -1862,7 +1862,7 @@ globus_l_gass_copy_size_file(
+ globus_url_t parsed_url;
+ globus_result_t result;
+ struct stat stat_buf;
+-
++
+ rc = globus_url_parse(url, &parsed_url);
+ if(rc != 0)
+ {
+@@ -1876,7 +1876,7 @@ globus_l_gass_copy_size_file(
+ rc));
+ goto error_url;
+ }
+-
++
+ if(parsed_url.url_path == GLOBUS_NULL)
+ {
+ result = globus_error_put(
+@@ -1888,7 +1888,7 @@ globus_l_gass_copy_size_file(
+ myname));
+ goto error_null_path;
+ }
+-
++
+ rc = stat(parsed_url.url_path, &stat_buf);
+ if(rc != 0)
+ {
+@@ -1902,20 +1902,20 @@ globus_l_gass_copy_size_file(
+ rc));
+ goto error_stat;
+ }
+-
++
+ *out_size = stat_buf.st_size;
+-
+- globus_url_destroy(&parsed_url);
++
++ globus_url_destroy(&parsed_url);
+ return GLOBUS_SUCCESS;
+
+-error_stat:
++error_stat:
+ error_null_path:
+ globus_url_destroy(&parsed_url);
+-
++
+ error_url:
+
+ return result;
+-
++
+ }
+
+
+@@ -1929,13 +1929,13 @@ globus_i_gass_copy_size(
+ static char * myname="globus_i_gass_copy_size";
+ globus_result_t result;
+ globus_gass_copy_url_mode_t url_mode;
+-
++
+ result = globus_gass_copy_get_url_mode(url, &url_mode);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_exit;
+ }
+-
++
+ if(url_mode == GLOBUS_GASS_COPY_URL_MODE_FTP)
+ {
+ result = globus_l_gass_copy_size_ftp(handle, url, attr, out_size);
+@@ -1964,9 +1964,9 @@ globus_i_gass_copy_size(
+ url));
+ goto error_exit;
+ }
+-
++
+ return GLOBUS_SUCCESS;
+-
++
+ error_exit:
+ return result;
+ }
+@@ -1995,91 +1995,91 @@ globus_l_gass_copy_target_populate(
+
+ if(attr == GLOBUS_NULL)
+ {
+- target->free_attr = GLOBUS_TRUE;
+- tmp_attr = (globus_gass_copy_attr_t *)
++ target->free_attr = GLOBUS_TRUE;
++ tmp_attr = (globus_gass_copy_attr_t *)
+ globus_libc_malloc(sizeof(globus_gass_copy_attr_t));
+
+- if(tmp_attr == GLOBUS_NULL)
+- {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: failed malloc a globus_gass_copy_attr_t structure successfully",
+- myname);
+- return globus_error_put(err);
+- }
++ if(tmp_attr == GLOBUS_NULL)
++ {
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: failed malloc a globus_gass_copy_attr_t structure successfully",
++ myname);
++ return globus_error_put(err);
++ }
+
+- globus_gass_copy_attr_init(tmp_attr);
++ globus_gass_copy_attr_init(tmp_attr);
+
+- attr = tmp_attr;
++ attr = tmp_attr;
+ }
+ else
+- target->free_attr = GLOBUS_FALSE;
++ target->free_attr = GLOBUS_FALSE;
+
+ target->mode = *url_mode;
+ switch (target->mode)
+ {
+ case GLOBUS_GASS_COPY_URL_MODE_FTP:
+
+- /* will be set to false once I start an operation that will get a
+- completion callback */
+- target->data.ftp.completed = GLOBUS_TRUE;
+- target->url = globus_libc_strdup(url);
+- target->attr = attr;
+- /* FIXX n_simultaneous should be pulled from attributes, or something */
+- if(attr->ftp_attr)
+- {
+- globus_ftp_control_parallelism_t tmp_parallelism;
+- globus_ftp_client_operationattr_get_parallelism(attr->ftp_attr, &tmp_parallelism);
+- if(tmp_parallelism.mode == GLOBUS_FTP_CONTROL_PARALLELISM_FIXED)
+- {
+-#ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "tmp_parallelism.mode== GLOBUS_FTP_CONTROL_PARALLELISM_FIXED, tmp_parallelism.fixed.size = %d\n", tmp_parallelism.fixed.size);
+-#endif
+- target->n_simultaneous = tmp_parallelism.fixed.size;
+- /*target->n_simultaneous = 1;*/
+- }
+- else
+- target->n_simultaneous = 1;
+- }
+- else
+- {
+- target->n_simultaneous = 1;
+- /*globus_libc_fprintf(stderr, "**** target->n_simultaneous: %d\n",target->n_simultaneous); */
+- }
+- break;
++ /* will be set to false once I start an operation that will get a
++ completion callback */
++ target->data.ftp.completed = GLOBUS_TRUE;
++ target->url = globus_libc_strdup(url);
++ target->attr = attr;
++ /* FIXX n_simultaneous should be pulled from attributes, or something */
++ if(attr->ftp_attr)
++ {
++ globus_ftp_control_parallelism_t tmp_parallelism;
++ globus_ftp_client_operationattr_get_parallelism(attr->ftp_attr, &tmp_parallelism);
++ if(tmp_parallelism.mode == GLOBUS_FTP_CONTROL_PARALLELISM_FIXED)
++ {
++#ifdef GLOBUS_I_GASS_COPY_DEBUG
++ globus_libc_fprintf(stderr, "tmp_parallelism.mode== GLOBUS_FTP_CONTROL_PARALLELISM_FIXED, tmp_parallelism.fixed.size = %d\n", tmp_parallelism.fixed.size);
++#endif
++ target->n_simultaneous = tmp_parallelism.fixed.size;
++ /*target->n_simultaneous = 1;*/
++ }
++ else
++ target->n_simultaneous = 1;
++ }
++ else
++ {
++ target->n_simultaneous = 1;
++ /*globus_libc_fprintf(stderr, "**** target->n_simultaneous: %d\n",target->n_simultaneous); */
++ }
++ break;
+
+ case GLOBUS_GASS_COPY_URL_MODE_GASS:
+
+- /*target->mode = GLOBUS_I_GASS_COPY_TARGET_MODE_GASS; */
+- target->url = globus_libc_strdup(url);
+- target->attr = attr;
+- target->n_simultaneous = 1;
+- break;
++ /*target->mode = GLOBUS_I_GASS_COPY_TARGET_MODE_GASS; */
++ target->url = globus_libc_strdup(url);
++ target->attr = attr;
++ target->n_simultaneous = 1;
++ break;
+
+ case GLOBUS_GASS_COPY_URL_MODE_IO:
+
+- /*target->mode = GLOBUS_I_GASS_COPY_TARGET_MODE_IO;*/
+- target->url = globus_libc_strdup(url);
+- target->attr = attr;
+- target->data.io.free_handle = GLOBUS_TRUE;
+- target->data.io.seekable = GLOBUS_TRUE;
+- target->data.io.handle = GLOBUS_NULL;
+- target->n_simultaneous = 1;
++ /*target->mode = GLOBUS_I_GASS_COPY_TARGET_MODE_IO;*/
++ target->url = globus_libc_strdup(url);
++ target->attr = attr;
++ target->data.io.free_handle = GLOBUS_TRUE;
++ target->data.io.seekable = GLOBUS_TRUE;
++ target->data.io.handle = GLOBUS_NULL;
++ target->n_simultaneous = 1;
+
+- break;
++ break;
+
+ case GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED:
+- /* something went horribly wrong */
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: %s: GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED",
+- myname,
+- url);
+- return globus_error_put(err);
+-
+- break;
++ /* something went horribly wrong */
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: %s: GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED",
++ myname,
++ url);
++ return globus_error_put(err);
++
++ break;
+ default:
+ break;
+ }
+@@ -2088,12 +2088,12 @@ globus_l_gass_copy_target_populate(
+ */
+ if (globus_fifo_init(&(target->queue)) != GLOBUS_SUCCESS)
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: failed to initialize fifo successfully",
+- myname);
+- return globus_error_put(err);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: failed to initialize fifo successfully",
++ myname);
++ return globus_error_put(err);
+ }
+
+ return GLOBUS_SUCCESS;
+@@ -2124,30 +2124,30 @@ globus_l_gass_copy_io_target_populate(
+ if(globus_io_get_handle_type(io_handle) == GLOBUS_IO_HANDLE_TYPE_FILE)
+ {
+ /* test file handle for seekable as it may be a pipe */
+- if(globus_io_file_seek(io_handle, 0, GLOBUS_IO_SEEK_CUR)
++ if(globus_io_file_seek(io_handle, 0, GLOBUS_IO_SEEK_CUR)
+ == GLOBUS_SUCCESS)
+ {
+- target->data.io.seekable = GLOBUS_TRUE;
+- }
+- else
+- {
+- target->data.io.seekable = GLOBUS_FALSE;
+- }
++ target->data.io.seekable = GLOBUS_TRUE;
++ }
++ else
++ {
++ target->data.io.seekable = GLOBUS_FALSE;
++ }
+ }
+ else
+- target->data.io.seekable = GLOBUS_FALSE;
++ target->data.io.seekable = GLOBUS_FALSE;
+ target->n_simultaneous = 1;
+
+ /* setup the queue
+ */
+ if (globus_fifo_init(&(target->queue)) != GLOBUS_SUCCESS)
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: failed to initialize fifo successfully",
+- myname);
+- return globus_error_put(err);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: failed to initialize fifo successfully",
++ myname);
++ return globus_error_put(err);
+ }
+
+ return GLOBUS_SUCCESS;
+@@ -2166,9 +2166,9 @@ globus_l_gass_copy_target_destroy(
+ /* empty and free the queue */
+ while(!globus_fifo_empty(&(target->queue)))
+ {
+- buffer_entry = globus_fifo_dequeue(&(target->queue));
+- globus_libc_free(buffer_entry->bytes);
+- globus_libc_free(buffer_entry);
++ buffer_entry = globus_fifo_dequeue(&(target->queue));
++ globus_libc_free(buffer_entry->bytes);
++ globus_libc_free(buffer_entry);
+ }
+ globus_fifo_destroy(&(target->queue));
+ /* clean up the mutex */
+@@ -2177,44 +2177,44 @@ globus_l_gass_copy_target_destroy(
+ if(target->free_attr == GLOBUS_TRUE)
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "target_destroy(): freeing the target attr\n");
++ globus_libc_fprintf(stderr, "target_destroy(): freeing the target attr\n");
+ #endif
+- if(target->mode == GLOBUS_GASS_COPY_URL_MODE_FTP &&
+- target->free_ftp_attr == GLOBUS_TRUE)
+- globus_libc_free(target->attr->ftp_attr);
+- globus_libc_free(target->attr);
++ if(target->mode == GLOBUS_GASS_COPY_URL_MODE_FTP &&
++ target->free_ftp_attr == GLOBUS_TRUE)
++ globus_libc_free(target->attr->ftp_attr);
++ globus_libc_free(target->attr);
+ }
+
+ switch(target->mode)
+ {
+ case GLOBUS_GASS_COPY_URL_MODE_FTP:
+- /* once parallel reads/writes are possible, will have to potentially
++ /* once parallel reads/writes are possible, will have to potentially
+ * free the attr, if parallelism is turned off by the library
+ */
+
+- globus_libc_free((target->url));
+- break;
++ globus_libc_free((target->url));
++ break;
+
+ case GLOBUS_GASS_COPY_URL_MODE_GASS:
+- globus_libc_free((target->url));
+- break;
++ globus_libc_free((target->url));
++ break;
+
+ case GLOBUS_GASS_COPY_URL_MODE_IO:
+- if(target->data.io.free_handle == GLOBUS_TRUE)
+- {
+- if(target->data.io.handle)
+- {
+- globus_libc_free((target->data.io.handle));
+- }
+- globus_libc_free((target->url));
+-
+- }
+- break;
++ if(target->data.io.free_handle == GLOBUS_TRUE)
++ {
++ if(target->data.io.handle)
++ {
++ globus_libc_free((target->data.io.handle));
++ }
++ globus_libc_free((target->url));
++
++ }
++ break;
+ default:
+ break;
+ }
+ memset(target, 0, sizeof(globus_i_gass_copy_target_t));
+-
++
+ return GLOBUS_SUCCESS;
+ } /* gloubs_l_gass_copy_target_destroy() */
+
+@@ -2315,7 +2315,7 @@ globus_l_gass_copy_state_free_targets(
+
+ /* clean up the destination target */
+ globus_l_gass_copy_target_destroy(&(state->dest));
+-
++
+ return GLOBUS_SUCCESS;
+
+ } /* globus_l_gass_copy_state_free_targets() */
+@@ -2356,69 +2356,69 @@ globus_l_gass_copy_transfer_start(
+ #endif
+
+ if ( (state->source.mode
+- == GLOBUS_GASS_COPY_URL_MODE_FTP)
+- && ( ( (state->dest.mode
+- == GLOBUS_GASS_COPY_URL_MODE_GASS) )
+- || ( (state->dest.mode
+- == GLOBUS_GASS_COPY_URL_MODE_IO)
+- && (!state->dest.data.io.seekable) ) ) )
+- {
+- /*
+- * If the source stream is ftp, this means it is capable
+- * of supporting multiple data channels and handing back
+- * data block in an arbitrary order.
+- *
+- * If the destination stream can only handle sequential
+- * writes of the data, then disable the multiple data
+- * channel support in ftp
+- */
+- if(state->source.attr->ftp_attr != GLOBUS_NULL)
+- {
+- globus_ftp_control_parallelism_t tmp_parallelism;
+-
+- globus_ftp_client_operationattr_get_parallelism(state->source.attr->ftp_attr, &tmp_parallelism);
+-
+- if(tmp_parallelism.mode != GLOBUS_FTP_CONTROL_PARALLELISM_NONE)
+- {
+- globus_gass_copy_attr_t * new_attr;
+- globus_ftp_client_operationattr_t * new_ftp_attr;
+-
+- new_attr = (globus_gass_copy_attr_t *)
+- globus_libc_malloc(sizeof(globus_gass_copy_attr_t));
+- globus_gass_copy_attr_init(new_attr);
+-
+- new_ftp_attr = (globus_ftp_client_operationattr_t *)
+- globus_libc_malloc(sizeof(globus_ftp_client_operationattr_t));
+-
+- globus_ftp_client_operationattr_copy(new_ftp_attr, (state->source.attr->ftp_attr));
+- tmp_parallelism.mode = GLOBUS_FTP_CONTROL_PARALLELISM_NONE;
+- globus_ftp_client_operationattr_set_parallelism(new_ftp_attr, &tmp_parallelism);
+-
+- globus_gass_copy_attr_set_ftp(new_attr, new_ftp_attr);
+-
+- state->source.attr = new_attr;
+-
+- state->source.free_attr = GLOBUS_TRUE;
+- state->source.free_ftp_attr = GLOBUS_TRUE;
+- } /* if(tmp_parallelism.mode != GLOBUS_FTP_CONTROL_PARALLELISM_NONE) */
+- } /* if(state->source.attr->ftp_attr != GLOBUS_NULL) */
+- /*
+- state->source.attr.parallelism_info.mode =
+- GLOBUS_GSIFTP_CONTROL_PARALLELISM_NONE;
+- state->source.attr.striping_info.mode =
+- GLOBUS_GSIFTP_CONTROL_STRIPING_NONE;
+- */
+- /*
+- * ftp -> gass_transfer:
+- * turn off both parallel & striping
+- * ftp -> io:
+- * globus_io_file_seek() can be used to deal with out of
+- * order blocks
+- * gass_transfer, io -> *
+- * The source data is serialized anyway, so do don't need
+- * to worry about the destination. An ftp destination can
+- * use parallelism and/or striping if desired
+- */
++ == GLOBUS_GASS_COPY_URL_MODE_FTP)
++ && ( ( (state->dest.mode
++ == GLOBUS_GASS_COPY_URL_MODE_GASS) )
++ || ( (state->dest.mode
++ == GLOBUS_GASS_COPY_URL_MODE_IO)
++ && (!state->dest.data.io.seekable) ) ) )
++ {
++ /*
++ * If the source stream is ftp, this means it is capable
++ * of supporting multiple data channels and handing back
++ * data block in an arbitrary order.
++ *
++ * If the destination stream can only handle sequential
++ * writes of the data, then disable the multiple data
++ * channel support in ftp
++ */
++ if(state->source.attr->ftp_attr != GLOBUS_NULL)
++ {
++ globus_ftp_control_parallelism_t tmp_parallelism;
++
++ globus_ftp_client_operationattr_get_parallelism(state->source.attr->ftp_attr, &tmp_parallelism);
++
++ if(tmp_parallelism.mode != GLOBUS_FTP_CONTROL_PARALLELISM_NONE)
++ {
++ globus_gass_copy_attr_t * new_attr;
++ globus_ftp_client_operationattr_t * new_ftp_attr;
++
++ new_attr = (globus_gass_copy_attr_t *)
++ globus_libc_malloc(sizeof(globus_gass_copy_attr_t));
++ globus_gass_copy_attr_init(new_attr);
++
++ new_ftp_attr = (globus_ftp_client_operationattr_t *)
++ globus_libc_malloc(sizeof(globus_ftp_client_operationattr_t));
++
++ globus_ftp_client_operationattr_copy(new_ftp_attr, (state->source.attr->ftp_attr));
++ tmp_parallelism.mode = GLOBUS_FTP_CONTROL_PARALLELISM_NONE;
++ globus_ftp_client_operationattr_set_parallelism(new_ftp_attr, &tmp_parallelism);
++
++ globus_gass_copy_attr_set_ftp(new_attr, new_ftp_attr);
++
++ state->source.attr = new_attr;
++
++ state->source.free_attr = GLOBUS_TRUE;
++ state->source.free_ftp_attr = GLOBUS_TRUE;
++ } /* if(tmp_parallelism.mode != GLOBUS_FTP_CONTROL_PARALLELISM_NONE) */
++ } /* if(state->source.attr->ftp_attr != GLOBUS_NULL) */
++ /*
++ state->source.attr.parallelism_info.mode =
++ GLOBUS_GSIFTP_CONTROL_PARALLELISM_NONE;
++ state->source.attr.striping_info.mode =
++ GLOBUS_GSIFTP_CONTROL_STRIPING_NONE;
++ */
++ /*
++ * ftp -> gass_transfer:
++ * turn off both parallel & striping
++ * ftp -> io:
++ * globus_io_file_seek() can be used to deal with out of
++ * order blocks
++ * gass_transfer, io -> *
++ * The source data is serialized anyway, so do don't need
++ * to worry about the destination. An ftp destination can
++ * use parallelism and/or striping if desired
++ */
+ } /* source.mode == GLOBUS_GASS_COPY_URL_MODE_FTP, and dest is not seekable */
+
+ /* depending on the mode, call the appropriate routine to start the
+@@ -2428,12 +2428,12 @@ globus_l_gass_copy_transfer_start(
+ {
+ case GLOBUS_GASS_COPY_URL_MODE_FTP:
+
+- state->source.data.ftp.n_channels = 0;
+- state->source.data.ftp.n_reads_posted = 0;
+-
+- if(state->dest.mode == GLOBUS_GASS_COPY_URL_MODE_FTP)
+- {
+- /* doing a third party transfer, dest side is using main handle */
++ state->source.data.ftp.n_channels = 0;
++ state->source.data.ftp.n_reads_posted = 0;
++
++ if(state->dest.mode == GLOBUS_GASS_COPY_URL_MODE_FTP)
++ {
++ /* doing a third party transfer, dest side is using main handle */
+ state->source.data.ftp.handle = &handle->ftp_handle_2;
+ }
+ else
+@@ -2443,53 +2443,53 @@ globus_l_gass_copy_transfer_start(
+
+ result = globus_l_gass_copy_ftp_setup_get(handle);
+
+- break;
++ break;
+
+ case GLOBUS_GASS_COPY_URL_MODE_GASS:
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "transfer_start(): about to call globus_gass_transfer_register_get()\n");
++ globus_libc_fprintf(stderr, "transfer_start(): about to call globus_gass_transfer_register_get()\n");
+ #endif
+- rc = globus_gass_transfer_register_get(
+- &(state->source.data.gass.request),
+- (state->source.attr->gass_requestattr),
+- state->source.url,
+- globus_l_gass_copy_gass_setup_callback,
+- (void *) handle);
++ rc = globus_gass_transfer_register_get(
++ &(state->source.data.gass.request),
++ (state->source.attr->gass_requestattr),
++ state->source.url,
++ globus_l_gass_copy_gass_setup_callback,
++ (void *) handle);
+ /*
+ FIXX - what happens if this is a referral?
+ */
+- if (rc != GLOBUS_SUCCESS)
+- {
++ if (rc != GLOBUS_SUCCESS)
++ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "transfer_start(): globus_gass_transfer_register_get returned !GLOBUS_SUCCESS\n");
++ globus_libc_fprintf(stderr, "transfer_start(): globus_gass_transfer_register_get returned !GLOBUS_SUCCESS\n");
+ #endif
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: %s globus_gass_transfer_register_get returned an error code of: %d",
+- myname,
+- state->source.url,
+- rc);
+- globus_i_gass_copy_set_error(handle, err);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: %s globus_gass_transfer_register_get returned an error code of: %d",
++ myname,
++ state->source.url,
++ rc);
++ globus_i_gass_copy_set_error(handle, err);
+
+- result = globus_error_put(err);
+- }
+- break;
++ result = globus_error_put(err);
++ }
++ break;
+
+ case GLOBUS_GASS_COPY_URL_MODE_IO:
+
+- result = globus_l_gass_copy_io_setup_get(handle);
++ result = globus_l_gass_copy_io_setup_get(handle);
+
+- break;
++ break;
+ default:
+ break;
+ }
+
+ if(result != GLOBUS_SUCCESS)
+ {
+- globus_i_gass_copy_set_error_from_result(handle, result);
+- handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
+- return result;
++ globus_i_gass_copy_set_error_from_result(handle, result);
++ handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
++ return result;
+ }
+
+ /* wait for ok from the source */
+@@ -2500,40 +2500,40 @@ globus_l_gass_copy_transfer_start(
+ while(state->source.status == GLOBUS_I_GASS_COPY_TARGET_INITIAL)
+ {
+ globus_cond_wait(&state->monitor.cond,
+- &state->monitor.mutex);
++ &state->monitor.mutex);
+ }
+ globus_mutex_unlock(&state->monitor.mutex);
+
+ if(handle->err)
+ {
+- handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
+- err = handle->err;
+- handle->err = GLOBUS_NULL;
++ handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
++ err = handle->err;
++ handle->err = GLOBUS_NULL;
+
+ /* clean up the source side since it was already opened..... */
+- globus_mutex_init(&monitor.mutex, GLOBUS_NULL);
+- globus_cond_init(&monitor.cond, GLOBUS_NULL);
+- monitor.done = GLOBUS_FALSE;
+- monitor.err = GLOBUS_NULL;
+- monitor.use_err = GLOBUS_FALSE;
++ globus_mutex_init(&monitor.mutex, GLOBUS_NULL);
++ globus_cond_init(&monitor.cond, GLOBUS_NULL);
++ monitor.done = GLOBUS_FALSE;
++ monitor.err = GLOBUS_NULL;
++ monitor.use_err = GLOBUS_FALSE;
+ handle->user_callback = GLOBUS_NULL;
+ globus_gass_copy_cancel(
+- handle,
+- globus_l_gass_copy_monitor_callback,
+- (void *) &monitor);
+- /* wait for the cancel to complete before returning to user */
+- globus_mutex_lock(&monitor.mutex);
+- {
+- while(!monitor.done)
+- {
+- globus_cond_wait(&monitor.cond, &monitor.mutex);
+- }
+- }
+- globus_mutex_unlock(&monitor.mutex);
+- globus_mutex_destroy(&monitor.mutex);
+- globus_cond_destroy(&monitor.cond);
+-
+- return globus_error_put(err);
++ handle,
++ globus_l_gass_copy_monitor_callback,
++ (void *) &monitor);
++ /* wait for the cancel to complete before returning to user */
++ globus_mutex_lock(&monitor.mutex);
++ {
++ while(!monitor.done)
++ {
++ globus_cond_wait(&monitor.cond, &monitor.mutex);
++ }
++ }
++ globus_mutex_unlock(&monitor.mutex);
++ globus_mutex_destroy(&monitor.mutex);
++ globus_cond_destroy(&monitor.cond);
++
++ return globus_error_put(err);
+ }
+
+ handle->status = GLOBUS_GASS_COPY_STATUS_SOURCE_READY;
+@@ -2560,48 +2560,48 @@ globus_l_gass_copy_transfer_start(
+ {
+ case GLOBUS_GASS_COPY_URL_MODE_FTP:
+
+- state->dest.data.ftp.n_channels = 0;
+- state->dest.data.ftp.n_reads_posted = 0;
++ state->dest.data.ftp.n_channels = 0;
++ state->dest.data.ftp.n_reads_posted = 0;
+
+ state->dest.data.ftp.handle = &handle->ftp_handle;
+- result = globus_l_gass_copy_ftp_setup_put(handle);
+- break;
++ result = globus_l_gass_copy_ftp_setup_put(handle);
++ break;
+
+ case GLOBUS_GASS_COPY_URL_MODE_GASS:
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "transfer_start(): about to call globus_gass_transfer_register_put()\n");
++ globus_libc_fprintf(stderr, "transfer_start(): about to call globus_gass_transfer_register_put()\n");
+ #endif
+ rc = globus_gass_transfer_register_put(
+- &(state->dest.data.gass.request),
+- (state->dest.attr->gass_requestattr),
+- state->dest.url,
+- 0,
+- globus_l_gass_copy_gass_setup_callback,
+- (void *) handle);
+-
+- if (rc != GLOBUS_SUCCESS)
+- {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: %s globus_gass_transfer_register_put returned an error code of: %d",
+- myname,
+- state->dest.url,
+- rc);
+- globus_i_gass_copy_set_error(handle, err);
+-
+- result = globus_error_put(err);
+- }
+-
+- break;
++ &(state->dest.data.gass.request),
++ (state->dest.attr->gass_requestattr),
++ state->dest.url,
++ 0,
++ globus_l_gass_copy_gass_setup_callback,
++ (void *) handle);
++
++ if (rc != GLOBUS_SUCCESS)
++ {
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: %s globus_gass_transfer_register_put returned an error code of: %d",
++ myname,
++ state->dest.url,
++ rc);
++ globus_i_gass_copy_set_error(handle, err);
++
++ result = globus_error_put(err);
++ }
++
++ break;
+
+ case GLOBUS_GASS_COPY_URL_MODE_IO:
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "transfer_start(): about to call globus_l_gass_copy_io_setup_put()\n");
++ globus_libc_fprintf(stderr, "transfer_start(): about to call globus_l_gass_copy_io_setup_put()\n");
+ #endif
+- result = globus_l_gass_copy_io_setup_put(handle);
++ result = globus_l_gass_copy_io_setup_put(handle);
+
+- break;
++ break;
+ default:
+ break;
+ }
+@@ -2620,36 +2620,36 @@ globus_l_gass_copy_transfer_start(
+ }
+ }
+
+- handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
++ handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "transfer_start(): error with setting up the dest\n");
++ globus_libc_fprintf(stderr, "transfer_start(): error with setting up the dest\n");
+ #endif
+
+ /* clean up the source side since it was already opened..... */
+- globus_mutex_init(&monitor.mutex, GLOBUS_NULL);
+- globus_cond_init(&monitor.cond, GLOBUS_NULL);
+- monitor.done = GLOBUS_FALSE;
+- monitor.err = GLOBUS_NULL;
+- monitor.use_err = GLOBUS_FALSE;
++ globus_mutex_init(&monitor.mutex, GLOBUS_NULL);
++ globus_cond_init(&monitor.cond, GLOBUS_NULL);
++ monitor.done = GLOBUS_FALSE;
++ monitor.err = GLOBUS_NULL;
++ monitor.use_err = GLOBUS_FALSE;
+ handle->user_callback = GLOBUS_NULL;
+ globus_gass_copy_cancel(
+- handle,
+- globus_l_gass_copy_monitor_callback,
+- (void *) &monitor);
+- /* wait for the cancel to complete before returning to user */
+- globus_mutex_lock(&monitor.mutex);
+- {
+- while(!monitor.done)
+- {
+- globus_cond_wait(&monitor.cond, &monitor.mutex);
+- }
+- }
+- globus_mutex_unlock(&monitor.mutex);
+- globus_mutex_destroy(&monitor.mutex);
+- globus_cond_destroy(&monitor.cond);
+-
+- return result;
++ handle,
++ globus_l_gass_copy_monitor_callback,
++ (void *) &monitor);
++ /* wait for the cancel to complete before returning to user */
++ globus_mutex_lock(&monitor.mutex);
++ {
++ while(!monitor.done)
++ {
++ globus_cond_wait(&monitor.cond, &monitor.mutex);
++ }
++ }
++ globus_mutex_unlock(&monitor.mutex);
++ globus_mutex_destroy(&monitor.mutex);
++ globus_cond_destroy(&monitor.cond);
++
++ return result;
+ }
+ /* wait for ok from the dest */
+ globus_mutex_lock(&(state->monitor.mutex));
+@@ -2661,39 +2661,39 @@ globus_l_gass_copy_transfer_start(
+ while(state->dest.status == GLOBUS_I_GASS_COPY_TARGET_INITIAL)
+ {
+ globus_cond_wait(&state->monitor.cond,
+- &state->monitor.mutex);
++ &state->monitor.mutex);
+ }
+ globus_mutex_unlock(&state->monitor.mutex);
+
+ if(handle->err)
+ {
+- handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
+- err = handle->err;
+- handle->err = GLOBUS_NULL;
++ handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
++ err = handle->err;
++ handle->err = GLOBUS_NULL;
+
+ /* clean up the source side since it was already opened..... */
+- globus_mutex_init(&monitor.mutex, GLOBUS_NULL);
+- globus_cond_init(&monitor.cond, GLOBUS_NULL);
+- monitor.done = GLOBUS_FALSE;
+- monitor.err = GLOBUS_NULL;
+- monitor.use_err = GLOBUS_FALSE;
++ globus_mutex_init(&monitor.mutex, GLOBUS_NULL);
++ globus_cond_init(&monitor.cond, GLOBUS_NULL);
++ monitor.done = GLOBUS_FALSE;
++ monitor.err = GLOBUS_NULL;
++ monitor.use_err = GLOBUS_FALSE;
+ handle->user_callback = GLOBUS_NULL;
+ globus_gass_copy_cancel(
+- handle,
+- globus_l_gass_copy_monitor_callback,
+- (void *) &monitor);
+- /* wait for the cancel to complete before returning to user */
+- globus_mutex_lock(&monitor.mutex);
+- {
+- while(!monitor.done)
+- {
+- globus_cond_wait(&monitor.cond, &monitor.mutex);
+- }
+- }
+- globus_mutex_unlock(&monitor.mutex);
+- globus_mutex_destroy(&monitor.mutex);
+- globus_cond_destroy(&monitor.cond);
+- return globus_error_put(err);
++ handle,
++ globus_l_gass_copy_monitor_callback,
++ (void *) &monitor);
++ /* wait for the cancel to complete before returning to user */
++ globus_mutex_lock(&monitor.mutex);
++ {
++ while(!monitor.done)
++ {
++ globus_cond_wait(&monitor.cond, &monitor.mutex);
++ }
++ }
++ globus_mutex_unlock(&monitor.mutex);
++ globus_mutex_destroy(&monitor.mutex);
++ globus_cond_destroy(&monitor.cond);
++ return globus_error_put(err);
+ }
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ globus_libc_fprintf(stderr, "transfer_start(): dest is ready, let's get goin'\n");
+@@ -2722,36 +2722,36 @@ globus_l_gass_copy_read_from_queue(
+
+ do
+ {
+- do_the_read = GLOBUS_FALSE;
+- buffer_entry = GLOBUS_NULL;
+- buffer = GLOBUS_NULL;
++ do_the_read = GLOBUS_FALSE;
++ buffer_entry = GLOBUS_NULL;
++ buffer = GLOBUS_NULL;
+
+- globus_mutex_lock(&(state->source.mutex));
+- {
++ globus_mutex_lock(&(state->source.mutex));
++ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "read_from_queue(): n_pending= %d n_simultaneous= %d\n",
+ state->source.n_pending,
+ state->source.n_simultaneous);
+ #endif
+
+- if(state->source.status == GLOBUS_I_GASS_COPY_TARGET_READY)
+- {
+- if (((state->source.n_pending <
+- state->source.n_simultaneous) &&
+- !state->cancel))
+- {
+- if(!globus_fifo_empty(&(state->source.queue)))
+- {
+- state->source.n_pending++;
+- buffer_entry =
++ if(state->source.status == GLOBUS_I_GASS_COPY_TARGET_READY)
++ {
++ if (((state->source.n_pending <
++ state->source.n_simultaneous) &&
++ !state->cancel))
++ {
++ if(!globus_fifo_empty(&(state->source.queue)))
++ {
++ state->source.n_pending++;
++ buffer_entry =
+ globus_fifo_dequeue(&(state->source.queue));
+- buffer = buffer_entry->bytes;
+- globus_libc_free(buffer_entry);
+- do_the_read = GLOBUS_TRUE;
+- }
+- else
+- {
++ buffer = buffer_entry->bytes;
++ globus_libc_free(buffer_entry);
++ do_the_read = GLOBUS_TRUE;
++ }
++ else
++ {
+ globus_mutex_lock(&(state->mutex));
+ if(state->n_buffers < state->max_buffers)
+ {
+@@ -2760,9 +2760,9 @@ globus_l_gass_copy_read_from_queue(
+ do_the_read = GLOBUS_TRUE;
+ }
+ globus_mutex_unlock(&(state->mutex));
+- }
+- }
+-
++ }
++ }
++
+ if(do_the_read)
+ {
+ if(!buffer)
+@@ -2779,14 +2779,14 @@ globus_l_gass_copy_read_from_queue(
+ result = globus_error_put(err);
+ }
+ }
+-
++
+ if(buffer)
+ {
+ result = globus_l_gass_copy_register_read(
+ handle,
+ buffer);
+ }
+-
++
+ if (result != GLOBUS_SUCCESS)
+ {
+ state->cancel = GLOBUS_I_GASS_COPY_CANCEL_TRUE;
+@@ -2800,9 +2800,9 @@ globus_l_gass_copy_read_from_queue(
+ globus_mutex_unlock(&(state->source.mutex));
+
+ } while(do_the_read);
+-
++
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "read_from_queue(): returning\n");
++ globus_libc_fprintf(stderr, "read_from_queue(): returning\n");
+ #endif
+ } /* globus_l_gass_copy_read_from_queue() */
+
+@@ -2845,48 +2845,48 @@ globus_l_gass_copy_register_read(
+ {
+ case GLOBUS_GASS_COPY_URL_MODE_FTP:
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "register_read(): calling globus_ftp_client_register_read()\n");
++ globus_libc_fprintf(stderr, "register_read(): calling globus_ftp_client_register_read()\n");
+ #endif
+- result = globus_ftp_client_register_read(
+- state->source.data.ftp.handle,
+- buffer,
+- handle->buffer_length,
+- globus_l_gass_copy_ftp_read_callback,
+- (void *) handle);
++ result = globus_ftp_client_register_read(
++ state->source.data.ftp.handle,
++ buffer,
++ handle->buffer_length,
++ globus_l_gass_copy_ftp_read_callback,
++ (void *) handle);
+
+- break;
++ break;
+
+ case GLOBUS_GASS_COPY_URL_MODE_GASS:
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "register_read(): calling globus_gass_transfer_receive_bytes()\n");
+-#endif
+- rc = globus_gass_transfer_receive_bytes(
+- state->source.data.gass.request,
+- buffer,
+- handle->buffer_length,
+- handle->buffer_length,
+- globus_l_gass_copy_gass_read_callback,
+- (void *) handle);
+-
+- if (rc != GLOBUS_SUCCESS)
+- {
+- /* figure out what the error is, and pass it back through the result */
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: globus_gass_transfer_receive_bytes returned error code: %d",
+- myname,
+- rc);
+- result = globus_error_put(err);
+- }
+- else result = GLOBUS_SUCCESS;
+-
+- break;
++ globus_libc_fprintf(stderr, "register_read(): calling globus_gass_transfer_receive_bytes()\n");
++#endif
++ rc = globus_gass_transfer_receive_bytes(
++ state->source.data.gass.request,
++ buffer,
++ handle->buffer_length,
++ handle->buffer_length,
++ globus_l_gass_copy_gass_read_callback,
++ (void *) handle);
++
++ if (rc != GLOBUS_SUCCESS)
++ {
++ /* figure out what the error is, and pass it back through the result */
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: globus_gass_transfer_receive_bytes returned error code: %d",
++ myname,
++ rc);
++ result = globus_error_put(err);
++ }
++ else result = GLOBUS_SUCCESS;
++
++ break;
+
+ case GLOBUS_GASS_COPY_URL_MODE_IO:
+- if(handle->partial_end_offset != -1)
++ if(handle->partial_end_offset != -1)
+ {
+- read_len =
++ read_len =
+ (handle->buffer_length < handle->partial_bytes_remaining) ?
+ handle->buffer_length : handle->partial_bytes_remaining;
+ handle->partial_bytes_remaining -= read_len;
+@@ -2895,23 +2895,23 @@ globus_l_gass_copy_register_read(
+ {
+ read_len = handle->buffer_length;
+ }
+- result = globus_io_register_read(
+- state->source.data.io.handle,
+- buffer,
+- read_len,
+- read_len,
+- globus_l_gass_copy_io_read_callback,
+- (void *) handle);
+-
+- break;
++ result = globus_io_register_read(
++ state->source.data.io.handle,
++ buffer,
++ read_len,
++ read_len,
++ globus_l_gass_copy_io_read_callback,
++ (void *) handle);
++
++ break;
+ case GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED:
+ default:
+- result = globus_error_put(globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: %s: GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED",
+- myname,
+- state->source.url));
++ result = globus_error_put(globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: %s: GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED",
++ myname,
++ state->source.url));
+ break;
+ }
+
+@@ -2945,7 +2945,7 @@ globus_l_gass_copy_gass_setup_callback(
+ static char * myname="globus_l_gass_copy_gass_setup_callback";
+
+ globus_gass_copy_handle_t * handle
+- = (globus_gass_copy_handle_t *) callback_arg;
++ = (globus_gass_copy_handle_t *) callback_arg;
+ globus_gass_copy_state_t * state = handle->state;
+
+
+@@ -2959,183 +2959,183 @@ globus_l_gass_copy_gass_setup_callback(
+ {
+ case GLOBUS_GASS_TRANSFER_REQUEST_REFERRED:
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "request status == GLOBUS_GASS_TRANSFER_REQUEST_REFERRED\n");
+ #endif
+- globus_gass_transfer_request_get_referral(request, &referral);
+- globus_gass_transfer_request_destroy(request);
+-
+- if (handle->status == GLOBUS_GASS_COPY_STATUS_INITIAL)
+- {
+- /* first setup the source with the register get
+- */
+-#ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "REQUEST_REFERRED: STATE_INITIAL\n");
+-#endif
+- current_url = globus_libc_strdup(state->source.url);
+- globus_libc_free(state->source.url);
+- state->source.url =globus_libc_strdup(
+- globus_gass_transfer_referral_get_url(&referral, 0));
+-
+-#ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "REQUEST_REFERRED: about to globus_gass_transfer_register_get() again with: %s\n",state->source.url);
+-#endif
+- if ( (rc = globus_gass_transfer_register_get(
+- &(state->source.data.gass.request),
+- (state->source.attr->gass_requestattr),
+- state->source.url,
+- globus_l_gass_copy_gass_setup_callback,
+- (void *) handle)) != GLOBUS_SUCCESS )
+- {/* there was an error */
+- globus_mutex_lock(&state->monitor.mutex);
+-#ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "gass_setup_callback(): transfer_register_get() returned: %d\n", rc);
+- if(rc==GLOBUS_GASS_TRANSFER_ERROR_BAD_URL)
+- globus_libc_fprintf(stderr, "rc == GLOBUS_GASS_ERROR_BAD_URL\n");
+-#endif
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: the original source url: %s was referred to: %s, for which globus_gass_transfer_register_get returned an error code of: %d",
+- myname,
+- current_url,
+- state->source.url,
+- rc);
+- globus_i_gass_copy_set_error(handle, err);
+- globus_libc_free(current_url);
+- globus_gass_transfer_referral_destroy(&referral);
+- goto wakeup_state;
+- }
+- globus_gass_transfer_referral_destroy(&referral);
+- }
+- else
+- {
+- /* if the state is not INITIAL then assume the source is ready
+- * and that we are now setting up the destination with the register put
+- */
+- current_url = globus_libc_strdup(state->dest.url);
+- globus_libc_free(state->dest.url);
+- state->dest.url =globus_libc_strdup(
+- globus_gass_transfer_referral_get_url(&referral, 0));
+-
+- globus_gass_transfer_referral_destroy(&referral);
+-
+- if ( (rc = globus_gass_transfer_register_put(
+- &request,
+- (state->dest.attr->gass_requestattr),
+- state->dest.url,
+- 0,
+- globus_l_gass_copy_gass_setup_callback,
+- (void *) handle)) != GLOBUS_SUCCESS )
+- { /* there was an error */
+- globus_mutex_lock(&state->monitor.mutex);
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: the original destination url: %s was referred to: %s, for which globus_gass_transfer_register_get returned an error code of: %d",
+- myname,
+- current_url,
+- state->dest.url,
+- rc);
+- globus_i_gass_copy_set_error(handle, err);
+- globus_libc_free(current_url);
+- globus_gass_transfer_referral_destroy(&referral);
+- goto wakeup_state;
+- }
+- globus_gass_transfer_referral_destroy(&referral);
+- }
+- globus_libc_free(current_url);
+- break;
++ globus_gass_transfer_request_get_referral(request, &referral);
++ globus_gass_transfer_request_destroy(request);
++
++ if (handle->status == GLOBUS_GASS_COPY_STATUS_INITIAL)
++ {
++ /* first setup the source with the register get
++ */
++#ifdef GLOBUS_I_GASS_COPY_DEBUG
++ globus_libc_fprintf(stderr, "REQUEST_REFERRED: STATE_INITIAL\n");
++#endif
++ current_url = globus_libc_strdup(state->source.url);
++ globus_libc_free(state->source.url);
++ state->source.url =globus_libc_strdup(
++ globus_gass_transfer_referral_get_url(&referral, 0));
++
++#ifdef GLOBUS_I_GASS_COPY_DEBUG
++ globus_libc_fprintf(stderr, "REQUEST_REFERRED: about to globus_gass_transfer_register_get() again with: %s\n",state->source.url);
++#endif
++ if ( (rc = globus_gass_transfer_register_get(
++ &(state->source.data.gass.request),
++ (state->source.attr->gass_requestattr),
++ state->source.url,
++ globus_l_gass_copy_gass_setup_callback,
++ (void *) handle)) != GLOBUS_SUCCESS )
++ {/* there was an error */
++ globus_mutex_lock(&state->monitor.mutex);
++#ifdef GLOBUS_I_GASS_COPY_DEBUG
++ globus_libc_fprintf(stderr, "gass_setup_callback(): transfer_register_get() returned: %d\n", rc);
++ if(rc==GLOBUS_GASS_TRANSFER_ERROR_BAD_URL)
++ globus_libc_fprintf(stderr, "rc == GLOBUS_GASS_ERROR_BAD_URL\n");
++#endif
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: the original source url: %s was referred to: %s, for which globus_gass_transfer_register_get returned an error code of: %d",
++ myname,
++ current_url,
++ state->source.url,
++ rc);
++ globus_i_gass_copy_set_error(handle, err);
++ globus_libc_free(current_url);
++ globus_gass_transfer_referral_destroy(&referral);
++ goto wakeup_state;
++ }
++ globus_gass_transfer_referral_destroy(&referral);
++ }
++ else
++ {
++ /* if the state is not INITIAL then assume the source is ready
++ * and that we are now setting up the destination with the register put
++ */
++ current_url = globus_libc_strdup(state->dest.url);
++ globus_libc_free(state->dest.url);
++ state->dest.url =globus_libc_strdup(
++ globus_gass_transfer_referral_get_url(&referral, 0));
++
++ globus_gass_transfer_referral_destroy(&referral);
++
++ if ( (rc = globus_gass_transfer_register_put(
++ &request,
++ (state->dest.attr->gass_requestattr),
++ state->dest.url,
++ 0,
++ globus_l_gass_copy_gass_setup_callback,
++ (void *) handle)) != GLOBUS_SUCCESS )
++ { /* there was an error */
++ globus_mutex_lock(&state->monitor.mutex);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: the original destination url: %s was referred to: %s, for which globus_gass_transfer_register_get returned an error code of: %d",
++ myname,
++ current_url,
++ state->dest.url,
++ rc);
++ globus_i_gass_copy_set_error(handle, err);
++ globus_libc_free(current_url);
++ globus_gass_transfer_referral_destroy(&referral);
++ goto wakeup_state;
++ }
++ globus_gass_transfer_referral_destroy(&referral);
++ }
++ globus_libc_free(current_url);
++ break;
+
+ case GLOBUS_GASS_TRANSFER_REQUEST_PENDING:
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "request status == GLOBUS_GASS_TRANSFER_REQUEST_PENDING, should signal the monitor\n");
+-#endif
+- if (handle->status == GLOBUS_GASS_COPY_STATUS_INITIAL)
+- {
+- globus_mutex_lock(&state->monitor.mutex);
+- state->source.status = GLOBUS_I_GASS_COPY_TARGET_READY;
+- globus_cond_signal(&state->monitor.cond);
+- globus_mutex_unlock(&state->monitor.mutex);
+- }
+- else
+- {
+- globus_mutex_lock(&state->monitor.mutex);
+- state->dest.status = GLOBUS_I_GASS_COPY_TARGET_READY;
+- globus_cond_signal(&state->monitor.cond);
+- globus_mutex_unlock(&state->monitor.mutex);
+- }
+- break;
++ globus_libc_fprintf(stderr, "request status == GLOBUS_GASS_TRANSFER_REQUEST_PENDING, should signal the monitor\n");
++#endif
++ if (handle->status == GLOBUS_GASS_COPY_STATUS_INITIAL)
++ {
++ globus_mutex_lock(&state->monitor.mutex);
++ state->source.status = GLOBUS_I_GASS_COPY_TARGET_READY;
++ globus_cond_signal(&state->monitor.cond);
++ globus_mutex_unlock(&state->monitor.mutex);
++ }
++ else
++ {
++ globus_mutex_lock(&state->monitor.mutex);
++ state->dest.status = GLOBUS_I_GASS_COPY_TARGET_READY;
++ globus_cond_signal(&state->monitor.cond);
++ globus_mutex_unlock(&state->monitor.mutex);
++ }
++ break;
+
+ case GLOBUS_GASS_TRANSFER_REQUEST_DONE:
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "request status == GLOBUS_GASS_TRANSFER_REQUEST_DONE\n");
++ globus_libc_fprintf(stderr, "request status == GLOBUS_GASS_TRANSFER_REQUEST_DONE\n");
+ #endif
+- globus_mutex_lock(&state->monitor.mutex);
+- if (handle->status == GLOBUS_GASS_COPY_STATUS_INITIAL)
+- current_url = state->source.url;
+- else
+- current_url = state->dest.url;
++ globus_mutex_lock(&state->monitor.mutex);
++ if (handle->status == GLOBUS_GASS_COPY_STATUS_INITIAL)
++ current_url = state->source.url;
++ else
++ current_url = state->dest.url;
+
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: we're just getting set up, but the status of url %s is GLOBUS_GASS_TRANSFER_REQUEST_DONE",
+- myname,
+- current_url);
+- globus_i_gass_copy_set_error(handle, err);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: we're just getting set up, but the status of url %s is GLOBUS_GASS_TRANSFER_REQUEST_DONE",
++ myname,
++ current_url);
++ globus_i_gass_copy_set_error(handle, err);
+
+- goto wakeup_state;
+- break;
++ goto wakeup_state;
++ break;
+
+ case GLOBUS_GASS_TRANSFER_REQUEST_DENIED:
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "request status == GLOBUS_GASS_TRANSFER_REQUEST_DENIED\n");
+ #endif
+- globus_mutex_lock(&state->monitor.mutex);
+- if (handle->status == GLOBUS_GASS_COPY_STATUS_INITIAL)
+- current_url = state->source.url;
+- else
+- current_url = state->dest.url;
++ globus_mutex_lock(&state->monitor.mutex);
++ if (handle->status == GLOBUS_GASS_COPY_STATUS_INITIAL)
++ current_url = state->source.url;
++ else
++ current_url = state->dest.url;
+
+- denial_reason = globus_gass_transfer_request_get_denial_reason(request);
+- denial_message =
++ denial_reason = globus_gass_transfer_request_get_denial_reason(request);
++ denial_message =
+ globus_gass_transfer_request_get_denial_message(request);
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: url: %s request was DENIED, for reason: %d, %s",
+- myname,
+- current_url,
+- denial_reason,
+- denial_message);
+- globus_i_gass_copy_set_error(handle, err);
+-
+- goto wakeup_state;
+- break;
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: url: %s request was DENIED, for reason: %d, %s",
++ myname,
++ current_url,
++ denial_reason,
++ denial_message);
++ globus_i_gass_copy_set_error(handle, err);
++
++ goto wakeup_state;
++ break;
+
+ case GLOBUS_GASS_TRANSFER_REQUEST_FAILED:
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "request status == GLOBUS_GASS_TRANSFER_REQUEST_FAILED\n");
+ #endif
+- globus_mutex_lock(&state->monitor.mutex);
+- if (handle->status == GLOBUS_GASS_COPY_STATUS_INITIAL)
+- current_url = state->source.url;
+- else
+- current_url = state->dest.url;
+-
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: url: %s request FAILED",
+- myname,
+- current_url);
+- globus_i_gass_copy_set_error(handle, err);
+-
+- goto wakeup_state;
+- break;
++ globus_mutex_lock(&state->monitor.mutex);
++ if (handle->status == GLOBUS_GASS_COPY_STATUS_INITIAL)
++ current_url = state->source.url;
++ else
++ current_url = state->dest.url;
++
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: url: %s request FAILED",
++ myname,
++ current_url);
++ globus_i_gass_copy_set_error(handle, err);
++
++ goto wakeup_state;
++ break;
+ default:
+ break;
+ } /* switch */
+@@ -3146,9 +3146,9 @@ wakeup_state:
+ * assume mutex has already been locked by above calls
+ */
+ if (handle->status == GLOBUS_GASS_COPY_STATUS_INITIAL)
+- state->source.status = GLOBUS_I_GASS_COPY_TARGET_FAILED;
++ state->source.status = GLOBUS_I_GASS_COPY_TARGET_FAILED;
+ else
+- state->dest.status = GLOBUS_I_GASS_COPY_TARGET_FAILED;
++ state->dest.status = GLOBUS_I_GASS_COPY_TARGET_FAILED;
+ handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
+
+ state->monitor.done = 1;
+@@ -3170,61 +3170,61 @@ globus_l_gass_copy_io_setup_get(
+
+ if (state->source.data.io.free_handle)
+ {
+- globus_url_parse(state->source.url, &parsed_url);
+- state->source.data.io.handle =(globus_io_handle_t *)
+- globus_libc_malloc(sizeof(globus_io_handle_t));
+-
+- if(state->source.data.io.handle == GLOBUS_NULL)
+- {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: failed to malloc a globus_io_handle_t successfully",
+- myname);
+- return globus_error_put(err);
+- }
+- result = globus_io_file_open(
+- parsed_url.url_path,
+- GLOBUS_IO_FILE_RDONLY,
+- GLOBUS_IO_FILE_IRUSR,
+- state->source.attr->io,
+- state->source.data.io.handle);
++ globus_url_parse(state->source.url, &parsed_url);
++ state->source.data.io.handle =(globus_io_handle_t *)
++ globus_libc_malloc(sizeof(globus_io_handle_t));
++
++ if(state->source.data.io.handle == GLOBUS_NULL)
++ {
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: failed to malloc a globus_io_handle_t successfully",
++ myname);
++ return globus_error_put(err);
++ }
++ result = globus_io_file_open(
++ parsed_url.url_path,
++ GLOBUS_IO_FILE_RDONLY,
++ GLOBUS_IO_FILE_IRUSR,
++ state->source.attr->io,
++ state->source.data.io.handle);
+
+
+ if(result == GLOBUS_SUCCESS && handle->partial_offset != -1)
+ {
+ if(handle->partial_end_offset != -1)
+ {
+- handle->partial_bytes_remaining =
++ handle->partial_bytes_remaining =
+ handle->partial_end_offset - handle->partial_offset;
+ }
+ result = globus_io_file_seek(
+ state->source.data.io.handle,
+ handle->partial_offset,
+- SEEK_SET);
++ SEEK_SET);
+ }
+
+- if(result==GLOBUS_SUCCESS)
+- {
++ if(result==GLOBUS_SUCCESS)
++ {
+
+- state->source.status = GLOBUS_I_GASS_COPY_TARGET_READY;
++ state->source.status = GLOBUS_I_GASS_COPY_TARGET_READY;
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "io_setup_get(): SUCCESS opening %s\n",parsed_url.url_path);
+- }
+- else
+- {
+- globus_libc_fprintf(stderr,
++ }
++ else
++ {
++ globus_libc_fprintf(stderr,
+ "io_setup_get(): FAILURE opening %s\n",parsed_url.url_path);
+ #endif
+- }
++ }
+ globus_url_destroy(&parsed_url);
+-
++
+ }
+ else
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "io_setup_get(): handle should already have been opened by the user\n");
++ globus_libc_fprintf(stderr, "io_setup_get(): handle should already have been opened by the user\n");
+ #endif
+ state->source.status = GLOBUS_I_GASS_COPY_TARGET_READY;
+ result=GLOBUS_SUCCESS;
+@@ -3248,62 +3248,62 @@ globus_l_gass_copy_io_setup_put(
+ globus_url_parse(state->dest.url, &parsed_url);
+ state->dest.data.io.handle = (globus_io_handle_t *)
+ globus_libc_malloc(sizeof(globus_io_handle_t));
+- if(state->dest.data.io.handle == GLOBUS_NULL)
+- {
++ if(state->dest.data.io.handle == GLOBUS_NULL)
++ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "io_setup_put(): error mallocing io_handle_t\n");
++ globus_libc_fprintf(stderr, "io_setup_put(): error mallocing io_handle_t\n");
+ #endif
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: failed to malloc a globus_io_handle_t successfully",
+- myname);
+- return globus_error_put(err);
+- }
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: failed to malloc a globus_io_handle_t successfully",
++ myname);
++ return globus_error_put(err);
++ }
+
+ result = globus_io_file_open(
+- parsed_url.url_path,
+- (handle->partial_offset == -1) ?
+- (GLOBUS_IO_FILE_WRONLY|GLOBUS_IO_FILE_CREAT|GLOBUS_IO_FILE_TRUNC) :
+- (GLOBUS_IO_FILE_WRONLY|GLOBUS_IO_FILE_CREAT),
+- (GLOBUS_IO_FILE_IRUSR|GLOBUS_IO_FILE_IWUSR|
+- GLOBUS_IO_FILE_IRGRP|GLOBUS_IO_FILE_IWGRP|
+- GLOBUS_IO_FILE_IROTH|GLOBUS_IO_FILE_IWOTH),
+- state->dest.attr->io,
+- state->dest.data.io.handle);
++ parsed_url.url_path,
++ (handle->partial_offset == -1) ?
++ (GLOBUS_IO_FILE_WRONLY|GLOBUS_IO_FILE_CREAT|GLOBUS_IO_FILE_TRUNC) :
++ (GLOBUS_IO_FILE_WRONLY|GLOBUS_IO_FILE_CREAT),
++ (GLOBUS_IO_FILE_IRUSR|GLOBUS_IO_FILE_IWUSR|
++ GLOBUS_IO_FILE_IRGRP|GLOBUS_IO_FILE_IWGRP|
++ GLOBUS_IO_FILE_IROTH|GLOBUS_IO_FILE_IWOTH),
++ state->dest.attr->io,
++ state->dest.data.io.handle);
+
+ if(result == GLOBUS_SUCCESS && handle->partial_offset != -1)
+ {
+ result = globus_io_file_seek(
+ state->dest.data.io.handle,
+ handle->partial_offset,
+- SEEK_SET);
++ SEEK_SET);
+ }
+
+
+- if(result==GLOBUS_SUCCESS)
+- {
+- state->dest.status = GLOBUS_I_GASS_COPY_TARGET_READY;
++ if(result==GLOBUS_SUCCESS)
++ {
++ state->dest.status = GLOBUS_I_GASS_COPY_TARGET_READY;
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "io_setup_put(): SUCCESS opening %s\n",parsed_url.url_path);
+- }
+- else
+- {
+- globus_libc_fprintf(stderr,
++ }
++ else
++ {
++ globus_libc_fprintf(stderr,
+ "io_setup_put(): FAILED opening %s\n",parsed_url.url_path);
+ #endif
+- }
++ }
+
+ globus_url_destroy(&parsed_url);
+ }
+ else
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "io_setup_put(): handle should already have been opened by the user\n");
++ globus_libc_fprintf(stderr, "io_setup_put(): handle should already have been opened by the user\n");
+ #endif
+- state->dest.status = GLOBUS_I_GASS_COPY_TARGET_READY;
+- result=GLOBUS_SUCCESS;
++ state->dest.status = GLOBUS_I_GASS_COPY_TARGET_READY;
++ result=GLOBUS_SUCCESS;
+ }
+
+ return result;
+@@ -3326,7 +3326,7 @@ globus_l_gass_copy_ftp_setup_get(
+ GLOBUS_NULL,
+ globus_l_gass_copy_ftp_get_done_callback,
+ (void *) handle);
+- }
++ }
+ else
+ {
+ result = globus_ftp_client_partial_get(
+@@ -3335,29 +3335,29 @@ globus_l_gass_copy_ftp_setup_get(
+ state->source.attr->ftp_attr,
+ GLOBUS_NULL,
+ handle->partial_offset,
+- handle->partial_end_offset,
++ handle->partial_end_offset,
+ globus_l_gass_copy_ftp_get_done_callback,
+ (void *) handle);
+ }
+-
++
+ if(result==GLOBUS_SUCCESS)
+ {
+- state->source.status = GLOBUS_I_GASS_COPY_TARGET_READY;
+- state->source.data.ftp.completed = GLOBUS_FALSE;
+-
++ state->source.status = GLOBUS_I_GASS_COPY_TARGET_READY;
++ state->source.data.ftp.completed = GLOBUS_FALSE;
++
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "ftp_setup_get(): SUCCESS opening %s\n",
++ globus_libc_fprintf(stderr, "ftp_setup_get(): SUCCESS opening %s\n",
+ state->source.url);
+ }
+ else
+ {
+- globus_libc_fprintf(stderr, "ftp_setup_get(): FAILURE opening %s\n",
++ globus_libc_fprintf(stderr, "ftp_setup_get(): FAILURE opening %s\n",
+ state->source.url);
+ #endif
+ }
+
+ return result;
+-
++
+ } /* globus_l_gass_copy_ftp_setup_get() */
+
+ globus_result_t
+@@ -3368,7 +3368,7 @@ globus_l_gass_copy_ftp_setup_put(
+ globus_result_t result;
+
+ if(handle->partial_offset == -1)
+- {
++ {
+ result = globus_ftp_client_put(
+ state->dest.data.ftp.handle,
+ state->dest.url,
+@@ -3385,18 +3385,18 @@ globus_l_gass_copy_ftp_setup_put(
+ state->dest.attr->ftp_attr,
+ GLOBUS_NULL,
+ handle->partial_offset,
+- handle->partial_end_offset,
++ handle->partial_end_offset,
+ globus_l_gass_copy_ftp_put_done_callback,
+ (void *) handle);
+ }
+-
++
+ if(result==GLOBUS_SUCCESS)
+ {
+- state->dest.status = GLOBUS_I_GASS_COPY_TARGET_READY;
+- state->dest.data.ftp.completed = GLOBUS_FALSE;
+-
++ state->dest.status = GLOBUS_I_GASS_COPY_TARGET_READY;
++ state->dest.data.ftp.completed = GLOBUS_FALSE;
++
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "ftp_setup_put(): SUCCESS opening %s\n",state->dest.url);
+ }
+ else
+@@ -3406,7 +3406,7 @@ globus_l_gass_copy_ftp_setup_put(
+ globus_l_gass_copy_perf_cancel_ftp_callback(handle->performance);
+ }
+
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "ftp_setup_put(): FAILURE opening %s\n",state->dest.url);
+ #endif
+ }
+@@ -3419,15 +3419,15 @@ globus_l_gass_copy_ftp_setup_put(
+
+ void
+ globus_l_gass_copy_ftp_transfer_callback(
+- void * user_arg,
++ void * user_arg,
+ globus_ftp_client_handle_t * handle,
+- globus_object_t * error)
++ globus_object_t * error)
+ {
+ globus_object_t * err = GLOBUS_NULL;
+ globus_result_t result;
+
+ globus_gass_copy_handle_t * copy_handle
+- = (globus_gass_copy_handle_t *) user_arg;
++ = (globus_gass_copy_handle_t *) user_arg;
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ globus_libc_fprintf(stderr, "ftp_transfer_callback(): called\n");
+@@ -3435,17 +3435,17 @@ globus_l_gass_copy_ftp_transfer_callback(
+
+ if(error != GLOBUS_SUCCESS)
+ {
+- /* do some error handling */
+- /* copy_handle->err = globus_copy_error(error);*/
++ /* do some error handling */
++ /* copy_handle->err = globus_copy_error(error);*/
+
+ if (copy_handle->status != GLOBUS_GASS_COPY_STATUS_CANCEL)
+ {
+- globus_i_gass_copy_set_error(copy_handle, error);
+- copy_handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
++ globus_i_gass_copy_set_error(copy_handle, error);
++ copy_handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
+ }
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "ftp_transfer_callback(): !GLOBUS_SUCESS, error= %d\n",
++ globus_libc_fprintf(stderr, "ftp_transfer_callback(): !GLOBUS_SUCESS, error= %d\n",
+ error);
+ #endif
+ }
+@@ -3453,7 +3453,7 @@ globus_l_gass_copy_ftp_transfer_callback(
+ {
+ copy_handle->status = GLOBUS_GASS_COPY_STATUS_DONE;
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "ftp_transfer_callback(): GLOBUS_SUCCESS\n");
++ globus_libc_fprintf(stderr, "ftp_transfer_callback(): GLOBUS_SUCCESS\n");
+ #endif
+ }
+
+@@ -3468,26 +3468,26 @@ globus_l_gass_copy_ftp_transfer_callback(
+ switch(copy_handle->status)
+ {
+ case GLOBUS_GASS_COPY_STATUS_DONE:
+- copy_handle->status = GLOBUS_GASS_COPY_STATUS_DONE_SUCCESS;
+- break;
++ copy_handle->status = GLOBUS_GASS_COPY_STATUS_DONE_SUCCESS;
++ break;
+ case GLOBUS_GASS_COPY_STATUS_FAILURE:
+- copy_handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
+- break;
++ copy_handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
++ break;
+ case GLOBUS_GASS_COPY_STATUS_CANCEL:
+- copy_handle->status = GLOBUS_GASS_COPY_STATUS_DONE_CANCELLED;
+- break;
++ copy_handle->status = GLOBUS_GASS_COPY_STATUS_DONE_CANCELLED;
++ break;
+ default:
+- break;
++ break;
+ }
+
+ /* checksum verify */
+- if(copy_handle->status == GLOBUS_GASS_COPY_STATUS_DONE_SUCCESS && err == GLOBUS_NULL &&
++ if(copy_handle->status == GLOBUS_GASS_COPY_STATUS_DONE_SUCCESS && err == GLOBUS_NULL &&
+ copy_handle->state->cksm_handle != GLOBUS_NULL && copy_handle->state->checksum != GLOBUS_NULL)
+ {
+ globus_assert_string(copy_handle->state->dest.free_attr != GLOBUS_TRUE, "Checksum verification requires ftp attributes.");
+ result = globus_l_gass_copy_verify_cksm(
+ copy_handle, copy_handle->state->dest.attr, copy_handle->state->dest.url);
+- if(result != GLOBUS_SUCCESS)
++ if(result != GLOBUS_SUCCESS)
+ {
+ err = globus_error_get(result);
+ copy_handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
+@@ -3502,11 +3502,11 @@ globus_l_gass_copy_ftp_transfer_callback(
+ }
+
+ if(copy_handle->user_callback != GLOBUS_NULL)
+- copy_handle->user_callback(
+- copy_handle->callback_arg,
+- copy_handle,
+- err);
+-
++ copy_handle->user_callback(
++ copy_handle->callback_arg,
++ copy_handle,
++ err);
++
+ if(err)
+ {
+ globus_object_free(err);
+@@ -3517,27 +3517,27 @@ void
+ globus_l_gass_copy_ftp_get_done_callback(
+ void * callback_arg,
+ globus_ftp_client_handle_t * handle,
+- globus_object_t * error)
++ globus_object_t * error)
+ {
+ globus_gass_copy_handle_t * copy_handle
+- = (globus_gass_copy_handle_t *) callback_arg;
++ = (globus_gass_copy_handle_t *) callback_arg;
+ globus_i_gass_copy_cancel_t * cancel_info = GLOBUS_NULL;
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ globus_libc_fprintf(stderr, "ftp_get_done_callback(): starting\n");
+ #endif
+-
++
+ globus_mutex_lock(©_handle->state->mutex);
+ {
+ copy_handle->state->source.data.ftp.completed = GLOBUS_TRUE;
+ }
+ globus_mutex_unlock(©_handle->state->mutex);
+-
++
+ if ((copy_handle->status == GLOBUS_GASS_COPY_STATUS_CANCEL) ||
+ (copy_handle->status == GLOBUS_GASS_COPY_STATUS_FAILURE))
+ {
+ /* prefer this error over a data error */
+- if(copy_handle->err &&
++ if(copy_handle->err &&
+ copy_handle->err == copy_handle->state->source.data.ftp.data_err)
+ {
+ globus_object_free(copy_handle->err);
+@@ -3545,7 +3545,7 @@ globus_l_gass_copy_ftp_get_done_callback(
+ copy_handle->state->source.data.ftp.data_err = NULL;
+ globus_i_gass_copy_set_error(copy_handle, error);
+ }
+-
++
+ cancel_info = (globus_i_gass_copy_cancel_t *)
+ globus_libc_malloc(sizeof(globus_i_gass_copy_cancel_t));
+ cancel_info->handle = copy_handle;
+@@ -3558,7 +3558,7 @@ globus_l_gass_copy_ftp_get_done_callback(
+ if (error != GLOBUS_SUCCESS)
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "ftp_get_done_callback(): called with error\n");
++ globus_libc_fprintf(stderr, "ftp_get_done_callback(): called with error\n");
+ #endif
+ copy_handle->state->source.status = GLOBUS_I_GASS_COPY_TARGET_FAILED;
+ copy_handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
+@@ -3583,27 +3583,27 @@ void
+ globus_l_gass_copy_ftp_put_done_callback(
+ void * callback_arg,
+ globus_ftp_client_handle_t * handle,
+- globus_object_t * error)
++ globus_object_t * error)
+ {
+ globus_gass_copy_handle_t * copy_handle
+- = (globus_gass_copy_handle_t *) callback_arg;
++ = (globus_gass_copy_handle_t *) callback_arg;
+ globus_i_gass_copy_cancel_t * cancel_info = GLOBUS_NULL;
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ globus_libc_fprintf(stderr, "ftp_put_done_callback(): starting\n");
+ #endif
+-
++
+ globus_mutex_lock(©_handle->state->mutex);
+ {
+ copy_handle->state->dest.data.ftp.completed = GLOBUS_TRUE;
+ }
+ globus_mutex_unlock(©_handle->state->mutex);
+-
++
+ if ((copy_handle->status == GLOBUS_GASS_COPY_STATUS_CANCEL) ||
+ (copy_handle->status == GLOBUS_GASS_COPY_STATUS_FAILURE))
+ {
+ /* prefer this error over a data error */
+- if(copy_handle->err &&
++ if(copy_handle->err &&
+ copy_handle->err == copy_handle->state->dest.data.ftp.data_err)
+ {
+ globus_object_free(copy_handle->err);
+@@ -3668,28 +3668,28 @@ globus_l_gass_copy_generic_read_callback(
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ globus_libc_fprintf(stderr,
+ "generic_read_callback(): read %d bytes, offset: %"GLOBUS_OFF_T_FORMAT", last_data: %d\n",
+- nbytes, offset, last_data);
++ nbytes, offset, last_data);
+ #endif
+
+ if(state->cancel == GLOBUS_I_GASS_COPY_CANCEL_TRUE)
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "generic_read_callback(): there was an error\n");
+ #endif
+- globus_mutex_lock(&(state->source.mutex));
+- state->source.n_pending--;
+- globus_mutex_unlock(&(state->source.mutex));
++ globus_mutex_lock(&(state->source.mutex));
++ state->source.n_pending--;
++ globus_mutex_unlock(&(state->source.mutex));
+
+ globus_gass_copy_cancel(handle, NULL, NULL);
+- return;
++ return;
+ }
+
+ /*
+ * - if it's the last_data, set TARGET_DONE to prevent more reads
+ * - a buffer entry with last_data = GLOBUS_TRUE is only sent if we
+ * have already received eof and there are no pending callbacks
+- * - we only allow zero byte writes if we have already received eof
++ * - we only allow zero byte writes if we have already received eof
+ * and there are no pending callbacks
+ */
+ globus_mutex_lock(&(state->source.mutex));
+@@ -3699,7 +3699,7 @@ globus_l_gass_copy_generic_read_callback(
+ {
+ state->source.status = GLOBUS_I_GASS_COPY_TARGET_DONE;
+ }
+-
++
+ if(state->source.status == GLOBUS_I_GASS_COPY_TARGET_DONE &&
+ state->source.n_pending == 0)
+ {
+@@ -3711,26 +3711,26 @@ globus_l_gass_copy_generic_read_callback(
+ {
+ push_write = GLOBUS_FALSE;
+ }
+-
++
+ last_data = GLOBUS_FALSE;
+ }
+ }
+ globus_mutex_unlock(&(state->source.mutex));
+-
++
+ /* push the write */
+ buffer_entry = (globus_i_gass_copy_buffer_t *)
+ globus_libc_malloc(sizeof(globus_i_gass_copy_buffer_t));
+-
++
+ if(buffer_entry == GLOBUS_NULL)
+ {
+ /* out of memory error */
+ err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: failed to malloc a buffer structure successfully",
+- myname);
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: failed to malloc a buffer structure successfully",
++ myname);
+ globus_i_gass_copy_set_error(handle, err);
+-
++
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ globus_libc_fprintf(stderr,
+ "generic_read_callback(): malloc failed\n");
+@@ -3738,14 +3738,14 @@ globus_l_gass_copy_generic_read_callback(
+ globus_gass_copy_cancel(handle, NULL, NULL);
+ return;
+ } /* if(buffer_entry == GLOBUS_NULL) */
+-
++
+ if(push_write)
+ {
+ buffer_entry->bytes = bytes;
+ buffer_entry->nbytes = nbytes;
+ buffer_entry->offset = offset;
+ buffer_entry->last_data = last_data;
+-
++
+ globus_mutex_lock(&(state->dest.mutex));
+ {
+ /* put this read buffer entry onto the write queue */
+@@ -3762,22 +3762,22 @@ globus_l_gass_copy_generic_read_callback(
+ }
+ globus_mutex_unlock(&(state->source.mutex));
+ }
+-
++
+ /* start the next write if there isn't already one outstanding */
+ if(handle->state->active)
+- globus_l_gass_copy_write_from_queue(handle);
++ globus_l_gass_copy_write_from_queue(handle);
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ else
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "generic_read_callback(): handle->state == GLOBUS_NULL\n");
+ #endif
+
+ /* if we haven't read everything from the source, read again */
+ if(handle->state->active)
+- globus_l_gass_copy_read_from_queue(handle);
++ globus_l_gass_copy_read_from_queue(handle);
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ else
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "generic_read_callback(): handle->state == GLOBUS_NULL\n");
+ #endif
+
+@@ -3792,10 +3792,10 @@ globus_l_gass_copy_ftp_read_callback(
+ globus_byte_t * bytes,
+ globus_size_t nbytes,
+ globus_off_t offset,
+- globus_bool_t eof)
++ globus_bool_t eof)
+ {
+ globus_gass_copy_handle_t * copy_handle
+- = (globus_gass_copy_handle_t *) callback_arg;
++ = (globus_gass_copy_handle_t *) callback_arg;
+ globus_gass_copy_state_t * state
+ = copy_handle->state;
+
+@@ -3803,55 +3803,55 @@ globus_l_gass_copy_ftp_read_callback(
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ globus_libc_fprintf(stderr,
+- "ftp_read_callback(): start, n_pending: %d, nbytes: %d, offset: %"GLOBUS_OFF_T_FORMAT", eof: %d\n",
+- state->source.n_pending, nbytes, offset, eof);
++ "ftp_read_callback(): start, n_pending: %d, nbytes: %d, offset: %"GLOBUS_OFF_T_FORMAT", eof: %d\n",
++ state->source.n_pending, nbytes, offset, eof);
+ #endif
+
+ if(error == GLOBUS_SUCCESS) /* no error occurred */
+ {
+- last_data = eof;
+- if(eof)
+- {
++ last_data = eof;
++ if(eof)
++ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
+- "ftp_read_callback(): source TARGET_DONE, nbytes: %d, offset: %"GLOBUS_OFF_T_FORMAT", eof: %d\n",
+- nbytes, offset, eof);
++ globus_libc_fprintf(stderr,
++ "ftp_read_callback(): source TARGET_DONE, nbytes: %d, offset: %"GLOBUS_OFF_T_FORMAT", eof: %d\n",
++ nbytes, offset, eof);
+ #endif
+- /*
+- globus_mutex_lock(&(state->source.mutex));
+- {
+- state->source.status = GLOBUS_I_GASS_COPY_TARGET_DONE;
+- }
++ /*
++ globus_mutex_lock(&(state->source.mutex));
++ {
++ state->source.status = GLOBUS_I_GASS_COPY_TARGET_DONE;
++ }
+
+- globus_mutex_unlock(&(state->source.mutex));
+- */
+- if((copy_handle->status != GLOBUS_GASS_COPY_STATUS_FAILURE) &&
+- (copy_handle->status < GLOBUS_GASS_COPY_STATUS_READ_COMPLETE))
+- copy_handle->status = GLOBUS_GASS_COPY_STATUS_READ_COMPLETE;
+- }
++ globus_mutex_unlock(&(state->source.mutex));
++ */
++ if((copy_handle->status != GLOBUS_GASS_COPY_STATUS_FAILURE) &&
++ (copy_handle->status < GLOBUS_GASS_COPY_STATUS_READ_COMPLETE))
++ copy_handle->status = GLOBUS_GASS_COPY_STATUS_READ_COMPLETE;
++ }
+ }
+ else /* there was an error */
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "ftp_read_callback: was passed an ERROR\n");
++ globus_libc_fprintf(stderr, "ftp_read_callback: was passed an ERROR\n");
+ #endif
+- {
+- if(!state->cancel) /* cancel has not been set already */
+- {
+- globus_i_gass_copy_set_error(copy_handle, error);
+- state->cancel = GLOBUS_I_GASS_COPY_CANCEL_TRUE;
+- copy_handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
++ {
++ if(!state->cancel) /* cancel has not been set already */
++ {
++ globus_i_gass_copy_set_error(copy_handle, error);
++ state->cancel = GLOBUS_I_GASS_COPY_CANCEL_TRUE;
++ copy_handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
+ state->source.data.ftp.data_err = copy_handle->err;
+- }
+- else
+- {
+- globus_mutex_lock(&(state->source.mutex));
+- state->source.n_pending--;
+- globus_mutex_unlock(&(state->source.mutex));
+- return;
+- }
+-
+- }
++ }
++ else
++ {
++ globus_mutex_lock(&(state->source.mutex));
++ state->source.n_pending--;
++ globus_mutex_unlock(&(state->source.mutex));
++ return;
++ }
++
++ }
+ } /* else (there was an error) */
+
+
+@@ -3860,7 +3860,7 @@ globus_l_gass_copy_ftp_read_callback(
+ bytes,
+ nbytes,
+ offset,
+- last_data);
++ last_data);
+ } /* globus_l_gass_copy_ftp_read_callback() */
+
+ void
+@@ -3877,7 +3877,7 @@ globus_l_gass_copy_gass_read_callback(
+ static char * myname="globus_l_gass_copy_gass_read_callback";
+
+ globus_gass_copy_handle_t * handle
+- = (globus_gass_copy_handle_t *) callback_arg;
++ = (globus_gass_copy_handle_t *) callback_arg;
+ globus_gass_copy_state_t * state = handle->state;
+ req_status = globus_gass_transfer_request_get_status(request);
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+@@ -3888,60 +3888,60 @@ globus_l_gass_copy_gass_read_callback(
+ if(req_status == GLOBUS_GASS_TRANSFER_REQUEST_DONE ||
+ req_status == GLOBUS_GASS_TRANSFER_REQUEST_PENDING)
+ { /* all is well */
+- if(last_data)
+- { /* this was the last read. set READ_COMPLETE and free the request */
+- /*
+- globus_mutex_lock(&(state->source.mutex));
+- {
+- state->source.status = GLOBUS_I_GASS_COPY_TARGET_DONE;
+- }
+- globus_mutex_unlock(&(state->source.mutex));
+- */
+- handle->status = GLOBUS_GASS_COPY_STATUS_READ_COMPLETE;
++ if(last_data)
++ { /* this was the last read. set READ_COMPLETE and free the request */
++ /*
++ globus_mutex_lock(&(state->source.mutex));
++ {
++ state->source.status = GLOBUS_I_GASS_COPY_TARGET_DONE;
++ }
++ globus_mutex_unlock(&(state->source.mutex));
++ */
++ handle->status = GLOBUS_GASS_COPY_STATUS_READ_COMPLETE;
+
+ /* req_status = globus_gass_transfer_request_get_status(request); */
+
+- if(req_status == GLOBUS_GASS_TRANSFER_REQUEST_DONE)
+- {
++ if(req_status == GLOBUS_GASS_TRANSFER_REQUEST_DONE)
++ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "gass_read_callback(): GLOBUS_GASS_TRANSFER_REQUEST_DONE\n");
+ #endif
+- globus_gass_transfer_request_destroy(request);
+- }
+- else
+- {
+- /* there's an error, tell someone who cares */
++ globus_gass_transfer_request_destroy(request);
++ }
++ else
++ {
++ /* there's an error, tell someone who cares */
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "gass_read_callback(): this was last_data, but status !=GLOBUS_GASS_TRANSFER_REQUEST_DONE\n");
++ globus_libc_fprintf(stderr, "gass_read_callback(): this was last_data, but status !=GLOBUS_GASS_TRANSFER_REQUEST_DONE\n");
+ #endif
+- }
+- }/* if(last_data) */
++ }
++ }/* if(last_data) */
+
+ } /* all is well */
+ else
+ { /* all is NOT well, deal with error */
+- {
+- if(!state->cancel) /* cancel has not been set already */
+- {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: gass_transfer_request_status: %d",
+- myname,
+- req_status);
+- globus_i_gass_copy_set_error(handle, err);
+- state->cancel = GLOBUS_I_GASS_COPY_CANCEL_TRUE;
+- handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
+- }
+- else
+- {
+- globus_mutex_lock(&(state->source.mutex));
+- state->source.n_pending--;
+- globus_mutex_unlock(&(state->source.mutex));
+- return;
+- }
+- }
++ {
++ if(!state->cancel) /* cancel has not been set already */
++ {
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: gass_transfer_request_status: %d",
++ myname,
++ req_status);
++ globus_i_gass_copy_set_error(handle, err);
++ state->cancel = GLOBUS_I_GASS_COPY_CANCEL_TRUE;
++ handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
++ }
++ else
++ {
++ globus_mutex_lock(&(state->source.mutex));
++ state->source.n_pending--;
++ globus_mutex_unlock(&(state->source.mutex));
++ return;
++ }
++ }
+ } /* else (there was an error) */
+
+ /*offset = state->source.n_complete * handle->buffer_length; */
+@@ -3951,7 +3951,7 @@ globus_l_gass_copy_gass_read_callback(
+ bytes,
+ nbytes,
+ offset,
+- last_data);
++ last_data);
+ state->source.n_complete++;
+ } /* globus_l_gass_copy_gass_read_callback() */
+
+@@ -3967,15 +3967,15 @@ globus_l_gass_copy_io_read_callback(
+ globus_object_t * err = GLOBUS_NULL;
+ globus_bool_t last_data=GLOBUS_FALSE;
+ globus_gass_copy_handle_t * handle
+- = (globus_gass_copy_handle_t *) callback_arg;
++ = (globus_gass_copy_handle_t *) callback_arg;
+ globus_gass_copy_state_t * state = handle->state;
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ if(result== GLOBUS_SUCCESS)
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "io_read_callback(): result == GLOBUS_SUCCESS\n");
+ else
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "io_read_callback(): result != GLOBUS_SUCCESS\n");
+
+ globus_libc_fprintf(stderr,
+@@ -3993,41 +3993,41 @@ globus_l_gass_copy_io_read_callback(
+
+ if(result != GLOBUS_SUCCESS)
+ {
+- err = globus_error_peek(result);
+- last_data=globus_io_eof(err);
++ err = globus_error_peek(result);
++ last_data=globus_io_eof(err);
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "io_read_callback(): last_data == %d\n", last_data);
+ #endif
+- if(last_data)
+- { /* this was the last read. set READ_COMPLETE */
+- /*
+- globus_mutex_lock(&(state->source.mutex));
+- {
+- state->source.status = GLOBUS_I_GASS_COPY_TARGET_DONE;
+- }
+- globus_mutex_unlock(&(state->source.mutex));
+- */
+- handle->status = GLOBUS_GASS_COPY_STATUS_READ_COMPLETE;
++ if(last_data)
++ { /* this was the last read. set READ_COMPLETE */
++ /*
++ globus_mutex_lock(&(state->source.mutex));
++ {
++ state->source.status = GLOBUS_I_GASS_COPY_TARGET_DONE;
++ }
++ globus_mutex_unlock(&(state->source.mutex));
++ */
++ handle->status = GLOBUS_GASS_COPY_STATUS_READ_COMPLETE;
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "io_read_callback(): this was the last READ, source.status == GLOBUS_I_GASS_COPY_TARGET_DONE\n");
++ globus_libc_fprintf(stderr, "io_read_callback(): this was the last READ, source.status == GLOBUS_I_GASS_COPY_TARGET_DONE\n");
+ #endif
+- if(state->source.data.io.free_handle)
+- {
+- globus_io_close(io_handle);
++ if(state->source.data.io.free_handle)
++ {
++ globus_io_close(io_handle);
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "io_read_callback(): handle closed\n");
+ #endif
+- /* thinking that this should go in the
++ /* thinking that this should go in the
+ * globus_l_gass_copy_state_free()
+- * globus_libc_free(handle);
+- */
+- }
+- }/* if(last_data) */
+- else /* there was an error */
+- {
++ * globus_libc_free(handle);
++ */
++ }
++ }/* if(last_data) */
++ else /* there was an error */
++ {
+ if(!state->cancel) /* cancel has not been set already */
+ {
+ globus_i_gass_copy_set_error(handle, err);
+@@ -4041,7 +4041,7 @@ globus_l_gass_copy_io_read_callback(
+ globus_mutex_unlock(&(state->source.mutex));
+ return;
+ }
+- } /* else (there was an error) */
++ } /* else (there was an error) */
+ }
+
+ /* cast to 64 bits if available, otherwise bad things happen */
+@@ -4053,7 +4053,7 @@ globus_l_gass_copy_io_read_callback(
+ bytes,
+ nbytes,
+ offset,
+- last_data);
++ last_data);
+ state->source.n_complete++;
+ } /* globus_l_gass_copy_io_read_callback() */
+
+@@ -4088,11 +4088,11 @@ globus_l_gass_copy_generic_write_callback(
+ if(state->cancel == GLOBUS_I_GASS_COPY_CANCEL_TRUE)
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "generic_write_callback(): there was an error\n");
+ #endif
+ globus_gass_copy_cancel(handle, NULL, NULL);
+- return;
++ return;
+ }
+
+
+@@ -4103,24 +4103,24 @@ globus_l_gass_copy_generic_write_callback(
+ /* push the buffer on the read queue and start another read */
+
+ buffer_entry = (globus_i_gass_copy_buffer_t *)
+- globus_libc_malloc(sizeof(globus_i_gass_copy_buffer_t));
++ globus_libc_malloc(sizeof(globus_i_gass_copy_buffer_t));
+
+ if(buffer_entry == GLOBUS_NULL)
+ {
+- /* out of memory error */
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: failed to malloc a buffer structure successfully",
+- myname);
+- globus_i_gass_copy_set_error(handle, err);
++ /* out of memory error */
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: failed to malloc a buffer structure successfully",
++ myname);
++ globus_i_gass_copy_set_error(handle, err);
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "generic_write_callback(): malloc failed\n");
+ #endif
+ globus_gass_copy_cancel(handle, NULL, NULL);
+- return;
++ return;
+ }
+
+ buffer_entry->bytes = bytes;
+@@ -4132,10 +4132,10 @@ globus_l_gass_copy_generic_write_callback(
+ "generic_write_callback(): calling read_from_queue()\n");
+ #endif
+ if(handle->state->active)
+- globus_l_gass_copy_read_from_queue(handle);
++ globus_l_gass_copy_read_from_queue(handle);
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ else
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "generic_write_callback(): handle->state == GLOBUS_NULL\n");
+ #endif
+
+@@ -4145,10 +4145,10 @@ globus_l_gass_copy_generic_write_callback(
+ "generic_write_callback(): calling write_from_queue()\n");
+ #endif
+ if(handle->state->active)
+- globus_l_gass_copy_write_from_queue(handle);
++ globus_l_gass_copy_write_from_queue(handle);
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ else
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "generic_write_callback(): handle->state == GLOBUS_NULL\n");
+ #endif
+
+@@ -4182,33 +4182,33 @@ typedef struct
+ * @ingroup globus_gass_copy
+ * @details
+ * @param callback_arg
+- * Paramter expected to contain a globus_l_gass_cksm_info_t updated by
++ * Paramter expected to contain a globus_l_gass_cksm_info_t updated by
+ * globus_gass_copy_cksm_async().
+ * @param handle
+ * Unused handle to globus_gass_copy_handle_t
+ * @param error
+- * Indicates an error from globus_gass_copy_cksm_async(), will be NULL if
++ * Indicates an error from globus_gass_copy_cksm_async(), will be NULL if
+ * no error occurred.
+ *
+ * @return
+- * This function does not directly return a value, however it does
+- * signal the calling function to indicate the asynchronous checksum
+- * has completed. This signifies that the checksum is accessable
++ * This function does not directly return a value, however it does
++ * signal the calling function to indicate the asynchronous checksum
++ * has completed. This signifies that the checksum is accessable
+ * through the "checksum" member (or it's NULL if there was an error)
+ * @see globus_gass_copy_cksm_async()
+ */
+-static
++static
+ void
+ globus_l_gass_cksm_cb(
+ void * callback_arg,
+ globus_gass_copy_handle_t * handle,
+ globus_object_t * error)
+-{
++{
+ globus_l_gass_cksm_info_t * cksm_info;
+ cksm_info = (globus_l_gass_cksm_info_t *) callback_arg;
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,"%s: %s() callback_arg %p\n\n",
++ globus_libc_fprintf(stderr,"%s: %s() callback_arg %p\n\n",
+ __FILE__, __func__, callback_arg);
+ #endif
+ if(error)
+@@ -4222,7 +4222,7 @@ globus_l_gass_cksm_cb(
+ cksm_info->done = GLOBUS_TRUE;
+ globus_cond_signal(&cksm_info->monitor->cond);
+ }
+- globus_mutex_unlock(&cksm_info->monitor->mutex);
++ globus_mutex_unlock(&cksm_info->monitor->mutex);
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ globus_libc_fprintf(stderr,"\n\n%s: %s() checksum is %s\n\n", __FILE__, __func__, cksm_info->urlinfo->checksum);
+ #endif
+@@ -4237,13 +4237,13 @@ globus_l_gass_cksm_cb(
+ * @param copy_handle
+ * The handle used to perform access the file for the checksum operation.
+ * @param cksm_attr
+- * Attributes describing the connection used to access the file for the
++ * Attributes describing the connection used to access the file for the
+ * checksum operation.
+ * @param url
+ * The URL to the destination file to be checksummed.
+ *
+ * @return
+- * This function returns GLOBUS_SUCCESS if the checksum on the source
++ * This function returns GLOBUS_SUCCESS if the checksum on the source
+ * and destination files match, or a result pointing to an
+ * object of one of the the following error types:
+ * @retval GLOBUS_GASS_COPY_ERROR_TYPE_NULL_PARAMETER
+@@ -4252,7 +4252,7 @@ globus_l_gass_cksm_cb(
+ *
+ * @see globus_gass_copy_url_to_handle() globus_gass_copy_handle_to_url()
+ */
+-static
++static
+ globus_result_t
+ globus_l_gass_copy_verify_cksm(
+ globus_gass_copy_handle_t * copy_handle,
+@@ -4304,10 +4304,10 @@ globus_l_gass_copy_verify_cksm(
+ globus_mutex_lock(&cksm_monitor.mutex);
+ while(!dst_cksm_info.done)
+ {
+- globus_cond_wait(&cksm_monitor.cond, &cksm_monitor.mutex);
++ globus_cond_wait(&cksm_monitor.cond, &cksm_monitor.mutex);
+ }
+ globus_mutex_unlock(&cksm_monitor.mutex);
+-
++
+ if(dst_cksm_info.error)
+ {
+ result = globus_error_put(dst_cksm_info.error);
+@@ -4358,83 +4358,83 @@ globus_l_gass_copy_write_from_queue(
+
+ while(1)
+ {
+- do_the_write = GLOBUS_FALSE;
++ do_the_write = GLOBUS_FALSE;
+
+- globus_mutex_lock(&(state->dest.mutex));
+- {
+- if(state->dest.status == GLOBUS_I_GASS_COPY_TARGET_READY)
+- { /* if the dest is READY (and not DONE), see if we should
++ globus_mutex_lock(&(state->dest.mutex));
++ {
++ if(state->dest.status == GLOBUS_I_GASS_COPY_TARGET_READY)
++ { /* if the dest is READY (and not DONE), see if we should
+ * register a write
+ */
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "write_from_queue(): dest.status == TARGET_READY, n_pending= %d, n_simultaneous= %d\n", state->dest.n_pending, state->dest.n_simultaneous);
++ globus_libc_fprintf(stderr, "write_from_queue(): dest.status == TARGET_READY, n_pending= %d, n_simultaneous= %d\n", state->dest.n_pending, state->dest.n_simultaneous);
+ #endif
+
+- if((state->dest.n_pending <
+- state->dest.n_simultaneous) &&
+- !state->cancel)
+- { /* if there aren't too many writes outstanding, and we
++ if((state->dest.n_pending <
++ state->dest.n_simultaneous) &&
++ !state->cancel)
++ { /* if there aren't too many writes outstanding, and we
+ * haven't canceled
+ */
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "write_from_queue: gonna check the queue\n");
+ #endif
+- if ((buffer_entry=globus_fifo_dequeue(&(state->dest.queue)))
+- != GLOBUS_NULL)
+- {
+- state->dest.n_pending++;
+- do_the_write = GLOBUS_TRUE;
++ if ((buffer_entry=globus_fifo_dequeue(&(state->dest.queue)))
++ != GLOBUS_NULL)
++ {
++ state->dest.n_pending++;
++ do_the_write = GLOBUS_TRUE;
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "write_from_queue: got a buffer from the queue\n");
+ #endif
+- }/* if (buffer_entry != GLOBUS_NULL), there is a buffer
++ }/* if (buffer_entry != GLOBUS_NULL), there is a buffer
+ * in the write queue
+ */
+- else
+- {
++ else
++ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "write_from_queue: NO buffers in the queue\n");
+ #endif
+- }
+- } /* (n_pending < n_simulatneous) && !cancel */
+- } /* if(state->dest.status == GLOBUS_I_GASS_COPY_TARGET_READY) */
+- } /* lock state->dest */
+- globus_mutex_unlock(&(state->dest.mutex));
++ }
++ } /* (n_pending < n_simulatneous) && !cancel */
++ } /* if(state->dest.status == GLOBUS_I_GASS_COPY_TARGET_READY) */
++ } /* lock state->dest */
++ globus_mutex_unlock(&(state->dest.mutex));
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "write_from_queue: unlocking the dest mutex\n");
+ #endif
+- if(do_the_write)
+- {
++ if(do_the_write)
++ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "write_from_queue(): about to call register_write()\n");
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "\t\t\t nbytes= %d, offset= %"GLOBUS_OFF_T_FORMAT", last_data= %d\n",
+ buffer_entry->nbytes,
+- buffer_entry->offset,
+- buffer_entry->last_data);
++ buffer_entry->offset,
++ buffer_entry->last_data);
+ #endif
+- result = globus_l_gass_copy_register_write(
+- handle,
+- buffer_entry);
++ result = globus_l_gass_copy_register_write(
++ handle,
++ buffer_entry);
+
+- if (result != GLOBUS_SUCCESS)
+- {
+- state->cancel = GLOBUS_I_GASS_COPY_CANCEL_TRUE;
++ if (result != GLOBUS_SUCCESS)
++ {
++ state->cancel = GLOBUS_I_GASS_COPY_CANCEL_TRUE;
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "write_from_queue(): there was an ERROR trying to register a write, call cancel\n");
++ globus_libc_fprintf(stderr, "write_from_queue(): there was an ERROR trying to register a write, call cancel\n");
+ #endif
+ globus_i_gass_copy_set_error_from_result(handle, result);
+ globus_gass_copy_cancel(handle, NULL, NULL);
+ return;
+- }
+- } /* if(do_the_write) */
+- else
+- break;
++ }
++ } /* if(do_the_write) */
++ else
++ break;
+ } /* while(1) */
+
+ /* if there are no writes to do, and no writes pending, clean up and call
+@@ -4443,25 +4443,25 @@ globus_l_gass_copy_write_from_queue(
+ if(handle->state->active)
+ {
+ globus_mutex_lock(&state->mutex);
+-
++
+ if(state->source.status == GLOBUS_I_GASS_COPY_TARGET_DONE &&
+ state->dest.status == GLOBUS_I_GASS_COPY_TARGET_DONE &&
+ state->dest.n_pending == 0 && state->source.n_pending == 0 &&
+- (state->dest.mode != GLOBUS_GASS_COPY_URL_MODE_FTP ||
++ (state->dest.mode != GLOBUS_GASS_COPY_URL_MODE_FTP ||
+ state->dest.data.ftp.completed) &&
+- (state->source.mode != GLOBUS_GASS_COPY_URL_MODE_FTP ||
++ (state->source.mode != GLOBUS_GASS_COPY_URL_MODE_FTP ||
+ state->source.data.ftp.completed) &&
+ handle->status != GLOBUS_GASS_COPY_STATUS_DONE)
+ {
+ globus_gass_copy_callback_t callback;
+-
++
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ globus_libc_fprintf(stderr,
+ "write_from_queue(): source and dest status == TARGET_DONE\n");
+ #endif
+ handle->status = GLOBUS_GASS_COPY_STATUS_DONE;
+ /* do cleanup */
+-
++
+ if(handle->performance)
+ {
+ if(state->dest.mode == GLOBUS_GASS_COPY_URL_MODE_FTP)
+@@ -4473,7 +4473,7 @@ globus_l_gass_copy_write_from_queue(
+ globus_l_gass_copy_perf_cancel_local_callback(handle->performance);
+ }
+ }
+-
++
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ if(!handle->state->active)
+ globus_libc_fprintf(stderr, " handle->state == GLOBUS_NULL\n");
+@@ -4482,7 +4482,7 @@ globus_l_gass_copy_write_from_queue(
+ #endif
+ err = handle->err;
+ handle->err = GLOBUS_NULL;
+-
++
+ /* set the final status of the transfer */
+ switch(handle->status)
+ {
+@@ -4496,17 +4496,17 @@ globus_l_gass_copy_write_from_queue(
+ handle->status = GLOBUS_GASS_COPY_STATUS_DONE_CANCELLED;
+ break;
+ default:
+- break;
++ break;
+ }
+
+ /* checksum verify */
+- if(handle->status == GLOBUS_GASS_COPY_STATUS_DONE_SUCCESS && err == GLOBUS_NULL &&
++ if(handle->status == GLOBUS_GASS_COPY_STATUS_DONE_SUCCESS && err == GLOBUS_NULL &&
+ handle->state->cksm_handle != GLOBUS_NULL && handle->state->checksum != GLOBUS_NULL)
+ {
+ globus_assert_string(state->dest.free_attr != GLOBUS_TRUE, "Checksum verification requires ftp attributes.");
+ result = globus_l_gass_copy_verify_cksm(
+ handle, state->dest.attr, state->dest.url);
+- if(result != GLOBUS_SUCCESS)
++ if(result != GLOBUS_SUCCESS)
+ {
+ err = globus_error_get(result);
+ handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
+@@ -4559,18 +4559,18 @@ globus_l_gass_copy_register_write(
+ switch (state->dest.mode)
+ {
+ case GLOBUS_GASS_COPY_URL_MODE_FTP:
+- /* check the offset to see if its what we are expecting */
++ /* check the offset to see if its what we are expecting */
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "register_write(): calling globus_ftp_client_register_write()\n");
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "\t\t\t nbytes= %d, offset= %"GLOBUS_OFF_T_FORMAT", last_data= %d\n",
+ buffer_entry->nbytes,
+- buffer_entry->offset,
+- buffer_entry->last_data);
++ buffer_entry->offset,
++ buffer_entry->last_data);
+ #endif
+
+- if(handle->partial_offset != -1 &&
++ if(handle->partial_offset != -1 &&
+ state->source.mode != GLOBUS_GASS_COPY_URL_MODE_FTP)
+ {
+ tmp_offset = buffer_entry->offset + handle->partial_offset;
+@@ -4587,67 +4587,67 @@ globus_l_gass_copy_register_write(
+ buffer_entry->last_data,
+ globus_l_gass_copy_ftp_write_callback,
+ (void *) handle);
+-
+- break;
++
++ break;
+
+ case GLOBUS_GASS_COPY_URL_MODE_GASS:
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "register_write(): send_bytes -- %d bytes (last_data==%d)\n",
+ buffer_entry->nbytes,
+ buffer_entry->last_data);
+ #endif
+- /* check the offset to see if its what we are expecting */
+- rc = globus_gass_transfer_send_bytes(
+- state->dest.data.gass.request,
+- buffer_entry->bytes,
+- buffer_entry->nbytes,
+- buffer_entry->last_data,
+- globus_l_gass_copy_gass_write_callback,
+- (void *) handle);
+-
+- if (rc != GLOBUS_SUCCESS)
+- {
+- /* figure out what the error is, and pass it back through the
++ /* check the offset to see if its what we are expecting */
++ rc = globus_gass_transfer_send_bytes(
++ state->dest.data.gass.request,
++ buffer_entry->bytes,
++ buffer_entry->nbytes,
++ buffer_entry->last_data,
++ globus_l_gass_copy_gass_write_callback,
++ (void *) handle);
++
++ if (rc != GLOBUS_SUCCESS)
++ {
++ /* figure out what the error is, and pass it back through the
+ * result
+ */
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: globus_gass_transfer_send_bytes returned error code: %d",
+- myname,
+- rc);
+- globus_i_gass_copy_set_error(handle, err);
+- result = globus_error_put(err);
+- }
+- else result = GLOBUS_SUCCESS;
+-
+- break;
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: globus_gass_transfer_send_bytes returned error code: %d",
++ myname,
++ rc);
++ globus_i_gass_copy_set_error(handle, err);
++ result = globus_error_put(err);
++ }
++ else result = GLOBUS_SUCCESS;
++
++ break;
+
+ case GLOBUS_GASS_COPY_URL_MODE_IO:
+
+- if (state->dest.data.io.seekable &&
+- state->source.mode == GLOBUS_GASS_COPY_URL_MODE_FTP)
+- {
+- result = globus_io_file_seek(
+- state->dest.data.io.handle,
+- buffer_entry->offset,
+- GLOBUS_IO_SEEK_SET);
+- }
+-
+- if(result == GLOBUS_SUCCESS)
+- {
+- result = globus_io_register_write(
+- state->dest.data.io.handle,
+- buffer_entry->bytes,
+- buffer_entry->nbytes,
+- globus_l_gass_copy_io_write_callback,
+- (void *) handle);
+- }
+-
+- break;
++ if (state->dest.data.io.seekable &&
++ state->source.mode == GLOBUS_GASS_COPY_URL_MODE_FTP)
++ {
++ result = globus_io_file_seek(
++ state->dest.data.io.handle,
++ buffer_entry->offset,
++ GLOBUS_IO_SEEK_SET);
++ }
++
++ if(result == GLOBUS_SUCCESS)
++ {
++ result = globus_io_register_write(
++ state->dest.data.io.handle,
++ buffer_entry->bytes,
++ buffer_entry->nbytes,
++ globus_l_gass_copy_io_write_callback,
++ (void *) handle);
++ }
++
++ break;
+ default:
+- break;
++ break;
+ }/* switch (state->dest.mode) */
+
+ globus_libc_free(buffer_entry);
+@@ -4663,61 +4663,61 @@ globus_l_gass_copy_ftp_write_callback(
+ globus_byte_t * bytes,
+ globus_size_t nbytes,
+ globus_off_t offset,
+- globus_bool_t eof)
++ globus_bool_t eof)
+ {
+ globus_gass_copy_handle_t * copy_handle
+- = (globus_gass_copy_handle_t *) callback_arg;
++ = (globus_gass_copy_handle_t *) callback_arg;
+ globus_gass_copy_state_t * state
+ = copy_handle->state;
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ globus_libc_fprintf(stderr,
+ "ftp_write_callback(): has been called, nbytes: %d, offset= %"GLOBUS_OFF_T_FORMAT", eof= %d\n",
+- nbytes, offset, eof);
++ nbytes, offset, eof);
+ #endif
+
+ if(error == GLOBUS_SUCCESS) /* no error occurred */
+ {
+- if(eof)
+- {
++ if(eof)
++ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
+- "ftp_write_callback(): about to set dest TARGET_DONE, nbytes: %d, offset= %"GLOBUS_OFF_T_FORMAT", eof= %d\n",
+- nbytes, offset, eof);
++ globus_libc_fprintf(stderr,
++ "ftp_write_callback(): about to set dest TARGET_DONE, nbytes: %d, offset= %"GLOBUS_OFF_T_FORMAT", eof= %d\n",
++ nbytes, offset, eof);
+ #endif
+- globus_mutex_lock(&(state->dest.mutex));
+- {
+- state->dest.status = GLOBUS_I_GASS_COPY_TARGET_DONE;
+- }
+- globus_mutex_unlock(&(state->dest.mutex));
+- if((copy_handle->status != GLOBUS_GASS_COPY_STATUS_FAILURE) &&
+- (copy_handle->status < GLOBUS_GASS_COPY_STATUS_WRITE_COMPLETE))
+- copy_handle->status = GLOBUS_GASS_COPY_STATUS_WRITE_COMPLETE;
+- }
++ globus_mutex_lock(&(state->dest.mutex));
++ {
++ state->dest.status = GLOBUS_I_GASS_COPY_TARGET_DONE;
++ }
++ globus_mutex_unlock(&(state->dest.mutex));
++ if((copy_handle->status != GLOBUS_GASS_COPY_STATUS_FAILURE) &&
++ (copy_handle->status < GLOBUS_GASS_COPY_STATUS_WRITE_COMPLETE))
++ copy_handle->status = GLOBUS_GASS_COPY_STATUS_WRITE_COMPLETE;
++ }
+ }
+ else /* there was an error */
+ {
+- {
+- if(!state->cancel) /* cancel has not been set already */
+- {
++ {
++ if(!state->cancel) /* cancel has not been set already */
++ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "ftp_write_callback(): there was an ERROR, throw cancel flag\n");
++ globus_libc_fprintf(stderr, "ftp_write_callback(): there was an ERROR, throw cancel flag\n");
+ #endif
+- globus_i_gass_copy_set_error(copy_handle, error);
+- state->cancel = GLOBUS_I_GASS_COPY_CANCEL_TRUE;
+- copy_handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
++ globus_i_gass_copy_set_error(copy_handle, error);
++ state->cancel = GLOBUS_I_GASS_COPY_CANCEL_TRUE;
++ copy_handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
+ state->dest.data.ftp.data_err = copy_handle->err;
+- }
+- else
+- {
+- globus_mutex_lock(&(state->dest.mutex));
+- state->dest.n_pending--;
+- globus_mutex_unlock(&(state->dest.mutex));
+- return;
+- }
++ }
++ else
++ {
++ globus_mutex_lock(&(state->dest.mutex));
++ state->dest.n_pending--;
++ globus_mutex_unlock(&(state->dest.mutex));
++ return;
++ }
+
+
+- }
++ }
+ } /* else (there was an error) */
+
+ globus_l_gass_copy_generic_write_callback(
+@@ -4741,7 +4741,7 @@ globus_l_gass_copy_gass_write_callback(
+ static char * myname="globus_l_gass_copy_gass_write_callback";
+
+ globus_gass_copy_handle_t * handle
+- = (globus_gass_copy_handle_t *) callback_arg;
++ = (globus_gass_copy_handle_t *) callback_arg;
+ globus_gass_copy_state_t * state = handle->state;
+
+ req_status = globus_gass_transfer_request_get_status(request);
+@@ -4754,59 +4754,59 @@ globus_l_gass_copy_gass_write_callback(
+ if(req_status == GLOBUS_GASS_TRANSFER_REQUEST_DONE ||
+ req_status == GLOBUS_GASS_TRANSFER_REQUEST_PENDING)
+ { /* all is well */
+- if(last_data)
+- { /* this was the last write. set WRITE_COMPLETE and free the request */
++ if(last_data)
++ { /* this was the last write. set WRITE_COMPLETE and free the request */
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "gass_write_callback(): THIS WAS THE LAST WRITE\n");
+ #endif
+- globus_mutex_lock(&(state->dest.mutex));
+- {
+- state->dest.status = GLOBUS_I_GASS_COPY_TARGET_DONE;
+- }
+- globus_mutex_unlock(&(state->dest.mutex));
+- handle->status = GLOBUS_GASS_COPY_STATUS_WRITE_COMPLETE;
++ globus_mutex_lock(&(state->dest.mutex));
++ {
++ state->dest.status = GLOBUS_I_GASS_COPY_TARGET_DONE;
++ }
++ globus_mutex_unlock(&(state->dest.mutex));
++ handle->status = GLOBUS_GASS_COPY_STATUS_WRITE_COMPLETE;
+
+- if(req_status == GLOBUS_GASS_TRANSFER_REQUEST_DONE)
+- {
++ if(req_status == GLOBUS_GASS_TRANSFER_REQUEST_DONE)
++ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "gass_write_callback(): GLOBUS_GASS_TRANSFER_REQUEST_DONE\n");
+ #endif
+- globus_gass_transfer_request_destroy(request);
+- }
+- else
+- {
+- /* there's an error, tell someone who cares */
++ globus_gass_transfer_request_destroy(request);
++ }
++ else
++ {
++ /* there's an error, tell someone who cares */
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "gass_write_callback(): this was last_data, but status !=GLOBUS_GASS_TRANSFER_REQUEST_DONE\n");
++ globus_libc_fprintf(stderr, "gass_write_callback(): this was last_data, but status !=GLOBUS_GASS_TRANSFER_REQUEST_DONE\n");
+ #endif
+- }
+- } /* if (last_data) */
++ }
++ } /* if (last_data) */
+ } /*all is well */
+ else
+ { /* all is NOT well, deal with error */
+- {
+- if(!state->cancel) /* cancel has not been set already */
+- {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: gass_transfer_request_status: %d",
+- myname,
+- req_status);
+- globus_i_gass_copy_set_error(handle, err);
+- state->cancel = GLOBUS_I_GASS_COPY_CANCEL_TRUE;
+- handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
+- }
+- else
+- {
+- globus_mutex_lock(&(state->dest.mutex));
+- state->dest.n_pending--;
+- globus_mutex_unlock(&(state->dest.mutex));
+- return;
+- }
+- }
++ {
++ if(!state->cancel) /* cancel has not been set already */
++ {
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: gass_transfer_request_status: %d",
++ myname,
++ req_status);
++ globus_i_gass_copy_set_error(handle, err);
++ state->cancel = GLOBUS_I_GASS_COPY_CANCEL_TRUE;
++ handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
++ }
++ else
++ {
++ globus_mutex_lock(&(state->dest.mutex));
++ state->dest.n_pending--;
++ globus_mutex_unlock(&(state->dest.mutex));
++ return;
++ }
++ }
+ } /* else (there was an error) */
+
+ globus_l_gass_copy_generic_write_callback(
+@@ -4825,96 +4825,96 @@ globus_l_gass_copy_io_write_callback(
+ globus_size_t nbytes)
+ {
+ globus_gass_copy_handle_t * handle
+- = (globus_gass_copy_handle_t *) callback_arg;
++ = (globus_gass_copy_handle_t *) callback_arg;
+ globus_gass_copy_state_t * state = handle->state;
+ globus_bool_t close_handle = GLOBUS_FALSE;
+-
++
+ /*
+ * used this to simulate a io write error
+ *
+ globus_object_t * err;
+
+ err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[STU]: STU, forcing io write callback fault");
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[STU]: STU, forcing io write callback fault");
+ result=globus_error_put(err);
+ */
+
+ if(result==GLOBUS_SUCCESS)
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "io_write_callback(): result == GLOBUS_SUCCESS\n");
+ #endif
+
+- globus_mutex_lock(&(state->source.mutex));
+- {
+- if(state->source.status == GLOBUS_I_GASS_COPY_TARGET_DONE &&
+- state->source.n_pending == 0)
+- {
++ globus_mutex_lock(&(state->source.mutex));
++ {
++ if(state->source.status == GLOBUS_I_GASS_COPY_TARGET_DONE &&
++ state->source.n_pending == 0)
++ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "io_write_callback(): THIS WAS THE LAST WRITE\n");
+ #endif
+- globus_mutex_lock(&(state->dest.mutex));
+- {
+- if(globus_fifo_empty(&(state->dest.queue)))
+- {
+- state->dest.status = GLOBUS_I_GASS_COPY_TARGET_DONE;
++ globus_mutex_lock(&(state->dest.mutex));
++ {
++ if(globus_fifo_empty(&(state->dest.queue)))
++ {
++ state->dest.status = GLOBUS_I_GASS_COPY_TARGET_DONE;
+
+- handle->status = GLOBUS_GASS_COPY_STATUS_WRITE_COMPLETE;
++ handle->status = GLOBUS_GASS_COPY_STATUS_WRITE_COMPLETE;
+
+- if(state->dest.data.io.free_handle)
+- {
+- close_handle = GLOBUS_TRUE;
++ if(state->dest.data.io.free_handle)
++ {
++ close_handle = GLOBUS_TRUE;
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "io_write_callback(): handle closed\n");
+ #endif
+- } /* if(state->dest.data.io.free_handle) */
+- } /* if write queue is empty */
+- }
+- globus_mutex_unlock(&(state->dest.mutex));
++ } /* if(state->dest.data.io.free_handle) */
++ } /* if write queue is empty */
++ }
++ globus_mutex_unlock(&(state->dest.mutex));
++
++ } /* end if last write */
++ }
++ globus_mutex_unlock(&(state->source.mutex));
+
+- } /* end if last write */
+- }
+- globus_mutex_unlock(&(state->source.mutex));
+-
+- if(close_handle)
+- {
+- globus_io_close(io_handle);
+- }
++ if(close_handle)
++ {
++ globus_io_close(io_handle);
++ }
+ }
+ else /* there was an error */
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "io_write_callback(): result != GLOBUS_SUCCESS\n");
+ #endif
+- {
+- if(!state->cancel) /* cancel has not been set already */
+- {
++ {
++ if(!state->cancel) /* cancel has not been set already */
++ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "io_write_callback(): cancel has not been set\n");
+ #endif
+- globus_i_gass_copy_set_error_from_result(handle, result);
+- state->cancel = GLOBUS_I_GASS_COPY_CANCEL_TRUE;
+- handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
+- }
+- else
+- {
++ globus_i_gass_copy_set_error_from_result(handle, result);
++ state->cancel = GLOBUS_I_GASS_COPY_CANCEL_TRUE;
++ handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
++ }
++ else
++ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "io_write_callback(): cancel has already been set\n");
+ #endif
+- globus_mutex_lock(&(state->dest.mutex));
+- state->dest.n_pending--;
+- globus_mutex_unlock(&(state->dest.mutex));
+- return;
+- }
+- }
++ globus_mutex_lock(&(state->dest.mutex));
++ state->dest.n_pending--;
++ globus_mutex_unlock(&(state->dest.mutex));
++ return;
++ }
++ }
+ } /* else (there was an error) */
+
+ globus_l_gass_copy_generic_write_callback(
+@@ -4974,18 +4974,18 @@ globus_gass_copy_url_to_url(
+
+ if(handle == GLOBUS_NULL)
+ {
+- bad_param = 1;
+- goto error_exit;
++ bad_param = 1;
++ goto error_exit;
+ }
+ if(source_url == GLOBUS_NULL)
+ {
+- bad_param = 2;
+- goto error_exit;
++ bad_param = 2;
++ goto error_exit;
+ }
+ if(dest_url == GLOBUS_NULL)
+ {
+- bad_param = 4;
+- goto error_exit;
++ bad_param = 4;
++ goto error_exit;
+ }
+
+ /* return an error if a transfer is already in progress */
+@@ -4993,10 +4993,10 @@ globus_gass_copy_url_to_url(
+ handle->status < GLOBUS_GASS_COPY_STATUS_DONE_SUCCESS)
+ {
+ err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: There is a transfer already active on this handle",
+- myname);
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: There is a transfer already active on this handle",
++ myname);
+ return globus_error_put(err);
+ }
+
+@@ -5007,20 +5007,20 @@ globus_gass_copy_url_to_url(
+ monitor.use_err = GLOBUS_FALSE;
+
+ result = globus_gass_copy_register_url_to_url(
+- handle,
+- source_url,
+- source_attr,
+- dest_url,
+- dest_attr,
+- globus_l_gass_copy_monitor_callback,
+- (void *) &monitor);
++ handle,
++ source_url,
++ source_attr,
++ dest_url,
++ dest_attr,
++ globus_l_gass_copy_monitor_callback,
++ (void *) &monitor);
+
+ if(result != GLOBUS_SUCCESS)
+ {
+- globus_mutex_destroy(&monitor.mutex);
+- globus_cond_destroy(&monitor.cond);
+- handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
+- return(result);
++ globus_mutex_destroy(&monitor.mutex);
++ globus_cond_destroy(&monitor.cond);
++ handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
++ return(result);
+ }
+ /* wait on cond_wait() for completion */
+ globus_mutex_lock(&monitor.mutex);
+@@ -5048,14 +5048,14 @@ globus_gass_copy_url_to_url(
+ error_exit:
+
+ err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, argument %d cannot be NULL",
+- myname,
+- bad_param);
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, argument %d cannot be NULL",
++ myname,
++ bad_param);
+
+ if(handle)
+- handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
++ handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
+
+ return globus_error_put(err);
+
+@@ -5109,18 +5109,18 @@ globus_gass_copy_url_to_handle(
+ /* Check arguments for validity */
+ if(handle == GLOBUS_NULL)
+ {
+- bad_param=1;
+- goto error_exit;
++ bad_param=1;
++ goto error_exit;
+ }
+ if(source_url == GLOBUS_NULL)
+ {
+- bad_param=2;
+- goto error_exit;
++ bad_param=2;
++ goto error_exit;
+ }
+ if(dest_handle == GLOBUS_NULL)
+ {
+- bad_param=4;
+- goto error_exit;
++ bad_param=4;
++ goto error_exit;
+ }
+
+ /* return an error if a transfer is already in progress */
+@@ -5128,10 +5128,10 @@ globus_gass_copy_url_to_handle(
+ handle->status < GLOBUS_GASS_COPY_STATUS_DONE_SUCCESS)
+ {
+ err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: There is a transfer already active on this handle",
+- myname);
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: There is a transfer already active on this handle",
++ myname);
+ return globus_error_put(err);
+ }
+
+@@ -5142,19 +5142,19 @@ globus_gass_copy_url_to_handle(
+ monitor.use_err = GLOBUS_FALSE;
+
+ result = globus_gass_copy_register_url_to_handle(
+- handle,
+- source_url,
+- source_attr,
+- dest_handle,
+- globus_l_gass_copy_monitor_callback,
+- (void *) &monitor);
++ handle,
++ source_url,
++ source_attr,
++ dest_handle,
++ globus_l_gass_copy_monitor_callback,
++ (void *) &monitor);
+
+ if(result != GLOBUS_SUCCESS)
+ {
+- globus_mutex_destroy(&monitor.mutex);
+- globus_cond_destroy(&monitor.cond);
+- handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
+- return(result);
++ globus_mutex_destroy(&monitor.mutex);
++ globus_cond_destroy(&monitor.cond);
++ handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
++ return(result);
+ }
+
+ /* wait on cond_wait() for completion */
+@@ -5162,7 +5162,7 @@ globus_gass_copy_url_to_handle(
+
+ while(!monitor.done)
+ {
+- globus_cond_wait(&monitor.cond, &monitor.mutex);
++ globus_cond_wait(&monitor.cond, &monitor.mutex);
+ }
+
+ globus_mutex_unlock(&monitor.mutex);
+@@ -5184,14 +5184,14 @@ globus_gass_copy_url_to_handle(
+ error_exit:
+
+ err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, argument %d cannot be NULL",
+- myname,
+- bad_param);
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, argument %d cannot be NULL",
++ myname,
++ bad_param);
+
+ if(handle)
+- handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
++ handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
+ return globus_error_put(err);
+
+ } /* globus_gass_copy_url_to_handle() */
+@@ -5241,18 +5241,18 @@ globus_gass_copy_handle_to_url(
+ /* Check arguments for validity */
+ if(handle == GLOBUS_NULL)
+ {
+- bad_param=1;
+- goto error_exit;
++ bad_param=1;
++ goto error_exit;
+ }
+ if(source_handle == GLOBUS_NULL)
+ {
+- bad_param=2;
+- goto error_exit;
++ bad_param=2;
++ goto error_exit;
+ }
+ if(dest_url == GLOBUS_NULL)
+ {
+- bad_param=3;
+- goto error_exit;
++ bad_param=3;
++ goto error_exit;
+ }
+
+ /* return an error if a transfer is already in progress */
+@@ -5260,10 +5260,10 @@ globus_gass_copy_handle_to_url(
+ handle->status < GLOBUS_GASS_COPY_STATUS_DONE_SUCCESS)
+ {
+ err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: There is a transfer already active on this handle",
+- myname);
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: There is a transfer already active on this handle",
++ myname);
+ return globus_error_put(err);
+ }
+
+@@ -5274,26 +5274,26 @@ globus_gass_copy_handle_to_url(
+ monitor.use_err = GLOBUS_FALSE;
+
+ result = globus_gass_copy_register_handle_to_url(
+- handle,
+- source_handle,
+- dest_url,
+- dest_attr,
+- globus_l_gass_copy_monitor_callback,
+- (void *) &monitor);
++ handle,
++ source_handle,
++ dest_url,
++ dest_attr,
++ globus_l_gass_copy_monitor_callback,
++ (void *) &monitor);
+
+ if(result != GLOBUS_SUCCESS)
+ {
+- globus_mutex_destroy(&monitor.mutex);
+- globus_cond_destroy(&monitor.cond);
+- handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
+- return(result);
++ globus_mutex_destroy(&monitor.mutex);
++ globus_cond_destroy(&monitor.cond);
++ handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
++ return(result);
+ }
+ /* wait on cond_wait() for completion */
+ globus_mutex_lock(&monitor.mutex);
+
+ while(!monitor.done)
+ {
+- globus_cond_wait(&monitor.cond, &monitor.mutex);
++ globus_cond_wait(&monitor.cond, &monitor.mutex);
+ }
+
+ globus_mutex_unlock(&monitor.mutex);
+@@ -5305,24 +5305,24 @@ globus_gass_copy_handle_to_url(
+
+ if(monitor.use_err)
+ {
+- return globus_error_put(monitor.err);
++ return globus_error_put(monitor.err);
+ }
+ else
+ {
+- return GLOBUS_SUCCESS;
++ return GLOBUS_SUCCESS;
+ }
+
+ error_exit:
+
+ err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, argument %d cannot be NULL",
+- myname,
+- bad_param);
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, argument %d cannot be NULL",
++ myname,
++ bad_param);
+
+ if(handle)
+- handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
++ handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
+
+ return globus_error_put(err);
+
+@@ -5394,29 +5394,29 @@ globus_gass_copy_register_url_to_url(
+ if(handle == GLOBUS_NULL)
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "register_url_to_url(): handle was GLOBUS_NULL\n");
+ #endif
+- bad_param = 1;
+- goto error_exit;
++ bad_param = 1;
++ goto error_exit;
+ }
+ if(source_url == GLOBUS_NULL)
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "register_url_to_url(): source_url was GLOBUS_NULL\n");
+ #endif
+- bad_param = 2;
+- goto error_exit;
++ bad_param = 2;
++ goto error_exit;
+ }
+ if(dest_url == GLOBUS_NULL)
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "register_url_to_url(): dest_url was GLOBUS_NULL\n");
+ #endif
+- bad_param = 4;
+- goto error_exit;
++ bad_param = 4;
++ goto error_exit;
+ }
+
+ /* return an error if a transfer is already in progress */
+@@ -5424,47 +5424,47 @@ globus_gass_copy_register_url_to_url(
+ handle->status < GLOBUS_GASS_COPY_STATUS_DONE_SUCCESS)
+ {
+ err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: There is a transfer already active on this handle",
+- myname);
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: There is a transfer already active on this handle",
++ myname);
+ return globus_error_put(err);
+ }
+-
++
+ result = globus_gass_copy_get_url_mode(
+- source_url,
+- &source_url_mode);
++ source_url,
++ &source_url_mode);
+ if(result != GLOBUS_SUCCESS)
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "register_url_to_url(): copy_url_mode returned ! GLOBUS_SUCCESS for source_url\n");
++ globus_libc_fprintf(stderr, "register_url_to_url(): copy_url_mode returned ! GLOBUS_SUCCESS for source_url\n");
+ #endif
+- goto error_result_exit;
++ goto error_result_exit;
+ }
+
+ result = globus_gass_copy_get_url_mode(
+- dest_url,
+- &dest_url_mode);
++ dest_url,
++ &dest_url_mode);
+ if(result != GLOBUS_SUCCESS)
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "register_url_to_url(): copy_url_mode returned ! GLOBUS_SUCCESS for dest_url\n");
++ globus_libc_fprintf(stderr, "register_url_to_url(): copy_url_mode returned ! GLOBUS_SUCCESS for dest_url\n");
+ #endif
+- goto error_result_exit;
++ goto error_result_exit;
+ }
+
+ if ( (source_url_mode == GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED)
+- || (dest_url_mode == GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED) )
++ || (dest_url_mode == GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED) )
+ {
+- char src_msg[256];
+- char dest_msg[256];
++ char src_msg[256];
++ char dest_msg[256];
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "register_url_to_url(): source or dest is URL_MODE_UNSUPPORTED\n");
+ #endif
+- if(source_url_mode == GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED)
+- {
+- sprintf(src_msg, " %s, GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED.",
++ if(source_url_mode == GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED)
++ {
++ sprintf(src_msg, " %s, GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED.",
+ source_url);
+ }
+ else
+@@ -5472,9 +5472,9 @@ globus_gass_copy_register_url_to_url(
+ *src_msg = '\0';
+ }
+
+- if(dest_url_mode == GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED)
+- {
+- sprintf(dest_msg, " %s, GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED.",
++ if(dest_url_mode == GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED)
++ {
++ sprintf(dest_msg, " %s, GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED.",
+ dest_url);
+ }
+ else
+@@ -5482,16 +5482,16 @@ globus_gass_copy_register_url_to_url(
+ *dest_msg = '\0';
+ }
+
+- handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: %s%s",
+- myname,
+- src_msg,
+- dest_msg);
++ handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: %s%s",
++ myname,
++ src_msg,
++ dest_msg);
+
+- return globus_error_put(err);
++ return globus_error_put(err);
+ }
+
+ /* reinitialize the state for this transfer */
+@@ -5505,22 +5505,22 @@ globus_gass_copy_register_url_to_url(
+ handle->callback_arg = callback_arg;
+
+ result = globus_l_gass_copy_target_populate(
+- handle,
+- &(state->source),
+- &source_url_mode,
+- source_url,
+- source_attr);
++ handle,
++ &(state->source),
++ &source_url_mode,
++ source_url,
++ source_attr);
+
+ if(result != GLOBUS_SUCCESS) goto error_result_exit;
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ globus_libc_fprintf(stderr, "source target populated\n");
+ #endif
+ result = globus_l_gass_copy_target_populate(
+- handle,
+- &(state->dest),
+- &dest_url_mode,
+- dest_url,
+- dest_attr);
++ handle,
++ &(state->dest),
++ &dest_url_mode,
++ dest_url,
++ dest_attr);
+
+ if(result != GLOBUS_SUCCESS) goto error_result_exit;
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+@@ -5530,8 +5530,8 @@ globus_gass_copy_register_url_to_url(
+ if(dest_url_mode == GLOBUS_GASS_COPY_URL_MODE_FTP && handle->send_allo)
+ {
+ globus_off_t source_size = 0;
+-
+-
++
++
+ if(handle->partial_end_offset != -1)
+ {
+ source_size = handle->partial_end_offset;
+@@ -5555,11 +5555,11 @@ globus_gass_copy_register_url_to_url(
+ state->dest.attr->ftp_attr,
+ source_size);
+ }
+- }
+-
++ }
++
+ if ( (source_url_mode == GLOBUS_GASS_COPY_URL_MODE_FTP) &&
+- (dest_url_mode == GLOBUS_GASS_COPY_URL_MODE_FTP) &&
+- !handle->no_third_party_transfers )
++ (dest_url_mode == GLOBUS_GASS_COPY_URL_MODE_FTP) &&
++ !handle->no_third_party_transfers )
+ {
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+@@ -5585,16 +5585,16 @@ globus_gass_copy_register_url_to_url(
+ mode != GLOBUS_FTP_CONTROL_MODE_EXTENDED_BLOCK)
+ {
+ new_ftp_attr = (globus_ftp_client_operationattr_t *)
+- globus_libc_malloc(sizeof(globus_ftp_client_operationattr_t));
++ globus_libc_malloc(sizeof(globus_ftp_client_operationattr_t));
+
+- globus_ftp_client_operationattr_copy(new_ftp_attr,
+- state->dest.attr->ftp_attr);
++ globus_ftp_client_operationattr_copy(new_ftp_attr,
++ state->dest.attr->ftp_attr);
+ }
+ }
+ else
+ {
+ new_ftp_attr = (globus_ftp_client_operationattr_t *)
+- globus_libc_malloc(sizeof(globus_ftp_client_operationattr_t));
++ globus_libc_malloc(sizeof(globus_ftp_client_operationattr_t));
+ globus_ftp_client_operationattr_init(new_ftp_attr);
+ }
+
+@@ -5622,16 +5622,16 @@ globus_gass_copy_register_url_to_url(
+ mode != GLOBUS_FTP_CONTROL_MODE_EXTENDED_BLOCK)
+ {
+ new_ftp_attr = (globus_ftp_client_operationattr_t *)
+- globus_libc_malloc(sizeof(globus_ftp_client_operationattr_t));
++ globus_libc_malloc(sizeof(globus_ftp_client_operationattr_t));
+
+- globus_ftp_client_operationattr_copy(new_ftp_attr,
+- state->source.attr->ftp_attr);
++ globus_ftp_client_operationattr_copy(new_ftp_attr,
++ state->source.attr->ftp_attr);
+ }
+ }
+ else
+ {
+ new_ftp_attr = (globus_ftp_client_operationattr_t *)
+- globus_libc_malloc(sizeof(globus_ftp_client_operationattr_t));
++ globus_libc_malloc(sizeof(globus_ftp_client_operationattr_t));
+ globus_ftp_client_operationattr_init(new_ftp_attr);
+ }
+
+@@ -5663,7 +5663,7 @@ globus_gass_copy_register_url_to_url(
+ globus_l_gass_copy_ftp_transfer_callback,
+ (void *) handle);
+ }
+- else
++ else
+ {
+ result = globus_ftp_client_partial_third_party_transfer(
+ &handle->ftp_handle,
+@@ -5677,54 +5677,54 @@ globus_gass_copy_register_url_to_url(
+ globus_l_gass_copy_ftp_transfer_callback,
+ (void *) handle);
+ }
+-
+- if (result != GLOBUS_SUCCESS)
+- {
+- /* do some error handling */
++
++ if (result != GLOBUS_SUCCESS)
++ {
++ /* do some error handling */
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "third_party_transfer() was not GLOBUS_SUCCESS! it returned %d\n",
+ result);
+ #endif
+- goto error_result_exit;
+- }
+- else
+- {
+- handle->status = GLOBUS_GASS_COPY_STATUS_TRANSFER_IN_PROGRESS;
++ goto error_result_exit;
++ }
++ else
++ {
++ handle->status = GLOBUS_GASS_COPY_STATUS_TRANSFER_IN_PROGRESS;
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "third_party_transfer() returned GLOBUS_SUCCESS\n");
+ #endif
+- }
++ }
+ }
+ else
+ {
+ /* At least one of the urls is not ftp, (or thirdparty transfers
+ * have been turned off) so we have to do the copy ourselves.
+ */
+- result = globus_l_gass_copy_transfer_start(handle);
+- if (result != GLOBUS_SUCCESS)
+- {
+- /* free the state */
+- if(handle->state->active)
+- {
+- globus_l_gass_copy_state_free_targets(handle->state);
+- }
+- goto error_result_exit;
+- }
++ result = globus_l_gass_copy_transfer_start(handle);
++ if (result != GLOBUS_SUCCESS)
++ {
++ /* free the state */
++ if(handle->state->active)
++ {
++ globus_l_gass_copy_state_free_targets(handle->state);
++ }
++ goto error_result_exit;
++ }
+ }
+
+ return GLOBUS_SUCCESS;
+
+ error_exit:
+ if(handle)
+- handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
++ handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
+ err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, argument %d cannot be NULL",
+- myname,
+- bad_param);
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, argument %d cannot be NULL",
++ myname,
++ bad_param);
+ return globus_error_put(err);
+
+ error_result_exit:
+@@ -5790,18 +5790,18 @@ globus_gass_copy_register_url_to_handle(
+ /* Check arguments for validity */
+ if(handle == GLOBUS_NULL)
+ {
+- bad_param=1;
+- goto error_exit;
++ bad_param=1;
++ goto error_exit;
+ }
+ if(source_url == GLOBUS_NULL)
+ {
+- bad_param=2;
+- goto error_exit;
++ bad_param=2;
++ goto error_exit;
+ }
+ if(dest_handle == GLOBUS_NULL)
+ {
+- bad_param=4;
+- goto error_exit;
++ bad_param=4;
++ goto error_exit;
+ }
+
+ /* return an error if a transfer is already in progress */
+@@ -5809,32 +5809,32 @@ globus_gass_copy_register_url_to_handle(
+ handle->status < GLOBUS_GASS_COPY_STATUS_DONE_SUCCESS)
+ {
+ err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: There is a transfer already active on this handle",
+- myname);
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: There is a transfer already active on this handle",
++ myname);
+ return globus_error_put(err);
+ }
+
+ result = globus_gass_copy_get_url_mode(
+- source_url,
+- &source_url_mode);
++ source_url,
++ &source_url_mode);
+
+ if(result != GLOBUS_SUCCESS) goto error_result_exit;
+
+ if ( source_url_mode == GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED)
+ {
+- handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: %s, GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED",
+- myname,
+- source_url);
++ handle->status = GLOBUS_GASS_COPY_STATUS_FAILURE;
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: %s, GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED",
++ myname,
++ source_url);
+
+- handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
++ handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
+
+- return globus_error_put(err);
++ return globus_error_put(err);
+ }
+
+ /* reinitialize the state for this transfer */
+@@ -5848,19 +5848,19 @@ globus_gass_copy_register_url_to_handle(
+ handle->callback_arg = callback_arg;
+
+ result = globus_l_gass_copy_target_populate(
+- handle,
+- &(state->source),
+- &source_url_mode,
+- source_url,
+- source_attr);
++ handle,
++ &(state->source),
++ &source_url_mode,
++ source_url,
++ source_attr);
+ if(result != GLOBUS_SUCCESS) goto error_result_exit;
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ globus_libc_fprintf(stderr, "source target populated\n");
+ #endif
+ result = globus_l_gass_copy_io_target_populate(
+- handle,
+- &(state->dest),
+- dest_handle);
++ handle,
++ &(state->dest),
++ dest_handle);
+ if(result != GLOBUS_SUCCESS) goto error_result_exit;
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+@@ -5870,20 +5870,20 @@ globus_gass_copy_register_url_to_handle(
+ result = globus_l_gass_copy_transfer_start(handle);
+ if (result != GLOBUS_SUCCESS)
+ {
+- goto error_result_exit;
++ goto error_result_exit;
+ }
+
+ return GLOBUS_SUCCESS;
+
+ error_exit:
+ if(handle)
+- handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
++ handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
+ err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, argument %d cannot be NULL",
+- myname,
+- bad_param);
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, argument %d cannot be NULL",
++ myname,
++ bad_param);
+ return globus_error_put(err);
+
+ error_result_exit:
+@@ -5950,18 +5950,18 @@ globus_gass_copy_register_handle_to_url(
+ /* Check arguments for validity */
+ if(handle == GLOBUS_NULL)
+ {
+- bad_param=1;
+- goto error_exit;
++ bad_param=1;
++ goto error_exit;
+ }
+ if(source_handle == GLOBUS_NULL)
+ {
+- bad_param=2;
+- goto error_exit;
++ bad_param=2;
++ goto error_exit;
+ }
+ if(dest_url == GLOBUS_NULL)
+ {
+- bad_param=3;
+- goto error_exit;
++ bad_param=3;
++ goto error_exit;
+ }
+
+ /* return an error if a transfer is already in progress */
+@@ -5969,30 +5969,30 @@ globus_gass_copy_register_handle_to_url(
+ handle->status < GLOBUS_GASS_COPY_STATUS_DONE_SUCCESS)
+ {
+ err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: There is a transfer already active on this handle",
+- myname);
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: There is a transfer already active on this handle",
++ myname);
+ return globus_error_put(err);
+ }
+
+ result = globus_gass_copy_get_url_mode(
+- dest_url,
+- &dest_url_mode);
++ dest_url,
++ &dest_url_mode);
+ if(result != GLOBUS_SUCCESS) goto error_result_exit;
+
+ if ( dest_url_mode == GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED)
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: %s, GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED",
+- myname,
+- dest_url);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: %s, GLOBUS_GASS_COPY_URL_MODE_UNSUPPORTED",
++ myname,
++ dest_url);
+
+- handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
++ handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
+
+- return globus_error_put(err);
++ return globus_error_put(err);
+ }
+
+ /* reinitialize the state for this transfer */
+@@ -6006,19 +6006,19 @@ globus_gass_copy_register_handle_to_url(
+ handle->callback_arg = callback_arg;
+
+ result = globus_l_gass_copy_io_target_populate(
+- handle,
+- &(state->source),
+- source_handle);
++ handle,
++ &(state->source),
++ source_handle);
+ if(result != GLOBUS_SUCCESS) goto error_result_exit;
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ globus_libc_fprintf(stderr, "source target populated\n");
+ #endif
+ result = globus_l_gass_copy_target_populate(
+- handle,
+- &(state->dest),
+- &dest_url_mode,
+- dest_url,
+- dest_attr);
++ handle,
++ &(state->dest),
++ &dest_url_mode,
++ dest_url,
++ dest_attr);
+
+ if(result != GLOBUS_SUCCESS) goto error_result_exit;
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+@@ -6027,20 +6027,20 @@ globus_gass_copy_register_handle_to_url(
+ result = globus_l_gass_copy_transfer_start(handle);
+ if (result != GLOBUS_SUCCESS)
+ {
+- goto error_result_exit;
++ goto error_result_exit;
+ }
+
+ return GLOBUS_SUCCESS;
+
+ error_exit:
+ if(handle)
+- handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
++ handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
+ err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, argument %d cannot be NULL",
+- myname,
+- bad_param);
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, argument %d cannot be NULL",
++ myname,
++ bad_param);
+ return globus_error_put(err);
+ error_result_exit:
+ handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
+@@ -6081,42 +6081,42 @@ globus_gass_copy_cache_url_state(
+
+ if(handle != GLOBUS_NULL)
+ {
+- globus_url_parse(url, &url_info);
+- if ( (strcmp(url_info.scheme, "ftp") == 0)
+- || (strcmp(url_info.scheme, "gsiftp") == 0) )
+- {
+- result = globus_ftp_client_handle_cache_url_state(
+- &handle->ftp_handle_2,
+- url);
++ globus_url_parse(url, &url_info);
++ if ( (strcmp(url_info.scheme, "ftp") == 0)
++ || (strcmp(url_info.scheme, "gsiftp") == 0) )
++ {
++ result = globus_ftp_client_handle_cache_url_state(
++ &handle->ftp_handle_2,
++ url);
+ if (result == GLOBUS_SUCCESS)
+ {
+- result = globus_ftp_client_handle_cache_url_state(
++ result = globus_ftp_client_handle_cache_url_state(
+ &handle->ftp_handle,
+ url);
+- }
+- }
+- else
+- {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
++ }
++ }
++ else
++ {
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
+ "[%s]: BAD_URL_SCHEME, url: %s, only ftp or gsiftp can be cached",
+- myname,
+- url);
+- return globus_error_put(err);
+- }
++ myname,
++ url);
++ return globus_error_put(err);
++ }
+
+ globus_url_destroy(&url_info);
+
+ }
+ else
+ { /* handle == GLOBUS_NULL */
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, handle is NULL",
+- myname);
+- return globus_error_put(err);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, handle is NULL",
++ myname);
++ return globus_error_put(err);
+ }
+
+ return result;
+@@ -6124,7 +6124,7 @@ globus_gass_copy_cache_url_state(
+ } /* globus_gass_copy_cache_url_state() */
+
+ /**
+- * @brief Remove an FTP or GridFTP cached connection
++ * @brief Remove an FTP or GridFTP cached connection
+ * @ingroup globus_gass_transfer
+ * @details
+ * Explicitly remove a cached connection to an FTP or GSIFTP server.
+@@ -6151,42 +6151,42 @@ globus_gass_copy_flush_url_state(
+
+ if(handle != GLOBUS_NULL)
+ {
+- globus_url_parse(url, &url_info);
+- if ( (strcmp(url_info.scheme, "ftp") == 0)
+- || (strcmp(url_info.scheme, "gsiftp") == 0) )
+- {
+- result = globus_ftp_client_handle_flush_url_state(
+- &handle->ftp_handle_2,
+- url);
++ globus_url_parse(url, &url_info);
++ if ( (strcmp(url_info.scheme, "ftp") == 0)
++ || (strcmp(url_info.scheme, "gsiftp") == 0) )
++ {
++ result = globus_ftp_client_handle_flush_url_state(
++ &handle->ftp_handle_2,
++ url);
+ if (result == GLOBUS_SUCCESS)
+ {
+ result = globus_ftp_client_handle_flush_url_state(
+ &handle->ftp_handle,
+ url);
+ }
+- }
+- else
+- {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_URL_SCHEME, url: %s, only ftp or gsiftp can be cached",
+- myname,
+- url);
+- return globus_error_put(err);
+- }
++ }
++ else
++ {
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_URL_SCHEME, url: %s, only ftp or gsiftp can be cached",
++ myname,
++ url);
++ return globus_error_put(err);
++ }
+
+ globus_url_destroy(&url_info);
+
+ }
+ else
+ { /* handle == GLOBUS_NULL */
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, handle is NULL",
+- myname);
+- return globus_error_put(err);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, handle is NULL",
++ myname);
++ return globus_error_put(err);
+ }
+ return result;
+ } /* globus_gass_copy_flush_url_state() */
+@@ -6210,17 +6210,17 @@ globus_gass_copy_set_user_pointer(
+
+ if(handle)
+ {
+- handle->user_pointer = user_pointer;
+- return GLOBUS_SUCCESS;
++ handle->user_pointer = user_pointer;
++ return GLOBUS_SUCCESS;
+ }
+ else
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, handle is NULL",
+- myname);
+- return globus_error_put(err);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, handle is NULL",
++ myname);
++ return globus_error_put(err);
+ }
+ } /* globus_gass_copy_set_user_pointer() */
+
+@@ -6238,17 +6238,17 @@ globus_gass_copy_get_user_pointer(
+
+ if (handle)
+ {
+- *user_data = handle->user_pointer;
+- return GLOBUS_SUCCESS;
++ *user_data = handle->user_pointer;
++ return GLOBUS_SUCCESS;
+ }
+ else
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, handle is NULL",
+- myname);
+- return globus_error_put(err);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, handle is NULL",
++ myname);
++ return globus_error_put(err);
+ }
+ }
+
+@@ -6271,27 +6271,27 @@ globus_gass_copy_cancel(
+ static char * myname="globus_gass_copy_cancel";
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "starting globus_gass_copy_cancel()\n");
++ globus_libc_fprintf(stderr, "starting globus_gass_copy_cancel()\n");
+ #endif
+
+ if (handle->status == GLOBUS_GASS_COPY_STATUS_NONE)
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: No transfers have been initiated using this handle",
+- myname);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: No transfers have been initiated using this handle",
++ myname);
+
+ return globus_error_put(err);
+ }
+
+ if (handle->status == GLOBUS_GASS_COPY_STATUS_DONE)
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: The last transfer has already completed.",
+- myname);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: The last transfer has already completed.",
++ myname);
+
+ return globus_error_put(err);
+ }
+@@ -6303,33 +6303,33 @@ globus_gass_copy_cancel(
+ GLOBUS_NULL,
+ "[%s]: The last transfer has already ended.",
+ myname);
+-
++
+ return globus_error_put(err);
+ }
+
+ if (handle->state->cancel == GLOBUS_I_GASS_COPY_CANCEL_CALLED)
+ {
+- if(handle->status == GLOBUS_GASS_COPY_STATUS_CANCEL)
+- {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: The last transfer has already been canceled.",
+- myname);
++ if(handle->status == GLOBUS_GASS_COPY_STATUS_CANCEL)
++ {
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: The last transfer has already been canceled.",
++ myname);
+
+- return globus_error_put(err);
+- }
++ return globus_error_put(err);
++ }
+
+- if(handle->status == GLOBUS_GASS_COPY_STATUS_FAILURE)
+- {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: A failure has already been detected in the last transfer.",
+- myname);
++ if(handle->status == GLOBUS_GASS_COPY_STATUS_FAILURE)
++ {
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: A failure has already been detected in the last transfer.",
++ myname);
+
+- return globus_error_put(err);
+- }
++ return globus_error_put(err);
++ }
+ }
+
+ handle->state->cancel = GLOBUS_I_GASS_COPY_CANCEL_CALLED;
+@@ -6352,41 +6352,41 @@ globus_gass_copy_cancel(
+ }
+ else
+ {
+- source_cancel_info = (globus_i_gass_copy_cancel_t *)
+- globus_libc_malloc(sizeof(globus_i_gass_copy_cancel_t));
+- source_cancel_info->handle = handle;
+- source_cancel_info->canceling_source = GLOBUS_TRUE;
++ source_cancel_info = (globus_i_gass_copy_cancel_t *)
++ globus_libc_malloc(sizeof(globus_i_gass_copy_cancel_t));
++ source_cancel_info->handle = handle;
++ source_cancel_info->canceling_source = GLOBUS_TRUE;
+
+- dest_cancel_info = (globus_i_gass_copy_cancel_t *)
+- globus_libc_malloc(sizeof(globus_i_gass_copy_cancel_t));
+- dest_cancel_info->handle = handle;
+- dest_cancel_info->canceling_source = GLOBUS_FALSE;
++ dest_cancel_info = (globus_i_gass_copy_cancel_t *)
++ globus_libc_malloc(sizeof(globus_i_gass_copy_cancel_t));
++ dest_cancel_info->handle = handle;
++ dest_cancel_info->canceling_source = GLOBUS_FALSE;
+
+- if(handle->state->source.status != GLOBUS_I_GASS_COPY_TARGET_DONE &&
+- handle->state->source.status != GLOBUS_I_GASS_COPY_TARGET_INITIAL)
+- source_result = globus_l_gass_copy_target_cancel(source_cancel_info);
++ if(handle->state->source.status != GLOBUS_I_GASS_COPY_TARGET_DONE &&
++ handle->state->source.status != GLOBUS_I_GASS_COPY_TARGET_INITIAL)
++ source_result = globus_l_gass_copy_target_cancel(source_cancel_info);
+
+ if (handle->state->active)
+ {
+ if(handle->state->dest.status != GLOBUS_I_GASS_COPY_TARGET_DONE &&
+ handle->state->dest.status != GLOBUS_I_GASS_COPY_TARGET_INITIAL)
+ {
+- dest_result = globus_l_gass_copy_target_cancel(dest_cancel_info);
++ dest_result = globus_l_gass_copy_target_cancel(dest_cancel_info);
+ }
+ }
+
+- if(source_result != GLOBUS_SUCCESS)
+- {
+- result = source_result;
+- }
+- else if(dest_result != GLOBUS_SUCCESS)
+- {
+- result = dest_result;
+- }
+- else
+- {
+- result = GLOBUS_SUCCESS;
+- }
++ if(source_result != GLOBUS_SUCCESS)
++ {
++ result = source_result;
++ }
++ else if(dest_result != GLOBUS_SUCCESS)
++ {
++ result = dest_result;
++ }
++ else
++ {
++ result = GLOBUS_SUCCESS;
++ }
+ /*
+ globus_libc_free(dest_cancel_info);
+ globus_libc_free(source_cancel_info);
+@@ -6394,7 +6394,7 @@ globus_gass_copy_cancel(
+ }
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "leaving globus_gass_copy_cancel()\n");
++ globus_libc_fprintf(stderr, "leaving globus_gass_copy_cancel()\n");
+ #endif
+
+ return result;
+@@ -6430,16 +6430,16 @@ globus_l_gass_copy_target_cancel(
+ if (cancel_info->canceling_source)
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "_target_cancel(): cancelling source\n");
++ globus_libc_fprintf(stderr, "_target_cancel(): cancelling source\n");
+ #endif
+ target = &(cancel_info->handle->state->source);
+ }
+ else
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "_target_cancel(): cancelling dest\n");
++ globus_libc_fprintf(stderr, "_target_cancel(): cancelling dest\n");
+ #endif
+- target = &(cancel_info->handle->state->dest);
++ target = &(cancel_info->handle->state->dest);
+ }
+
+ switch (target->mode)
+@@ -6458,8 +6458,8 @@ globus_l_gass_copy_target_cancel(
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ globus_libc_fprintf(stderr,
+ "target_cancel(): _ftp_client_abort() returned an error\n");
+- globus_libc_fprintf(stderr, "target_cancel(): error = %s\n",
+- globus_object_printable_to_string(globus_error_peek(result)));
++ globus_libc_fprintf(stderr, "target_cancel(): error = %s\n",
++ globus_object_printable_to_string(globus_error_peek(result)));
+ globus_libc_fprintf(stderr, " resetting to SUCCESS\n");
+ #endif
+ result = GLOBUS_SUCCESS;
+@@ -6468,42 +6468,42 @@ globus_l_gass_copy_target_cancel(
+ break;
+ case GLOBUS_GASS_COPY_URL_MODE_GASS:
+
+- req_status =
+- globus_gass_transfer_request_get_status(target->data.gass.request);
++ req_status =
++ globus_gass_transfer_request_get_status(target->data.gass.request);
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "target_cancel: gass_request_status = %d\n", req_status);
+ #endif
+- if(req_status != GLOBUS_GASS_TRANSFER_REQUEST_FAILED &&
++ if(req_status != GLOBUS_GASS_TRANSFER_REQUEST_FAILED &&
+ req_status != GLOBUS_GASS_TRANSFER_REQUEST_DENIED)
+ {
+- rc = globus_gass_transfer_fail(
++ rc = globus_gass_transfer_fail(
+ target->data.gass.request,
+ globus_l_gass_copy_gass_transfer_cancel_callback,
+ cancel_info);
+- if (rc != GLOBUS_SUCCESS)
+- {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: %s globus_gass_transfer_request_fail returned an error code of: %d",
+- myname,
+- target->url,
+- rc);
+- globus_i_gass_copy_set_error(cancel_info->handle, err);
+-
+- result = globus_error_put(err);
+- }
+- else
+- {
+- globus_l_gass_copy_generic_cancel(cancel_info);
+- }
+- }
+- else
+- {
+- globus_gass_transfer_request_destroy(target->data.gass.request);
+- globus_l_gass_copy_generic_cancel(cancel_info);
+- }
++ if (rc != GLOBUS_SUCCESS)
++ {
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: %s globus_gass_transfer_request_fail returned an error code of: %d",
++ myname,
++ target->url,
++ rc);
++ globus_i_gass_copy_set_error(cancel_info->handle, err);
++
++ result = globus_error_put(err);
++ }
++ else
++ {
++ globus_l_gass_copy_generic_cancel(cancel_info);
++ }
++ }
++ else
++ {
++ globus_gass_transfer_request_destroy(target->data.gass.request);
++ globus_l_gass_copy_generic_cancel(cancel_info);
++ }
+
+ break;
+ case GLOBUS_GASS_COPY_URL_MODE_IO:
+@@ -6514,11 +6514,11 @@ globus_l_gass_copy_target_cancel(
+ cancel_info);
+ break;
+ default:
+- break;
++ break;
+ }
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ if(result != GLOBUS_SUCCESS)
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "[%s]: error trying to cancel one of the targets\n",
+ myname);
+ #endif
+@@ -6533,10 +6533,10 @@ globus_l_gass_copy_gass_transfer_cancel_callback(
+ globus_gass_transfer_request_status_t status;
+ globus_object_t * err;
+ globus_i_gass_copy_cancel_t * cancel_info
+- = (globus_i_gass_copy_cancel_t *) callback_arg;
++ = (globus_i_gass_copy_cancel_t *) callback_arg;
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ "starting _gass_transfer_cancel_callback()\n");
+ #endif
+
+@@ -6566,7 +6566,7 @@ globus_l_gass_copy_io_cancel_callback(
+ = (globus_i_gass_copy_cancel_t *) callback_arg;
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "starting _io_cancel_callback()\n");
++ globus_libc_fprintf(stderr, "starting _io_cancel_callback()\n");
+ #endif
+
+ /* what to do if we get an error ??
+@@ -6588,18 +6588,18 @@ globus_l_gass_copy_generic_cancel(
+ globus_gass_copy_callback_t cancel_callback;
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "starting _gass_copy_generic_cancel()\n");
++ globus_libc_fprintf(stderr, "starting _gass_copy_generic_cancel()\n");
+ #endif
+ globus_mutex_lock(&(state->mutex));
+-
++
+ if (cancel_info->canceling_source)
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "_generic_cancel() source\n");
++ globus_libc_fprintf(stderr, "_generic_cancel() source\n");
+ #endif
+- handle->state->source.status = GLOBUS_I_GASS_COPY_TARGET_DONE;
++ handle->state->source.status = GLOBUS_I_GASS_COPY_TARGET_DONE;
+ if (handle->state->dest.status == GLOBUS_I_GASS_COPY_TARGET_DONE ||
+- handle->state->dest.status == GLOBUS_I_GASS_COPY_TARGET_INITIAL)
++ handle->state->dest.status == GLOBUS_I_GASS_COPY_TARGET_INITIAL)
+ {
+ all_done = GLOBUS_TRUE;
+ }
+@@ -6607,11 +6607,11 @@ globus_l_gass_copy_generic_cancel(
+ else
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "_generic_cancel() dest\n");
++ globus_libc_fprintf(stderr, "_generic_cancel() dest\n");
+ #endif
+- handle->state->dest.status = GLOBUS_I_GASS_COPY_TARGET_DONE;
++ handle->state->dest.status = GLOBUS_I_GASS_COPY_TARGET_DONE;
+ if (handle->state->source.status == GLOBUS_I_GASS_COPY_TARGET_DONE ||
+- handle->state->source.status == GLOBUS_I_GASS_COPY_TARGET_INITIAL)
++ handle->state->source.status == GLOBUS_I_GASS_COPY_TARGET_INITIAL)
+ {
+ all_done = GLOBUS_TRUE;
+ }
+@@ -6621,16 +6621,16 @@ globus_l_gass_copy_generic_cancel(
+ globus_l_gass_copy_perf_cancel_local_callback(handle->performance);
+ }
+ }
+-
++
+ if (all_done &&
+ ((handle->state->dest.mode == GLOBUS_GASS_COPY_URL_MODE_FTP &&
+ !handle->state->dest.data.ftp.completed) ||
+- (handle->state->source.mode == GLOBUS_GASS_COPY_URL_MODE_FTP &&
++ (handle->state->source.mode == GLOBUS_GASS_COPY_URL_MODE_FTP &&
+ !handle->state->source.data.ftp.completed)))
+ {
+ all_done = GLOBUS_FALSE;
+ }
+-
++
+ if(all_done)
+ {
+ user_callback = handle->user_callback;
+@@ -6644,64 +6644,64 @@ globus_l_gass_copy_generic_cancel(
+ globus_gass_copy_cancel(handle, NULL, NULL);
+ }
+ globus_mutex_unlock(&(state->mutex));
+-
++
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+ globus_libc_fprintf(stderr, "_generic_cancel() before all done\n");
+ #endif
+
+ if (all_done)
+ {
+- globus_l_gass_copy_state_free_targets(state);
++ globus_l_gass_copy_state_free_targets(state);
+
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, "globus_l_gass_copy_generic_cancel():\n");
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr, "globus_l_gass_copy_generic_cancel():\n");
++ globus_libc_fprintf(stderr,
+ " ...check to call user/cancel callbacks.\n");
+ #endif
+
+- /* set the final status of the transfer */
+- switch(handle->status)
+- {
+- case GLOBUS_GASS_COPY_STATUS_FAILURE:
+- handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
+- break;
+- case GLOBUS_GASS_COPY_STATUS_CANCEL:
+- handle->status = GLOBUS_GASS_COPY_STATUS_DONE_CANCELLED;
+- break;
+- default:
+- break;
+- }
++ /* set the final status of the transfer */
++ switch(handle->status)
++ {
++ case GLOBUS_GASS_COPY_STATUS_FAILURE:
++ handle->status = GLOBUS_GASS_COPY_STATUS_DONE_FAILURE;
++ break;
++ case GLOBUS_GASS_COPY_STATUS_CANCEL:
++ handle->status = GLOBUS_GASS_COPY_STATUS_DONE_CANCELLED;
++ break;
++ default:
++ break;
++ }
+
+ err = handle->err;
+- handle->err = GLOBUS_NULL;
+-
+- if(cancel_callback != GLOBUS_NULL)
++ handle->err = GLOBUS_NULL;
++
++ if(cancel_callback != GLOBUS_NULL)
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ " ...calling user cancel callback.\n");
+ #endif
+- cancel_callback(
+- handle->cancel_callback_arg,
+- handle,
+- err);
++ cancel_callback(
++ handle->cancel_callback_arg,
++ handle,
++ err);
+ }
+
+- if(user_callback != GLOBUS_NULL)
++ if(user_callback != GLOBUS_NULL)
+ {
+ #ifdef GLOBUS_I_GASS_COPY_DEBUG
+- globus_libc_fprintf(stderr, " ...calling user callback.\n");
++ globus_libc_fprintf(stderr, " ...calling user callback.\n");
+ #endif
+- user_callback(
+- handle->callback_arg,
+- handle,
+- err);
++ user_callback(
++ handle->callback_arg,
++ handle,
++ err);
+ }
+- /* if an error object was created, free it */
++ /* if an error object was created, free it */
+
+ if (err)
+ {
+- globus_object_free(err);
++ globus_object_free(err);
+ }
+
+ } /* if (all_done) */
+@@ -6824,21 +6824,21 @@ globus_i_gass_copy_attr_duplicate(globus_gass_copy_attr_t ** attr)
+
+ if ( (attr == GLOBUS_NULL) || (*attr == GLOBUS_NULL) )
+ {
+- err = globus_error_construct_string(
+- GLOBUS_GASS_COPY_MODULE,
+- GLOBUS_NULL,
+- "[%s]: BAD_PARAMETER, attr==GLOBUS_NULL, or *attr==GLOBUS_NULL",
+- myname);
++ err = globus_error_construct_string(
++ GLOBUS_GASS_COPY_MODULE,
++ GLOBUS_NULL,
++ "[%s]: BAD_PARAMETER, attr==GLOBUS_NULL, or *attr==GLOBUS_NULL",
++ myname);
+
+- return globus_error_put(err);
++ return globus_error_put(err);
+ }
+
+ new_attr = (globus_gass_copy_attr_t *)
+- globus_libc_malloc(sizeof(globus_gass_copy_attr_t));
++ globus_libc_malloc(sizeof(globus_gass_copy_attr_t));
+ globus_gass_copy_attr_init(new_attr);
+
+ new_ftp_attr = (globus_ftp_client_operationattr_t *)
+- globus_libc_malloc(sizeof(globus_ftp_client_operationattr_t));
++ globus_libc_malloc(sizeof(globus_ftp_client_operationattr_t));
+
+ globus_ftp_cient_attr_copy(new_ftp_attr, *(attr)->ftp_attr);
+ /* new_attr = *attr; */
+diff --git a/gass/copy/source/globus_url_copy.c b/gass/copy/source/globus_url_copy.c
+index c40d459b6..9ad992909 100644
+--- a/gass/copy/source/globus_url_copy.c
++++ b/gass/copy/source/globus_url_copy.c
+@@ -121,7 +121,7 @@ int guc_gencert(gss_buffer_desc * buf)
+ EVP_PKEY *pkey = NULL;
+ BIO *bio;
+ char *ptr;
+-
++
+ guc_mkcert(&x509, &pkey, 2048, 0, 100);
+
+ bio = BIO_new(BIO_s_mem());
+@@ -132,17 +132,17 @@ int guc_gencert(gss_buffer_desc * buf)
+
+ X509_free(x509);
+ EVP_PKEY_free(pkey);
+-
++
+ buf->length = BIO_get_mem_data(bio, &ptr);
+ buf->value = strdup(ptr);
+ BIO_free(bio);
+
+ return 0;
+ }
+-
+
+-
+-
++
++
++
+ #define GUC_URL_ENC_CHAR "#;:=+ ,"
+
+ /******************************************************************************
+@@ -159,7 +159,7 @@ typedef struct
+ volatile globus_bool_t done;
+ } globus_l_guc_monitor_t;
+
+-typedef struct
++typedef struct
+ {
+ globus_gass_copy_glob_entry_t type;
+ char * url;
+@@ -169,7 +169,7 @@ typedef struct
+ char * checksum;
+ } globus_l_guc_url_info_t;
+
+-typedef struct
++typedef struct
+ {
+ char * src_url;
+ char * dst_url;
+@@ -184,14 +184,14 @@ typedef struct globus_l_guc_handle_s
+ globus_gass_copy_handle_t cksm_gass_copy_handle;
+
+ globus_gass_copy_attr_t source_gass_copy_attr;
+- globus_gass_copy_attr_t dest_gass_copy_attr;
+-
++ globus_gass_copy_attr_t dest_gass_copy_attr;
++
+ globus_ftp_client_operationattr_t source_ftp_attr;
+ globus_ftp_client_operationattr_t dest_ftp_attr;
+
+ globus_gass_transfer_requestattr_t source_gass_attr;
+ globus_gass_transfer_requestattr_t dest_gass_attr;
+-
++
+ void * guc_info;
+ void * current_transfer;
+ globus_l_guc_src_dst_pair_t * pipeline_free_pair;
+@@ -199,7 +199,7 @@ typedef struct globus_l_guc_handle_s
+ int id;
+ } globus_l_guc_handle_t;
+
+-typedef struct
++typedef struct
+ {
+ globus_fifo_t user_url_list;
+ globus_fifo_t expanded_url_list;
+@@ -234,11 +234,11 @@ typedef struct
+ int restart_timeout;
+ int stall_timeout;
+ globus_size_t stripe_bs;
+- globus_bool_t striped;
+- globus_bool_t rfc1738;
+- globus_bool_t create_dest;
+- globus_off_t partial_offset;
+- globus_off_t partial_length;
++ globus_bool_t striped;
++ globus_bool_t rfc1738;
++ globus_bool_t create_dest;
++ globus_off_t partial_offset;
++ globus_off_t partial_length;
+ globus_bool_t list_uses_data_mode;
+ globus_bool_t udt;
+ globus_bool_t nl_bottleneck;
+@@ -265,7 +265,7 @@ typedef struct
+ char * dst_authz_assert;
+ globus_bool_t cache_src_authz_assert;
+ globus_bool_t cache_dst_authz_assert;
+-
++
+ gss_cred_id_t src_cred;
+ gss_cred_id_t dst_cred;
+ gss_cred_id_t data_cred;
+@@ -283,7 +283,7 @@ typedef struct
+ globus_l_guc_handle_t ** handles;
+ globus_bool_t comp_checksum;
+ char * checksum_algo;
+-
++
+ } globus_l_guc_info_t;
+
+ typedef struct globus_l_guc_transfer_s
+@@ -310,7 +310,7 @@ enum
+ GLOBUS_L_GUC_DATE = 2,
+ GLOBUS_L_GUC_CKSM = 3
+ } globus_l_guc_sync_level_t;
+-
++
+
+ static globus_hashtable_t guc_l_alias_table;
+ static globus_bool_t guc_l_aliases = GLOBUS_FALSE;
+@@ -323,7 +323,7 @@ static gss_buffer_desc auto_data = GSS_C_EMPTY_BUFFER;
+ Module specific prototypes
+ *****************************************************************************/
+
+-static
++static
+ void
+ globus_l_url_copy_monitor_callback(void * callback_arg,
+ globus_gass_copy_handle_t * handle,
+@@ -351,13 +351,13 @@ globus_l_guc_dest_entry_cb(
+ const char * url,
+ const globus_gass_copy_glob_stat_t * info_stat,
+ void * user_arg);
+-
++
+ static
+ globus_result_t
+ globus_l_guc_file_to_string(
+ char * filename,
+ char ** str);
+-
++
+ static
+ int
+ globus_l_guc_parse_arguments(
+@@ -390,7 +390,7 @@ static
+ int
+ globus_l_guc_init_gass_copy_handle(
+ globus_gass_copy_handle_t * gass_copy_handle,
+- globus_l_guc_info_t * guc_info,
++ globus_l_guc_info_t * guc_info,
+ int id);
+
+ static
+@@ -414,18 +414,18 @@ static
+ void
+ globus_l_guc_info_destroy(
+ globus_l_guc_info_t * guc_info);
+-
++
+ static
+ void
+ globus_l_guc_destroy_url_list(
+ globus_fifo_t * url_list);
+
+-static
++static
+ void
+ globus_l_guc_hashtable_element_free(
+ void * datum);
+
+-static
++static
+ void
+ globus_l_guc_url_info_free(
+ void * datum);
+@@ -496,23 +496,23 @@ const char * long_usage =
+ " Convert the file to/from ASCII format to/from local file format\n"
+ " -b | -binary\n"
+ " Do not apply any conversion to the files. *default*\n"
+-" -f <filename>\n"
++" -f <filename>\n"
+ " Read a list of url pairs from filename. Each line should contain\n"
+ " <sourceURL> <destURL>\n"
+ " Enclose URLs with spaces in double quotes (\").\n"
+ " Blank lines and lines beginning with # will be ignored.\n"
+-" -cd | -create-dest\n"
++" -cd | -create-dest\n"
+ " Create destination directory if needed\n"
+-" -r | -recurse\n"
++" -r | -recurse\n"
+ " Copy files in subdirectories\n"
+-
+-" -fast\n"
++
++" -fast\n"
+ " Recommended when using GridFTP servers. Use MODE E for all data\n"
+ " transfers, including reusing data channels between list and transfer\n"
+ " operations.\n"
+ " -t <transfer time in seconds>\n"
+ " Run the transfer for this number of seconds and then end.\n"
+-" Useful for performance testing or forced restart loops.\n"
++" Useful for performance testing or forced restart loops.\n"
+ " -q | -quiet \n"
+ " Suppress all output for successful operation\n"
+ " -v | -verbose \n"
+@@ -533,7 +533,7 @@ const char * long_usage =
+ " The interval in seconds to wait after a failure before retrying\n"
+ " the transfer. Use 0 for an exponential back off. Default is 0.\n"
+ " -rst-timeout <seconds>\n"
+-" Maximum time after a failure to keep retrying. Use 0 for no\n"
++" Maximum time after a failure to keep retrying. Use 0 for no\n"
+ " timeout. Default is 0.\n"
+ " -stall-timeout | -st <seconds>\n"
+ " How long before canceling/restarting a transfer with no data\n"
+@@ -555,7 +555,7 @@ const char * long_usage =
+ " user's starting directory on the server. By default, all paths are\n"
+ " root-relative. When this flag is set, the path portion of the ftp url\n"
+ " must start with %%2F if it designates a root-relative path.\n"
+-
++
+ " -s <subject> | -subject <subject>\n"
+ " Use this subject to match with both the source and dest servers\n"
+ " -ss <subject> | -source-subject <subject>\n"
+@@ -570,7 +570,7 @@ const char * long_usage =
+ " underlying transfer methods\n"
+ " -p <parallelism> | -parallel <parallelism>\n"
+ " specify the number of parallel data connections should be used.\n"
+-
++
+ " -notpt | -no-third-party-transfers\n"
+ " turn third-party transfers off (on by default)\n"
+ " -nodcau | -no-data-channel-authentication\n"
+@@ -579,7 +579,7 @@ const char * long_usage =
+ " set data channel protection mode to SAFE\n"
+ " -dcpriv | -data-channel-private\n"
+ " set data channel protection mode to PRIVATE\n"
+-
++
+ " -off | -partial-offset\n"
+ " offset for partial ftp file transfers, defaults to 0\n"
+ " -len | -partial-length\n"
+@@ -596,7 +596,7 @@ const char * long_usage =
+ " -ipv6\n"
+ " use ipv6 when available (EXPERIMENTAL)\n"
+ " -udt\n"
+-" Use UDT, a reliable udp based transport protocol, for data transfers\n"
++" Use UDT, a reliable udp based transport protocol, for data transfers\n"
+ " -no-g2 | -nogridftp2\n"
+ " disable use of GridFTP v2 protocol enhancements\n"
+ " -dp | -delayed-pasv\n"
+@@ -621,13 +621,13 @@ const char * long_usage =
+ " in a GridFTP transfer\n"
+ " -aa | -authz-assert <authorization assertion file>\n"
+ " Use the assertions in this file to authorize the access with both\n"
+-" source and dest servers\n"
++" source and dest servers\n"
+ " -saa | -src-authz-assert <authorization assertion file>\n"
+ " Use the assertions in this file to authorize the access with source\n"
+-" server\n"
++" server\n"
+ " -daa | -dst-authz-assert <authorization assertion file>\n"
+ " Use the assertions in this file to authorize the access with dest\n"
+-" server\n"
++" server\n"
+ " -cache-aa | -cache-authz-assert\n"
+ " Cache the authz assertion for subsequent transfers\n"
+ " -cache-saa | -cache-src-authz-assert\n"
+@@ -680,7 +680,7 @@ const char * long_usage =
+ " Set the credentials to use for source, destination, \n"
+ " or both ftp connections.\n"
+ " -data-cred <path to credentials or proxy file>\n"
+-" Set the credential to use for data connection. A value of 'auto' will\n"
++" Set the credential to use for data connection. A value of 'auto' will\n"
+ " generate a temporary self-signed credential. This may be used with\n"
+ " any authentication method, but the server must support the DCSC command.\n"
+ " -af <filename> | -alias-file <filename>\n"
+@@ -747,7 +747,7 @@ this feature has not yet been implemented.
+ exit(1); \
+ }
+
+-static
++static
+ int
+ test_integer( char * value,
+ void * ignored,
+@@ -759,11 +759,11 @@ test_integer( char * value,
+ return res;
+ }
+
+-enum
+-{
+- arg_a = 1,
+- arg_b,
+- arg_c,
++enum
++{
++ arg_a = 1,
++ arg_b,
++ arg_c,
+ arg_ext,
+ arg_plugin,
+ arg_mc,
+@@ -775,25 +775,25 @@ enum
+ arg_src_modargs,
+ arg_dst_modname,
+ arg_dst_modargs,
+- arg_s,
+- arg_t,
+- arg_p,
+- arg_f,
++ arg_s,
++ arg_t,
++ arg_p,
++ arg_f,
+ arg_vb,
+- arg_q,
+- arg_v,
+- arg_debugftp,
++ arg_q,
++ arg_v,
++ arg_debugftp,
+ arg_restart,
+- arg_rst_retries,
+- arg_rst_interval,
+- arg_rst_timeout,
++ arg_rst_retries,
++ arg_rst_interval,
++ arg_rst_timeout,
+ arg_stall_timeout,
+- arg_ss,
+- arg_ds,
++ arg_ss,
++ arg_ds,
+ arg_tcp_bs,
+- arg_bs,
++ arg_bs,
+ arg_conc,
+- arg_notpt,
++ arg_notpt,
+ arg_nodcau,
+ arg_data_safe,
+ arg_data_private,
+@@ -854,7 +854,7 @@ static char * listname(id)[] = { alias1, alias2, GLOBUS_NULL }
+ #define flagdef(id,alias1,alias2) \
+ namedef(id,alias1,alias2); \
+ static globus_args_option_descriptor_t defname(id) = { id, listname(id), 0, \
+- GLOBUS_NULL, GLOBUS_NULL }
++ GLOBUS_NULL, GLOBUS_NULL }
+ #define funcname(x) x##_predicate_test
+ #define paramsname(x) x##_predicate_params
+
+@@ -1001,19 +1001,19 @@ static globus_args_option_descriptor_t args_options[arg_num];
+ setupopt(arg_nodcau); \
+ setupopt(arg_data_safe); \
+ setupopt(arg_data_private); \
+- setupopt(arg_recurse); \
+- setupopt(arg_partial_offset); \
+- setupopt(arg_partial_length); \
+- setupopt(arg_rfc1738); \
++ setupopt(arg_recurse); \
++ setupopt(arg_partial_offset); \
++ setupopt(arg_partial_length); \
++ setupopt(arg_rfc1738); \
+ setupopt(arg_create_dest); \
+- setupopt(arg_fast); \
+- setupopt(arg_list); \
++ setupopt(arg_fast); \
++ setupopt(arg_list); \
+ setupopt(arg_udt); \
+ setupopt(arg_nl_bottleneck); \
+ setupopt(arg_nl_interval); \
+- setupopt(arg_ipv6); \
++ setupopt(arg_ipv6); \
+ setupopt(arg_gridftp2_off); \
+- setupopt(arg_gridftp2); \
++ setupopt(arg_gridftp2); \
+ setupopt(arg_src_pipe_str); \
+ setupopt(arg_dst_pipe_str); \
+ setupopt(arg_pipe_str); \
+@@ -1037,13 +1037,13 @@ static globus_args_option_descriptor_t args_options[arg_num];
+ setupopt(arg_dump_only); \
+ setupopt(arg_preserve); \
+ setupopt(arg_perms); \
+- setupopt(arg_allo); \
+- setupopt(arg_noallo); \
+- setupopt(arg_cred); \
+- setupopt(arg_src_cred); \
+- setupopt(arg_dst_cred); \
+- setupopt(arg_data_cred); \
+- setupopt(arg_stripe_bs); \
++ setupopt(arg_allo); \
++ setupopt(arg_noallo); \
++ setupopt(arg_cred); \
++ setupopt(arg_src_cred); \
++ setupopt(arg_dst_cred); \
++ setupopt(arg_data_cred); \
++ setupopt(arg_stripe_bs); \
+ setupopt(arg_striped); \
+ setupopt(arg_checksum); \
+ setupopt(arg_checksum_algo);
+@@ -1116,7 +1116,7 @@ globus_l_guc_glob_list_cb(
+ }
+ globus_url_destroy(&url_info);
+ }
+-
++
+ static
+ void
+ globus_l_guc_ext_interrupt_handler(
+@@ -1285,7 +1285,7 @@ globus_l_guc_ext(
+ error:
+
+ fprintf(stderr, "%s\n", globus_error_print_friendly(err));
+-
++
+ return 1;
+ }
+ /* END CRFT STUFF */
+@@ -1338,7 +1338,7 @@ globus_l_guc_url_replace_host(
+ char * ptr;
+ char * tmp;
+ char * end;
+-
++
+ tmp = globus_libc_strdup(in_url);
+ ptr = strstr(tmp, "ftp://");
+ if(ptr == NULL)
+@@ -1353,15 +1353,15 @@ globus_l_guc_url_replace_host(
+ {
+ goto skip;
+ }
+-
++
+ out = globus_common_create_string("%s/%s%s", tmp, host, end);
+ globus_free(tmp);
+-
++
+ return out;
+-
++
+ skip:
+ globus_free(tmp);
+- return NULL;
++ return NULL;
+ }
+
+ static
+@@ -1375,20 +1375,20 @@ globus_l_guc_dequeue_pair(
+ globus_l_guc_alias_t * dst_alias = NULL;
+ char * new_src;
+ char * new_dst;
+-
++
+ pair = (globus_l_guc_src_dst_pair_t *) globus_fifo_dequeue(q);
+-
++
+ if(guc_l_aliases)
+ {
+ /*
+- src_alias = (globus_l_guc_alias_t *)
++ src_alias = (globus_l_guc_alias_t *)
+ globus_hashtable_lookup(&guc_l_alias_table, (void *) "source");
+- dst_alias = (globus_l_guc_alias_t *)
++ dst_alias = (globus_l_guc_alias_t *)
+ globus_hashtable_lookup(&guc_l_alias_table, (void *) "destination");
+ */
+ src_alias = guc_l_src_alias_ent;
+ dst_alias = guc_l_dst_alias_ent;
+-
++
+ if(src_alias && src_alias->entries > 0)
+ {
+ new_src = globus_l_guc_url_replace_host(
+@@ -1399,7 +1399,7 @@ globus_l_guc_dequeue_pair(
+ pair->src_url = new_src;
+ }
+ }
+-
++
+ if(dst_alias && dst_alias->entries > 0)
+ {
+ new_dst = globus_l_guc_url_replace_host(
+@@ -1411,7 +1411,7 @@ globus_l_guc_dequeue_pair(
+ }
+ }
+ }
+-
++
+ if(!g_ssh_print_connect && !g_all_quiet &&
+ strncmp(pair->src_url, "sshftp://", 9) == 0 &&
+ strncmp(pair->dst_url, "sshftp://", 9) == 0)
+@@ -1443,13 +1443,13 @@ globus_l_guc_print_url_line(
+ char * pre;
+ char * statstr = NULL;
+ char * tmpstr = NULL;
+-
++
+ pre = prefix ? prefix : "";
+-
++
+ statstr = globus_libc_strdup("");
+
+ if(info)
+- {
++ {
+ if(info->size >= 0 && info->type == GLOBUS_GASS_COPY_GLOB_ENTRY_FILE)
+ {
+ tmpstr = globus_common_create_string(
+@@ -1479,31 +1479,31 @@ globus_l_guc_print_url_line(
+ statstr = tmpstr;
+ }
+ }
+-
++
+ if(length > -1)
+ {
+ rc = fprintf(
+- fp,
++ fp,
+ "%s\"%s\" \"%s\" %"GLOBUS_OFF_T_FORMAT",%"GLOBUS_OFF_T_FORMAT" %s\n",
+- pre, src_url, dst_url, offset, length, statstr);
++ pre, src_url, dst_url, offset, length, statstr);
+ }
+ else if(offset > -1)
+- {
++ {
+ rc = fprintf(
+- fp,
+- "%s\"%s\" \"%s\" %"GLOBUS_OFF_T_FORMAT" %s\n",
++ fp,
++ "%s\"%s\" \"%s\" %"GLOBUS_OFF_T_FORMAT" %s\n",
+ pre, src_url, dst_url, offset, statstr);
+ }
+ else if(tmpstr)
+ {
+- rc = fprintf(fp, "%s\"%s\" \"%s\" 0,-1 %s\n",
++ rc = fprintf(fp, "%s\"%s\" \"%s\" 0,-1 %s\n",
+ pre, src_url, dst_url, statstr);
+- }
++ }
+ else
+ {
+- rc = fprintf(fp, "%s\"%s\" \"%s\"\n",
++ rc = fprintf(fp, "%s\"%s\" \"%s\"\n",
+ pre, src_url, dst_url);
+- }
++ }
+
+ globus_free(statstr);
+ return rc;
+@@ -1527,7 +1527,7 @@ globus_l_guc_dump_urls(
+ globus_l_guc_transfer_t * transfer_info;
+
+ guc_info = (globus_l_guc_info_t *) user_arg;
+-
++
+ globus_mutex_lock(&g_monitor.mutex);
+
+ if(guc_info->dumpfile)
+@@ -1550,10 +1550,10 @@ globus_l_guc_dump_urls(
+ unlink(dumptmp);
+ return;
+ }
+-
++
+ for(i = 0; i < guc_info->conc; i++)
+ {
+- transfer_info = (globus_l_guc_transfer_t *)
++ transfer_info = (globus_l_guc_transfer_t *)
+ guc_info->handles[i]->current_transfer;
+ if(transfer_info)
+ {
+@@ -1563,7 +1563,7 @@ globus_l_guc_dump_urls(
+ globus_off_t end_offset = 0;
+ globus_off_t off = transfer_info->urls->offset;
+ globus_off_t len = transfer_info->urls->length;
+-
++
+ globus_gass_copy_get_ftp_handle(
+ &guc_info->handles[i]->gass_copy_handle, &ftp_handle);
+ globus_ftp_client_handle_get_restart_marker(
+@@ -1571,15 +1571,15 @@ globus_l_guc_dump_urls(
+ globus_ftp_client_restart_marker_get_first_block(
+ &marker, &start_offset, &end_offset);
+ globus_ftp_client_restart_marker_destroy(&marker);
+-
++
+ if(transfer_info->urls->length > -1)
+ {
+ off = transfer_info->urls->offset + end_offset;
+- len = transfer_info->urls->length - (end_offset - start_offset);
++ len = transfer_info->urls->length - (end_offset - start_offset);
+ }
+ else if(end_offset > 0 || transfer_info->urls->offset > -1)
+- {
+- off = end_offset > transfer_info->urls->offset ?
++ {
++ off = end_offset > transfer_info->urls->offset ?
+ end_offset : transfer_info->urls->offset;
+ }
+
+@@ -1591,18 +1591,18 @@ globus_l_guc_dump_urls(
+ len,
+ transfer_info->urls->src_info,
+ NULL);
+- }
++ }
+ }
+-
++
+ if(!globus_fifo_empty(&guc_info->expanded_url_list))
+ {
+ tmp_fifo = globus_fifo_copy(&guc_info->expanded_url_list);
+-
++
+ while(!globus_fifo_empty(tmp_fifo))
+ {
+- url_pair =
++ url_pair =
+ (globus_l_guc_src_dst_pair_t *) globus_fifo_dequeue(tmp_fifo);
+-
++
+ globus_l_guc_print_url_line(
+ dumpfile,
+ url_pair->src_url,
+@@ -1614,16 +1614,16 @@ globus_l_guc_dump_urls(
+ }
+ globus_fifo_destroy(tmp_fifo);
+ }
+-
++
+ if(!globus_fifo_empty(&guc_info->user_url_list))
+ {
+ tmp_fifo = globus_fifo_copy(&guc_info->user_url_list);
+-
++
+ while(!globus_fifo_empty(tmp_fifo))
+ {
+- url_pair =
++ url_pair =
+ (globus_l_guc_src_dst_pair_t *) globus_fifo_dequeue(tmp_fifo);
+-
++
+ globus_l_guc_print_url_line(
+ dumpfile,
+ url_pair->src_url,
+@@ -1635,7 +1635,7 @@ globus_l_guc_dump_urls(
+ }
+ globus_fifo_destroy(tmp_fifo);
+ }
+-
++
+ fclose(dumpfile);
+ if(rename(dumptmp, guc_info->dumpfile) < 0)
+ {
+@@ -1643,7 +1643,7 @@ globus_l_guc_dump_urls(
+ }
+ globus_free(dumptmp);
+ }
+-
++
+ if(guc_info->dump_only_file && guc_info->dump_only_fp == NULL)
+ {
+ dumptmp = globus_common_create_string("%s.XXXXXX", guc_info->dump_only_file);
+@@ -1663,20 +1663,20 @@ globus_l_guc_dump_urls(
+ close(dumpfd);
+ unlink(dumptmp);
+ return;
+- }
+-
++ }
++
+ if(!globus_fifo_empty(&guc_info->dump_url_list))
+ {
+ tmp_fifo = globus_fifo_copy(&guc_info->dump_url_list);
+-
++
+ while(!globus_fifo_empty(tmp_fifo))
+ {
+ char * is_dir;
+-
+- url_pair =
++
++ url_pair =
+ (globus_l_guc_src_dst_pair_t *) globus_fifo_dequeue(tmp_fifo);
+-
+- is_dir =
++
++ is_dir =
+ url_pair->src_url[strlen(url_pair->src_url) - 1] == '/' ?
+ "#" : NULL;
+
+@@ -1698,8 +1698,8 @@ globus_l_guc_dump_urls(
+ unlink(dumptmp);
+ }
+ globus_free(dumptmp);
+-
+- }
++
++ }
+
+ globus_mutex_unlock(&g_monitor.mutex);
+
+@@ -1718,14 +1718,14 @@ globus_l_guc_transfer_kickout(
+ globus_bool_t expanded = GLOBUS_FALSE;
+ globus_bool_t expand = GLOBUS_FALSE;
+ globus_object_t * err = NULL;
+-
++
+ transfer_info = (globus_l_guc_transfer_t * ) user_arg;
+
+ globus_mutex_lock(&g_monitor.mutex);
+- {
++ {
+ if(!g_monitor.done && !transfer_info->guc_info->cancelled &&
+ !globus_fifo_empty(&transfer_info->guc_info->expanded_url_list))
+- {
++ {
+ globus_l_guc_url_pair_free(transfer_info->urls);
+ transfer_info->urls = globus_l_guc_dequeue_pair(
+ &transfer_info->guc_info->expanded_url_list,
+@@ -1737,19 +1737,19 @@ globus_l_guc_transfer_kickout(
+ }
+ else if(!g_monitor.done && !transfer_info->guc_info->cancelled &&
+ !globus_fifo_empty(&transfer_info->guc_info->user_url_list))
+- {
++ {
+ globus_l_guc_url_pair_free(transfer_info->urls);
+ transfer_info->urls = globus_l_guc_dequeue_pair(
+ &transfer_info->guc_info->user_url_list,
+ transfer_info->handle->id);
+-
++
+ transfer_info->guc_info->conc_outstanding++;
+ transfer_info->handle->current_transfer = transfer_info;
+ if(transfer_info->guc_info->create_dest)
+ {
+ transfer_info->needs_mkdir = GLOBUS_TRUE;
+ }
+-
++
+ expand = GLOBUS_TRUE;
+ }
+ else
+@@ -1766,21 +1766,21 @@ globus_l_guc_transfer_kickout(
+ retry = GLOBUS_TRUE;
+ }
+ }
+-
++
+ }
+ globus_mutex_unlock(&g_monitor.mutex);
+-
++
+ if(expanded)
+- {
++ {
+ result = globus_l_guc_transfer(transfer_info);
+ if(result != GLOBUS_SUCCESS && !g_continue)
+- {
++ {
+ globus_mutex_lock(&g_monitor.mutex);
+ {
+ g_monitor.done = GLOBUS_TRUE;
+ g_monitor.use_err = GLOBUS_TRUE;
+ g_monitor.err = globus_error_peek(result);
+-
++
+ if(transfer_info->guc_info->conc_outstanding == 0)
+ {
+ globus_cond_signal(&g_monitor.cond);
+@@ -1810,13 +1810,13 @@ globus_l_guc_transfer_kickout(
+ GLOBUS_FALSE,
+ GLOBUS_TRUE);
+ }
+-
++
+ result = globus_l_guc_expand_single_url(transfer_info);
+ if(result != GLOBUS_SUCCESS)
+ {
+ err = globus_error_peek(result);
+ }
+-
++
+ result = GLOBUS_SUCCESS;
+ globus_l_url_copy_monitor_callback(
+ transfer_info, &transfer_info->handle->gass_copy_handle, err);
+@@ -1865,7 +1865,7 @@ main(int argc, char **argv)
+ err = globus_module_activate(GLOBUS_GASS_COPY_MODULE);
+ if( err != GLOBUS_SUCCESS )
+ {
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ _GASCSL("Error %d, activating gass copy module\n"),
+ err);
+ return 1;
+@@ -1873,7 +1873,7 @@ main(int argc, char **argv)
+ err = globus_module_activate(GLOBUS_FTP_CLIENT_DEBUG_PLUGIN_MODULE);
+ if( err != GLOBUS_SUCCESS )
+ {
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ _GASCSL("Error %d, activating ftp debug plugin module\n"),
+ err);
+ return 1;
+@@ -1881,7 +1881,7 @@ main(int argc, char **argv)
+ err = globus_module_activate(GLOBUS_FTP_CLIENT_RESTART_PLUGIN_MODULE);
+ if( err != GLOBUS_SUCCESS )
+ {
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ _GASCSL("Error %d, activating ftp restart plugin module\n"),
+ err);
+ return 1;
+@@ -1889,7 +1889,7 @@ main(int argc, char **argv)
+ err = globus_module_activate(GLOBUS_GSI_GSSAPI_MODULE);
+ if( err != GLOBUS_SUCCESS )
+ {
+- globus_libc_fprintf(stderr,
++ globus_libc_fprintf(stderr,
+ _GASCSL("Error %d, activating ftp restart plugin module\n"),
+ err);
+ return 1;
+@@ -1908,22 +1908,22 @@ main(int argc, char **argv)
+ {
+ return 1;
+ }
+-
++
+ /* crft interception */
+ if(g_ext != NULL)
+ {
+ return globus_l_guc_ext(&guc_info);
+ }
+-
+- guc_info.handles = (globus_l_guc_handle_t **)
++
++ guc_info.handles = (globus_l_guc_handle_t **)
+ globus_calloc(guc_info.conc, sizeof(globus_l_guc_handle_t *));
+ for(i = 0; i < guc_info.conc; i++)
+ {
+- guc_info.handles[i] = (globus_l_guc_handle_t *)
++ guc_info.handles[i] = (globus_l_guc_handle_t *)
+ globus_calloc(1, sizeof(globus_l_guc_handle_t));
+-
++
+ guc_info.handles[i]->guc_info = &guc_info;
+-
++
+ globus_gass_copy_attr_init(
+ &guc_info.handles[i]->source_gass_copy_attr);
+ globus_gass_copy_attr_init(
+@@ -1951,11 +1951,11 @@ main(int argc, char **argv)
+ &guc_info.handles[i]->cksm_gass_copy_handle);
+ }
+ }
+-
++
+ globus_mutex_init(&g_monitor.mutex, NULL);
+ globus_cond_init(&g_monitor.cond, NULL);
+ g_monitor.was_error = 0;
+-
++
+ if(guc_info.list_url != NULL)
+ {
+ globus_fifo_enqueue(&guc_info.expanded_url_list,
+@@ -1999,7 +1999,7 @@ main(int argc, char **argv)
+ globus_l_guc_interrupt_handler,
+ NULL);
+ }
+-
++
+ if(guc_info.dumpfile || guc_info.dump_only_file)
+ {
+ GlobusTimeReltimeSet(delay, 60, 0);
+@@ -2020,10 +2020,10 @@ main(int argc, char **argv)
+ g_err_msg = globus_error_print_friendly(
+ globus_error_peek(result));
+ fprintf(stderr, _GASCSL("\nerror: %s"), g_err_msg);
+- globus_free(g_err_msg);
++ globus_free(g_err_msg);
+ ret_val = 1;
+ }
+-
++
+ if(guc_info.dumpfile || guc_info.dump_only_file)
+ {
+ globus_callback_unregister(dumpfile_handle, NULL, NULL, NULL);
+@@ -2039,7 +2039,7 @@ main(int argc, char **argv)
+ raise(SIGINT);
+ #endif
+ }
+-
++
+ /* make sure the timer doesn't go off after a cancel. setting this
+ to true makes the handler ignore everything if it hasn't fired yet */
+ globus_mutex_lock(&g_monitor.mutex);
+@@ -2056,7 +2056,7 @@ main(int argc, char **argv)
+ {
+ globus_libc_fprintf(stdout, "\n");
+ }
+-
++
+ if(guc_info.udt)
+ {
+ /* sidestep udt shutdown issues */
+@@ -2068,17 +2068,17 @@ main(int argc, char **argv)
+ &guc_info.handles[i]->gass_copy_handle);
+ globus_gass_copy_handle_destroy(
+ &guc_info.handles[i]->cksm_gass_copy_handle);
+-
++
+ globus_free(guc_info.handles[i]);
+ }
+ globus_free(guc_info.handles);
+ guc_info.handles = NULL;
+-
++
+ globus_mutex_destroy(&g_monitor.mutex);
+ globus_cond_destroy(&g_monitor.cond);
+
+ globus_l_guc_info_destroy(&guc_info);
+-
++
+ globus_module_deactivate(GLOBUS_GSI_GSSAPI_MODULE);
+ /* XXX fix hang globus_module_deactivate_all(); */
+
+@@ -2095,17 +2095,17 @@ Parameters:
+ Returns:
+ ******************************************************************************/
+
+-static
++static
+ void
+ globus_l_url_copy_monitor_callback(
+ void * callback_arg,
+ globus_gass_copy_handle_t * handle,
+ globus_object_t * error)
+-{
++{
+ globus_l_guc_transfer_t * transfer_info;
+-
++
+ transfer_info = (globus_l_guc_transfer_t *) callback_arg;
+-
++
+ globus_mutex_lock(&g_monitor.mutex);
+ {
+ if(error != NULL)
+@@ -2113,17 +2113,17 @@ globus_l_url_copy_monitor_callback(
+ if(!g_continue)
+ {
+ globus_l_guc_enqueue_pair(
+- &transfer_info->guc_info->user_url_list,
++ &transfer_info->guc_info->user_url_list,
+ transfer_info->urls);
+-
++
+ transfer_info->urls = NULL;
+-
++
+ g_monitor.done = GLOBUS_TRUE;
+ g_monitor.use_err = GLOBUS_TRUE;
+ g_monitor.err = globus_object_copy(error);
+ }
+ else
+- {
++ {
+ char * msg;
+ g_monitor.was_error++;
+ msg = globus_error_print_friendly(error);
+@@ -2132,12 +2132,12 @@ globus_l_url_copy_monitor_callback(
+ }
+
+ }
+-
++
+ transfer_info->guc_info->conc_outstanding--;
+ transfer_info->handle->current_transfer = NULL;
+ globus_l_guc_url_pair_free(transfer_info->urls);
+ transfer_info->urls = NULL;
+-
++
+ if(transfer_info->handle->source_ftp_attr)
+ {
+ globus_ftp_client_operationattr_destroy(
+@@ -2149,16 +2149,16 @@ globus_l_url_copy_monitor_callback(
+ globus_ftp_client_operationattr_destroy(
+ &transfer_info->handle->dest_ftp_attr);
+ transfer_info->handle->dest_ftp_attr = NULL;
+- }
++ }
+ }
+ globus_mutex_unlock(&g_monitor.mutex);
+-
++
+ globus_callback_register_oneshot(
+ NULL,
+ NULL,
+ globus_l_guc_transfer_kickout,
+ transfer_info);
+-
++
+ return;
+ } /* globus_l_url_copy_monitor_callback() */
+
+@@ -2178,7 +2178,7 @@ globus_l_gass_copy_performance_cb(
+ float avg_throughput)
+ {
+ globus_libc_fprintf(stdout,
+- " %12" GLOBUS_OFF_T_FORMAT
++ " %12" GLOBUS_OFF_T_FORMAT
+ " bytes %12.2f MB/sec avg %12.2f MB/sec inst\r",
+ total_bytes,
+ avg_throughput / (1024 * 1024),
+@@ -2244,14 +2244,14 @@ globus_l_guc_entry_cb(
+ char * tmp_unique;
+ globus_bool_t seen = GLOBUS_FALSE;
+ int retval;
+- globus_l_guc_transfer_t * transfer_info;
++ globus_l_guc_transfer_t * transfer_info;
+ globus_l_guc_url_info_t * urlinfo;
+-
++
+ transfer_info = (globus_l_guc_transfer_t *) user_arg;
+ guc_info = transfer_info->guc_info;
+
+ globus_mutex_lock(&g_monitor.mutex);
+-
++
+ if(guc_info->recurse && info_stat &&
+ info_stat->type == GLOBUS_GASS_COPY_GLOB_ENTRY_DIR &&
+ info_stat->unique_id && *info_stat->unique_id)
+@@ -2261,19 +2261,19 @@ globus_l_guc_entry_cb(
+ &guc_info->recurse_hash,
+ tmp_unique,
+ tmp_unique);
+-
++
+ if(retval != 0)
+ {
+ globus_free(tmp_unique);
+ seen = GLOBUS_TRUE;
+ }
+ }
+-
++
+ if(!seen)
+ {
+- urlinfo = (globus_l_guc_url_info_t *)
++ urlinfo = (globus_l_guc_url_info_t *)
+ globus_calloc(sizeof(globus_l_guc_url_info_t), 1);
+-
++
+ urlinfo->url = globus_libc_strdup(url);
+ urlinfo->mode = info_stat->mode;
+ urlinfo->mdtm = info_stat->mdtm;
+@@ -2284,11 +2284,11 @@ globus_l_guc_entry_cb(
+ &transfer_info->matched_url_list,
+ urlinfo);
+ }
+-
++
+ globus_mutex_unlock(&g_monitor.mutex);
+-
+- return;
+-}
++
++ return;
++}
+
+ static
+ void
+@@ -2299,50 +2299,50 @@ globus_l_guc_dest_entry_cb(
+ {
+ globus_l_guc_info_t * guc_info;
+ int retval;
+- globus_l_guc_transfer_t * transfer_info;
++ globus_l_guc_transfer_t * transfer_info;
+ globus_l_guc_url_info_t * urlinfo;
+-
++
+ transfer_info = (globus_l_guc_transfer_t *) user_arg;
+ guc_info = transfer_info->guc_info;
+
+ globus_mutex_lock(&g_monitor.mutex);
+-
++
+ if(info_stat &&
+ info_stat->type != GLOBUS_GASS_COPY_GLOB_ENTRY_DIR)
+ {
+- urlinfo = (globus_l_guc_url_info_t *)
++ urlinfo = (globus_l_guc_url_info_t *)
+ globus_calloc(sizeof(globus_l_guc_url_info_t), 1);
+-
++
+ urlinfo->url = globus_libc_strdup(url);
+ urlinfo->mode = info_stat->mode;
+ urlinfo->mdtm = info_stat->mdtm;
+ urlinfo->size = info_stat->size;
+ urlinfo->type = info_stat->type;
+-
++
+ retval = globus_hashtable_insert(
+ &guc_info->dest_hash,
+ urlinfo->url,
+ urlinfo);
+-
++
+ if(retval != 0)
+ {
+ globus_free(urlinfo->url);
+ globus_free(urlinfo);
+ }
+ }
+-
++
+ globus_mutex_unlock(&g_monitor.mutex);
+-
+- return;
+-}
+
+-static
++ return;
++}
++
++static
+ void
+ globus_l_guc_info_destroy(
+ globus_l_guc_info_t * guc_info)
+ {
+ OM_uint32 min_stat;
+-
++
+ if(guc_info->source_subject)
+ {
+ globus_free(guc_info->source_subject);
+@@ -2416,7 +2416,7 @@ static
+ int
+ globus_l_guc_parse_file(
+ globus_l_guc_info_t * guc_info,
+- char * file_name,
++ char * file_name,
+ globus_fifo_t * user_url_list)
+ {
+ FILE * fptr;
+@@ -2446,7 +2446,7 @@ globus_l_guc_parse_file(
+ url_len = 0;
+ offset = guc_info->partial_offset;
+ length = guc_info->partial_length;
+-
++
+ while(*p && isspace(*p))
+ {
+ p++;
+@@ -2460,7 +2460,7 @@ globus_l_guc_parse_file(
+ {
+ continue;
+ }
+-
++
+ if(*p == '"')
+ {
+ rc = sscanf(p, "\"%[^\"]\"", src_url);
+@@ -2469,16 +2469,16 @@ globus_l_guc_parse_file(
+ else
+ {
+ rc = sscanf(p, "%s", src_url);
+- }
+-
++ }
++
+ if(rc != 1)
+- {
++ {
+ goto error_parse;
+ }
+-
++
+ url_len += strlen(src_url);
+ p = p + url_len;
+-
++
+ url_len = 0;
+ while(*p && isspace(*p))
+ {
+@@ -2493,16 +2493,16 @@ globus_l_guc_parse_file(
+ else
+ {
+ rc = sscanf(p, "%s", dst_url);
+- }
++ }
+
+ if(rc != 1)
+- {
++ {
+ goto error_parse;
+ }
+-
++
+ url_len += strlen(dst_url);
+ p = p + url_len;
+-
++
+ while(*p && isspace(*p))
+ {
+ p++;
+@@ -2512,7 +2512,7 @@ globus_l_guc_parse_file(
+ rc = sscanf(p, "%"GLOBUS_OFF_T_FORMAT",%"GLOBUS_OFF_T_FORMAT,
+ &offset, &length);
+ if(rc < 1 || offset < -1 || length < -1)
+- {
++ {
+ goto error_parse;
+ }
+ }
+@@ -2548,7 +2548,7 @@ globus_l_guc_parse_file(
+ }
+
+ return 0;
+-
++
+ error_parse:
+ if(fptr != stdin)
+ {
+@@ -2556,7 +2556,7 @@ error_parse:
+ }
+ fprintf(stderr, _GASCSL("Problem parsing url list: line %d\n"), line_num);
+ return -2;
+-
++
+ }
+
+ static
+@@ -2592,7 +2592,7 @@ globus_l_guc_load_alias_file(
+ {
+ line_num++;
+ p = line;
+-
++
+ while(*p && isspace(*p))
+ {
+ p++;
+@@ -2601,28 +2601,28 @@ globus_l_guc_load_alias_file(
+ {
+ continue;
+ }
+-
++
+ if(*p == '@')
+ {
+ newalias = GLOBUS_TRUE;
+ rc = sscanf(p, "@%s", buf);
+ if(rc != 1)
+- {
++ {
+ goto error_parse;
+ }
+ }
+ else
+ {
+ if(!alias_ent)
+- {
++ {
+ goto error_parse;
+ }
+ rc = sscanf(p, "%s", buf);
+ if(rc != 1)
+- {
++ {
+ goto error_parse;
+ }
+- }
++ }
+
+ if(newalias)
+ {
+@@ -2638,7 +2638,7 @@ globus_l_guc_load_alias_file(
+ if(rc != 0)
+ {
+ goto error_parse;
+- }
++ }
+ newalias = GLOBUS_FALSE;
+ }
+ else
+@@ -2649,21 +2649,21 @@ globus_l_guc_load_alias_file(
+ }
+
+ fclose(fptr);
+-
++
+ guc_l_aliases = GLOBUS_TRUE;
+- guc_l_src_alias_ent = (globus_l_guc_alias_t *)
++ guc_l_src_alias_ent = (globus_l_guc_alias_t *)
+ globus_hashtable_lookup(&guc_l_alias_table, (void *) "source");
+- guc_l_dst_alias_ent = (globus_l_guc_alias_t *)
++ guc_l_dst_alias_ent = (globus_l_guc_alias_t *)
+ globus_hashtable_lookup(&guc_l_alias_table, (void *) "destination");
+
+ return 0;
+-
++
+ error_parse:
+ fclose(fptr);
+- fprintf(stderr,
++ fprintf(stderr,
+ "Problem parsing alias file %s: line %d\n", file_name, line_num);
+ return -2;
+-
++
+ }
+
+
+@@ -2698,14 +2698,14 @@ globus_l_guc_transfer(
+ source_io_handle = globus_l_guc_get_io_handle(src_url, fileno(stdin));
+ dest_io_handle = globus_l_guc_get_io_handle(dst_url, fileno(stdout));
+
+- if(guc_info->comp_checksum)
++ if(guc_info->comp_checksum)
+ {
+ /*
+ * Associate the source checksum with the transfer handle
+ * so that the destination checksum can be verified after
+ * the successful transfer.
+- */
+- globus_gass_copy_set_checksum(&handle->gass_copy_handle,
++ */
++ globus_gass_copy_set_checksum(&handle->gass_copy_handle,
+ transfer_info->urls->src_info->checksum);
+ }
+
+@@ -2724,7 +2724,7 @@ globus_l_guc_transfer(
+ src_url,
+ GLOBUS_TRUE,
+ GLOBUS_FALSE);
+- }
++ }
+ if(dest_io_handle == NULL)
+ {
+ globus_l_guc_gass_attr_init(
+@@ -2737,12 +2737,12 @@ globus_l_guc_transfer(
+ GLOBUS_FALSE);
+ }
+
+- /* setting offsets should have been an attr option in gass_copy but
++ /* setting offsets should have been an attr option in gass_copy but
+ since we only run one operation per handle this will be ok. */
+ globus_gass_copy_set_partial_offsets(
+- &handle->gass_copy_handle,
++ &handle->gass_copy_handle,
+ transfer_info->urls->offset,
+- (transfer_info->urls->length == -1) ?
++ (transfer_info->urls->length == -1) ?
+ -1 : transfer_info->urls->offset + transfer_info->urls->length);
+
+ if(source_io_handle)
+@@ -2769,18 +2769,18 @@ globus_l_guc_transfer(
+ {
+ if(dst_url[strlen(dst_url) - 1] == '/')
+ {
+- dst_is_dir = GLOBUS_TRUE;
++ dst_is_dir = GLOBUS_TRUE;
+ }
+ else
+ {
+ dst_is_dir = GLOBUS_FALSE;
+- }
+-
++ }
++
+ if(!g_quiet_flag)
+ {
+ if(dst_is_dir)
+ {
+- src_filename = strrchr(src_url, '/');
++ src_filename = strrchr(src_url, '/');
+ while(src_filename > src_url && *src_filename == '/')
+ {
+ src_filename--;
+@@ -2790,8 +2790,8 @@ globus_l_guc_transfer(
+ src_filename--;
+ }
+ src_filename++;
+-
+- dst_filename = strrchr(dst_url, '/');
++
++ dst_filename = strrchr(dst_url, '/');
+ while(dst_filename > dst_url && *dst_filename == '/')
+ {
+ dst_filename--;
+@@ -2809,16 +2809,16 @@ globus_l_guc_transfer(
+ {
+ src_filename = src_url;
+ }
+-
++
+ dst_filename = strrchr(dst_url, '/');
+ if(!dst_filename++)
+ {
+ dst_filename = dst_url;
+ }
+ }
+-
+-
+- if(src_url_base == GLOBUS_NULL ||
++
++
++ if(src_url_base == GLOBUS_NULL ||
+ src_filename - src_url != src_url_base_len ||
+ strncmp(src_url, src_url_base, src_filename - src_url))
+ {
+@@ -2827,7 +2827,7 @@ globus_l_guc_transfer(
+ globus_free(src_url_base);
+ }
+ src_url_base = globus_libc_strdup(src_url);
+-
++
+ src_url_base_len = src_filename - src_url;
+ src_url_base[src_url_base_len] = '\0';
+ new_url = GLOBUS_TRUE;
+@@ -2836,8 +2836,8 @@ globus_l_guc_transfer(
+ {
+ new_url = GLOBUS_FALSE;
+ }
+-
+- if(dst_url_base == GLOBUS_NULL ||
++
++ if(dst_url_base == GLOBUS_NULL ||
+ dst_filename - dst_url != dst_url_base_len ||
+ strncmp(dst_url, dst_url_base, dst_filename - dst_url))
+ {
+@@ -2846,12 +2846,12 @@ globus_l_guc_transfer(
+ globus_free(dst_url_base);
+ }
+ dst_url_base = globus_libc_strdup(dst_url);
+-
++
+ dst_url_base_len = dst_filename - dst_url;
+ dst_url_base[dst_url_base_len] = '\0';
+ new_url = GLOBUS_TRUE;
+ }
+-
++
+ if(new_url)
+ {
+ globus_guc_transfer_update(
+@@ -2860,7 +2860,7 @@ globus_l_guc_transfer(
+ globus_guc_transfer_update(
+ NULL, NULL, src_filename, dst_filename);
+ }
+-
++
+ if(dst_is_dir)
+ {
+ if(guc_info->dump_only_file)
+@@ -2870,16 +2870,16 @@ globus_l_guc_transfer(
+ globus_l_guc_src_dst_pair_t * url_pair;
+ url_pair = (globus_l_guc_src_dst_pair_t *)
+ globus_malloc(sizeof(globus_l_guc_src_dst_pair_t));
+-
++
+ url_pair->src_url = globus_libc_strdup(transfer_info->urls->src_url);
+ url_pair->dst_url = globus_libc_strdup(transfer_info->urls->dst_url);
+ url_pair->offset = transfer_info->urls->offset;
+ url_pair->length = transfer_info->urls->length;
+ url_pair->src_info = transfer_info->urls->src_info;
+ transfer_info->urls->src_info = NULL;
+-
++
+ globus_l_guc_enqueue_pair(
+- &guc_info->dump_url_list,
++ &guc_info->dump_url_list,
+ url_pair);
+ }
+ result = GLOBUS_SUCCESS;
+@@ -2914,10 +2914,10 @@ globus_l_guc_transfer(
+ GLOBUS_FALSE,
+ GLOBUS_TRUE);
+ }
+-
++
+ result = globus_l_guc_expand_single_url(transfer_info);
+ if(result != GLOBUS_SUCCESS)
+- {
++ {
+ err = globus_error_peek(result);
+ }
+ result = GLOBUS_SUCCESS;
+@@ -2944,22 +2944,22 @@ globus_l_guc_transfer(
+ globus_l_guc_src_dst_pair_t * url_pair;
+ url_pair = (globus_l_guc_src_dst_pair_t *)
+ globus_malloc(sizeof(globus_l_guc_src_dst_pair_t));
+-
++
+ url_pair->src_url = globus_libc_strdup(transfer_info->urls->src_url);
+ url_pair->dst_url = globus_libc_strdup(transfer_info->urls->dst_url);
+ url_pair->offset = transfer_info->urls->offset;
+ url_pair->length = transfer_info->urls->length;
+ url_pair->src_info = transfer_info->urls->src_info;
+- transfer_info->urls->src_info = NULL;
+-
++ transfer_info->urls->src_info = NULL;
++
+ globus_l_guc_enqueue_pair(
+- &guc_info->dump_url_list,
++ &guc_info->dump_url_list,
+ url_pair);
+ }
+ result = GLOBUS_SUCCESS;
+-
++
+ globus_l_url_copy_monitor_callback(
+- transfer_info, &handle->gass_copy_handle, NULL);
++ transfer_info, &handle->gass_copy_handle, NULL);
+ }
+ }
+ }
+@@ -2983,11 +2983,11 @@ globus_l_guc_transfer(
+ {
+ globus_free(dst_url_base);
+ }
+-
+- return result;
++
++ return result;
+
+ }
+-
++
+ static
+ globus_result_t
+ globus_l_guc_transfer_files(
+@@ -3010,7 +3010,7 @@ globus_l_guc_transfer_files(
+ g_monitor.use_err = GLOBUS_FALSE;
+ guc_info->cancelled = GLOBUS_FALSE;
+ guc_info->conc_outstanding = 0;
+-
++
+ for(i = 0; i < guc_info->conc; i++)
+ {
+ transfer_info = (globus_l_guc_transfer_t *)
+@@ -3021,10 +3021,10 @@ globus_l_guc_transfer_files(
+ transfer_info->guc_info = guc_info;
+ transfer_info->needs_mkdir = GLOBUS_FALSE;
+ globus_fifo_init(&transfer_info->matched_url_list);
+-
++
+ globus_l_guc_transfer_kickout(transfer_info);
+ }
+-
++
+ globus_mutex_lock(&g_monitor.mutex);
+
+ while(!g_monitor.done || guc_info->conc_outstanding > 0)
+@@ -3036,27 +3036,27 @@ globus_l_guc_transfer_files(
+ {
+ fprintf(stderr, "%s", _GASCSL("\nCancelling copy...\n"));
+ guc_info->cancelled = GLOBUS_TRUE;
+-
++
+ if(guc_info->dumpfile || guc_info->dump_only_file)
+ {
+ globus_l_guc_dump_urls(guc_info);
+ }
+
+ for(i = 0; i < guc_info->conc; i++)
+- {
++ {
+ globus_gass_copy_cancel(
+- &guc_info->handles[i]->gass_copy_handle,
+- GLOBUS_NULL,
++ &guc_info->handles[i]->gass_copy_handle,
++ GLOBUS_NULL,
+ GLOBUS_NULL);
+ }
+ globus_l_globus_url_copy_ctrlc_handled = GLOBUS_TRUE;
+-
++
+ globus_callback_unregister_signal_handler(
+ GLOBUS_SIGNAL_INTERRUPT, GLOBUS_NULL, GLOBUS_NULL);
+ }
+ }
+ globus_mutex_unlock(&g_monitor.mutex);
+-
++
+
+ if(g_monitor.use_err)
+ {
+@@ -3080,7 +3080,7 @@ globus_l_guc_transfer_files(
+ {
+ goto error_transfer;
+ }
+-
++
+ if(!globus_l_globus_url_copy_ctrlc_handled)
+ {
+ globus_callback_unregister_signal_handler(
+@@ -3104,7 +3104,7 @@ globus_l_guc_transfer_files(
+ globus_error_construct_string(
+ GLOBUS_NULL,
+ GLOBUS_NULL,
+- _GASCSL("There were errors with %d transfers.\n"),
++ _GASCSL("There were errors with %d transfers.\n"),
+ g_monitor.was_error));
+ }
+ else
+@@ -3115,8 +3115,8 @@ globus_l_guc_transfer_files(
+ GLOBUS_NULL,
+ _GASCSL("There was an error with 1 transfer.\n")));
+ }
+-
+- }
++
++ }
+ return result;
+
+ error_transfer:
+@@ -3129,13 +3129,13 @@ error_transfer:
+ {
+ globus_free(dest_io_handle);
+ }
+-
++
+ if(!globus_l_globus_url_copy_ctrlc_handled)
+ {
+ globus_callback_unregister_signal_handler(
+ GLOBUS_SIGNAL_INTERRUPT, GLOBUS_NULL, GLOBUS_NULL);
+ }
+-
++
+ return result;
+ }
+
+@@ -3168,23 +3168,23 @@ globus_l_guc_file_to_string(
+
+ error_memory:
+ result = globus_error_put(
+- globus_error_construct_string(
+- GLOBUS_NULL,
+- GLOBUS_NULL,
+- _GASCSL("Could not open file: %s\n"),
+- filename));
++ globus_error_construct_string(
++ GLOBUS_NULL,
++ GLOBUS_NULL,
++ _GASCSL("Could not open file: %s\n"),
++ filename));
+ fclose(fp);
+ error_open:
+ if(result == GLOBUS_SUCCESS)
+- {
+- result = globus_error_put(
+- globus_error_construct_string(
+- GLOBUS_NULL,
+- GLOBUS_NULL,
+- _GASCSL("Could not allocate memory.\n")));
++ {
++ result = globus_error_put(
++ globus_error_construct_string(
++ GLOBUS_NULL,
++ GLOBUS_NULL,
++ _GASCSL("Could not allocate memory.\n")));
+ }
+ return result;
+-}
++}
+
+ #if 0
+ static
+@@ -3448,14 +3448,14 @@ guc_l_convert_file_url(
+ return globus_libc_strdup(in_url);
+ }
+ dir_ptr = globus_url_string_hex_encode(tmp_path, "");
+-
++
+ /* In windows, absolute paths don't begin with / */
+ tmp_ptr = globus_common_create_string("file://%s%s",
+ dir_ptr[0] == '/' ? "" : "/", dir_ptr);
+-
++
+ globus_free(dir_ptr);
+ globus_free(tmp_path);
+-
++
+ return tmp_ptr;
+ }
+
+@@ -3540,13 +3540,13 @@ globus_l_guc_load_cred(
+ guc_gencert(&buf);
+ auto_data.length = buf.length;
+ auto_data.value = buf.value;
+- return result;
++ return result;
+ }
+ else
+- {
++ {
+ buf.value = globus_common_create_string("X509_USER_PROXY=%s", path);
+ buf.length = strlen(buf.value);
+-
++
+ maj_stat = gss_import_cred(
+ &min_stat,
+ &cred,
+@@ -3559,7 +3559,7 @@ globus_l_guc_load_cred(
+ {
+ goto error;
+ }
+-
++
+ globus_free(buf.value);
+ }
+ }
+@@ -3588,18 +3588,18 @@ globus_l_guc_load_cred(
+ {
+ goto error;
+ }
+-
++
+ maj_stat = gss_display_name(&min_stat, name, &buf, NULL);
+ if(maj_stat != GSS_S_COMPLETE)
+ {
+ goto error;
+ }
+-
++
+ *out_subject = buf.value;
+-
++
+ gss_release_name(&min_stat, &name);
+ }
+-
++
+ if(out_cred)
+ {
+ *out_cred = cred;
+@@ -3610,7 +3610,7 @@ globus_l_guc_load_cred(
+ }
+
+ return result;
+-
++
+ error:
+ result = globus_error_put(globus_error_construct_gssapi_error(
+ NULL, NULL, maj_stat, min_stat));
+@@ -3703,7 +3703,7 @@ globus_l_guc_parse_arguments(
+
+
+ /* determine the program name */
+-
++
+ program = strrchr(argv[0],'/');
+ if(!program)
+ {
+@@ -3711,7 +3711,7 @@ globus_l_guc_parse_arguments(
+ }
+ else
+ {
+- program++;
++ program++;
+ }
+
+ globus_url_copy_i_args_init();
+@@ -3730,7 +3730,7 @@ globus_l_guc_parse_arguments(
+ {
+ return -1;
+ }
+-
++
+ for(list = options_found;
+ !globus_list_empty(list);
+ list = globus_list_rest(list))
+@@ -3828,7 +3828,7 @@ globus_l_guc_parse_arguments(
+ globus_url_copy_l_args_error(
+ "invalid value for block size");
+ return -1;
+- }
++ }
+ guc_info->block_size = (globus_size_t) tmp_off;
+ break;
+ case arg_f:
+@@ -3841,7 +3841,7 @@ globus_l_guc_parse_arguments(
+ globus_url_copy_l_args_error(
+ "invalid value for tcp buffer size");
+ return -1;
+- }
++ }
+ guc_info->tcp_buffer_size = (globus_size_t) tmp_off;
+ break;
+ case arg_s:
+@@ -3854,7 +3854,7 @@ globus_l_guc_parse_arguments(
+ globus_url_copy_l_args_error(
+ "Invalid value to -t. Must be an integer");
+ return -1;
+- }
++ }
+ break;
+ case arg_ss:
+ guc_info->source_subject = globus_libc_strdup(instance->values[0]);
+@@ -3910,7 +3910,7 @@ globus_l_guc_parse_arguments(
+ break;
+ case arg_create_dest:
+ guc_info->create_dest = GLOBUS_TRUE;
+- break;
++ break;
+ case arg_stripe_bs:
+ rc = globus_args_bytestr_to_num(instance->values[0], &tmp_off);
+ if(rc != 0)
+@@ -3918,19 +3918,19 @@ globus_l_guc_parse_arguments(
+ globus_url_copy_l_args_error(
+ "invalid value for stripe blocksize");
+ return -1;
+- }
++ }
+ guc_info->stripe_bs = (globus_size_t) tmp_off;
+- break;
+- case arg_striped:
+- guc_info->striped = GLOBUS_TRUE;
+- break;
+- case arg_udt:
+- guc_info->udt = GLOBUS_TRUE;
+- break;
+- case arg_nl_bottleneck:
+- guc_info->nl_bottleneck = GLOBUS_TRUE;
++ break;
++ case arg_striped:
++ guc_info->striped = GLOBUS_TRUE;
++ break;
++ case arg_udt:
++ guc_info->udt = GLOBUS_TRUE;
++ break;
++ case arg_nl_bottleneck:
++ guc_info->nl_bottleneck = GLOBUS_TRUE;
+ guc_info->nl_level = 15;
+- break;
++ break;
+
+ case arg_nl_interval:
+ guc_info->nl_bottleneck = GLOBUS_TRUE;
+@@ -3942,19 +3942,19 @@ globus_l_guc_parse_arguments(
+ _GASCSL("Error: Argument to nl-bottleneck must be a 4 bit mask"
+ "\n"));
+ return -1;
+- }
++ }
+ break;
+
+
+- case arg_ipv6:
+- guc_info->ipv6 = GLOBUS_TRUE;
+- break;
+- case arg_gridftp2:
+- guc_info->gridftp2 = GLOBUS_TRUE;
+- break;
+- case arg_gridftp2_off:
+- guc_info->gridftp2 = GLOBUS_FALSE;
+- break;
++ case arg_ipv6:
++ guc_info->ipv6 = GLOBUS_TRUE;
++ break;
++ case arg_gridftp2:
++ guc_info->gridftp2 = GLOBUS_TRUE;
++ break;
++ case arg_gridftp2_off:
++ guc_info->gridftp2 = GLOBUS_FALSE;
++ break;
+
+ case arg_src_pipe_str:
+ guc_info->src_pipe_str =
+@@ -3972,31 +3972,31 @@ globus_l_guc_parse_arguments(
+ break;
+
+ case arg_src_net_stack_str:
+- guc_info->src_net_stack_str =
++ guc_info->src_net_stack_str =
+ globus_libc_strdup(instance->values[0]);
+ break;
+ case arg_src_disk_stack_str:
+- guc_info->src_disk_stack_str =
++ guc_info->src_disk_stack_str =
+ globus_libc_strdup(instance->values[0]);
+ break;
+ case arg_dst_net_stack_str:
+- guc_info->dst_net_stack_str =
++ guc_info->dst_net_stack_str =
+ globus_libc_strdup(instance->values[0]);
+ break;
+ case arg_dst_disk_stack_str:
+- guc_info->dst_disk_stack_str =
++ guc_info->dst_disk_stack_str =
+ globus_libc_strdup(instance->values[0]);
+ break;
+ case arg_net_stack_str:
+- guc_info->src_net_stack_str =
++ guc_info->src_net_stack_str =
+ globus_libc_strdup(instance->values[0]);
+- guc_info->dst_net_stack_str =
++ guc_info->dst_net_stack_str =
+ globus_libc_strdup(instance->values[0]);
+ break;
+ case arg_disk_stack_str:
+- guc_info->src_disk_stack_str =
++ guc_info->src_disk_stack_str =
+ globus_libc_strdup(instance->values[0]);
+- guc_info->dst_disk_stack_str =
++ guc_info->dst_disk_stack_str =
+ globus_libc_strdup(instance->values[0]);
+ break;
+ case arg_authz_assert:
+@@ -4004,31 +4004,31 @@ globus_l_guc_parse_arguments(
+ instance->values[0], &authz_assert);
+ if(result != GLOBUS_SUCCESS)
+ {
+- fprintf(stderr,
++ fprintf(stderr,
+ _GASCSL("Error: Unable to read authz assertion %s\n"),
+- globus_error_print_friendly(globus_error_peek(result)));
++ globus_error_print_friendly(globus_error_peek(result)));
+ return -1;
+ }
+ break;
+ case arg_src_authz_assert:
+ result = globus_l_guc_file_to_string(
+- instance->values[0], &guc_info->src_authz_assert);
++ instance->values[0], &guc_info->src_authz_assert);
+ if(result != GLOBUS_SUCCESS)
+ {
+- fprintf(stderr,
++ fprintf(stderr,
+ _GASCSL("Error: Unable to read src authz assertion %s\n"),
+- globus_error_print_friendly(globus_error_peek(result)));
++ globus_error_print_friendly(globus_error_peek(result)));
+ return -1;
+ }
+ break;
+ case arg_dst_authz_assert:
+ result = globus_l_guc_file_to_string(
+- instance->values[0], &guc_info->dst_authz_assert);
++ instance->values[0], &guc_info->dst_authz_assert);
+ if(result != GLOBUS_SUCCESS)
+ {
+- fprintf(stderr,
++ fprintf(stderr,
+ _GASCSL("Error: Unable to read dst authz assertion %s\n"),
+- globus_error_print_friendly(globus_error_peek(result)));
++ globus_error_print_friendly(globus_error_peek(result)));
+ return -1;
+ }
+ break;
+@@ -4047,8 +4047,8 @@ globus_l_guc_parse_arguments(
+ break;
+ case arg_src_cred:
+ result = globus_l_guc_load_cred(
+- instance->values[0],
+- &guc_info->src_cred,
++ instance->values[0],
++ &guc_info->src_cred,
+ &guc_info->src_cred_subj);
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -4060,7 +4060,7 @@ globus_l_guc_parse_arguments(
+ break;
+ case arg_dst_cred:
+ result = globus_l_guc_load_cred(
+- instance->values[0],
++ instance->values[0],
+ &guc_info->dst_cred,
+ &guc_info->dst_cred_subj);
+ if(result != GLOBUS_SUCCESS)
+@@ -4073,7 +4073,7 @@ globus_l_guc_parse_arguments(
+ break;
+ case arg_data_cred:
+ result = globus_l_guc_load_cred(
+- instance->values[0],
++ instance->values[0],
+ &guc_info->data_cred,
+ &guc_info->data_cred_subj);
+ if(result != GLOBUS_SUCCESS)
+@@ -4084,75 +4084,75 @@ globus_l_guc_parse_arguments(
+ return -1;
+ }
+ break;
+- case arg_delayed_pasv:
+- guc_info->delayed_pasv = GLOBUS_TRUE;
+- break;
+- case arg_pipeline:
+- guc_info->pipeline = GLOBUS_TRUE;
+- break;
+- case arg_pipelineq:
+- guc_info->pipeline = GLOBUS_TRUE;
+- guc_info->pipelineq = atoi(instance->values[0]);
+- break;
+- case arg_sync:
+- guc_info->sync = GLOBUS_TRUE;
+- break;
+- case arg_sync_level:
+- guc_info->sync_level = atoi(instance->values[0]);
+- break;
+- case arg_checksum:
+- guc_info->comp_checksum = GLOBUS_TRUE;
+- break;
+- case arg_checksum_algo:
+- guc_info->checksum_algo = globus_libc_strdup(instance->values[0]);
+- break;
+- case arg_dump_only:
+- guc_info->dump_only_file = globus_libc_strdup(instance->values[0]);
+- break;
+- case arg_preserve:
+- case arg_perms:
+- guc_info->perms = GLOBUS_TRUE;
+- break;
+- case arg_allo:
+- guc_info->allo = GLOBUS_TRUE;
+- break;
+- case arg_noallo:
+- guc_info->allo = GLOBUS_FALSE;
+- break;
+- case arg_partial_offset:
++ case arg_delayed_pasv:
++ guc_info->delayed_pasv = GLOBUS_TRUE;
++ break;
++ case arg_pipeline:
++ guc_info->pipeline = GLOBUS_TRUE;
++ break;
++ case arg_pipelineq:
++ guc_info->pipeline = GLOBUS_TRUE;
++ guc_info->pipelineq = atoi(instance->values[0]);
++ break;
++ case arg_sync:
++ guc_info->sync = GLOBUS_TRUE;
++ break;
++ case arg_sync_level:
++ guc_info->sync_level = atoi(instance->values[0]);
++ break;
++ case arg_checksum:
++ guc_info->comp_checksum = GLOBUS_TRUE;
++ break;
++ case arg_checksum_algo:
++ guc_info->checksum_algo = globus_libc_strdup(instance->values[0]);
++ break;
++ case arg_dump_only:
++ guc_info->dump_only_file = globus_libc_strdup(instance->values[0]);
++ break;
++ case arg_preserve:
++ case arg_perms:
++ guc_info->perms = GLOBUS_TRUE;
++ break;
++ case arg_allo:
++ guc_info->allo = GLOBUS_TRUE;
++ break;
++ case arg_noallo:
++ guc_info->allo = GLOBUS_FALSE;
++ break;
++ case arg_partial_offset:
+ rc = globus_args_bytestr_to_num(instance->values[0], &tmp_off);
+ if(rc != 0)
+ {
+ globus_url_copy_l_args_error(
+ "invalid value for offset");
+ return -1;
+- }
++ }
+ guc_info->partial_offset = tmp_off;
+- break;
+- case arg_partial_length:
++ break;
++ case arg_partial_length:
+ rc = globus_args_bytestr_to_num(instance->values[0], &tmp_off);
+ if(rc != 0)
+ {
+ globus_url_copy_l_args_error(
+ "invalid value for length");
+ return -1;
+- }
++ }
+ guc_info->partial_length = tmp_off;
+ if(guc_info->partial_offset == -1)
+ {
+ guc_info->partial_offset = 0;
+ }
+- break;
+- case arg_fast:
+- guc_info->list_uses_data_mode = GLOBUS_TRUE;
+- if(guc_info->num_streams < 1)
+- {
++ break;
++ case arg_fast:
++ guc_info->list_uses_data_mode = GLOBUS_TRUE;
++ if(guc_info->num_streams < 1)
++ {
+ guc_info->num_streams = 1;
+ }
+
+- break;
++ break;
+
+- case arg_list:
++ case arg_list:
+ guc_info->list_url = globus_libc_strdup(instance->values[0]);
+ break;
+
+@@ -4174,7 +4174,7 @@ globus_l_guc_parse_arguments(
+ {
+ if(guc_info->src_disk_stack_str)
+ {
+- tmp_str = globus_common_create_string("%s,%s",
++ tmp_str = globus_common_create_string("%s,%s",
+ guc_info->src_pipe_str, guc_info->src_disk_stack_str);
+ free(guc_info->src_disk_stack_str);
+ guc_info->src_disk_stack_str = tmp_str;
+@@ -4188,7 +4188,7 @@ globus_l_guc_parse_arguments(
+ {
+ if(guc_info->dst_disk_stack_str)
+ {
+- tmp_str = globus_common_create_string("%s,%s",
++ tmp_str = globus_common_create_string("%s,%s",
+ guc_info->dst_pipe_str, guc_info->dst_disk_stack_str);
+ free(guc_info->dst_disk_stack_str);
+ guc_info->dst_disk_stack_str = tmp_str;
+@@ -4199,7 +4199,7 @@ globus_l_guc_parse_arguments(
+ "%s,ordering", guc_info->dst_pipe_str);
+ }
+ }
+- /* if we are doing multicast allow no dest option by adding the first
++ /* if we are doing multicast allow no dest option by adding the first
+ url in the file */
+ if(guc_info->mc_file != NULL)
+ {
+@@ -4243,12 +4243,12 @@ globus_l_guc_parse_arguments(
+ }
+
+ rc = -1;
+- if(guc_info->dump_only_file && guc_info->dump_only_file[0] == '-' &&
++ if(guc_info->dump_only_file && guc_info->dump_only_file[0] == '-' &&
+ guc_info->dump_only_file[1] == '\0')
+ {
+ guc_info->dump_only_fp = stdout;
+ }
+-
++
+ if(guc_info->dumpfile)
+ {
+ if(guc_info->dump_only_file && !guc_info->dump_only_fp)
+@@ -4263,7 +4263,7 @@ globus_l_guc_parse_arguments(
+
+ rc = globus_l_guc_parse_file(
+ guc_info, guc_info->dumpfile, &guc_info->user_url_list);
+-
++
+ if(rc == 0 && globus_fifo_empty(&guc_info->user_url_list))
+ {
+ printf("Dumpfile exists and is empty. Nothing to do.");
+@@ -4275,14 +4275,14 @@ globus_l_guc_parse_arguments(
+ }
+
+ }
+-
++
+ if(rc == 0)
+ {
+ if(g_verbose_flag)
+ {
+ printf("Reading URLs from dumpfile\n");
+ }
+- }
++ }
+ else if(file_name != NULL)
+ {
+ /* get source dest pairs */
+@@ -4307,8 +4307,8 @@ globus_l_guc_parse_arguments(
+ else if(guc_info->list_url == NULL) /* only if we are not listing */
+ {
+ /* there must be 2 additional unflagged arguments:
+- * the source and destination URL's
+- */
++ * the source and destination URL's
++ */
+ if(argc > 3)
+ {
+ globus_url_copy_l_args_error("too many url strings specified");
+@@ -4328,7 +4328,7 @@ globus_l_guc_parse_arguments(
+ return -1;
+ }
+ else
+- {
++ {
+ ent = (globus_l_guc_src_dst_pair_t *)
+ globus_malloc(sizeof(globus_l_guc_src_dst_pair_t));
+
+@@ -4337,10 +4337,10 @@ globus_l_guc_parse_arguments(
+ ent->offset = guc_info->partial_offset;
+ ent->length = guc_info->partial_length;
+ ent->src_info = NULL;
+-
++
+ globus_fifo_enqueue(&guc_info->user_url_list, ent);
+ }
+-
++
+ }
+
+ globus_l_guc_load_alias_file(guc_info->alias_file);
+@@ -4350,7 +4350,7 @@ globus_l_guc_parse_arguments(
+ if(guc_info->src_cred == GSS_C_NO_CREDENTIAL)
+ {
+ result = globus_l_guc_load_cred(
+- cred_path,
++ cred_path,
+ &guc_info->src_cred,
+ &guc_info->src_cred_subj);
+ if(result != GLOBUS_SUCCESS)
+@@ -4364,7 +4364,7 @@ globus_l_guc_parse_arguments(
+ if(guc_info->dst_cred == GSS_C_NO_CREDENTIAL)
+ {
+ result = globus_l_guc_load_cred(
+- cred_path,
++ cred_path,
+ &guc_info->dst_cred,
+ &guc_info->dst_cred_subj);
+ if(result != GLOBUS_SUCCESS)
+@@ -4375,15 +4375,15 @@ globus_l_guc_parse_arguments(
+ return -1;
+ }
+ }
+-
++
+ globus_free(cred_path);
+ }
+-
+- if(guc_info->src_cred != GSS_C_NO_CREDENTIAL &&
++
++ if(guc_info->src_cred != GSS_C_NO_CREDENTIAL &&
+ guc_info->dst_cred == GSS_C_NO_CREDENTIAL)
+ {
+ result = globus_l_guc_load_cred(
+- NULL,
++ NULL,
+ &guc_info->dst_cred,
+ &guc_info->dst_cred_subj);
+ if(result != GLOBUS_SUCCESS)
+@@ -4394,11 +4394,11 @@ globus_l_guc_parse_arguments(
+ return -1;
+ }
+ }
+- if(guc_info->src_cred == GSS_C_NO_CREDENTIAL &&
++ if(guc_info->src_cred == GSS_C_NO_CREDENTIAL &&
+ guc_info->dst_cred != GSS_C_NO_CREDENTIAL)
+ {
+ result = globus_l_guc_load_cred(
+- NULL,
++ NULL,
+ &guc_info->src_cred,
+ &guc_info->src_cred_subj);
+ if(result != GLOBUS_SUCCESS)
+@@ -4457,7 +4457,7 @@ globus_l_guc_parse_arguments(
+ globus_fifo_peek(&guc_info->user_url_list);
+
+ /* we must verify that we are doing a 3pt. this means that
+- both src and dst url must be ftp:// or gsiftp://
++ both src and dst url must be ftp:// or gsiftp://
+ obviously this doesnt work for the case where there is
+ a file full or url transfers and the first is 3pt fpt transfers
+ but the remainder are not. that case is a PITA. For now
+@@ -4556,7 +4556,7 @@ globus_l_guc_parse_arguments(
+ globus_free(net_netlog_str);
+ globus_free(disk_netlog_str);
+ }
+-
++
+ /* check arguemnt validity */
+ if((guc_info->options & GLOBUS_URL_COPY_ARG_ASCII) &&
+ (guc_info->options & GLOBUS_URL_COPY_ARG_BINARY) )
+@@ -4573,7 +4573,7 @@ globus_l_guc_parse_arguments(
+ return -1;
+ }
+ return 0;
+-
++
+ }
+
+
+@@ -4592,7 +4592,7 @@ globus_l_guc_create_dir(
+ globus_url_t parsed_url;
+ globus_list_t * mkdir_urls = GLOBUS_NULL;
+ char * dst_filename;
+-
++
+ rc = globus_url_parse(url, &parsed_url);
+ if(rc != 0)
+ {
+@@ -4624,10 +4624,10 @@ globus_l_guc_create_dir(
+
+ save_url[dst_filename - dst_mkurl + 1] = '\0';
+ globus_list_insert(&mkdir_urls, save_url);
+-
+- *dst_filename = '\0';
++
++ *dst_filename = '\0';
+ }
+-
++
+ globus_url_destroy(&parsed_url);
+ rc = globus_url_parse(dst_mkurl, &parsed_url);
+ }
+@@ -4636,7 +4636,7 @@ globus_l_guc_create_dir(
+ globus_url_destroy(&parsed_url);
+ }
+ globus_free(dst_mkurl);
+-
++
+ dst_mkurl = globus_libc_strdup(url);
+ dst_filename = strrchr(dst_mkurl, '/');
+ if(dst_filename && *(++dst_filename))
+@@ -4646,12 +4646,12 @@ globus_l_guc_create_dir(
+ globus_list_insert(&mkdir_urls, dst_mkurl);
+
+ while(!done_create_dest && !globus_list_empty(mkdir_urls))
+- {
++ {
+ globus_bool_t inserted = GLOBUS_FALSE;
+ char * already_exists = NULL;
+-
++
+ dst_mkurl = globus_list_remove(&mkdir_urls, mkdir_urls);
+-
++
+ already_exists = globus_hashtable_lookup(
+ &guc_info->mkdir_hash, dst_mkurl);
+
+@@ -4680,7 +4680,7 @@ globus_l_guc_create_dir(
+ {
+ done_create_dest = GLOBUS_TRUE;
+ }
+-
++
+ if(result == GLOBUS_SUCCESS || !first_attempt)
+ {
+ globus_mutex_lock(&g_monitor.mutex);
+@@ -4700,22 +4700,22 @@ globus_l_guc_create_dir(
+ &handle->dest_ftp_attr);
+ handle->dest_ftp_attr = NULL;
+ }
+-
++
+ first_attempt = GLOBUS_FALSE;
+ if(!inserted)
+ {
+ globus_free(dst_mkurl);
+ }
+ }
+-
++
+ while(!globus_list_empty(mkdir_urls))
+ {
+ dst_mkurl = globus_list_remove(&mkdir_urls, mkdir_urls);
+ globus_free(dst_mkurl);
+ }
+-
++
+ return GLOBUS_SUCCESS;
+-
++
+ error:
+ return result;
+ }
+@@ -4740,7 +4740,7 @@ globus_l_guc_expand_urls(
+ 256,
+ globus_hashtable_string_hash,
+ globus_hashtable_string_keyeq);
+-
++
+ globus_hashtable_init(
+ &guc_info->dest_hash,
+ 256,
+@@ -4760,19 +4760,19 @@ globus_l_guc_expand_urls(
+
+ src_url = user_url_pair->src_url;
+ dst_url = user_url_pair->dst_url;
+-
++
+ no_expand = GLOBUS_FALSE;
+ if(strcmp("-", src_url) == 0)
+ {
+ expanded_url_pair = (globus_l_guc_src_dst_pair_t *)
+ globus_malloc(sizeof(globus_l_guc_src_dst_pair_t));
+-
++
+ expanded_url_pair->src_url = globus_libc_strdup(src_url);
+ expanded_url_pair->dst_url = globus_libc_strdup(dst_url);
+ expanded_url_pair->offset = user_url_pair->offset;
+ expanded_url_pair->length = user_url_pair->length;
+ expanded_url_pair->src_info = NULL;
+-
++
+ if(guc_info->create_dest && !guc_info->dump_only_file)
+ {
+ result = globus_l_guc_create_dir(
+@@ -4784,11 +4784,11 @@ globus_l_guc_expand_urls(
+ }
+
+ globus_fifo_enqueue(
+- &guc_info->expanded_url_list,
++ &guc_info->expanded_url_list,
+ expanded_url_pair);
+ no_expand = GLOBUS_TRUE;
+ }
+-
++
+ globus_l_guc_gass_attr_init(
+ &handle->source_gass_copy_attr,
+ &handle->source_gass_attr,
+@@ -4810,7 +4810,7 @@ globus_l_guc_expand_urls(
+ }
+
+ if(!no_expand)
+- {
++ {
+ globus_l_guc_transfer_t transfer_info;
+ transfer_info.urls = user_url_pair;
+ globus_fifo_init(&transfer_info.matched_url_list);
+@@ -4830,17 +4830,17 @@ globus_l_guc_expand_urls(
+ if(result != GLOBUS_SUCCESS)
+ {
+ if(!g_continue)
+- {
++ {
+ globus_fifo_enqueue(
+- &transfer_info.guc_info->user_url_list,
++ &transfer_info.guc_info->user_url_list,
+ transfer_info.urls);
+
+ transfer_info.urls = NULL;
+ }
+-
++
+ globus_l_guc_url_pair_free(transfer_info.urls);
+ goto error_expand;
+-
++
+ }
+ }
+ globus_ftp_client_operationattr_destroy(&handle->source_ftp_attr);
+@@ -4850,18 +4850,18 @@ globus_l_guc_expand_urls(
+ globus_ftp_client_operationattr_destroy(&handle->dest_ftp_attr);
+ handle->dest_ftp_attr = NULL;
+ }
+-
++
+ globus_l_guc_url_pair_free(user_url_pair);
+ }
+
+- if(!globus_fifo_empty(&guc_info->expanded_url_list) ||
++ if(!globus_fifo_empty(&guc_info->expanded_url_list) ||
+ guc_info->sync || guc_info->dump_only_fp)
+ {
+ no_matches = GLOBUS_FALSE;
+ }
+
+ result = globus_l_guc_transfer_files(guc_info);
+-
++
+ if(globus_l_globus_url_copy_ctrlc_handled)
+ {
+ goto error_transfer;
+@@ -4874,14 +4874,14 @@ globus_l_guc_expand_urls(
+ goto error_transfer;
+ }
+ }
+-
++
+ if(no_matches && result == GLOBUS_SUCCESS)
+ {
+ result = globus_error_put(
+ globus_error_construct_string(
+ GLOBUS_NULL,
+ GLOBUS_NULL,
+- _GASCSL("No files matched the source url.\n")));
++ _GASCSL("No files matched the source url.\n")));
+ }
+ if(was_error && result == GLOBUS_SUCCESS)
+ {
+@@ -4910,15 +4910,15 @@ error_expand:
+ handle->dest_ftp_attr = NULL;
+ }
+
+-error_transfer:
++error_transfer:
+ globus_hashtable_destroy_all(&guc_info->recurse_hash,
+ globus_l_guc_hashtable_element_free);
+ globus_hashtable_destroy_all(&guc_info->dest_hash,
+ globus_l_guc_url_info_free);
+ globus_hashtable_destroy_all(&guc_info->mkdir_hash,
+ globus_l_guc_hashtable_element_free);
+-
+- return result;
++
++ return result;
+ }
+
+ typedef struct
+@@ -4932,17 +4932,17 @@ typedef struct
+ } globus_l_guc_cksm_info_t;
+
+
+-static
++static
+ void
+ globus_l_guc_cksm_cb(
+ void * callback_arg,
+ globus_gass_copy_handle_t * handle,
+ globus_object_t * error)
+-{
++{
+ globus_l_guc_cksm_info_t * cksm_info;
+
+ cksm_info = (globus_l_guc_cksm_info_t *) callback_arg;
+-
++
+ if(error)
+ {
+ globus_free(cksm_info->urlinfo->checksum);
+@@ -4954,7 +4954,7 @@ globus_l_guc_cksm_cb(
+ cksm_info->done = GLOBUS_TRUE;
+ globus_cond_signal(&cksm_info->monitor->cond);
+ }
+- globus_mutex_unlock(&cksm_info->monitor->mutex);
++ globus_mutex_unlock(&cksm_info->monitor->mutex);
+ }
+
+
+@@ -4970,7 +4970,7 @@ globus_l_guc_check_sync(
+ globus_bool_t retval = GLOBUS_TRUE;
+ globus_result_t result = GLOBUS_SUCCESS;
+ globus_l_guc_url_info_t * dest_urlinfo;
+-
++
+ globus_mutex_lock(&g_monitor.mutex);
+ dest_urlinfo = globus_hashtable_remove(&guc_info->dest_hash, dst_url);
+ globus_mutex_unlock(&g_monitor.mutex);
+@@ -4988,13 +4988,13 @@ globus_l_guc_check_sync(
+
+ globus_mutex_init(&cksm_monitor.mutex, NULL);
+ globus_cond_init(&cksm_monitor.cond, NULL);
+-
++
+ src_urlinfo->checksum = malloc(CKSM_SIZE);
+ src_cksm_info.urlinfo = src_urlinfo;
+ src_cksm_info.done = GLOBUS_FALSE;
+ src_cksm_info.monitor = &cksm_monitor;
+ src_cksm_info.error = NULL;
+-
++
+ result = globus_gass_copy_cksm_async(
+ &handle->gass_copy_handle,
+ src_urlinfo->url,
+@@ -5013,20 +5013,20 @@ globus_l_guc_check_sync(
+ }
+ globus_ftp_client_handle_t real_ftp_handle;
+ globus_ftp_client_handle_t cksm_ftp_handle;
+-
++
+ dest_urlinfo->checksum = malloc(CKSM_SIZE);
+ dst_cksm_info.urlinfo = dest_urlinfo;
+ dst_cksm_info.done = GLOBUS_FALSE;
+ dst_cksm_info.monitor = &cksm_monitor;
+ dst_cksm_info.error = NULL;
+-
++
+ globus_gass_copy_get_ftp_handle(
+ &handle->gass_copy_handle, &real_ftp_handle);
+ globus_gass_copy_get_ftp_handle(
+ &handle->cksm_gass_copy_handle, &cksm_ftp_handle);
+ globus_ftp_client_handle_borrow_connection(
+ &real_ftp_handle, GLOBUS_FALSE, &cksm_ftp_handle, GLOBUS_TRUE);
+-
++
+ result = globus_gass_copy_cksm_async(
+ &handle->cksm_gass_copy_handle,
+ dest_urlinfo->url,
+@@ -5046,7 +5046,7 @@ globus_l_guc_check_sync(
+
+ goto error;
+ }
+-
++
+ globus_mutex_lock(&cksm_monitor.mutex);
+ while(!src_cksm_info.done || !dst_cksm_info.done)
+ {
+@@ -5054,7 +5054,7 @@ globus_l_guc_check_sync(
+ &cksm_monitor.cond, &cksm_monitor.mutex);
+ }
+ globus_mutex_unlock(&cksm_monitor.mutex);
+-
++
+ if(src_cksm_info.error)
+ {
+ result = globus_error_put(src_cksm_info.error);
+@@ -5071,7 +5071,7 @@ globus_l_guc_check_sync(
+
+ goto error;
+ }
+-
++
+ if(src_urlinfo->checksum && dest_urlinfo->checksum &&
+ strcmp(src_urlinfo->checksum, dest_urlinfo->checksum) == 0)
+ {
+@@ -5086,7 +5086,7 @@ globus_l_guc_check_sync(
+ break;
+
+ case GLOBUS_L_GUC_DATE:
+- if(dest_urlinfo->mdtm >= src_urlinfo->mdtm &&
++ if(dest_urlinfo->mdtm >= src_urlinfo->mdtm &&
+ src_urlinfo->mdtm != -1 &&
+ dest_urlinfo->size == src_urlinfo->size &&
+ src_urlinfo->size != -1)
+@@ -5094,7 +5094,7 @@ globus_l_guc_check_sync(
+ retval = GLOBUS_FALSE;
+ }
+ break;
+-
++
+ case GLOBUS_L_GUC_SIZE:
+ if(dest_urlinfo->size == src_urlinfo->size &&
+ src_urlinfo->size != -1)
+@@ -5109,14 +5109,14 @@ globus_l_guc_check_sync(
+ retval = GLOBUS_FALSE;
+ }
+ break;
+-
++
+ default:
+ break;
+ }
+
+ globus_l_guc_url_info_free(dest_urlinfo);
+ }
+-
++
+ *mismatch = retval;
+ return GLOBUS_SUCCESS;
+
+@@ -5142,41 +5142,41 @@ globus_l_guc_expand_single_url(
+ globus_result_t result;
+ globus_bool_t dst_is_file;
+ globus_bool_t matched_is_dir;
+- int files_matched;
++ int files_matched;
+ globus_l_guc_info_t * guc_info;
+ globus_l_guc_handle_t * handle;
+ globus_bool_t do_transfer = GLOBUS_TRUE;
+- int rc;
+-
++ int rc;
++
+ src_url = transfer_info->urls->src_url;
+ dst_url = transfer_info->urls->dst_url;
+ handle = transfer_info->handle;
+ guc_info = transfer_info->guc_info;
+-
++
+ result = globus_gass_copy_glob_expand_url(
+ &handle->gass_copy_handle,
+ src_url,
+ &handle->source_gass_copy_attr,
+ globus_l_guc_entry_cb,
+ transfer_info);
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ result = globus_error_put(
+- globus_error_construct_error(
+- GLOBUS_NULL,
+- globus_error_peek(result),
+- 0,
+- __FILE__,
+- GLOBUS_NULL,
+- __LINE__,
+- "Unable to list url %s:",
++ globus_error_construct_error(
++ GLOBUS_NULL,
++ globus_error_peek(result),
++ 0,
++ __FILE__,
++ GLOBUS_NULL,
++ __LINE__,
++ "Unable to list url %s:",
+ src_url));
+- goto error_expand;
++ goto error_expand;
+ }
+-
++
+ url_len = strlen(dst_url);
+-
++
+ if(dst_url[url_len - 1] == '/')
+ {
+ dst_is_file = GLOBUS_FALSE;
+@@ -5189,7 +5189,7 @@ globus_l_guc_expand_single_url(
+ if(guc_info->sync)
+ {
+ globus_gass_copy_glob_stat_t stat_info;
+-
++
+ result = globus_gass_copy_stat(
+ &handle->gass_copy_handle,
+ dst_url,
+@@ -5202,7 +5202,7 @@ globus_l_guc_expand_single_url(
+ char * tmp_dst;
+
+ tmp_dst = globus_libc_strdup(dst_url);
+-
++
+ globus_mutex_lock(&g_monitor.mutex);
+ rc = globus_hashtable_insert(
+ &guc_info->mkdir_hash,
+@@ -5241,7 +5241,7 @@ globus_l_guc_expand_single_url(
+ globus_l_guc_dest_entry_cb(
+ dst_url, &stat_info, transfer_info);
+ }
+-
++
+ if(stat_info.symlink_target)
+ {
+ globus_free(stat_info.symlink_target);
+@@ -5256,7 +5256,7 @@ globus_l_guc_expand_single_url(
+ char * tmp_errstr;
+ globus_object_t * tmp_err;
+ char * tmp_ptr;
+-
++
+ tmp_err = globus_error_peek(result);
+ tmp_errstr = globus_error_print_friendly(tmp_err);
+ for(tmp_ptr = tmp_errstr; *tmp_ptr != '\0'; tmp_ptr++)
+@@ -5288,17 +5288,17 @@ globus_l_guc_expand_single_url(
+ globus_free(tmp_errstr);
+ }
+ }
+-
++
+ files_matched = 0;
+ base_url_len = strrchr(src_url, '/') - src_url + 1;
+-
++
+ while(!globus_fifo_empty(&transfer_info->matched_url_list))
+ {
+- matched_src_urlinfo = (globus_l_guc_url_info_t *)
++ matched_src_urlinfo = (globus_l_guc_url_info_t *)
+ globus_fifo_dequeue(&transfer_info->matched_url_list);
+-
++
+ matched_file = matched_src_urlinfo->url + base_url_len;
+-
++
+ matched_is_dir = GLOBUS_FALSE;
+ if(matched_src_urlinfo->url[strlen(matched_src_urlinfo->url) - 1] == '/')
+ {
+@@ -5314,7 +5314,7 @@ globus_l_guc_expand_single_url(
+ goto error_too_many_matches;
+ }
+ }
+-
++
+ if(dst_is_file && ++files_matched > 1)
+ {
+ globus_l_guc_url_info_free(matched_src_urlinfo);
+@@ -5325,11 +5325,11 @@ globus_l_guc_expand_single_url(
+ {
+ matched_dest_url = globus_libc_strdup(dst_url);
+ }
+- else
+- {
++ else
++ {
+ matched_dest_url = (char *) globus_malloc(
+ (url_len + strlen(matched_file) + 1) * sizeof(char));
+-
++
+ sprintf(matched_dest_url, "%s%s", dst_url, matched_file);
+ }
+ if(guc_info->sync)
+@@ -5341,34 +5341,34 @@ globus_l_guc_expand_single_url(
+ goto error_expand;
+ }
+ }
+-
++
+ if(do_transfer)
+ {
+
+ /*
+ * See if a post transfer checksum comparison has been requested
+- */
++ */
+
+- if(guc_info->comp_checksum)
++ if(guc_info->comp_checksum)
+ {
+ if(matched_src_urlinfo->checksum == GLOBUS_NULL)
+ {
+ /*
+ * If a checksum hasn't been taken on the source yet, take it now.
+ */
+-
++
+ globus_l_guc_cksm_info_t src_cksm_info;
+ globus_l_guc_monitor_t cksm_monitor;
+-
++
+ globus_mutex_init(&cksm_monitor.mutex, NULL);
+ globus_cond_init(&cksm_monitor.cond, NULL);
+-
++
+ matched_src_urlinfo->checksum = malloc(CKSM_SIZE);
+ src_cksm_info.urlinfo = matched_src_urlinfo;
+ src_cksm_info.done = GLOBUS_FALSE;
+ src_cksm_info.monitor = &cksm_monitor;
+ src_cksm_info.error = NULL;
+-
++
+ result = globus_gass_copy_cksm_async(
+ &handle->gass_copy_handle,
+ matched_src_urlinfo->url,
+@@ -5392,7 +5392,7 @@ globus_l_guc_expand_single_url(
+ &cksm_monitor.cond, &cksm_monitor.mutex);
+ }
+ globus_mutex_unlock(&cksm_monitor.mutex);
+-
++
+ if(src_cksm_info.error)
+ {
+ result = globus_error_put(src_cksm_info.error);
+@@ -5400,7 +5400,7 @@ globus_l_guc_expand_single_url(
+ }
+ }
+ }
+-
++
+ if(guc_info->create_dest && !guc_info->dump_only_file)
+ {
+ result = globus_l_guc_create_dir(
+@@ -5410,7 +5410,7 @@ globus_l_guc_expand_single_url(
+ goto error_mkdir;
+ }
+ }
+-
++
+ if(guc_info->dump_only_fp)
+ {
+ globus_l_guc_print_url_line(
+@@ -5422,7 +5422,7 @@ globus_l_guc_expand_single_url(
+ matched_src_urlinfo,
+ matched_is_dir ? "#" : NULL);
+ }
+-
++
+ expanded_url_pair = (globus_l_guc_src_dst_pair_t *)
+ globus_malloc(sizeof(globus_l_guc_src_dst_pair_t));
+
+@@ -5431,13 +5431,13 @@ globus_l_guc_expand_single_url(
+ expanded_url_pair->offset = transfer_info->urls->offset;
+ expanded_url_pair->length = transfer_info->urls->length;
+ expanded_url_pair->src_info = matched_src_urlinfo;
+-
++
+ matched_src_urlinfo->url = NULL;
+-
++
+ if(!guc_info->dump_only_fp || matched_is_dir)
+ {
+ globus_l_guc_enqueue_pair(
+- &guc_info->expanded_url_list,
++ &guc_info->expanded_url_list,
+ expanded_url_pair);
+ }
+ else
+@@ -5451,9 +5451,9 @@ globus_l_guc_expand_single_url(
+ globus_free(matched_dest_url);
+ }
+ }
+-
++
+ return GLOBUS_SUCCESS;
+-
++
+ error_too_many_matches:
+ result = globus_error_put(
+ globus_error_construct_string(
+@@ -5461,15 +5461,15 @@ error_too_many_matches:
+ GLOBUS_NULL,
+ _GASCSL("Multiple source urls must be transferred to a directory "
+ "destination url:\n%s\n"),
+- dst_url));
++ dst_url));
+ error_mkdir:
+ error_expand:
+ error_checksum:
+- return result;
++ return result;
+ }
+
+ static
+-void
++void
+ globus_l_guc_pipeline(
+ globus_ftp_client_handle_t * ftp_handle,
+ char ** source_url,
+@@ -5480,47 +5480,47 @@ globus_l_guc_pipeline(
+ globus_l_guc_info_t * guc_info;
+ globus_l_guc_src_dst_pair_t * pair;
+ globus_bool_t none = GLOBUS_FALSE;
+-
++
+ handle = (globus_l_guc_handle_t *) user_arg;
+ guc_info = handle->guc_info;
+-
++
+ *source_url = NULL;
+ *dest_url = NULL;
+-
++
+ globus_mutex_lock(&g_monitor.mutex);
+
+- globus_l_guc_url_pair_free(handle->pipeline_free_pair);
++ globus_l_guc_url_pair_free(handle->pipeline_free_pair);
+ handle->pipeline_free_pair = NULL;
+-
++
+ if(!g_monitor.done && !globus_fifo_empty(&guc_info->expanded_url_list))
+ {
+ pair = (globus_l_guc_src_dst_pair_t *)
+ globus_fifo_peek(&guc_info->expanded_url_list);
+-
++
+ if(pair->dst_url[strlen(pair->dst_url) - 1] == '/')
+ {
+ none = GLOBUS_TRUE;
+ }
+-
+- if(strncmp(pair->src_url, "file:/", 5) == 0 ||
++
++ if(strncmp(pair->src_url, "file:/", 5) == 0 ||
+ strncmp(pair->src_url, "http", 4) == 0 ||
+- strncmp(pair->dst_url, "file:/", 5) == 0 ||
+- strncmp(pair->dst_url, "http", 4) == 0)
++ strncmp(pair->dst_url, "file:/", 5) == 0 ||
++ strncmp(pair->dst_url, "http", 4) == 0)
+ {
+ none = GLOBUS_TRUE;
+ }
+-
++
+ if(!none)
+ {
+ char idstr[16];
+-
++
+ sprintf(idstr, "%u", handle->pipeline_id++);
+ *source_url = pair->src_url;
+ *dest_url = pair->dst_url;
+-
++
+ handle->pipeline_free_pair = globus_fifo_dequeue(
+ &guc_info->expanded_url_list);
+-
++
+ if(!g_quiet_flag)
+ {
+ globus_libc_fprintf(stdout,
+@@ -5531,7 +5531,7 @@ globus_l_guc_pipeline(
+
+ globus_mutex_unlock(&g_monitor.mutex);
+
+-
++
+ }
+
+
+@@ -5574,7 +5574,7 @@ globus_l_guc_init_gass_copy_handle(
+
+ return -1;
+ }
+-
++
+ ver_str = globus_common_create_string(
+ "%d.%d (%s, %d-%d) [%s]",
+ local_version.major,
+@@ -5611,7 +5611,7 @@ globus_l_guc_init_gass_copy_handle(
+ {
+ fprintf(stderr, "Failed to load extension %s\n", plugin_name);
+ }
+-
++
+ func_name = globus_common_create_string("%s_funcs", plugin_name);
+
+ funcs = (globus_guc_client_plugin_funcs_t *) globus_extension_lookup(
+@@ -5673,13 +5673,13 @@ globus_l_guc_init_gass_copy_handle(
+ if(g_use_restart)
+ {
+ GlobusTimeReltimeSet(interval, guc_info->restart_interval, 0);
+-
++
+ if(guc_info->restart_timeout)
+ {
+ GlobusTimeAbstimeSet(timeout, guc_info->restart_timeout, 0);
+ timeout_p = &timeout;
+ }
+-
++
+ result = globus_ftp_client_restart_plugin_init(
+ &restart_plugin,
+ guc_info->restart_retries, /* retry times 0=forever */
+@@ -5692,7 +5692,7 @@ globus_l_guc_init_gass_copy_handle(
+
+ return -1;
+ }
+-
++
+ if(guc_info->stall_timeout)
+ {
+ result = globus_ftp_client_restart_plugin_set_stall_timeout(
+@@ -5701,7 +5701,7 @@ globus_l_guc_init_gass_copy_handle(
+ {
+ fprintf(stderr, _GASCSL("Error: Unable to init debug plugin %s\n"),
+ globus_error_print_friendly(globus_error_peek(result)));
+-
++
+ return -1;
+ }
+ }
+@@ -5718,12 +5718,12 @@ globus_l_guc_init_gass_copy_handle(
+ }
+ }
+ else if(guc_info->stall_timeout)
+- {
++ {
+ GlobusTimeAbstimeSet(timeout, 0, 1);
+ timeout_p = &timeout;
+
+ result = globus_ftp_client_restart_plugin_init(
+- &restart_plugin, 0, NULL, timeout_p);
++ &restart_plugin, 0, NULL, timeout_p);
+ if(result != GLOBUS_SUCCESS)
+ {
+ fprintf(stderr, _GASCSL("Error: Unable to init debug plugin %s\n"),
+@@ -5731,7 +5731,7 @@ globus_l_guc_init_gass_copy_handle(
+
+ return -1;
+ }
+-
++
+ result = globus_ftp_client_restart_plugin_set_stall_timeout(
+ &restart_plugin, guc_info->stall_timeout);
+ if(result != GLOBUS_SUCCESS)
+@@ -5752,7 +5752,7 @@ globus_l_guc_init_gass_copy_handle(
+
+ return -1;
+ }
+- }
++ }
+
+ if(guc_info->rfc1738)
+ {
+@@ -5765,7 +5765,7 @@ globus_l_guc_init_gass_copy_handle(
+
+ return -1;
+ }
+- }
++ }
+
+ result = globus_ftp_client_handleattr_set_gridftp2(
+ &ftp_handleattr, guc_info->gridftp2);
+@@ -5790,15 +5790,15 @@ globus_l_guc_init_gass_copy_handle(
+
+ return -1;
+ }
+- }
+-
++ }
++
+ globus_gass_copy_handleattr_set_ftp_attr(
+ &gass_copy_handleattr, &ftp_handleattr);
+ globus_gass_copy_handle_init(gass_copy_handle, &gass_copy_handleattr);
+
+ if(guc_info->block_size > 0)
+ {
+- globus_gass_copy_set_buffer_length(gass_copy_handle,
++ globus_gass_copy_set_buffer_length(gass_copy_handle,
+ guc_info->block_size);
+ }
+
+@@ -5807,17 +5807,17 @@ globus_l_guc_init_gass_copy_handle(
+ globus_gass_copy_set_no_third_party_transfers(gass_copy_handle,
+ GLOBUS_TRUE);
+ }
+-
++
+ if(!guc_info->pipeline)
+ {
+ globus_gass_copy_set_allocate(gass_copy_handle, guc_info->allo);
+ }
+-
++
+ if(guc_info->sync)
+ {
+ globus_gass_copy_set_stat_on_expand(gass_copy_handle, GLOBUS_TRUE);
+ }
+-
++
+ if(g_verbose_flag)
+ {
+ result = globus_gass_copy_register_performance_cb(
+@@ -5827,7 +5827,7 @@ globus_l_guc_init_gass_copy_handle(
+
+ if(result != GLOBUS_SUCCESS)
+ {
+- fprintf(stderr,
++ fprintf(stderr,
+ _GASCSL("Error: Unable to register performance handler %s\n"),
+ globus_error_print_friendly(globus_error_peek(result)));
+
+@@ -5893,14 +5893,14 @@ globus_l_guc_gass_attr_init(
+ char * dcau_subj = NULL;
+
+ if(src)
+- {
++ {
+ subject = guc_info->source_subject;
+ module_name = guc_info->src_module_name;
+ module_args = guc_info->src_module_args;
+ authz_assert = guc_info->src_authz_assert,
+ cache_authz_assert = guc_info->cache_src_authz_assert;
+ cred = guc_info->src_cred;
+- if(guc_info->src_cred_subj && guc_info->dst_cred_subj &&
++ if(guc_info->src_cred_subj && guc_info->dst_cred_subj &&
+ strcmp(guc_info->src_cred_subj, guc_info->dst_cred_subj))
+ {
+ dcau_subj = guc_info->dst_cred_subj;
+@@ -5914,20 +5914,20 @@ globus_l_guc_gass_attr_init(
+ authz_assert = guc_info->dst_authz_assert,
+ cache_authz_assert = guc_info->cache_dst_authz_assert;
+ cred = guc_info->dst_cred;
+- if(guc_info->src_cred_subj && guc_info->dst_cred_subj &&
++ if(guc_info->src_cred_subj && guc_info->dst_cred_subj &&
+ strcmp(guc_info->src_cred_subj, guc_info->dst_cred_subj))
+ {
+ dcau_subj = guc_info->src_cred_subj;
+ }
+ }
+-
++
+ globus_url_parse(url, &url_info);
+ globus_gass_copy_get_url_mode(url, &url_mode);
+ /*
+ * setup the ftp attr
+ */
+ if(url_mode == GLOBUS_GASS_COPY_URL_MODE_FTP)
+- {
++ {
+ globus_ftp_client_operationattr_init(ftp_attr);
+
+ if(guc_info->tcp_buffer_size > 0)
+@@ -5949,49 +5949,49 @@ globus_l_guc_gass_attr_init(
+ parallelism.fixed.size = guc_info->num_streams;
+ globus_ftp_client_operationattr_set_parallelism(
+ ftp_attr,
+- ¶llelism);
+-
++ ¶llelism);
++
+ globus_ftp_client_operationattr_set_list_uses_data_mode(
+ ftp_attr,
+ guc_info->list_uses_data_mode);
+- }
++ }
+
+- if(guc_info->striped)
+- {
+- memset(&layout, '\0', sizeof(globus_ftp_control_layout_t));
++ if(guc_info->striped)
++ {
++ memset(&layout, '\0', sizeof(globus_ftp_control_layout_t));
+ switch(guc_info->stripe_bs)
+ {
+ case -1:
+- layout.mode =
++ layout.mode =
+ GLOBUS_FTP_CONTROL_STRIPING_NONE;
+ break;
+ case 0:
+- layout.mode =
++ layout.mode =
+ GLOBUS_FTP_CONTROL_STRIPING_PARTITIONED;
+ break;
+ default:
+- layout.mode =
++ layout.mode =
+ GLOBUS_FTP_CONTROL_STRIPING_BLOCKED_ROUND_ROBIN;
+ layout.round_robin.block_size = guc_info->stripe_bs;
+ }
+ globus_ftp_client_operationattr_set_mode(
+ ftp_attr,
+ GLOBUS_FTP_CONTROL_MODE_EXTENDED_BLOCK);
+- globus_ftp_client_operationattr_set_striped(ftp_attr, GLOBUS_TRUE);
++ globus_ftp_client_operationattr_set_striped(ftp_attr, GLOBUS_TRUE);
+ globus_ftp_client_operationattr_set_layout(ftp_attr, &layout);
+- }
++ }
+
+- if(guc_info->delayed_pasv)
+- {
++ if(guc_info->delayed_pasv)
++ {
+ globus_ftp_client_operationattr_set_delayed_pasv(
+- ftp_attr, GLOBUS_TRUE);
+- }
++ ftp_attr, GLOBUS_TRUE);
++ }
+
+- if(guc_info->ipv6)
+- {
++ if(guc_info->ipv6)
++ {
+ globus_ftp_client_operationattr_set_allow_ipv6(
+- ftp_attr, GLOBUS_TRUE);
+- }
++ ftp_attr, GLOBUS_TRUE);
++ }
+
+ if(module_name != NULL)
+ {
+@@ -6039,15 +6039,15 @@ globus_l_guc_gass_attr_init(
+ else if(auto_data.length > 0)
+ {
+ globus_ftp_client_operationattr_set_data_security(
+- ftp_attr, 'p', &auto_data);
++ ftp_attr, 'p', &auto_data);
+ }
+- else if(url_info.scheme_type == GLOBUS_URL_SCHEME_SSHFTP &&
++ else if(url_info.scheme_type == GLOBUS_URL_SCHEME_SSHFTP &&
+ (guc_info->data_private || guc_info->data_safe))
+ {
+ fprintf(stderr, "\nERROR: Data protection with sshftp requires a credential. Try '-data-cred auto'.\n\n");
+ exit(EXIT_FAILURE);
+ }
+-
++
+ if(guc_info->no_dcau)
+ {
+ dcau.mode = GLOBUS_FTP_CONTROL_DCAU_NONE;
+@@ -6065,13 +6065,13 @@ globus_l_guc_gass_attr_init(
+ ftp_attr,
+ &dcau);
+ }
+-
++
+ if(url_info.scheme_type == GLOBUS_URL_SCHEME_GSIFTP)
+ {
+ gsi_driver_str = "gsi";
+ }
+ }
+-
++
+ if(guc_info->data_private)
+ {
+ globus_ftp_client_operationattr_set_data_protection(
+@@ -6084,7 +6084,7 @@ globus_l_guc_gass_attr_init(
+ ftp_attr,
+ GLOBUS_FTP_CONTROL_PROTECTION_SAFE);
+ }
+-
++
+ if(src)
+ {
+ tmp_net_str = guc_info->src_net_stack_str;
+@@ -6165,7 +6165,7 @@ globus_l_guc_gass_attr_init(
+ }
+
+ globus_gass_copy_attr_set_ftp(gass_copy_attr, ftp_attr);
+-
++
+ }
+ /*
+ * setup the gass copy attr
+@@ -6198,8 +6198,8 @@ globus_l_guc_gass_attr_init(
+ globus_gass_copy_attr_set_gass(gass_copy_attr, gass_t_attr);
+ }
+
+- globus_url_destroy(&url_info);
+-
++ globus_url_destroy(&url_info);
++
+ return 0;
+ }
+
+@@ -6220,7 +6220,7 @@ globus_l_guc_get_io_handle(
+ {
+ return NULL;
+ }
+-
++
+ io_handle =(globus_io_handle_t *)
+ globus_libc_malloc(sizeof(globus_io_handle_t));
+
+@@ -6249,7 +6249,7 @@ globus_l_guc_url_pair_free(
+ globus_l_guc_url_info_free(url_pair->src_info);
+ globus_free(url_pair);
+ }
+-}
++}
+
+ static
+ void
+@@ -6263,38 +6263,38 @@ globus_l_guc_destroy_url_list(
+ url_pair = (globus_l_guc_src_dst_pair_t *)
+ globus_fifo_dequeue(url_list);
+ globus_l_guc_url_pair_free(url_pair);
+- }
++ }
+ globus_fifo_destroy(url_list);
+-}
++}
+
+-static
++static
+ void
+ globus_l_guc_hashtable_element_free(
+ void * datum)
+ {
+ char * string;
+-
++
+ string = (char *) datum;
+
+ if(string != GLOBUS_NULL)
+- {
++ {
+ globus_free(string);
+ }
+-
++
+ return;
+ }
+
+-static
++static
+ void
+ globus_l_guc_url_info_free(
+ void * datum)
+ {
+ globus_l_guc_url_info_t * info;
+-
++
+ info = (globus_l_guc_url_info_t *) datum;
+
+ if(info != NULL)
+- {
++ {
+ if(info->url)
+ {
+ globus_free(info->url);
+@@ -6305,6 +6305,6 @@ globus_l_guc_url_info_free(
+ }
+ globus_free(info);
+ }
+-
++
+ return;
+ }
+--
+2.54.0
+
diff --git a/0002-Build-with-OpenSSL-4.patch b/0002-Build-with-OpenSSL-4.patch
new file mode 100644
index 0000000..cea3ce4
--- /dev/null
+++ b/0002-Build-with-OpenSSL-4.patch
@@ -0,0 +1,35 @@
+From 24375b8503d2a4373600b14d03700b697415737b 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/3] Build with OpenSSL 4
+
+---
+ gass/copy/source/globus_url_copy.c | 4 +++-
+ 1 file changed, 3 insertions(+), 1 deletion(-)
+
+diff --git a/gass/copy/source/globus_url_copy.c b/gass/copy/source/globus_url_copy.c
+index 9ad992909..7f7274cdb 100644
+--- a/gass/copy/source/globus_url_copy.c
++++ b/gass/copy/source/globus_url_copy.c
+@@ -88,7 +88,7 @@ int guc_mkcert(X509 **x509p, EVP_PKEY **pkeyp, int bits, int serial, int days)
+ X509_gmtime_adj(X509_get_notAfter(x),(long)60*60*24*days);
+ X509_set_pubkey(x,pk);
+
+- name = X509_get_subject_name(x);
++ name = X509_NAME_dup(X509_get_subject_name(x));
+
+ /* This function creates and adds the entry, working out the
+ * correct string type and performing checks on its length.
+@@ -102,7 +102,9 @@ int guc_mkcert(X509 **x509p, EVP_PKEY **pkeyp, int bits, int serial, int days)
+ /* Its self signed so set the issuer name to be the same as the
+ * subject.
+ */
++ X509_set_subject_name(x,name);
+ X509_set_issuer_name(x,name);
++ X509_NAME_free(name);
+
+ if (!X509_sign(x,pk,EVP_md5()))
+ goto err;
+--
+2.54.0
+
diff --git a/0003-Fix-compiler-and-doxygen-warnings.patch b/0003-Fix-compiler-and-doxygen-warnings.patch
new file mode 100644
index 0000000..1157e23
--- /dev/null
+++ b/0003-Fix-compiler-and-doxygen-warnings.patch
@@ -0,0 +1,184 @@
+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 3/3] Fix compiler and doxygen warnings
+
+---
+ gass/copy/source/globus_gass_copy.c | 32 ++++++++++++------------
+ gass/copy/source/globus_gass_copy_glob.c | 5 +---
+ 2 files changed, 17 insertions(+), 20 deletions(-)
+
+diff --git a/gass/copy/source/globus_gass_copy.c b/gass/copy/source/globus_gass_copy.c
+index 3debc7ae3..61365d1cc 100644
+--- a/gass/copy/source/globus_gass_copy.c
++++ b/gass/copy/source/globus_gass_copy.c
+@@ -4932,7 +4932,7 @@ globus_l_gass_copy_io_write_callback(
+
+ /**
+ * @brief Blocking Transfer between URLs
+- * @ingroup globus_gass_transfer
++ * @ingroup globus_gass_copy
+ * @details
+ * @param handle
+ * The handle to perform the copy operation
+@@ -5069,7 +5069,7 @@ error_exit:
+
+ /**
+ * @brief Blocking Transfer from an URL to an IO handle
+- * @ingroup globus_gass_transfer
++ * @ingroup globus_gass_copy
+ * @details
+ * @param handle
+ * The handle to perform the copy operation
+@@ -5199,7 +5199,7 @@ error_exit:
+
+ /**
+ * @brief Blocking transfer from an IO handle to an URL
+- * @ingroup globus_gass_transfer
++ * @ingroup globus_gass_copy
+ * @details
+ * @param handle
+ * The handle to perform the copy operation
+@@ -5334,7 +5334,7 @@ error_exit:
+
+ /**
+ * Nonblocking Transfer between URLs
+- * @ingroup globus_gass_transfer
++ * @ingroup globus_gass_copy
+ * @details
+ * This functions initiates a transfer from source URL to destination URL,
+ * then returns immediately.
+@@ -5734,7 +5734,7 @@ error_result_exit:
+
+ /**
+ * @brief Nonblocking transfer from an URL to an IO handle
+- * @ingroup globus_gass_transfer
++ * @ingroup globus_gass_copy
+ * @details
+ * This functions initiates a transfer from source URL to an IO handle,
+ * then returns immediately.
+@@ -5894,7 +5894,7 @@ error_result_exit:
+
+ /**
+ * Nonblocking Transfer From an IO handle to an URL
+- * @ingroup globus_gass_transfer
++ * @ingroup globus_gass_copy
+ * @details
+ * This functions initiates a transfer from an IO handle to destination URL,
+ * then returns immediately.
+@@ -6053,7 +6053,7 @@ error_result_exit:
+
+ /**
+ * @brief Cache connections to an FTP or GridFTP server
+- * @ingroup globus_gass_transfer
++ * @ingroup globus_gass_copy
+ * @details
+ * Explicitly cache connections to URL server. When
+ * an URL is cached, the connection
+@@ -6125,7 +6125,7 @@ globus_gass_copy_cache_url_state(
+
+ /**
+ * @brief Remove an FTP or GridFTP cached connection
+- * @ingroup globus_gass_transfer
++ * @ingroup globus_gass_copy
+ * @details
+ * Explicitly remove a cached connection to an FTP or GSIFTP server.
+ * If an idle connection to an FTP server exists, it will be closed.
+@@ -6198,7 +6198,7 @@ globus_gass_copy_flush_url_state(
+
+ /**
+ * @brief Set the user pointer in a handle
+- * @ingroup globus_gass_transfer
++ * @ingroup globus_gass_copy
+ */
+ globus_result_t
+ globus_gass_copy_set_user_pointer(
+@@ -6226,7 +6226,7 @@ globus_gass_copy_set_user_pointer(
+
+ /**
+ * @brief Get the user pointer in a handle
+- * @ingroup globus_gass_transfer
++ * @ingroup globus_gass_copy
+ */
+ globus_result_t
+ globus_gass_copy_get_user_pointer(
+@@ -6254,7 +6254,7 @@ globus_gass_copy_get_user_pointer(
+
+ /**
+ * @brief Cancel a transfer
+- * @ingroup globus_gass_transfer
++ * @ingroup globus_gass_copy
+ */
+ globus_result_t
+ globus_gass_copy_cancel(
+@@ -6716,7 +6716,7 @@ globus_l_gass_copy_generic_cancel(
+ #ifdef USE_FTP_ATTRS
+ /**
+ * @brief Set TCP buffer/window size
+- * @ingroup globus_gass_transfer
++ * @ingroup globus_gass_copy
+ */
+ globus_result_t
+ globus_gass_copy_attr_set_tcpbuffer(
+@@ -6761,7 +6761,7 @@ globus_gass_copy_attr_set_tcpbuffer(
+
+ /**
+ * @brief Set parallelism info
+- * @ingroup globus_gass_transfer
++ * @ingroup globus_gass_copy
+ */
+ globus_result_t
+ globus_gass_copy_attr_set_parallelism(
+@@ -6773,7 +6773,7 @@ globus_gass_copy_attr_set_parallelism(
+
+ /**
+ * @brief Set striping info
+- * @ingroup globus_gass_transfer
++ * @ingroup globus_gass_copy
+ */
+ globus_result_t
+ globus_gass_copy_attr_set_striping(
+@@ -6785,7 +6785,7 @@ globus_gass_copy_attr_set_striping(
+
+ /**
+ * @brief Set authorization info
+- * @ingroup globus_gass_transfer
++ * @ingroup globus_gass_copy
+ */
+ globus_result_t
+ globus_gass_copy_attr_set_authorization(
+@@ -6797,7 +6797,7 @@ globus_gass_copy_attr_set_authorization(
+
+ /**
+ * @brief Set secure channel info
+- * @ingroup globus_gass_transfer
++ * @ingroup globus_gass_copy
+ */
+ globus_result_t
+ globus_gass_copy_attr_set_secure_channel(
+diff --git a/gass/copy/source/globus_gass_copy_glob.c b/gass/copy/source/globus_gass_copy_glob.c
+index 7fa0c1cf3..7fbe7c798 100644
+--- a/gass/copy/source/globus_gass_copy_glob.c
++++ b/gass/copy/source/globus_gass_copy_glob.c
+@@ -295,7 +295,6 @@ globus_l_gass_copy_glob_expand_file_url(
+ globus_result_t result;
+ int retval;
+ globus_url_t parsed_url;
+- int i;
+ struct stat stat_buf;
+ char unique_id[256];
+ globus_gass_copy_glob_entry_t type;
+@@ -375,9 +374,7 @@ globus_l_gass_copy_glob_expand_file_url(
+ goto error_open;
+ }
+
+- for(i = 0;
+- globus_libc_readdir_r(dir, &dir_entry) == 0 && dir_entry;
+- i++)
++ while(globus_libc_readdir_r(dir, &dir_entry) == 0 && dir_entry)
+ {
+ char path[MAXPATHLEN];
+
+--
+2.54.0
+
diff --git a/globus-gass-copy.spec b/globus-gass-copy.spec
index 07d8fe9..ca64dbf 100644
--- a/globus-gass-copy.spec
+++ b/globus-gass-copy.spec
@@ -1,13 +1,16 @@
Name: globus-gass-copy
%global _name %(tr - _ <<< %{name})
Version: 10.13
-Release: 5%{?dist}
+Release: 6%{?dist}
Summary: Grid Community Toolkit - Globus Gass Copy
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-Build-with-OpenSSL-4.patch
+Patch2: 0003-Fix-compiler-and-doxygen-warnings.patch
BuildRequires: make
BuildRequires: gcc
@@ -95,6 +98,9 @@ Globus Gass Copy Documentation Files
%prep
%setup -q -n %{_name}-%{version}
+%patch -P0 -p4
+%patch -P1 -p4
+%patch -P2 -p4
%build
# Reduce overlinking
@@ -151,6 +157,10 @@ GLOBUS_HOSTNAME=localhost %make_build check
%license GLOBUS_LICENSE
%changelog
+* Sun Jun 14 2026 Mattias Ellert <mattias.ellert@physics.uu.se> - 10.13-6
+- Compile with OpenSSL 4
+- Fix compiler and doxygen warnings
+
* Fri Jan 16 2026 Fedora Release Engineering <releng@fedoraproject.org> - 10.13-5
- 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:46 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:46 [rpms/globus-gass-copy] rawhide: Compile with OpenSSL 4 Mattias Ellert
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox