public inbox for git-commits@fedoraproject.org
help / color / mirror / Atom feed
From: Mattias Ellert <mattias.ellert@physics.uu.se>
To: git-commits@fedoraproject.org
Subject: [rpms/globus-ftp-control] rawhide: Fix compiler warnings
Date: Sun, 14 Jun 2026 08:46:05 GMT [thread overview]
Message-ID: <178142676544.1.2775375303281980534.rpms-globus-ftp-control-810997f54f4a@fedoraproject.org> (raw)
A new commit has been pushed.
Repo : rpms/globus-ftp-control
Branch : rawhide
Commit : 810997f54f4a18473f998240938d838d9eb6ca5a
Author : Mattias Ellert <mattias.ellert@physics.uu.se>
Date : 2026-06-14T10:39:13+02:00
Stats : +5957/-1 in 3 file(s)
URL : https://src.fedoraproject.org/rpms/globus-ftp-control/c/810997f54f4a18473f998240938d838d9eb6ca5a?branch=rawhide
Log:
Fix compiler warnings
---
diff --git a/0001-Untabify-and-remove-trailing-white-space.patch b/0001-Untabify-and-remove-trailing-white-space.patch
new file mode 100644
index 0000000..4e29169
--- /dev/null
+++ b/0001-Untabify-and-remove-trailing-white-space.patch
@@ -0,0 +1,5583 @@
+From 3ccdaa0236230bbcbcbf339e7dfdfaf23c10bd6f Mon Sep 17 00:00:00 2001
+From: Mattias Ellert <mattias.ellert@physics.uu.se>
+Date: Wed, 20 May 2026 00:15:37 +0200
+Subject: [PATCH 1/2] Untabify and remove trailing white-space
+
+---
+ .../control/source/globus_ftp_control_data.c | 868 +++++++--------
+ .../source/globus_ftp_control_server.c | 992 +++++++++---------
+ gridftp/control/source/test/connect_test.c | 16 +-
+ gridftp/control/source/test/data_test.c | 120 +--
+ .../source/test/globus_ftp_control_test.c | 52 +-
+ gridftp/control/source/test/test_server.c | 4 +-
+ 6 files changed, 1026 insertions(+), 1026 deletions(-)
+
+diff --git a/gridftp/control/source/globus_ftp_control_data.c b/gridftp/control/source/globus_ftp_control_data.c
+index 68ddee325..619aa4810 100644
+--- a/gridftp/control/source/globus_ftp_control_data.c
++++ b/gridftp/control/source/globus_ftp_control_data.c
+@@ -192,7 +192,7 @@ typedef struct globus_i_ftp_dc_transfer_handle_s
+ globus_mutex_t * mutex;
+ globus_i_ftp_dc_handle_t * whos_my_daddy;
+ struct globus_ftp_control_handle_s * control_handle;
+-
++
+ globus_mutex_t order_mutex;
+ globus_bool_t order_data;
+ int order_ctr;
+@@ -301,7 +301,7 @@ globus_l_ftp_control_data_stream_connect_direction(
+
+ globus_result_t
+ globus_l_ftp_data_stream_stripe_poll(
+- globus_ftp_data_stripe_t * stripe);
++ globus_ftp_data_stripe_t * stripe);
+
+ globus_result_t
+ globus_l_ftp_data_stripe_poll(
+@@ -672,7 +672,7 @@ globus_i_ftp_control_data_set_netlogger(
+ * else if priority_1 comes before priority_2, return < 0
+ * else return 0
+ */
+-
++
+ static
+ int
+ globus_l_ftp_control_q_compare(
+@@ -682,10 +682,10 @@ globus_l_ftp_control_q_compare(
+ int rc;
+ globus_l_ftp_handle_table_entry_t * entry1;
+ globus_l_ftp_handle_table_entry_t * entry2;
+-
++
+ entry1 = (globus_l_ftp_handle_table_entry_t *) priority_1;
+ entry2 = (globus_l_ftp_handle_table_entry_t *) priority_2;
+-
++
+ if(entry1->offset > entry2->offset || entry1->eof)
+ {
+ rc = 1;
+@@ -766,7 +766,7 @@ globus_i_ftp_control_create_stack(
+ !globus_list_empty(list);
+ list = globus_list_rest(list))
+ {
+- driver_ent =
++ driver_ent =
+ (globus_i_ftp_control_stack_entry_t *) globus_list_first(list);
+
+ result = GLOBUS_SUCCESS;
+@@ -788,13 +788,13 @@ globus_i_ftp_control_create_stack(
+ driver_ent->opts);
+ }
+ }
+-
++
+ return GLOBUS_SUCCESS;
+
+ error:
+ globus_xio_stack_destroy(*stack);
+ return result;
+-
++
+ }
+
+ void
+@@ -807,11 +807,11 @@ globus_i_ftp_control_unload_xio_drivers(
+ {
+ driver_ent = (globus_i_ftp_control_stack_entry_t *)
+ globus_list_first(driver_list);
+-
+-
++
++
+ if(driver_ent->driver_name)
+ {
+- if(strcmp(driver_ent->driver_name, "tcp") != 0 &&
++ if(strcmp(driver_ent->driver_name, "tcp") != 0 &&
+ strcmp(driver_ent->driver_name, "gsi") != 0)
+ {
+ /* globus_xio_driver_unload(driver_ent->driver); */
+@@ -824,11 +824,11 @@ globus_i_ftp_control_unload_xio_drivers(
+ globus_free(driver_ent->opts);
+ }
+ globus_free(driver_ent);
+-
++
+ globus_list_remove(&driver_list, driver_list);
+ }
+ }
+-
++
+ globus_result_t
+ globus_i_ftp_control_load_xio_drivers(
+ char * driver_string,
+@@ -856,7 +856,7 @@ globus_i_ftp_control_load_xio_drivers(
+ if(ptr != NULL)
+ {
+ *ptr = '\0';
+- tmp_str = ptr+1;
++ tmp_str = ptr+1;
+ }
+ else
+ {
+@@ -893,7 +893,7 @@ globus_i_ftp_control_load_xio_drivers(
+
+ globus_list_insert(&list, stack_ent);
+ }
+-
++
+ globus_free(driver_str);
+ }
+ else
+@@ -919,7 +919,7 @@ globus_i_ftp_control_load_xio_drivers(
+ globus_list_insert(driver_list, globus_list_first(list));
+ globus_list_remove(&list, list);
+ }
+-
++
+ return GLOBUS_SUCCESS;
+
+ error_load:
+@@ -1049,7 +1049,7 @@ globus_list_remove_element(
+ */
+ globus_result_t
+ globus_ftp_control_data_connect_read(
+- globus_ftp_control_handle_t * handle,
++ globus_ftp_control_handle_t * handle,
+ globus_ftp_control_data_connect_callback_t callback,
+ void * user_arg)
+ {
+@@ -1101,7 +1101,7 @@ globus_ftp_control_data_connect_read(
+ globus_object_free(dc_handle->connect_error);
+ dc_handle->connect_error = GLOBUS_NULL;
+ }
+-
++
+ if(dc_handle->mode == GLOBUS_FTP_CONTROL_MODE_STREAM)
+ {
+ if(dc_handle->state != GLOBUS_FTP_DATA_STATE_PORT &&
+@@ -1244,7 +1244,7 @@ globus_ftp_control_data_set_interface(
+ */
+ globus_result_t
+ globus_ftp_control_data_connect_write(
+- globus_ftp_control_handle_t * handle,
++ globus_ftp_control_handle_t * handle,
+ globus_ftp_control_data_connect_callback_t callback,
+ void * user_arg)
+ {
+@@ -1285,7 +1285,7 @@ globus_ftp_control_data_connect_write(
+ globus_object_free(dc_handle->connect_error);
+ dc_handle->connect_error = GLOBUS_NULL;
+ }
+-
++
+ if(dc_handle->mode == GLOBUS_FTP_CONTROL_MODE_STREAM)
+ {
+ if(dc_handle->state != GLOBUS_FTP_DATA_STATE_PORT &&
+@@ -1910,7 +1910,7 @@ globus_ftp_control_data_add_channels(
+ * Sends an EOF message to each stripe along an open data connection.
+ *
+ * @param handle
+- * A pointer to a FTP control handle. This handle contains
++ * A pointer to a FTP control handle. This handle contains
+ * the state for a connection.
+ * @param count[]
+ * This array of integers should contain an integer that
+@@ -2031,7 +2031,7 @@ globus_ftp_control_data_send_eof(
+ : globus_error_construct_string(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+- _FCSL("globus_ftp_control_data_send_eof() handle not in proper state %s"),
++ _FCSL("globus_ftp_control_data_send_eof() handle not in proper state %s"),
+ globus_l_ftp_control_state_to_string(dc_handle->state));
+ }
+ else if(!transfer_handle->eof_registered)
+@@ -2043,13 +2043,13 @@ globus_ftp_control_data_send_eof(
+ }
+ else if(dc_handle->send_eof)
+ {
+-
++
+ err = globus_error_construct_string(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+ _FCSL("globus_ftp_control_data_send_eof() : The current handle is set to automatically send eof. Pass GLOBUS_FALSE to globus_ftp_control_local_send_eof()."));
+ }
+-
++
+ if(err)
+ {
+ globus_mutex_unlock(&dc_handle->mutex);
+@@ -2307,8 +2307,8 @@ globus_ftp_control_data_remove_channels(
+ */
+ globus_result_t
+ globus_ftp_control_data_query_channels(
+- globus_ftp_control_handle_t * handle,
+- unsigned int * num_channels,
++ globus_ftp_control_handle_t * handle,
++ unsigned int * num_channels,
+ unsigned int stripe_ndx)
+ {
+ globus_i_ftp_dc_handle_t * dc_handle;
+@@ -2397,8 +2397,8 @@ globus_ftp_control_data_query_channels(
+ */
+ globus_result_t
+ globus_ftp_control_data_get_total_data_channels(
+- globus_ftp_control_handle_t * handle,
+- unsigned int * num_channels,
++ globus_ftp_control_handle_t * handle,
++ unsigned int * num_channels,
+ unsigned int stripe_ndx)
+ {
+ globus_i_ftp_dc_handle_t * dc_handle;
+@@ -2478,7 +2478,7 @@ globus_ftp_control_data_get_total_data_channels(
+
+ globus_result_t
+ globus_ftp_control_data_get_remote_hosts(
+- globus_ftp_control_handle_t * handle,
++ globus_ftp_control_handle_t * handle,
+ globus_ftp_control_host_port_t * address,
+ int * addr_count)
+ {
+@@ -2620,7 +2620,7 @@ globus_ftp_control_data_get_remote_hosts(
+ */
+ globus_result_t
+ globus_ftp_control_local_send_eof(
+- globus_ftp_control_handle_t * handle,
++ globus_ftp_control_handle_t * handle,
+ globus_bool_t send_eof)
+ {
+ globus_i_ftp_dc_handle_t * dc_handle;
+@@ -2666,8 +2666,8 @@ globus_ftp_control_local_send_eof(
+
+ globus_result_t
+ globus_ftp_control_get_parallelism(
+- globus_ftp_control_handle_t * handle,
+- globus_ftp_control_parallelism_t * parallelism)
++ globus_ftp_control_handle_t * handle,
++ globus_ftp_control_parallelism_t * parallelism)
+ {
+ globus_i_ftp_dc_handle_t * dc_handle;
+ globus_object_t * err;
+@@ -2736,8 +2736,8 @@ globus_ftp_control_get_parallelism(
+ */
+ globus_result_t
+ globus_ftp_control_local_parallelism(
+- globus_ftp_control_handle_t * handle,
+- globus_ftp_control_parallelism_t * parallelism)
++ globus_ftp_control_handle_t * handle,
++ globus_ftp_control_parallelism_t * parallelism)
+ {
+ int ctr;
+ globus_ftp_data_stripe_t * stripe;
+@@ -2824,7 +2824,7 @@ globus_ftp_control_local_parallelism(
+ */
+ globus_result_t
+ globus_ftp_control_local_pasv(
+- globus_ftp_control_handle_t * handle,
++ globus_ftp_control_handle_t * handle,
+ globus_ftp_control_host_port_t * address)
+ {
+ globus_result_t result = GLOBUS_SUCCESS;
+@@ -2886,7 +2886,7 @@ globus_ftp_control_local_pasv(
+ return globus_error_put(globus_error_construct_string(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+- _FCSL("globus_ftp_control_local_pasv(): Handle not in the proper state %s."),
++ _FCSL("globus_ftp_control_local_pasv(): Handle not in the proper state %s."),
+ globus_l_ftp_control_state_to_string(dc_handle->state)));
+ }
+
+@@ -2900,13 +2900,13 @@ globus_ftp_control_local_pasv(
+ address,
+ 1);
+ stripe = &dc_handle->transfer_handle->stripes[0];
+-
++
+ result = globus_io_tcp_create_listener(
+ &address->port,
+ -1,
+ &dc_handle->io_attr,
+ &stripe->listener_handle);
+-
++
+ if(result == GLOBUS_SUCCESS)
+ {
+ dc_handle->transfer_handle->ref++;
+@@ -2920,7 +2920,7 @@ globus_ftp_control_local_pasv(
+ {
+ unsigned short p;
+ char * dataip;
+-
++
+ if((dataip = getenv("GLOBUS_FTP_CLIENT_DATA_IP")) != NULL)
+ {
+ result = globus_libc_contact_string_to_ints(
+@@ -2931,7 +2931,7 @@ globus_ftp_control_local_pasv(
+ }
+ }
+ else
+- {
++ {
+ res = globus_io_tcp_get_local_address_ex(
+ &handle->cc_handle.io_handle,
+ address->host,
+@@ -2941,12 +2941,12 @@ globus_ftp_control_local_pasv(
+ {
+ char * cs;
+ globus_sockaddr_t addr;
+-
++
+ GlobusLibcSockaddrSetFamily(addr, AF_INET);
+ GlobusLibcSockaddrSetPort(addr, address->port);
+ result = globus_libc_addr_to_contact_string(
+ &addr,
+- GLOBUS_LIBC_ADDR_LOCAL |
++ GLOBUS_LIBC_ADDR_LOCAL |
+ GLOBUS_LIBC_ADDR_NUMERIC |
+ GLOBUS_LIBC_ADDR_IPV4,
+ &cs);
+@@ -2964,7 +2964,7 @@ globus_ftp_control_local_pasv(
+ }
+ }
+ }
+-
++
+ dc_handle->state = GLOBUS_FTP_DATA_STATE_PASV;
+ }
+ }
+@@ -3021,7 +3021,7 @@ globus_ftp_control_local_spas(
+ */
+ globus_result_t
+ globus_ftp_control_local_port(
+- globus_ftp_control_handle_t * handle,
++ globus_ftp_control_handle_t * handle,
+ globus_ftp_control_host_port_t * address)
+ {
+ globus_result_t result = GLOBUS_SUCCESS;
+@@ -3079,7 +3079,7 @@ globus_ftp_control_local_port(
+ return globus_error_put(globus_error_construct_string(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+- _FCSL("globus_ftp_control_local_port(): Handle not in the proper state %s."),
++ _FCSL("globus_ftp_control_local_port(): Handle not in the proper state %s."),
+ globus_l_ftp_control_state_to_string(dc_handle->state)));
+ }
+
+@@ -3103,7 +3103,7 @@ globus_ftp_control_local_port(
+
+ globus_result_t
+ globus_ftp_control_get_spor(
+- globus_ftp_control_handle_t * handle,
++ globus_ftp_control_handle_t * handle,
+ globus_ftp_control_host_port_t addresses[],
+ unsigned int * num_addresses)
+ {
+@@ -3201,9 +3201,9 @@ globus_ftp_control_get_spor(
+ */
+ globus_result_t
+ globus_ftp_control_local_spor(
+- globus_ftp_control_handle_t * handle,
+- globus_ftp_control_host_port_t addresses[],
+- unsigned int num_addresses)
++ globus_ftp_control_handle_t * handle,
++ globus_ftp_control_host_port_t addresses[],
++ unsigned int num_addresses)
+ {
+ globus_i_ftp_dc_handle_t * dc_handle;
+ globus_object_t * err;
+@@ -3399,7 +3399,7 @@ globus_ftp_control_get_type(
+
+ globus_result_t
+ globus_ftp_control_get_mode(
+- globus_ftp_control_handle_t * handle,
++ globus_ftp_control_handle_t * handle,
+ globus_ftp_control_mode_t * mode)
+ {
+ globus_i_ftp_dc_handle_t * dc_handle;
+@@ -3462,7 +3462,7 @@ globus_ftp_control_get_mode(
+ */
+ globus_result_t
+ globus_ftp_control_local_mode(
+- globus_ftp_control_handle_t * handle,
++ globus_ftp_control_handle_t * handle,
+ globus_ftp_control_mode_t mode)
+ {
+ globus_i_ftp_dc_handle_t * dc_handle;
+@@ -3532,7 +3532,7 @@ globus_ftp_control_local_mode(
+ * @param starting_offset
+ * The starting offset to expect. May not be 0 for restarted transfers.
+ *
+- * Note that this may result in slower transfers, or, if
++ * Note that this may result in slower transfers, or, if
+ * the data arrives far out of order, failed transfers.
+ */
+ globus_result_t
+@@ -3584,8 +3584,8 @@ globus_ftp_control_set_force_order(
+ globus_mutex_lock(&dc_handle->mutex);
+ {
+ dc_handle->transfer_handle->order_data = order_data;
+- dc_handle->transfer_handle->order_next_offset = starting_offset;
+- dc_handle->transfer_handle->order_next_offset_passed = starting_offset;
++ dc_handle->transfer_handle->order_next_offset = starting_offset;
++ dc_handle->transfer_handle->order_next_offset_passed = starting_offset;
+ }
+ globus_mutex_unlock(&dc_handle->mutex);
+
+@@ -3609,13 +3609,13 @@ globus_ftp_control_set_force_order(
+ */
+ globus_result_t
+ globus_ftp_control_local_tcp_buffer(
+- globus_ftp_control_handle_t * handle,
++ globus_ftp_control_handle_t * handle,
+ globus_ftp_control_tcpbuffer_t * tcp_buffer)
+ {
+ globus_i_ftp_dc_handle_t * dc_handle;
+ globus_object_t * err;
+ static char * myname=
+- "globus_ftp_control_local_tcp_buffer";
++ "globus_ftp_control_local_tcp_buffer";
+
+ /*
+ * error checking
+@@ -3645,21 +3645,21 @@ globus_ftp_control_local_tcp_buffer(
+
+ if(tcp_buffer->mode != GLOBUS_FTP_CONTROL_TCPBUFFER_FIXED)
+ {
+- err = globus_error_construct_string(
+- GLOBUS_FTP_CONTROL_MODULE,
+- GLOBUS_NULL,
+- _FCSL("globus_ftp_control_local_tcp_buffer(): buffer setting mode not supported"));
+- return globus_error_put(err);
++ err = globus_error_construct_string(
++ GLOBUS_FTP_CONTROL_MODULE,
++ GLOBUS_NULL,
++ _FCSL("globus_ftp_control_local_tcp_buffer(): buffer setting mode not supported"));
++ return globus_error_put(err);
+ }
+
+
+ if( 0 > tcp_buffer->fixed.size )
+ {
+- err = globus_error_construct_string(
+- GLOBUS_FTP_CONTROL_MODULE,
+- GLOBUS_NULL,
+- _FCSL("globus_ftp_control_local_tcp_buffer(): buffer size must be greater than 0"));
+- return globus_error_put(err);
++ err = globus_error_construct_string(
++ GLOBUS_FTP_CONTROL_MODULE,
++ GLOBUS_NULL,
++ _FCSL("globus_ftp_control_local_tcp_buffer(): buffer size must be greater than 0"));
++ return globus_error_put(err);
+ }
+
+ dc_handle = &handle->dc_handle;
+@@ -3667,15 +3667,15 @@ globus_ftp_control_local_tcp_buffer(
+ globus_mutex_lock(&dc_handle->mutex);
+ {
+ dc_handle->tcp_buffer_size = tcp_buffer->fixed.size;
+- if(dc_handle->tcp_buffer_size > 0)
+- {
+- globus_io_attr_set_socket_sndbuf(
+- &dc_handle->io_attr,
+- dc_handle->tcp_buffer_size);
+- globus_io_attr_set_socket_rcvbuf(
+- &dc_handle->io_attr,
+- dc_handle->tcp_buffer_size);
+- }
++ if(dc_handle->tcp_buffer_size > 0)
++ {
++ globus_io_attr_set_socket_sndbuf(
++ &dc_handle->io_attr,
++ dc_handle->tcp_buffer_size);
++ globus_io_attr_set_socket_rcvbuf(
++ &dc_handle->io_attr,
++ dc_handle->tcp_buffer_size);
++ }
+ }
+ globus_mutex_unlock(&dc_handle->mutex);
+
+@@ -3694,7 +3694,7 @@ globus_ftp_control_data_get_socket_buf(
+ globus_ftp_data_stripe_t * stripes;
+ globus_i_ftp_dc_handle_t * dc_handle;
+ static char * my_name =
+- "globus_ftp_control_data_get_socket_buf";
++ "globus_ftp_control_data_get_socket_buf";
+
+ if(handle == NULL)
+ {
+@@ -3768,7 +3768,7 @@ globus_ftp_control_data_get_socket_buf(
+ my_name);
+ return globus_error_put(err);
+ }
+- res = globus_io_handle_get_socket_buf(
++ res = globus_io_handle_get_socket_buf(
+ &data_conn->io_handle,
+ rcvbuf,
+ sndbuf);
+@@ -3856,7 +3856,7 @@ globus_ftp_control_data_get_retransmit_count(
+ }
+
+ tcp_driver = globus_io_compat_get_tcp_driver();
+-
++
+ for(ctr = 0; ctr < transfer_handle->stripe_count; ctr++)
+ {
+ stripe = &transfer_handle->stripes[ctr];
+@@ -3895,7 +3895,7 @@ globus_ftp_control_data_get_retransmit_count(
+ {
+ struct tcp_info tcpinfo;
+ socklen_t len;
+-
++
+ len = sizeof(tcpinfo);
+ res = globus_xio_system_socket_getsockopt(
+ socket, IPPROTO_TCP, TCP_INFO, (void *) &tcpinfo, &len);
+@@ -3904,7 +3904,7 @@ globus_ftp_control_data_get_retransmit_count(
+ globus_mutex_unlock(&dc_handle->mutex);
+ return res;
+ }
+-
++
+ count = tcpinfo.tcpi_total_retrans;
+ }
+ #endif
+@@ -3948,13 +3948,13 @@ globus_ftp_control_data_get_retransmit_count(
+ * @param delegated_credential_handle */
+ globus_result_t
+ globus_ftp_control_local_dcau(
+- globus_ftp_control_handle_t * handle,
++ globus_ftp_control_handle_t * handle,
+ const globus_ftp_control_dcau_t * dcau,
+ gss_cred_id_t delegated_credential_handle)
+ {
+ globus_i_ftp_dc_handle_t * dc_handle;
+ static char * myname=
+- "globus_ftp_control_local_dcau";
++ "globus_ftp_control_local_dcau";
+ globus_object_t * err;
+
+ /*
+@@ -3975,9 +3975,9 @@ globus_ftp_control_local_dcau(
+ dcau->mode != GLOBUS_FTP_CONTROL_DCAU_SUBJECT)
+ {
+ err = globus_error_construct_string(
+- GLOBUS_FTP_CONTROL_MODULE,
+- GLOBUS_NULL,
+- _FCSL("globus_ftp_control_local_dcau: invalid dcau mode"));
++ GLOBUS_FTP_CONTROL_MODULE,
++ GLOBUS_NULL,
++ _FCSL("globus_ftp_control_local_dcau: invalid dcau mode"));
+ return globus_error_put(err);
+ }
+
+@@ -3996,75 +3996,75 @@ globus_ftp_control_local_dcau(
+
+ globus_mutex_lock(&dc_handle->mutex);
+ {
+- if(dc_handle->dcau.mode == GLOBUS_FTP_CONTROL_DCAU_SUBJECT &&
+- dc_handle->dcau.subject.subject != GLOBUS_NULL)
+- {
+- globus_libc_free(dc_handle->dcau.subject.subject);
+- dc_handle->dcau.subject.subject = GLOBUS_NULL;
+- }
+- dc_handle->dcau.mode = dcau->mode;
+- if(dcau->mode == GLOBUS_FTP_CONTROL_DCAU_SUBJECT)
+- {
+- dc_handle->dcau.subject.subject =
+- globus_libc_strdup(dcau->subject.subject);
+- }
+-
+- if(dc_handle->dcau.mode != GLOBUS_FTP_CONTROL_DCAU_NONE)
+- {
+- globus_io_secure_authorization_data_t auth_data;
+- globus_io_secure_authorization_data_initialize(&auth_data);
+-
+- globus_io_attr_set_secure_authentication_mode(
+- &dc_handle->io_attr,
+- GLOBUS_IO_SECURE_AUTHENTICATION_MODE_MUTUAL,
+- delegated_credential_handle);
++ if(dc_handle->dcau.mode == GLOBUS_FTP_CONTROL_DCAU_SUBJECT &&
++ dc_handle->dcau.subject.subject != GLOBUS_NULL)
++ {
++ globus_libc_free(dc_handle->dcau.subject.subject);
++ dc_handle->dcau.subject.subject = GLOBUS_NULL;
++ }
++ dc_handle->dcau.mode = dcau->mode;
++ if(dcau->mode == GLOBUS_FTP_CONTROL_DCAU_SUBJECT)
++ {
++ dc_handle->dcau.subject.subject =
++ globus_libc_strdup(dcau->subject.subject);
++ }
++
++ if(dc_handle->dcau.mode != GLOBUS_FTP_CONTROL_DCAU_NONE)
++ {
++ globus_io_secure_authorization_data_t auth_data;
++ globus_io_secure_authorization_data_initialize(&auth_data);
++
++ globus_io_attr_set_secure_authentication_mode(
++ &dc_handle->io_attr,
++ GLOBUS_IO_SECURE_AUTHENTICATION_MODE_MUTUAL,
++ delegated_credential_handle);
+
+ globus_io_attr_set_secure_proxy_mode(
+ &dc_handle->io_attr,
+- GLOBUS_IO_SECURE_PROXY_MODE_MANY);
+-
+- switch(dc_handle->dcau.mode)
+- {
+- case GLOBUS_FTP_CONTROL_DCAU_SELF:
+- globus_io_attr_set_secure_authorization_mode(
+- &dc_handle->io_attr,
+- GLOBUS_IO_SECURE_AUTHORIZATION_MODE_SELF,
+- &auth_data);
+- break;
+-
+- case GLOBUS_FTP_CONTROL_DCAU_SUBJECT:
+- globus_io_secure_authorization_data_set_identity(
+- &auth_data,
+- dc_handle->dcau.subject.subject);
+- globus_io_attr_set_secure_authorization_mode(
+- &dc_handle->io_attr,
+- GLOBUS_IO_SECURE_AUTHORIZATION_MODE_IDENTITY,
+- &auth_data);
+- break;
+- default:
+- break;
+- }
+-
+- globus_io_secure_authorization_data_destroy(&auth_data);
+- }
+- else
+- {
+- dc_handle->protection = GLOBUS_FTP_CONTROL_PROTECTION_CLEAR;
+-
+- globus_io_attr_set_secure_channel_mode(
+- &dc_handle->io_attr,
+- GLOBUS_IO_SECURE_CHANNEL_MODE_CLEAR);
+-
+- globus_io_attr_set_secure_authorization_mode(
+- &dc_handle->io_attr,
+- GLOBUS_IO_SECURE_AUTHORIZATION_MODE_NONE,
+- GLOBUS_NULL);
+-
+- globus_io_attr_set_secure_authentication_mode(
+- &dc_handle->io_attr,
+- GLOBUS_IO_SECURE_AUTHENTICATION_MODE_NONE,
+- GLOBUS_NULL);
+- }
++ GLOBUS_IO_SECURE_PROXY_MODE_MANY);
++
++ switch(dc_handle->dcau.mode)
++ {
++ case GLOBUS_FTP_CONTROL_DCAU_SELF:
++ globus_io_attr_set_secure_authorization_mode(
++ &dc_handle->io_attr,
++ GLOBUS_IO_SECURE_AUTHORIZATION_MODE_SELF,
++ &auth_data);
++ break;
++
++ case GLOBUS_FTP_CONTROL_DCAU_SUBJECT:
++ globus_io_secure_authorization_data_set_identity(
++ &auth_data,
++ dc_handle->dcau.subject.subject);
++ globus_io_attr_set_secure_authorization_mode(
++ &dc_handle->io_attr,
++ GLOBUS_IO_SECURE_AUTHORIZATION_MODE_IDENTITY,
++ &auth_data);
++ break;
++ default:
++ break;
++ }
++
++ globus_io_secure_authorization_data_destroy(&auth_data);
++ }
++ else
++ {
++ dc_handle->protection = GLOBUS_FTP_CONTROL_PROTECTION_CLEAR;
++
++ globus_io_attr_set_secure_channel_mode(
++ &dc_handle->io_attr,
++ GLOBUS_IO_SECURE_CHANNEL_MODE_CLEAR);
++
++ globus_io_attr_set_secure_authorization_mode(
++ &dc_handle->io_attr,
++ GLOBUS_IO_SECURE_AUTHORIZATION_MODE_NONE,
++ GLOBUS_NULL);
++
++ globus_io_attr_set_secure_authentication_mode(
++ &dc_handle->io_attr,
++ GLOBUS_IO_SECURE_AUTHENTICATION_MODE_NONE,
++ GLOBUS_NULL);
++ }
+ }
+ globus_mutex_unlock(&dc_handle->mutex);
+
+@@ -4073,8 +4073,8 @@ globus_ftp_control_local_dcau(
+
+ globus_result_t
+ globus_ftp_control_get_dcau(
+- globus_ftp_control_handle_t * handle,
+- globus_ftp_control_dcau_t * dcau)
++ globus_ftp_control_handle_t * handle,
++ globus_ftp_control_dcau_t * dcau)
+ {
+ globus_i_ftp_dc_handle_t * dc_handle;
+ globus_object_t * err = GLOBUS_SUCCESS;
+@@ -4109,19 +4109,19 @@ globus_ftp_control_get_dcau(
+
+ globus_mutex_lock(&dc_handle->mutex);
+ {
+- dcau->mode = dc_handle->dcau.mode;
+- if(dc_handle->dcau.mode == GLOBUS_FTP_CONTROL_DCAU_SUBJECT)
+- {
+- dcau->subject.subject =
+- globus_libc_strdup(dc_handle->dcau.subject.subject);
+- if(!dcau->subject.subject)
+- {
+- err = globus_error_construct_string(
+- GLOBUS_FTP_CONTROL_MODULE,
+- GLOBUS_NULL,
+- _FCSL("globus_ftp_control_get_dcau: malloc failed"));
+- }
+- }
++ dcau->mode = dc_handle->dcau.mode;
++ if(dc_handle->dcau.mode == GLOBUS_FTP_CONTROL_DCAU_SUBJECT)
++ {
++ dcau->subject.subject =
++ globus_libc_strdup(dc_handle->dcau.subject.subject);
++ if(!dcau->subject.subject)
++ {
++ err = globus_error_construct_string(
++ GLOBUS_FTP_CONTROL_MODULE,
++ GLOBUS_NULL,
++ _FCSL("globus_ftp_control_get_dcau: malloc failed"));
++ }
++ }
+ }
+ globus_mutex_unlock(&dc_handle->mutex);
+
+@@ -4131,12 +4131,12 @@ globus_ftp_control_get_dcau(
+
+ globus_result_t
+ globus_ftp_control_local_prot(
+- globus_ftp_control_handle_t * handle,
+- globus_ftp_control_protection_t protection)
++ globus_ftp_control_handle_t * handle,
++ globus_ftp_control_protection_t protection)
+ {
+ globus_i_ftp_dc_handle_t * dc_handle;
+ static char * myname=
+- "globus_ftp_control_local_prot";
++ "globus_ftp_control_local_prot";
+ globus_object_t * err;
+
+ /*
+@@ -4169,64 +4169,64 @@ globus_ftp_control_local_prot(
+ GlobusFTPControlDataTestMagic(dc_handle);
+ if(dc_handle->dcau.mode == GLOBUS_FTP_CONTROL_DCAU_NONE)
+ {
+- err = globus_error_construct_string(
+- GLOBUS_FTP_CONTROL_MODULE,
+- GLOBUS_NULL,
+- _FCSL("Cannot set protection without using dcau"));
+- return globus_error_put(err);
++ err = globus_error_construct_string(
++ GLOBUS_FTP_CONTROL_MODULE,
++ GLOBUS_NULL,
++ _FCSL("Cannot set protection without using dcau"));
++ return globus_error_put(err);
+ }
+ if(dc_handle->protection == GLOBUS_FTP_CONTROL_PROTECTION_CONFIDENTIAL)
+ {
+- err = globus_error_construct_string(
+- GLOBUS_FTP_CONTROL_MODULE,
+- GLOBUS_NULL,
+- _FCSL("\"Confidential\" protection level not supported with GSSAPI"));
+- return globus_error_put(err);
++ err = globus_error_construct_string(
++ GLOBUS_FTP_CONTROL_MODULE,
++ GLOBUS_NULL,
++ _FCSL("\"Confidential\" protection level not supported with GSSAPI"));
++ return globus_error_put(err);
+ }
+
+ globus_mutex_lock(&dc_handle->mutex);
+ {
+- dc_handle->protection = protection;
+-
+- switch(dc_handle->protection)
+- {
+- case GLOBUS_FTP_CONTROL_PROTECTION_CLEAR:
+- globus_io_attr_set_secure_channel_mode(
+- &dc_handle->io_attr,
+- GLOBUS_IO_SECURE_CHANNEL_MODE_CLEAR);
+- globus_io_attr_set_secure_protection_mode(
+- &dc_handle->io_attr,
+- GLOBUS_IO_SECURE_PROTECTION_MODE_NONE);
+- break;
+-
+- case GLOBUS_FTP_CONTROL_PROTECTION_SAFE:
+- globus_io_attr_set_secure_channel_mode(
+- &dc_handle->io_attr,
+- GLOBUS_IO_SECURE_CHANNEL_MODE_SSL_WRAP);
+- globus_io_attr_set_secure_protection_mode(
+- &dc_handle->io_attr,
+- GLOBUS_IO_SECURE_PROTECTION_MODE_SAFE);
+- break;
+-
+- case GLOBUS_FTP_CONTROL_PROTECTION_PRIVATE:
+- globus_io_attr_set_secure_channel_mode(
+- &dc_handle->io_attr,
+- GLOBUS_IO_SECURE_CHANNEL_MODE_SSL_WRAP);
+- globus_io_attr_set_secure_protection_mode(
+- &dc_handle->io_attr,
+- GLOBUS_IO_SECURE_PROTECTION_MODE_PRIVATE);
+- break;
+-
+- default:
+- globus_assert(
+- dc_handle->protection
+- == GLOBUS_FTP_CONTROL_PROTECTION_CLEAR ||
+- dc_handle->protection
+- == GLOBUS_FTP_CONTROL_PROTECTION_SAFE ||
+- dc_handle->protection
+- == GLOBUS_FTP_CONTROL_PROTECTION_PRIVATE);
+- break;
+- }
++ dc_handle->protection = protection;
++
++ switch(dc_handle->protection)
++ {
++ case GLOBUS_FTP_CONTROL_PROTECTION_CLEAR:
++ globus_io_attr_set_secure_channel_mode(
++ &dc_handle->io_attr,
++ GLOBUS_IO_SECURE_CHANNEL_MODE_CLEAR);
++ globus_io_attr_set_secure_protection_mode(
++ &dc_handle->io_attr,
++ GLOBUS_IO_SECURE_PROTECTION_MODE_NONE);
++ break;
++
++ case GLOBUS_FTP_CONTROL_PROTECTION_SAFE:
++ globus_io_attr_set_secure_channel_mode(
++ &dc_handle->io_attr,
++ GLOBUS_IO_SECURE_CHANNEL_MODE_SSL_WRAP);
++ globus_io_attr_set_secure_protection_mode(
++ &dc_handle->io_attr,
++ GLOBUS_IO_SECURE_PROTECTION_MODE_SAFE);
++ break;
++
++ case GLOBUS_FTP_CONTROL_PROTECTION_PRIVATE:
++ globus_io_attr_set_secure_channel_mode(
++ &dc_handle->io_attr,
++ GLOBUS_IO_SECURE_CHANNEL_MODE_SSL_WRAP);
++ globus_io_attr_set_secure_protection_mode(
++ &dc_handle->io_attr,
++ GLOBUS_IO_SECURE_PROTECTION_MODE_PRIVATE);
++ break;
++
++ default:
++ globus_assert(
++ dc_handle->protection
++ == GLOBUS_FTP_CONTROL_PROTECTION_CLEAR ||
++ dc_handle->protection
++ == GLOBUS_FTP_CONTROL_PROTECTION_SAFE ||
++ dc_handle->protection
++ == GLOBUS_FTP_CONTROL_PROTECTION_PRIVATE);
++ break;
++ }
+ }
+ globus_mutex_unlock(&dc_handle->mutex);
+
+@@ -4236,8 +4236,8 @@ globus_ftp_control_local_prot(
+
+ globus_result_t
+ globus_ftp_control_get_prot(
+- globus_ftp_control_handle_t * handle,
+- globus_ftp_control_protection_t * protection)
++ globus_ftp_control_handle_t * handle,
++ globus_ftp_control_protection_t * protection)
+ {
+ globus_i_ftp_dc_handle_t * dc_handle;
+ globus_object_t * err = GLOBUS_SUCCESS;
+@@ -4271,7 +4271,7 @@ globus_ftp_control_get_prot(
+
+ globus_mutex_lock(&dc_handle->mutex);
+ {
+- *protection = dc_handle->protection;
++ *protection = dc_handle->protection;
+ }
+ globus_mutex_unlock(&dc_handle->mutex);
+
+@@ -4297,42 +4297,42 @@ globus_ftp_control_get_prot(
+ */
+ globus_result_t
+ globus_ftp_control_local_pbsz(
+- globus_ftp_control_handle_t * handle,
+- unsigned long bufsize)
++ globus_ftp_control_handle_t * handle,
++ unsigned long bufsize)
+ {
+- globus_object_t * error = GLOBUS_NULL;
++ globus_object_t * error = GLOBUS_NULL;
+
+ if(handle == GLOBUS_NULL)
+ {
+- error = globus_error_construct_string(
+- GLOBUS_FTP_CONTROL_MODULE,
+- GLOBUS_NULL,
+- _FCSL("globus_ftp_control_local_pbsz: Handle argument is NULL"));
+- goto error_exit;
++ error = globus_error_construct_string(
++ GLOBUS_FTP_CONTROL_MODULE,
++ GLOBUS_NULL,
++ _FCSL("globus_ftp_control_local_pbsz: Handle argument is NULL"));
++ goto error_exit;
+ }
+ /* pbsz must be <= 32 bits */
+ if(bufsize != (bufsize & 0xffffffff))
+ {
+- error = globus_error_construct_string(
+- GLOBUS_FTP_CONTROL_MODULE,
+- GLOBUS_NULL,
+- _FCSL("globus_ftp_control_local_pbsz: Invalid buffer size"));
+- goto error_exit;
++ error = globus_error_construct_string(
++ GLOBUS_FTP_CONTROL_MODULE,
++ GLOBUS_NULL,
++ _FCSL("globus_ftp_control_local_pbsz: Invalid buffer size"));
++ goto error_exit;
+ }
+
+ globus_mutex_lock(&(handle->dc_handle.mutex));
+ {
+- if(handle->dc_handle.pbsz != 0UL &&
+- handle->dc_handle.pbsz < bufsize)
+- {
+- error = globus_error_construct_string(
+- GLOBUS_FTP_CONTROL_MODULE,
+- GLOBUS_NULL,
+- _FCSL("globus_ftp_control_local_pbsz: Invalid buffer size"));
++ if(handle->dc_handle.pbsz != 0UL &&
++ handle->dc_handle.pbsz < bufsize)
++ {
++ error = globus_error_construct_string(
++ GLOBUS_FTP_CONTROL_MODULE,
++ GLOBUS_NULL,
++ _FCSL("globus_ftp_control_local_pbsz: Invalid buffer size"));
+
+- goto unlock_exit;
+- }
+- handle->dc_handle.pbsz = bufsize;
++ goto unlock_exit;
++ }
++ handle->dc_handle.pbsz = bufsize;
+ }
+ unlock_exit:
+ globus_mutex_unlock(&handle->dc_handle.mutex);
+@@ -4360,28 +4360,28 @@ error_exit:
+ */
+ globus_result_t
+ globus_ftp_control_get_pbsz(
+- globus_ftp_control_handle_t * handle,
+- unsigned long * bufsize)
++ globus_ftp_control_handle_t * handle,
++ unsigned long * bufsize)
+ {
+ if(handle == GLOBUS_NULL)
+ {
+- return globus_error_put(
+- globus_error_construct_string(
+- GLOBUS_FTP_CONTROL_MODULE,
+- GLOBUS_NULL,
+- _FCSL("globus_ftp_control_local_pbsz: Handle argument is NULL")));
++ return globus_error_put(
++ globus_error_construct_string(
++ GLOBUS_FTP_CONTROL_MODULE,
++ GLOBUS_NULL,
++ _FCSL("globus_ftp_control_local_pbsz: Handle argument is NULL")));
+ }
+ if(bufsize == GLOBUS_NULL)
+ {
+- return globus_error_put(
+- globus_error_construct_string(
+- GLOBUS_FTP_CONTROL_MODULE,
+- GLOBUS_NULL,
+- _FCSL("globus_ftp_control_local_pbsz: bufsize argument is NULL")));
++ return globus_error_put(
++ globus_error_construct_string(
++ GLOBUS_FTP_CONTROL_MODULE,
++ GLOBUS_NULL,
++ _FCSL("globus_ftp_control_local_pbsz: bufsize argument is NULL")));
+ }
+ globus_mutex_lock(&(handle->dc_handle.mutex));
+ {
+- *bufsize = handle->dc_handle.pbsz;
++ *bufsize = handle->dc_handle.pbsz;
+ }
+ globus_mutex_unlock(&(handle->dc_handle.mutex));
+
+@@ -4412,8 +4412,8 @@ globus_ftp_control_get_pbsz(
+ */
+ globus_result_t
+ globus_ftp_control_local_stru(
+- globus_ftp_control_handle_t * handle,
+- globus_ftp_control_structure_t structure)
++ globus_ftp_control_handle_t * handle,
++ globus_ftp_control_structure_t structure)
+ {
+ globus_i_ftp_dc_handle_t * dc_handle;
+ globus_object_t * err;
+@@ -4499,13 +4499,13 @@ globus_ftp_control_local_stru(
+ */
+ globus_result_t
+ globus_ftp_control_data_write(
+- globus_ftp_control_handle_t * handle,
+- globus_byte_t * buffer,
+- globus_size_t length,
+- globus_off_t offset,
+- globus_bool_t eof,
+- globus_ftp_control_data_callback_t callback,
+- void * callback_arg)
++ globus_ftp_control_handle_t * handle,
++ globus_byte_t * buffer,
++ globus_size_t length,
++ globus_off_t offset,
++ globus_bool_t eof,
++ globus_ftp_control_data_callback_t callback,
++ void * callback_arg)
+ {
+ globus_i_ftp_dc_handle_t * dc_handle;
+ globus_result_t result = GLOBUS_SUCCESS;
+@@ -4579,7 +4579,7 @@ globus_ftp_control_data_write(
+ : globus_error_construct_string(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+- _FCSL("globus_ftp_control_data_write(): Handle not in proper state. %s"),
++ _FCSL("globus_ftp_control_data_write(): Handle not in proper state. %s"),
+ globus_l_ftp_control_state_to_string(dc_handle->state));
+ }
+ else if(dc_handle->mode == GLOBUS_FTP_CONTROL_MODE_STREAM)
+@@ -4613,7 +4613,7 @@ globus_ftp_control_data_write(
+ GLOBUS_NULL,
+ _FCSL("globus_ftp_control_data_write(): Handle not in proper state."));
+ }
+-
++
+ if(err)
+ {
+ globus_mutex_unlock(&dc_handle->mutex);
+@@ -4629,7 +4629,7 @@ globus_ftp_control_data_write(
+
+ globus_result_t
+ globus_ftp_control_get_stripe_count(
+- globus_ftp_control_handle_t * handle,
++ globus_ftp_control_handle_t * handle,
+ int * stripe_count)
+ {
+ globus_i_ftp_dc_handle_t * dc_handle;
+@@ -4700,11 +4700,11 @@ globus_ftp_control_get_stripe_count(
+ */
+ globus_result_t
+ globus_ftp_control_data_read(
+- globus_ftp_control_handle_t * handle,
+- globus_byte_t * buffer,
+- globus_size_t max_length,
+- globus_ftp_control_data_callback_t callback,
+- void * callback_arg)
++ globus_ftp_control_handle_t * handle,
++ globus_byte_t * buffer,
++ globus_size_t max_length,
++ globus_ftp_control_data_callback_t callback,
++ void * callback_arg)
+ {
+ globus_i_ftp_dc_handle_t * dc_handle;
+ globus_result_t result = GLOBUS_SUCCESS;
+@@ -4761,7 +4761,7 @@ globus_ftp_control_data_read(
+ globus_mutex_lock(&dc_handle->mutex);
+ {
+ err = GLOBUS_NULL;
+-
++
+ if(dc_handle->transfer_handle == GLOBUS_NULL)
+ {
+ err = dc_handle->connect_error
+@@ -4771,7 +4771,7 @@ globus_ftp_control_data_read(
+ GLOBUS_NULL,
+ _FCSL("Handle not in the proper state:transfer handle == NULL"));
+ }
+- else if(dc_handle->state != GLOBUS_FTP_DATA_STATE_CONNECT_READ &&
++ else if(dc_handle->state != GLOBUS_FTP_DATA_STATE_CONNECT_READ &&
+ (dc_handle->state != GLOBUS_FTP_DATA_STATE_EOF ||
+ dc_handle->transfer_handle->direction != GLOBUS_FTP_DATA_STATE_CONNECT_READ))
+ {
+@@ -4815,7 +4815,7 @@ globus_ftp_control_data_read(
+ GLOBUS_NULL,
+ _FCSL("globus_ftp_control_data_read(): Handle not using correct mode. Possible memory corruption."));
+ }
+-
++
+ if(err)
+ {
+ globus_mutex_unlock(&dc_handle->mutex);
+@@ -4834,11 +4834,11 @@ globus_ftp_control_data_read(
+ */
+ globus_result_t
+ globus_ftp_control_data_read_all(
+- globus_ftp_control_handle_t * handle,
+- globus_byte_t * buffer,
+- globus_size_t length,
++ globus_ftp_control_handle_t * handle,
++ globus_byte_t * buffer,
++ globus_size_t length,
+ globus_ftp_control_data_callback_t callback,
+- void * callback_arg)
++ void * callback_arg)
+ {
+ globus_i_ftp_dc_handle_t * dc_handle;
+ globus_ftp_data_stripe_t * stripe;
+@@ -4901,7 +4901,7 @@ globus_ftp_control_data_read_all(
+ globus_mutex_lock(&dc_handle->mutex);
+ {
+ err = GLOBUS_NULL;
+-
++
+ if(dc_handle->transfer_handle == GLOBUS_NULL)
+ {
+ err = dc_handle->connect_error
+@@ -4928,13 +4928,13 @@ globus_ftp_control_data_read_all(
+ GLOBUS_NULL,
+ _FCSL("globus_ftp_control_data_read_all(): Only one read_all can be registered at a time. You must wait for a callback with eof set to GLOBUS_TRUE before calling read all again."));
+ }
+-
++
+ if(err)
+ {
+ globus_mutex_unlock(&dc_handle->mutex);
+ return globus_error_put(err);
+ }
+-
++
+ transfer_handle->big_buffer = buffer;
+ transfer_handle->big_buffer_length = length;
+ transfer_handle->big_buffer_cb = callback;
+@@ -5121,7 +5121,7 @@ globus_l_ftp_control_data_stream_read_write(
+ globus_ftp_data_stripe_t * stripe;
+ globus_object_t * err;
+ globus_i_ftp_dc_transfer_handle_t * transfer_handle;
+- static char * my_name =
++ static char * my_name =
+ "globus_l_ftp_control_data_stream_read_write";
+
+ if(dc_handle->state == GLOBUS_FTP_DATA_STATE_CLOSING)
+@@ -5304,9 +5304,9 @@ globus_l_ftp_control_data_eb_write(
+ GLOBUS_NULL,
+ GLOBUS_NULL,
+ dc_handle);
+- tmp_ent->callback_table_handle =
++ tmp_ent->callback_table_handle =
+ data_info.callback_table_handle;
+-
++
+ globus_fifo_enqueue(&stripe->command_q,
+ (void *)tmp_ent);
+
+@@ -5667,9 +5667,9 @@ globus_X_ftp_control_local_layout(
+ name);
+ }
+ globus_mutex_unlock(&globus_l_ftp_control_data_mutex);
+-
++
+ globus_free(name);
+-
++
+ if(layout_info == GLOBUS_NULL)
+ {
+ return globus_error_put(globus_error_construct_string(
+@@ -5745,7 +5745,7 @@ globus_X_ftp_control_local_layout(
+ */
+ globus_result_t
+ globus_ftp_control_create_data_info(
+- globus_ftp_control_handle_t * handle,
++ globus_ftp_control_handle_t * handle,
+ globus_ftp_control_data_write_info_t * data_info,
+ globus_byte_t * buffer,
+ globus_size_t length,
+@@ -5844,7 +5844,7 @@ globus_ftp_control_create_data_info(
+ */
+ globus_result_t
+ globus_ftp_control_release_data_info(
+- globus_ftp_control_handle_t * handle,
++ globus_ftp_control_handle_t * handle,
+ globus_ftp_control_data_write_info_t * data_info)
+ {
+ globus_i_ftp_dc_handle_t * dc_handle;
+@@ -5942,7 +5942,7 @@ globus_ftp_control_release_data_info(
+ */
+ globus_result_t
+ globus_ftp_control_data_write_stripe(
+- globus_ftp_control_handle_t * handle,
++ globus_ftp_control_handle_t * handle,
+ globus_byte_t * buffer,
+ globus_size_t length,
+ globus_off_t offset,
+@@ -5997,7 +5997,7 @@ globus_ftp_control_data_write_stripe(
+ _FCSL("Handle not in the proper state"));
+ return globus_error_put(err);
+ }
+-
++
+ res = globus_i_ftp_control_create_data_info(
+ dc_handle,
+ &data_info,
+@@ -6073,7 +6073,7 @@ exit:
+ */
+ globus_result_t
+ globus_X_ftp_control_data_write_stripe(
+- globus_ftp_control_handle_t * handle,
++ globus_ftp_control_handle_t * handle,
+ globus_byte_t * buffer,
+ globus_size_t length,
+ globus_off_t offset,
+@@ -6145,10 +6145,10 @@ globus_X_ftp_control_data_write_stripe(
+ globus_result_t
+ globus_i_ftp_control_data_write_stripe(
+ globus_i_ftp_dc_handle_t * dc_handle,
+- globus_byte_t * buffer,
+- globus_size_t length,
+- globus_off_t offset,
+- globus_bool_t eof,
++ globus_byte_t * buffer,
++ globus_size_t length,
++ globus_off_t offset,
++ globus_bool_t eof,
+ int stripe_ndx,
+ globus_ftp_control_data_write_info_t * data_info)
+ {
+@@ -6366,7 +6366,7 @@ globus_l_ftp_data_stripe_poll(
+ */
+ globus_result_t
+ globus_l_ftp_data_stream_stripe_poll(
+- globus_ftp_data_stripe_t * stripe)
++ globus_ftp_data_stripe_t * stripe)
+ {
+ globus_l_ftp_handle_table_entry_t * entry;
+ globus_ftp_data_connection_t * data_conn;
+@@ -6401,7 +6401,7 @@ globus_l_ftp_data_stream_stripe_poll(
+ entry->buffer,
+ entry->length,
+ &tmp_len);
+-
++
+ if(entry->ascii_buffer)
+ {
+ tmp_buf = entry->ascii_buffer;
+@@ -6688,8 +6688,8 @@ globus_l_ftp_data_eb_poll(
+ }/* end while */
+ }
+ else if(dc_handle->state == GLOBUS_FTP_DATA_STATE_CONNECT_READ
+- || (dc_handle->state == GLOBUS_FTP_DATA_STATE_EOF &&
+- transfer_handle->direction == GLOBUS_FTP_DATA_STATE_CONNECT_READ))
++ || (dc_handle->state == GLOBUS_FTP_DATA_STATE_EOF &&
++ transfer_handle->direction == GLOBUS_FTP_DATA_STATE_CONNECT_READ))
+ {
+ /*
+ * if we are reading a big buffer
+@@ -6768,13 +6768,13 @@ globus_l_ftp_data_eb_poll(
+ globus_fifo_dequeue(&stripe->free_conn_q);
+
+ if(transfer_handle->order_data)
+- {
++ {
+ /* forcing ordered data */
+ checked_order = GLOBUS_TRUE;
+-
++
+ /* find offset we are looking for */
+- while(data_conn->offset !=
+- transfer_handle->order_next_offset &&
++ while(data_conn->offset !=
++ transfer_handle->order_next_offset &&
+ !globus_fifo_empty(&stripe->free_conn_q))
+ {
+ globus_fifo_enqueue(&remaining_conn_q, data_conn);
+@@ -6783,14 +6783,14 @@ globus_l_ftp_data_eb_poll(
+ }
+
+ globus_i_ftp_control_debug_printf(9,
+- (stderr, "w: %"GLOBUS_OFF_T_FORMAT", h: %"GLOBUS_OFF_T_FORMAT", %p\n",
+- transfer_handle->order_next_offset,
++ (stderr, "w: %"GLOBUS_OFF_T_FORMAT", h: %"GLOBUS_OFF_T_FORMAT", %p\n",
++ transfer_handle->order_next_offset,
+ data_conn->offset,
+ (void *) data_conn));
+-
+- /* if this stream has the offset we want,
++
++ /* if this stream has the offset we want,
+ * register the read, otherwise queue up the read */
+- if(data_conn->offset == transfer_handle->order_next_offset)
++ if(data_conn->offset == transfer_handle->order_next_offset)
+ {
+ do_read = GLOBUS_TRUE;
+ transfer_handle->order_ctr = 0;
+@@ -6800,7 +6800,7 @@ globus_l_ftp_data_eb_poll(
+ do_read = GLOBUS_FALSE;
+ done = GLOBUS_TRUE;
+ globus_fifo_enqueue(&remaining_conn_q, data_conn);
+-
++
+ /* offset not available, restore queues */
+ globus_fifo_enqueue(&remaining_command_q, entry);
+ while(!globus_fifo_empty(&stripe->command_q))
+@@ -6852,7 +6852,7 @@ globus_l_ftp_data_eb_poll(
+ globus_l_ftp_eb_read_callback,
+ (void *)entry);
+ globus_assert(res == GLOBUS_SUCCESS);
+-
++
+ transfer_handle->order_next_offset += entry->length;
+ }
+ }
+@@ -6865,12 +6865,12 @@ globus_l_ftp_data_eb_poll(
+ done = GLOBUS_TRUE;
+ }
+ }/* end while */
+- if(dc_handle->state == GLOBUS_FTP_DATA_STATE_CONNECT_READ &&
++ if(dc_handle->state == GLOBUS_FTP_DATA_STATE_CONNECT_READ &&
+ transfer_handle->order_data)
+ {
+ int pending_connections;
+-
+- pending_connections =
++
++ pending_connections =
+ stripe->total_connection_count
+ + stripe->outstanding_connections
+ - globus_fifo_size(&stripe->free_conn_q);
+@@ -6881,7 +6881,7 @@ globus_l_ftp_data_eb_poll(
+ globus_fifo_size(&stripe->free_conn_q),
+ pending_connections));
+ if(pending_connections == 0 && checked_order)
+- {
++ {
+ /* give time for pending incoming connections */
+ if(transfer_handle->order_ctr > stripe->total_connection_count * 2 + 10)
+ {
+@@ -7324,7 +7324,7 @@ globus_l_ftp_control_stripes_destroy(
+ &data_conn->io_handle,
+ globus_l_ftp_io_close_callback,
+ (void *)callback_info);
+-
++
+ if(res != GLOBUS_SUCCESS)
+ {
+ res = globus_callback_register_oneshot(
+@@ -7458,7 +7458,7 @@ globus_l_ftp_control_data_adjust_connection(
+ {
+ data_conn = (globus_ftp_data_connection_t *)
+ globus_fifo_dequeue(&stripe->free_conn_q);
+- globus_list_remove(&stripe->all_conn_list,
++ globus_list_remove(&stripe->all_conn_list,
+ globus_list_search(stripe->all_conn_list, data_conn));
+
+ data_conn->eod = GLOBUS_TRUE;
+@@ -7549,7 +7549,7 @@ globus_l_ftp_control_command_flush_callback(
+ }
+ }
+ globus_mutex_unlock(&dc_handle->mutex);
+-
++
+ if(entry->error)
+ {
+ globus_object_free(entry->error);
+@@ -7606,7 +7606,7 @@ globus_l_ftp_control_command_kickout(
+ dc_handle = entry->dc_handle;
+ GlobusFTPControlDataTestMagic(dc_handle);
+ transfer_handle = entry->transfer_handle;
+-
++
+ if(entry->callback)
+ {
+ entry->callback(
+@@ -7637,7 +7637,7 @@ globus_l_ftp_control_command_kickout(
+ }
+
+ globus_free(entry);
+-
++
+ }
+
+ static
+@@ -7736,7 +7736,7 @@ globus_i_ftp_control_data_cc_init(
+ dc_handle->connect_error = GLOBUS_NULL;
+ globus_io_tcpattr_init(&dc_handle->io_attr);
+ globus_io_attr_set_tcp_nodelay(&dc_handle->io_attr,
+- GLOBUS_TRUE);
++ GLOBUS_TRUE);
+
+ dc_handle->layout_func = GLOBUS_NULL;
+ dc_handle->layout_user_arg = GLOBUS_NULL;
+@@ -7804,7 +7804,7 @@ globus_l_ftp_control_dc_dec_ref(
+ if(dc_handle->close_callback != GLOBUS_NULL &&
+ globus_list_empty(dc_handle->transfer_list))
+ {
+- globus_result_t res;
++ globus_result_t res;
+ GlobusTimeReltimeSet(reltime, 0, 0);
+ res = globus_callback_register_oneshot(
+ GLOBUS_NULL,
+@@ -7832,10 +7832,10 @@ globus_l_ftp_control_dc_dec_ref(
+ globus_priority_q_destroy(&transfer_handle->ordered_buffer_q);
+ globus_handle_table_destroy(&transfer_handle->handle_table);
+ globus_free(transfer_handle->stripes);
+-
+- globus_assert(dc_handle->transfer_handle != transfer_handle &&
++
++ globus_assert(dc_handle->transfer_handle != transfer_handle &&
+ "Destroying a transfer_handle we still have a pointer to");
+-
++
+ globus_free(transfer_handle);
+ globus_cond_signal(&globus_l_ftp_control_data_cond);
+ }
+@@ -7902,7 +7902,7 @@ globus_i_ftp_control_data_cc_destroy(
+ {
+ dc_handle->initialized = GLOBUS_FALSE;
+ res = GLOBUS_SUCCESS;
+- globus_io_tcpattr_destroy(&dc_handle->io_attr);
++ globus_io_tcpattr_destroy(&dc_handle->io_attr);
+ if(dc_handle->nl_io_handle_set)
+ {
+ globus_netlogger_handle_destroy(&dc_handle->nl_io_handle);
+@@ -7920,7 +7920,7 @@ globus_i_ftp_control_data_cc_destroy(
+ {
+ globus_libc_free(dc_handle->dcau.subject.subject);
+ }
+-
++
+ if(dc_handle->connect_error)
+ {
+ globus_object_free(dc_handle->connect_error);
+@@ -8321,9 +8321,9 @@ globus_l_ftp_stream_write_eof_callback(
+ globus_ftp_control_handle_t * control_handle;
+ globus_ftp_data_connection_t * data_conn;
+ globus_byte_t * buffer = GLOBUS_NULL;
+- void * big_buffer_cb_arg;
+- globus_ftp_control_data_callback_t big_buffer_cb = GLOBUS_NULL;
+- globus_byte_t * big_buffer = GLOBUS_NULL;
++ void * big_buffer_cb_arg;
++ globus_ftp_control_data_callback_t big_buffer_cb = GLOBUS_NULL;
++ globus_byte_t * big_buffer = GLOBUS_NULL;
+ globus_bool_t poll;
+
+ entry = (globus_l_ftp_handle_table_entry_t *) arg;
+@@ -8531,7 +8531,7 @@ globus_l_ftp_stream_listen_callback(
+ user_arg = data_conn->user_arg;
+ stripe_ndx = stripe->stripe_ndx;
+ globus_free(callback_info);
+- }
++ }
+
+ /*
+ * remove reference for listener callback
+@@ -8540,7 +8540,7 @@ globus_l_ftp_stream_listen_callback(
+ {
+ dc_handle->connect_error = globus_object_copy(error);
+ }
+-
++
+ poll = !globus_l_ftp_control_dc_dec_ref(transfer_handle);
+ if(poll)
+ {
+@@ -8553,7 +8553,7 @@ globus_l_ftp_stream_listen_callback(
+ if(callback != GLOBUS_NULL)
+ {
+ callback(user_arg, control_handle, stripe_ndx, GLOBUS_FALSE, error);
+-
++
+ /*
+ * if the user wanted a callback we must dec the reference
+ * it had after we call it.
+@@ -8658,9 +8658,9 @@ globus_l_ftp_stream_accept_connect_callback(
+ type,
+ GLOBUS_IO_ERROR_TYPE_IO_CANCELLED))
+ {
+- globus_list_remove_element(
+- &stripe->all_conn_list,
+- data_conn);
++ globus_list_remove_element(
++ &stripe->all_conn_list,
++ data_conn);
+
+ globus_l_ftp_control_stripes_destroy(dc_handle, error);
+ }
+@@ -8698,7 +8698,7 @@ globus_l_ftp_stream_accept_connect_callback(
+ globus_fifo_enqueue(&stripe->free_conn_q, data_conn);
+ stripe->connection_count++;
+ }
+-
++
+ if(error && !dc_handle->connect_error)
+ {
+ dc_handle->connect_error = globus_object_copy(error);
+@@ -8711,12 +8711,12 @@ globus_l_ftp_stream_accept_connect_callback(
+ {
+ callback(user_arg, control_handle, stripe_ndx, GLOBUS_FALSE, error);
+ }
+-
++
+ if(error)
+ {
+ globus_object_free(error);
+ }
+-
++
+ globus_mutex_lock(&dc_handle->mutex);
+ {
+ if(callback != GLOBUS_NULL)
+@@ -9236,11 +9236,11 @@ globus_l_ftp_eb_listen_callback(
+ callback = data_conn->callback;
+ user_arg = data_conn->user_arg;
+ stripe_ndx = stripe->stripe_ndx;
+- }
++ }
+ /*
+ * remove reference for listener callback
+ */
+-
++
+ if(error && !dc_handle->connect_error)
+ {
+ dc_handle->connect_error = globus_object_copy(error);
+@@ -9444,7 +9444,7 @@ globus_l_ftp_eb_accept_callback(
+ }
+ globus_mutex_unlock(&dc_handle->mutex);
+ }
+-
++
+ if(error)
+ {
+ globus_object_free(error);
+@@ -9506,7 +9506,7 @@ globus_l_ftp_eb_read_header_callback(
+ else
+ {
+ if(eb_header->descriptor & GLOBUS_FTP_CONTROL_DATA_DESCRIPTOR_EOD)
+- {
++ {
+ /* set connection state eod and local state eod */
+ data_conn->eod = GLOBUS_TRUE;
+ eod = GLOBUS_TRUE;
+@@ -9552,13 +9552,13 @@ globus_l_ftp_eb_read_header_callback(
+ /*
+ * next assertion happens if the writer breaks
+ * the protocol and sends a CLOSE prior to
+- * an EOD.
++ * an EOD.
+ *
+- * TODO: stop transfer and return error to user
++ * TODO: stop transfer and return error to user
+ */
+ globus_assert(data_conn->reusing || data_conn->eod);
+
+- /*
++ /*
+ * if local eod state is true it means we have not
+ * already preformed the following needed steps so
+ * do them now.
+@@ -9568,7 +9568,7 @@ globus_l_ftp_eb_read_header_callback(
+ stripe->eods_received++;
+ stripe->connection_count--;
+ }
+- /*
++ /*
+ * if not local eod but conn state eod, it means that
+ * that we have added the connection to the free_cache
+ * list and must remove it
+@@ -9581,7 +9581,7 @@ globus_l_ftp_eb_read_header_callback(
+ stripe->free_cache_list, data_conn));
+ }
+
+- /*
++ /*
+ * remove from all list before closing
+ */
+ globus_list_remove_element(
+@@ -9660,10 +9660,10 @@ globus_l_ftp_eb_read_header_callback(
+ else
+ {
+ globus_off_t end_offset;
+- globus_off_t end_buffer;
++ globus_off_t end_buffer;
+
+- end_offset = ((globus_off_t) data_conn->bytes_ready) +
+- data_conn->offset;
++ end_offset = ((globus_off_t) data_conn->bytes_ready) +
++ data_conn->offset;
+ end_buffer = ((globus_off_t)
+ transfer_handle->big_buffer_length);
+
+@@ -9676,7 +9676,7 @@ globus_l_ftp_eb_read_header_callback(
+ error = globus_error_construct_string(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+- _FCSL("too much data has been sent."));
++ _FCSL("too much data has been sent."));
+ globus_l_ftp_control_stripes_destroy(dc_handle, error);
+ }
+ else
+@@ -9719,7 +9719,7 @@ globus_l_ftp_eb_read_header_callback(
+
+ globus_free(eb_header);
+
+-
++
+ if(error != GLOBUS_NULL)
+ {
+ globus_object_free(error);
+@@ -9735,7 +9735,7 @@ globus_l_ftp_data_order_read_cb(
+ globus_i_ftp_dc_transfer_handle_t * transfer_handle;
+ globus_bool_t done = GLOBUS_FALSE;
+ int rc;
+-
++
+ entry = (globus_l_ftp_handle_table_entry_t *) ent;
+ transfer_handle = entry->transfer_handle;
+ dc_handle = entry->dc_handle;
+@@ -9746,18 +9746,18 @@ globus_l_ftp_data_order_read_cb(
+ (void *)entry,
+ (void *)entry);
+ globus_assert(rc == GLOBUS_SUCCESS);
+-
+- while(!done &&
++
++ while(!done &&
+ !globus_priority_q_empty(&transfer_handle->ordered_buffer_q))
+ {
+- entry = (globus_l_ftp_handle_table_entry_t *)
++ entry = (globus_l_ftp_handle_table_entry_t *)
+ globus_priority_q_first(
+ &transfer_handle->ordered_buffer_q);
+ globus_i_ftp_control_debug_printf(9,
+- (stderr, "bw: %"GLOBUS_OFF_T_FORMAT", bh: %"GLOBUS_OFF_T_FORMAT"\n",
++ (stderr, "bw: %"GLOBUS_OFF_T_FORMAT", bh: %"GLOBUS_OFF_T_FORMAT"\n",
+ transfer_handle->order_next_offset_passed,
+ entry->offset));
+-
++
+ if(transfer_handle->order_next_offset_passed == entry->offset)
+ {
+ entry = (globus_l_ftp_handle_table_entry_t *)
+@@ -9831,7 +9831,7 @@ globus_l_ftp_eb_read_callback(
+ transfer_handle = stripe->whos_my_daddy;
+ control_handle = dc_handle->whos_my_daddy;
+ globus_i_ftp_control_debug_printf(9,
+- (stderr, "readcb: %"GLOBUS_OFF_T_FORMAT", %p\n",
++ (stderr, "readcb: %"GLOBUS_OFF_T_FORMAT", %p\n",
+ data_conn->offset,
+ (void *) data_conn));
+
+@@ -9972,7 +9972,7 @@ globus_l_ftp_eb_read_callback(
+ {
+ globus_free(entry->ascii_buffer);
+ }
+-
++
+ if(transfer_handle->order_data)
+ {
+ free_entry = GLOBUS_FALSE;
+@@ -9991,7 +9991,7 @@ globus_l_ftp_eb_read_callback(
+ }
+ }
+ globus_mutex_unlock(&dc_handle->mutex);
+-
++
+ if(free_entry)
+ {
+ if(entry->callback != GLOBUS_NULL)
+@@ -10023,7 +10023,7 @@ globus_l_ftp_eb_read_callback(
+ }
+ }
+ globus_mutex_unlock(&dc_handle->mutex);
+-
++
+ if(error != GLOBUS_NULL)
+ {
+ globus_object_free(error);
+@@ -10184,7 +10184,7 @@ globus_l_ftp_eb_connect_callback(
+ globus_fifo_enqueue(&stripe->free_conn_q, data_conn);
+ }
+ }
+-
++
+ if(error && !dc_handle->connect_error)
+ {
+ dc_handle->connect_error = globus_object_copy(error);
+@@ -10210,12 +10210,12 @@ globus_l_ftp_eb_connect_callback(
+ GLOBUS_TRUE);
+ globus_free(eof_cb_ent);
+ }
+-
++
+ if(error)
+ {
+ globus_object_free(error);
+ }
+-
++
+ globus_mutex_lock(&dc_handle->mutex);
+ {
+ /*
+@@ -10616,11 +10616,11 @@ globus_l_ftp_eb_send_eof_callback(
+
+ globus_mutex_lock(&dc_handle->mutex);
+ {
+- /* in case of error we ended up never calling the user cb, since
+- * we destroy right after this -- save original error now so
++ /* in case of error we ended up never calling the user cb, since
++ * we destroy right after this -- save original error now so
+ * we can check later if we should fire_cb */
+ initial_state = dc_handle->state;
+-
++
+ globus_assert(eof_ent->dc_handle->transfer_handle != NULL);
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -10674,7 +10674,7 @@ globus_l_ftp_eb_send_eof_callback(
+ fire_cb = GLOBUS_TRUE;
+ globus_free(tmp_ent->count);
+ globus_free(tmp_ent);
+- }
++ }
+ else
+ {
+ transfer_handle->send_eof_ent = tmp_ent;
+@@ -10899,7 +10899,7 @@ globus_l_ftp_control_data_encode(
+ globus_off_t in_size)
+ {
+ globus_off_t x;
+- int ind;
++ int ind;
+
+ x = (globus_off_t) in_size;
+
+@@ -10907,74 +10907,74 @@ globus_l_ftp_control_data_encode(
+
+ if(sizeof(globus_off_t) < 8)
+ {
+- buf[ind++] = 0;
++ buf[ind++] = 0;
+ }
+ else
+ {
+- buf[ind++] = (x >> 56) & 0xff;
++ buf[ind++] = (x >> 56) & 0xff;
+ }
+
+ if(sizeof(globus_off_t) < 7)
+ {
+- buf[ind++] = 0;
++ buf[ind++] = 0;
+ }
+ else
+ {
+- buf[ind++] = (x >> 48) & 0xff;
++ buf[ind++] = (x >> 48) & 0xff;
+ }
+
+ if(sizeof(globus_off_t) < 6)
+ {
+- buf[ind++] = 0;
++ buf[ind++] = 0;
+ }
+ else
+ {
+- buf[ind++] = (x >> 40) & 0xff;
++ buf[ind++] = (x >> 40) & 0xff;
+ }
+
+ if(sizeof(globus_off_t) < 5)
+ {
+- buf[ind++] = 0;
++ buf[ind++] = 0;
+ }
+ else
+ {
+- buf[ind++] = (x >> 32) & 0xff;
++ buf[ind++] = (x >> 32) & 0xff;
+ }
+
+ if(sizeof(globus_off_t) < 4)
+ {
+- buf[ind++] = 0;
++ buf[ind++] = 0;
+ }
+ else
+ {
+- buf[ind++] = (x >> 24) & 0xff;
++ buf[ind++] = (x >> 24) & 0xff;
+ }
+
+ if(sizeof(globus_off_t) < 3)
+ {
+- buf[ind++] = 0;
++ buf[ind++] = 0;
+ }
+ else
+ {
+- buf[ind++] = (x >> 16) & 0xff;
++ buf[ind++] = (x >> 16) & 0xff;
+ }
+
+ if(sizeof(globus_off_t) < 2)
+ {
+- buf[ind++] = 0;
++ buf[ind++] = 0;
+ }
+ else
+ {
+- buf[ind++] = (x >> 8) & 0xff;
++ buf[ind++] = (x >> 8) & 0xff;
+ }
+
+ if(sizeof(globus_off_t) < 1)
+ {
+- buf[ind++] = 0;
++ buf[ind++] = 0;
+ }
+ else
+ {
+- buf[ind++] = (x) & 0xff;
++ buf[ind++] = (x) & 0xff;
+ }
+ }
+ /* globus_l_ftp_control_data_encode() */
+@@ -10985,106 +10985,106 @@ globus_l_ftp_control_data_decode(
+ globus_byte_t * buf,
+ globus_off_t * out_size)
+ {
+- globus_off_t x;
+- globus_bool_t overflow;
++ globus_off_t x;
++ globus_bool_t overflow;
+ x = 0;
+
+ overflow = GLOBUS_FALSE;
+
+ if(sizeof(globus_off_t) >= 8)
+ {
+- x += ((globus_off_t) buf[0]) << 56;
++ x += ((globus_off_t) buf[0]) << 56;
+ }
+ else
+ {
+- if(buf[0] != 0)
+- {
+- overflow = GLOBUS_TRUE;
+- }
++ if(buf[0] != 0)
++ {
++ overflow = GLOBUS_TRUE;
++ }
+ }
+
+ if(sizeof(globus_off_t) >= 7)
+ {
+- x += ((globus_off_t) buf[1]) << 48;
++ x += ((globus_off_t) buf[1]) << 48;
+ }
+ else
+ {
+- if(buf[1] != 0)
+- {
+- overflow = GLOBUS_TRUE;
+- }
++ if(buf[1] != 0)
++ {
++ overflow = GLOBUS_TRUE;
++ }
+ }
+
+ if(sizeof(globus_off_t) >= 6)
+ {
+- x += ((globus_off_t) buf[2]) << 40;
++ x += ((globus_off_t) buf[2]) << 40;
+ }
+ else
+ {
+- if(buf[2] != 0)
+- {
+- overflow = GLOBUS_TRUE;
+- }
++ if(buf[2] != 0)
++ {
++ overflow = GLOBUS_TRUE;
++ }
+ }
+
+ if(sizeof(globus_off_t) >= 5)
+ {
+- x += ((globus_off_t) buf[3]) << 32;
++ x += ((globus_off_t) buf[3]) << 32;
+ }
+ else
+ {
+- if(buf[3] != 0)
+- {
+- overflow = GLOBUS_TRUE;
+- }
++ if(buf[3] != 0)
++ {
++ overflow = GLOBUS_TRUE;
++ }
+ }
+
+ if(sizeof(globus_off_t) >= 4)
+ {
+- x += ((globus_off_t) buf[4]) << 24;
++ x += ((globus_off_t) buf[4]) << 24;
+ }
+ else
+ {
+- if(buf[4] != 0)
+- {
+- overflow = GLOBUS_TRUE;
+- }
++ if(buf[4] != 0)
++ {
++ overflow = GLOBUS_TRUE;
++ }
+ }
+
+ if(sizeof(globus_off_t) >= 3)
+ {
+- x += ((globus_off_t) buf[5]) << 16;
++ x += ((globus_off_t) buf[5]) << 16;
+ }
+ else
+ {
+- if(buf[5] != 0)
+- {
+- overflow = GLOBUS_TRUE;
+- }
++ if(buf[5] != 0)
++ {
++ overflow = GLOBUS_TRUE;
++ }
+ }
+
+ if(sizeof(globus_off_t) >= 2)
+ {
+- x += ((globus_off_t) buf[6]) << 8;
++ x += ((globus_off_t) buf[6]) << 8;
+ }
+ else
+ {
+- if(buf[6] != 0)
+- {
+- overflow = GLOBUS_TRUE;
+- }
++ if(buf[6] != 0)
++ {
++ overflow = GLOBUS_TRUE;
++ }
+ }
+
+ if(sizeof(globus_off_t) >= 1)
+ {
+- x += ((globus_off_t) buf[7]);
++ x += ((globus_off_t) buf[7]);
+ }
+ else
+ {
+- if(buf[7] != 0)
+- {
+- overflow = GLOBUS_TRUE;
+- }
++ if(buf[7] != 0)
++ {
++ overflow = GLOBUS_TRUE;
++ }
+ }
+
+ /* should do something with overflow? */
+@@ -11107,7 +11107,7 @@ globus_l_ftp_control_state_to_string(
+ static const char * eof = "EOF";
+ static const char * send_eof = "SEND_EOF";
+ static const char * unknown = "UNKNOWN";
+-
++
+ switch(state)
+ {
+ case GLOBUS_FTP_DATA_STATE_NONE:
+diff --git a/gridftp/control/source/globus_ftp_control_server.c b/gridftp/control/source/globus_ftp_control_server.c
+index 932726005..01547b936 100644
+--- a/gridftp/control/source/globus_ftp_control_server.c
++++ b/gridftp/control/source/globus_ftp_control_server.c
+@@ -45,55 +45,55 @@ typedef struct globus_ftp_l_command_hash_entry_s
+ }
+ globus_ftp_l_command_hash_entry_t;
+
+-static void
++static void
+ globus_l_ftp_control_listen_cb(
+- void * arg,
++ void * arg,
+ globus_io_handle_t * handle,
+ globus_result_t result);
+
+-static void
++static void
+ globus_l_ftp_control_accept_cb(
+- void * arg,
++ void * arg,
+ globus_io_handle_t * handle,
+ globus_result_t result);
+
+-static void
++static void
+ globus_l_ftp_control_stop_server_cb(
+- void * arg,
++ void * arg,
+ globus_io_handle_t * handle,
+ globus_result_t result);
+
+ static void
+ globus_l_ftp_control_read_command_cb(
+- void * arg,
++ void * arg,
+ globus_io_handle_t * handle,
+ globus_result_t result,
+- globus_byte_t * buf,
++ globus_byte_t * buf,
+ globus_size_t nbytes);
+
+-static void
++static void
+ globus_l_ftp_control_send_response_cb(
+- void * arg,
++ void * arg,
+ globus_io_handle_t * handle,
+ globus_result_t result,
+- globus_byte_t * buf,
++ globus_byte_t * buf,
+ globus_size_t nbytes);
+
+-static void
++static void
+ globus_l_ftp_control_auth_write_cb(
+- void * arg,
++ void * arg,
+ globus_io_handle_t * handle,
+ globus_result_t result,
+- globus_byte_t * buf,
++ globus_byte_t * buf,
+ globus_size_t nbytes);
+
+
+-static void
++static void
+ globus_l_ftp_control_auth_read_cb(
+- void * arg,
++ void * arg,
+ globus_io_handle_t * handle,
+ globus_result_t result,
+- globus_byte_t * buf,
++ globus_byte_t * buf,
+ globus_size_t nbytes);
+
+ globus_result_t globus_l_ftp_control_parse_sbuf_cmd(
+@@ -121,7 +121,7 @@ globus_result_t globus_l_ftp_control_parse_mode_cmd(
+ globus_ftp_control_command_t * command);
+
+ globus_result_t globus_l_ftp_control_parse_opts_cmd(
+- globus_ftp_control_command_t * command);
++ globus_ftp_control_command_t * command);
+
+ globus_result_t globus_l_ftp_control_parse_string_arg(
+ globus_ftp_control_command_t * command);
+@@ -131,8 +131,8 @@ globus_result_t globus_l_ftp_control_parse_no_arg(
+
+ #endif
+
+-/*
+- * Hardcoded replies used int the accept/authentication process
++/*
++ * Hardcoded replies used int the accept/authentication process
+ */
+
+ const char * globus_i_ftp_server_220_reply=
+@@ -152,7 +152,7 @@ const char * globus_i_ftp_server_334_reply=
+ * @details
+ * This function will set up (i.e. initialize all mutexes and
+ * variables) a globus ftp server handle. It will also enter the
+- * handle in a list used by the module activation/deactivation functions.
++ * handle in a list used by the module activation/deactivation functions.
+ *
+ * @param handle
+ * The handle to initialize.
+@@ -160,7 +160,7 @@ const char * globus_i_ftp_server_334_reply=
+ * - GLOBUS_SUCCESS
+ * - invalid handle
+ */
+-globus_result_t
++globus_result_t
+ globus_ftp_control_server_handle_init(
+ globus_ftp_control_server_t * handle)
+ {
+@@ -210,7 +210,7 @@ globus_ftp_control_server_handle_init(
+ */
+
+
+-globus_result_t
++globus_result_t
+ globus_ftp_control_server_handle_destroy(
+ globus_ftp_control_server_t * handle)
+ {
+@@ -224,10 +224,10 @@ globus_ftp_control_server_handle_destroy(
+ );
+ }
+
+- if(handle->state ==
++ if(handle->state ==
+ GLOBUS_FTP_CONTROL_SERVER_LISTENING)
+ {
+-
++
+ return globus_error_put(
+ globus_error_construct_string(
+ GLOBUS_FTP_CONTROL_MODULE,
+@@ -235,7 +235,7 @@ globus_ftp_control_server_handle_destroy(
+ _FCSL("globus_ftp_control_server_handle_destroy: handle is still listening"))
+ );
+ }
+-
++
+ globus_mutex_lock(&globus_l_ftp_server_handle_list_mutex);
+ {
+ globus_mutex_destroy(&(handle->mutex));
+@@ -268,7 +268,7 @@ globus_ftp_control_server_handle_destroy(
+ * The callback function called when connection requests
+ * are made.
+ * @param callback_arg
+- * The user argument passed to the callback function when
++ * The user argument passed to the callback function when
+ * connection requests are made.
+ *
+ * @note I'm not providing any mechanism for making sure that this
+@@ -322,7 +322,7 @@ globus_ftp_control_server_listen(
+ * The callback function called when connection requests
+ * are made.
+ * @param callback_arg
+- * The user argument passed to the callback function when
++ * The user argument passed to the callback function when
+ * connection requests are made.
+ *
+ * @note I'm not providing any mechanism for making sure that this
+@@ -402,7 +402,7 @@ globus_ftp_control_server_listen_ex(
+ globus_mutex_unlock(&(server_handle->mutex));
+
+ backlog=-1;
+-
++
+ globus_io_attr_set_socket_oobinline(attr, GLOBUS_TRUE);
+ globus_io_attr_set_tcp_nodelay(attr, GLOBUS_TRUE);
+
+@@ -410,36 +410,36 @@ globus_ftp_control_server_listen_ex(
+ backlog,
+ attr,
+ &server_handle->io_handle);
+-
++
+
+ if(rc != GLOBUS_SUCCESS)
+ {
+ return rc;
+ }
+-
++
+ globus_mutex_lock(&(server_handle->mutex));
+ {
+ server_handle->state=GLOBUS_FTP_CONTROL_SERVER_LISTENING;
+ }
+ globus_mutex_unlock(&(server_handle->mutex));
+-
++
+ rc=globus_io_tcp_register_listen(&server_handle->io_handle,
+ globus_l_ftp_control_listen_cb,
+ (void *) server_handle);
+-
++
+ if(rc != GLOBUS_SUCCESS)
+ {
+ return rc;
+ }
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+ #ifdef GLOBUS_INTERNAL_DOC
+
+ /**
+- * Internal callback for the globus_io_tcp_register_listen function.
+- *
++ * Internal callback for the globus_io_tcp_register_listen function.
++ *
+ * This is a internal callback used with the
+ * globus_io_tcp_register_listen function, which in this library is
+ * used for detecting connections to a listening "server" socket.
+@@ -459,15 +459,15 @@ globus_ftp_control_server_listen_ex(
+ *
+ * @note If a error is detected in this function the user callback is
+ * called with an appropriate error object and the function
+- * returns.
++ * returns.
+ */
+
+ #endif
+
+
+-static void
++static void
+ globus_l_ftp_control_listen_cb(
+- void * arg,
++ void * arg,
+ globus_io_handle_t * handle,
+ globus_result_t result)
+ {
+@@ -490,11 +490,11 @@ globus_l_ftp_control_listen_cb(
+ (server_handle->callback)(server_handle->callback_arg,
+ server_handle,
+ GLOBUS_NULL);
+-
++
+ rc=globus_io_tcp_register_listen(&server_handle->io_handle,
+ globus_l_ftp_control_listen_cb,
+ arg);
+-
++
+ if(rc != GLOBUS_SUCCESS)
+ {
+ error=globus_error_get(rc);
+@@ -516,11 +516,11 @@ globus_l_ftp_control_listen_cb(
+ * @details
+ * This function initializes a command structure based on a null
+ * terminated string representing one line of input from the
+- * client. The command structure is used as a convenience to determine
++ * client. The command structure is used as a convenience to determine
+ * what command the client issued. This function parses a command
+ * string sent by a client and populates the command argument
+ * appropriately. In the GSSAPI case it will also decode and unwrap
+- * the command before parsing it.
++ * the command before parsing it.
+ *
+ * @param command
+ * A pointer to the command structure to be initialized
+@@ -543,7 +543,7 @@ globus_ftp_control_command_init(
+ char * decoded_cmd = GLOBUS_NULL;
+ globus_result_t rc;
+ globus_ftp_l_command_hash_entry_t * command_hash_entry;
+-
++
+ length=strlen(raw_command);
+
+ command->noop.raw_command=
+@@ -569,7 +569,7 @@ globus_ftp_control_command_init(
+ }
+ else
+ {
+- command->noop.raw_command[j]=raw_command[i];
++ command->noop.raw_command[j]=raw_command[i];
+ j++;
+ }
+ }
+@@ -586,7 +586,7 @@ globus_ftp_control_command_init(
+ return rc;
+ }
+ }
+-
++
+ if(decoded_cmd != GLOBUS_NULL)
+ {
+ globus_libc_free(command->noop.raw_command);
+@@ -600,7 +600,7 @@ globus_ftp_control_command_init(
+ sscanf(command->noop.raw_command,"%4s",cmd);
+
+ i=0;
+-
++
+ while(cmd[i] != '\0')
+ {
+ cmd[i]=toupper(cmd[i]);
+@@ -621,7 +621,7 @@ globus_ftp_control_command_init(
+ command->code = GLOBUS_FTP_CONTROL_COMMAND_UNKNOWN;
+ rc = GLOBUS_SUCCESS;
+ }
+-
++
+ return rc;
+ }
+
+@@ -631,7 +631,7 @@ globus_ftp_control_command_init(
+ * @details
+ * This function frees up the memory allocated to the command
+ * argument.
+- *
++ *
+ * @param command
+ * The command structure whose associated memory is to be freed
+ */
+@@ -648,13 +648,13 @@ globus_ftp_control_command_destroy(
+ _FCSL("globus_ftp_control_command_destroy: command argument is NULL"))
+ );
+ }
+-
++
+ globus_libc_free(command->noop.raw_command);
+-
++
+ switch(command->code)
+ {
+ case GLOBUS_FTP_CONTROL_COMMAND_SITE:
+- case GLOBUS_FTP_CONTROL_COMMAND_DELE:
++ case GLOBUS_FTP_CONTROL_COMMAND_DELE:
+ case GLOBUS_FTP_CONTROL_COMMAND_RMD:
+ case GLOBUS_FTP_CONTROL_COMMAND_MKD:
+ case GLOBUS_FTP_CONTROL_COMMAND_NLST:
+@@ -684,7 +684,7 @@ globus_ftp_control_command_destroy(
+ case GLOBUS_FTP_CONTROL_COMMAND_SPOR:
+ {
+ globus_libc_free(command->spor.host_port);
+- break;
++ break;
+ }
+ default:
+ break;
+@@ -697,7 +697,7 @@ globus_ftp_control_command_destroy(
+ * @brief Copy of GridFTP command
+ * @ingroup globus_ftp_control_server
+ * @details
+- * This function should be called when the user needs to make a
++ * This function should be called when the user needs to make a
+ * copy of a command structure.
+ *
+ * @param dest
+@@ -717,7 +717,7 @@ globus_ftp_control_command_copy(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+ _FCSL("globus_ftp_control_command_copy: dest argument is NULL"))
+- );
++ );
+ }
+
+ if(src == GLOBUS_NULL)
+@@ -727,13 +727,13 @@ globus_ftp_control_command_copy(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+ _FCSL("globus_ftp_control_command_copy: src argument is NULL"))
+- );
++ );
+ }
+
+ dest->code=src->code;
+
+ dest->noop.raw_command=globus_libc_strdup(src->noop.raw_command);
+-
++
+ if(dest->noop.raw_command == GLOBUS_NULL)
+ {
+ return globus_error_put(
+@@ -741,14 +741,14 @@ globus_ftp_control_command_copy(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+ _FCSL("globus_ftp_control_command_copy: strdup failed"))
+- );
++ );
+ }
+-
++
+ switch(dest->code)
+ {
+ case GLOBUS_FTP_CONTROL_COMMAND_UNKNOWN:
+ case GLOBUS_FTP_CONTROL_COMMAND_SITE:
+- case GLOBUS_FTP_CONTROL_COMMAND_DELE:
++ case GLOBUS_FTP_CONTROL_COMMAND_DELE:
+ case GLOBUS_FTP_CONTROL_COMMAND_RMD:
+ case GLOBUS_FTP_CONTROL_COMMAND_MKD:
+ case GLOBUS_FTP_CONTROL_COMMAND_NLST:
+@@ -772,12 +772,12 @@ globus_ftp_control_command_copy(
+ case GLOBUS_FTP_CONTROL_COMMAND_QUIT:
+
+ dest->noop.string_arg = GLOBUS_NULL;
+-
++
+ if(src->noop.string_arg != GLOBUS_NULL)
+ {
+ dest->noop.string_arg=
+ globus_libc_strdup(src->noop.string_arg);
+-
++
+ if(dest->noop.string_arg == GLOBUS_NULL)
+ {
+ globus_libc_free(dest->noop.raw_command);
+@@ -786,7 +786,7 @@ globus_ftp_control_command_copy(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+ _FCSL("globus_ftp_control_command_copy: strdup failed"))
+- );
++ );
+ }
+ }
+ break;
+@@ -801,7 +801,7 @@ globus_ftp_control_command_copy(
+ case GLOBUS_FTP_CONTROL_COMMAND_SPOR:
+ dest->spor.num_args=src->spor.num_args;
+ dest->spor.host_port = (globus_ftp_control_host_port_t *)
+- globus_libc_malloc(src->spor.num_args *
++ globus_libc_malloc(src->spor.num_args *
+ sizeof(globus_ftp_control_host_port_t));
+ if(dest->spor.host_port == GLOBUS_NULL)
+ {
+@@ -811,12 +811,12 @@ globus_ftp_control_command_copy(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+ _FCSL("globus_ftp_control_command_copy: malloc failed"))
+- );
++ );
+ }
+-
++
+ memcpy(dest->spor.host_port,
+ src->spor.host_port,
+- src->spor.num_args *
++ src->spor.num_args *
+ sizeof(globus_ftp_control_host_port_t));
+ break;
+ case GLOBUS_FTP_CONTROL_COMMAND_TYPE:
+@@ -840,9 +840,9 @@ globus_ftp_control_command_copy(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+ _FCSL("globus_ftp_control_command_copy: Unknown command"))
+- );
++ );
+ }
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+@@ -851,10 +851,10 @@ globus_ftp_control_command_copy(
+ * @ingroup globus_ftp_control_server
+ * @details
+ * This function stops listening on the given listener object
+- * for client connections. All existing client connections are
++ * for client connections. All existing client connections are
+ * left open.
+ *
+- * @param listener
++ * @param listener
+ * the globus_ftp_control_server_t object that should
+ * no longer listen for connections.
+ * @param callback
+@@ -871,10 +871,10 @@ globus_ftp_control_server_stop(
+ {
+ globus_result_t rc;
+ globus_i_ftp_server_passthru_cb_arg_t * cb_arg;
+-
++
+
+ if(listener == GLOBUS_NULL)
+- {
++ {
+ return globus_error_put(
+ globus_error_construct_string(
+ GLOBUS_FTP_CONTROL_MODULE,
+@@ -892,10 +892,10 @@ globus_ftp_control_server_stop(
+ _FCSL("globus_ftp_control_server_stop: callback argument is NULL"))
+ );
+ }
+-
++
+ globus_mutex_lock(&(listener->mutex));
+ {
+- if(listener->state !=
++ if(listener->state !=
+ GLOBUS_FTP_CONTROL_SERVER_LISTENING)
+ {
+ globus_mutex_unlock(&(listener->mutex));
+@@ -908,7 +908,7 @@ globus_ftp_control_server_stop(
+ cb_arg = (globus_i_ftp_server_passthru_cb_arg_t *)
+ globus_libc_malloc(
+ sizeof(globus_i_ftp_server_passthru_cb_arg_t));
+-
++
+ if(cb_arg == GLOBUS_NULL)
+ {
+ return globus_error_put(
+@@ -931,7 +931,7 @@ globus_ftp_control_server_stop(
+ globus_libc_free(cb_arg);
+ return rc;
+ }
+-
++
+ return GLOBUS_SUCCESS;
+
+ }
+@@ -939,8 +939,8 @@ globus_ftp_control_server_stop(
+ #ifdef GLOBUS_INTERNAL_DOC
+
+ /**
+- * Internal callback for the globus_io_register_close function.
+- *
++ * Internal callback for the globus_io_register_close function.
++ *
+ * This is an internal callback used as part of the
+ * globus_ftp_control_server_stop function. It checks the result of
+ * the close and calls the user callback.
+@@ -952,20 +952,20 @@ globus_ftp_control_server_stop(
+ * The globus_io handle for the connection. In practice this
+ * represents the socket fd for the connection.
+ * @param result
+- * The result of the close operation
++ * The result of the close operation
+ *
+ * @return void
+ *
+ * @note If a error is detected in this function the user callback is
+ * called with an appropriate error object or ftp response and
+- * the function returns.
++ * the function returns.
+ */
+
+ #endif
+
+-static void
++static void
+ globus_l_ftp_control_stop_server_cb(
+- void * arg,
++ void * arg,
+ globus_io_handle_t * handle,
+ globus_result_t result)
+ {
+@@ -973,7 +973,7 @@ globus_l_ftp_control_stop_server_cb(
+ globus_object_t * error;
+
+ cb_arg = (globus_i_ftp_server_passthru_cb_arg_t *) arg;
+-
++
+ if(result != GLOBUS_SUCCESS){
+ error=globus_error_get(result);
+ (cb_arg->callback)(cb_arg->callback_arg,
+@@ -1004,9 +1004,9 @@ globus_l_ftp_control_stop_server_cb(
+ * connection. This function must be called to accept that user
+ * connection request. Once the connection is established or if
+ * a error occurs, the callback function is called.
+- *
++ *
+ * @param listener
+- * The server object that received the connection request.
++ * The server object that received the connection request.
+ * @param handle
+ * The control connection object. This structure will be populated
+ * and passed to the callback when the client is authorized. This
+@@ -1050,12 +1050,12 @@ globus_ftp_control_server_accept(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+ _FCSL("globus_ftp_control_server_accept: listener argument is NULL"))
+- );
++ );
+ }
+
+ globus_mutex_lock(&(listener->mutex));
+ {
+- if(listener->state !=
++ if(listener->state !=
+ GLOBUS_FTP_CONTROL_SERVER_LISTENING)
+ {
+ globus_mutex_unlock(&(listener->mutex));
+@@ -1101,7 +1101,7 @@ globus_ftp_control_server_accept(
+ globus_l_ftp_control_accept_cb,
+ (void *) handle);
+ globus_io_tcpattr_destroy(&listener_attr);
+-
++
+ if(rc != GLOBUS_SUCCESS)
+ {
+ globus_mutex_lock(&(handle->cc_handle.mutex));
+@@ -1130,8 +1130,8 @@ globus_ftp_control_server_accept(
+ #ifdef GLOBUS_INTERNAL_DOC
+
+ /**
+- * Internal callback for the globus_io_register_accept function.
+- *
++ * Internal callback for the globus_io_register_accept function.
++ *
+ * This is an internal callback used as part of the
+ * globus_ftp_control_accept function. It checks the result of
+ * the accept, and sends a initial response to the user.
+@@ -1143,20 +1143,20 @@ globus_ftp_control_server_accept(
+ * The globus_io handle for the connection. In practice this
+ * represents the socket fd for the connection.
+ * @param result
+- * The result of the accept operation
++ * The result of the accept operation
+ *
+ * @return void
+ *
+ * @note If a error is detected in this function the user callback is
+ * called with an appropriate error object or ftp response and
+- * the function returns.
++ * the function returns.
+ */
+
+ #endif
+
+-static void
++static void
+ globus_l_ftp_control_accept_cb(
+- void * arg,
++ void * arg,
+ globus_io_handle_t * handle,
+ globus_result_t result)
+ {
+@@ -1165,7 +1165,7 @@ globus_l_ftp_control_accept_cb(
+ globus_ftp_control_handle_t * c_handle;
+ globus_bool_t call_close_cb = GLOBUS_FALSE;
+
+-
++
+ c_handle=(globus_ftp_control_handle_t *) arg;
+ cc_handle=&(c_handle->cc_handle);
+
+@@ -1198,7 +1198,7 @@ globus_l_ftp_control_accept_cb(
+ globus_mutex_lock(&(cc_handle->mutex));
+ {
+ cc_handle->cb_count--;
+-
++
+ if(!cc_handle->cb_count &&
+ cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
+ {
+@@ -1224,7 +1224,7 @@ globus_l_ftp_control_accept_cb(
+ * globus_ftp_control_server_accept call), this function should be called
+ * to authenticate the client. The caller of this function may specify
+ * certain authentication requirements using the auth_requirements parameter.
+- *
++ *
+ * @param handle
+ * The control connection object. This structure will be populated
+ * and passed to the callback when the client is authorized. This
+@@ -1247,7 +1247,7 @@ globus_l_ftp_control_accept_cb(
+ * have been initialized prior to calling this function.
+ */
+ globus_result_t
+-globus_ftp_control_server_authenticate(
++globus_ftp_control_server_authenticate(
+ globus_ftp_control_handle_t * handle,
+ globus_ftp_control_auth_requirements_t auth_requirements,
+ globus_ftp_control_auth_callback_t callback,
+@@ -1386,11 +1386,11 @@ globus_ftp_control_server_authenticate(
+ }
+ cc_handle->auth_info.auth_gssapi_subject
+ = malloc(subject_buf.length + 1);
+-
++
+ if (cc_handle->auth_info.auth_gssapi_subject == NULL)
+ {
+ gss_release_buffer(&min_stat, &subject_buf);
+-
++
+ error = globus_error_construct_string(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+@@ -1410,7 +1410,7 @@ globus_ftp_control_server_authenticate(
+ rc=globus_io_register_read(&cc_handle->io_handle,
+ cc_handle->read_buffer,
+ GLOBUS_FTP_CONTROL_READ_BUFFER_SIZE,
+- 1,
++ 1,
+ globus_l_ftp_control_auth_read_cb,
+ handle);
+ if(rc != GLOBUS_SUCCESS)
+@@ -1418,11 +1418,11 @@ globus_ftp_control_server_authenticate(
+ error=globus_error_get(rc);
+ goto error_std;
+ }
+-
++
+ return GLOBUS_SUCCESS;
+-
++
+ error_std:
+-
++
+ rc2 = globus_i_ftp_control_auth_info_destroy(
+ &(cc_handle->auth_info));
+ globus_assert(rc2 == GLOBUS_SUCCESS);
+@@ -1430,7 +1430,7 @@ error_std:
+ globus_mutex_lock(&(cc_handle->mutex));
+ {
+ cc_handle->cb_count--;
+-
++
+ if(!cc_handle->cb_count &&
+ cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
+ {
+@@ -1443,15 +1443,15 @@ error_std:
+ {
+ globus_i_ftp_control_call_close_cb(handle);
+ }
+-
++
+ return rc;
+ }
+
+ #ifdef GLOBUS_INTERNAL_DOC
+
+ /**
+- * Internal callback for the globus_io_register_write function.
+- *
++ * Internal callback for the globus_io_register_write function.
++ *
+ * This is an internal callback used as part of the
+ * globus_ftp_control_authenticate function. It checks the result of
+ * the write (which was used to send a response to the client), and
+@@ -1466,23 +1466,23 @@ error_std:
+ * The globus_io handle for the connection. In practice this
+ * represents the socket fd for the connection.
+ * @param result
+- * The result of the write operation
++ * The result of the write operation
+ *
+ * @return void
+ *
+ * @note If a error is detected in this function the user callback is
+ * called with an appropriate error object or ftp response and
+- * the function returns.
++ * the function returns.
+ */
+
+ #endif
+
+-static void
++static void
+ globus_l_ftp_control_auth_write_cb(
+- void * arg,
++ void * arg,
+ globus_io_handle_t * handle,
+ globus_result_t result,
+- globus_byte_t * buf,
++ globus_byte_t * buf,
+ globus_size_t nbytes)
+ {
+ globus_ftp_cc_handle_t * cc_handle;
+@@ -1504,7 +1504,7 @@ globus_l_ftp_control_auth_write_cb(
+ goto error_auth_destroy;
+ }
+
+- if(cc_handle->auth_requirements &
++ if(cc_handle->auth_requirements &
+ GLOBUS_FTP_CONTROL_AUTH_REQ_NONE)
+ {
+ callback=cc_handle->auth_cb;
+@@ -1527,17 +1527,17 @@ globus_l_ftp_control_auth_write_cb(
+ cc_handle->cb_count--;
+
+ if(!cc_handle->cb_count &&
+- cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
+- {
+- call_close_cb = GLOBUS_TRUE;
+- }
++ cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
++ {
++ call_close_cb = GLOBUS_TRUE;
++ }
+ }
+ globus_mutex_unlock(&(cc_handle->mutex));
+
+- if(call_close_cb == GLOBUS_TRUE)
+- {
+- globus_i_ftp_control_call_close_cb(c_handle);
+- }
++ if(call_close_cb == GLOBUS_TRUE)
++ {
++ globus_i_ftp_control_call_close_cb(c_handle);
++ }
+
+ return;
+ }
+@@ -1558,7 +1558,7 @@ globus_l_ftp_control_auth_write_cb(
+ error=globus_error_get(rc);
+ goto error_auth_destroy;
+ }
+-
++
+ return;
+
+ error_auth_destroy:
+@@ -1578,17 +1578,17 @@ error_auth_destroy:
+ cc_handle->cb_count--;
+
+ if(!cc_handle->cb_count &&
+- cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
+- {
+- call_close_cb = GLOBUS_TRUE;
+- }
++ cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
++ {
++ call_close_cb = GLOBUS_TRUE;
++ }
+ }
+ globus_mutex_unlock(&(cc_handle->mutex));
+-
+- if(call_close_cb == GLOBUS_TRUE)
+- {
+- globus_i_ftp_control_call_close_cb(c_handle);
+- }
++
++ if(call_close_cb == GLOBUS_TRUE)
++ {
++ globus_i_ftp_control_call_close_cb(c_handle);
++ }
+
+ return;
+ }
+@@ -1596,8 +1596,8 @@ error_auth_destroy:
+ #ifdef GLOBUS_INTERNAL_DOC
+
+ /**
+- * Internal callback for the globus_io_register_read function.
+- *
++ * Internal callback for the globus_io_register_read function.
++ *
+ * This is an internal callback used as part of the
+ * globus_ftp_control_authenticate function. It checks the result of
+ * the read (which was used to read commands from the client), and
+@@ -1607,7 +1607,7 @@ error_auth_destroy:
+ * is not complete a reply to the received command is sent to then
+ * client using the auth_write callbacks which will continue to read
+ * commands. If no full command was received a new register_read is
+- * called.
++ * called.
+ *
+ * @param arg
+ * The callback argument, which in this case is the control
+@@ -1616,23 +1616,23 @@ error_auth_destroy:
+ * The globus_io handle for the connection. In practice this
+ * represents the socket fd for the connection.
+ * @param result
+- * The result of the accept operation
++ * The result of the accept operation
+ *
+ * @return void
+ *
+ * @note If a error is detected in this function the user callback is
+ * called with an appropriate error object or ftp response and
+- * the function returns.
++ * the function returns.
+ */
+
+ #endif
+
+-static void
++static void
+ globus_l_ftp_control_auth_read_cb(
+- void * arg,
++ void * arg,
+ globus_io_handle_t * handle,
+ globus_result_t result,
+- globus_byte_t * buf,
++ globus_byte_t * buf,
+ globus_size_t nbytes)
+ {
+ globus_ftp_cc_handle_t * cc_handle;
+@@ -1667,7 +1667,7 @@ globus_l_ftp_control_auth_read_cb(
+ error=globus_error_get(result);
+ goto error_auth_destroy;
+ }
+-
++
+ cc_handle->bytes_read += nbytes;
+
+ for(i = 1;i<cc_handle->bytes_read;i++)
+@@ -1687,19 +1687,19 @@ globus_l_ftp_control_auth_read_cb(
+ error=globus_error_get(rc);
+ goto error_auth_destroy;
+ }
+-
++
+ for(j=i+1;j<cc_handle->bytes_read;j++)
+ {
+ cc_handle->read_buffer[j-(i+1)]=
+ cc_handle->read_buffer[j];
+ }
+-
++
+ cc_handle->bytes_read -= (i+1);
+-
++
+ switch(command.code)
+ {
+ case GLOBUS_FTP_CONTROL_COMMAND_AUTH:
+- if(command.auth.type !=
++ if(command.auth.type !=
+ GLOBUS_FTP_CONTROL_AUTH_GSSAPI)
+ {
+ error=globus_error_construct_string(
+@@ -1708,8 +1708,8 @@ globus_l_ftp_control_auth_read_cb(
+ _FCSL("globus_l_ftp_control_auth_read_cb: Authentication mechanism not supported"));
+ goto error_cmd_destroy;
+ }
+-
+- if( !(cc_handle->auth_requirements &
++
++ if( !(cc_handle->auth_requirements &
+ GLOBUS_FTP_CONTROL_AUTH_REQ_GSSAPI))
+ {
+ error=globus_error_construct_string(
+@@ -1718,8 +1718,8 @@ globus_l_ftp_control_auth_read_cb(
+ _FCSL("globus_l_ftp_control_auth_read_cb: GSSAPI authentication not allowed"));
+ goto error_cmd_destroy;
+ }
+-
+- if(cc_handle->auth_info.prev_cmd !=
++
++ if(cc_handle->auth_info.prev_cmd !=
+ GLOBUS_FTP_CONTROL_COMMAND_UNKNOWN)
+ {
+ error=globus_error_construct_string(
+@@ -1728,11 +1728,11 @@ globus_l_ftp_control_auth_read_cb(
+ _FCSL("globus_l_ftp_control_auth_read_cb: AUTH must be the first command in the authentication sequence"));
+ goto error_cmd_destroy;
+ }
+-
++
+ maj_stat=globus_gss_assist_acquire_cred(
+ &min_stat,
+ GSS_C_ACCEPT,
+- &(cc_handle->auth_info.credential_handle));
++ &(cc_handle->auth_info.credential_handle));
+
+ if(maj_stat != GSS_S_COMPLETE)
+ {
+@@ -1740,7 +1740,7 @@ globus_l_ftp_control_auth_read_cb(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+ _FCSL("globus_l_ftp_control_auth_read_cb: globus_gss_assist_acquire_cred failed"));
+- goto error_cmd_destroy;
++ goto error_cmd_destroy;
+ }
+ else
+ {
+@@ -1748,17 +1748,17 @@ globus_l_ftp_control_auth_read_cb(
+ }
+
+ cc_handle->auth_info.prev_cmd=command.code;
+-
++
+ reply=globus_libc_strdup(
+ globus_i_ftp_server_334_reply);
+-
++
+ if(reply == GLOBUS_NULL)
+ {
+ error=globus_error_construct_string(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+ _FCSL("globus_l_ftp_control_auth_read_cb: strdup failed"));
+- goto error_cmd_destroy;
++ goto error_cmd_destroy;
+ }
+
+ rc=globus_io_register_write(
+@@ -1767,20 +1767,20 @@ globus_l_ftp_control_auth_read_cb(
+ (globus_size_t) strlen(reply),
+ globus_l_ftp_control_auth_write_cb,
+ arg);
+-
++
+ if(rc != GLOBUS_SUCCESS)
+ {
+ globus_libc_free(reply);
+ error=globus_error_get(rc);
+ goto error_cmd_destroy;
+ }
+-
++
+ break;
+-
++
+ case GLOBUS_FTP_CONTROL_COMMAND_ADAT:
+- if((cc_handle->auth_info.prev_cmd !=
++ if((cc_handle->auth_info.prev_cmd !=
+ GLOBUS_FTP_CONTROL_COMMAND_AUTH) &&
+- (cc_handle->auth_info.prev_cmd !=
++ (cc_handle->auth_info.prev_cmd !=
+ GLOBUS_FTP_CONTROL_COMMAND_ADAT))
+ {
+ error=globus_error_construct_string(
+@@ -1791,8 +1791,8 @@ globus_l_ftp_control_auth_read_cb(
+ }
+
+ cc_handle->auth_info.prev_cmd=command.code;
+-
+- recv_tok.value=
++
++ recv_tok.value=
+ globus_libc_malloc(
+ (strlen(command.adat.string_arg) + 3) * 6 / 8);
+
+@@ -1804,10 +1804,10 @@ globus_l_ftp_control_auth_read_cb(
+ _FCSL("globus_l_ftp_control_auth_read_cb: malloc failed"));
+ goto error_cmd_destroy;
+ }
+-
++
+ rc=globus_i_ftp_control_radix_decode(
+- (globus_byte_t *) command.adat.string_arg,
+- recv_tok.value,
++ (globus_byte_t *) command.adat.string_arg,
++ recv_tok.value,
+ &length);
+ if(rc != GLOBUS_SUCCESS)
+ {
+@@ -1815,7 +1815,7 @@ globus_l_ftp_control_auth_read_cb(
+ error=globus_error_get(rc);
+ goto error_cmd_destroy;
+ }
+-
++
+ recv_tok.length = length;
+
+ if(cc_handle->auth_info.encrypt)
+@@ -1827,9 +1827,9 @@ globus_l_ftp_control_auth_read_cb(
+ /* context_handle */
+ &(cc_handle->auth_info.auth_gssapi_context),
+ /* verifier_cred_handle */
+- cc_handle->auth_info.credential_handle,
++ cc_handle->auth_info.credential_handle,
+ /* input_token */
+- &recv_tok,
++ &recv_tok,
+ /* channel bindings */
+ GSS_C_NO_CHANNEL_BINDINGS,
+ /* src_name */
+@@ -1840,17 +1840,17 @@ globus_l_ftp_control_auth_read_cb(
+ &send_tok,
+ &ret_flags,
+ /* ignore time_rec */
+- GLOBUS_NULL,
++ GLOBUS_NULL,
+ &(cc_handle->auth_info.delegated_credential_handle)
+ );
+-
++
+ globus_libc_free(recv_tok.value);
+
+ switch(maj_stat)
+ {
+
+ case GSS_S_COMPLETE:
+-
++
+ cc_handle->use_auth = GLOBUS_TRUE;
+ cc_handle->auth_info.authenticated = GLOBUS_TRUE;
+
+@@ -1858,7 +1858,7 @@ globus_l_ftp_control_auth_read_cb(
+ {
+ cc_handle->auth_info.encrypt = GLOBUS_TRUE;
+ }
+-
++
+ maj_stat = gss_display_name(
+ &min_stat,
+ cc_handle->auth_info.target_name,
+@@ -1868,11 +1868,11 @@ globus_l_ftp_control_auth_read_cb(
+ cc_handle->auth_info.auth_gssapi_subject =
+ malloc(sizeof(char)*
+ (subject_buf.length + 1));
+-
++
+ if(cc_handle->auth_info.auth_gssapi_subject == GLOBUS_NULL)
+ {
+ gss_release_buffer(&min_stat, &subject_buf);
+-
++
+ error=globus_error_construct_string(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+@@ -1886,31 +1886,31 @@ globus_l_ftp_control_auth_read_cb(
+
+ cc_handle->auth_info.auth_gssapi_subject[
+ subject_buf.length] = '\0';
+-
++
+ gss_release_buffer(&min_stat, &subject_buf);
+
+- if(cc_handle->auth_requirements &
++ if(cc_handle->auth_requirements &
+ GLOBUS_FTP_CONTROL_AUTH_REQ_USER)
+ {
+ if(send_tok.length == 0)
+- {
++ {
+ reply=globus_libc_strdup(
+ globus_i_ftp_server_235_reply);
+-
++
+ if(reply == GLOBUS_NULL)
+ {
+ error=globus_error_construct_string(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+ _FCSL("globus_l_ftp_control_auth_read_cb: strdup failed"));
+- goto error_cmd_destroy;
++ goto error_cmd_destroy;
+ }
+ }
+ else
+ {
+ reply= (char *) globus_libc_malloc(
+ send_tok.length * 8 / 6 + 16);
+-
++
+ if(reply == GLOBUS_NULL)
+ {
+ gss_release_buffer(&min_stat, &send_tok);
+@@ -1920,16 +1920,16 @@ globus_l_ftp_control_auth_read_cb(
+ _FCSL("globus_l_ftp_control_auth_read_cb: malloc failed"));
+ goto error_cmd_destroy;
+ }
+-
++
+ strcpy(reply,"235 ADAT=");
+-
++
+ length=send_tok.length;
+-
+- rc = globus_i_ftp_control_radix_encode(send_tok.value,
+- (globus_byte_t *) &(reply[9]),
++
++ rc = globus_i_ftp_control_radix_encode(send_tok.value,
++ (globus_byte_t *) &(reply[9]),
+ &length);
+ gss_release_buffer(&min_stat, &send_tok);
+-
++
+ if(rc != GLOBUS_SUCCESS)
+ {
+ globus_libc_free(reply);
+@@ -1940,14 +1940,14 @@ globus_l_ftp_control_auth_read_cb(
+ reply[length+9]='\r';
+ reply[length+10]='\n';
+ }
+-
++
+ rc=globus_io_register_write(
+ handle,
+ (globus_byte_t *) reply,
+ (globus_size_t) strlen(reply),
+ globus_l_ftp_control_auth_write_cb,
+ arg);
+-
++
+ if(rc != GLOBUS_SUCCESS)
+ {
+ globus_libc_free(reply);
+@@ -1963,7 +1963,7 @@ globus_l_ftp_control_auth_read_cb(
+ cc_handle->auth_cb_arg=GLOBUS_NULL;
+ }
+ globus_mutex_unlock(&(cc_handle->mutex));
+-
++
+ (callback)(callback_arg,
+ c_handle,
+ GLOBUS_NULL,
+@@ -1972,26 +1972,26 @@ globus_l_ftp_control_auth_read_cb(
+ globus_mutex_lock(&(cc_handle->mutex));
+ {
+ cc_handle->cb_count--;
+-
++
+ if(!cc_handle->cb_count &&
+- cc_handle->cc_state ==
+- GLOBUS_FTP_CONTROL_CLOSING)
+- {
+- call_close_cb = GLOBUS_TRUE;
+- }
++ cc_handle->cc_state ==
++ GLOBUS_FTP_CONTROL_CLOSING)
++ {
++ call_close_cb = GLOBUS_TRUE;
++ }
+ }
+ globus_mutex_unlock(&(cc_handle->mutex));
+-
+- if(call_close_cb == GLOBUS_TRUE)
+- {
+- globus_i_ftp_control_call_close_cb(c_handle);
+- }
++
++ if(call_close_cb == GLOBUS_TRUE)
++ {
++ globus_i_ftp_control_call_close_cb(c_handle);
++ }
+ }
+ break;
+ case GSS_S_CONTINUE_NEEDED:
+ reply= (char *) globus_libc_malloc(
+ send_tok.length * 8 / 6 + 16);
+-
++
+ if(reply == GLOBUS_NULL)
+ {
+ gss_release_buffer(&min_stat, &send_tok);
+@@ -2001,13 +2001,13 @@ globus_l_ftp_control_auth_read_cb(
+ _FCSL("globus_l_ftp_control_auth_read_cb: malloc failed"));
+ goto error_cmd_destroy;
+ }
+-
++
+ strcpy(reply,"335 ADAT=");
+-
++
+ length=send_tok.length;
+-
+- rc = globus_i_ftp_control_radix_encode(send_tok.value,
+- (globus_byte_t *) &(reply[9]),
++
++ rc = globus_i_ftp_control_radix_encode(send_tok.value,
++ (globus_byte_t *) &(reply[9]),
+ &length);
+ gss_release_buffer(&min_stat, &send_tok);
+
+@@ -2020,7 +2020,7 @@ globus_l_ftp_control_auth_read_cb(
+
+ reply[length+9]='\r';
+ reply[length+10]='\n';
+-
++
+ rc=globus_io_register_write(
+ handle,
+ (globus_byte_t *) reply,
+@@ -2044,9 +2044,9 @@ globus_l_ftp_control_auth_read_cb(
+ }
+ break;
+ case GLOBUS_FTP_CONTROL_COMMAND_USER:
+- if((cc_handle->auth_info.prev_cmd !=
++ if((cc_handle->auth_info.prev_cmd !=
+ GLOBUS_FTP_CONTROL_COMMAND_ADAT) &&
+- (cc_handle->auth_info.prev_cmd !=
++ (cc_handle->auth_info.prev_cmd !=
+ GLOBUS_FTP_CONTROL_COMMAND_UNKNOWN))
+ {
+ error=globus_error_construct_string(
+@@ -2055,10 +2055,10 @@ globus_l_ftp_control_auth_read_cb(
+ _FCSL("globus_l_ftp_control_auth_read_cb: USER must either be preceded by ADAT or be the first command"));
+ goto error_cmd_destroy;
+ }
+-
++
+ cc_handle->auth_info.prev_cmd=command.code;
+
+- if((cc_handle->auth_requirements &
++ if((cc_handle->auth_requirements &
+ GLOBUS_FTP_CONTROL_AUTH_REQ_GSSAPI) &&
+ (cc_handle->use_auth == GLOBUS_FALSE))
+ {
+@@ -2066,9 +2066,9 @@ globus_l_ftp_control_auth_read_cb(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+ _FCSL("globus_l_ftp_control_auth_read_cb: GSSAPI authentication required"));
+- goto error_cmd_destroy;
++ goto error_cmd_destroy;
+ }
+-
++
+ cc_handle->auth_info.user=globus_libc_strdup(
+ command.user.string_arg);
+
+@@ -2080,8 +2080,8 @@ globus_l_ftp_control_auth_read_cb(
+ _FCSL("globus_l_ftp_control_auth_read_cb: strdup failed"));
+ goto error_cmd_destroy;
+ }
+-
+- if(cc_handle->auth_requirements &
++
++ if(cc_handle->auth_requirements &
+ GLOBUS_FTP_CONTROL_AUTH_REQ_USER)
+ {
+
+@@ -2095,7 +2095,7 @@ globus_l_ftp_control_auth_read_cb(
+ cc_handle->auth_cb_arg=GLOBUS_NULL;
+ }
+ globus_mutex_unlock(&(cc_handle->mutex));
+-
++
+ (callback)(callback_arg,
+ c_handle,
+ GLOBUS_NULL,
+@@ -2106,19 +2106,19 @@ globus_l_ftp_control_auth_read_cb(
+ cc_handle->cb_count--;
+
+ if(!cc_handle->cb_count &&
+- cc_handle->cc_state ==
+- GLOBUS_FTP_CONTROL_CLOSING)
+- {
+- call_close_cb = GLOBUS_TRUE;
+- }
++ cc_handle->cc_state ==
++ GLOBUS_FTP_CONTROL_CLOSING)
++ {
++ call_close_cb = GLOBUS_TRUE;
++ }
+ }
+ globus_mutex_unlock(&(cc_handle->mutex));
+
+- if(call_close_cb == GLOBUS_TRUE)
+- {
+- globus_i_ftp_control_call_close_cb(c_handle);
+- }
+-
++ if(call_close_cb == GLOBUS_TRUE)
++ {
++ globus_i_ftp_control_call_close_cb(c_handle);
++ }
++
+ break;
+ }
+
+@@ -2135,8 +2135,8 @@ globus_l_ftp_control_auth_read_cb(
+ reply= globus_libc_strdup(
+ globus_i_ftp_server_332_reply);
+ }
+-
+-
++
++
+ if(reply == GLOBUS_NULL)
+ {
+ error=globus_error_construct_string(
+@@ -2145,14 +2145,14 @@ globus_l_ftp_control_auth_read_cb(
+ _FCSL("globus_l_ftp_control_auth_read_cb: strdup failed"));
+ goto error_cmd_destroy;
+ }
+-
++
+ if(cc_handle->auth_info.authenticated == GLOBUS_TRUE)
+ {
+ rc=globus_i_ftp_control_encode_reply(
+ reply,
+ &encoded_reply,
+ &(cc_handle->auth_info));
+-
++
+ globus_libc_free(reply);
+
+ if(rc != GLOBUS_SUCCESS)
+@@ -2160,10 +2160,10 @@ globus_l_ftp_control_auth_read_cb(
+ error=globus_error_get(rc);
+ goto error_cmd_destroy;
+ }
+-
++
+ reply=encoded_reply;
+ }
+-
++
+
+ rc=globus_io_register_write(
+ handle,
+@@ -2171,14 +2171,14 @@ globus_l_ftp_control_auth_read_cb(
+ (globus_size_t) strlen(reply),
+ globus_l_ftp_control_auth_write_cb,
+ arg);
+-
++
+ if(rc != GLOBUS_SUCCESS)
+ {
+ globus_libc_free(reply);
+ error=globus_error_get(rc);
+ goto error_cmd_destroy;
+ }
+-
++
+ }
+ else
+ {
+@@ -2191,7 +2191,7 @@ globus_l_ftp_control_auth_read_cb(
+ break;
+ case GLOBUS_FTP_CONTROL_COMMAND_PASS:
+
+- if(cc_handle->auth_info.prev_cmd !=
++ if(cc_handle->auth_info.prev_cmd !=
+ GLOBUS_FTP_CONTROL_COMMAND_USER)
+ {
+ error=globus_error_construct_string(
+@@ -2214,8 +2214,8 @@ globus_l_ftp_control_auth_read_cb(
+ _FCSL("globus_l_ftp_control_auth_read_cb: No password given"));
+ goto error_cmd_destroy;
+ }
+-
+- if(!(cc_handle->auth_requirements &
++
++ if(!(cc_handle->auth_requirements &
+ GLOBUS_FTP_CONTROL_AUTH_REQ_ACCT))
+ {
+ globus_mutex_lock(&(cc_handle->mutex));
+@@ -2224,7 +2224,7 @@ globus_l_ftp_control_auth_read_cb(
+ cc_handle->auth_cb_arg=GLOBUS_NULL;
+ }
+ globus_mutex_unlock(&(cc_handle->mutex));
+-
++
+ (callback)(callback_arg,
+ c_handle,
+ GLOBUS_NULL,
+@@ -2233,23 +2233,23 @@ globus_l_ftp_control_auth_read_cb(
+ {
+ cc_handle->cb_count--;
+ if(!cc_handle->cb_count &&
+- cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
+- {
+- call_close_cb = GLOBUS_TRUE;
+- }
++ cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
++ {
++ call_close_cb = GLOBUS_TRUE;
++ }
+ }
+ globus_mutex_unlock(&(cc_handle->mutex));
+-
+- if(call_close_cb == GLOBUS_TRUE)
+- {
+- globus_i_ftp_control_call_close_cb(c_handle);
+- }
++
++ if(call_close_cb == GLOBUS_TRUE)
++ {
++ globus_i_ftp_control_call_close_cb(c_handle);
++ }
+ }
+ else
+ {
+ reply=globus_libc_strdup(
+ globus_i_ftp_server_332_reply);
+-
++
+ if(reply == GLOBUS_NULL)
+ {
+ error=globus_error_construct_string(
+@@ -2258,25 +2258,25 @@ globus_l_ftp_control_auth_read_cb(
+ _FCSL("globus_l_ftp_control_auth_read_cb: strdup failed"));
+ goto error_cmd_destroy;
+ }
+-
++
+ if(cc_handle->auth_info.authenticated == GLOBUS_TRUE)
+ {
+ rc=globus_i_ftp_control_encode_reply(
+ reply,
+ &encoded_reply,
+ &(cc_handle->auth_info));
+-
++
+ globus_libc_free(reply);
+-
++
+ if(rc != GLOBUS_SUCCESS)
+ {
+ error=globus_error_get(rc);
+ goto error_cmd_destroy;
+ }
+-
++
+ reply=encoded_reply;
+ }
+-
++
+ rc=globus_io_register_write(
+ handle,
+ (globus_byte_t *) reply,
+@@ -2293,11 +2293,11 @@ globus_l_ftp_control_auth_read_cb(
+ }
+ break;
+ case GLOBUS_FTP_CONTROL_COMMAND_ACCT:
+- if(((cc_handle->auth_requirements &
++ if(((cc_handle->auth_requirements &
+ GLOBUS_FTP_CONTROL_AUTH_REQ_PASS) &&
+- (cc_handle->auth_info.prev_cmd !=
++ (cc_handle->auth_info.prev_cmd !=
+ GLOBUS_FTP_CONTROL_COMMAND_PASS)) ||
+- (cc_handle->auth_info.prev_cmd !=
++ (cc_handle->auth_info.prev_cmd !=
+ GLOBUS_FTP_CONTROL_COMMAND_USER))
+ {
+ error=globus_error_construct_string(
+@@ -2318,8 +2318,8 @@ globus_l_ftp_control_auth_read_cb(
+ _FCSL("globus_l_ftp_control_auth_read_cb: no account given"));
+ goto error_cmd_destroy;
+ }
+-
+- if(cc_handle->auth_requirements &
++
++ if(cc_handle->auth_requirements &
+ GLOBUS_FTP_CONTROL_AUTH_REQ_ACCT)
+ {
+ globus_mutex_lock(&(cc_handle->mutex));
+@@ -2328,7 +2328,7 @@ globus_l_ftp_control_auth_read_cb(
+ cc_handle->auth_cb_arg=GLOBUS_NULL;
+ }
+ globus_mutex_unlock(&(cc_handle->mutex));
+-
++
+ (callback)(callback_arg,
+ c_handle,
+ GLOBUS_NULL,
+@@ -2338,18 +2338,18 @@ globus_l_ftp_control_auth_read_cb(
+ cc_handle->cb_count--;
+
+ if(!cc_handle->cb_count &&
+- cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
+- {
+- call_close_cb = GLOBUS_TRUE;
+- }
++ cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
++ {
++ call_close_cb = GLOBUS_TRUE;
++ }
+
+ }
+ globus_mutex_unlock(&(cc_handle->mutex));
+
+- if(call_close_cb == GLOBUS_TRUE)
+- {
+- globus_i_ftp_control_call_close_cb(c_handle);
+- }
++ if(call_close_cb == GLOBUS_TRUE)
++ {
++ globus_i_ftp_control_call_close_cb(c_handle);
++ }
+ }
+ else
+ {
+@@ -2367,18 +2367,18 @@ globus_l_ftp_control_auth_read_cb(
+ _FCSL("globus_l_ftp_control_auth_read_cb: Command not part of authentication process"));
+ goto error_cmd_destroy;
+ }
+-
++
+ globus_ftp_control_command_destroy(&command);
+ return;
+ }
+ }
+-
++
+ if(cc_handle->bytes_read == cc_handle->read_buffer_size)
+ {
+ new_buf= (globus_byte_t *) globus_libc_malloc(
+ cc_handle->read_buffer_size +
+ GLOBUS_I_FTP_CONTROL_BUF_INCR);
+-
++
+ if(new_buf == GLOBUS_NULL)
+ {
+ error=globus_error_construct_string(
+@@ -2387,31 +2387,31 @@ globus_l_ftp_control_auth_read_cb(
+ _FCSL("globus_l_ftp_control_auth_read_cb: malloc failed"));
+ goto error_auth_destroy;
+ }
+-
++
+ memcpy(new_buf,
+ cc_handle->read_buffer,
+ cc_handle->bytes_read);
+-
++
+ cc_handle->read_buffer_size += GLOBUS_I_FTP_CONTROL_BUF_INCR;
+ globus_libc_free(cc_handle->read_buffer);
+ cc_handle->read_buffer=new_buf;
+ }
+-
++
+ rc=globus_io_register_read(&(cc_handle->io_handle),
+ &(cc_handle->read_buffer[
+ cc_handle->bytes_read]),
+- cc_handle->read_buffer_size -
++ cc_handle->read_buffer_size -
+ cc_handle->bytes_read,
+ 1,
+ globus_l_ftp_control_auth_read_cb,
+ arg);
+-
++
+ if(rc != GLOBUS_SUCCESS)
+ {
+ error=globus_error_get(rc);
+ goto error_auth_destroy;
+ }
+-
++
+ return;
+
+ error_cmd_destroy:
+@@ -2420,7 +2420,7 @@ error_auth_destroy:
+ rc = globus_i_ftp_control_auth_info_destroy(
+ &(cc_handle->auth_info));
+ globus_assert(rc == GLOBUS_SUCCESS);
+-
++
+ (cc_handle->auth_cb)(cc_handle->auth_cb_arg,
+ c_handle,
+ error,
+@@ -2431,18 +2431,18 @@ error_auth_destroy:
+ {
+ cc_handle->cb_count--;
+ if(!cc_handle->cb_count &&
+- cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
+- {
+- call_close_cb = GLOBUS_TRUE;
+- }
++ cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
++ {
++ call_close_cb = GLOBUS_TRUE;
++ }
+ }
+ globus_mutex_unlock(&(cc_handle->mutex));
+
+- if(call_close_cb == GLOBUS_TRUE)
+- {
+- globus_i_ftp_control_call_close_cb(c_handle);
+- }
+-
++ if(call_close_cb == GLOBUS_TRUE)
++ {
++ globus_i_ftp_control_call_close_cb(c_handle);
++ }
++
+ return;
+ }
+
+@@ -2450,13 +2450,13 @@ error_auth_destroy:
+ * @brief Read GridFTP commands
+ * @ingroup globus_ftp_control_server
+ * @details
+- * This function begins reading control commands on a
++ * This function begins reading control commands on a
+ * globus_ftp_control_handle_t. When a command is read
+ * the callback function is called.
+ *
+ * @param handle
+ * The control connection handle that commands will be read
+- * from. Prior to calling this the function
++ * from. Prior to calling this the function
+ * globus_ftp_control_handle_t must be populated via a
+ * call to globus_ftp_control_accept().
+ * @param callback
+@@ -2507,11 +2507,11 @@ globus_ftp_control_read_commands(
+ }
+ globus_mutex_unlock(&(handle->cc_handle.mutex));
+
+-
++
+ rc=globus_io_register_read(&(handle->cc_handle.io_handle),
+ &(handle->cc_handle.read_buffer[
+ handle->cc_handle.bytes_read]),
+- handle->cc_handle.read_buffer_size -
++ handle->cc_handle.read_buffer_size -
+ handle->cc_handle.bytes_read,
+ 0,
+ globus_l_ftp_control_read_command_cb,
+@@ -2521,40 +2521,40 @@ globus_ftp_control_read_commands(
+ {
+ globus_i_ftp_control_auth_info_destroy(
+ &(handle->cc_handle.auth_info));
+-
++
+ globus_mutex_lock(&(handle->cc_handle.mutex));
+ {
+ handle->cc_handle.cb_count--;
+ if(!handle->cc_handle.cb_count &&
+- handle->cc_handle.cc_state == GLOBUS_FTP_CONTROL_CLOSING)
+- {
+- call_close_cb = GLOBUS_TRUE;
+- }
++ handle->cc_handle.cc_state == GLOBUS_FTP_CONTROL_CLOSING)
++ {
++ call_close_cb = GLOBUS_TRUE;
++ }
+ }
+ globus_mutex_unlock(&(handle->cc_handle.mutex));
+
+- if(call_close_cb == GLOBUS_TRUE)
+- {
+- globus_i_ftp_control_call_close_cb(handle);
+- }
++ if(call_close_cb == GLOBUS_TRUE)
++ {
++ globus_i_ftp_control_call_close_cb(handle);
++ }
+
+ return rc;
+ }
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+ #ifdef GLOBUS_INTERNAL_DOC
+
+ /**
+- * Internal callback for the globus_io_register_read function.
+- *
++ * Internal callback for the globus_io_register_read function.
++ *
+ * This is an internal callback used as part of the
+- * globus_ftp_control_read_commands function. It checks the result of
++ * globus_ftp_control_read_commands function. It checks the result of
+ * the read (which was used to read commands from the client), and
+ * if a full command was received, parses it and returns the resulting
+ * command structure to the user through the user callback. If no full
+- * command was received a new register_read is called.
++ * command was received a new register_read is called.
+ *
+ * @param arg
+ * The callback argument, which in this case is the control
+@@ -2563,23 +2563,23 @@ globus_ftp_control_read_commands(
+ * The globus_io handle for the connection. In practice this
+ * represents the socket fd for the connection.
+ * @param result
+- * The result of the accept operation
++ * The result of the accept operation
+ *
+ * @return void
+ *
+ * @note If a error is detected in this function the user callback is
+ * called with an appropriate error object or ftp response and
+- * the function returns.
++ * the function returns.
+ */
+
+ #endif
+
+ static void
+ globus_l_ftp_control_read_command_cb(
+- void * arg,
++ void * arg,
+ globus_io_handle_t * handle,
+ globus_result_t result,
+- globus_byte_t * buf,
++ globus_byte_t * buf,
+ globus_size_t nbytes)
+ {
+ globus_ftp_cc_handle_t * cc_handle;
+@@ -2602,11 +2602,11 @@ globus_l_ftp_control_read_command_cb(
+ error=globus_error_get(result);
+ goto error_auth_destroy;
+ }
+-
++
+ cc_handle->bytes_read += nbytes;
+
+ last=0;
+-
++
+ for(i = 1;i < cc_handle->bytes_read; i++)
+ {
+ if(cc_handle->read_buffer[i-1] == '\r' &&
+@@ -2624,7 +2624,7 @@ globus_l_ftp_control_read_command_cb(
+ error=globus_error_get(rc);
+ goto error_auth_destroy;
+ }
+-
++
+ (cc_handle->command_cb)(cc_handle->command_cb_arg,
+ c_handle,
+ GLOBUS_NULL,
+@@ -2634,7 +2634,7 @@ globus_l_ftp_control_read_command_cb(
+ last=i+1;
+ }
+ }
+-
++
+ if(last != 0)
+ {
+ for(i=last;i<cc_handle->bytes_read;i++)
+@@ -2642,7 +2642,7 @@ globus_l_ftp_control_read_command_cb(
+ cc_handle->read_buffer[i-last]=
+ cc_handle->read_buffer[i];
+ }
+-
++
+ cc_handle->bytes_read -= last;
+ }
+ else
+@@ -2661,7 +2661,7 @@ globus_l_ftp_control_read_command_cb(
+ _FCSL("globus_l_ftp_control_read_command_cb: malloc failed"));
+ goto error_auth_destroy;
+ }
+-
++
+ memcpy(new_buf,
+ cc_handle->read_buffer,
+ cc_handle->bytes_read);
+@@ -2676,71 +2676,71 @@ globus_l_ftp_control_read_command_cb(
+ globus_mutex_lock(&(cc_handle->mutex));
+ {
+ if(cc_handle->cb_count == 1 &&
+- cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
++ cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
+ {
+ cc_handle->cb_count--;
+- call_close_cb = GLOBUS_TRUE;
++ call_close_cb = GLOBUS_TRUE;
+ }
+- else if(code == GLOBUS_FTP_CONTROL_COMMAND_QUIT)
+- {
++ else if(code == GLOBUS_FTP_CONTROL_COMMAND_QUIT)
++ {
+ cc_handle->cb_count--;
+- }
++ }
+ }
+ globus_mutex_unlock(&(cc_handle->mutex));
+-
+- if(call_close_cb == GLOBUS_TRUE)
+- {
++
++ if(call_close_cb == GLOBUS_TRUE)
++ {
+ globus_i_ftp_control_call_close_cb(c_handle);
+ return;
+- }
+-
++ }
++
+ if(code != GLOBUS_FTP_CONTROL_COMMAND_QUIT)
+ {
+ rc=globus_io_register_read(&(cc_handle->io_handle),
+ &(cc_handle->read_buffer[
+ cc_handle->bytes_read]),
+- cc_handle->read_buffer_size -
++ cc_handle->read_buffer_size -
+ cc_handle->bytes_read,
+ 1,
+ globus_l_ftp_control_read_command_cb,
+ arg);
+-
++
+ if(rc != GLOBUS_SUCCESS)
+ {
+ error=globus_error_get(rc);
+ goto error_auth_destroy;
+ }
+ }
+-
++
+ return;
+
+ error_auth_destroy:
+ rc = globus_i_ftp_control_auth_info_destroy(
+ &(cc_handle->auth_info));
+ globus_assert(rc == GLOBUS_SUCCESS);
+-
++
+ (cc_handle->command_cb)(cc_handle->command_cb_arg,
+ c_handle,
+ error,
+ GLOBUS_NULL);
+ globus_object_free(error);
+-
++
+ globus_mutex_lock(&(cc_handle->mutex));
+ {
+ cc_handle->cb_count--;
+
+ if(!cc_handle->cb_count &&
+- cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
+- {
+- call_close_cb = GLOBUS_TRUE;
+- }
++ cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
++ {
++ call_close_cb = GLOBUS_TRUE;
++ }
+ }
+ globus_mutex_unlock(&(cc_handle->mutex));
+-
+- if(call_close_cb == GLOBUS_TRUE)
+- {
+- globus_i_ftp_control_call_close_cb(c_handle);
+- }
++
++ if(call_close_cb == GLOBUS_TRUE)
++ {
++ globus_i_ftp_control_call_close_cb(c_handle);
++ }
+
+ return;
+ }
+@@ -2750,8 +2750,8 @@ error_auth_destroy:
+ * @brief Send a GridFTP response
+ * @ingroup globus_ftp_control_server
+ * @details
+- * This function sends a GridFTP formatted response to the client.
+- * When a command callback is received the user calls this function
++ * This function sends a GridFTP formatted response to the client.
++ * When a command callback is received the user calls this function
+ * to respond to the clients request.
+ *
+ * @param handle
+@@ -2794,15 +2794,15 @@ globus_ftp_control_send_response(
+ );
+ }
+
+-
++
+ va_start(ap, callback_arg);
+-
++
+ arglength=globus_libc_vfprintf(globus_i_ftp_control_devnull,
+ respspec,
+ ap);
+
+ va_end(ap);
+-
++
+ if(arglength < 1)
+ {
+ result=globus_error_put(
+@@ -2857,13 +2857,13 @@ globus_ftp_control_send_response(
+ result=rc;
+ goto return_error;
+ }
+-
++
+ buf=encoded_buf;
+ }
+
+ element = (globus_ftp_control_rw_queue_element_t *)
+ globus_libc_malloc(sizeof(globus_ftp_control_rw_queue_element_t));
+-
++
+ if(element == GLOBUS_NULL)
+ {
+ result=globus_error_put(
+@@ -2917,7 +2917,7 @@ globus_ftp_control_send_response(
+ (globus_size_t) strlen((char *) buf),
+ globus_l_ftp_control_send_response_cb,
+ (void *) handle);
+-
++
+ if(rc != GLOBUS_SUCCESS)
+ {
+ globus_mutex_lock(&(handle->cc_handle.mutex));
+@@ -2927,26 +2927,26 @@ globus_ftp_control_send_response(
+ queue_empty=globus_fifo_empty(&handle->cc_handle.writers);
+
+ if(!handle->cc_handle.cb_count &&
+- handle->cc_handle.cc_state == GLOBUS_FTP_CONTROL_CLOSING)
+- {
+- call_close_cb = GLOBUS_TRUE;
+- }
++ handle->cc_handle.cc_state == GLOBUS_FTP_CONTROL_CLOSING)
++ {
++ call_close_cb = GLOBUS_TRUE;
++ }
+ }
+ globus_mutex_unlock(&(handle->cc_handle.mutex));
+
+- if(call_close_cb == GLOBUS_TRUE)
+- {
+- globus_i_ftp_control_call_close_cb(handle);
++ if(call_close_cb == GLOBUS_TRUE)
++ {
++ globus_i_ftp_control_call_close_cb(handle);
+ }
+
+ globus_libc_free(buf);
+- globus_libc_free(element);
++ globus_libc_free(element);
+
+ if(queue_empty == GLOBUS_FALSE)
+ {
+ globus_i_ftp_control_write_next(handle);
+ }
+-
++
+ result=rc;
+ goto return_error;
+ }
+@@ -2961,8 +2961,8 @@ return_error:
+ #ifdef GLOBUS_INTERNAL_DOC
+
+ /**
+- * Internal callback for the globus_io_register_write function.
+- *
++ * Internal callback for the globus_io_register_write function.
++ *
+ * This is an internal callback used as part of the
+ * globus_ftp_control_send_response function. It checks the result of
+ * the write (which was used to send a response to the client), and
+@@ -2975,23 +2975,23 @@ return_error:
+ * The globus_io handle for the connection. In practice this
+ * represents the socket fd for the connection.
+ * @param result
+- * The result of the write operation
++ * The result of the write operation
+ *
+ * @return void
+ *
+ * @note If a error is detected in this function the user callback is
+ * called with an appropriate error object or ftp response and
+- * the function returns.
++ * the function returns.
+ */
+
+ #endif
+
+-static void
++static void
+ globus_l_ftp_control_send_response_cb(
+- void * arg,
++ void * arg,
+ globus_io_handle_t * handle,
+ globus_result_t result,
+- globus_byte_t * buf,
++ globus_byte_t * buf,
+ globus_size_t nbytes)
+ {
+ globus_ftp_cc_handle_t * cc_handle;
+@@ -3014,12 +3014,12 @@ globus_l_ftp_control_send_response_cb(
+ queue_empty=globus_fifo_empty(&cc_handle->writers);
+ }
+ globus_mutex_unlock(&(cc_handle->mutex));
+-
++
+ if(queue_empty == GLOBUS_FALSE)
+ {
+ globus_i_ftp_control_write_next(c_handle);
+ }
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ error=globus_error_get(result);
+@@ -3031,26 +3031,26 @@ globus_l_ftp_control_send_response_cb(
+ GLOBUS_NULL);
+
+ globus_libc_free(element);
+-
++
+ globus_mutex_lock(&(cc_handle->mutex));
+ {
+ cc_handle->cb_count--;
+
+ if(!cc_handle->cb_count &&
+- cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
+- {
+- call_close_cb = GLOBUS_TRUE;
++ cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
++ {
++ call_close_cb = GLOBUS_TRUE;
+ }
+ }
+ globus_mutex_unlock(&(cc_handle->mutex));
+-
+- if(call_close_cb == GLOBUS_TRUE)
+- {
+- globus_i_ftp_control_call_close_cb(c_handle);
+- }
++
++ if(call_close_cb == GLOBUS_TRUE)
++ {
++ globus_i_ftp_control_call_close_cb(c_handle);
++ }
+
+ return;
+-
++
+ return_error:
+
+ (element->send_response_cb)((element->arg),
+@@ -3063,17 +3063,17 @@ return_error:
+ {
+ cc_handle->cb_count--;
+ if(!cc_handle->cb_count &&
+- cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
+- {
+- call_close_cb = GLOBUS_TRUE;
++ cc_handle->cc_state == GLOBUS_FTP_CONTROL_CLOSING)
++ {
++ call_close_cb = GLOBUS_TRUE;
+ }
+ }
+ globus_mutex_unlock(&(cc_handle->mutex));
+
+- if(call_close_cb == GLOBUS_TRUE)
+- {
+- globus_i_ftp_control_call_close_cb(c_handle);
+- }
++ if(call_close_cb == GLOBUS_TRUE)
++ {
++ globus_i_ftp_control_call_close_cb(c_handle);
++ }
+
+ return;
+ }
+@@ -3083,7 +3083,7 @@ return_error:
+ /**
+ * Internal helper function which base 64 decodes and gss unwraps a
+ * MIC command
+- *
++ *
+ * Internal helper function which base 64 decodes and gss unwraps a
+ * MIC command
+ *
+@@ -3095,7 +3095,7 @@ return_error:
+ * @param auth_info
+ * The auth_info structure to use for gss unwrapping the command
+ *
+- * @return
++ * @return
+ * - error object
+ * - GLOBUS_SUCCESS
+ *
+@@ -3119,7 +3119,7 @@ globus_i_ftp_control_decode_command(
+ OM_uint32 min_stat;
+ int conf_state;
+ gss_qop_t qop_state;
+-
++
+ if(cmd == GLOBUS_NULL)
+ {
+ return globus_error_put(
+@@ -3129,11 +3129,11 @@ globus_i_ftp_control_decode_command(
+ _FCSL("globus_i_ftp_control_decode_command: cmd argument is NULL"))
+ );
+ }
+-
++
+ length=strlen(cmd);
+-
++
+ tmp=(char *) globus_libc_malloc(length+1);
+-
++
+ if(tmp == GLOBUS_NULL)
+ {
+ return globus_error_put(
+@@ -3143,7 +3143,7 @@ globus_i_ftp_control_decode_command(
+ _FCSL("globus_ftp_control_decode_command: malloc failed"))
+ );
+ }
+-
++
+ if(sscanf(cmd,"%4s",tmp) < 1)
+ {
+ rc = globus_error_put(
+@@ -3154,16 +3154,16 @@ globus_i_ftp_control_decode_command(
+ );
+ goto decode_error;
+ }
+-
++
+ i=0;
+-
++
+ while(tmp[i] != '\0')
+ {
+ tmp[i]=toupper(tmp[i]);
+ i++;
+ }
+-
+-
++
++
+ if(strcmp(tmp,"MIC") &&
+ strcmp(tmp,"ENC"))
+ {
+@@ -3180,7 +3180,7 @@ globus_i_ftp_control_decode_command(
+ {
+ /* if command is ENC and encryption isn't turned on in
+ sec context */
+-
++
+ rc = globus_error_put(
+ globus_error_construct_string(
+ GLOBUS_FTP_CONTROL_MODULE,
+@@ -3189,7 +3189,7 @@ globus_i_ftp_control_decode_command(
+ );
+ goto decode_error;
+ }
+-
++
+ if(sscanf(cmd,"%*s %s",tmp) < 1)
+ {
+ rc = globus_error_put(
+@@ -3200,9 +3200,9 @@ globus_i_ftp_control_decode_command(
+ );
+ goto decode_error;
+ }
+-
++
+ *decoded_cmd = (char *) globus_libc_malloc((length+3) * 6/8);
+-
++
+ if(*decoded_cmd == GLOBUS_NULL)
+ {
+ rc = globus_error_put(
+@@ -3213,27 +3213,27 @@ globus_i_ftp_control_decode_command(
+ );
+ goto decode_error;
+ }
+-
++
+ rc=globus_i_ftp_control_radix_decode(
+ (globus_byte_t *) tmp,
+ (globus_byte_t *) *decoded_cmd,&length);
+-
++
+ if(rc != GLOBUS_SUCCESS)
+ {
+ globus_libc_free(*decoded_cmd);
+ goto decode_error;
+ }
+-
++
+ wrapped_token.value = *decoded_cmd;
+ wrapped_token.length = length;
+
+- maj_stat = gss_unwrap(&min_stat,
++ maj_stat = gss_unwrap(&min_stat,
+ auth_info->auth_gssapi_context,
+- &wrapped_token,
++ &wrapped_token,
+ &unwrapped_token,
+- &conf_state,
++ &conf_state,
+ &qop_state);
+-
++
+ if(maj_stat != GSS_S_COMPLETE)
+ {
+ rc = globus_error_put(
+@@ -3242,23 +3242,23 @@ globus_i_ftp_control_decode_command(
+ GLOBUS_NULL,
+ _FCSL("globus_ftp_control_decode_command: failed to unwrap command"))
+ );
+-
++
+ globus_libc_free(*decoded_cmd);
+ goto decode_error;
+ }
+-
++
+ globus_assert(strlen(cmd) > unwrapped_token.length);
+-
++
+ memcpy(tmp,
+ unwrapped_token.value,
+ unwrapped_token.length);
+
+ tmp[unwrapped_token.length] = '\0';
+-
++
+ gss_release_buffer(&min_stat, &unwrapped_token);
+-
++
+ globus_libc_free(*decoded_cmd);
+-
++
+ *decoded_cmd=tmp;
+
+ return GLOBUS_SUCCESS;
+@@ -3266,9 +3266,9 @@ globus_i_ftp_control_decode_command(
+ decode_error:
+
+ *decoded_cmd=GLOBUS_NULL;
+-
++
+ globus_libc_free(tmp);
+-
++
+ return rc;
+ }
+
+@@ -3277,7 +3277,7 @@ decode_error:
+ /**
+ * Internal helper function which gss wraps, base 64 encodes and puts
+ * a 635 in front of the supplied response
+- *
++ *
+ * Internal helper function which gss wraps, base 64 encodes and puts
+ * a 635 in front of the supplied response
+ *
+@@ -3289,7 +3289,7 @@ decode_error:
+ * @param auth_info
+ * The auth_info structure to use for gss wrapping the reply.
+ *
+- * @return
++ * @return
+ * - error object
+ * - GLOBUS_SUCCESS
+ *
+@@ -3310,7 +3310,7 @@ globus_i_ftp_control_encode_reply(
+ OM_uint32 min_stat;
+ int conf_state;
+ int length;
+-
++
+ if(auth_info == GLOBUS_NULL ||
+ reply == GLOBUS_NULL ||
+ encoded_reply == GLOBUS_NULL)
+@@ -3322,7 +3322,7 @@ globus_i_ftp_control_encode_reply(
+ _FCSL("globus_i_ftp_control_encode_reply: NULL argument detected"))
+ );
+ }
+-
++
+ in_buf.value = reply;
+ in_buf.length = strlen(reply)+1;
+
+@@ -3330,11 +3330,11 @@ globus_i_ftp_control_encode_reply(
+ auth_info->auth_gssapi_context,
+ 0,
+ GSS_C_QOP_DEFAULT,
+- &in_buf,
++ &in_buf,
+ &conf_state,
+ &out_buf);
+-
+- if(maj_stat != GSS_S_COMPLETE)
++
++ if(maj_stat != GSS_S_COMPLETE)
+ {
+ return globus_error_put(
+ globus_error_construct_string(
+@@ -3368,11 +3368,11 @@ globus_i_ftp_control_encode_reply(
+ {
+ strcat(*encoded_reply,"631 ");
+ }
+-
++
+ length = out_buf.length;
+ globus_i_ftp_control_radix_encode(
+ out_buf.value,
+- (globus_byte_t *) &((*encoded_reply)[4]),
++ (globus_byte_t *) &((*encoded_reply)[4]),
+ &length);
+
+ (*encoded_reply)[length+4]='\r';
+@@ -3380,7 +3380,7 @@ globus_i_ftp_control_encode_reply(
+ (*encoded_reply)[length+6]='\0';
+
+ gss_release_buffer(&min_stat, &out_buf);
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+@@ -3392,12 +3392,12 @@ globus_i_ftp_control_encode_reply(
+ /**
+ * Internal helper function which sets up a list for keeping track of
+ * server handles.
+- *
++ *
+ * Internal helper function which sets up a list for keeping track of
+ * server handles.
+ *
+ *
+- * @return
++ * @return
+ * - GLOBUS_SUCCESS
+ *
+ */
+@@ -3409,7 +3409,7 @@ globus_result_t
+ globus_i_ftp_control_server_activate(void)
+ {
+ globus_ftp_l_command_hash_entry_t * entries;
+-
++
+ globus_mutex_init(
+ &(globus_l_ftp_server_handle_list_mutex), GLOBUS_NULL);
+
+@@ -3419,7 +3419,7 @@ globus_i_ftp_control_server_activate(void)
+ globus_hashtable_string_keyeq);
+
+ /* the size of this array needs to be adjusted */
+-
++
+ entries = (globus_ftp_l_command_hash_entry_t *)
+ globus_libc_malloc(44 * sizeof(globus_ftp_l_command_hash_entry_t));
+
+@@ -3530,7 +3530,7 @@ globus_i_ftp_control_server_activate(void)
+ globus_hashtable_insert(&globus_l_ftp_control_parse_table,
+ "SMNT",
+ &entries[17]);
+-
++
+ entries[18].code = GLOBUS_FTP_CONTROL_COMMAND_OPTS;
+ entries[18].parse_func = globus_l_ftp_control_parse_opts_cmd;
+ globus_hashtable_insert(&globus_l_ftp_control_parse_table,
+@@ -3584,7 +3584,7 @@ globus_i_ftp_control_server_activate(void)
+ globus_hashtable_insert(&globus_l_ftp_control_parse_table,
+ "PASS",
+ &entries[26]);
+-
++
+ entries[27].code = GLOBUS_FTP_CONTROL_COMMAND_RMD;
+ entries[27].parse_func = globus_l_ftp_control_parse_string_arg;
+ globus_hashtable_insert(&globus_l_ftp_control_parse_table,
+@@ -3697,9 +3697,9 @@ globus_i_ftp_control_server_activate(void)
+ *
+ * Internal helper function which goes through a list of server
+ * handles and closes any open connections associated with the
+- * handles.
+- *
+- * @return
++ * handles.
++ *
++ * @return
+ * - GLOBUS_SUCCESS
+ *
+ */
+@@ -3720,7 +3720,7 @@ globus_i_ftp_control_server_deactivate(void)
+ globus_list_first(globus_l_ftp_server_handle_list);
+ globus_mutex_lock(&(server_handle->mutex));
+ {
+- if(server_handle->state ==
++ if(server_handle->state ==
+ GLOBUS_FTP_CONTROL_SERVER_LISTENING)
+ {
+ rc=globus_io_close(&(server_handle->io_handle));
+@@ -3729,7 +3729,7 @@ globus_i_ftp_control_server_deactivate(void)
+ }
+ }
+ globus_mutex_unlock(&(server_handle->mutex));
+-
++
+ globus_mutex_destroy(&(server_handle->mutex));
+ globus_list_remove(&globus_l_ftp_server_handle_list,
+ globus_l_ftp_server_handle_list);
+@@ -3741,18 +3741,18 @@ globus_i_ftp_control_server_deactivate(void)
+
+
+ /* free all command hash memory */
+-
++
+ globus_libc_free(globus_hashtable_lookup(
+ &globus_l_ftp_control_parse_table,
+ "SBUF"));
+
+ globus_hashtable_destroy(&globus_l_ftp_control_parse_table);
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+ globus_result_t globus_l_ftp_control_parse_sbuf_cmd(
+- globus_ftp_control_command_t * command)
++ globus_ftp_control_command_t * command)
+ {
+ if(sscanf(command->noop.raw_command,
+ "%*s %d", &command->sbuf.buffer_size) < 1)
+@@ -3767,12 +3767,12 @@ globus_result_t globus_l_ftp_control_parse_string_arg(
+ {
+ int length;
+ int arg_start;
+-
++
+ length = strlen(command->noop.raw_command);
+-
++
+ command->size.string_arg =
+ (char *) globus_libc_malloc(length);
+-
++
+ if(command->size.string_arg == GLOBUS_NULL)
+ {
+ return globus_error_put(
+@@ -3781,10 +3781,10 @@ globus_result_t globus_l_ftp_control_parse_string_arg(
+ GLOBUS_NULL,
+ _FCSL("globus_ftp_control_command_init: malloc failed")));
+ }
+-
++
+ sscanf(command->noop.raw_command,"%*s%n",
+ &arg_start);
+-
++
+ while(isspace(command->noop.raw_command[arg_start]))
+ {
+ arg_start++;
+@@ -3795,11 +3795,11 @@ globus_result_t globus_l_ftp_control_parse_string_arg(
+ length--;
+ }
+
+- command->noop.raw_command[length]='\0';
++ command->noop.raw_command[length]='\0';
+
+ strcpy(command->eret.string_arg,
+ &command->noop.raw_command[arg_start]);
+-
++
+ return GLOBUS_SUCCESS;
+
+ }
+@@ -3807,13 +3807,13 @@ globus_result_t globus_l_ftp_control_parse_string_arg(
+ globus_result_t globus_l_ftp_control_parse_no_arg(
+ globus_ftp_control_command_t * command)
+ {
+- command->cdup.string_arg=GLOBUS_NULL;
++ command->cdup.string_arg=GLOBUS_NULL;
+ return GLOBUS_SUCCESS;
+ }
+
+
+ globus_result_t globus_l_ftp_control_parse_allo_cmd(
+- globus_ftp_control_command_t * command)
++ globus_ftp_control_command_t * command)
+ {
+ command->allo.record_size = 0;
+ if(sscanf(command->noop.raw_command,"%*s %d R %d",
+@@ -3823,12 +3823,12 @@ globus_result_t globus_l_ftp_control_parse_allo_cmd(
+ command->allo.size = 0;
+ command->allo.record_size = 0;
+ }
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+ globus_result_t globus_l_ftp_control_parse_opts_cmd(
+- globus_ftp_control_command_t * command)
++ globus_ftp_control_command_t * command)
+ {
+ int length;
+
+@@ -3836,7 +3836,7 @@ globus_result_t globus_l_ftp_control_parse_opts_cmd(
+
+ command->opts.cmd_name =
+ (char *) globus_libc_malloc(length);
+-
++
+ if(command->opts.cmd_name == GLOBUS_NULL)
+ {
+ return globus_error_put(
+@@ -3846,7 +3846,7 @@ globus_result_t globus_l_ftp_control_parse_opts_cmd(
+ _FCSL("globus_ftp_control_command_init: malloc failed")));
+ }
+
+- command->opts.cmd_opts =
++ command->opts.cmd_opts =
+ (char *) globus_libc_malloc(length);
+
+ if(command->opts.cmd_opts == GLOBUS_NULL)
+@@ -3858,7 +3858,7 @@ globus_result_t globus_l_ftp_control_parse_opts_cmd(
+ GLOBUS_NULL,
+ _FCSL("globus_ftp_control_command_init: malloc failed")));
+ }
+-
++
+ if(sscanf(command->noop.raw_command,"%*s %s %s",
+ command->opts.cmd_name, command->opts.cmd_opts) < 2)
+ {
+@@ -3872,10 +3872,10 @@ globus_result_t globus_l_ftp_control_parse_opts_cmd(
+
+
+ globus_result_t globus_l_ftp_control_parse_port_cmd(
+- globus_ftp_control_command_t * command)
++ globus_ftp_control_command_t * command)
+ {
+ int port[2];
+-
++
+ if(sscanf(command->noop.raw_command,
+ "%*s %u,%u,%u,%u,%u,%u",
+ &(command->port.host_port.host[0]),
+@@ -3888,7 +3888,7 @@ globus_result_t globus_l_ftp_control_parse_port_cmd(
+ command->code=GLOBUS_FTP_CONTROL_COMMAND_UNKNOWN;
+ return GLOBUS_SUCCESS;
+ }
+-
++
+ if((command->port.host_port.host)[0] > 255 ||
+ (command->port.host_port.host)[1] > 255 ||
+ (command->port.host_port.host)[2] > 255 ||
+@@ -3899,38 +3899,38 @@ globus_result_t globus_l_ftp_control_parse_port_cmd(
+ command->code=GLOBUS_FTP_CONTROL_COMMAND_UNKNOWN;
+ return GLOBUS_SUCCESS;
+ }
+-
++
+ command->port.host_port.port= (short) 256*port[0]+port[1];
+ command->port.host_port.hostlen = 4;
+ return GLOBUS_SUCCESS;
+ }
+
+ globus_result_t globus_l_ftp_control_parse_spor_cmd(
+- globus_ftp_control_command_t * command)
++ globus_ftp_control_command_t * command)
+ {
+ char * start;
+ int i;
+ int j;
+ int arg_start;
+ int port[2];
+-
++
+ start=strstr(command->noop.raw_command,"SPOR");
+-
++
+ i=0;
+-
++
+ while(start != &(command->noop.raw_command[i]))
+ {
+ i++;
+ }
+
+ arg_start = i+4;
+-
++
+ i = arg_start;
+-
++
+ j = 0;
+-
++
+ /* figure out how many host/port arguments there are */
+-
++
+ while(command->noop.raw_command[i])
+ {
+ if(isspace(command->noop.raw_command[i]))
+@@ -3941,7 +3941,7 @@ globus_result_t globus_l_ftp_control_parse_spor_cmd(
+ {
+ i++;
+ }
+-
++
+ if(command->noop.raw_command[i])
+ {
+ j++;
+@@ -3952,12 +3952,12 @@ globus_result_t globus_l_ftp_control_parse_spor_cmd(
+ i++;
+ }
+ }
+-
++
+ /* allocate memory for them */
+-
++
+ command->spor.host_port = (globus_ftp_control_host_port_t*)
+ globus_libc_malloc(j*sizeof(globus_ftp_control_host_port_t));
+-
++
+ if(command->spor.host_port == GLOBUS_NULL)
+ {
+ return globus_error_put(
+@@ -3966,12 +3966,12 @@ globus_result_t globus_l_ftp_control_parse_spor_cmd(
+ GLOBUS_NULL,
+ _FCSL("globus_ftp_control_command_init: malloc failed")));
+ }
+-
++
+ command->spor.num_args = j;
+-
++
+ i = arg_start;
+ j = 0;
+-
++
+ while(command->noop.raw_command[i])
+ {
+ if(!isspace(command->noop.raw_command[i]))
+@@ -3989,7 +3989,7 @@ globus_result_t globus_l_ftp_control_parse_spor_cmd(
+ command->code=GLOBUS_FTP_CONTROL_COMMAND_UNKNOWN;
+ return GLOBUS_SUCCESS;
+ }
+-
++
+ if((command->spor.host_port[j].host)[0] > 255 ||
+ (command->spor.host_port[j].host)[1] > 255 ||
+ (command->spor.host_port[j].host)[2] > 255 ||
+@@ -4001,18 +4001,18 @@ globus_result_t globus_l_ftp_control_parse_spor_cmd(
+ command->code=GLOBUS_FTP_CONTROL_COMMAND_UNKNOWN;
+ return GLOBUS_SUCCESS;
+ }
+-
+- command->spor.host_port[j].port=
++
++ command->spor.host_port[j].port=
+ (short) 256*port[0]+port[1];
+ command->spor.host_port[j].hostlen = 4;
+-
++
+ i++;
+ while(command->noop.raw_command[i] &&
+ !isspace(command->noop.raw_command[i]))
+ {
+ i++;
+ }
+-
++
+ if(command->noop.raw_command[i])
+ {
+ j++;
+@@ -4023,16 +4023,16 @@ globus_result_t globus_l_ftp_control_parse_spor_cmd(
+ i++;
+ }
+ }
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+ globus_result_t globus_l_ftp_control_parse_type_cmd(
+- globus_ftp_control_command_t * command)
++ globus_ftp_control_command_t * command)
+
+ {
+ char tmp;
+-
++
+ command->type.option=GLOBUS_FTP_CONTROL_TYPE_NO_OPTION;
+ command->type.bytesize=0;
+
+@@ -4040,13 +4040,13 @@ globus_result_t globus_l_ftp_control_parse_type_cmd(
+ {
+ command->type.type=GLOBUS_FTP_CONTROL_TYPE_NONE;
+ }
+-
++
+ switch(tmp)
+ {
+ case 'A':
+ case 'a':
+ command->type.type=GLOBUS_FTP_CONTROL_TYPE_ASCII;
+-
++
+ if(sscanf(command->noop.raw_command,
+ "%*s %*c %c",&tmp) > 0)
+ {
+@@ -4068,11 +4068,11 @@ globus_result_t globus_l_ftp_control_parse_type_cmd(
+ }
+ }
+ return GLOBUS_SUCCESS;
+-
++
+ case 'E':
+ case 'e':
+ command->type.type=GLOBUS_FTP_CONTROL_TYPE_EBCDIC;
+-
++
+ if(sscanf(command->noop.raw_command,
+ "%*s %*c %c",&tmp) > 0)
+ {
+@@ -4118,17 +4118,17 @@ globus_result_t globus_l_ftp_control_parse_type_cmd(
+
+
+ globus_result_t globus_l_ftp_control_parse_stru_cmd(
+- globus_ftp_control_command_t * command)
++ globus_ftp_control_command_t * command)
+ {
+ char tmp;
+-
++
+ command->stru.structure=
+ GLOBUS_FTP_CONTROL_STRUCTURE_NONE;
+ if(sscanf(command->noop.raw_command,"%*s %c",&tmp) < 1)
+ {
+ return GLOBUS_SUCCESS;
+ }
+-
++
+ switch(tmp)
+ {
+ case 'F':
+@@ -4153,48 +4153,48 @@ globus_result_t globus_l_ftp_control_parse_stru_cmd(
+
+
+ globus_result_t globus_l_ftp_control_parse_auth_cmd(
+- globus_ftp_control_command_t * command)
++ globus_ftp_control_command_t * command)
+ {
+ char tmp[10];
+ int i;
+-
++
+ command->auth.type=GLOBUS_FTP_CONTROL_AUTH_UNKNOWN;
+-
++
+ if(sscanf(command->noop.raw_command,"%*s %7s",tmp) < 1)
+ {
+ return GLOBUS_SUCCESS;
+ }
+-
++
+ i = 0;
+-
++
+ while(tmp[i] != '\0')
+ {
+ tmp[i] = toupper(tmp[i]);
+ i++;
+ }
+-
++
+ if(strcmp("GSSAPI",tmp) == 0)
+ {
+ command->auth.type=GLOBUS_FTP_CONTROL_AUTH_GSSAPI;
+ }
+-
++
+ return GLOBUS_SUCCESS;
+-
++
+ }
+
+ globus_result_t globus_l_ftp_control_parse_mode_cmd(
+- globus_ftp_control_command_t * command)
++ globus_ftp_control_command_t * command)
+ {
+ char tmp;
+-
++
+ command->code=GLOBUS_FTP_CONTROL_COMMAND_MODE;
+-
++
+ if(sscanf(command->noop.raw_command,"%*s %c",&tmp) < 1)
+ {
+ command->mode.mode=GLOBUS_FTP_CONTROL_MODE_NONE;
+ return GLOBUS_SUCCESS;
+ }
+-
++
+ switch(tmp)
+ {
+ case 'S':
+diff --git a/gridftp/control/source/test/connect_test.c b/gridftp/control/source/test/connect_test.c
+index 2a9ed5739..e1cb59809 100644
+--- a/gridftp/control/source/test/connect_test.c
++++ b/gridftp/control/source/test/connect_test.c
+@@ -59,7 +59,7 @@ typedef struct
+ globus_ftp_control_auth_info_t auth_info;
+ bool use_auth;
+ enum
+- {
++ {
+ CMD_CONNECT,
+ CMD_AUTHENTICATE,
+ CMD_QUIT,
+@@ -80,7 +80,7 @@ void
+ globus_l_server_close_callback(
+ void * callback_arg,
+ globus_ftp_control_handle_t *handle,
+- globus_object_t *error,
++ globus_object_t *error,
+ globus_ftp_control_response_t *ftp_response);
+ static
+ void
+@@ -94,7 +94,7 @@ void
+ globus_l_client_callback(
+ void * callback_arg,
+ globus_ftp_control_handle_t *handle,
+- globus_object_t *error,
++ globus_object_t *error,
+ globus_ftp_control_response_t *ftp_response)
+ {
+ globus_result_t result = GLOBUS_SUCCESS;
+@@ -138,7 +138,7 @@ globus_l_client_callback(
+ globus_l_client_callback,
+ client);
+ client->command = CMD_QUIT;
+- if (result == GLOBUS_SUCCESS
++ if (result == GLOBUS_SUCCESS
+ && ftp_response->code > 399)
+ {
+ client->error = globus_error_construct_string(
+@@ -877,7 +877,7 @@ void
+ globus_l_server_close_callback(
+ void * callback_arg,
+ globus_ftp_control_handle_t *handle,
+- globus_object_t *error,
++ globus_object_t *error,
+ globus_ftp_control_response_t *ftp_response)
+ {
+ globus_l_server_response_callback(callback_arg, handle, error);
+@@ -892,7 +892,7 @@ globus_l_server_response_callback(
+ {
+ auth_test_server_session_t *session = callback_arg;
+ globus_result_t res = GLOBUS_SUCCESS;
+- globus_ftp_control_auth_requirements_t
++ globus_ftp_control_auth_requirements_t
+ auth_req;
+
+ if (error)
+@@ -974,7 +974,7 @@ globus_l_server_accept_callback(
+ }
+
+ static
+-void
++void
+ globus_l_server_listen_callback(
+ void * callback_arg,
+ globus_ftp_control_server_t * server_handle,
+@@ -1048,7 +1048,7 @@ initialize_servers(void)
+ cleartext_server.auth_requirements =
+ GLOBUS_FTP_CONTROL_AUTH_REQ_USER
+ | GLOBUS_FTP_CONTROL_AUTH_REQ_PASS;
+-
++
+ result = globus_ftp_control_server_handle_init(
+ &tls_server.server);
+ if (result != GLOBUS_SUCCESS)
+diff --git a/gridftp/control/source/test/data_test.c b/gridftp/control/source/test/data_test.c
+index 8e58816f4..b708747ef 100644
+--- a/gridftp/control/source/test/data_test.c
++++ b/gridftp/control/source/test/data_test.c
+@@ -146,12 +146,12 @@ connect_read_big_buffer_callback(
+ globus_bool_t resuse,
+ globus_object_t * error);
+
+-void
++void
+ binary_eb_mode(
+ globus_ftp_control_handle_t * handle,
+ int plevel);
+
+-void
++void
+ binary_stream_mode(
+ globus_ftp_control_handle_t * handle,
+ int plevel);
+@@ -170,7 +170,7 @@ diff(
+ const char * dest);
+
+ void
+-force_close_cb(
++force_close_cb(
+ void * user_arg,
+ globus_ftp_control_handle_t * handle,
+ globus_object_t * error)
+@@ -187,15 +187,15 @@ force_close_cb(
+ globus_mutex_unlock(&monitor->mutex);
+ }
+
+-int
++int
+ main(
+ int argc,
+ char * argv[])
+-{
++{
+ globus_result_t res;
+ int ctr;
+- int rc;
+- int i;
++ int rc;
++ int i;
+ int plevel;
+
+ LTDL_SET_PRELOADED_SYMBOLS();
+@@ -328,7 +328,7 @@ main(
+ for(plevel = 1; plevel <= MAX_PLEVEL; plevel++)
+ {
+ verbose_printf(2, "parallel level %d\n", plevel);
+- big_buffer_test(binary_eb_mode, plevel);
++ big_buffer_test(binary_eb_mode, plevel);
+ }
+ verbose_printf(1, "big buffer in eb mode passed\n");
+ printf("ok - big_buffer_test(binary_eb_mode, plevel)\n");
+@@ -414,13 +414,13 @@ test_send_eof(
+ (void *)&done_monitor);
+
+ if(res != GLOBUS_SUCCESS)
+- {
++ {
+ return res;
+ }
+ globus_mutex_lock(&done_monitor.mutex);
+ {
+ while(!done_monitor.done)
+- {
++ {
+ globus_cond_wait(&done_monitor.cond, &done_monitor.mutex);
+ }
+ }
+@@ -490,7 +490,7 @@ big_buffer_test(
+ verbose_printf(3, "waiting for transfer.\n");
+ globus_mutex_lock(&done_monitor.mutex);
+ {
+- while(done_monitor.count < 2 &&
++ while(done_monitor.count < 2 &&
+ !done_monitor.done)
+ {
+ globus_cond_wait(&done_monitor.cond, &done_monitor.mutex);
+@@ -619,12 +619,12 @@ reuse_handles_test(
+ &port_connections,
+ 0);
+
+- verbose_printf(3,
++ verbose_printf(3,
+ "pasv_connection count = %d, port connection count = %d\n",
+ pasv_connections, port_connections);
+ globus_mutex_lock(&done_monitor.mutex);
+ {
+- while(done_monitor.count < 2 &&
++ while(done_monitor.count < 2 &&
+ !done_monitor.done)
+ {
+ globus_cond_wait(&done_monitor.cond, &done_monitor.mutex);
+@@ -684,7 +684,7 @@ reuse_handles_test(
+ return GLOBUS_SUCCESS;
+ }
+
+-void
++void
+ binary_eb_mode(
+ globus_ftp_control_handle_t * handle,
+ int plevel)
+@@ -696,23 +696,23 @@ binary_eb_mode(
+ parallelism.fixed.size = plevel;
+
+ res = globus_ftp_control_local_type(
+- handle,
+- GLOBUS_FTP_CONTROL_TYPE_IMAGE,
++ handle,
++ GLOBUS_FTP_CONTROL_TYPE_IMAGE,
+ 0);
+ test_result(res, "local_type", __LINE__);
+
+ res = globus_ftp_control_local_mode(
+- handle,
++ handle,
+ GLOBUS_FTP_CONTROL_MODE_EXTENDED_BLOCK);
+ test_result(res, "local_mode", __LINE__);
+
+ res = globus_ftp_control_local_parallelism(
+- handle,
++ handle,
+ ¶llelism);
+ test_result(res, "local_mode", __LINE__);
+ }
+
+-void
++void
+ binary_stream_mode(
+ globus_ftp_control_handle_t * handle,
+ int plevel)
+@@ -720,13 +720,13 @@ binary_stream_mode(
+ globus_result_t res;
+
+ res = globus_ftp_control_local_type(
+- handle,
+- GLOBUS_FTP_CONTROL_TYPE_IMAGE,
++ handle,
++ GLOBUS_FTP_CONTROL_TYPE_IMAGE,
+ 0);
+ test_result(res, "local_type", __LINE__);
+
+ res = globus_ftp_control_local_mode(
+- handle,
++ handle,
+ GLOBUS_FTP_CONTROL_MODE_STREAM);
+ test_result(res, "local_mode", __LINE__);
+ }
+@@ -743,7 +743,7 @@ cache_multiparallel_test(
+ globus_ftp_control_handle_t pasv_handle;
+ ftp_test_monitor_t done_monitor;
+ data_test_info_t * test_info;
+- int nsock_a[] =
++ int nsock_a[] =
+ {4, 16, 8, 32, 2, 4, 0};
+
+ ftp_test_monitor_init(&done_monitor);
+@@ -794,7 +794,7 @@ cache_multiparallel_test(
+ verbose_printf(3, "waiting for transfer.\n");
+ globus_mutex_lock(&done_monitor.mutex);
+ {
+- while(done_monitor.count < 2 &&
++ while(done_monitor.count < 2 &&
+ !done_monitor.done)
+ {
+ globus_cond_wait(&done_monitor.cond, &done_monitor.mutex);
+@@ -914,7 +914,7 @@ cache_test(
+ verbose_printf(3, "waiting for transfer.\n");
+ globus_mutex_lock(&done_monitor.mutex);
+ {
+- while(done_monitor.count < 2 &&
++ while(done_monitor.count < 2 &&
+ !done_monitor.done)
+ {
+ globus_cond_wait(&done_monitor.cond, &done_monitor.mutex);
+@@ -974,13 +974,13 @@ cache_test(
+ * It then sends data to all of them and compares the data on both ends
+ * if the trasfers. In order to ease the testing of some of the clean up
+ * this test does leak some memory.
+- *
++ *
+ * It tests the control library data code for:
+ * 1) read and write functionality for data integrity
+ * 2) functionality when multiple handles are simaltaneously being used.
+ * 3) reads of sizes greater than and smaller than the size of the extended
+ * block.
+- * 4) clean up. At the end of half the transfers close() and destroy()
++ * 4) clean up. At the end of half the transfers close() and destroy()
+ * are called. The other half leave the clean up up to deactivate.
+ */
+ globus_result_t
+@@ -1018,7 +1018,7 @@ transfer_test(
+
+ res = globus_i_ftp_control_data_cc_init(pasv_handle);
+ test_result(res, "pasv handle init", __LINE__);
+-
++
+ res = globus_i_ftp_control_data_cc_init(port_handle);
+ test_result(res, "port handle init", __LINE__);
+
+@@ -1033,7 +1033,7 @@ transfer_test(
+
+ mode_cb(pasv_handle, plevel);
+ mode_cb(port_handle, plevel);
+-
++
+ if(!g_send_eof)
+ {
+ res = globus_ftp_control_local_send_eof(
+@@ -1082,7 +1082,7 @@ transfer_test(
+ if(res == GLOBUS_SUCCESS)
+ {
+ globus_mutex_lock(&done_monitor.mutex);
+- {
++ {
+ while(!done_monitor.done)
+ {
+ globus_cond_wait(&done_monitor.cond, &done_monitor.mutex);
+@@ -1136,12 +1136,12 @@ connect_read_big_buffer_callback(
+ globus_result_t res;
+
+ test_info = (data_test_info_t *)callback_arg;
+-
+- verbose_printf(3,
+- "connect_read_big_buffer_callback() : start\n");
++
++ verbose_printf(3,
++ "connect_read_big_buffer_callback() : start\n");
+ if(error != GLOBUS_NULL)
+ {
+- test_result(globus_error_put(error),
++ test_result(globus_error_put(error),
+ "connect_read_big_buffer_callback error", __LINE__);
+ }
+
+@@ -1194,8 +1194,8 @@ connect_read_callback(
+ globus_result_t res;
+
+ test_info = (data_test_info_t *)callback_arg;
+-
+- verbose_printf(3, "connect_read_callback() : start\n");
++
++ verbose_printf(3, "connect_read_callback() : start\n");
+ if(error != GLOBUS_NULL)
+ {
+ test_result(globus_error_put(error), "connect_read_callback error"
+@@ -1213,7 +1213,7 @@ connect_read_callback(
+ {
+ failure_end("stat failed\n");
+ }
+- write_blk_size = stat_info.st_size / WRITE_CHUNK_COUNT + 1;
++ write_blk_size = stat_info.st_size / WRITE_CHUNK_COUNT + 1;
+ blk_size = write_blk_size / 2 + 1;
+
+ buf = (globus_byte_t *)malloc(blk_size);
+@@ -1239,10 +1239,10 @@ data_read_big_buffer_callback(
+ globus_off_t offset_read,
+ globus_bool_t eof)
+ {
+- data_test_info_t * test_info;
++ data_test_info_t * test_info;
+
+- verbose_printf(4,
+- "data_read_big_buffer_callback():start %d %d %d\n",
++ verbose_printf(4,
++ "data_read_big_buffer_callback():start %d %d %d\n",
+ length_read, offset_read, eof);
+
+ if(error != GLOBUS_NULL)
+@@ -1262,8 +1262,8 @@ data_read_big_buffer_callback(
+ {
+ verbose_printf(3, "eof big buffer callback\n");
+ /* write out the entire buffer */
+-
+- if(fwrite(buffer, 1, test_info->bb_len, test_info->fout)
++
++ if(fwrite(buffer, 1, test_info->bb_len, test_info->fout)
+ != test_info->bb_len)
+ {
+ failure_end("fwrite failed\n");
+@@ -1276,7 +1276,7 @@ data_read_big_buffer_callback(
+ {
+ verbose_printf(1, "files are not the same: %d\n", __LINE__);
+ test_info->monitor->done = GLOBUS_TRUE;
+- test_info->monitor->result =
++ test_info->monitor->result =
+ globus_error_put(GLOBUS_ERROR_NO_INFO);
+ globus_cond_signal(&test_info->monitor->cond);
+ }
+@@ -1331,10 +1331,10 @@ connect_write_big_buffer_callback(
+ {
+ failure_end("stat failed\n");
+ }
+-
++
+ offset = 0;
+ fseek(test_info->fin, offset, SEEK_SET);
+- blk_size = stat_info.st_size / WRITE_CHUNK_COUNT + 1;
++ blk_size = stat_info.st_size / WRITE_CHUNK_COUNT + 1;
+ for(ctr = 0; ctr < WRITE_CHUNK_COUNT; ctr++)
+ {
+ buf = globus_malloc(blk_size);
+@@ -1342,7 +1342,7 @@ connect_write_big_buffer_callback(
+ /*
+ * read a chunk
+ */
+- nbyte = fread(buf, 1, blk_size, test_info->fin);
++ nbyte = fread(buf, 1, blk_size, test_info->fin);
+ if(nbyte < blk_size)
+ {
+ if(feof(test_info->fin))
+@@ -1368,7 +1368,7 @@ connect_write_big_buffer_callback(
+ nbyte,
+ offset,
+ eof,
+- data_write_callback,
++ data_write_callback,
+ (void *)test_info);
+ test_result(res, "data_write", __LINE__);
+ offset += nbyte;
+@@ -1377,7 +1377,7 @@ connect_write_big_buffer_callback(
+ globus_mutex_unlock(&test_info->monitor->mutex);
+ }
+
+-void
++void
+ data_read_callback(
+ void * callback_arg,
+ globus_ftp_control_handle_t * handle,
+@@ -1387,12 +1387,12 @@ data_read_callback(
+ globus_off_t offset,
+ globus_bool_t eof)
+ {
+- data_test_info_t * test_info;
++ data_test_info_t * test_info;
+ globus_result_t res;
+ int blk_size;
+ globus_byte_t * buf;
+
+- verbose_printf(4, "data_read_callback() : start\n");
++ verbose_printf(4, "data_read_callback() : start\n");
+ if(error != GLOBUS_NULL)
+ {
+ failure_end("data_read_callback error\n");
+@@ -1420,7 +1420,7 @@ data_read_callback(
+ {
+ verbose_printf(1, "files are not the same: %d\n", __LINE__);
+ test_info->monitor->done = GLOBUS_TRUE;
+- test_info->monitor->result =
++ test_info->monitor->result =
+ globus_error_put(GLOBUS_ERROR_NO_INFO);
+ globus_cond_signal(&test_info->monitor->cond);
+ }
+@@ -1492,8 +1492,8 @@ connect_write_callback(
+ {
+ failure_end("stat failed\n");
+ }
+-
+- blk_size = stat_info.st_size / WRITE_CHUNK_COUNT + 1;
++
++ blk_size = stat_info.st_size / WRITE_CHUNK_COUNT + 1;
+ for(ctr = 0; ctr < WRITE_CHUNK_COUNT; ctr++)
+ {
+ buf = globus_malloc(blk_size);
+@@ -1501,7 +1501,7 @@ connect_write_callback(
+ /*
+ * read a chunk
+ */
+- nbyte = fread(buf, 1, blk_size, test_info->fin);
++ nbyte = fread(buf, 1, blk_size, test_info->fin);
+ if(nbyte < blk_size)
+ {
+ if(feof(test_info->fin))
+@@ -1518,7 +1518,7 @@ connect_write_callback(
+ /*
+ * write a chunk
+ */
+- verbose_printf(4,
++ verbose_printf(4,
+ "registering a write 0x%x offset=%d length=%d eof=%d\n",
+ buf, offset, nbyte, eof);
+ res = globus_ftp_control_data_write(
+@@ -1527,7 +1527,7 @@ connect_write_callback(
+ nbyte,
+ offset,
+ eof,
+- data_write_callback,
++ data_write_callback,
+ (void *)test_info);
+ test_result(res, "data_write", __LINE__);
+ offset += nbyte;
+@@ -1592,7 +1592,7 @@ connect_write_zero_eof_callback(
+ /*
+ * write a chunk
+ */
+- verbose_printf(4,
++ verbose_printf(4,
+ "registering a write 0x%x offset=%d length=%d eof=%d\n",
+ buf, offset, nbyte, eof);
+ res = globus_ftp_control_data_write(
+@@ -1605,7 +1605,7 @@ connect_write_zero_eof_callback(
+ (void *)test_info);
+ test_result(res, "data_write", __LINE__);
+ offset += nbyte;
+-
++
+ res = globus_ftp_control_data_write(
+ handle,
+ buf,
+@@ -1658,7 +1658,7 @@ data_write_callback(
+ globus_cond_signal(&test_info->monitor->cond);
+ }
+ globus_mutex_unlock(&test_info->monitor->mutex);
+- }
++ }
+ if(length > 0 &&!eof)
+ {
+ globus_free(buffer);
+@@ -1776,7 +1776,7 @@ diff(
+ do
+ {
+ b += fread(dbuf + b, 1, a-b, dfp);
+- }
++ }
+ while (b > 0 && b < a && (!feof(dfp)) && (!ferror(dfp)));
+
+ if (a == b)
+diff --git a/gridftp/control/source/test/globus_ftp_control_test.c b/gridftp/control/source/test/globus_ftp_control_test.c
+index 4d68e44f2..32ca2946f 100644
+--- a/gridftp/control/source/test/globus_ftp_control_test.c
++++ b/gridftp/control/source/test/globus_ftp_control_test.c
+@@ -57,8 +57,8 @@ abort_test_wrapper(
+ * a string describing it to the "test_array" table, and
+ * increase the TEST_COUNT by one.
+ ****************************************************************/
+-typedef
+-globus_bool_t
++typedef
++globus_bool_t
+ (*globus_ftp_control_test_func_t)(
+ globus_ftp_control_handle_t * control_handle);
+
+@@ -74,7 +74,7 @@ test_entry_t test_array[] =
+ {disconnect_wrapper, "disconnect handle test"},
+ {simple_dir_test_wrapper, "simple directory test"},
+ {simple_data_test_wrapper, "simple data test"},
+- {abort_test_wrapper, "abort test"},
++ {abort_test_wrapper, "abort test"},
+ {outstanding_io_test_wrapper, "outstanding io data test"},
+ {simple_control_test_wrapper, "simple control test"},
+ {async_control_test, "asynchronous control test"},
+@@ -99,11 +99,11 @@ login_t login_info = {
+ 0
+ };
+ extern int verbose_print_level;
+-int
++int
+ main(
+ int argc,
+ char * argv[])
+-{
++{
+ int ctr;
+ globus_ftp_control_handle_t control_handle;
+ globus_result_t result;
+@@ -171,7 +171,7 @@ main(
+ tests_run++;
+ result = globus_ftp_control_handle_init(&handles[0]);
+ connect_control_handle(
+- &handles[0],
++ &handles[0],
+ login_info.login,
+ login_info.password,
+ login_info.dir,
+@@ -192,8 +192,8 @@ main(
+ if(result != GLOBUS_SUCCESS)
+ {
+ tests_failed++;
+- verbose_printf(1,
+- "activate/deactivate test # %d failed\n",
++ verbose_printf(1,
++ "activate/deactivate test # %d failed\n",
+ tests_run);
+ exit(1);
+ }
+@@ -203,8 +203,8 @@ main(
+ if(result != GLOBUS_SUCCESS)
+ {
+ tests_failed++;
+- verbose_printf(1,
+- "activate/deactivate test # %d failed\n",
++ verbose_printf(1,
++ "activate/deactivate test # %d failed\n",
+ tests_run);
+ exit(1);
+ }
+@@ -214,15 +214,15 @@ main(
+ if(result != GLOBUS_SUCCESS)
+ {
+ tests_failed++;
+- verbose_printf(1,
+- "activate/deactivate test # %d failed\n",
++ verbose_printf(1,
++ "activate/deactivate test # %d failed\n",
+ tests_run);
+ exit(1);
+ }
+ tests_passed++;
+ verbose_printf(1, "test #%d) activate/deactivate passed\n", tests_run);
+
+-
++
+ /*
+ * initailize variables for the test
+ */
+@@ -249,14 +249,14 @@ main(
+ if(eb_test_array[ctr].test_func(&control_handle))
+ {
+ tests_passed++;
+- verbose_printf(1, "test #%d) \"%s\" passed.\n",
++ verbose_printf(1, "test #%d) \"%s\" passed.\n",
+ tests_run, eb_test_array[ctr].name);
+ }
+ else
+ {
+ tests_failed++;
+ printf("Failed\n");
+- verbose_printf(1, "test #%d) \"%s\" failed.\n",
++ verbose_printf(1, "test #%d) \"%s\" failed.\n",
+ tests_run, eb_test_array[ctr].name);
+ exit(1);
+ }
+@@ -270,14 +270,14 @@ main(
+ if(test_array[ctr].test_func(&control_handle))
+ {
+ tests_passed++;
+- verbose_printf(1, "test #%d) \"%s\" passed.\n",
++ verbose_printf(1, "test #%d) \"%s\" passed.\n",
+ tests_run, test_array[ctr].name);
+ }
+ else
+ {
+ tests_failed++;
+ printf("Failed\n");
+- verbose_printf(1, "test #%d) \"%s\" failed.\n",
++ verbose_printf(1, "test #%d) \"%s\" failed.\n",
+ tests_run, test_array[ctr].name);
+ exit(1);
+ }
+@@ -310,12 +310,12 @@ simple_control_test_wrapper(
+ login_info.dir,
+ login_info.hostname,
+ login_info.port);
+- if(rc)
++ if(rc)
+ {
+ rc = simple_control_test(control_handle);
+ }
+ if(rc)
+- {
++ {
+ rc = disconnect_control_handle(control_handle);
+ }
+
+@@ -362,14 +362,14 @@ simple_data_test_wrapper(
+ {
+ rc = simple_data_test(control_handle);
+ }
+- if(rc)
++ if(rc)
+ {
+ rc = disconnect_control_handle(control_handle);
+ }
+
+ return rc;
+ }
+-
++
+ globus_bool_t
+ eb_simple_data_test_wrapper(
+ globus_ftp_control_handle_t * control_handle)
+@@ -386,14 +386,14 @@ eb_simple_data_test_wrapper(
+ {
+ rc = eb_data_test(control_handle);
+ }
+- if(rc)
++ if(rc)
+ {
+ rc = disconnect_control_handle(control_handle);
+ }
+
+ return rc;
+ }
+-
++
+ globus_bool_t
+ outstanding_io_test_wrapper(
+ globus_ftp_control_handle_t * control_handle)
+@@ -406,11 +406,11 @@ outstanding_io_test_wrapper(
+ login_info.dir,
+ login_info.hostname,
+ login_info.port);
+- if(rc)
++ if(rc)
+ {
+ rc = outstanding_io_test(control_handle);
+ }
+- if(rc)
++ if(rc)
+ {
+ rc = disconnect_control_handle(control_handle);
+ }
+@@ -464,4 +464,4 @@ abort_test_wrapper(
+ }
+
+ return rc;
+-}
++}
+diff --git a/gridftp/control/source/test/test_server.c b/gridftp/control/source/test/test_server.c
+index d0274624a..805acee2e 100644
+--- a/gridftp/control/source/test/test_server.c
++++ b/gridftp/control/source/test/test_server.c
+@@ -119,7 +119,7 @@ gpftpd_ac_response_callback(
+ void * callback_arg,
+ globus_ftp_control_handle_t * handle,
+ globus_object_t * error)
+-{
++{
+ globus_result_t result;
+ result = globus_ftp_control_read_commands(
+ handle,
+@@ -227,7 +227,7 @@ gpftpd_accept_callback(
+ callback_arg);
+ }
+
+-void
++void
+ gpftpd_listen_callback(
+ void * callback_arg,
+ globus_ftp_control_server_t * server_handle,
+--
+2.54.0
+
diff --git a/0002-Fix-compiler-and-doxygen-warnings.patch b/0002-Fix-compiler-and-doxygen-warnings.patch
new file mode 100644
index 0000000..bf1b3e8
--- /dev/null
+++ b/0002-Fix-compiler-and-doxygen-warnings.patch
@@ -0,0 +1,366 @@
+From 4ee08d13e2963309e2063dc45dedd067337d3b76 Mon Sep 17 00:00:00 2001
+From: Mattias Ellert <mattias.ellert@physics.uu.se>
+Date: Wed, 20 May 2026 00:15:37 +0200
+Subject: [PATCH 2/2] Fix compiler and doxygen warnings
+
+---
+ .../control/source/globus_ftp_control_data.c | 21 +---------
+ .../source/globus_ftp_control_server.c | 41 ++++++++++---------
+ .../source/test/connect_disconnect_test.c | 4 +-
+ gridftp/control/source/test/connect_test.c | 5 +--
+ gridftp/control/source/test/data_test.c | 2 -
+ .../control/source/test/get_lingering_close.c | 4 +-
+ .../source/test/globus_ftp_control_test.c | 14 +++----
+ gridftp/control/source/test/test_server.c | 7 +---
+ 8 files changed, 39 insertions(+), 59 deletions(-)
+
+diff --git a/gridftp/control/source/globus_ftp_control_data.c b/gridftp/control/source/globus_ftp_control_data.c
+index 619aa4810..533e0fbd7 100644
+--- a/gridftp/control/source/globus_ftp_control_data.c
++++ b/gridftp/control/source/globus_ftp_control_data.c
+@@ -2491,7 +2491,6 @@ globus_ftp_control_data_get_remote_hosts(
+ globus_ftp_data_connection_t * data_conn;
+ int ctr;
+ int ndx;
+- int count;
+ static char * myname=
+ "globus_ftp_control_data_get_remote_hosts";
+
+@@ -2565,13 +2564,6 @@ globus_ftp_control_data_get_remote_hosts(
+ return res;
+ }
+
+- /* count the total # of connections */
+- count = 0;
+- for(ctr = 0; ctr < transfer_handle->stripe_count; ctr++)
+- {
+- count += globus_list_size(transfer_handle->stripes[ctr].all_conn_list);
+- }
+-
+ ndx = 0;
+ for(ctr = 0; ctr < transfer_handle->stripe_count &&
+ ndx < *addr_count; ctr++)
+@@ -8219,7 +8211,6 @@ globus_l_ftp_io_close_callback(
+ globus_l_ftp_data_callback_info_t * callback_info;
+ globus_ftp_control_data_callback_t eof_callback = GLOBUS_NULL;
+ globus_l_ftp_handle_table_entry_t * eof_cb_ent;
+- globus_bool_t poll;
+
+ callback_info = (globus_l_ftp_data_callback_info_t *)arg;
+
+@@ -8266,13 +8257,13 @@ globus_l_ftp_io_close_callback(
+
+ globus_mutex_lock(&dc_handle->mutex);
+ {
+- poll = !globus_l_ftp_control_dc_dec_ref(transfer_handle);
++ globus_l_ftp_control_dc_dec_ref(transfer_handle);
+ /*
+ * decrement the reference the callbacks had
+ */
+ if(eof_callback != GLOBUS_NULL)
+ {
+- poll = !globus_l_ftp_control_dc_dec_ref(transfer_handle);
++ globus_l_ftp_control_dc_dec_ref(transfer_handle);
+ }
+ }
+ globus_mutex_unlock(&dc_handle->mutex);
+@@ -8293,14 +8284,6 @@ globus_l_ftp_io_close_callback(
+ data_conn->free_me = GLOBUS_TRUE;
+ }
+ }
+-
+- /*
+- This is not needed and introduces a race
+- if(poll)
+- {
+- globus_l_ftp_data_stripe_poll(dc_handle);
+- }
+- */
+ }
+
+
+diff --git a/gridftp/control/source/globus_ftp_control_server.c b/gridftp/control/source/globus_ftp_control_server.c
+index 01547b936..3060531c9 100644
+--- a/gridftp/control/source/globus_ftp_control_server.c
++++ b/gridftp/control/source/globus_ftp_control_server.c
+@@ -1253,7 +1253,6 @@ globus_ftp_control_server_authenticate(
+ globus_ftp_control_auth_callback_t callback,
+ void * callback_arg)
+ {
+- globus_object_t * error = GLOBUS_NULL;
+ globus_ftp_cc_handle_t * cc_handle;
+ globus_result_t rc;
+ globus_result_t rc2;
+@@ -1298,7 +1297,6 @@ globus_ftp_control_server_authenticate(
+ &(cc_handle->auth_info),GLOBUS_NULL);
+ if(rc != GLOBUS_SUCCESS)
+ {
+- error=globus_error_get(rc);
+ goto error_std;
+ }
+
+@@ -1316,7 +1314,6 @@ globus_ftp_control_server_authenticate(
+
+ if (rc != GLOBUS_SUCCESS)
+ {
+- error = globus_error_get(rc);
+ goto error_std;
+ }
+
+@@ -1330,11 +1327,12 @@ globus_ftp_control_server_authenticate(
+ || cc_handle->auth_info.auth_gssapi_context
+ == GSS_C_NO_CONTEXT)
+ {
+- error = globus_error_construct_string(
+- GLOBUS_FTP_CONTROL_MODULE,
+- (rc != GLOBUS_SUCCESS) ? globus_error_get(rc) : NULL,
+- _FCSL("TLS control channel not established"));
+-
++ rc = globus_error_put(
++ globus_error_construct_string(
++ GLOBUS_FTP_CONTROL_MODULE,
++ (rc != GLOBUS_SUCCESS) ? globus_error_get(rc) : NULL,
++ _FCSL("TLS control channel not established"))
++ );
+ goto error_std;
+ }
+
+@@ -1358,10 +1356,12 @@ globus_ftp_control_server_authenticate(
+
+ if (maj_stat != GSS_S_COMPLETE)
+ {
+- error = globus_error_construct_string(
+- GLOBUS_FTP_CONTROL_MODULE,
+- globus_error_get(min_stat),
+- _FCSL("gss_inquire_context failed"));
++ rc = globus_error_put(
++ globus_error_construct_string(
++ GLOBUS_FTP_CONTROL_MODULE,
++ globus_error_get(min_stat),
++ _FCSL("gss_inquire_context failed"))
++ );
+ goto error_std;
+ }
+
+@@ -1378,10 +1378,12 @@ globus_ftp_control_server_authenticate(
+
+ if (maj_stat != GSS_S_COMPLETE)
+ {
+- error = globus_error_construct_string(
+- GLOBUS_FTP_CONTROL_MODULE,
+- NULL,
+- _FCSL("gss_display_name failed"));
++ rc = globus_error_put(
++ globus_error_construct_string(
++ GLOBUS_FTP_CONTROL_MODULE,
++ NULL,
++ _FCSL("gss_display_name failed"))
++ );
+ goto error_std;
+ }
+ cc_handle->auth_info.auth_gssapi_subject
+@@ -1391,10 +1393,12 @@ globus_ftp_control_server_authenticate(
+ {
+ gss_release_buffer(&min_stat, &subject_buf);
+
+- error = globus_error_construct_string(
++ rc = globus_error_put(
++ globus_error_construct_string(
+ GLOBUS_FTP_CONTROL_MODULE,
+ GLOBUS_NULL,
+- _FCSL("globus_l_ftp_control_auth_read_cb: malloc failed"));
++ _FCSL("globus_l_ftp_control_auth_read_cb: malloc failed"))
++ );
+ goto error_std;
+ }
+
+@@ -1415,7 +1419,6 @@ globus_ftp_control_server_authenticate(
+ handle);
+ if(rc != GLOBUS_SUCCESS)
+ {
+- error=globus_error_get(rc);
+ goto error_std;
+ }
+
+diff --git a/gridftp/control/source/test/connect_disconnect_test.c b/gridftp/control/source/test/connect_disconnect_test.c
+index 92673a84a..bf47a474a 100644
+--- a/gridftp/control/source/test/connect_disconnect_test.c
++++ b/gridftp/control/source/test/connect_disconnect_test.c
+@@ -73,10 +73,10 @@ connect_response_callback(
+ {
+ memset(&auth, '\0', sizeof(auth));
+ {
+- OM_uint32 maj, min;
++ OM_uint32 min;
+ gss_buffer_desc buffer;
+
+- maj = gss_acquire_cred(
++ gss_acquire_cred(
+ &min,
+ GSS_C_NO_NAME,
+ 0,
+diff --git a/gridftp/control/source/test/connect_test.c b/gridftp/control/source/test/connect_test.c
+index e1cb59809..9f9ab9ee9 100644
+--- a/gridftp/control/source/test/connect_test.c
++++ b/gridftp/control/source/test/connect_test.c
+@@ -954,19 +954,18 @@ globus_l_server_accept_callback(
+ globus_ftp_control_handle_t * handle,
+ globus_object_t * error)
+ {
+- globus_result_t res;
+ auth_test_server_session_t *session = callback_arg;
+
+ if (error != NULL)
+ {
+ session->server_state = SERVER_DONE;
+- res = globus_ftp_control_force_close(
++ globus_ftp_control_force_close(
+ handle,
+ globus_l_server_close_callback,
+ callback_arg);
+ }
+
+- res = globus_ftp_control_send_response(
++ globus_ftp_control_send_response(
+ handle,
+ "220 Globus GridFTP Test Server\r\n",
+ globus_l_server_response_callback,
+diff --git a/gridftp/control/source/test/data_test.c b/gridftp/control/source/test/data_test.c
+index b708747ef..ba5d9e610 100644
+--- a/gridftp/control/source/test/data_test.c
++++ b/gridftp/control/source/test/data_test.c
+@@ -735,7 +735,6 @@ globus_result_t
+ cache_multiparallel_test(
+ set_handle_mode_cb_t mode_cb)
+ {
+- int ctr;
+ int ctr2;
+ globus_result_t res;
+ globus_ftp_control_host_port_t host_port;
+@@ -769,7 +768,6 @@ cache_multiparallel_test(
+ for(ctr2 = 0; nsock_a[ctr2] != 0; ctr2++)
+ {
+ verbose_printf(2, "parallel level %d\n", nsock_a[ctr2]);
+-// for(ctr = 0; ctr < TEST_ITERATIONS; ctr++)
+ {
+ mode_cb(&pasv_handle, nsock_a[ctr2]);
+ mode_cb(&port_handle, nsock_a[ctr2]);
+diff --git a/gridftp/control/source/test/get_lingering_close.c b/gridftp/control/source/test/get_lingering_close.c
+index fa10030d8..3fa6925dd 100644
+--- a/gridftp/control/source/test/get_lingering_close.c
++++ b/gridftp/control/source/test/get_lingering_close.c
+@@ -59,13 +59,13 @@ response_cb(
+ {
+ if(response->code == 220)
+ {
+- OM_uint32 maj, min;
++ OM_uint32 min;
+ gss_buffer_desc buffer;
+ gss_cred_id_t g_cred;
+ gss_name_t g_name;
+ char * g_subject;
+
+- maj = gss_acquire_cred(
++ gss_acquire_cred(
+ &min,
+ GSS_C_NO_NAME,
+ 0,
+diff --git a/gridftp/control/source/test/globus_ftp_control_test.c b/gridftp/control/source/test/globus_ftp_control_test.c
+index 32ca2946f..01575ab51 100644
+--- a/gridftp/control/source/test/globus_ftp_control_test.c
++++ b/gridftp/control/source/test/globus_ftp_control_test.c
+@@ -167,7 +167,7 @@ main(
+ /*
+ * first test
+ */
+- rc = globus_module_activate(GLOBUS_FTP_CONTROL_MODULE);
++ globus_module_activate(GLOBUS_FTP_CONTROL_MODULE);
+ tests_run++;
+ result = globus_ftp_control_handle_init(&handles[0]);
+ connect_control_handle(
+@@ -177,14 +177,14 @@ main(
+ login_info.dir,
+ login_info.hostname,
+ login_info.port);
+- rc = globus_module_deactivate(GLOBUS_FTP_CONTROL_MODULE);
++ globus_module_deactivate(GLOBUS_FTP_CONTROL_MODULE);
+ tests_passed++;
+ verbose_printf(1, "test #%d) activate/connect/deactivate passed\n", tests_run);
+
+ /*
+ * second test
+ */
+- rc = globus_module_activate(GLOBUS_FTP_CONTROL_MODULE);
++ globus_module_activate(GLOBUS_FTP_CONTROL_MODULE);
+ tests_run++;
+ for(ctr = 0; ctr < TEST_COUNT; ctr++)
+ {
+@@ -211,7 +211,7 @@ main(
+ }
+ }
+ rc = globus_module_deactivate(GLOBUS_FTP_CONTROL_MODULE);
+- if(result != GLOBUS_SUCCESS)
++ if(rc != GLOBUS_SUCCESS)
+ {
+ tests_failed++;
+ verbose_printf(1,
+@@ -227,7 +227,7 @@ main(
+ * initailize variables for the test
+ */
+ rc = globus_module_activate(GLOBUS_COMMON_MODULE);
+- if(result != GLOBUS_SUCCESS)
++ if(rc != GLOBUS_SUCCESS)
+ {
+ globus_libc_printf("unable to activate common module\n");
+ exit(1);
+@@ -236,7 +236,7 @@ main(
+ * run stream mode tests
+ */
+ rc = globus_module_activate(GLOBUS_FTP_CONTROL_MODULE);
+- if(result != GLOBUS_SUCCESS)
++ if(rc != GLOBUS_SUCCESS)
+ {
+ globus_libc_printf("unable to activate gsiftp module\n");
+ exit(1);
+@@ -285,7 +285,7 @@ main(
+ globus_ftp_control_handle_destroy(&control_handle);
+
+ rc = globus_module_deactivate(GLOBUS_FTP_CONTROL_MODULE);
+- if(result != GLOBUS_SUCCESS)
++ if(rc != GLOBUS_SUCCESS)
+ {
+ globus_libc_printf("unable to activate gsiftp module\n");
+ exit(1);
+diff --git a/gridftp/control/source/test/test_server.c b/gridftp/control/source/test/test_server.c
+index 805acee2e..56b94c530 100644
+--- a/gridftp/control/source/test/test_server.c
++++ b/gridftp/control/source/test/test_server.c
+@@ -120,8 +120,7 @@ gpftpd_ac_response_callback(
+ globus_ftp_control_handle_t * handle,
+ globus_object_t * error)
+ {
+- globus_result_t result;
+- result = globus_ftp_control_read_commands(
++ globus_ftp_control_read_commands(
+ handle,
+ gpftpd_command_callback,
+ callback_arg);
+@@ -213,14 +212,12 @@ gpftpd_accept_callback(
+ globus_ftp_control_handle_t * handle,
+ globus_object_t * error)
+ {
+- globus_result_t res;
+-
+ if(error)
+ {
+ error_msg(globus_error_put(error), __LINE__);
+ }
+
+- res = globus_ftp_control_send_response(
++ globus_ftp_control_send_response(
+ handle,
+ "220 Globus GridFTP Test Server\r\n",
+ gpftpd_response_callback,
+--
+2.54.0
+
diff --git a/globus-ftp-control.spec b/globus-ftp-control.spec
index 0c5476e..cc6fcef 100644
--- a/globus-ftp-control.spec
+++ b/globus-ftp-control.spec
@@ -1,13 +1,15 @@
Name: globus-ftp-control
%global _name %(tr - _ <<< %{name})
Version: 9.10
-Release: 10%{?dist}
+Release: 11%{?dist}
Summary: Grid Community Toolkit - GridFTP Control Library
License: Apache-2.0
URL: https://github.com/gridcf/gct/
Source: https://repo.gridcf.org/gct6/sources/%{_name}-%{version}.tar.gz
Source8: README
+Patch0: 0001-Untabify-and-remove-trailing-white-space.patch
+Patch1: 0002-Fix-compiler-and-doxygen-warnings.patch
BuildRequires: make
BuildRequires: gcc
@@ -67,6 +69,8 @@ GridFTP Control Library Documentation Files
%prep
%setup -q -n %{_name}-%{version}
+%patch -P0 -p4
+%patch -P1 -p4
%build
# Reduce overlinking
@@ -118,6 +122,9 @@ GLOBUS_HOSTNAME=localhost %make_build check
%license GLOBUS_LICENSE
%changelog
+* Sun Jun 14 2026 Mattias Ellert <mattias.ellert@physics.uu.se> - 9.10-11
+- Fix compiler warnings
+
* Fri Jan 16 2026 Fedora Release Engineering <releng@fedoraproject.org> - 9.10-10
- Rebuilt for https://fedoraproject.org/wiki/Fedora_44_Mass_Rebuild
reply other threads:[~2026-06-14 8:46 UTC|newest]
Thread overview: [no followups] expand[flat|nested] mbox.gz Atom feed
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=178142676544.1.2775375303281980534.rpms-globus-ftp-control-810997f54f4a@fedoraproject.org \
--to=mattias.ellert@physics.uu.se \
--cc=git-commits@fedoraproject.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox