public inbox for git-commits@fedoraproject.org
help / color / mirror / Atom feed
* [rpms/globus-gridftp-server] rawhide: Fix compiler warnings
@ 2026-06-14 8:47 Mattias Ellert
0 siblings, 0 replies; only message in thread
From: Mattias Ellert @ 2026-06-14 8:47 UTC (permalink / raw)
To: git-commits
A new commit has been pushed.
Repo : rpms/globus-gridftp-server
Branch : rawhide
Commit : 9ddaecef6e4f57c9561462a6c16c4047132fbd31
Author : Mattias Ellert <mattias.ellert@physics.uu.se>
Date : 2026-06-14T10:39:13+02:00
Stats : +12018/-1 in 3 file(s)
URL : https://src.fedoraproject.org/rpms/globus-gridftp-server/c/9ddaecef6e4f57c9561462a6c16c4047132fbd31?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..8f5897c
--- /dev/null
+++ b/0001-Untabify-and-remove-trailing-white-space.patch
@@ -0,0 +1,11689 @@
+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
+
+---
+ gridftp/server/src/gfs_dynbe_client.c | 4 +-
+ gridftp/server/src/gfs_gfork_master.c | 44 +-
+ gridftp/server/src/globus_i_gfs_config.c | 590 +++----
+ gridftp/server/src/globus_i_gfs_control.c | 314 ++--
+ gridftp/server/src/globus_i_gfs_data.c | 1468 ++++++++---------
+ .../server/src/globus_i_gfs_default_brain.c | 36 +-
+ .../modules/file/globus_gridftp_server_file.c | 692 ++++----
+ .../remote/globus_gridftp_server_remote.c | 342 ++--
+ 8 files changed, 1745 insertions(+), 1745 deletions(-)
+
+diff --git a/gridftp/server/src/gfs_dynbe_client.c b/gridftp/server/src/gfs_dynbe_client.c
+index 62134e0a6..9c132d5f6 100644
+--- a/gridftp/server/src/gfs_dynbe_client.c
++++ b/gridftp/server/src/gfs_dynbe_client.c
+@@ -40,7 +40,7 @@
+ "%s", \
+ (error_msg)))
+
+-enum
++enum
+ {
+ GLOBUS_DYNCLIENT_ERROR_PARM = 1
+ };
+@@ -219,7 +219,7 @@ main(
+ goto error_open;
+ }
+ result = globus_xio_write(
+- g_xio_handle, buffer,
++ g_xio_handle, buffer,
+ GF_DYN_PACKET_LEN, GF_DYN_PACKET_LEN, &nbytes, NULL);
+ if(result != GLOBUS_SUCCESS)
+ {
+diff --git a/gridftp/server/src/gfs_gfork_master.c b/gridftp/server/src/gfs_gfork_master.c
+index ac49e7d24..91b201459 100644
+--- a/gridftp/server/src/gfs_gfork_master.c
++++ b/gridftp/server/src/gfs_gfork_master.c
+@@ -17,7 +17,7 @@
+ /* This is ment to be a fairly simple program. If it starts creeping too
+ much we need to reconsider it */
+
+-/* TODO:
++/* TODO:
+ 1) memory limitation, perhaps just implemented in brain based on
+ connection count?
+
+@@ -50,7 +50,7 @@
+ #define GFSGForkFuncName(func) static const char * _gfs_gfork_func_name = #func
+ #endif
+
+-#define GFSGforkTopNiceShare(_val) ((_val * 9) / 10)
++#define GFSGforkTopNiceShare(_val) ((_val * 9) / 10)
+
+ #define GFSGforkSizeOfIdleServer (2*1024*1024)
+
+@@ -138,7 +138,7 @@ typedef struct gfs_l_gfork_master_entry_s
+
+
+ static
+-void
++void
+ gfs_l_gfork_write_close_cb(
+ globus_xio_handle_t handle,
+ globus_result_t result,
+@@ -178,7 +178,7 @@ gfs_l_gfork_log(
+ fflush(g_log_fptr);
+ }
+
+-static
++static
+ void
+ gfs_l_gfork_timeout(
+ void * user_arg)
+@@ -404,7 +404,7 @@ gfs_l_gfork_read_dynbe_bc_cb(
+ int i;
+
+ for(i = 0; i < count; i++)
+- {
++ {
+ globus_free(iovec[i].iov_base);
+ }
+ }
+@@ -483,7 +483,7 @@ gfs_l_gfork_read_dynbe(
+ &g_gfork_be_table, table_key);
+ if(ent_buf == NULL)
+ {
+- ent_buf = (gfs_l_gfork_master_entry_t *)
++ ent_buf = (gfs_l_gfork_master_entry_t *)
+ globus_calloc(1, sizeof(gfs_l_gfork_master_entry_t));
+ memcpy(ent_buf->buffer, buffer, GF_DYN_PACKET_LEN);
+
+@@ -527,7 +527,7 @@ gfs_l_gfork_read_dynbe(
+ gfs_l_gfork_write_close_cb,
+ buffer);
+ globus_free(buffer);
+- goto error_cs;
++ goto error_cs;
+ }
+ iov[0].iov_base = malloc(GF_DYN_PACKET_LEN);
+ memcpy(iov[0].iov_base, buffer, GF_DYN_PACKET_LEN);
+@@ -882,7 +882,7 @@ gfs_l_gfork_dyn_be_open(
+ {
+ /* a good buffer */
+
+- /* temparily assign ent_buf here, we ultimatale
++ /* temparily assign ent_buf here, we ultimatale
+ want ent_buf-> buffer */
+ iov[i].iov_base = ent_buf;
+ iov[i].iov_len = GF_DYN_PACKET_LEN;
+@@ -1112,7 +1112,7 @@ gfs_l_gfork_ready_send(
+ handle,
+ to_pid,
+ &iov,
+- 1,
++ 1,
+ gfs_l_gfork_free_write_cb,
+ NULL);
+ if(result != GLOBUS_SUCCESS)
+@@ -1121,7 +1121,7 @@ gfs_l_gfork_ready_send(
+ result, 3, "failed to send to %d\n", to_pid);
+ }
+ }
+-
++
+ static
+ void
+ gfs_l_gfork_mem_try(
+@@ -1166,7 +1166,7 @@ gfs_l_gfork_mem_try(
+
+ entry->mem_size += mem_given;
+ entry->tcp_buffer_mem = mem_given / 3;
+-
++
+ globus_hashtable_insert(
+ &gfs_l_memlimit_table, (void *) (intptr_t) entry->pid, entry);
+
+@@ -1348,7 +1348,7 @@ gfs_l_gfork_incoming_cb(
+ {
+ if(buffer[GF_VERSION_NDX] != GF_VERSION)
+ {
+- gfs_l_gfork_log(GLOBUS_SUCCESS, 0,
++ gfs_l_gfork_log(GLOBUS_SUCCESS, 0,
+ "Incoming message with bad version, ignoring.");
+ goto error;
+ }
+@@ -1357,7 +1357,7 @@ gfs_l_gfork_incoming_cb(
+ &gfs_l_memlimit_table, (void *) (intptr_t) from_pid);
+ if(entry == NULL)
+ {
+- gfs_l_gfork_log(GLOBUS_SUCCESS, 0,
++ gfs_l_gfork_log(GLOBUS_SUCCESS, 0,
+ "Incoming message from unknown pid %d", from_pid);
+ goto error;
+ }
+@@ -1366,11 +1366,11 @@ gfs_l_gfork_incoming_cb(
+ {
+ case GFS_GFORK_MSG_TYPE_RELEASE:
+
+- memcpy(&tmp32,
++ memcpy(&tmp32,
+ &buffer[GF_RELEASE_COUNT_NDX], GF_RELEASE_COUNT_LEN);
+ if(tmp32 > 0)
+ {
+- gfs_l_gfork_log(GLOBUS_SUCCESS, 0,
++ gfs_l_gfork_log(GLOBUS_SUCCESS, 0,
+ "Pid %d returning %d bytes.\n", from_pid, (int)tmp32);
+
+ diff = entry->tcp_buffer_mem - tmp32;
+@@ -1726,7 +1726,7 @@ main(
+ g_done = GLOBUS_FALSE;
+
+ globus_hashtable_init(
+- &g_gfork_be_table,
++ &g_gfork_be_table,
+ 256,
+ globus_hashtable_string_hash,
+ globus_hashtable_string_keyeq);
+@@ -2008,7 +2008,7 @@ gfs_l_gfork_opts_updatetime(
+ char ** opt,
+ void * arg,
+ int * out_parms_used)
+-{
++{
+ globus_result_t result;
+ int sc;
+ int tm;
+@@ -2107,7 +2107,7 @@ gfs_l_gfork_opts_nice_share(
+ char ** opt,
+ void * arg,
+ int * out_parms_used)
+-{
++{
+ globus_result_t result;
+ int sc;
+ int n;
+@@ -2120,14 +2120,14 @@ gfs_l_gfork_opts_nice_share(
+ GFS_GFORK_ERROR_PARAMETER);
+ goto error_format;
+ }
+-
++
+ gfs_l_gfork_nice_share_count = n;
+ *out_parms_used = 1;
+-
++
+ return GLOBUS_SUCCESS;
+ error_format:
+ return result;
+-
++
+ }
+
+
+@@ -2204,7 +2204,7 @@ gfs_gfork_master_options(
+ globus_result_t result;
+ int sc;
+ char * env_s;
+-
++
+ GFSGForkFuncName(gfs_gfork_master_options);
+
+ globus_options_init(
+diff --git a/gridftp/server/src/globus_i_gfs_config.c b/gridftp/server/src/globus_i_gfs_config.c
+index d5ee9a9a7..57367ac64 100644
+--- a/gridftp/server/src/globus_i_gfs_config.c
++++ b/gridftp/server/src/globus_i_gfs_config.c
+@@ -103,8 +103,8 @@ typedef struct
+
+ static globus_mutex_t globus_i_gfs_config_mutex;
+
+-static const globus_l_gfs_config_option_t option_list[] =
+-{
++static const globus_l_gfs_config_option_t option_list[] =
++{
+ {NULL, "Informational Options", NULL, NULL, NULL, 0, 0, NULL, NULL, NULL, NULL, GLOBUS_FALSE, NULL},
+ {"help", "help", NULL, "help", "h", GLOBUS_L_GFS_CONFIG_BOOL, GLOBUS_FALSE, NULL,
+ "Show usage information and exit.", NULL, NULL,GLOBUS_FALSE, NULL},
+@@ -133,7 +133,7 @@ static const globus_l_gfs_config_option_t option_list[] =
+ "Directory to chdir to after starting. Will use / if not set. Note that this is the "
+ "directory of the process, not the client's home directory.", NULL, NULL,GLOBUS_FALSE, NULL},
+ {"threads", "threads", NULL, "threads", NULL, GLOBUS_L_GFS_CONFIG_INT, 0, NULL,
+- "Enable threaded operation and set the number of threads. The default is 0, which "
++ "Enable threaded operation and set the number of threads. The default is 0, which "
+ "is non-threaded. When threading is required, a thread count of 1 or 2 should "
+ "be sufficient.", NULL, NULL, GLOBUS_TRUE, NULL},
+ {"fork", "fork", NULL, "fork", "f", GLOBUS_L_GFS_CONFIG_BOOL, GLOBUS_TRUE, NULL,
+@@ -142,9 +142,9 @@ static const globus_l_gfs_config_option_t option_list[] =
+ "accept a single connection, and then exit.", NULL, NULL,GLOBUS_FALSE, NULL},
+ {"fork_fallback", "fork_fallback", NULL, "fork-fallback", NULL, GLOBUS_L_GFS_CONFIG_BOOL, GLOBUS_FALSE, NULL,
+ NULL /* attempt to run non-forked if fork fails */, NULL, NULL, GLOBUS_FALSE, NULL},
+- {"single", "single", NULL, "single", "1", GLOBUS_L_GFS_CONFIG_BOOL, GLOBUS_FALSE, NULL,
++ {"single", "single", NULL, "single", "1", GLOBUS_L_GFS_CONFIG_BOOL, GLOBUS_FALSE, NULL,
+ "Exit after a single connection.", NULL, NULL,GLOBUS_FALSE, NULL},
+- {"chroot_path", "chroot_path", NULL, "chroot-path", NULL, GLOBUS_L_GFS_CONFIG_STRING, 0, NULL,
++ {"chroot_path", "chroot_path", NULL, "chroot-path", NULL, GLOBUS_L_GFS_CONFIG_STRING, 0, NULL,
+ "Path to become the new root after authentication. This path must contain a valid "
+ "certificate structure, /etc/passwd, and /etc/group. The command "
+ "globus-gridftp-server-setup-chroot can help create a suitable directory structure.", NULL, NULL,GLOBUS_FALSE, NULL},
+@@ -282,7 +282,7 @@ static const globus_l_gfs_config_option_t option_list[] =
+ "replaced by the authenticated user's home directory, or the '-home-dir' option, if used. "
+ "Note that if the home directory is not accessible, '~' will be set to '/'. "
+ "By default all paths are allowed, and access control is handled by the OS. "
+- "In a striped or split process configuration, this should be set on both the frontend and data nodes.",
++ "In a striped or split process configuration, this should be set on both the frontend and data nodes.",
+ NULL, NULL,GLOBUS_FALSE, NULL},
+ {"rp_follow_symlinks", "rp_follow_symlinks", NULL, "rp-follow-symlinks", NULL, GLOBUS_L_GFS_CONFIG_BOOL, GLOBUS_FALSE, NULL,
+ "Do not verify that a symlink points to an allowed path before following. By default, symlinks are "
+@@ -290,7 +290,7 @@ static const globus_l_gfs_config_option_t option_list[] =
+ "will be followed even if they point to a path that is otherwise restricted.", NULL, NULL,GLOBUS_FALSE, NULL},
+ {"acl", "acl", NULL, "acl", "em", GLOBUS_L_GFS_CONFIG_STRING, 0, NULL,
+ "A comma separated list of ACL or event modules to load.",
+- NULL, NULL,GLOBUS_FALSE, NULL},
++ NULL, NULL,GLOBUS_FALSE, NULL},
+ {NULL, "Logging Options", NULL, NULL, NULL, 0, 0, NULL, NULL, NULL, NULL,GLOBUS_FALSE, NULL},
+ {"log_level", "log_level", NULL, "log-level", "d", GLOBUS_L_GFS_CONFIG_STRING, 0, "ERROR",
+ "Log level. A comma separated list of levels from: 'ERROR, WARN, INFO, TRANSFER, DUMP, ALL'. "
+@@ -426,7 +426,7 @@ static const globus_l_gfs_config_option_t option_list[] =
+ "to unauthenticated clients.", NULL, NULL,GLOBUS_FALSE, NULL},
+ {"banner_append", "banner_append", NULL, "banner-append", NULL, GLOBUS_L_GFS_CONFIG_BOOL, GLOBUS_FALSE, NULL,
+ "When this is set, the message set in the 'banner' or 'banner_file' option "
+- "will be appended to the default banner message rather than replacing it.",
++ "will be appended to the default banner message rather than replacing it.",
+ NULL, NULL,GLOBUS_FALSE, NULL},
+ {"version_tag", "version_tag", NULL, "version-tag", NULL, GLOBUS_L_GFS_CONFIG_STRING, 0, NULL,
+ "Add an identifying string to the existing toolkit version. This is displayed in the default "
+@@ -439,12 +439,12 @@ static const globus_l_gfs_config_option_t option_list[] =
+ {"load_dsi_module", "load_dsi_module", NULL, "dsi", NULL, GLOBUS_L_GFS_CONFIG_STRING, 0, NULL,
+ "Data Storage Interface module to load. File and remote modules are defined by the server. "
+ "If not set, the file module is loaded, unless the 'remote' option is specified, in which case the remote "
+- "module is loaded. An additional configuration string can be passed to the DSI using the format "
++ "module is loaded. An additional configuration string can be passed to the DSI using the format "
+ "[module name]:[configuration string] to this option. The format of the configuration "
+ "string is defined by the DSI being loaded.", NULL, NULL,GLOBUS_FALSE, NULL},
+ {"allowed_modules", "allowed_modules", NULL, "allowed-modules", NULL, GLOBUS_L_GFS_CONFIG_STRING, 0, NULL,
+ "Comma separated list of ERET/ESTO modules to allow, and optionally specify an alias for. "
+- "Example: module1,alias2:module2,module3 (module2 will be loaded when a client asks for alias2).", NULL, NULL,GLOBUS_FALSE, NULL},
++ "Example: module1,alias2:module2,module3 (module2 will be loaded when a client asks for alias2).", NULL, NULL,GLOBUS_FALSE, NULL},
+ {"dc_whitelist", "dc_whitelist", NULL, "dc-whitelist", NULL, GLOBUS_L_GFS_CONFIG_STRING, 0, NULL,
+ "A comma separated list of drivers allowed on the network stack.", NULL, NULL,GLOBUS_FALSE, NULL},
+ {"fs_whitelist", "fs_whitelist", NULL, "fs-whitelist", NULL, GLOBUS_L_GFS_CONFIG_STRING, 0, NULL,
+@@ -484,7 +484,7 @@ static const globus_l_gfs_config_option_t option_list[] =
+ "Sets options that make server easier to debug. Forces no-fork, no-chdir, "
+ "and allows core dumps on bad signals instead of exiting cleanly. "
+ "Not recommended for production servers. Note that non-forked servers running "
+- "as 'root' will only accept a single connection, and then exit.", NULL, NULL,GLOBUS_FALSE, NULL},
++ "as 'root' will only accept a single connection, and then exit.", NULL, NULL,GLOBUS_FALSE, NULL},
+ {"pidfile", "pidfile", NULL, "pidfile", NULL, GLOBUS_L_GFS_CONFIG_STRING, 0, NULL,
+ "Write PID of the GridFTP server to this path. May contain variable references to ${localstatedir}", NULL, NULL, GLOBUS_FALSE, NULL},
+
+@@ -498,7 +498,7 @@ static const globus_l_gfs_config_option_t option_list[] =
+ {"slow_dirlist", "slow_dirlist", NULL, NULL, NULL, GLOBUS_L_GFS_CONFIG_INT, 0, NULL,
+ NULL, NULL, NULL,GLOBUS_FALSE, NULL}, /* fake stat responses on dirs with more than this many entries */
+ {"checksum_throttle", "checksum_throttle", NULL, NULL, NULL, GLOBUS_L_GFS_CONFIG_INT, 0, NULL,
+- NULL, NULL, NULL,GLOBUS_FALSE, NULL}, /* delay checksum reads by this many microseconds per blocksize'd read,
++ NULL, NULL, NULL,GLOBUS_FALSE, NULL}, /* delay checksum reads by this many microseconds per blocksize'd read,
+ * effectively setting a floor on the checksum rate to size/blocksize*delay per size */
+ {"test_acl", NULL, NULL, NULL, "testacl", GLOBUS_L_GFS_CONFIG_STRING, 0, NULL,
+ NULL /* load and pass arguments to the test acl module. the string
+@@ -554,13 +554,13 @@ static const globus_l_gfs_config_option_t option_list[] =
+ NULL /* Data node connection count. */, NULL, NULL, GLOBUS_TRUE, NULL},
+ {"tcp_mem_limit", NULL, NULL, NULL, NULL, GLOBUS_L_GFS_CONFIG_INT, 0, NULL,
+ NULL /* TCP memory limit */, NULL, NULL, GLOBUS_TRUE, NULL},
+- {"max_bw", NULL, NULL, NULL, NULL, GLOBUS_L_GFS_CONFIG_INT, 0, NULL,
++ {"max_bw", NULL, NULL, NULL, NULL, GLOBUS_L_GFS_CONFIG_INT, 0, NULL,
+ NULL, NULL, NULL, GLOBUS_TRUE, NULL},
+- {"current_bw", NULL, NULL, NULL, NULL, GLOBUS_L_GFS_CONFIG_INT, 0, NULL,
++ {"current_bw", NULL, NULL, NULL, NULL, GLOBUS_L_GFS_CONFIG_INT, 0, NULL,
+ NULL, NULL, NULL, GLOBUS_TRUE, NULL},
+ {"file_transfer_count", NULL, NULL, NULL, NULL, GLOBUS_L_GFS_CONFIG_INT, 0, NULL,
+ NULL, NULL, NULL, GLOBUS_TRUE, NULL},
+- {"byte_transfer_count", NULL, NULL, NULL, NULL, GLOBUS_L_GFS_CONFIG_STRING, 0, NULL,
++ {"byte_transfer_count", NULL, NULL, NULL, NULL, GLOBUS_L_GFS_CONFIG_STRING, 0, NULL,
+ NULL, NULL, NULL, GLOBUS_TRUE, NULL},
+ {NULL, /* END */ NULL, NULL, NULL, NULL, 0, 0, NULL, NULL, NULL, NULL,GLOBUS_FALSE, NULL}
+ };
+@@ -573,7 +573,7 @@ static char * globus_l_gfs_port_range = NULL;
+ static globus_bool_t globus_l_gfs_common_loaded = GLOBUS_FALSE;
+ static globus_bool_t globus_l_gfs_is_worker = GLOBUS_FALSE;
+
+-/* for string options, setting with an int_val of 1 will free the old one */
++/* for string options, setting with an int_val of 1 will free the old one */
+ static
+ int
+ globus_l_gfs_config_set(
+@@ -583,24 +583,24 @@ globus_l_gfs_config_set(
+ {
+ globus_l_gfs_config_option_t * option;
+ int i;
+- int rc;
++ int rc;
+ GlobusGFSName(globus_l_gfs_config_set);
+ GlobusGFSDebugEnter();
+
+ option = (globus_l_gfs_config_option_t *) globus_hashtable_remove(
+- &option_table, option_name);
++ &option_table, option_name);
+ if(!option)
+ {
+ option = (globus_l_gfs_config_option_t *)
+ globus_calloc(1, sizeof(globus_l_gfs_config_option_t));
+- for(i = 0;
++ for(i = 0;
+ i < option_count && option_list[i].option_name &&
+- strcmp(option_name, option_list[i].option_name);
++ strcmp(option_name, option_list[i].option_name);
+ i++);
+ if(i == option_count)
+ {
+ goto error;
+- }
++ }
+ memcpy(option, &option_list[i], sizeof(globus_l_gfs_config_option_t));
+ }
+ switch(option->type)
+@@ -636,7 +636,7 @@ globus_l_gfs_config_set(
+ error:
+ globus_free(option);
+ GlobusGFSDebugExitWithError();
+- return 1;
++ return 1;
+ }
+
+ #define GLOBUS_L_GFS_LINEBUFLEN 1024
+@@ -668,7 +668,7 @@ globus_l_gfs_config_load_config_file(
+ GlobusGFSDebugExitWithError();
+ return -2; /* XXX construct real error */
+ }
+- globus_l_gfs_config_set("loaded_config", 0, globus_libc_strdup(filename));
++ globus_l_gfs_config_set("loaded_config", 0, globus_libc_strdup(filename));
+
+ line_num = 0;
+ linebuf = globus_malloc(linebuflen);
+@@ -686,7 +686,7 @@ globus_l_gfs_config_load_config_file(
+ {
+ goto error_mem;
+ }
+-
++
+ while(fgets(linebuf, linebuflen, fptr) != NULL)
+ {
+ p = linebuf;
+@@ -704,7 +704,7 @@ globus_l_gfs_config_load_config_file(
+ goto error_mem;
+ }
+ strncat(linebuf, part_line, linebuflen);
+-
++
+ optionbuf = globus_realloc(optionbuf, linebuflen);
+ if(!optionbuf)
+ {
+@@ -719,7 +719,7 @@ globus_l_gfs_config_load_config_file(
+ }
+ line_num++;
+ p = linebuf;
+- optlen = 0;
++ optlen = 0;
+ while(*p && isspace(*p))
+ {
+ p++;
+@@ -731,11 +731,11 @@ globus_l_gfs_config_load_config_file(
+ if(*p == '#')
+ {
+ continue;
+- }
++ }
+ if(*p == '$')
+ {
+ continue;
+- }
++ }
+
+ if(*p == '"')
+ {
+@@ -745,14 +745,14 @@ globus_l_gfs_config_load_config_file(
+ else
+ {
+ rc = sscanf(p, "%s", optionbuf);
+- }
++ }
+ if(rc != 1)
+- {
++ {
+ goto error_parse;
+ }
+ optlen += strlen(optionbuf);
+ p = p + optlen;
+-
++
+ optlen = 0;
+ while(*p && isspace(*p))
+ {
+@@ -766,13 +766,13 @@ globus_l_gfs_config_load_config_file(
+ else
+ {
+ rc = sscanf(p, "%s", valuebuf);
+- }
++ }
+ if(rc != 1)
+- {
++ {
+ goto error_parse;
+- }
++ }
+ optlen += strlen(valuebuf);
+- p = p + optlen;
++ p = p + optlen;
+ while(*p && isspace(*p))
+ {
+ p++;
+@@ -781,7 +781,7 @@ globus_l_gfs_config_load_config_file(
+ {
+ goto error_parse;
+ }
+-
++
+ found = GLOBUS_FALSE;
+ for(i = 0; !found && i < option_count; i++)
+ {
+@@ -789,16 +789,16 @@ globus_l_gfs_config_load_config_file(
+ {
+ continue;
+ }
+- if(!option_list[i].configfile_option ||
++ if(!option_list[i].configfile_option ||
+ strcmp(optionbuf, option_list[i].configfile_option))
+ {
+ continue;
+ }
+-
++
+ found = GLOBUS_TRUE;
+-
++
+ option = (globus_l_gfs_config_option_t *) globus_hashtable_remove(
+- &option_table, option_list[i].option_name);
++ &option_table, option_list[i].option_name);
+ if(!option)
+ {
+ option = (globus_l_gfs_config_option_t *)
+@@ -818,19 +818,19 @@ globus_l_gfs_config_load_config_file(
+ }
+ else
+ {
+- globus_gfs_log_exit_message("Value for %s must be 0 or 1.\n",
++ globus_gfs_log_exit_message("Value for %s must be 0 or 1.\n",
+ option_list[i].option_name);
+ goto error_parse;
+- }
++ }
+ break;
+ case GLOBUS_L_GFS_CONFIG_INT:
+ rc = globus_args_bytestr_to_num(valuebuf, &tmp_off);
+ if(rc != 0)
+ {
+- globus_gfs_log_exit_message("Invalid value for %s\n",
++ globus_gfs_log_exit_message("Invalid value for %s\n",
+ option_list[i].option_name);
+ goto error_parse;
+- }
++ }
+ option->int_value = (int) tmp_off;
+ break;
+ case GLOBUS_L_GFS_CONFIG_STRING:
+@@ -842,7 +842,7 @@ globus_l_gfs_config_load_config_file(
+ rc = globus_hashtable_insert(&option_table,
+ option->option_name,
+ (void *) option);
+-
++
+ if(rc)
+ {
+ /* XXX error, log something */
+@@ -851,24 +851,24 @@ globus_l_gfs_config_load_config_file(
+ if(!found)
+ {
+ globus_gfs_log_exit_message("Problem parsing config file %s: line %d. "
+- "Unknown option '%s'.\n",
++ "Unknown option '%s'.\n",
+ filename, line_num, optionbuf);
+ goto error_param;
+ }
+ }
+
+ fclose(fptr);
+-
++
+ globus_free(linebuf);
+ globus_free(valuebuf);
+ globus_free(optionbuf);
+-
++
+ GlobusGFSDebugExit();
+ return GLOBUS_SUCCESS;
+
+ error_parse:
+ fclose(fptr);
+- globus_gfs_log_exit_message("Problem parsing config file %s: line %d.\n",
++ globus_gfs_log_exit_message("Problem parsing config file %s: line %d.\n",
+ filename, line_num);
+ error_param:
+ error_mem:
+@@ -878,9 +878,9 @@ error_mem:
+
+ }
+
+-/* handle options needed before module inits.
++/* handle options needed before module inits.
+ no return - errors get caught on next pass */
+-static
++static
+ void
+ globus_l_gfs_config_parse_preinit_opt(
+ char * line,
+@@ -889,15 +889,15 @@ globus_l_gfs_config_parse_preinit_opt(
+ {
+ int rc;
+ char * p = line;
+-
++
+ if((rc = sscanf(p, "%s", optionbuf)) == 1)
+ {
+- if(!globus_l_gfs_is_worker &&
++ if(!globus_l_gfs_is_worker &&
+ (!strcmp(optionbuf, "inetd") || !strcmp(optionbuf, "debug") ||
+ !strcmp(optionbuf, "ssh") || !strcmp(optionbuf, "fork")))
+ {
+ p = p + strlen(optionbuf);
+-
++
+ while(*p && isspace(*p))
+ {
+ p++;
+@@ -909,7 +909,7 @@ globus_l_gfs_config_parse_preinit_opt(
+ else
+ {
+ rc = sscanf(p, "%s", valuebuf);
+- }
++ }
+ if(rc == 1)
+ {
+ globus_l_gfs_is_worker = atoi(valuebuf);
+@@ -922,7 +922,7 @@ globus_l_gfs_config_parse_preinit_opt(
+ if(globus_l_gfs_num_threads == -1 && !strcmp(optionbuf, "threads"))
+ {
+ p = p + strlen(optionbuf);
+-
++
+ while(*p && isspace(*p))
+ {
+ p++;
+@@ -934,7 +934,7 @@ globus_l_gfs_config_parse_preinit_opt(
+ else
+ {
+ rc = sscanf(p, "%s", valuebuf);
+- }
++ }
+ if(rc == 1)
+ {
+ globus_l_gfs_num_threads = atoi(valuebuf);
+@@ -943,7 +943,7 @@ globus_l_gfs_config_parse_preinit_opt(
+ if(!globus_l_gfs_port_range && !strcmp(optionbuf, "port_range"))
+ {
+ p = p + strlen(optionbuf);
+-
++
+ while(*p && isspace(*p))
+ {
+ p++;
+@@ -955,7 +955,7 @@ globus_l_gfs_config_parse_preinit_opt(
+ else
+ {
+ rc = sscanf(p, "%s", valuebuf);
+- }
++ }
+ if(rc == 1)
+ {
+ setenv("GLOBUS_TCP_PORT_RANGE", valuebuf, 1);
+@@ -1022,7 +1022,7 @@ globus_l_gfs_config_load_envs_from_file(
+ goto error_mem;
+ }
+ strncat(linebuf, part_line, linebuflen);
+-
++
+ optionbuf = realloc(optionbuf, linebuflen);
+ if(!optionbuf)
+ {
+@@ -1037,12 +1037,12 @@ globus_l_gfs_config_load_envs_from_file(
+ }
+ line_num++;
+ p = linebuf;
+- optlen = 0;
++ optlen = 0;
+ while(*p && isspace(*p))
+ {
+ p++;
+ }
+-
++
+ /* parse some non-env options */
+ if(*p != '$')
+ {
+@@ -1050,15 +1050,15 @@ globus_l_gfs_config_load_envs_from_file(
+ continue;
+ }
+ p++;
+-
++
+ rc = sscanf(p, "%s", optionbuf);
+ if(rc != 1)
+- {
++ {
+ goto error_parse;
+ }
+ optlen += strlen(optionbuf);
+ p = p + optlen;
+-
++
+ optlen = 0;
+ while(*p && isspace(*p))
+ {
+@@ -1072,13 +1072,13 @@ globus_l_gfs_config_load_envs_from_file(
+ else
+ {
+ rc = sscanf(p, "%s", valuebuf);
+- }
++ }
+ if(rc != 1)
+- {
++ {
+ goto error_parse;
+- }
++ }
+ optlen += strlen(valuebuf);
+- p = p + optlen;
++ p = p + optlen;
+ while(*p && isspace(*p))
+ {
+ p++;
+@@ -1087,14 +1087,14 @@ globus_l_gfs_config_load_envs_from_file(
+ {
+ goto error_parse;
+ }
+-
++
+ rc = globus_libc_setenv(optionbuf, valuebuf, 1);
+ if(rc < 0)
+ {
+ char errstr[PATH_MAX];
+ snprintf(
+ errstr, PATH_MAX,
+- "Problem loading environment from config file %s: line %d.\n",
++ "Problem loading environment from config file %s: line %d.\n",
+ filename, line_num);
+ perror(errstr);
+ }
+@@ -1105,20 +1105,20 @@ globus_l_gfs_config_load_envs_from_file(
+ free(linebuf);
+ free(valuebuf);
+ free(optionbuf);
+-
++
+ return 0;
+
+ error_parse:
+ if(globus_l_gfs_common_loaded)
+ {
+- globus_gfs_log_exit_message("Problem parsing environment from config file %s: line %d.\n",
++ globus_gfs_log_exit_message("Problem parsing environment from config file %s: line %d.\n",
+ filename, line_num);
+ }
+ else
+ {
+ fprintf(
+ stderr,
+- "Problem parsing environment from config file %s: line %d. \n",
++ "Problem parsing environment from config file %s: line %d. \n",
+ filename, line_num);
+ }
+
+@@ -1205,7 +1205,7 @@ globus_l_gfs_config_load_config_dir(
+ }
+ }
+ result = globus_l_gfs_config_load_envs_from_file(full_path);
+-
++
+ free(entries[i]);
+ free(full_path);
+ }
+@@ -1233,7 +1233,7 @@ globus_l_gfs_config_load_config_env()
+ globus_off_t tmp_off;
+ GlobusGFSName(globus_l_gfs_config_load_config_env);
+ GlobusGFSDebugEnter();
+-
++
+
+ for(i = 0; i < option_count; i++)
+ {
+@@ -1247,14 +1247,14 @@ globus_l_gfs_config_load_config_env()
+ }
+
+ value = getenv(option_list[i].env_var_option);
+-
++
+ if (!value)
+ {
+ continue;
+ }
+-
++
+ option = (globus_l_gfs_config_option_t *) globus_hashtable_remove(
+- &option_table, option_list[i].option_name);
++ &option_table, option_list[i].option_name);
+ if(!option)
+ {
+ option = (globus_l_gfs_config_option_t *)
+@@ -1275,10 +1275,10 @@ globus_l_gfs_config_load_config_env()
+ }
+ else
+ {
+- globus_gfs_log_exit_message("Value for %s must be 0 or 1.\n",
++ globus_gfs_log_exit_message("Value for %s must be 0 or 1.\n",
+ option_list[i].option_name);
+ return -1;
+- }
++ }
+ break;
+ case GLOBUS_L_GFS_CONFIG_INT:
+ rc = globus_args_bytestr_to_num(value, &tmp_off);
+@@ -1288,10 +1288,10 @@ globus_l_gfs_config_load_config_env()
+ {
+ free(option);
+ }
+- globus_gfs_log_exit_message("Invalid value for %s\n",
++ globus_gfs_log_exit_message("Invalid value for %s\n",
+ option_list[i].option_name);
+ return -1;
+- }
++ }
+ option->int_value = (int) tmp_off;
+ break;
+ case GLOBUS_L_GFS_CONFIG_STRING:
+@@ -1303,12 +1303,12 @@ globus_l_gfs_config_load_config_env()
+ rc = globus_hashtable_insert(&option_table,
+ option->option_name,
+ (void *) option);
+-
++
+ if(rc)
+ {
+ /* XXX error, log something */
+ }
+- }
++ }
+
+ GlobusGFSDebugExit();
+ return GLOBUS_SUCCESS;
+@@ -1333,7 +1333,7 @@ globus_l_gfs_config_load_commandline(
+ globus_off_t tmp_off;
+ GlobusGFSName(globus_l_gfs_config_load_commandline);
+ GlobusGFSDebugEnter();
+-
++
+ for(arg_num = 1; arg_num < argc; ++arg_num)
+ {
+ found = GLOBUS_FALSE;
+@@ -1341,7 +1341,7 @@ globus_l_gfs_config_load_commandline(
+
+ argp = argv[arg_num];
+ len = strlen(argp);
+-
++
+ if(len && *argp == '-')
+ {
+ argp++;
+@@ -1364,25 +1364,25 @@ globus_l_gfs_config_load_commandline(
+ len--;
+ negate = GLOBUS_TRUE;
+ }
+-
++
+ for(i = 0; i < option_count && !found && len; i++)
+ {
+ if(option_list[i].option_name == NULL)
+ {
+ continue;
+ }
+- if((!option_list[i].short_cmdline_option ||
+- strcmp(argp, option_list[i].short_cmdline_option)) &&
+- (!option_list[i].long_cmdline_option ||
++ if((!option_list[i].short_cmdline_option ||
++ strcmp(argp, option_list[i].short_cmdline_option)) &&
++ (!option_list[i].long_cmdline_option ||
+ strcmp(argp, option_list[i].long_cmdline_option)) )
+ {
+ continue;
+ }
+-
++
+ found = GLOBUS_TRUE;
+-
++
+ option = (globus_l_gfs_config_option_t *) globus_hashtable_remove(
+- &option_table, option_list[i].option_name);
++ &option_table, option_list[i].option_name);
+ if(!option)
+ {
+ opt_is_new = GLOBUS_TRUE;
+@@ -1419,10 +1419,10 @@ globus_l_gfs_config_load_commandline(
+ }
+ globus_gfs_log_exit_message("Invalid value for %s\n", argp);
+ return -1;
+- }
++ }
+ option->int_value = (int) tmp_off;
+ break;
+-
++
+ case GLOBUS_L_GFS_CONFIG_STRING:
+ if(++arg_num >= argc)
+ {
+@@ -1443,14 +1443,14 @@ globus_l_gfs_config_load_commandline(
+ rc = globus_hashtable_insert(&option_table,
+ option->option_name,
+ (void *) option);
+-
++
+ if(rc)
+ {
+ /* XXX error, log something */
+ }
+-
++
+ }
+-
++
+ if(!found)
+ {
+ if(opt_is_new)
+@@ -1462,7 +1462,7 @@ globus_l_gfs_config_load_commandline(
+ return -1;
+ }
+ }
+-
++
+ GlobusGFSDebugExit();
+ return GLOBUS_SUCCESS;
+
+@@ -1478,9 +1478,9 @@ globus_l_gfs_config_load_defaults()
+ globus_l_gfs_config_option_t * option;
+ GlobusGFSName(globus_l_gfs_config_load_defaults);
+ GlobusGFSDebugEnter();
+-
++
+ for(i = 0; i < option_count; i++)
+- {
++ {
+ if(option_list[i].option_name == NULL)
+ {
+ continue;
+@@ -1488,11 +1488,11 @@ globus_l_gfs_config_load_defaults()
+ option = (globus_l_gfs_config_option_t *)
+ globus_malloc(sizeof(globus_l_gfs_config_option_t));
+ memcpy(option, &option_list[i], sizeof(globus_l_gfs_config_option_t));
+-
+- rc = globus_hashtable_insert(&option_table,
+- option->option_name,
++
++ rc = globus_hashtable_insert(&option_table,
++ option->option_name,
+ (void *) option);
+-
++
+ if(rc)
+ {
+ /* XXX error, log something */
+@@ -1500,7 +1500,7 @@ globus_l_gfs_config_load_defaults()
+ }
+
+ GlobusGFSDebugExit();
+- return GLOBUS_SUCCESS;
++ return GLOBUS_SUCCESS;
+ }
+
+ static
+@@ -1514,18 +1514,18 @@ globus_l_config_loadfile(
+ char * out_buf;
+ GlobusGFSName(globus_l_config_loadfile);
+ GlobusGFSDebugEnter();
+-
++
+ file = fopen(filename, "r");
+ if(!file)
+ {
+ goto error;
+ }
+-
++
+ fseek(file, 0L, SEEK_END);
+ file_len = ftell(file);
+- fseek(file, 0L, SEEK_SET);
++ fseek(file, 0L, SEEK_SET);
+
+- out_buf = (char *) malloc((file_len + 1) * sizeof(char));
++ out_buf = (char *) malloc((file_len + 1) * sizeof(char));
+ if(!out_buf)
+ {
+ fclose(file);
+@@ -1537,7 +1537,7 @@ globus_l_config_loadfile(
+ out_buf[file_len] = '\0';
+
+ *data_out = out_buf;
+-
++
+ GlobusGFSDebugExit();
+ return 0;
+
+@@ -1554,18 +1554,18 @@ globus_l_gfs_config_display_html_usage()
+ globus_l_gfs_config_option_t * o;
+ GlobusGFSName(globus_l_gfs_config_display_html_usage);
+ GlobusGFSDebugEnter();
+-
++
+ printf("<!-- generated by globus-gridftp-server -help -html -->\n");
+ printf("<p>\n"
+- "The table below lists config file options, associated command line "
++ "The table below lists config file options, associated command line "
+ "options (if available) and descriptions. Note that any boolean "
+- "option can be negated on the command line by preceding the specified "
++ "option can be negated on the command line by preceding the specified "
+ "option with '-no-' or '-n'. Example: -no-cas or -nf.\n"
+ "</p>\n");
+
+ printf("<ul>\n");
+ for(i = 0; i < option_count; i++)
+- {
++ {
+ o = (globus_l_gfs_config_option_t *) &option_list[i];
+ if(o->option_name == NULL && o->configfile_option != NULL)
+ {
+@@ -1579,12 +1579,12 @@ globus_l_gfs_config_display_html_usage()
+
+ printf("<table border=\"1\" cellpadding=\"5\">\n");
+ for(i = 0; i < option_count; i++)
+- {
++ {
+ char * shortflag;
+ char * longflag;
+ char * value;
+ char * defval;
+-
++
+ o = (globus_l_gfs_config_option_t *) &option_list[i];
+ if(o->option_name == NULL && o->configfile_option != NULL)
+ {
+@@ -1606,26 +1606,26 @@ globus_l_gfs_config_display_html_usage()
+ case GLOBUS_L_GFS_CONFIG_BOOL:
+ shortflag = "-";
+ longflag = "-";
+- value = " <0|1>";
++ value = " <0|1>";
+ defval = o->int_value ? "TRUE" : "FALSE";
+ break;
+ case GLOBUS_L_GFS_CONFIG_INT:
+ shortflag = "-";
+ longflag = "-";
+- value = " <number>";
+- defval = o->int_value > 0 ?
++ value = " <number>";
++ defval = o->int_value > 0 ?
+ globus_common_create_string("%d", o->int_value) : "not set";
+ break;
+ case GLOBUS_L_GFS_CONFIG_STRING:
+ shortflag = "-";
+ longflag = "-";
+- value = " <string>";
++ value = " <string>";
+ defval = o->value ? o->value : "not set";
+ break;
+ default:
+ shortflag = "";
+ longflag = "";
+- value = "";
++ value = "";
+ defval = o->value ? o->value : "not set";
+ break;
+ }
+@@ -1638,17 +1638,17 @@ globus_l_gfs_config_display_html_usage()
+ " </table>\n"
+ " </td>\n"
+ " <td valign=\"top\"><p>%s</p><p>Default value: %s</p></td>\n"
+- " </tr>\n",
+- o->configfile_option,
++ " </tr>\n",
++ o->configfile_option,
+ value,
+- o->short_cmdline_option ? shortflag : "",
++ o->short_cmdline_option ? shortflag : "",
+ o->short_cmdline_option ? o->short_cmdline_option : "",
+- o->type != GLOBUS_L_GFS_CONFIG_BOOL &&
++ o->type != GLOBUS_L_GFS_CONFIG_BOOL &&
+ o->short_cmdline_option ? value : "",
+- o->short_cmdline_option ? "\n" : "",
++ o->short_cmdline_option ? "\n" : "",
+ o->long_cmdline_option ? longflag : "",
+ o->long_cmdline_option ? o->long_cmdline_option : "",
+- o->type != GLOBUS_L_GFS_CONFIG_BOOL &&
++ o->type != GLOBUS_L_GFS_CONFIG_BOOL &&
+ o->long_cmdline_option ? value : "",
+ o->usage,
+ defval);
+@@ -1680,7 +1680,7 @@ globus_l_gfs_config_display_wsdl()
+ out = stdout;
+ }
+ for(i = 0; i < option_count; i++)
+- {
++ {
+ o = (globus_l_gfs_config_option_t *) &option_list[i];
+ if(o->option_name != NULL && o->public)
+ {
+@@ -1709,7 +1709,7 @@ globus_l_gfs_config_display_wsdl()
+ fprintf(out, " <xsd:complexType><xsd:sequence>\n");
+
+ for(i = 0; i < option_count; i++)
+- {
++ {
+ o = (globus_l_gfs_config_option_t *) &option_list[i];
+ if(o->option_name != NULL && o->public)
+ {
+@@ -1750,7 +1750,7 @@ globus_l_gfs_config_display_c_service()
+ globus_bool_t close = GLOBUS_TRUE;
+ char * c_file;
+ GlobusGFSDebugEnter();
+-
++
+ c_file = globus_common_create_string("%s.c",
+ globus_i_gfs_config_string("wsdl"));
+ out = fopen(c_file, "w");
+@@ -1760,7 +1760,7 @@ globus_l_gfs_config_display_c_service()
+ out = stdout;
+ }
+ for(i = 0; i < option_count; i++)
+- {
++ {
+ o = (globus_l_gfs_config_option_t *) &option_list[i];
+ if(o->option_name != NULL && o->public)
+ {
+@@ -1787,7 +1787,7 @@ globus_l_gfs_config_display_c_service()
+ fprintf(out, " globus_result_t result;\n");
+ fprintf(out, " globus_i_gfs_config_option_cb_ent_t * cb_handle;\n");
+ for(i = 0; i < option_count; i++)
+- {
++ {
+ o = (globus_l_gfs_config_option_t *) &option_list[i];
+ if(o->option_name != NULL && o->public)
+ {
+@@ -1867,7 +1867,7 @@ globus_l_gfs_config_display_docbook_usage()
+ globus_l_gfs_config_option_t * o;
+ GlobusGFSName(globus_l_gfs_config_display_docbook_usage);
+ GlobusGFSDebugEnter();
+-
++
+ printf("<!-- generated by globus-gridftp-server -help -docbook -->\n");
+ printf("<para>\n"
+ "The list below contains the command-line options for the server, "
+@@ -1879,10 +1879,10 @@ globus_l_gfs_config_display_docbook_usage()
+ "</refsect1>\n");
+
+ for(i = 0; i < option_count; i++)
+- {
++ {
+ char * value;
+ char * defval;
+-
++
+ o = (globus_l_gfs_config_option_t *) &option_list[i];
+ if(o->option_name == NULL && o->configfile_option != NULL)
+ {
+@@ -1911,8 +1911,8 @@ globus_l_gfs_config_display_docbook_usage()
+ defval = o->int_value ? "TRUE" : "FALSE";
+ break;
+ case GLOBUS_L_GFS_CONFIG_INT:
+- value = "number";
+- defval = o->int_value > 0 ?
++ value = "number";
++ defval = o->int_value > 0 ?
+ globus_common_create_string("%d", o->int_value) : NULL;
+ break;
+ case GLOBUS_L_GFS_CONFIG_STRING:
+@@ -1920,11 +1920,11 @@ globus_l_gfs_config_display_docbook_usage()
+ defval = o->value ? o->value : NULL;
+ break;
+ default:
+- value = "";
++ value = "";
+ defval = o->value ? o->value : NULL;
+ break;
+ }
+-
++
+ printf(" <varlistentry>\n");
+ if (o->short_cmdline_option)
+ {
+@@ -1979,7 +1979,7 @@ globus_l_gfs_config_display_asciidoc_usage()
+ globus_l_gfs_config_option_t * o;
+ GlobusGFSName(globus_l_gfs_config_display_docbook_usage);
+ GlobusGFSDebugEnter();
+-
++
+ printf("////\ngenerated by globus-gridftp-server -help -asciidoc\n////\n");
+ printf("The list below contains the command-line options for the server, "
+ "and also the name of the configuration file entry that implements "
+@@ -1989,10 +1989,10 @@ globus_l_gfs_config_display_asciidoc_usage()
+ "\n");
+
+ for(i = 0; i < option_count; i++)
+- {
++ {
+ char * value;
+ char * defval;
+-
++
+ o = (globus_l_gfs_config_option_t *) &option_list[i];
+ if(o->option_name == NULL && o->configfile_option != NULL)
+ {
+@@ -2026,8 +2026,8 @@ globus_l_gfs_config_display_asciidoc_usage()
+ defval = o->int_value ? "TRUE" : "FALSE";
+ break;
+ case GLOBUS_L_GFS_CONFIG_INT:
+- value = "number";
+- defval = o->int_value > 0 ?
++ value = "number";
++ defval = o->int_value > 0 ?
+ globus_common_create_string("%d", o->int_value) : NULL;
+ break;
+ case GLOBUS_L_GFS_CONFIG_STRING:
+@@ -2035,11 +2035,11 @@ globus_l_gfs_config_display_asciidoc_usage()
+ defval = o->value ? o->value : NULL;
+ break;
+ default:
+- value = "";
++ value = "";
+ defval = o->value ? o->value : NULL;
+ break;
+ }
+-
++
+ printf("*");
+ if (o->short_cmdline_option)
+ {
+@@ -2123,16 +2123,16 @@ globus_i_gfs_config_display_long_usage()
+ globus_l_gfs_config_display_c_service();
+ }
+ else
+- {
++ {
+ for(i = 0; i < option_count; i++)
+- {
++ {
+ o = (globus_l_gfs_config_option_t *) &option_list[i];
+ if(o->usage == NULL)
+ {
+ continue;
+ }
+-
+- printf("%-14s %s\n%-14s %sCommand line or ENV args:",
++
++ printf("%-14s %s\n%-14s %sCommand line or ENV args:",
+ o->option_name, o->usage, "",
+ o->type == GLOBUS_L_GFS_CONFIG_BOOL ? "(FLAG) " : "");
+ if(o->short_cmdline_option)
+@@ -2172,15 +2172,15 @@ globus_l_gfs_config_format_line(
+ int count;
+ int last;
+ int blanks;
+-
++
+ len = strlen(in_str);
+ count = 0;
+ last = 0;
+ memset(out_buffer, 0, rows * columns);
+-
++
+ for(i = 0; i < rows && count < len; i++)
+ {
+- for(j = 0; j < columns - 1 && count < len; j++, count++)
++ for(j = 0; j < columns - 1 && count < len; j++, count++)
+ {
+ if(in_str[count] == ' ')
+ {
+@@ -2205,12 +2205,12 @@ globus_l_gfs_config_format_line(
+ while(count < len && in_str[count] == ' ')
+ {
+ count++;
+- }
++ }
+ }
+
+ return 0;
+ }
+-
++
+ void
+ globus_i_gfs_config_display_usage()
+ {
+@@ -2218,7 +2218,7 @@ globus_i_gfs_config_display_usage()
+ globus_l_gfs_config_option_t * o;
+ GlobusGFSName(globus_i_gfs_config_display_short_usage);
+ GlobusGFSDebugEnter();
+-
++
+ if(globus_i_gfs_config_bool("html"))
+ {
+ globus_l_gfs_config_display_html_usage();
+@@ -2237,7 +2237,7 @@ globus_i_gfs_config_display_usage()
+ globus_l_gfs_config_display_c_service();
+ }
+ else
+- {
++ {
+ for(i = 0; i < option_count; i++)
+ {
+ char linebuffer[GLOBUS_GFS_HELP_ROWS * GLOBUS_GFS_HELP_COLS];
+@@ -2253,7 +2253,7 @@ globus_i_gfs_config_display_usage()
+ {
+ count = 0;
+ printf("\n");
+- len = GLOBUS_GFS_HELP_WIDTH -
++ len = GLOBUS_GFS_HELP_WIDTH -
+ (strlen(o->configfile_option) + 4);
+ if(len > 0)
+ {
+@@ -2280,16 +2280,16 @@ globus_i_gfs_config_display_usage()
+ {
+ continue;
+ }
+-
++
+ switch(o->type)
+ {
+ case GLOBUS_L_GFS_CONFIG_BOOL:
+- value = "";
++ value = "";
+ sprintf(defval, "%s", o->int_value ? "TRUE" : "FALSE");
+ break;
+ case GLOBUS_L_GFS_CONFIG_INT:
+- value = "<number>";
+- if(o->int_value > 0)
++ value = "<number>";
++ if(o->int_value > 0)
+ {
+ sprintf(defval, "%d", o->int_value);
+ }
+@@ -2299,16 +2299,16 @@ globus_i_gfs_config_display_usage()
+ }
+ break;
+ case GLOBUS_L_GFS_CONFIG_STRING:
+- value = "<string>";
+- sprintf(defval, "%s",
++ value = "<string>";
++ sprintf(defval, "%s",
+ o->value ? (char *) o->value : "not set");
+ break;
+ default:
+- value = "";
++ value = "";
+ sprintf(defval, "%s", "not set");
+ break;
+ }
+-
++
+ if(o->short_cmdline_option)
+ {
+ count += printf(" -%s", o->short_cmdline_option);
+@@ -2330,16 +2330,16 @@ globus_i_gfs_config_display_usage()
+ usage, GLOBUS_GFS_HELP_ROWS, GLOBUS_GFS_HELP_COLS, linebuffer);
+
+ len = strlen(linebuffer);
+- for(row = 0; row < GLOBUS_GFS_HELP_ROWS &&
+- linebuffer[row * GLOBUS_GFS_HELP_COLS];
++ for(row = 0; row < GLOBUS_GFS_HELP_ROWS &&
++ linebuffer[row * GLOBUS_GFS_HELP_COLS];
+ row++)
+ {
+ if(row == 1)
+ {
+ count += printf(" Default: %s ", defval);
+ }
+- for(col = count;
+- col < GLOBUS_GFS_HELP_WIDTH - GLOBUS_GFS_HELP_COLS;
++ for(col = count;
++ col < GLOBUS_GFS_HELP_WIDTH - GLOBUS_GFS_HELP_COLS;
+ col++)
+ {
+ printf(" ");
+@@ -2373,14 +2373,14 @@ globus_i_gfs_config_hostname_to_address_string(
+ globus_addrinfo_t hints;
+ globus_addrinfo_t * addrinfo;
+ globus_result_t result;
+-
++
+ memset(&hints, 0, sizeof(globus_addrinfo_t));
+ hints.ai_family = PF_UNSPEC;
+ hints.ai_socktype = SOCK_STREAM;
+ hints.ai_protocol = 0;
+
+ result = globus_libc_getaddrinfo(hostname, NULL, &hints, &addrinfo);
+- if(result != GLOBUS_SUCCESS || addrinfo == NULL ||
++ if(result != GLOBUS_SUCCESS || addrinfo == NULL ||
+ addrinfo->ai_addr == NULL)
+ {
+ goto error_exit;
+@@ -2396,11 +2396,11 @@ globus_i_gfs_config_hostname_to_address_string(
+ {
+ globus_libc_freeaddrinfo(addrinfo);
+ goto error_exit;
+- }
+- globus_libc_freeaddrinfo(addrinfo);
+-
++ }
++ globus_libc_freeaddrinfo(addrinfo);
++
+ return GLOBUS_SUCCESS;
+-
++
+ error_exit:
+ return result;
+ }
+@@ -2462,9 +2462,9 @@ globus_l_gfs_config_misc()
+
+ #ifdef WIN32
+ globus_l_gfs_config_set("fork", GLOBUS_FALSE, NULL);
+-#endif
++#endif
+
+- if(globus_i_gfs_config_bool("detach") &&
++ if(globus_i_gfs_config_bool("detach") &&
+ !globus_i_gfs_config_bool("daemon"))
+ {
+ globus_l_gfs_config_set("daemon", GLOBUS_TRUE, NULL);
+@@ -2510,8 +2510,8 @@ globus_l_gfs_config_misc()
+ else if(strchr(value, ':') == NULL)
+ {
+ globus_l_gfs_config_set(
+- "log_module",
+- 0,
++ "log_module",
++ 0,
+ globus_common_create_string("%s:buffer=0", value));
+ globus_free(value);
+ }
+@@ -2546,29 +2546,29 @@ globus_l_gfs_config_misc()
+ "control_interface", 0, globus_libc_strdup(iface));
+ }
+ }
+-
+- if((value =
++
++ if((value =
+ globus_i_gfs_config_string("control_interface")) != GLOBUS_NULL)
+- {
++ {
+ memset(ipaddr, 0, sizeof(ipaddr));
+ result = globus_i_gfs_config_hostname_to_address_string(
+- value, ipaddr, sizeof(ipaddr));
++ value, ipaddr, sizeof(ipaddr));
+ if(result != GLOBUS_SUCCESS)
+- {
++ {
+ goto error_exit;
+ }
+ globus_l_gfs_config_set(
+ "control_interface", 1, globus_libc_strdup(ipaddr));
+ }
+
+- if((value =
++ if((value =
+ globus_i_gfs_config_string("data_interface")) != GLOBUS_NULL)
+- {
++ {
+ memset(ipaddr, 0, sizeof(ipaddr));
+ result = globus_i_gfs_config_hostname_to_address_string(
+- value, ipaddr, sizeof(ipaddr));
++ value, ipaddr, sizeof(ipaddr));
+ if(result != GLOBUS_SUCCESS)
+- {
++ {
+ goto error_exit;
+ }
+ globus_l_gfs_config_set(
+@@ -2578,15 +2578,15 @@ globus_l_gfs_config_misc()
+ if((value = globus_i_gfs_config_string("hostname")) != GLOBUS_NULL)
+ {
+ globus_l_gfs_config_set("fqdn", 0, globus_libc_strdup(value));
+-
++
+ memset(ipaddr, 0, sizeof(ipaddr));
+ result = globus_i_gfs_config_hostname_to_address_string(
+- value, ipaddr, sizeof(ipaddr));
++ value, ipaddr, sizeof(ipaddr));
+ if(result != GLOBUS_SUCCESS)
+- {
++ {
+ goto error_exit;
+ }
+-
++
+ if(globus_i_gfs_config_string("control_interface") == NULL)
+ {
+ globus_l_gfs_config_set(
+@@ -2605,18 +2605,18 @@ globus_l_gfs_config_misc()
+ globus_libc_gethostname(hostname, 1024);
+ globus_l_gfs_config_set("fqdn", 0, globus_libc_strdup(hostname));
+ globus_free(hostname);
+- }
++ }
+
+ if((value = globus_i_gfs_config_string("version_tag")) != NULL)
+ {
+- toolkit_version =
++ toolkit_version =
+ globus_common_create_string("%s %s", toolkit_id, value);
+ }
+ else
+ {
+ toolkit_version = globus_libc_strdup(toolkit_id);
+ }
+-
++
+ default_banner = globus_common_create_string(
+ "%s GridFTP Server %d.%d (%s, %d-%d) [%s] ready.",
+ globus_i_gfs_config_string("fqdn"),
+@@ -2626,11 +2626,11 @@ globus_l_gfs_config_misc()
+ local_version.timestamp,
+ local_version.branch_id,
+ toolkit_version);
+-
++
+ data = NULL;
+ if(globus_i_gfs_config_bool("banner_terse"))
+ {
+- data = globus_libc_strdup("");
++ data = globus_libc_strdup("");
+ }
+ else if((value = globus_i_gfs_config_string("banner_file")) != GLOBUS_NULL)
+ {
+@@ -2640,13 +2640,13 @@ globus_l_gfs_config_misc()
+ {
+ data = globus_libc_strdup(value);
+ }
+-
++
+ if(data != NULL)
+ {
+ if(globus_i_gfs_config_bool("banner_append"))
+ {
+ char * banner;
+- banner =
++ banner =
+ globus_common_create_string("%s %s", default_banner, data);
+ globus_free(data);
+ data = banner;
+@@ -2657,8 +2657,8 @@ globus_l_gfs_config_misc()
+ {
+ data = default_banner;
+ }
+- globus_l_gfs_config_set("banner", 1, data);
+-
++ globus_l_gfs_config_set("banner", 1, data);
++
+ data = globus_common_create_string(
+ "%d.%d (%s, %d-%d) [%s]",
+ local_version.major,
+@@ -2673,14 +2673,14 @@ globus_l_gfs_config_misc()
+ if((value = globus_i_gfs_config_string("login_msg_file")) != GLOBUS_NULL)
+ {
+ rc = globus_l_config_loadfile(value, &data);
+- globus_l_gfs_config_set("login_msg", 0, data);
++ globus_l_gfs_config_set("login_msg", 0, data);
+ }
+
+ value = globus_i_gfs_config_string("load_dsi_module");
+ if(value != NULL)
+ {
+ char * ptr;
+-
++
+ ptr = strchr(value, ':');
+ if(ptr)
+ {
+@@ -2700,26 +2700,26 @@ globus_l_gfs_config_misc()
+ if(value)
+ {
+ if(globus_i_gfs_config_string("load_dsi_module") == NULL &&
+- !globus_i_gfs_config_bool("data_node") &&
++ !globus_i_gfs_config_bool("data_node") &&
+ !globus_i_gfs_config_bool("hybrid"))
+ {
+ globus_l_gfs_config_set(
+- "load_dsi_module", 0, globus_libc_strdup("remote"));
++ "load_dsi_module", 0, globus_libc_strdup("remote"));
+ }
+-
+- /* if stripe_count wasn't set, set it to the number of
++
++ /* if stripe_count wasn't set, set it to the number of
+ * nodes configured */
+ if(globus_i_gfs_config_int("stripe_count") == -1)
+ {
+ int node_count = 1;
+ char * ptr;
+-
++
+ ptr = value;
+ while(ptr && *ptr && (ptr = strchr(ptr, ',')) != NULL)
+ {
+ ptr++;
+ node_count++;
+- }
++ }
+ globus_l_gfs_config_set("stripe_count", node_count, NULL);
+ }
+ }
+@@ -2731,9 +2731,9 @@ globus_l_gfs_config_misc()
+ globus_l_gfs_config_set("stripe_count", 1, NULL);
+ }
+ }
+-
++
+ }
+-
++
+ value = globus_libc_strdup(globus_i_gfs_config_string("popen_whitelist"));
+ if(value != NULL)
+ {
+@@ -2741,21 +2741,21 @@ globus_l_gfs_config_misc()
+ while((ptr = strchr(module, ',')) != NULL)
+ {
+ *ptr = '\0';
+- globus_list_insert(&popen_list, globus_libc_strdup(module));
++ globus_list_insert(&popen_list, globus_libc_strdup(module));
+ module = ptr + 1;
+ }
+ if(ptr == NULL)
+ {
+- globus_list_insert(&popen_list, globus_libc_strdup(module));
+- }
+- globus_free(value);
++ globus_list_insert(&popen_list, globus_libc_strdup(module));
++ }
++ globus_free(value);
+ }
+- globus_l_gfs_config_set("popen_list", 0, popen_list);
++ globus_l_gfs_config_set("popen_list", 0, popen_list);
+
+ if(globus_i_gfs_config_string("load_dsi_module") == NULL)
+ {
+- globus_l_gfs_config_set("load_dsi_module", 0, globus_libc_strdup("file"));
+- }
++ globus_l_gfs_config_set("load_dsi_module", 0, globus_libc_strdup("file"));
++ }
+
+ value = globus_libc_strdup(globus_i_gfs_config_string("allowed_modules"));
+ if(value != NULL)
+@@ -2764,17 +2764,17 @@ globus_l_gfs_config_misc()
+ while((ptr = strchr(module, ',')) != NULL)
+ {
+ *ptr = '\0';
+- globus_list_insert(&module_list, globus_libc_strdup(module));
++ globus_list_insert(&module_list, globus_libc_strdup(module));
+ module = ptr + 1;
+ }
+ if(ptr == NULL)
+ {
+- globus_list_insert(&module_list, globus_libc_strdup(module));
+- }
+- globus_free(value);
++ globus_list_insert(&module_list, globus_libc_strdup(module));
++ }
++ globus_free(value);
+ }
+- globus_l_gfs_config_set("module_list", 0, module_list);
+-
++ globus_l_gfs_config_set("module_list", 0, module_list);
++
+ /* if auth_level is -1 it means it has not yet been touched */
+ switch(globus_i_gfs_config_int("auth_level"))
+ {
+@@ -2820,7 +2820,7 @@ globus_l_gfs_config_misc()
+ if(globus_i_gfs_config_bool("fork"))
+ {
+ /* should log an error */
+- globus_l_gfs_config_set("fork", GLOBUS_FALSE, NULL);
++ globus_l_gfs_config_set("fork", GLOBUS_FALSE, NULL);
+ }
+
+ /* set the convenience conf opt */
+@@ -2840,9 +2840,9 @@ globus_l_gfs_config_misc()
+ globus_l_gfs_config_set("ipc_deny_from", 0, str);
+ }
+ }
+-
+- if(globus_i_gfs_config_string("remote_nodes") &&
+- !globus_i_gfs_config_bool("data_node") &&
++
++ if(globus_i_gfs_config_string("remote_nodes") &&
++ !globus_i_gfs_config_bool("data_node") &&
+ globus_i_gfs_config_string("ipc_subject"))
+ {
+ char * ipc_dn;
+@@ -2851,7 +2851,7 @@ globus_l_gfs_config_misc()
+ OM_uint32 maj_stat;
+ gss_name_t cred_name;
+ gss_cred_id_t cred;
+-
++
+ ipc_dn = globus_i_gfs_config_string("ipc_subject");
+
+ if(strcasecmp(ipc_dn, "auto") == 0)
+@@ -2888,11 +2888,11 @@ globus_l_gfs_config_misc()
+ result = min_stat;
+ goto error_exit;
+ }
+- globus_l_gfs_config_set("ipc_cred", 0, cred);
++ globus_l_gfs_config_set("ipc_cred", 0, cred);
+ }
+-
+- else if(globus_i_gfs_config_string("remote_nodes") &&
+- !globus_i_gfs_config_bool("data_node") &&
++
++ else if(globus_i_gfs_config_string("remote_nodes") &&
++ !globus_i_gfs_config_bool("data_node") &&
+ globus_i_gfs_config_string("ipc_credential"))
+ {
+ char * cred_file;
+@@ -2900,13 +2900,13 @@ globus_l_gfs_config_misc()
+ OM_uint32 min_stat;
+ OM_uint32 maj_stat;
+ gss_cred_id_t cred;
+-
++
+ cred_file = globus_i_gfs_config_string("ipc_credential");
+
+ buf.value = globus_common_create_string(
+ "X509_USER_PROXY=%s", cred_file);
+ buf.length = strlen(buf.value);
+-
++
+ maj_stat = gss_import_cred(
+ &min_stat,
+ &cred,
+@@ -2920,20 +2920,20 @@ globus_l_gfs_config_misc()
+ result = min_stat;
+ goto error_exit;
+ }
+-
++
+ globus_free(buf.value);
+-
+- globus_l_gfs_config_set("ipc_cred", 0, cred);
++
++ globus_l_gfs_config_set("ipc_cred", 0, cred);
+ }
+-
++
+ GlobusGFSDebugExit();
+ return GLOBUS_SUCCESS;
+-
++
+ error_exit:
+ GlobusGFSDebugExitWithError();
+ return result;
+ }
+-
++
+
+ /* logging is available in this func */
+ void
+@@ -2944,7 +2944,7 @@ globus_i_gfs_config_post_init()
+
+ if(globus_i_gfs_config_bool("allow_udt") && globus_l_gfs_num_threads < 1)
+ {
+- globus_gfs_log_message(GLOBUS_GFS_LOG_WARN,
++ globus_gfs_log_message(GLOBUS_GFS_LOG_WARN,
+ "Disabling UDT: threads must be enabled for UDT to function.\n");
+
+ globus_l_gfs_config_set("allow_udt", GLOBUS_FALSE, NULL);
+@@ -2954,13 +2954,13 @@ globus_i_gfs_config_post_init()
+ }
+
+ /**
+- * load configuration. read from defaults, file, env, and command line
++ * load configuration. read from defaults, file, env, and command line
+ * arguments. each overriding the other.
+ * this function will log error messages and exit the server if any
+ * errors occur.
+ * XXX need to allow config errors to log to syslog, stderr, etc
+ */
+-
++
+ int
+ globus_i_gfs_config_init_envs(
+ int argc,
+@@ -2988,8 +2988,8 @@ globus_i_gfs_config_init_envs(
+ {
+ tmp_argv = argv;
+ }
+-
+- GLOBUS_GSI_SYSCONFIG_GET_CURRENT_WORKING_DIR(&cwd_str);
++
++ GLOBUS_GSI_SYSCONFIG_GET_CURRENT_WORKING_DIR(&cwd_str);
+
+ global_config_file = "/etc/grid-security/gridftp.conf";
+ local_config_file = NULL;
+@@ -3002,14 +3002,14 @@ globus_i_gfs_config_init_envs(
+ {
+ argp++;
+ }
+- if(argp[0] == 'c' && argp[1] == '\0'
++ if(argp[0] == 'c' && argp[1] == '\0'
+ && tmp_argv[arg_num + 1])
+ {
+ local_config_file = strdup(tmp_argv[arg_num + 1]);
+ arg_num++;
+ cmdline_config = 1;
+ }
+- else if(argp[0] == 'C' && argp[1] == '\0' &&
++ else if(argp[0] == 'C' && argp[1] == '\0' &&
+ tmp_argv[arg_num + 1])
+ {
+ conf_dir = strdup(tmp_argv[arg_num + 1]);
+@@ -3021,14 +3021,14 @@ globus_i_gfs_config_init_envs(
+ arg_num++;
+ }
+ else if(!strcmp(argp, "threads") && tmp_argv[arg_num + 1])
+- {
++ {
+ globus_l_gfs_num_threads = atoi(tmp_argv[arg_num + 1]);
+ arg_num++;
+ }
+ else if(!strcmp(argp, "inetd") || !strcmp(argp, "debug") ||
+- !strcmp(argp, "i") || !strcmp(argp, "ssh") ||
++ !strcmp(argp, "i") || !strcmp(argp, "ssh") ||
+ !strcmp(argp, "no-fork"))
+- {
++ {
+ globus_l_gfs_is_worker = GLOBUS_TRUE;
+ }
+ else if(!strcmp(argp, "port-range") && tmp_argv[arg_num + 1])
+@@ -3042,7 +3042,7 @@ globus_i_gfs_config_init_envs(
+ if(local_config_file == NULL)
+ {
+ char * tmp_gl;
+-
++
+ tmp_str = malloc(PATH_MAX);
+ tmp_gl = getenv("GLOBUS_LOCATION");
+ if(tmp_gl)
+@@ -3051,10 +3051,10 @@ globus_i_gfs_config_init_envs(
+ if(rc > 0)
+ {
+ local_config_file = tmp_str;
+- }
++ }
+ }
+ }
+-
++
+ if(base_str)
+ {
+ free(cwd_str);
+@@ -3110,7 +3110,7 @@ globus_i_gfs_config_init_envs(
+ {
+ rc = globus_l_gfs_config_load_envs_from_file(global_config_file);
+ }
+-
++
+ if(globus_l_gfs_port_range)
+ {
+ setenv("GLOBUS_TCP_PORT_RANGE", globus_l_gfs_port_range, 1);
+@@ -3125,7 +3125,7 @@ globus_i_gfs_config_init_envs(
+ setenv("GLOBUS_CALLBACK_POLLING_THREADS", nthreads, 1);
+ globus_thread_set_model("pthread");
+ }
+-
++
+ if(local_config_file != NULL)
+ {
+ free(local_config_file);
+@@ -3138,7 +3138,7 @@ globus_i_gfs_config_init_envs(
+ {
+ free(base_str);
+ }
+-
++
+ return 0;
+
+ error:
+@@ -3166,9 +3166,9 @@ globus_i_gfs_config_init(
+ char * base_str = NULL;
+ GlobusGFSName(globus_i_gfs_config_init);
+ GlobusGFSDebugEnter();
+-
++
+ globus_l_gfs_common_loaded = GLOBUS_TRUE;
+-
++
+ globus_hashtable_init(
+ &option_table,
+ 256,
+@@ -3185,9 +3185,9 @@ globus_i_gfs_config_init(
+ {
+ tmp_argv = argv;
+ }
+-
+- GLOBUS_GSI_SYSCONFIG_GET_CURRENT_WORKING_DIR(&cwd_str);
+-
++
++ GLOBUS_GSI_SYSCONFIG_GET_CURRENT_WORKING_DIR(&cwd_str);
++
+ exec_name = tmp_argv[0];
+ /* set default exe name */
+ globus_location(&tmp_str);
+@@ -3211,7 +3211,7 @@ globus_i_gfs_config_init(
+ global_config_file = "/etc/grid-security/gridftp.conf";
+ local_config_file = NULL;
+ conf_dir = NULL;
+-
++
+ for(arg_num = 0; arg_num < argc; arg_num++)
+ {
+ argp = tmp_argv[arg_num];
+@@ -3223,7 +3223,7 @@ globus_i_gfs_config_init(
+ {
+ argp++;
+ }
+-
++
+ if(argp[0] == 'c' && argp[1] == '\0' && tmp_argv[arg_num + 1])
+ {
+ local_config_file = globus_libc_strdup(tmp_argv[arg_num + 1]);
+@@ -3231,7 +3231,7 @@ globus_i_gfs_config_init(
+ arg_num++;
+ continue;
+ }
+-
++
+ if(argp[0] == 'C' && argp[1] == '\0' && tmp_argv[arg_num + 1])
+ {
+ conf_dir = globus_libc_strdup(tmp_argv[arg_num + 1]);
+@@ -3245,14 +3245,14 @@ globus_i_gfs_config_init(
+ continue;
+ }
+ }
+-
++
+ if(local_config_file == NULL && !argv_only)
+ {
+ globus_eval_path("${sysconfdir}/gridftp.conf", &local_config_file);
+ }
+
+ globus_l_gfs_config_load_defaults();
+-
++
+ if(base_str)
+ {
+ globus_free(cwd_str);
+@@ -3279,7 +3279,7 @@ globus_i_gfs_config_init(
+ goto error;
+ }
+ }
+-
++
+ if(local_config_file != NULL)
+ {
+ if(*local_config_file != '/')
+@@ -3303,7 +3303,7 @@ globus_i_gfs_config_init(
+ {
+ rc = globus_l_gfs_config_load_envs_from_file(global_config_file);
+ }
+-
++
+ if(!argv_only)
+ {
+ globus_l_gfs_config_load_config_env();
+@@ -3313,15 +3313,15 @@ globus_i_gfs_config_init(
+ {
+ goto error;
+ }
+-
++
+ result = globus_l_gfs_config_misc();
+ if(result != GLOBUS_SUCCESS)
+ {
+- globus_gfs_log_exit_message("Error in post config setup:\n %s",
++ globus_gfs_log_exit_message("Error in post config setup:\n %s",
+ globus_error_print_friendly(globus_error_peek(result)));
+ goto error;
+ }
+-
++
+ globus_l_gfs_config_set("exec_name", 0, exec_name);
+ globus_l_gfs_config_set("argv", 0, tmp_argv);
+ globus_l_gfs_config_set("argc", argc, NULL);
+@@ -3338,7 +3338,7 @@ globus_i_gfs_config_init(
+ {
+ globus_free(base_str);
+ }
+-
++
+ globus_mutex_init(&globus_i_gfs_config_mutex, NULL);
+
+ GlobusGFSDebugExit();
+@@ -3354,15 +3354,15 @@ globus_i_gfs_config_int(
+ const char * option_name)
+ {
+ globus_l_gfs_config_option_t * option;
+- int value = 0;
++ int value = 0;
+ GlobusGFSName(globus_i_gfs_config_int);
+ GlobusGFSDebugEnter();
+-
+- option = (globus_l_gfs_config_option_t *)
++
++ option = (globus_l_gfs_config_option_t *)
+ globus_hashtable_lookup(&option_table, (void *) option_name);
+-
++
+ if(option)
+- {
++ {
+ value = option->int_value;
+ }
+
+@@ -3376,15 +3376,15 @@ globus_i_gfs_config_get(
+ const char * option_name)
+ {
+ globus_l_gfs_config_option_t * option;
+- void * value = NULL;
++ void * value = NULL;
+ GlobusGFSName(globus_i_gfs_config_get);
+ GlobusGFSDebugEnter();
+-
+- option = (globus_l_gfs_config_option_t *)
++
++ option = (globus_l_gfs_config_option_t *)
+ globus_hashtable_lookup(&option_table, (void *) option_name);
+-
++
+ if(option && option->value)
+- {
++ {
+ value = option->value;
+ }
+
+@@ -3418,7 +3418,7 @@ globus_i_gfs_config_is_anonymous(
+ valid = GLOBUS_TRUE;
+ }
+ }
+-
++
+ GlobusGFSDebugExit();
+ return valid;
+ }
+@@ -3444,7 +3444,7 @@ globus_i_gfs_config_allow_addr(
+ globus_i_gfs_config_string("ipc_deny_from"));
+ }
+ else
+- {
++ {
+ allow_list = globus_libc_strdup(
+ globus_i_gfs_config_string("allow_from"));
+ deny_list = globus_libc_strdup(
+@@ -3517,7 +3517,7 @@ globus_i_gfs_config_get_module_name(
+ GlobusGFSName(globus_i_gfs_config_get_module_name);
+ GlobusGFSDebugEnter();
+
+- module_list = (globus_list_t *) globus_i_gfs_config_get("module_list");
++ module_list = (globus_list_t *) globus_i_gfs_config_get("module_list");
+ for(list = module_list;
+ !globus_list_empty(list) && !found;
+ list = globus_list_rest(list))
+@@ -3539,7 +3539,7 @@ globus_i_gfs_config_get_module_name(
+ {
+ found = GLOBUS_TRUE;
+ }
+- }
++ }
+ if(found)
+ {
+ out_module = module;
+@@ -3560,7 +3560,7 @@ globus_gfs_config_get_bool(
+ globus_bool_t rc;
+
+ globus_mutex_lock(&globus_i_gfs_config_mutex);
+- rc = globus_i_gfs_config_bool(option_name);
++ rc = globus_i_gfs_config_bool(option_name);
+ globus_mutex_unlock(&globus_i_gfs_config_mutex);
+ return rc;
+ }
+@@ -3572,7 +3572,7 @@ globus_gfs_config_get_string(
+ char * rc;
+
+ globus_mutex_lock(&globus_i_gfs_config_mutex);
+- rc = globus_i_gfs_config_string(option_name);
++ rc = globus_i_gfs_config_string(option_name);
+ globus_mutex_unlock(&globus_i_gfs_config_mutex);
+ return rc;
+ }
+@@ -3584,7 +3584,7 @@ globus_gfs_config_get_list(
+ globus_list_t * rc;
+
+ globus_mutex_lock(&globus_i_gfs_config_mutex);
+- rc = globus_i_gfs_config_list(option_name);
++ rc = globus_i_gfs_config_list(option_name);
+ globus_mutex_unlock(&globus_i_gfs_config_mutex);
+ return rc;
+ }
+@@ -3596,7 +3596,7 @@ globus_gfs_config_get(
+ void * rc;
+
+ globus_mutex_lock(&globus_i_gfs_config_mutex);
+- rc = globus_i_gfs_config_get(option_name);
++ rc = globus_i_gfs_config_get(option_name);
+ globus_mutex_unlock(&globus_i_gfs_config_mutex);
+ return rc;
+ }
+@@ -3608,7 +3608,7 @@ globus_gfs_config_get_int(
+ int rc;
+
+ globus_mutex_lock(&globus_i_gfs_config_mutex);
+- rc = globus_i_gfs_config_int(option_name);
++ rc = globus_i_gfs_config_int(option_name);
+ globus_mutex_unlock(&globus_i_gfs_config_mutex);
+ return rc;
+ }
+diff --git a/gridftp/server/src/globus_i_gfs_control.c b/gridftp/server/src/globus_i_gfs_control.c
+index e18953bec..6c369c1d1 100644
+--- a/gridftp/server/src/globus_i_gfs_control.c
++++ b/gridftp/server/src/globus_i_gfs_control.c
+@@ -91,7 +91,7 @@ typedef struct
+ char * username;
+ globus_gridftp_server_control_t server_handle;
+ globus_object_t * close_error;
+-
++
+ globus_hashtable_t custom_cmd_table;
+ } globus_l_gfs_server_instance_t;
+
+@@ -105,7 +105,7 @@ typedef struct
+
+ globus_gfs_operation_type_t bounce_type;
+ globus_i_gfs_data_callback_t bounce_cb;
+- void * bounce_info;
++ void * bounce_info;
+ } globus_l_gfs_request_info_t;
+
+ typedef struct globus_l_gfs_auth_info_s
+@@ -123,7 +123,7 @@ static globus_bool_t globus_l_gfs_control_should_be_gone = GL
+ char *
+ globus_i_gsc_string_to_959(
+ int code,
+- const char * in_str,
++ const char * in_str,
+ const char * preline);
+
+ static
+@@ -133,7 +133,7 @@ globus_l_gfs_control_log(
+ const char * message,
+ int type,
+ void * user_arg);
+-
++
+ static
+ void
+ globus_l_gfs_request_custom_command(
+@@ -147,7 +147,7 @@ static int
+ globus_l_gfs_activate()
+ {
+ int rc = 0;
+-
++
+ rc = globus_module_activate(GLOBUS_XIO_MODULE);
+ if(rc != 0)
+ {
+@@ -168,7 +168,7 @@ globus_l_gfs_activate()
+ {
+ return rc;
+ }
+-
++
+ GlobusDebugInit(GLOBUS_GRIDFTP_SERVER,
+ ERROR WARNING TRACE INTERNAL_TRACE INFO STATE INFO_VERBOSE);
+
+@@ -248,7 +248,7 @@ globus_i_gfs_control_init()
+ "connections_max",
+ globus_l_gfs_conn_max_change_cb,
+ NULL);
+-
++
+ GlobusGFSDebugExit();
+ }
+
+@@ -264,12 +264,12 @@ globus_i_gfs_control_stop()
+ {
+ globus_l_gfs_control_active = GLOBUS_FALSE;
+ globus_l_gfs_control_should_be_gone = GLOBUS_TRUE;
+-
++
+ for(list = globus_l_gfs_server_handle_list;
+ !globus_list_empty(list);
+ list = globus_list_rest(list))
+ {
+- instance = (globus_l_gfs_server_instance_t *)
++ instance = (globus_l_gfs_server_instance_t *)
+ globus_list_first(list);
+
+ globus_gridftp_server_control_stop(instance->server_handle);
+@@ -300,7 +300,7 @@ globus_l_gfs_request_info_init(
+ result = GlobusGFSErrorMemory("request");
+ goto error;
+ }
+-
++
+ request->control_op = control_op;
+ request->instance = instance;
+ request->info = info_struct;
+@@ -411,13 +411,13 @@ globus_l_gfs_kvstr_path(
+ {
+ new_kvstr = globus_libc_strdup(kvstr);
+ }
+-
++
+ globus_free(chk_path);
+ globus_free(real_path);
+-
++
+ *out_kvstr = new_kvstr;
+ return GLOBUS_SUCCESS;
+-
++
+ err:
+ if(chk_path)
+ {
+@@ -427,8 +427,8 @@ err:
+ {
+ globus_free(real_path);
+ }
+-
+- return result;
++
++ return result;
+ }
+
+
+@@ -465,7 +465,7 @@ globus_l_gfs_channel_close_cb(
+ {
+ instance->close_func(instance->close_arg, instance->close_error);
+ }
+-
++
+ if(instance->home_dir)
+ {
+ globus_free(instance->home_dir);
+@@ -505,7 +505,7 @@ globus_l_gfs_done_cb(
+ globus_mutex_lock(&globus_l_gfs_control_mutex);
+ {
+ globus_l_gfs_control_should_be_gone = GLOBUS_TRUE;
+-
++
+ globus_list_remove(&globus_l_gfs_server_handle_list,
+ globus_list_search(globus_l_gfs_server_handle_list, instance));
+ }
+@@ -513,7 +513,7 @@ globus_l_gfs_done_cb(
+
+ globus_gridftp_server_control_destroy(instance->server_handle);
+
+- instance->close_error =
++ instance->close_error =
+ (result == GLOBUS_SUCCESS ? NULL : globus_error_get(result));
+ result = globus_xio_register_close(
+ instance->xio_handle,
+@@ -574,54 +574,54 @@ globus_l_gfs_auth_session_cb(
+ "User %s successfully authorized.\n",
+ reply->info.session.username);
+
+- if(reply->info.session.home_dir != NULL &&
++ if(reply->info.session.home_dir != NULL &&
+ globus_i_gfs_config_bool("use_home_dirs"))
+ {
+-#ifdef WIN32
+- if(isalpha(reply->info.session.home_dir[0]) &&
++#ifdef WIN32
++ if(isalpha(reply->info.session.home_dir[0]) &&
+ reply->info.session.home_dir[1] == ':')
+ {
+ reply->info.session.home_dir[1] = reply->info.session.home_dir[0];
+ reply->info.session.home_dir[0] = '/';
+- }
+-#endif
++ }
++#endif
+ globus_gridftp_server_control_set_cwd(
+ auth_info->instance->server_handle,
+ reply->info.session.home_dir);
+ }
+-
++
+ if(reply->info.session.home_dir)
+ {
+- auth_info->instance->home_dir =
++ auth_info->instance->home_dir =
+ globus_libc_strdup(reply->info.session.home_dir);
+ }
+- /*
++ /*
+ else
+ {
+ auth_info->instance->home_dir = globus_libc_strdup("/");
+ }
+ */
+- auth_info->instance->username =
++ auth_info->instance->username =
+ globus_libc_strdup(reply->info.session.username);
+-
+- if(reply->op_info &&
++
++ if(reply->op_info &&
+ !globus_hashtable_empty(&reply->op_info->custom_command_table))
+ {
+ globus_list_t * list;
+ int rc;
+ globus_i_gfs_cmd_ent_t * cmd_ent;
+-
+- auth_info->instance->custom_cmd_table =
++
++ auth_info->instance->custom_cmd_table =
+ reply->op_info->custom_command_table;
+-
++
+ rc = globus_hashtable_to_list(
+ &reply->op_info->custom_command_table, &list);
+-
++
+ while(!globus_list_empty(list))
+ {
+- cmd_ent = (globus_i_gfs_cmd_ent_t *)
++ cmd_ent = (globus_i_gfs_cmd_ent_t *)
+ globus_list_remove(&list, list);
+-
++
+ result = globus_gsc_959_command_add(
+ auth_info->instance->server_handle,
+ cmd_ent->cmd_name,
+@@ -636,7 +636,7 @@ globus_l_gfs_auth_session_cb(
+ char * tmp_msg;
+ tmp_msg = globus_error_print_friendly(
+ globus_error_peek(result));
+-
++
+ globus_gfs_log_message(
+ GLOBUS_GFS_LOG_ERR,
+ "Could not register command '%s':\n%s",
+@@ -729,7 +729,7 @@ globus_l_gfs_request_auth(
+ "session.authn",
+ 0,
+ "user=%s DN=\"%s\"",
+- user_name,
++ user_name,
+ subject ? subject : "");
+
+ result = globus_gridftp_server_control_get_data_auth(
+@@ -775,7 +775,7 @@ globus_l_gfs_request_auth(
+ goto user_error;
+ }
+ }
+-
++
+ auth_info = (globus_l_gfs_auth_info_t *) calloc(1,
+ sizeof(globus_l_gfs_auth_info_t));
+ if(auth_info == NULL)
+@@ -832,7 +832,7 @@ globus_l_gfs_data_stat_cb(
+ if(reply->result != GLOBUS_SUCCESS)
+ {
+ int ftp_code;
+-
++
+ /* use code and message from reply if set */
+ if(reply->code && reply->msg)
+ {
+@@ -881,7 +881,7 @@ globus_l_gfs_data_stat_cb(
+ GLOBUS_GRIDFTP_SERVER_CONTROL_RESPONSE_SUCCESS,
+ GLOBUS_NULL);
+ }
+-
++
+ if(reply->code / 100 != 1)
+ {
+ info = (globus_gfs_stat_info_t *) request->info;
+@@ -917,7 +917,7 @@ globus_l_gfs_request_stat(
+
+ instance = (globus_l_gfs_server_instance_t *) user_arg;
+
+- stat_info = (globus_gfs_stat_info_t *)
++ stat_info = (globus_gfs_stat_info_t *)
+ globus_calloc(1, sizeof(globus_gfs_stat_info_t));
+
+ result = globus_l_gfs_request_info_init(
+@@ -947,11 +947,11 @@ globus_l_gfs_request_stat(
+
+ GlobusGFSDebugExit();
+ return;
+-
++
+ error_init:
+ {
+ int ftp_code;
+-
++
+ /* pull response code from error */
+ if((ftp_code = globus_gfs_error_get_ftp_response_code(
+ globus_error_peek(result))) == 0)
+@@ -1022,7 +1022,7 @@ globus_l_gfs_data_command_cb(
+ globus_gsc_959_finished_command(op, msg);
+ globus_free(msg);
+ break;
+-
++
+ case GLOBUS_GFS_CMD_SITE_CHROOT:
+ if(request->instance->home_dir)
+ {
+@@ -1085,14 +1085,14 @@ globus_l_gfs_data_command_cb(
+ globus_gsc_959_finished_command(op, msg);
+ globus_free(msg);
+ break;
+-
++
+ case GLOBUS_GFS_CMD_HTTP_PUT:
+ case GLOBUS_GFS_CMD_HTTP_GET:
+ if(reply->code / 100 == 1)
+ {
+ struct timeval now;
+ gettimeofday(&now, NULL);
+-
++
+ switch(reply->code)
+ {
+ case 112:
+@@ -1109,7 +1109,7 @@ globus_l_gfs_data_command_cb(
+ default:
+ return;
+ }
+-
++
+ globus_i_gsc_cmd_intermediate_reply(op, msg);
+ globus_free(msg);
+ }
+@@ -1121,7 +1121,7 @@ globus_l_gfs_data_command_cb(
+ _tmp = globus_common_create_string(
+ "OK.\n%s", reply->msg);
+ msg = globus_gsc_string_to_959(200, _tmp, NULL);
+- }
++ }
+ else
+ {
+ msg = strdup("200 OK.\r\n");
+@@ -1141,7 +1141,7 @@ globus_l_gfs_data_command_cb(
+ }
+ }
+ else
+- {
++ {
+ globus_gsc_959_finished_command(op, "250 OK.\r\n");
+ }
+ break;
+@@ -1177,10 +1177,10 @@ globus_l_gfs_data_command_cb(
+ globus_free(tmp_msg);
+ globus_free(msg);
+ }
+-
++
+ if(reply->code / 100 == 1)
+ return;
+-
++
+ if(info)
+ {
+ if(info->pathname)
+@@ -1212,7 +1212,7 @@ globus_l_gfs_data_command_cb(
+ globus_free(info->op_info->argv[ctr]);
+ }
+ globus_free(info->op_info->argv);
+- }
++ }
+ globus_free(info->op_info);
+ }
+ globus_free(info);
+@@ -1254,20 +1254,20 @@ globus_l_gfs_data_internal_stat_cb(
+ {
+ globus_gfs_command_info_t * command_info;
+ globus_gfs_data_reply_t command_reply;
+-
++
+ memset(&command_reply, 0, sizeof(globus_gfs_data_reply_t));
+ command_info = (globus_gfs_command_info_t *) request->info;
+ command_reply.info.command.command = command_info->command;
+ command_reply.result = reply->result;
+-
++
+ request->bounce_cb(&command_reply, request);
+ }
+ break;
+-
++
+ default:
+ break;
+ }
+-
++
+ GlobusGFSDebugExit();
+ }
+
+@@ -1297,7 +1297,7 @@ globus_l_gfs_request_custom_command(
+
+ instance = (globus_l_gfs_server_instance_t *) user_arg;
+
+- command_info = (globus_gfs_command_info_t *)
++ command_info = (globus_gfs_command_info_t *)
+ globus_calloc(1, sizeof(globus_gfs_command_info_t));
+
+ result = globus_l_gfs_request_info_init(
+@@ -1310,22 +1310,22 @@ globus_l_gfs_request_custom_command(
+ if(strcmp(cmd_array[0], "SITE") == 0)
+ {
+ char key[1024];
+-
++
+ snprintf(key, sizeof(key), "%s %s", cmd_array[0], cmd_array[1]);
+ cmd_ent = globus_hashtable_lookup(
+ &instance->custom_cmd_table, key);
+ }
+ else
+- {
++ {
+ cmd_ent = globus_hashtable_lookup(
+ &instance->custom_cmd_table, cmd_array[0]);
+ }
+-
++
+ if(cmd_ent)
+ {
+ command_info->command = cmd_ent->cmd_id;
+ if(cmd_ent->has_pathname)
+- {
++ {
+ switch(cmd_ent->access_type)
+ {
+ case GFS_ACL_ACTION_READ:
+@@ -1340,11 +1340,11 @@ globus_l_gfs_request_custom_command(
+ default:
+ acc = GFS_L_WRITE;
+ break;
+- }
++ }
+ result = globus_l_gfs_get_full_path(
+- instance,
+- cmd_array[argc - 1],
+- &command_info->pathname,
++ instance,
++ cmd_array[argc - 1],
++ &command_info->pathname,
+ acc);
+ if(command_info->pathname == NULL)
+ {
+@@ -1356,7 +1356,7 @@ globus_l_gfs_request_custom_command(
+ command_info->pathname = globus_libc_strdup(cmd_array[argc - 1]);
+ }
+
+- command_info->op_info =
++ command_info->op_info =
+ globus_calloc(1, sizeof(globus_i_gfs_op_info_t));
+
+ command_info->op_info->cmd_ent = cmd_ent;
+@@ -1364,7 +1364,7 @@ globus_l_gfs_request_custom_command(
+ command_info->op_info->argv = globus_calloc(argc, sizeof(char *));
+ for(i = 0; i < argc; i++)
+ {
+- command_info->op_info->argv[i] =
++ command_info->op_info->argv[i] =
+ globus_libc_strdup(cmd_array[i]);
+ }
+
+@@ -1388,23 +1388,23 @@ globus_l_gfs_request_custom_command(
+ globus_l_gfs_control_log(instance->server_handle, msg_for_log,
+ type, instance);
+ free(msg_for_log);
+-
++
+ GlobusGFSDebugExit();
+ return;
+
+-err:
++err:
+ error_init:
+
+ globus_l_gfs_control_log(instance->server_handle, msg_for_log,
+ GLOBUS_GRIDFTP_SERVER_CONTROL_LOG_ERROR, instance);
+ free(msg_for_log);
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ char * ftp_str;
+ char * tmp_str;
+ int ftp_code;
+-
++
+ /* pull response code from error */
+ if((ftp_code = globus_gfs_error_get_ftp_response_code(
+ globus_error_peek(result))) == 0)
+@@ -1450,7 +1450,7 @@ globus_l_gfs_request_command(
+
+ instance = (globus_l_gfs_server_instance_t *) user_arg;
+
+- command_info = (globus_gfs_command_info_t *)
++ command_info = (globus_gfs_command_info_t *)
+ globus_calloc(1, sizeof(globus_gfs_command_info_t));
+
+ result = globus_l_gfs_request_info_init(
+@@ -1496,7 +1496,7 @@ globus_l_gfs_request_command(
+ else if(strcmp(cmd_array[0], "RNFR") == 0)
+ {
+ globus_gfs_stat_info_t * stat_info;
+-
++
+ command_info->command = GLOBUS_GFS_CMD_RNFR;
+ result = globus_l_gfs_get_full_path(
+ instance, cmd_array[1], &command_info->pathname, GFS_L_WRITE);
+@@ -1504,8 +1504,8 @@ globus_l_gfs_request_command(
+ {
+ goto err;
+ }
+-
+- stat_info = (globus_gfs_stat_info_t *)
++
++ stat_info = (globus_gfs_stat_info_t *)
+ globus_calloc(1, sizeof(globus_gfs_stat_info_t));
+
+ stat_info->file_only = GLOBUS_TRUE;
+@@ -1545,7 +1545,7 @@ globus_l_gfs_request_command(
+ command_info->command = GLOBUS_GFS_CMD_DCSC;
+ command_info->cksm_alg = globus_libc_strdup(cmd_array[1]);
+ command_info->pathname = globus_libc_strdup(cmd_array[2]);
+- if(command_info->pathname == NULL &&
++ if(command_info->pathname == NULL &&
+ strcasecmp(command_info->cksm_alg, "d") != 0)
+ {
+ goto err;
+@@ -1556,7 +1556,7 @@ globus_l_gfs_request_command(
+ {
+ char * freq;
+ int consumed;
+-
++
+ command_info->command = GLOBUS_GFS_CMD_CKSM;
+ result = globus_l_gfs_get_full_path(
+ instance, cmd_array[4], &command_info->pathname, GFS_L_READ);
+@@ -1570,7 +1570,7 @@ globus_l_gfs_request_command(
+ cmd_array[2],
+ &command_info->cksm_offset,
+ &consumed);
+- if(rc < 1 || *(cmd_array[2] + consumed) != '\0' ||
++ if(rc < 1 || *(cmd_array[2] + consumed) != '\0' ||
+ command_info->cksm_offset < 0)
+ {
+ result = GlobusGFSErrorGeneric("Invalid offset.");
+@@ -1581,7 +1581,7 @@ globus_l_gfs_request_command(
+ cmd_array[3],
+ &command_info->cksm_length,
+ &consumed);
+- if(rc < 1 || *(cmd_array[3] + consumed) != '\0' ||
++ if(rc < 1 || *(cmd_array[3] + consumed) != '\0' ||
+ command_info->cksm_length < -1)
+ {
+ result = GlobusGFSErrorGeneric("Invalid length.");
+@@ -1589,7 +1589,7 @@ globus_l_gfs_request_command(
+ }
+
+ type = GLOBUS_GRIDFTP_SERVER_CONTROL_LOG_FILE_COMMANDS;
+-
++
+ if((freq = getenv("GFS_CKSM_MARKERS")) != NULL)
+ {
+ command_info->chmod_mode = strtol(freq, NULL, 10);
+@@ -1626,13 +1626,13 @@ globus_l_gfs_request_command(
+ }
+ if (strlen(cmd_array[1]) < 14)
+ {
+- goto err;
++ goto err;
+ }
+ {
+ char* tz;
+ struct tm modtime;
+ memset(&modtime, 0, sizeof(modtime));
+- if (sscanf(cmd_array[1], "%4d%2d%2d%2d%2d%2d",
++ if (sscanf(cmd_array[1], "%4d%2d%2d%2d%2d%2d",
+ &modtime.tm_year, &modtime.tm_mon, &modtime.tm_mday,
+ &modtime.tm_hour, &modtime.tm_min, &modtime.tm_sec) != 6)
+ {
+@@ -1655,7 +1655,7 @@ globus_l_gfs_request_command(
+ if (command_info->utime_time < 0)
+ {
+ goto err;
+- }
++ }
+ }
+ type = GLOBUS_GRIDFTP_SERVER_CONTROL_LOG_SITE;
+ }
+@@ -1707,7 +1707,7 @@ globus_l_gfs_request_command(
+ else if(strcmp(cmd_array[1], "VERSION") == 0)
+ {
+ char version_string[1024];
+-
++
+ type = GLOBUS_GRIDFTP_SERVER_CONTROL_LOG_SITE;
+ snprintf(version_string, sizeof(version_string),
+ "200 %s\r\n", globus_i_gfs_config_string("version_string"));
+@@ -1769,13 +1769,13 @@ globus_l_gfs_request_command(
+ }
+ if (strlen(cmd_array[2]) < 14)
+ {
+- goto err;
++ goto err;
+ }
+ {
+ char* tz;
+ struct tm modtime;
+ memset(&modtime, 0, sizeof(modtime));
+- if (sscanf(cmd_array[2], "%4d%2d%2d%2d%2d%2d",
++ if (sscanf(cmd_array[2], "%4d%2d%2d%2d%2d%2d",
+ &modtime.tm_year, &modtime.tm_mon, &modtime.tm_mday,
+ &modtime.tm_hour, &modtime.tm_min, &modtime.tm_sec) != 6)
+ {
+@@ -1802,14 +1802,14 @@ globus_l_gfs_request_command(
+ if (command_info->utime_time < 0)
+ {
+ goto err;
+- }
++ }
+ }
+ type = GLOBUS_GRIDFTP_SERVER_CONTROL_LOG_SITE;
+ }
+ else if(strcmp(cmd_array[1], "SYMLINKFROM") == 0)
+- {
++ {
+ globus_gfs_stat_info_t * stat_info;
+-
++
+ command_info->command = GLOBUS_GFS_CMD_SITE_SYMLINKFROM;
+ result = globus_l_gfs_get_full_path(
+ instance, cmd_array[2], &command_info->pathname, GFS_L_READ);
+@@ -1817,10 +1817,10 @@ globus_l_gfs_request_command(
+ {
+ goto err;
+ }
+-
+- stat_info = (globus_gfs_stat_info_t *)
++
++ stat_info = (globus_gfs_stat_info_t *)
+ globus_calloc(1, sizeof(globus_gfs_stat_info_t));
+-
++
+ stat_info->file_only = GLOBUS_TRUE;
+ stat_info->pathname = globus_libc_strdup(command_info->pathname);
+ request->bounce_info = stat_info;
+@@ -1890,7 +1890,7 @@ globus_l_gfs_request_command(
+ "%s %s", cmd_array[2], tmp_path);
+ globus_free(tmp_path);
+ }
+- else if(strcasecmp(cmd_array[2], "CREATE") == 0)
++ else if(strcasecmp(cmd_array[2], "CREATE") == 0)
+ {
+ char * tmp_argstr;
+ result = globus_l_gfs_kvstr_path(
+@@ -1903,12 +1903,12 @@ globus_l_gfs_request_command(
+ "%s %s", cmd_array[2], tmp_argstr);
+ globus_free(tmp_argstr);
+ }
+- else if(strcasecmp(cmd_array[2], "DELETE") == 0)
++ else if(strcasecmp(cmd_array[2], "DELETE") == 0)
+ {
+ command_info->pathname = globus_common_create_string(
+ "%s %s", cmd_array[2], cmd_array[3]);
+ }
+-
++
+ if(command_info->pathname == NULL)
+ {
+ goto err;
+@@ -1919,14 +1919,14 @@ globus_l_gfs_request_command(
+ {
+ command_info->command = GLOBUS_GFS_CMD_UPAS;
+ command_info->pathname = globus_libc_strdup(cmd_array[2]);
+-
++
+ type = GLOBUS_GRIDFTP_SERVER_CONTROL_LOG_TRANSFER_STATE;
+ }
+ else if(strcmp(cmd_array[1], "UPRT") == 0)
+ {
+ command_info->command = GLOBUS_GFS_CMD_UPRT;
+ command_info->pathname = globus_libc_strdup(cmd_array[2]);
+-
++
+ type = GLOBUS_GRIDFTP_SERVER_CONTROL_LOG_TRANSFER_STATE;
+ }
+ else if(strcmp(cmd_array[1], "HTTP") == 0)
+@@ -1940,8 +1940,8 @@ globus_l_gfs_request_command(
+ {
+ goto err;
+ }
+- }
+- else if(strcasecmp(cmd_array[2], "DOWNLOAD") == 0)
++ }
++ else if(strcasecmp(cmd_array[2], "DOWNLOAD") == 0)
+ {
+ command_info->command = GLOBUS_GFS_CMD_HTTP_GET;
+ result = globus_l_gfs_kvstr_path(
+@@ -1951,7 +1951,7 @@ globus_l_gfs_request_command(
+ goto err;
+ }
+ }
+- else if(strcasecmp(cmd_array[2], "CONFIG") == 0)
++ else if(strcasecmp(cmd_array[2], "CONFIG") == 0)
+ {
+ command_info->command = GLOBUS_GFS_CMD_HTTP_CONFIG;
+ command_info->pathname = globus_libc_strdup(cmd_array[3]);
+@@ -1972,12 +1972,12 @@ globus_l_gfs_request_command(
+ {
+ goto err;
+ }
+-
++
+ rc = globus_libc_scan_off_t(
+ cmd_array[2],
+ &command_info->cksm_offset,
+ &consumed);
+- if(rc < 1 || *(cmd_array[2] + consumed) != '\0' ||
++ if(rc < 1 || *(cmd_array[2] + consumed) != '\0' ||
+ command_info->cksm_offset < 0)
+ {
+ result = GlobusGFSErrorGeneric("Invalid length.");
+@@ -2035,7 +2035,7 @@ globus_l_gfs_request_command(
+ globus_l_gfs_control_log(instance->server_handle, msg_for_log,
+ type, instance);
+ free(msg_for_log);
+-
++
+ GlobusGFSDebugExit();
+ return;
+
+@@ -2047,20 +2047,20 @@ error_init:
+ globus_l_gfs_control_log(instance->server_handle, msg_for_log,
+ GLOBUS_GRIDFTP_SERVER_CONTROL_LOG_ERROR, instance);
+ free(msg_for_log);
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ char * ftp_str;
+ char * tmp_str;
+ int ftp_code;
+-
++
+ /* pull response code from error */
+ if((ftp_code = globus_gfs_error_get_ftp_response_code(
+ globus_error_peek(result))) == 0)
+ {
+ ftp_code = 500;
+ }
+- tmp_str = globus_error_print_friendly(globus_error_peek(result));
++ tmp_str = globus_error_print_friendly(globus_error_peek(result));
+ ftp_str = globus_gsc_string_to_959(ftp_code, tmp_str, NULL);
+ globus_gsc_959_finished_command(op, ftp_str);
+ globus_free(tmp_str);
+@@ -2188,7 +2188,7 @@ globus_l_gfs_get_event_mask(
+ }
+ if(in_event_mask & GLOBUS_GFS_EVENT_TRANSFER_COMPLETE)
+ {
+- out_event_mask |=
++ out_event_mask |=
+ GLOBUS_GRIDFTP_SERVER_CONTROL_EVENT_TRANSFER_COMPLETE;
+ }
+
+@@ -2215,7 +2215,7 @@ globus_l_gfs_data_event_cb(
+ {
+ case GLOBUS_GFS_EVENT_TRANSFER_BEGIN:
+ request->event_arg = reply->event_arg;
+-
++
+ request->transfer_events = GLOBUS_TRUE;
+ event_mask = globus_l_gfs_get_event_mask(reply->event_mask);
+ result = globus_gridftp_server_control_events_enable(
+@@ -2229,27 +2229,27 @@ globus_l_gfs_data_event_cb(
+ /* TODO: can we ignore this */
+ }
+ break;
+-
++
+ case GLOBUS_GFS_EVENT_TRANSFER_CONNECTED:
+ globus_gridftp_server_control_begin_transfer(op);
+ break;
+-
++
+ case GLOBUS_GFS_EVENT_DISCONNECTED:
+ globus_gridftp_server_control_disconnected(
+- request->instance->server_handle,
++ request->instance->server_handle,
+ reply->data_arg);
+ break;
+-
++
+ case GLOBUS_GFS_EVENT_BYTES_RECVD:
+ globus_gridftp_server_control_event_send_perf(
+ op, reply->node_ndx, reply->recvd_bytes);
+ break;
+-
++
+ case GLOBUS_GFS_EVENT_RANGES_RECVD:
+ globus_gridftp_server_control_event_send_restart(
+ op, reply->recvd_ranges);
+ break;
+-
++
+ default:
+ globus_assert(0 && "Unexpected event type");
+ break;
+@@ -2273,7 +2273,7 @@ globus_l_gfs_data_transfer_cb(
+
+ request = (globus_l_gfs_request_info_t *) user_arg;
+ op = request->control_op;
+-
++
+
+ destroy_req = !request->transfer_events;
+ if(reply->result != GLOBUS_SUCCESS)
+@@ -2281,7 +2281,7 @@ globus_l_gfs_data_transfer_cb(
+ char * msg;
+ globus_result_t result;
+ int ftp_code;
+-
++
+ /* use code and message from reply if set */
+ if(reply->code && reply->msg)
+ {
+@@ -2435,11 +2435,11 @@ globus_l_gfs_request_send(
+
+ GlobusGFSDebugExit();
+ return;
+-
++
+ error_init:
+ {
+ int ftp_code;
+-
++
+ /* pull response code from error */
+ if((ftp_code = globus_gfs_error_get_ftp_response_code(
+ globus_error_peek(result))) == 0)
+@@ -2496,7 +2496,7 @@ globus_l_gfs_request_recv(
+ {
+ goto error_init;
+ }
+-
++
+ /* if restart range is anything but 0-MAX then we don't trunc the file */
+ if(globus_range_list_size(range_list))
+ {
+@@ -2514,9 +2514,9 @@ globus_l_gfs_request_recv(
+ "%"GLOBUS_OFF_T_FORMAT,
+ &recv_info->partial_offset);
+ recv_info->partial_length = -1;
+-
++
+ /* ESTO A 0 /file is not the same as STOR /file
+- ESTO doesn't truncate the file.
++ ESTO doesn't truncate the file.
+ */
+ recv_info->truncate = GLOBUS_FALSE;
+
+@@ -2526,7 +2526,7 @@ globus_l_gfs_request_recv(
+ {
+ recv_info->partial_offset = 0;
+ recv_info->partial_length = -1;
+-
++
+ if(mod_name != NULL)
+ {
+ recv_info->module_name = globus_libc_strdup(mod_name);
+@@ -2544,7 +2544,7 @@ globus_l_gfs_request_recv(
+ }
+
+ }
+-
++
+ result = globus_l_gfs_get_full_path(
+ instance, path, &recv_info->pathname, GFS_L_WRITE);
+ if(result != GLOBUS_SUCCESS)
+@@ -2555,7 +2555,7 @@ globus_l_gfs_request_recv(
+ recv_info->stripe_count = 1;
+ recv_info->node_count = 1;
+ recv_info->data_arg = data_handle;
+-
++
+ globus_i_gfs_data_request_recv(
+ NULL,
+ instance->session_arg,
+@@ -2567,11 +2567,11 @@ globus_l_gfs_request_recv(
+
+ GlobusGFSDebugExit();
+ return;
+-
++
+ error_init:
+ {
+ int ftp_code;
+-
++
+ /* pull response code from error */
+ if((ftp_code = globus_gfs_error_get_ftp_response_code(
+ globus_error_peek(result))) == 0)
+@@ -2643,11 +2643,11 @@ globus_l_gfs_request_list(
+
+ GlobusGFSDebugExit();
+ return;
+-
++
+ error_init:
+ {
+ int ftp_code;
+-
++
+ /* pull response code from error */
+ if((ftp_code = globus_gfs_error_get_ftp_response_code(
+ globus_error_peek(result))) == 0)
+@@ -2776,25 +2776,25 @@ globus_l_gfs_get_data_info(
+ NULL);
+ globus_assert(result == GLOBUS_SUCCESS);
+
+- result = globus_gridftp_server_control_get_layout(
++ result = globus_gridftp_server_control_get_layout(
+ op,
+ (globus_gsc_layout_t *) &data_info->stripe_layout,
+ &data_info->stripe_blocksize);
+ globus_assert(result == GLOBUS_SUCCESS);
+-
+- if(data_info->stripe_blocksize == 0 ||
++
++ if(data_info->stripe_blocksize == 0 ||
+ globus_i_gfs_config_bool("stripe_blocksize_locked"))
+ {
+- data_info->stripe_blocksize =
++ data_info->stripe_blocksize =
+ globus_i_gfs_config_int("stripe_blocksize");
+ }
+ if(globus_i_gfs_config_int("stripe_layout_locked"))
+ {
+- data_info->stripe_layout =
++ data_info->stripe_layout =
+ globus_i_gfs_config_int("stripe_layout");
+ }
+ else
+- {
++ {
+ switch(data_info->stripe_layout)
+ {
+ case GLOBUS_GSC_LAYOUT_TYPE_PARTITIONED:
+@@ -2805,12 +2805,12 @@ globus_l_gfs_get_data_info(
+ break;
+ case GLOBUS_GSC_LAYOUT_TYPE_NONE:
+ default:
+- data_info->stripe_layout =
++ data_info->stripe_layout =
+ globus_i_gfs_config_int("stripe_layout");
+ break;
+ }
+ }
+-
++
+ data_info->blocksize = globus_i_gfs_config_int("blocksize");
+
+ GlobusGFSDebugExit();
+@@ -2850,29 +2850,29 @@ globus_l_gfs_request_passive_data(
+
+ globus_l_gfs_get_data_info(op, data_info, net_prt);
+
+- if(globus_i_gfs_config_bool("encrypt_data") &&
++ if(globus_i_gfs_config_bool("encrypt_data") &&
+ (data_info->prot != 'P' || data_info->dcau == 'N'))
+ {
+ tmp_str = strdup("Encryption is required.");
+ err_code = GLOBUS_GRIDFTP_SERVER_CONTROL_RESPONSE_DATA_CONN_AUTH;
+ goto error_postinit;
+ }
+-
++
+ if(pathname)
+ {
+- /* delayed pasv, final perm check will happen on the stor/retr */
++ /* delayed pasv, final perm check will happen on the stor/retr */
+ result = globus_l_gfs_get_full_path(
+ instance, pathname, &data_info->pathname, GFS_L_LIST);
+ if(result != GLOBUS_SUCCESS)
+ {
+ err_code = GLOBUS_GRIDFTP_SERVER_CONTROL_RESPONSE_ACTION_FAILED;
+ goto error_postinit;
+- }
++ }
+ }
+ globus_xio_contact_parse(&parsed_contact, instance->local_contact);
+ data_info->max_cs = max;
+ data_info->interface = globus_libc_strdup(parsed_contact.host);
+-
++
+ globus_xio_contact_destroy(&parsed_contact);
+
+ globus_i_gfs_data_request_passive(
+@@ -2885,7 +2885,7 @@ globus_l_gfs_request_passive_data(
+
+ GlobusGFSDebugExit();
+ return;
+-
++
+ error_postinit:
+ globus_l_gfs_request_info_destroy(request);
+ error_init:
+@@ -2999,7 +2999,7 @@ globus_l_gfs_request_active_data(
+ }
+
+ globus_l_gfs_get_data_info(op, data_info, net_prt);
+- if(globus_i_gfs_config_bool("encrypt_data") &&
++ if(globus_i_gfs_config_bool("encrypt_data") &&
+ (data_info->prot != 'P' || data_info->dcau == 'N'))
+ {
+ tmp_str = strdup("Encryption is required.");
+@@ -3012,9 +3012,9 @@ globus_l_gfs_request_active_data(
+ data_info->contact_strings = cs;
+ data_info->cs_count = cs_count;
+ data_info->interface = globus_libc_strdup(parsed_contact.host);
+-
++
+ globus_xio_contact_destroy(&parsed_contact);
+-
++
+ globus_i_gfs_data_request_active(
+ NULL,
+ instance->session_arg,
+@@ -3025,7 +3025,7 @@ globus_l_gfs_request_active_data(
+
+ GlobusGFSDebugExit();
+ return;
+-
++
+ error_postinit:
+ globus_l_gfs_request_info_destroy(request);
+ error_init:
+@@ -3085,7 +3085,7 @@ globus_l_gfs_control_log(
+ msg = globus_libc_strdup(message);
+ globus_i_gfs_log_tr(msg, '\"', '\'');
+ globus_i_gfs_log_tr(msg, '\r', ' ');
+-
++
+ switch(type)
+ {
+ case GLOBUS_GRIDFTP_SERVER_CONTROL_LOG_REPLY:
+@@ -3124,7 +3124,7 @@ globus_l_gfs_control_log(
+ msg);
+ break;
+ }
+-
++
+ globus_free(msg);
+
+ GlobusGFSDebugExit();
+@@ -3538,7 +3538,7 @@ globus_l_gfs_add_commands(
+ {
+ goto error;
+ }
+-
++
+ if(globus_i_gfs_config_bool("allow_udt"))
+ {
+ result = globus_gridftp_server_control_add_feature(
+@@ -3601,7 +3601,7 @@ globus_l_gfs_add_commands(
+ if(dsi_ver)
+ {
+ feat_str = globus_common_create_string("DSI %s", dsi_ver);
+-
++
+ result = globus_gridftp_server_control_add_feature(
+ control_handle, feat_str);
+ globus_free(feat_str);
+@@ -3697,11 +3697,11 @@ globus_l_gfs_control_watchdog_check(
+ }
+ }
+ globus_mutex_unlock(&globus_l_gfs_control_mutex);
+-
++
+ if(can_kill)
+ {
+ globus_reltime_t timer;
+-
++
+ GlobusTimeReltimeSet(timer, 60, 0);
+ globus_callback_register_oneshot(
+ NULL,
+@@ -3798,7 +3798,7 @@ globus_i_gfs_control_start(
+
+ idle_timeout = globus_i_gfs_config_int("control_idle_timeout");
+ preauth_timeout = globus_i_gfs_config_int("control_preauth_timeout");
+-
++
+ result = globus_gridftp_server_control_attr_set_idle_time(
+ attr, idle_timeout, preauth_timeout);
+ if(result != GLOBUS_SUCCESS)
+@@ -3870,7 +3870,7 @@ globus_i_gfs_control_start(
+ goto error_attr_setup;
+ }
+
+- module_list = (globus_list_t *) globus_i_gfs_config_get("module_list");
++ module_list = (globus_list_t *) globus_i_gfs_config_get("module_list");
+ for(list = module_list;
+ !globus_list_empty(list);
+ list = globus_list_rest(list))
+@@ -3895,7 +3895,7 @@ globus_i_gfs_control_start(
+ goto error_attr_setup;
+ }
+ globus_free(alias);
+- }
++ }
+
+ result = globus_gridftp_server_control_attr_set_list(
+ attr, globus_l_gfs_request_list, instance);
+@@ -3939,7 +3939,7 @@ globus_i_gfs_control_start(
+ goto error_add_commands;
+ }
+
+-
++
+
+ /* disable commands if the user says to */
+ if((value = globus_i_gfs_config_string("disable_command_list")) != NULL)
+@@ -3962,7 +3962,7 @@ globus_i_gfs_control_start(
+ {
+ goto error_start;
+ }
+-
++
+ globus_gfs_log_event(
+ GLOBUS_GFS_LOG_INFO,
+ GLOBUS_GFS_LOG_EVENT_START,
+diff --git a/gridftp/server/src/globus_i_gfs_data.c b/gridftp/server/src/globus_i_gfs_data.c
+index 0bf0ea436..b2be75e4f 100644
+--- a/gridftp/server/src/globus_i_gfs_data.c
++++ b/gridftp/server/src/globus_i_gfs_data.c
+@@ -218,10 +218,10 @@ typedef struct
+ globus_bool_t final;
+ } globus_l_gfs_data_bounce_t;
+
+-typedef struct
++typedef struct
+ {
+ char * all;
+-
++
+ char * modify;
+ globus_bool_t modify_seen;
+ char * checksum_md5;
+@@ -271,21 +271,21 @@ typedef struct
+ char * client_appver;
+ char * client_scheme;
+ gss_cred_id_t dcsc_cred;
+-
++
+ globus_bool_t upas;
+ globus_ftp_control_handle_t udt_data_channel;
+ globus_bool_t udt_data_channel_inuse;
+-
++
+ globus_list_t ** active_rp_list;
+ globus_list_t * rp_list;
+-
++
+ globus_bool_t sharing;
+ char * sharing_state_dir;
+ char * sharing_id;
+ char * sharing_sharee;
+-
++
+ char * taskid;
+-
++
+ char * s3id;
+ char * s3key;
+ gss_cred_id_t http_cred;
+@@ -297,16 +297,16 @@ typedef struct
+ globus_xio_driver_t http_driver;
+
+ char * storattr_str;
+-
++
+ globus_bool_t order_data;
+-
++
+ int last_active;
+ globus_off_t watch_updates;
+ globus_bool_t watch;
+ globus_bool_t watch_aborted;
+ char * watch_op;
+ globus_callback_handle_t watch_handle;
+-
++
+ globus_hashtable_t custom_cmd_table;
+ } globus_l_gfs_data_session_t;
+
+@@ -357,7 +357,7 @@ typedef struct globus_l_gfs_data_operation_s
+ int list_depth;
+ int traversal_options;
+ globus_result_t delayed_error;
+-
++
+ char * user_msg;
+ int user_code;
+
+@@ -367,7 +367,7 @@ typedef struct globus_l_gfs_data_operation_s
+ globus_range_list_t recvd_ranges;
+ int retr_markers;
+ globus_bool_t markers;
+-
++
+ globus_l_gfs_data_path_list_t * path_list;
+ globus_l_gfs_data_path_list_t * current_path;
+ globus_l_gfs_data_path_list_t * root_paths;
+@@ -403,12 +403,12 @@ typedef struct globus_l_gfs_data_operation_s
+ /**/
+
+ globus_l_gfs_storattr_t * storattr;
+-
++
+ char * http_response_str;
+ char * http_ip;
+
+ int update_interval;
+-
++
+ void * event_arg;
+ int event_mask;
+
+@@ -570,7 +570,7 @@ static
+ void
+ globus_l_gfs_data_active_kickout(
+ void * user_arg);
+-
++
+ static
+ void
+ globus_l_gfs_data_passive_kickout(
+@@ -594,24 +594,24 @@ globus_l_gfs_data_brain_ready_delay_cb(
+
+ void
+ globus_i_gfs_data_http_read_cb(
+- globus_xio_handle_t xio_handle,
++ globus_xio_handle_t xio_handle,
+ globus_result_t result,
+ globus_byte_t * buffer,
+ globus_size_t length,
+- globus_size_t nbytes,
++ globus_size_t nbytes,
+ globus_xio_data_descriptor_t data_desc,
+ void * user_arg);
+ void
+ globus_i_gfs_data_http_write_cb(
+- globus_xio_handle_t xio_handle,
++ globus_xio_handle_t xio_handle,
+ globus_result_t result,
+ globus_byte_t * buffer,
+ globus_size_t length,
+- globus_size_t nbytes,
++ globus_size_t nbytes,
+ globus_xio_data_descriptor_t data_desc,
+ void * user_arg);
+
+-globus_result_t
++globus_result_t
+ globus_i_gfs_data_http_get(
+ globus_l_gfs_data_operation_t * op,
+ char * path,
+@@ -661,7 +661,7 @@ globus_i_gfs_data_http_print_response(
+ char * b64_header = NULL;
+ char * b64_body = NULL;
+ int body_len = 0;
+-
++
+ rc = globus_hashtable_to_list(header_table, &header_list);
+
+ header_str = strdup("");
+@@ -681,10 +681,10 @@ globus_i_gfs_data_http_print_response(
+ body, body_len, (globus_byte_t *) b64_body, NULL);
+ globus_assert(result == GLOBUS_SUCCESS);
+ }
+-
++
+ b64_header = malloc(strlen(header_str) * 4 / 3 + 4);
+ result = globus_l_gfs_base64_encode(
+- (globus_byte_t *) header_str, strlen(header_str),
++ (globus_byte_t *) header_str, strlen(header_str),
+ (globus_byte_t *) b64_header, NULL);
+ globus_assert(result == GLOBUS_SUCCESS);
+
+@@ -712,8 +712,8 @@ globus_i_gfs_data_http_print_response(
+ response_code,
+ b64_header);
+ }
+-
+- globus_free(header_str);
++
++ globus_free(header_str);
+ globus_free(b64_header);
+ if(b64_body)
+ {
+@@ -727,7 +727,7 @@ globus_i_gfs_data_http_print_response(
+ static char globus_l_gfs_base64_pad = '=';
+ static char * globus_l_gfs_base64_n =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+-static
++static
+ globus_result_t
+ globus_l_gfs_base64_decode(
+ const unsigned char * inbuf,
+@@ -745,7 +745,7 @@ globus_l_gfs_base64_decode(
+ {
+ if((p = strchr(globus_l_gfs_base64_n, inbuf[i])) == NULL)
+ {
+- goto err;
++ goto err;
+ }
+ D = p - globus_l_gfs_base64_n;
+ switch(i&3)
+@@ -772,27 +772,27 @@ globus_l_gfs_base64_decode(
+ switch(i&3)
+ {
+ case 1:
+- goto err;
+-
++ goto err;
++
+ case 2:
+ if(D&15)
+ {
+- goto err;
++ goto err;
+ }
+ if(strcmp((char *) &inbuf[i], "=="))
+ {
+- goto err;
++ goto err;
+ }
+ break;
+
+ case 3:
+ if(D&3)
+ {
+- goto err;
++ goto err;
+ }
+ if(strcmp((char *) &inbuf[i], "="))
+ {
+- goto err;
++ goto err;
+ }
+ break;
+
+@@ -814,7 +814,7 @@ char *
+ globus_l_gfs_defaulthome()
+ {
+ char * home_dir;
+-#ifdef WIN32
++#ifdef WIN32
+ char * ptr;
+
+ if(getenv("HOMEDRIVE") && getenv("HOMEPATH"))
+@@ -851,7 +851,7 @@ globus_l_gfs_defaulthome()
+ * for disabled accounts. Returns an error globus_result_t otherwise.
+ * Assumes caller has checked value of pw (i.e. pw is not NULL).
+ */
+-
++
+ static
+ globus_result_t
+ globus_l_gfs_validate_pwent(
+@@ -876,7 +876,7 @@ globus_l_gfs_validate_pwent(
+ ("shell is not a regular file: %s", pw->pw_shell));
+ goto err;
+ }
+-
++
+ /* shell executable? */
+ if((statbuf.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) == 0)
+ {
+@@ -887,7 +887,7 @@ globus_l_gfs_validate_pwent(
+
+ GlobusGFSDebugExit();
+ return GLOBUS_SUCCESS;
+-
++
+ err:
+ GlobusGFSDebugExitWithError();
+ return result;
+@@ -987,9 +987,9 @@ globus_l_gfs_data_watchdog_check(
+ void * arg)
+ {
+ globus_l_gfs_data_session_t * session_handle;
+-
++
+ session_handle = (globus_l_gfs_data_session_t *) arg;
+-
++
+ if(!session_handle)
+ {
+ globus_gfs_log_message(GLOBUS_GFS_LOG_ERR,
+@@ -998,7 +998,7 @@ globus_l_gfs_data_watchdog_check(
+ }
+ else if(session_handle->watch && session_handle->watch_aborted)
+ {
+- if(time(NULL) >
++ if(time(NULL) >
+ session_handle->last_active + globus_l_gfs_watchdog_limit)
+ {
+ char * msg = globus_common_create_string(
+@@ -1032,7 +1032,7 @@ globus_l_gfs_data_reset_watchdog(
+ session_handle->watch_op = operation;
+ session_handle->watch_updates = 0;
+ session_handle->watch_aborted = GLOBUS_FALSE;
+-
++
+ if(session_handle->watch)
+ {
+ if(session_handle->watch_handle == 0)
+@@ -1169,7 +1169,7 @@ globus_l_gfs_data_post_transfer_event_cb(
+ }
+
+ return remote_data_arg;
+-}
++}
+
+ globus_result_t
+ globus_i_gfs_data_virtualize_path(
+@@ -1180,28 +1180,28 @@ globus_i_gfs_data_virtualize_path(
+ globus_l_gfs_data_session_t * session_handle;
+ char * tmp_ptr;
+ session_handle = (globus_l_gfs_data_session_t *) session_arg;
+-
++
+ if(!session_handle->chroot_path)
+ {
+ *ret_string = NULL;
+ return GLOBUS_SUCCESS;
+ }
+-
++
+ tmp_ptr = strstr(in_string, session_handle->chroot_path);
+-
++
+ if(!tmp_ptr)
+ {
+ *ret_string = NULL;
+ return GLOBUS_SUCCESS;
+ }
+-
++
+ *ret_string = globus_malloc(
+ strlen(in_string) + strlen(session_handle->chroot_path));
+-
++
+ strncpy(*ret_string, in_string, tmp_ptr - in_string);
+- strcpy(*ret_string + (tmp_ptr - in_string),
++ strcpy(*ret_string + (tmp_ptr - in_string),
+ tmp_ptr + strlen((session_handle->chroot_path)));
+-
++
+ return GLOBUS_SUCCESS;
+ }
+
+@@ -1331,7 +1331,7 @@ globus_i_gfs_get_full_path(
+ result = GlobusGFSErrorGeneric("invalid pathname");
+ goto done;
+ }
+-
++
+ #ifdef WIN32
+ #define WIN_CHARS_NOT_ALLOWED ":*?\"<>|"
+ tmp_path = in_path;
+@@ -1348,10 +1348,10 @@ globus_i_gfs_get_full_path(
+ result = GlobusGFSErrorGeneric(
+ "A filename cannot contain any of the following characters: "
+ "\\ / : * ? \" < > |");
+- goto done;
+- }
++ goto done;
++ }
+ #endif
+-
++
+ if(*in_path == '/')
+ {
+ strncpy(path, in_path, sizeof(path));
+@@ -1362,7 +1362,7 @@ globus_i_gfs_get_full_path(
+ {
+ result = GlobusGFSErrorGeneric(
+ "No home directory, cannot expand ~");
+- goto done;
++ goto done;
+ }
+ in_path++;
+ if(*in_path == '/')
+@@ -1403,11 +1403,11 @@ globus_i_gfs_get_full_path(
+ /* XXX expand other usernames here */
+ result = GlobusGFSErrorGeneric(
+ "Cannot expand ~");
+- goto done;
++ goto done;
+ }
+-
++
+ cwd = globus_libc_strdup(res_pwd->pw_dir);
+- }
++ }
+ cwd_len = strlen(cwd);
+ if(cwd_len > 1 && cwd[cwd_len - 1] == '/')
+ {
+@@ -1441,7 +1441,7 @@ globus_i_gfs_get_full_path(
+ }
+
+ DriveLetterToWin(norm_path);
+-
++
+ result = globus_i_gfs_data_check_path(
+ session_arg, norm_path, ret_path, access_type, 1);
+ if(result != GLOBUS_SUCCESS)
+@@ -1495,7 +1495,7 @@ globus_i_gfs_data_check_path(
+ globus_list_t * rp_list;
+ GlobusGFSName(globus_i_gfs_data_check_path);
+ GlobusGFSDebugEnter();
+-
++
+ session_handle = (globus_l_gfs_data_session_t *) session_arg;
+
+ if(globus_list_empty(*session_handle->active_rp_list) &&
+@@ -1503,7 +1503,7 @@ globus_i_gfs_data_check_path(
+ {
+ allowed = GLOBUS_TRUE;
+ }
+-
++
+ if(is_virtual && session_handle->chroot_path)
+ {
+ if(in_path[0] == '/' && in_path[1] == '\0')
+@@ -1520,14 +1520,14 @@ globus_i_gfs_data_check_path(
+ {
+ start_path = in_path;
+ }
+-
++
+ if(!allowed)
+ {
+ if(session_handle->dsi->descriptor & GLOBUS_GFS_DSI_DESCRIPTOR_HAS_REALPATH &&
+- !globus_i_gfs_config_bool("rp_follow_symlinks") &&
+- strcmp(start_path, "/") != 0 &&
++ !globus_i_gfs_config_bool("rp_follow_symlinks") &&
++ strcmp(start_path, "/") != 0 &&
+ session_handle->dsi->realpath_func != NULL)
+- {
++ {
+ result = session_handle->dsi->realpath_func(
+ start_path, &true_path, session_handle->session_arg);
+ if(result != GLOBUS_SUCCESS)
+@@ -1535,20 +1535,20 @@ globus_i_gfs_data_check_path(
+ char * true_base;
+ char * end_slash = "";
+ int path_len;
+-
++
+ strncpy(path, start_path, sizeof(path));
+ path[MAXPATHLEN - 1] = '\0';
+-
++
+ path_len = strlen(path);
+ if(path[path_len - 1] == '/')
+ {
+ path[--path_len] = '\0';
+ end_slash = "/";
+ }
+-
++
+ tmp_ptr = strrchr(path, '/');
+ *(tmp_ptr++) = '\0';
+-
++
+ if(*path == '\0')
+ {
+ result = GLOBUS_FAILURE;
+@@ -1558,7 +1558,7 @@ globus_i_gfs_data_check_path(
+ result = session_handle->dsi->realpath_func(
+ path, &true_base, session_handle->session_arg);
+ }
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ result = GLOBUS_SUCCESS;
+@@ -1588,7 +1588,7 @@ globus_i_gfs_data_check_path(
+ *ret_path = NULL;
+ }
+ }
+-
++
+ if(true_path)
+ {
+
+@@ -1608,26 +1608,26 @@ globus_i_gfs_data_check_path(
+ rp_list = session_handle->rp_list;
+ }
+
+-
++
+ while(!globus_list_empty(rp_list))
+ {
+ check_path = true_path;
+ do
+ {
+ in_path_len = strlen(check_path);
+-
++
+ for(list = rp_list;
+ !globus_list_empty(list) && !allowed && !disallowed;
+ list = globus_list_rest(list))
+- {
++ {
+ alias_ent = globus_list_first(list);
+-
++
+ /* disallow if this a dir check and any contents are denied */
+ if(access_type & GFS_L_DIR && alias_ent->access & GFS_L_NONE)
+ {
+ if(strncmp(check_path, alias_ent->alias, in_path_len) == 0 &&
+ (check_path[in_path_len - 1] == '/' ||
+- alias_ent->alias[in_path_len] == '\0' ||
++ alias_ent->alias[in_path_len] == '\0' ||
+ alias_ent->alias[in_path_len] == '/'))
+ {
+ disallowed = GLOBUS_TRUE;
+@@ -1639,7 +1639,7 @@ globus_i_gfs_data_check_path(
+ continue;
+ }
+ }
+-
++
+ /* check if we have an exact match */
+ if(strcspn(alias_ent->alias, "[*?") != alias_ent->alias_len)
+ {
+@@ -1658,7 +1658,7 @@ globus_i_gfs_data_check_path(
+ }
+ else if(strncmp(check_path, alias_ent->alias, alias_ent->alias_len) == 0 &&
+ (alias_ent->alias[alias_ent->alias_len - 1] == '/' ||
+- check_path[alias_ent->alias_len] == '\0' ||
++ check_path[alias_ent->alias_len] == '\0' ||
+ check_path[alias_ent->alias_len] == '/'))
+ {
+ if(alias_ent->access & access_type)
+@@ -1670,13 +1670,13 @@ globus_i_gfs_data_check_path(
+ disallowed = GLOBUS_TRUE;
+ }
+ }
+-
++
+ /* check if we are a parent of an exact match */
+ if(!allowed && !disallowed && access_type & GFS_L_LIST)
+ {
+ if(strncmp(check_path, alias_ent->alias, in_path_len) == 0 &&
+ (check_path[in_path_len - 1] == '/' ||
+- alias_ent->alias[in_path_len] == '\0' ||
++ alias_ent->alias[in_path_len] == '\0' ||
+ alias_ent->alias[in_path_len] == '/'))
+ {
+ if(alias_ent->access & access_type)
+@@ -1708,17 +1708,17 @@ globus_i_gfs_data_check_path(
+ check_again = GLOBUS_FALSE;
+ }
+ } while(check_again);
+-
++
+ if(!allowed)
+ {
+ result = GlobusGFSErrorGeneric(
+ "Path not allowed.");
+-
++
+ rp_list = NULL;
+ }
+ else
+ {
+- if(rp_list == *session_handle->active_rp_list &&
++ if(rp_list == *session_handle->active_rp_list &&
+ !globus_list_empty(session_handle->rp_list))
+ {
+ rp_list = session_handle->rp_list;
+@@ -1728,15 +1728,15 @@ globus_i_gfs_data_check_path(
+ {
+ rp_list = NULL;
+ }
+-
++
+ if(!rp_list && ret_path)
+ {
+ if(alias_ent && alias_ent->realpath)
+ {
+ strncpy(path, alias_ent->realpath, alias_ent->realpath_len);
+- strcpy(path + alias_ent->realpath_len,
++ strcpy(path + alias_ent->realpath_len,
+ true_path + alias_ent->alias_len);
+-
++
+ *ret_path = globus_libc_strdup(path);
+ }
+ else if(session_handle->chroot_path)
+@@ -1750,11 +1750,11 @@ globus_i_gfs_data_check_path(
+ }
+ }
+ }
+-
++
+ globus_free(true_path);
+ }
+
+-
++
+ if(is_virtual && session_handle->chroot_path)
+ {
+ globus_free(start_path);
+@@ -1979,7 +1979,7 @@ globus_l_gfs_free_session_handle(
+ }
+ globus_free(session_handle->session_info_copy);
+ }
+-
++
+ if(session_handle->custom_cmd_table)
+ {
+ globus_list_t * list;
+@@ -2004,7 +2004,7 @@ globus_l_gfs_free_session_handle(
+ }
+ globus_hashtable_destroy(&session_handle->custom_cmd_table);
+ }
+-
++
+ if(session_handle->https_stack)
+ {
+ globus_xio_stack_destroy(session_handle->https_stack);
+@@ -2198,13 +2198,13 @@ globus_i_gfs_kv_getval(
+ int keylen;
+ char * tmp_val = NULL;
+ globus_bool_t done = GLOBUS_FALSE;
+-
++
+ keylen = strlen(key);
+ keystart = kvstring;
+ keyend = strchr(kvstring, '=');
+ while(keyend && keystart && !done)
+ {
+- if((keylen == keyend - keystart) &&
++ if((keylen == keyend - keystart) &&
+ strncasecmp(key, keystart, keyend - keystart) == 0)
+ {
+ done = GLOBUS_TRUE;
+@@ -2230,7 +2230,7 @@ globus_i_gfs_kv_getval(
+ {
+ strncpy(tmp_val, valstart, valend - valstart);
+ tmp_val[valend - valstart] = '\0';
+-
++
+ if(urldecode)
+ {
+ globus_url_string_hex_decode(tmp_val);
+@@ -2238,7 +2238,7 @@ globus_i_gfs_kv_getval(
+ }
+ }
+ }
+-
++
+ return tmp_val;
+ }
+
+@@ -2258,7 +2258,7 @@ globus_i_gfs_kv_replaceval(
+ char save;
+ char * enc_val;
+ globus_bool_t done = GLOBUS_FALSE;
+-
++
+ if(encode)
+ {
+ enc_val = globus_url_string_hex_encode(new_val, ";");
+@@ -2271,13 +2271,13 @@ globus_i_gfs_kv_replaceval(
+ }
+ enc_val = new_val;
+ }
+-
++
+ keylen = strlen(key);
+ keystart = kvstring;
+ keyend = strchr(keystart, '=');
+ while(keyend && keystart && !done)
+ {
+- if((keylen == keyend - keystart) &&
++ if((keylen == keyend - keystart) &&
+ strncasecmp(key, keystart, keyend - keystart) == 0)
+ {
+ done = GLOBUS_TRUE;
+@@ -2305,7 +2305,7 @@ globus_i_gfs_kv_replaceval(
+ *valstart = save;
+ }
+ }
+-
++
+ if(encode)
+ {
+ globus_free(enc_val);
+@@ -2423,16 +2423,16 @@ globus_l_gfs_authorize_cb(
+ {
+ globus_gfs_finished_info_t finished_info;
+ globus_l_gfs_data_operation_t * op;
+-
++
+ op = (globus_l_gfs_data_operation_t *) user_arg;
+ memset(&finished_info, '\0', sizeof(globus_gfs_finished_info_t));
+-
++
+ result = GlobusGFSErrorWrapFailed(
+ "authorization", result);
+ finished_info.result = result;
+ finished_info.type = op->type;
+ finished_info.id = op->id;
+-
++
+ if(op->callback == NULL)
+ {
+ globus_gfs_ipc_reply_finished(
+@@ -2444,7 +2444,7 @@ globus_l_gfs_authorize_cb(
+ &finished_info,
+ op->user_arg);
+ }
+-
++
+ globus_mutex_lock(&op->session_handle->mutex);
+ {
+ if(op->data_handle != NULL)
+@@ -2455,19 +2455,19 @@ globus_l_gfs_authorize_cb(
+ op->data_handle->state =
+ GLOBUS_L_GFS_DATA_HANDLE_VALID;
+ break;
+-
++
+ case GLOBUS_L_GFS_DATA_HANDLE_CLOSING:
+ break;
+-
++
+ case GLOBUS_L_GFS_DATA_HANDLE_CLOSED:
+ case GLOBUS_L_GFS_DATA_HANDLE_CLOSING_AND_DESTROYED:
+ if(!op->data_handle->is_mine)
+ {
+- remote_data_arg =
++ remote_data_arg =
+ op->data_handle->remote_data_arg;
+ }
+ break;
+-
++
+ case GLOBUS_L_GFS_DATA_HANDLE_TE_PRE_CLOSED:
+ case GLOBUS_L_GFS_DATA_HANDLE_TE_PRE_AND_DESTROYED:
+ case GLOBUS_L_GFS_DATA_HANDLE_VALID:
+@@ -2480,9 +2480,9 @@ globus_l_gfs_authorize_cb(
+ }
+ globus_mutex_unlock(&op->session_handle->mutex);
+ globus_assert(destroy_op);
+-
++
+ globus_l_gfs_data_fire_cb(op, remote_data_arg, destroy_session);
+-
++
+ globus_l_gfs_data_operation_destroy(op);
+ }
+ }
+@@ -2618,7 +2618,7 @@ globus_i_gfs_data_new_dsi(
+ globus_result_t result = GLOBUS_SUCCESS;
+ GlobusGFSName(globus_i_gfs_data_new_dsi);
+ GlobusGFSDebugEnter();
+-
++
+ if(check_name)
+ {
+ module_name = globus_i_gfs_config_get_module_name(dsi_name);
+@@ -2652,7 +2652,7 @@ globus_i_gfs_data_new_dsi(
+ goto err;
+ }
+ }
+-
++
+ /* check again */
+ new_dsi = (globus_gfs_storage_iface_t *) globus_extension_lookup(
+ dsi_handle, GLOBUS_GFS_DSI_REGISTRY, (void *) module_name);
+@@ -2665,7 +2665,7 @@ globus_i_gfs_data_new_dsi(
+
+ *dsi_iface = new_dsi;
+ return GLOBUS_SUCCESS;
+-
++
+ err:
+ *dsi_iface = NULL;
+ GlobusGFSDebugExit();
+@@ -2813,7 +2813,7 @@ globus_l_gfs_data_brain_ready_delay_cb(
+ globus_free(op->session_handle->home_dir);
+ }
+ op->session_handle->home_dir = strdup("/");
+- }
++ }
+
+ finished_info.info.session.home_dir = op->session_handle->home_dir;
+
+@@ -2830,7 +2830,7 @@ globus_l_gfs_data_brain_ready_delay_cb(
+ op->user_arg);
+ }
+ globus_l_gfs_data_reset_watchdog(op->session_handle, NULL);
+-
++
+ globus_mutex_lock(&op->session_handle->mutex);
+ {
+ GFSDataOpDec(op, destroy_op, destroy_session);
+@@ -2942,9 +2942,9 @@ globus_l_libc_initgroups_cb(
+ {
+ globus_l_libc_initgroups_info_t * info;
+ int rc;
+-
++
+ info = (globus_l_libc_initgroups_info_t *) user_arg;
+-
++
+ globus_mutex_lock(&info->mutex);
+ {
+ rc = initgroups(info->username, info->gid);
+@@ -2952,7 +2952,7 @@ globus_l_libc_initgroups_cb(
+ {
+ info->rc = rc;
+ }
+-
++
+ info->count--;
+ if(info->count == 0)
+ {
+@@ -2977,7 +2977,7 @@ globus_libc_initgroups(
+ int threads;
+ char * tmp;
+
+- threads = 2; /* XXX include globus_callback_threads.c to get #define? */
++ threads = 2; /* XXX include globus_callback_threads.c to get #define? */
+ if((tmp = globus_module_getenv("GLOBUS_CALLBACK_POLLING_THREADS")) != NULL)
+ {
+ rc = atoi(tmp);
+@@ -2987,7 +2987,7 @@ globus_libc_initgroups(
+ }
+ }
+
+- info = (globus_l_libc_initgroups_info_t *)
++ info = (globus_l_libc_initgroups_info_t *)
+ globus_malloc(sizeof(globus_l_libc_initgroups_info_t));
+
+ globus_mutex_init(&info->mutex, NULL);
+@@ -3008,14 +3008,14 @@ globus_libc_initgroups(
+ info);
+ info->count++;
+ }
+-
++
+ while(info->count > 0)
+ {
+ globus_cond_wait(&info->cond, &info->mutex);
+ }
+ }
+ globus_mutex_unlock(&info->mutex);
+-
++
+ tmprc = info->rc;
+ globus_mutex_destroy(&info->mutex);
+ globus_cond_destroy(&info->cond);
+@@ -3028,13 +3028,13 @@ globus_libc_initgroups(
+ {
+ rc = tmprc;
+ }
+-
++
+ return rc;
+ }
+
+ int
+ globus_list_cmp_alias_ent(
+- void * a,
++ void * a,
+ void * b,
+ void * arg)
+ {
+@@ -3045,7 +3045,7 @@ globus_list_cmp_alias_ent(
+ char b_tmp[b_ent->alias_len+1];
+ size_t a_i;
+ size_t b_i;
+-
++
+
+ strcpy(a_tmp, a_ent->alias ? a_ent->alias : "");
+ strcpy(b_tmp, b_ent->alias ? b_ent->alias : "");
+@@ -3060,14 +3060,14 @@ globus_list_cmp_alias_ent(
+ case '*':
+ a_tmp[a_i] = 1;
+ break;
+- case '?':
++ case '?':
+ a_tmp[a_i] = 2;
+ break;
+- case '[':
++ case '[':
+ a_tmp[a_i] = 3;
+ break;
+ }
+- }
++ }
+
+ b_i = strcspn(b_tmp, "[*?");
+ if(b_i < b_ent->alias_len)
+@@ -3077,15 +3077,15 @@ globus_list_cmp_alias_ent(
+ case '*':
+ b_tmp[b_i] = 1;
+ break;
+- case '?':
++ case '?':
+ b_tmp[b_i] = 2;
+ break;
+- case '[':
++ case '[':
+ b_tmp[b_i] = 3;
+ break;
+ }
+ }
+-
++
+ return strcmp(a_tmp, b_tmp) >= 0;
+ }
+
+@@ -3102,7 +3102,7 @@ globus_l_gfs_data_update_var_path(
+ GlobusGFSDebugEnter();
+
+ path = globus_libc_strdup(in_path);
+-
++
+ if((var = strstr(path, "$USER")) != NULL)
+ {
+ *var = '\0';
+@@ -3123,9 +3123,9 @@ globus_l_gfs_data_update_var_path(
+ }
+ if((var = strstr(path, "~")) != NULL)
+ {
+- char * tmp_home;
+-
+- tmp_home = session_handle->home_dir ?
++ char * tmp_home;
++
++ tmp_home = session_handle->home_dir ?
+ session_handle->home_dir : session_handle->true_home;
+ *var = '\0';
+ var += 1;
+@@ -3134,10 +3134,10 @@ globus_l_gfs_data_update_var_path(
+ globus_free(path);
+ path = new_path;
+ }
+-
++
+ return path;
+-}
+-
++}
++
+ static
+ void
+ globus_l_gfs_data_update_restricted_paths(
+@@ -3150,27 +3150,27 @@ globus_l_gfs_data_update_restricted_paths(
+ char * var_path;
+ GlobusGFSName(globus_l_gfs_data_update_restricted_paths);
+ GlobusGFSDebugEnter();
+-
+-
++
++
+ if(!globus_list_empty(*rp_list))
+- {
++ {
+ for(list = *rp_list;
+ !globus_list_empty(list);
+ list = globus_list_rest(list))
+- {
++ {
+ alias_ent = globus_list_first(list);
+-
++
+ if(alias_ent->alias[0] == '~' || strchr(alias_ent->alias, '$'))
+ {
+ var_path = globus_l_gfs_data_update_var_path(
+ session_handle, alias_ent->alias);
+-
++
+ globus_free(alias_ent->alias);
+- alias_ent->alias = var_path;
++ alias_ent->alias = var_path;
+ alias_ent->alias_len = strlen(alias_ent->alias);
+
+ resort = GLOBUS_TRUE;
+-
++
+ #ifdef WIN32
+ for(var_path = alias_ent->alias; *var_path != '\0'; var_path++)
+ {
+@@ -3179,15 +3179,15 @@ globus_l_gfs_data_update_restricted_paths(
+ #endif
+ }
+
+- if(alias_ent->realpath &&
++ if(alias_ent->realpath &&
+ (alias_ent->realpath[0] == '~' || strchr(alias_ent->realpath, '$')))
+ {
+ var_path = globus_l_gfs_data_update_var_path(
+ session_handle, alias_ent->realpath);
+-
++
+ globus_free(alias_ent->realpath);
+- alias_ent->realpath = var_path;
+- alias_ent->realpath_len = strlen(alias_ent->realpath);
++ alias_ent->realpath = var_path;
++ alias_ent->realpath_len = strlen(alias_ent->realpath);
+
+ #ifdef WIN32
+ for(var_path = alias_ent->realpath; *var_path != '\0'; var_path++)
+@@ -3197,7 +3197,7 @@ globus_l_gfs_data_update_restricted_paths(
+ #endif
+ }
+ }
+-
++
+ if(resort)
+ {
+ *rp_list = globus_list_sort_destructive(
+@@ -3218,31 +3218,31 @@ globus_l_gfs_data_update_restricted_paths_symlinks(
+ globus_bool_t resort = GLOBUS_FALSE;
+ GlobusGFSName(globus_l_gfs_data_update_restricted_paths);
+ GlobusGFSDebugEnter();
+-
++
+ if(!globus_i_gfs_config_bool("rp_follow_symlinks") && session_handle &&
+ session_handle->dsi->descriptor & GLOBUS_GFS_DSI_DESCRIPTOR_HAS_REALPATH &&
+ session_handle->dsi->realpath_func)
+ {
+ if(!globus_list_empty(*rp_list))
+- {
++ {
+ for(list = *rp_list;
+ !globus_list_empty(list);
+ list = globus_list_rest(list))
+- {
++ {
+ char * real_path = NULL;
+ globus_bool_t result;
+-
++
+ alias_ent = globus_list_first(list);
+-
++
+ result = session_handle->dsi->realpath_func(
+ alias_ent->alias, &real_path, session_handle->session_arg);
+-
++
+ if(result == GLOBUS_SUCCESS && real_path)
+ {
+ if(strcmp(real_path, alias_ent->alias) != 0)
+ {
+ globus_l_gfs_alias_ent_t * new_ent;
+-
++
+ new_ent = (globus_l_gfs_alias_ent_t *)
+ globus_calloc(1, sizeof(globus_l_gfs_alias_ent_t));
+ new_ent->access = alias_ent->access;
+@@ -3253,9 +3253,9 @@ globus_l_gfs_data_update_restricted_paths_symlinks(
+ new_ent->realpath = strdup(alias_ent->realpath);
+ new_ent->realpath_len = alias_ent->realpath_len;
+ }
+-
++
+ globus_list_insert(&new_list, new_ent);
+-
++
+ resort = GLOBUS_TRUE;
+ }
+ else
+@@ -3263,15 +3263,15 @@ globus_l_gfs_data_update_restricted_paths_symlinks(
+ globus_free(real_path);
+ real_path = NULL;
+ }
+- }
++ }
+ }
+-
++
+ if(resort)
+ {
+ while(!globus_list_empty(new_list))
+ {
+ globus_list_insert(
+- rp_list,
++ rp_list,
+ globus_list_remove(&new_list, new_list));
+ }
+
+@@ -3298,20 +3298,20 @@ globus_l_gfs_data_parse_restricted_paths(
+ char * chroot_path_esc = NULL;
+ GlobusGFSName(globus_l_gfs_data_parse_restricted_paths);
+ GlobusGFSDebugEnter();
+-
++
+ list = globus_list_from_string(restrict_paths, ',', NULL);
+-
++
+ /* escape glob chars in chroot */
+ if(is_virtual && session_handle && session_handle->chroot_path &&
+- strcspn(session_handle->chroot_path, "[*?") !=
++ strcspn(session_handle->chroot_path, "[*?") !=
+ strlen(session_handle->chroot_path))
+ {
+ char * ptr;
+ char * ptr_esc;
+-
+- chroot_path_esc =
++
++ chroot_path_esc =
+ (char *) malloc(2 * strlen(session_handle->chroot_path) + 1);
+-
++
+ ptr = session_handle->chroot_path;
+ ptr_esc = chroot_path_esc;
+ while(*ptr)
+@@ -3324,7 +3324,7 @@ globus_l_gfs_data_parse_restricted_paths(
+ case ']':
+ case '\\':
+ *ptr_esc++ = '\\';
+-
++
+ default:
+ *ptr_esc++ = *ptr++;
+ break;
+@@ -3344,13 +3344,13 @@ globus_l_gfs_data_parse_restricted_paths(
+ char * ptr;
+ char * alias;
+ globus_bool_t done;
+-
++
+ ent = (globus_l_gfs_alias_ent_t *)
+ globus_malloc(sizeof(globus_l_gfs_alias_ent_t));
+ ent->access = 0;
+-
+- ent_str = (char *) globus_list_remove(&list, list);
+-
++
++ ent_str = (char *) globus_list_remove(&list, list);
++
+ ptr = ent_str;
+ done = GLOBUS_FALSE;
+ while(*ptr && !done)
+@@ -3362,7 +3362,7 @@ globus_l_gfs_data_parse_restricted_paths(
+ ent->access |= GFS_L_READ;
+ ptr++;
+ break;
+-
++
+ case 'w':
+ case 'W':
+ ent->access |= GFS_L_WRITE;
+@@ -3374,7 +3374,7 @@ globus_l_gfs_data_parse_restricted_paths(
+ ent->access |= GFS_L_NONE;
+ ptr++;
+ break;
+-
++
+ case '/':
+ case '~':
+ case '$':
+@@ -3387,7 +3387,7 @@ globus_l_gfs_data_parse_restricted_paths(
+ }
+ done = GLOBUS_TRUE;
+ break;
+-
++
+ default:
+ done = GLOBUS_TRUE;
+ GlobusGFSErrorGenericStr(result,
+@@ -3396,24 +3396,24 @@ globus_l_gfs_data_parse_restricted_paths(
+ "The entry '%s' is invalid.\n", ent_str));
+ return result;
+ break;
+- }
++ }
+ }
+ ent->access |= GFS_L_LIST;
+-
++
+ if(ent->access & GFS_L_NONE)
+ {
+ ent->access = GFS_L_NONE;
+ }
+-
++
+ if((alias = strchr(ptr, ':')) != NULL)
+ {
+ *alias = '\0';
+ alias++;
+-
++
+ ent->alias = globus_libc_strdup(alias);
+ globus_url_string_hex_decode(ent->alias);
+ ent->alias_len = strlen(ent->alias);
+-
++
+ ent->realpath = globus_libc_strdup(ptr);
+ globus_url_string_hex_decode(ent->realpath);
+ ent->realpath_len = strlen(ent->realpath);
+@@ -3423,7 +3423,7 @@ globus_l_gfs_data_parse_restricted_paths(
+ ent->alias = globus_libc_strdup(ptr);
+ globus_url_string_hex_decode(ent->alias);
+ ent->alias_len = strlen(ent->alias);
+-
++
+ ent->realpath = NULL;
+ ent->realpath_len = 0;
+ }
+@@ -3431,7 +3431,7 @@ globus_l_gfs_data_parse_restricted_paths(
+
+ if(strchr(GFS_RP_LEAD_CHARS, *ent->alias) == NULL ||
+ (ent->realpath && strchr(GFS_RP_LEAD_CHARS, *ent->alias) == NULL))
+- {
++ {
+ globus_free(ent->alias);
+ if(ent->realpath)
+ {
+@@ -3442,22 +3442,22 @@ globus_l_gfs_data_parse_restricted_paths(
+ else
+ {
+ if(is_virtual)
+- {
++ {
+ char * tmp_path;
+-
++
+ if(ent->realpath)
+ {
+ globus_free(ent->realpath);
+ ent->realpath = NULL;
+ ent->realpath_len = 0;
+ }
+-
++
+ if(ent->alias[0] == '~')
+ {
+ tmp_path = globus_common_create_string(
+- "%s%s",
+- chroot_path_esc ?
+- "/" : session_handle->home_dir,
++ "%s%s",
++ chroot_path_esc ?
++ "/" : session_handle->home_dir,
+ ent->alias + 1);
+ globus_free(ent->alias);
+ ent->alias = tmp_path;
+@@ -3466,15 +3466,15 @@ globus_l_gfs_data_parse_restricted_paths(
+ else
+ {
+ if(chroot_path_esc)
+- {
+- tmp_path = globus_common_create_string("%s%s",
++ {
++ tmp_path = globus_common_create_string("%s%s",
+ chroot_path_esc, ent->alias);
+ globus_free(ent->alias);
+ ent->alias = tmp_path;
+ ent->alias_len = strlen(ent->alias);
+ }
+ }
+-
++
+ if(ent->alias_len > 1 && ent->alias[ent->alias_len - 1] == '/')
+ {
+ ent->alias[ent->alias_len - 1] = '\0';
+@@ -3485,12 +3485,12 @@ globus_l_gfs_data_parse_restricted_paths(
+ #ifdef WIN32
+ globus_l_gfs_alias_ent_t * new_ent;
+ char * tmp_ptr;
+-
++
+ for(tmp_ptr = ent->alias; *tmp_ptr != '\0'; tmp_ptr++)
+ {
+ *tmp_ptr = tolower(*tmp_ptr);
+ }
+-
++
+ if(ent->realpath)
+ {
+ for(tmp_ptr = ent->realpath; *tmp_ptr != '\0'; tmp_ptr++)
+@@ -3500,7 +3500,7 @@ globus_l_gfs_data_parse_restricted_paths(
+ }
+ #endif
+ globus_list_insert(&tmp_list, ent);
+-
++
+ #ifdef WIN32
+ /* now store driveletter:/path form of the ent */
+ if(ent->alias[0] == '/' && ent->alias[1] == '\0')
+@@ -3508,7 +3508,7 @@ globus_l_gfs_data_parse_restricted_paths(
+ /* the root path needs to mean every drive letter */
+ DWORD drivemask;
+ char drive[] = "a";
+-
++
+ drivemask = GetLogicalDrives();
+ while(drivemask && *drive <= 'z')
+ {
+@@ -3520,7 +3520,7 @@ globus_l_gfs_data_parse_restricted_paths(
+ new_ent->alias_len = strlen("_:/");
+ new_ent->alias = strdup("_:/");
+ new_ent->alias[0] = *drive;
+-
++
+ globus_list_insert(&tmp_list, new_ent);
+ }
+ (*drive)++;
+@@ -3535,7 +3535,7 @@ globus_l_gfs_data_parse_restricted_paths(
+ new_ent->alias = globus_libc_strdup(ent->alias);
+ new_ent->realpath = globus_libc_strdup(ent->realpath);
+ ent = new_ent;
+-
++
+ if(!ent->realpath && ent->alias[0] == '/' &&
+ isalpha(ent->alias[1]))
+ {
+@@ -3549,7 +3549,7 @@ globus_l_gfs_data_parse_restricted_paths(
+ ent->alias_len = 3;
+ }
+ }
+-
++
+ if(ent->realpath && ent->realpath[0] == '/' &&
+ isalpha(ent->realpath[1]))
+ {
+@@ -3566,11 +3566,11 @@ globus_l_gfs_data_parse_restricted_paths(
+ globus_list_insert(&tmp_list, ent);
+ }
+ #endif
+- }
++ }
+
+ }
+ }
+-
++
+ if(!globus_list_empty(tmp_list))
+ {
+ *out_list = globus_list_sort_destructive(
+@@ -3580,7 +3580,7 @@ globus_l_gfs_data_parse_restricted_paths(
+ {
+ result = GlobusGFSErrorGeneric("No valid paths added to restricted list.");
+ }
+-
++
+ GlobusGFSDebugExit();
+ return result;
+ }
+@@ -3631,7 +3631,7 @@ globus_l_gfs_data_read_share_file(
+ res = GlobusGFSErrorGeneric("Problem allocating memory.\n");
+ goto error_mem;
+ }
+-
++
+ while(fgets(linebuf, linebuflen, fptr) != NULL)
+ {
+ p = linebuf;
+@@ -3650,7 +3650,7 @@ globus_l_gfs_data_read_share_file(
+ goto error_mem;
+ }
+ strncat(linebuf, part_line, linebuflen);
+-
++
+ optionbuf = globus_realloc(optionbuf, linebuflen);
+ if(!optionbuf)
+ {
+@@ -3667,7 +3667,7 @@ globus_l_gfs_data_read_share_file(
+ }
+ line_num++;
+ p = linebuf;
+- optlen = 0;
++ optlen = 0;
+ while(*p && isspace(*p))
+ {
+ p++;
+@@ -3679,7 +3679,7 @@ globus_l_gfs_data_read_share_file(
+ if(*p == '#')
+ {
+ continue;
+- }
++ }
+
+ if(*p == '"')
+ {
+@@ -3689,14 +3689,14 @@ globus_l_gfs_data_read_share_file(
+ else
+ {
+ rc = sscanf(p, "%s", optionbuf);
+- }
++ }
+ if(rc != 1)
+- {
++ {
+ goto error_parse;
+ }
+ optlen += strlen(optionbuf);
+ p = p + optlen;
+-
++
+ optlen = 0;
+ while(*p && isspace(*p))
+ {
+@@ -3710,13 +3710,13 @@ globus_l_gfs_data_read_share_file(
+ else
+ {
+ rc = sscanf(p, "%s", valuebuf);
+- }
++ }
+ if(rc != 1)
+- {
++ {
+ goto error_parse;
+- }
++ }
+ optlen += strlen(valuebuf);
+- p = p + optlen;
++ p = p + optlen;
+ while(*p && isspace(*p))
+ {
+ p++;
+@@ -3725,7 +3725,7 @@ globus_l_gfs_data_read_share_file(
+ {
+ goto error_parse;
+ }
+-
++
+ if(!strcmp(optionbuf, "share_path"))
+ {
+ *share_path = strdup(valuebuf);
+@@ -3734,11 +3734,11 @@ globus_l_gfs_data_read_share_file(
+ }
+
+ fclose(fptr);
+-
++
+ globus_free(linebuf);
+ globus_free(valuebuf);
+ globus_free(optionbuf);
+-
++
+ GlobusGFSDebugExit();
+ return GLOBUS_SUCCESS;
+
+@@ -3769,7 +3769,7 @@ globus_l_gfs_data_check_sharing_perms(
+ owned by user; must have no group and world perms */
+ if(statbuf.st_uid == session_handle->uid)
+ {
+- if((statbuf.st_mode &
++ if((statbuf.st_mode &
+ (S_IRGRP | S_IXGRP | S_IWGRP | S_IROTH | S_IWOTH | S_IXOTH)) == 0)
+ {
+ rc = 0;
+@@ -3783,7 +3783,7 @@ globus_l_gfs_data_check_sharing_perms(
+ dir);
+ }
+ }
+-
++
+ /* case 2: community state directory
+ world or group writable
+ not world or group readable
+@@ -3791,7 +3791,7 @@ globus_l_gfs_data_check_sharing_perms(
+ #ifndef WIN32
+ else if((statbuf.st_mode & (S_IWGRP | S_IWOTH)) != 0)
+ {
+- if(statbuf.st_uid == 0 && ((statbuf.st_mode & S_ISVTX) != 0) &&
++ if(statbuf.st_uid == 0 && ((statbuf.st_mode & S_ISVTX) != 0) &&
+ ((statbuf.st_mode & (S_IRGRP | S_IROTH)) == 0))
+ {
+ rc = 0;
+@@ -3825,7 +3825,7 @@ globus_l_gfs_data_check_sharing_perms(
+ "accessed.\n",
+ dir);
+ }
+-
++
+ return rc;
+ }
+
+@@ -3861,7 +3861,7 @@ globus_l_gfs_data_check_sharing_allowed(
+ * if the deny list includes the user, he is immediately denied.
+ * if the allow list includes the user, he is immediately allowed.
+ * if the allow list is unset, he is allowed pending the group check.
+- * if the allow list is set and does not include the user, he is denied
++ * if the allow list is set and does not include the user, he is denied
+ pending the group check.
+ */
+ if(user_allow == NULL)
+@@ -3873,7 +3873,7 @@ globus_l_gfs_data_check_sharing_allowed(
+ {
+ allowed = GLOBUS_FALSE;
+ explicitly = GLOBUS_FALSE;
+-
++
+ user = user_allow;
+ while((ptr = strchr(user, ',')) != NULL && !allowed)
+ {
+@@ -3917,13 +3917,13 @@ globus_l_gfs_data_check_sharing_allowed(
+ }
+ }
+ globus_free(user_deny);
+- }
++ }
+
+ if(explicitly)
+ {
+ goto finish;
+ }
+-
++
+
+ group_deny = globus_libc_strdup(
+ globus_gfs_config_get_string("sharing_groups_deny"));
+@@ -3942,7 +3942,7 @@ globus_l_gfs_data_check_sharing_allowed(
+ while((ptr = strchr(group, ',')) != NULL && !allowed)
+ {
+ *ptr = '\0';
+-
++
+ grent = getgrnam(group);
+ if(grent)
+ {
+@@ -4021,7 +4021,7 @@ globus_l_gfs_data_check_sharing_allowed(
+ }
+ }
+ }
+- }
++ }
+ if(group_deny)
+ {
+ globus_free(group_deny);
+@@ -4078,18 +4078,18 @@ globus_l_gfs_data_authorize(
+ auth_level = globus_i_gfs_config_int("auth_level");
+ pw_file = (char *) globus_i_gfs_config_string("pw_file");
+ process_username = globus_i_gfs_config_string("process_user");
+- /* if there is a subject or del cred we are using gsi,
++ /* if there is a subject or del cred we are using gsi,
+ look it up in the gridmap */
+ sharing_dn = globus_i_gfs_config_string("sharing_dn");
+ op->session_handle->sharing = (sharing_dn != NULL);
+-
++
+ if(session_info->subject != NULL || session_info->del_cred != NULL)
+ {
+ if(sharing_dn && !strcmp(sharing_dn, session_info->subject))
+ {
+- if(session_info->username &&
+- strncmp(session_info->username,
+- GLOBUS_SHARING_PREFIX,
++ if(session_info->username &&
++ strncmp(session_info->username,
++ GLOBUS_SHARING_PREFIX,
+ strlen(GLOBUS_SHARING_PREFIX)) == 0)
+ {
+ char * usr_tmp;
+@@ -4099,13 +4099,13 @@ globus_l_gfs_data_authorize(
+ globus_size_t cert_len = 0;
+ char * tmp;
+ globus_gsi_cred_handle_t tmp_cred_handle;
+-
+- shared_user_str =
++
++ shared_user_str =
+ session_info->username + strlen(GLOBUS_SHARING_PREFIX);
+ ptr = shared_user_str;
+-
++
+ if((usr_tmp = globus_i_gfs_kv_getval(ptr, "USER", 1)) != NULL)
+- {
++ {
+ session_info->map_user = GLOBUS_FALSE;
+ }
+ else
+@@ -4114,7 +4114,7 @@ globus_l_gfs_data_authorize(
+ session_info->map_user = GLOBUS_TRUE;
+ }
+
+- if((op->session_handle->sharing_id =
++ if((op->session_handle->sharing_id =
+ globus_i_gfs_kv_getval(ptr, "ID", 1)) == NULL)
+ {
+ res = GlobusGFSErrorGeneric(
+@@ -4135,7 +4135,7 @@ globus_l_gfs_data_authorize(
+ }
+
+ if((crt_tmp = globus_i_gfs_kv_getval(ptr, "CERT", 0)) != NULL)
+- {
++ {
+ desired_user_cert = malloc(strlen(crt_tmp + 1));
+ res = globus_l_gfs_base64_decode(
+ (globus_byte_t *) crt_tmp,
+@@ -4158,7 +4158,7 @@ globus_l_gfs_data_authorize(
+ {
+ goto pwent_error;
+ }
+-
++
+ globus_gfs_log_message(
+ GLOBUS_GFS_LOG_INFO,
+ "DN %s has provided sharing credentials for DN %s.\n",
+@@ -4182,31 +4182,31 @@ globus_l_gfs_data_authorize(
+ "Invalid arguments for " GLOBUS_SHARING_PREFIX ". Missing SHAREE.");
+ goto pwent_error;
+ }
+-
++
+ globus_free(session_info->username);
+ session_info->username = usr_tmp;
+
+ sharing_attempted = GLOBUS_TRUE;
+- }
++ }
+ }
+
+- if(!sharing_attempted && session_info->username &&
+- strncmp(session_info->username,
+- GLOBUS_SHARING_PREFIX,
++ if(!sharing_attempted && session_info->username &&
++ strncmp(session_info->username,
++ GLOBUS_SHARING_PREFIX,
+ strlen(GLOBUS_SHARING_PREFIX)) == 0)
+ {
+ GlobusGFSErrorGenericStr(res,
+ ("Sharing not allowed with DN %s", session_info->subject));
+ goto pwent_error;
+ }
+-
++
+ if(!(auth_level & GLOBUS_L_GFS_AUTH_NOGRIDMAP))
+ {
+- if(globus_i_gfs_config_bool("cas") &&
++ if(globus_i_gfs_config_bool("cas") &&
+ (context || sharing_attempted))
+ {
+ globus_bool_t free_usr = GLOBUS_FALSE;
+-
++
+ if(session_info->map_user)
+ {
+ usr = NULL;
+@@ -4217,7 +4217,7 @@ globus_l_gfs_data_authorize(
+ }
+
+ *authz_usr = '\0';
+-
++
+ if(sharing_attempted)
+ {
+ res = globus_gss_assist_map_and_authorize_sharing(
+@@ -4226,7 +4226,7 @@ globus_l_gfs_data_authorize(
+ usr,
+ authz_usr,
+ USER_NAME_MAX);
+-
++
+ globus_free(desired_user_cert);
+ desired_user_cert = NULL;
+ }
+@@ -4515,7 +4515,7 @@ globus_l_gfs_data_authorize(
+ res = GlobusGFSErrorGeneric("Access denied by configuration.");
+ goto pwent_error;
+ }
+-
++
+ /* check that account is not disabled */
+ if(pwent && !globus_i_gfs_config_bool("allow_disabled_login"))
+ {
+@@ -4526,7 +4526,7 @@ globus_l_gfs_data_authorize(
+ errmsg = globus_error_print_friendly(globus_error_peek(res));
+ globus_gfs_log_message(
+ GLOBUS_GFS_LOG_ERR,
+- "Access denied for user '%s': %s\n",
++ "Access denied for user '%s': %s\n",
+ session_info->username, errmsg);
+ globus_free(errmsg);
+ res = GlobusGFSErrorGeneric(
+@@ -4566,7 +4566,7 @@ globus_l_gfs_data_authorize(
+ goto uid_error;
+ }
+ }
+-
++
+
+ if(pwent->pw_uid == 0 && !globus_i_gfs_config_bool("allow_root"))
+ {
+@@ -4626,23 +4626,23 @@ globus_l_gfs_data_authorize(
+
+ var_dir = globus_l_gfs_data_update_var_path(
+ op->session_handle, custom_home_dir);
+-
++
+ op->session_handle->home_dir = var_dir;
+ }
+ else
+ {
+- op->session_handle->home_dir =
++ op->session_handle->home_dir =
+ globus_libc_strdup(op->session_handle->true_home);
+ }
+-
++
+ if(sharing_dn)
+ {
+ char * sharing_state;
+-
++
+ sharing_state = globus_i_gfs_config_string("sharing_state_dir");
+- op->session_handle->sharing_state_dir =
++ op->session_handle->sharing_state_dir =
+ globus_l_gfs_data_update_var_path(
+- op->session_handle,
++ op->session_handle,
+ sharing_state ? sharing_state : "$HOME/.globus/sharing");
+
+ if(!op->session_handle->sharing_state_dir)
+@@ -4650,7 +4650,7 @@ globus_l_gfs_data_authorize(
+ res = GlobusGFSErrorMemory("sharing state dir");
+ goto pwent_error;
+ }
+-
++
+ if(sharing_attempted)
+ {
+ char * share_path = NULL;
+@@ -4665,7 +4665,7 @@ globus_l_gfs_data_authorize(
+ session_info->username));
+ goto pwent_error;
+ }
+-
++
+ share_file = globus_common_create_string(
+ "%s/share-%s",
+ op->session_handle->sharing_state_dir,
+@@ -4745,16 +4745,16 @@ globus_l_gfs_data_authorize(
+ }
+ globus_free(share_file);
+ share_file = NULL;
+-
++
+ globus_gfs_log_message(
+ GLOBUS_GFS_LOG_INFO,
+ "Access allowed for sharing of user '%s' from share id '%s'. "
+ "Sharee '%s' is restricted to '%s'.\n",
+- session_info->username,
+- op->session_handle->sharing_id,
+- op->session_handle->sharing_sharee,
++ session_info->username,
++ op->session_handle->sharing_id,
++ op->session_handle->sharing_sharee,
+ op->session_handle->chroot_path);
+-
++
+ if(op->session_handle->chroot_path[1] == '\0')
+ {
+ globus_free(op->session_handle->chroot_path);
+@@ -4772,13 +4772,13 @@ globus_l_gfs_data_authorize(
+ {
+ tmp_restrict = globus_common_create_string(
+ "RW/,N%s,N~/.*", op->session_handle->sharing_state_dir);
+- }
++ }
+ #ifdef WIN32
+ if(strstr(tmp_restrict, ":/"))
+ {
+ char * tp;
+ tp = strstr(tmp_restrict, ":/");
+- tp--;
++ tp--;
+ tp[1] = tp[0];
+ tp[0] = '/';
+ }
+@@ -4788,18 +4788,18 @@ globus_l_gfs_data_authorize(
+ while(!globus_list_empty(tmp_list))
+ {
+ globus_list_insert(
+- &globus_l_gfs_path_alias_list_sharing,
++ &globus_l_gfs_path_alias_list_sharing,
+ globus_list_remove(&tmp_list, tmp_list));
+ }
+ globus_free(tmp_restrict);
+-
++
+ if(res != GLOBUS_SUCCESS)
+ {
+ goto pwent_error;
+ }
+ }
+ }
+-
++
+ globus_l_gfs_data_update_restricted_paths(
+ op->session_handle, &globus_l_gfs_path_alias_list_base);
+ globus_l_gfs_data_update_restricted_paths(
+@@ -4821,8 +4821,8 @@ globus_l_gfs_data_authorize(
+ {
+ op->session_handle->active_rp_list = &globus_l_gfs_path_alias_list_base;
+ }
+-
+- if(!globus_i_gfs_config_bool("use_home_dirs") ||
++
++ if(!globus_i_gfs_config_bool("use_home_dirs") ||
+ op->session_handle->home_dir == NULL)
+ {
+ if(op->session_handle->home_dir)
+@@ -4830,22 +4830,22 @@ globus_l_gfs_data_authorize(
+ globus_free(op->session_handle->home_dir);
+ }
+ op->session_handle->home_dir = strdup("/");
+- }
++ }
+
+ if(op->session_handle->real_username == NULL)
+ {
+- if(pwent)
++ if(pwent)
+ {
+- op->session_handle->real_username =
++ op->session_handle->real_username =
+ globus_libc_strdup(pwent->pw_name);
+ }
+ else
+ {
+- op->session_handle->real_username =
++ op->session_handle->real_username =
+ globus_libc_strdup(op->session_handle->username);
+ }
+ }
+-
++
+ globus_gfs_log_event(
+ GLOBUS_GFS_LOG_INFO,
+ GLOBUS_GFS_LOG_EVENT_END,
+@@ -4992,7 +4992,7 @@ globus_l_gfs_load_safe(
+ GLOBUS_GFS_LOG_ERR,
+ "Some network stack drivers failed to load: %s\n",
+ msg = globus_error_print_friendly(globus_error_peek(result)));
+-
++
+ if(msg)
+ {
+ globus_free(msg);
+@@ -5071,7 +5071,7 @@ globus_i_gfs_data_dsi_checksum_support(
+ }
+
+
+-char *
++char *
+ globus_i_gfs_data_dsi_version()
+ {
+ int rc;
+@@ -5080,15 +5080,15 @@ globus_i_gfs_data_dsi_version()
+ GlobusGFSName(globus_i_gfs_data_init);
+ GlobusGFSDebugEnter();
+
+-
++
+ rc = globus_extension_get_module_version(
+ globus_l_gfs_active_dsi_handle, &version);
+ if(rc == GLOBUS_SUCCESS)
+ {
+ str = globus_common_create_string(
+- "%s-%d.%d",
+- globus_l_gfs_active_dsi_name,
+- version.major,
++ "%s-%d.%d",
++ globus_l_gfs_active_dsi_name,
++ version.major,
+ version.minor);
+ }
+
+@@ -5107,19 +5107,19 @@ globus_i_gfs_data_init()
+
+ globus_extension_register_builtins(local_extensions);
+
+- globus_l_gfs_active_dsi_name =
++ globus_l_gfs_active_dsi_name =
+ globus_i_gfs_config_string("load_dsi_module");
+
+ result = globus_i_gfs_data_new_dsi(
+- &globus_l_gfs_active_dsi_handle,
++ &globus_l_gfs_active_dsi_handle,
+ globus_l_gfs_active_dsi_name,
+- &globus_l_gfs_dsi,
++ &globus_l_gfs_dsi,
+ GLOBUS_FALSE);
+
+ if(result != GLOBUS_SUCCESS)
+ {
+ globus_gfs_log_exit_message(
+- "Couldn't load '%s'. %s\n", globus_l_gfs_active_dsi_name,
++ "Couldn't load '%s'. %s\n", globus_l_gfs_active_dsi_name,
+ globus_error_print_friendly(globus_error_peek(result)));
+ exit(1);
+ }
+@@ -5158,7 +5158,7 @@ globus_i_gfs_data_init()
+ {
+ result = globus_l_gfs_data_parse_restricted_paths(
+ NULL, restrict_path, &globus_l_gfs_path_alias_list_sharing, 0);
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ globus_gfs_log_exit_result("Error parsing sharing restricted paths", result);
+@@ -5171,7 +5171,7 @@ globus_i_gfs_data_init()
+ {
+ result = globus_l_gfs_data_parse_restricted_paths(
+ NULL, restrict_path, &globus_l_gfs_path_alias_list_sharing, 0);
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ globus_gfs_log_exit_result("Error parsing restricted paths", result);
+@@ -5184,14 +5184,14 @@ globus_i_gfs_data_init()
+ {
+ result = globus_l_gfs_data_parse_restricted_paths(
+ NULL, restrict_path, &globus_l_gfs_path_alias_list_base, 0);
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ globus_gfs_log_exit_result("Error parsing restricted paths", result);
+ exit(1);
+ }
+ }
+-
++
+ if(globus_i_gfs_config_bool("inetd"))
+ {
+ globus_l_gfs_watchdog_limit = globus_i_gfs_config_int("control_idle_timeout");
+@@ -5200,30 +5200,30 @@ globus_i_gfs_data_init()
+ globus_l_gfs_watchdog_limit = 300;
+ }
+ }
+-
++
+ if(globus_i_gfs_config_bool("allow_udt"))
+ {
+ result = globus_xio_driver_load("udt", &globus_l_gfs_udt_driver_preload);
+ if(result != GLOBUS_SUCCESS)
+ {
+ globus_gfs_log_result(
+- GLOBUS_GFS_LOG_INFO,
++ GLOBUS_GFS_LOG_INFO,
+ "Unable to load UDT driver", result);
+ globus_gfs_config_set_bool("allow_udt", GLOBUS_FALSE);
+ }
+ }
+-
++
+ if((globus_i_gfs_config_string("netmgr")) != NULL)
+ {
+ result = globus_xio_driver_load("net_manager", &globus_l_gfs_netmgr_driver);
+ if(result != GLOBUS_SUCCESS)
+ {
+ globus_gfs_log_result(
+- GLOBUS_GFS_LOG_INFO,
++ GLOBUS_GFS_LOG_INFO,
+ "Unable to load Network Manager driver", result);
+ }
+- }
+-
++ }
++
+ GlobusGFSDebugExit();
+ }
+
+@@ -5454,7 +5454,7 @@ globus_l_gfs_data_stat_kickout(
+ {
+ reply.code = 100;
+ }
+-
++
+ reply.type = GLOBUS_GFS_OP_STAT;
+ reply.id = bounce_info->op->id;
+ reply.result = bounce_info->error ?
+@@ -5466,7 +5466,7 @@ globus_l_gfs_data_stat_kickout(
+ reply.info.stat.gid_array = (int *)bounce_info->op->session_handle->gid_array;
+
+ /* pull response code from error */
+- if(bounce_info->final_stat && reply.result != GLOBUS_SUCCESS &&
++ if(bounce_info->final_stat && reply.result != GLOBUS_SUCCESS &&
+ (code = globus_gfs_error_get_ftp_response_code(
+ globus_error_peek(reply.result))) != 0)
+ {
+@@ -5499,13 +5499,13 @@ globus_l_gfs_data_stat_kickout(
+ bounce_info->op->session_handle, bounce_info->op->data_handle);
+ }
+ globus_mutex_unlock(&bounce_info->op->session_handle->mutex);
+-
++
+ globus_assert(destroy_op);
+ globus_l_gfs_data_fire_cb(
+ bounce_info->op, remote_data_arg, destroy_session);
+ globus_l_gfs_data_operation_destroy(bounce_info->op);
+ }
+-
++
+ if(bounce_info->stat_array)
+ {
+ for(i = 0; i < bounce_info->stat_count; i++)
+@@ -5563,7 +5563,7 @@ globus_l_gfs_data_approve_popen(
+ result = GlobusGFSErrorGeneric("small malloc failure.");
+ goto error;
+ }
+-
++
+ end = cmd;
+ while(end && (ptr = strstr(end, "popen:")))
+ {
+@@ -5574,23 +5574,23 @@ globus_l_gfs_data_approve_popen(
+ result = GlobusGFSErrorGeneric("popen argv not supplied.");
+ goto error;
+ }
+-
++
+ ptr += 5;
+-
++
+ delim = *ptr;
+- *ptr = '\0';
++ *ptr = '\0';
+ ptr++;
+-
++
+ endchars[0] = delim;
+ end = strpbrk(ptr, endchars);
+-
++
+ if(end != NULL)
+ {
+ end_delim = *end;
+ *end = '\0';
+ end++;
+ }
+-
++
+ for(found = GLOBUS_FALSE,
+ list = (globus_list_t *) globus_i_gfs_config_get("popen_list");
+ !globus_list_empty(list) && !found;
+@@ -5608,14 +5608,14 @@ globus_l_gfs_data_approve_popen(
+ {
+ size = strlen(alias);
+ prog = alias;
+-
++
+ }
+ if((strncmp(alias, ptr, size) == 0 && strlen(ptr) == size) ||
+ strcmp(prog, ptr) == 0)
+ {
+ found = GLOBUS_TRUE;
+ }
+- }
++ }
+ if(found)
+ {
+ if(access(prog, R_OK | X_OK) < 0)
+@@ -5639,7 +5639,7 @@ globus_l_gfs_data_approve_popen(
+ }
+ else
+ {
+- tmp = globus_common_create_string("%s%s%c%s",
++ tmp = globus_common_create_string("%s%s%c%s",
+ out ? out : "", start, delim, prog);
+ if(out)
+ {
+@@ -5668,9 +5668,9 @@ globus_l_gfs_data_approve_popen(
+
+ globus_free(cmd);
+ }
+-
++
+ *out_cmd = out;
+-
++
+ GlobusGFSDebugExit();
+ return result;
+
+@@ -5702,7 +5702,7 @@ globus_l_gfs_data_load_stack(
+ globus_result_t result = GLOBUS_SUCCESS;
+ GlobusGFSName(globus_l_gfs_data_load_stack);
+ GlobusGFSDebugEnter();
+-
++
+ if(*driver_list_out)
+ {
+ globus_xio_driver_list_destroy(*driver_list_out, GLOBUS_FALSE);
+@@ -5710,14 +5710,14 @@ globus_l_gfs_data_load_stack(
+ }
+
+ if(strcasecmp(driver_string_in, "default") == 0)
+- {
++ {
+ driver_string = default_stack;
+ }
+ else
+ {
+ driver_string = driver_string_in;
+ }
+-
++
+ if(driver_string)
+ {
+ result = globus_l_gfs_data_approve_popen(
+@@ -5733,9 +5733,9 @@ globus_l_gfs_data_load_stack(
+ parsed_driver_string,
+ driver_list_out,
+ allowed_drivers);
+-
++
+ globus_free(parsed_driver_string);
+-
++
+ if(subst_io_drivers)
+ {
+ globus_xio_driver_list_ent_t * ent;
+@@ -5764,7 +5764,7 @@ globus_l_gfs_data_load_stack(
+ }
+ }
+ }
+-
++
+ GlobusGFSDebugExit();
+ return result;
+ }
+@@ -5867,14 +5867,14 @@ globus_i_gfs_data_request_command(
+ else if(strcasecmp(cmd_info->cksm_alg, "P") == 0)
+ {
+ globus_size_t dcsc_len;
+- OM_uint32 major_status;
++ OM_uint32 major_status;
+ OM_uint32 minor_status;
+- gss_buffer_desc buf;
++ gss_buffer_desc buf;
+ gss_cred_id_t cred;
+-
++
+ dcsc_len = strlen(cmd_info->pathname);
+ buf.value = calloc(1, dcsc_len);
+-
++
+ rc = globus_l_gfs_base64_decode(
+ (globus_byte_t *) cmd_info->pathname, buf.value, &dcsc_len);
+ if(rc != GLOBUS_SUCCESS)
+@@ -5884,7 +5884,7 @@ globus_i_gfs_data_request_command(
+ "Invalid base64 input for credential type P.");
+ }
+ else
+- {
++ {
+ buf.length = strlen(buf.value);
+ major_status = gss_import_cred(
+ &minor_status,
+@@ -5908,7 +5908,7 @@ globus_i_gfs_data_request_command(
+ gss_release_cred(
+ &min_rc, &op->session_handle->dcsc_cred);
+ }
+-
++
+ op->session_handle->dcsc_cred = cred;
+ }
+ }
+@@ -5926,7 +5926,7 @@ globus_i_gfs_data_request_command(
+ globus_byte_t * tmp_val;
+ globus_byte_t * ca_pem = NULL;
+ globus_size_t ca_pem_len = 0;
+-
++
+ op->session_handle->http_config_called = GLOBUS_TRUE;
+ if((tmp_val = (globus_byte_t *)
+ globus_i_gfs_kv_getval(
+@@ -5943,8 +5943,8 @@ globus_i_gfs_data_request_command(
+ "Invalid base64 input for CA_CERTS.");
+ }
+ else
+- {
+- result = GLOBUS_SUCCESS;
++ {
++ result = GLOBUS_SUCCESS;
+ if(op->session_handle->http_ca_certs)
+ {
+ globus_free(op->session_handle->http_ca_certs);
+@@ -5952,20 +5952,20 @@ globus_i_gfs_data_request_command(
+ op->session_handle->http_ca_certs = (char *) ca_pem;
+ }
+ }
+-
++
+ call = GLOBUS_FALSE;
+ globus_gridftp_server_finished_command(op, result, NULL);
+ break;
+
+ }
+-
++
+ case GLOBUS_GFS_CMD_HTTP_PUT:
+- {
++ {
+ char * request;
+ char * path;
+ globus_off_t offset;
+- globus_off_t length;
+-
++ globus_off_t length;
++
+ result = globus_i_gfs_data_http_parse_args(
+ cmd_info->pathname, &path, &request, &offset, &length);
+ if(result == GLOBUS_SUCCESS)
+@@ -5982,12 +5982,12 @@ globus_i_gfs_data_request_command(
+ break;
+
+ case GLOBUS_GFS_CMD_HTTP_GET:
+- {
++ {
+ char * request;
+ char * path;
+ globus_off_t offset;
+- globus_off_t length;
+-
++ globus_off_t length;
++
+ result = globus_i_gfs_data_http_parse_args(
+ cmd_info->pathname, &path, &request, &offset, &length);
+ if(result == GLOBUS_SUCCESS)
+@@ -6030,7 +6030,7 @@ globus_i_gfs_data_request_command(
+ break;
+
+ case GLOBUS_GFS_CMD_SITE_SETDISKSTACK:
+- if(session_handle->dsi->descriptor &
++ if(session_handle->dsi->descriptor &
+ GLOBUS_GFS_DSI_DESCRIPTOR_SENDER)
+ {
+ result = globus_l_gfs_data_load_stack(
+@@ -6068,14 +6068,14 @@ globus_i_gfs_data_request_command(
+ result = GlobusGFSErrorGeneric(
+ "Sharing control is not allowed.");
+ }
+-
++
+ else if(!strncasecmp(cmd_info->pathname, "CREATE", 6))
+ {
+ char * share_args;
+ char * share_path = NULL;
+ char * share_id = NULL;
+ char * share_file = NULL;
+-
++
+ share_args = strchr(cmd_info->pathname, ' ');
+ if(!share_args)
+ {
+@@ -6083,7 +6083,7 @@ globus_i_gfs_data_request_command(
+ goto share_create_error;
+ }
+ share_args++;
+- if((share_id =
++ if((share_id =
+ globus_i_gfs_kv_getval(share_args, "ID", 1)) == NULL)
+ {
+ result = GlobusGFSErrorGeneric(
+@@ -6102,7 +6102,7 @@ globus_i_gfs_data_request_command(
+ }
+ tmp++;
+ }
+- if((share_path =
++ if((share_path =
+ globus_i_gfs_kv_getval(share_args, "PATH", 1)) == NULL)
+ {
+ result = GlobusGFSErrorGeneric(
+@@ -6117,12 +6117,12 @@ globus_i_gfs_data_request_command(
+ "Sharing is not allowed for the current user.");
+ goto share_create_error;
+ }
+-
++
+ share_file = globus_common_create_string(
+ "%s/share-%s",
+ op->session_handle->sharing_state_dir,
+ share_id);
+-
++
+ /* check if path will be accessible */
+ if(result == GLOBUS_SUCCESS)
+ {
+@@ -6162,14 +6162,14 @@ globus_i_gfs_data_request_command(
+ if(access(share_file, F_OK) < 0)
+ {
+ int sharingfd;
+-
++
+ /* create state dir if default and doesn't exist */
+- if(strstr(op->session_handle->sharing_state_dir, "/.globus/sharing") &&
++ if(strstr(op->session_handle->sharing_state_dir, "/.globus/sharing") &&
+ access(op->session_handle->sharing_state_dir, F_OK) < 0)
+ {
+ char * tmp_dir;
+ char * ptr;
+-
++
+ tmp_dir = strdup(op->session_handle->sharing_state_dir);
+ ptr = strrchr(tmp_dir, '/');
+ if(ptr)
+@@ -6181,15 +6181,15 @@ globus_i_gfs_data_request_command(
+ mkdir(tmp_dir, 0700);
+ free(tmp_dir);
+ }
+-
++
+ if(globus_l_gfs_data_check_sharing_perms(op->session_handle) != 0)
+ {
+ result = GlobusGFSErrorGeneric(
+ "Sharing state dir has invalid permissions.");
+ goto share_create_error;
+- }
++ }
+
+- sharingfd =
++ sharingfd =
+ open(share_file, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
+ if(sharingfd < 0)
+ {
+@@ -6201,7 +6201,7 @@ globus_i_gfs_data_request_command(
+ char * tmp_content;
+ char * tmp_enc;
+ int save_rc = 0;
+-#ifdef WIN32
++#ifdef WIN32
+ if(isalpha(share_path[0]) && share_path[1] == ':')
+ {
+ share_path[1] = share_path[0];
+@@ -6213,8 +6213,8 @@ globus_i_gfs_data_request_command(
+ }
+ #endif
+ tmp_enc = globus_url_string_hex_encode(share_path, "\"");
+-
+- tmp_content = globus_common_create_string(
++
++ tmp_content = globus_common_create_string(
+ "#\n# This file is required in order to enable GridFTP file sharing.\n"
+ "# If you remove this file, file sharing will no longer work.\n#\n\n"
+ "share_path \"%s\"\n", tmp_enc);
+@@ -6233,14 +6233,14 @@ globus_i_gfs_data_request_command(
+ "Enabling sharing (close)", errno);
+ save_rc = rc;
+ }
+-
++
+ rc = chmod(share_file, S_IRUSR);
+ if(rc < 0 && !save_rc)
+ {
+ result = GlobusGFSErrorSystemError(
+ "Enabling sharing (chmod)", errno);
+ }
+-
++
+ globus_free(tmp_enc);
+ globus_free(tmp_content);
+ }
+@@ -6270,7 +6270,7 @@ share_create_error:
+ {
+ char * share_file = NULL;
+ char * share_id = NULL;
+-
++
+ share_id = strchr(cmd_info->pathname, ' ');
+ if(!share_id)
+ {
+@@ -6290,7 +6290,7 @@ share_create_error:
+ }
+ tmp++;
+ }
+-
++
+ share_file = globus_common_create_string(
+ "%s/share-%s",
+ op->session_handle->sharing_state_dir,
+@@ -6340,9 +6340,9 @@ share_delete_error:
+ result = GlobusGFSErrorGeneric("Missing path argument.");
+ goto share_test_error;
+ }
+-
++
+ share_path++;
+-
++
+ /** check if sharing can be enabled **/
+ /* creation disabled */
+ if(!globus_i_gfs_config_bool("sharing_control"))
+@@ -6350,7 +6350,7 @@ share_delete_error:
+ result = GlobusGFSErrorGeneric(
+ "Sharing control is not enabled.");
+ }
+-
++
+ /* check allow/deny config */
+ else if(!globus_l_gfs_data_check_sharing_allowed(op->session_handle))
+ {
+@@ -6362,12 +6362,12 @@ share_delete_error:
+ else
+ {
+ /* create state dir if default and doesn't exist */
+- if(strstr(op->session_handle->sharing_state_dir, "/.globus/sharing") &&
++ if(strstr(op->session_handle->sharing_state_dir, "/.globus/sharing") &&
+ access(op->session_handle->sharing_state_dir, F_OK) < 0)
+ {
+ char * tmp_dir;
+ char * ptr;
+-
++
+ tmp_dir = strdup(op->session_handle->sharing_state_dir);
+ ptr = strrchr(tmp_dir, '/');
+ if(ptr)
+@@ -6379,14 +6379,14 @@ share_delete_error:
+ mkdir(tmp_dir, 0700);
+ free(tmp_dir);
+ }
+-
++
+ if(globus_l_gfs_data_check_sharing_perms(op->session_handle) != 0)
+ {
+ result = GlobusGFSErrorGeneric(
+ "Sharing state dir has invalid permissions.");
+ goto share_test_error;
+- }
+-
++ }
++
+ if(access(op->session_handle->sharing_state_dir, W_OK) == 0)
+ {
+ result = GLOBUS_SUCCESS;
+@@ -6427,9 +6427,9 @@ share_test_error:
+ }
+ globus_gridftp_server_finished_command(op, result, NULL);
+ call = GLOBUS_FALSE;
+-
++
+ break;
+-
++
+ case GLOBUS_GFS_CMD_SITE_RESTRICT:
+ if(!globus_list_empty(session_handle->rp_list))
+ {
+@@ -6441,10 +6441,10 @@ share_test_error:
+ result = globus_l_gfs_data_parse_restricted_paths(
+ session_handle, cmd_info->pathname, &session_handle->rp_list, 1);
+ }
+-
++
+ globus_l_gfs_data_update_restricted_paths_symlinks(
+ session_handle, &session_handle->rp_list);
+-
++
+
+ globus_gridftp_server_finished_command(op, result, NULL);
+
+@@ -6463,11 +6463,11 @@ share_test_error:
+ }
+ else
+ {
+- session_handle->chroot_path =
++ session_handle->chroot_path =
+ globus_libc_strdup(cmd_info->pathname);
+ result = GLOBUS_SUCCESS;
+ }
+-
++
+ globus_gridftp_server_finished_command(op, result, NULL);
+
+ call = GLOBUS_FALSE;
+@@ -6479,7 +6479,7 @@ share_test_error:
+ {
+ result = GlobusGFSErrorGeneric(
+ "Controller parameter must be 0 or 1.");
+-
++
+ globus_gridftp_server_finished_command(op, result, NULL);
+
+ }
+@@ -6489,13 +6489,13 @@ share_test_error:
+ char * stunserver;
+ globus_xio_driver_list_ent_t * ent;
+ globus_xio_attr_t xio_attr;
+-
++
+ if(session_handle->net_stack_list == NULL)
+ {
+ result = globus_l_gfs_data_load_stack(
+ op->session_handle->subject ? "udt,gsi" : "udt",
+ &op->session_handle->net_stack_list,
+- globus_i_gfs_config_bool("allow_udt") ?
++ globus_i_gfs_config_bool("allow_udt") ?
+ NULL : &gfs_l_data_net_allowed_drivers,
+ NULL,
+ GLOBUS_TRUE);
+@@ -6505,10 +6505,10 @@ share_test_error:
+ "Setting data channel driver stack", result);
+ }
+ }
+-
++
+ ent = globus_xio_driver_list_find_driver(
+ session_handle->net_stack_list, "udt");
+-
++
+ if(ent)
+ {
+ if(session_handle->udt_data_channel_inuse)
+@@ -6517,7 +6517,7 @@ share_test_error:
+ &session_handle->udt_data_channel);
+ session_handle->udt_data_channel_inuse = GLOBUS_FALSE;
+ }
+-
++
+ result = globus_ftp_control_handle_init(
+ &session_handle->udt_data_channel);
+ if(result != GLOBUS_SUCCESS)
+@@ -6527,7 +6527,7 @@ share_test_error:
+ goto error_upas;
+ }
+ session_handle->udt_data_channel_inuse = GLOBUS_TRUE;
+-
++
+ result = globus_i_ftp_control_data_get_attr(
+ &session_handle->udt_data_channel,
+ &xio_attr);
+@@ -6557,7 +6557,7 @@ share_test_error:
+ error_upas:
+ globus_gridftp_server_finished_command(op, result, candidates);
+ }
+-
++
+ call = GLOBUS_FALSE;
+ break;
+
+@@ -6565,7 +6565,7 @@ error_upas:
+ {
+ globus_xio_driver_list_ent_t * ent;
+ globus_xio_attr_t xio_attr;
+-
++
+ ent = globus_xio_driver_list_find_driver(
+ session_handle->net_stack_list, "udt");
+ if(ent)
+@@ -6577,25 +6577,25 @@ error_upas:
+ {
+ goto error_uprt;
+ }
+-
++
+ result = globus_xio_attr_cntl(
+ xio_attr,
+ ent->driver,
+ 18 /* GLOBUS_XIO_UDT_SET_REMOTE_CANDIDATES */,
+ cmd_info->pathname);
+-
++
+ session_handle->upas = GLOBUS_TRUE;
+ }
+ else
+ {
+ result = GlobusGFSErrorWrapFailed(
+ "Setting data channel driver stack", result);
+- }
++ }
+ error_uprt:
+ globus_gridftp_server_finished_command(op, result, NULL);
+
+ }
+-
++
+ call = GLOBUS_FALSE;
+ break;
+
+@@ -6682,7 +6682,7 @@ error_uprt:
+ call = GLOBUS_FALSE;
+ globus_gridftp_server_finished_command(op, result, NULL);
+ break;
+-
++
+ case GLOBUS_GFS_CMD_SITE_TASKID:
+ if(op->session_handle->taskid)
+ {
+@@ -6699,7 +6699,7 @@ error_uprt:
+ {
+ globus_free(op->session_handle->storattr_str);
+ }
+- op->session_handle->storattr_str =
++ op->session_handle->storattr_str =
+ globus_libc_strdup(cmd_info->pathname);
+
+ call = GLOBUS_FALSE;
+@@ -6749,15 +6749,15 @@ error_uprt:
+ case GLOBUS_GFS_CMD_SITE_CHGRP:
+ action = GFS_ACL_ACTION_WRITE;
+ break;
+-
++
+ case GLOBUS_GFS_CMD_SITE_UTIME:
+ action = GFS_ACL_ACTION_WRITE;
+ break;
+-
++
+ case GLOBUS_GFS_CMD_SITE_SYMLINK:
+ action = GFS_ACL_ACTION_CREATE;
+ break;
+-
++
+ case GLOBUS_GFS_CMD_SITE_AUTHZ_ASSERT:
+ /*
+ * A new action to provide authorization assertions received
+@@ -6783,7 +6783,7 @@ error_uprt:
+ default:
+ if(cmd_info->command >= GLOBUS_GFS_MIN_CUSTOM_CMD)
+ {
+- if(cmd_info->op_info && cmd_info->op_info->cmd_ent &&
++ if(cmd_info->op_info && cmd_info->op_info->cmd_ent &&
+ cmd_info->op_info->cmd_ent->access_type)
+ {
+ action = cmd_info->op_info->cmd_ent->access_type;
+@@ -6890,12 +6890,12 @@ globus_l_gfs_data_handle_init(
+
+ if(session_handle->udt_data_channel_inuse)
+ {
+- memcpy(&handle->data_channel, &session_handle->udt_data_channel,
++ memcpy(&handle->data_channel, &session_handle->udt_data_channel,
+ sizeof(globus_ftp_control_handle_t));
+ session_handle->udt_data_channel_inuse = GLOBUS_FALSE;
+ }
+ else
+- {
++ {
+ result = globus_ftp_control_handle_init(&handle->data_channel);
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -6964,7 +6964,7 @@ globus_l_gfs_data_handle_init(
+ {
+ handle->info.nstreams = 1;
+ }
+-
++
+ if(handle->info.mode == 'S')
+ {
+ handle->info.nstreams = 1;
+@@ -7032,7 +7032,7 @@ globus_l_gfs_data_handle_init(
+ dcau.mode = handle->info.dcau;
+ dcau.subject.mode = handle->info.dcau;
+ dcau.subject.subject = handle->info.subject;
+-
++
+ if(session_handle->dcsc_cred != GSS_C_NO_CREDENTIAL)
+ {
+ globus_xio_attr_t xio_attr;
+@@ -7068,7 +7068,7 @@ globus_l_gfs_data_handle_init(
+ {
+ cred = handle->info.del_cred;
+ }
+-
++
+ result = globus_ftp_control_local_dcau(
+ &handle->data_channel, &dcau, cred);
+ if(result != GLOBUS_SUCCESS)
+@@ -7099,13 +7099,13 @@ globus_l_gfs_data_handle_init(
+ goto error_control;
+ }
+ }
+-
++
+ /* create a default stack that we can add the netmgr driver to */
+ if(globus_l_gfs_netmgr_driver && globus_list_empty(net_stack_list))
+ {
+ globus_xio_driver_list_ent_t * ent;
+ globus_list_t ** tailp = &net_stack_list;
+-
++
+ ent = malloc(sizeof(globus_xio_driver_list_ent_t));
+ ent->driver = globus_io_compat_get_tcp_driver();
+ ent->driver_name = strdup("tcp");
+@@ -7114,7 +7114,7 @@ globus_l_gfs_data_handle_init(
+ ent->loaded = GLOBUS_TRUE;
+ globus_list_insert(tailp, ent);
+ tailp = globus_list_rest_ref(*tailp);
+-
++
+ ent = malloc(sizeof(globus_xio_driver_list_ent_t));
+ ent->driver = globus_io_compat_get_gsi_driver();
+ ent->driver_name = strdup("gsi");
+@@ -7124,7 +7124,7 @@ globus_l_gfs_data_handle_init(
+ globus_list_insert(tailp, ent);
+ tailp = globus_list_rest_ref(*tailp);
+ }
+-
++
+ if(!globus_list_empty(net_stack_list))
+ {
+ globus_xio_stack_t stack;
+@@ -7144,7 +7144,7 @@ globus_l_gfs_data_handle_init(
+ globus_error_print_friendly(globus_error_peek(result)));
+ goto error_control;
+ }
+-
++
+
+ for (p = net_stack_list; !globus_list_empty(p); p = globus_list_rest(p))
+ {
+@@ -7160,7 +7160,7 @@ globus_l_gfs_data_handle_init(
+ }
+
+ globus_xio_stack_init(&stack, NULL);
+-
++
+ result = globus_xio_driver_list_to_stack_attr(
+ new_net_stack_list, stack, xio_attr);
+ globus_list_free(new_net_stack_list);
+@@ -7179,10 +7179,10 @@ globus_l_gfs_data_handle_init(
+ char * opt_str;
+
+ globus_xio_stack_push_driver(stack, globus_l_gfs_netmgr_driver);
+-
++
+ opt_str = globus_common_create_string(
+- "service=gridftp-data;task-id=%s;%s",
+- session_handle->taskid ? session_handle->taskid : "none",
++ "service=gridftp-data;task-id=%s;%s",
++ session_handle->taskid ? session_handle->taskid : "none",
+ globus_i_gfs_config_string("netmgr"));
+
+ result = globus_xio_attr_cntl(
+@@ -7197,13 +7197,13 @@ globus_l_gfs_data_handle_init(
+ "Setting network manager options \"%s\": %s\n",
+ opt_str,
+ globus_error_print_friendly(globus_error_peek(result)));
+- globus_free(opt_str);
++ globus_free(opt_str);
+ goto error_control;
+ }
+
+ globus_free(opt_str);
+ }
+-
++
+ result = globus_i_ftp_control_data_set_stack(
+ &handle->data_channel, stack);
+ if(result != GLOBUS_SUCCESS)
+@@ -7720,7 +7720,7 @@ globus_l_gfs_data_hybrid_session_start_cb(
+ {
+ globus_l_gfs_data_operation_t * op;
+ globus_l_gfs_data_operation_t * hybrid_op;
+-
++
+ op = user_arg;
+ if(op && op->hybrid_op)
+ {
+@@ -7754,7 +7754,7 @@ globus_l_gfs_data_hybrid_session_start_cb(
+ globus_l_gfs_data_passive_kickout,
+ bounce_info);
+ }
+-
++
+ else
+ {
+ globus_i_gfs_data_request_passive(
+@@ -7790,7 +7790,7 @@ globus_l_gfs_data_hybrid_session_start_cb(
+ globus_l_gfs_data_active_kickout,
+ bounce_info);
+ }
+-
++
+ else
+ {
+ globus_i_gfs_data_request_active(
+@@ -7836,7 +7836,7 @@ globus_l_gfs_data_passive_kickout(
+ bounce_info->handle->is_mine = GLOBUS_TRUE;
+ bounce_info->handle->state = GLOBUS_L_GFS_DATA_HANDLE_VALID;
+
+- reply.info.data.data_arg = (void *) (intptr_t)
++ reply.info.data.data_arg = (void *) (intptr_t)
+ globus_handle_table_insert(
+ &bounce_info->handle->session_handle->handle_table,
+ bounce_info->handle,
+@@ -7901,16 +7901,16 @@ globus_i_gfs_data_request_passive(
+ session_handle = (globus_l_gfs_data_session_t *) session_arg;
+ globus_l_gfs_data_reset_watchdog(session_handle, NULL);
+
+- if(session_handle->hybrid && data_info->max_cs != 1 &&
++ if(session_handle->hybrid && data_info->max_cs != 1 &&
+ session_handle->dsi != globus_l_gfs_dsi_hybrid)
+ {
+ globus_l_gfs_data_operation_t * hybrid_op;
+ result = globus_i_gfs_data_new_dsi(
+- &globus_l_gfs_active_dsi_handle,
+- "remote",
+- &globus_l_gfs_dsi_hybrid,
++ &globus_l_gfs_active_dsi_handle,
++ "remote",
++ &globus_l_gfs_dsi_hybrid,
+ GLOBUS_FALSE);
+-
++
+ if(!globus_l_gfs_dsi_hybrid)
+ {
+ goto error_op;
+@@ -7925,7 +7925,7 @@ globus_i_gfs_data_request_passive(
+ }
+
+ session_handle->dsi = globus_l_gfs_dsi_hybrid;
+-
++
+ result = globus_l_gfs_data_operation_init(&op, session_handle);
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -7933,7 +7933,7 @@ globus_i_gfs_data_request_passive(
+ "globus_l_gfs_data_operation_init", result);
+ goto error_op;
+ }
+-
++
+ result = globus_l_gfs_data_operation_init(
+ (globus_l_gfs_data_operation_t **) &op->hybrid_op, session_handle);
+ if(result != GLOBUS_SUCCESS)
+@@ -7952,8 +7952,8 @@ globus_i_gfs_data_request_passive(
+ hybrid_op->session_handle = session_handle;
+ hybrid_op->info_struct = data_info;
+
+-
+-
++
++
+ op->callback = globus_l_gfs_data_hybrid_session_start_cb;
+ op->user_arg = op;
+ op->session_handle = session_handle;
+@@ -7962,10 +7962,10 @@ globus_i_gfs_data_request_passive(
+ op->type = GLOBUS_L_GFS_DATA_INFO_TYPE_PASSIVE;
+ globus_l_gfs_data_auth_init_cb(
+ NULL, GFS_ACL_ACTION_INIT, op, GLOBUS_SUCCESS);
+-
++
+ return;
+ }
+-
++
+ if(session_handle->dsi->passive_func != NULL)
+ {
+ result = globus_l_gfs_data_operation_init(&op, session_handle);
+@@ -8009,7 +8009,7 @@ globus_i_gfs_data_request_passive(
+ data_info->del_cred = session_handle->del_cred;
+ }
+ else
+- {
++ {
+ session_handle->dcsc_cred = data_info->del_cred;
+ data_info->del_cred = NULL;
+ }
+@@ -8035,7 +8035,7 @@ globus_i_gfs_data_request_passive(
+ "globus_ftp_control_local_pasv", result);
+ goto error_control;
+ }
+-
++
+
+ /* XXX This needs to be smarter. The address should be the same one
+ * the user is connected to on the control channel (at least when
+@@ -8232,17 +8232,17 @@ globus_i_gfs_data_request_active(
+ session_handle = (globus_l_gfs_data_session_t *) session_arg;
+ globus_l_gfs_data_reset_watchdog(session_handle, NULL);
+
+- if(session_handle->hybrid && data_info->cs_count != 1 &&
++ if(session_handle->hybrid && data_info->cs_count != 1 &&
+ session_handle->dsi != globus_l_gfs_dsi_hybrid)
+ {
+ globus_l_gfs_data_operation_t * hybrid_op;
+-
++
+ result = globus_i_gfs_data_new_dsi(
+ &globus_l_gfs_active_dsi_handle,
+ "remote",
+ &globus_l_gfs_dsi_hybrid,
+ GLOBUS_FALSE);
+-
++
+ if(!globus_l_gfs_dsi_hybrid)
+ {
+ goto error_op;
+@@ -8257,7 +8257,7 @@ globus_i_gfs_data_request_active(
+ }
+
+ session_handle->dsi = globus_l_gfs_dsi_hybrid;
+-
++
+ result = globus_l_gfs_data_operation_init(&op, session_handle);
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -8265,7 +8265,7 @@ globus_i_gfs_data_request_active(
+ "globus_l_gfs_data_operation_init", result);
+ goto error_op;
+ }
+-
++
+ result = globus_l_gfs_data_operation_init(
+ (globus_l_gfs_data_operation_t **) &op->hybrid_op, session_handle);
+ if(result != GLOBUS_SUCCESS)
+@@ -8284,8 +8284,8 @@ globus_i_gfs_data_request_active(
+ hybrid_op->session_handle = session_handle;
+ hybrid_op->info_struct = data_info;
+
+-
+-
++
++
+ op->callback = globus_l_gfs_data_hybrid_session_start_cb;
+ op->user_arg = op;
+ op->session_handle = session_handle;
+@@ -8294,10 +8294,10 @@ globus_i_gfs_data_request_active(
+ op->type = GLOBUS_L_GFS_DATA_INFO_TYPE_ACTIVE;
+ globus_l_gfs_data_auth_init_cb(
+ NULL, GFS_ACL_ACTION_INIT, op, GLOBUS_SUCCESS);
+-
++
+ return;
+ }
+-
++
+ if(session_handle->dsi->active_func != NULL)
+ {
+ result = globus_l_gfs_data_operation_init(&op, session_handle);
+@@ -8489,7 +8489,7 @@ globus_i_gfs_data_request_recv(
+
+ session_handle = (globus_l_gfs_data_session_t *) session_arg;
+ globus_l_gfs_data_reset_watchdog(session_handle, "RECV");
+-
++
+ /* YOU ARE ENTERING THE UGLY HACK ZONE */
+ globus_mutex_lock(&session_handle->mutex);
+ {
+@@ -8517,7 +8517,7 @@ globus_i_gfs_data_request_recv(
+ "globus_l_gfs_data_operation_init", result);
+ goto error_op;
+ }
+-
++
+ op->ipc_handle = ipc_handle;
+ op->session_handle = session_handle;
+ op->type = GLOBUS_L_GFS_DATA_INFO_TYPE_RECV;
+@@ -8539,14 +8539,14 @@ globus_i_gfs_data_request_recv(
+ op->markers = globus_i_gfs_config_bool("always_send_markers");
+ if(session_handle->storattr_str)
+ {
+- op->storattr = (globus_l_gfs_storattr_t *)
++ op->storattr = (globus_l_gfs_storattr_t *)
+ globus_calloc(1, sizeof(globus_l_gfs_storattr_t));
+ op->storattr->all = session_handle->storattr_str;
+ session_handle->storattr_str = NULL;
+
+ op->storattr->modify = globus_i_gfs_kv_getval(
+ op->storattr->all, "modify", 0);
+-
++
+ op->storattr->checksum_md5 = globus_i_gfs_kv_getval(
+ op->storattr->all, "x.checksum.md5", 0);
+ if(!op->storattr->checksum_md5)
+@@ -8554,11 +8554,11 @@ globus_i_gfs_data_request_recv(
+ op->storattr->checksum_md5 = globus_i_gfs_kv_getval(
+ op->storattr->all, "checksum.md5", 0);
+ }
+-
++
+ if(op->storattr->checksum_md5 && !recv_info->expected_checksum)
+ {
+ recv_info->expected_checksum_alg = globus_libc_strdup("md5");
+- recv_info->expected_checksum =
++ recv_info->expected_checksum =
+ globus_libc_strdup(op->storattr->checksum_md5);
+ }
+ }
+@@ -8568,7 +8568,7 @@ globus_i_gfs_data_request_recv(
+ {
+ /* globus_assert(data_handle->outstanding_op == NULL); */
+ data_handle->outstanding_op = op;
+- globus_assert(data_handle->state == GLOBUS_L_GFS_DATA_HANDLE_VALID ||
++ globus_assert(data_handle->state == GLOBUS_L_GFS_DATA_HANDLE_VALID ||
+ data_handle->state == GLOBUS_L_GFS_DATA_HANDLE_TE_VALID);
+ data_handle->state = GLOBUS_L_GFS_DATA_HANDLE_INUSE;
+ }
+@@ -8577,7 +8577,7 @@ globus_i_gfs_data_request_recv(
+ {
+ op->http_ip = data_handle->http_ip;
+ data_handle->http_ip = NULL;
+-
++
+ op->op_info_id = globus_l_gfs_op_info_ctr++;
+ if(!recv_info->op_info)
+ {
+@@ -8748,7 +8748,7 @@ globus_i_gfs_data_request_send(
+ {
+ /*globus_assert(data_handle->outstanding_op == NULL); */
+ data_handle->outstanding_op = op;
+- globus_assert(data_handle->state == GLOBUS_L_GFS_DATA_HANDLE_VALID ||
++ globus_assert(data_handle->state == GLOBUS_L_GFS_DATA_HANDLE_VALID ||
+ data_handle->state == GLOBUS_L_GFS_DATA_HANDLE_TE_VALID);
+ data_handle->state = GLOBUS_L_GFS_DATA_HANDLE_INUSE;
+ }
+@@ -8757,7 +8757,7 @@ globus_i_gfs_data_request_send(
+ {
+ op->http_ip = data_handle->http_ip;
+ data_handle->http_ip = NULL;
+-
++
+ op->op_info_id = globus_l_gfs_op_info_ctr++;
+ if(!send_info->op_info)
+ {
+@@ -8774,7 +8774,7 @@ globus_i_gfs_data_request_send(
+ char * full_pathname = NULL;
+
+ chdir_to = globus_i_gfs_config_string("chdir_to");
+-
++
+ result = globus_i_gfs_get_full_path(
+ session_handle->home_dir,
+ chdir_to ? chdir_to : "/", // XXX
+@@ -8853,7 +8853,7 @@ error_handle:
+ static
+ void
+ globus_l_gfs_data_list_done(
+- globus_l_gfs_data_operation_t* op,
++ globus_l_gfs_data_operation_t* op,
+ globus_result_t result)
+ {
+ while(op->path_list)
+@@ -8871,7 +8871,7 @@ globus_l_gfs_data_list_done(
+ globus_free(tofree->pathname);
+ globus_free(tofree);
+ }
+-
++
+ op->current_path = NULL;
+ globus_free(op->stat_wrapper);
+ globus_gridftp_server_finished_transfer(op, result);
+@@ -8899,18 +8899,18 @@ globus_l_gfs_data_request_next_path(
+ orig_op->current_path = NULL;
+ free(stat_info->pathname);
+ }
+-
++
+ nextpath = orig_op->path_list;
+ if(nextpath)
+ {
+ orig_op->path_list = nextpath->next;
+-
++
+ result = globus_l_gfs_data_operation_init(&op, orig_op->session_handle);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error_op;
+- }
+-
++ }
++
+ op->uid = getuid();
+ op->state = GLOBUS_L_GFS_DATA_REQUESTING;
+ op->callback = globus_l_gfs_data_list_stat_cb;
+@@ -8918,15 +8918,15 @@ globus_l_gfs_data_request_next_path(
+ op->session_handle = orig_op->session_handle;
+ op->info_struct = orig_op->stat_wrapper;
+ op->type = GLOBUS_L_GFS_DATA_INFO_TYPE_STAT;
+-
++
+ stat_info->pathname = nextpath->pathname;
+-
++
+ globus_callback_register_oneshot(
+ NULL,
+ NULL,
+ globus_l_gfs_blocking_dispatch_kickout,
+ op);
+-
++
+ orig_op->current_path = nextpath;
+ }
+
+@@ -8965,21 +8965,21 @@ globus_l_gfs_data_list_write_cb(
+ {
+ globus_free(bounce_info->list_response);
+ }
+-
++
+ globus_mutex_lock(&op->stat_lock);
+ if(bounce_info->final_stat && !globus_l_gfs_data_request_next_path(op))
+ {
+ finish = GLOBUS_TRUE;
+ }
+ globus_mutex_unlock(&op->stat_lock);
+-
++
+ globus_free(bounce_info);
+
+ if(op->delayed_error != GLOBUS_SUCCESS)
+ {
+ result = op->delayed_error;
+ }
+-
++
+ if(finish)
+ {
+ globus_l_gfs_data_list_done(op, result);
+@@ -9007,7 +9007,7 @@ globus_l_gfs_data_list_stat_cb(
+ int i;
+ int dirlen;
+ int baselen;
+-
++
+ GlobusGFSName(globus_l_gfs_data_list_stat_cb);
+ GlobusGFSDebugEnter();
+
+@@ -9025,7 +9025,7 @@ globus_l_gfs_data_list_stat_cb(
+ result = reply->result;
+ goto error;
+ }
+- if (!(op->traversal_options & GLOBUS_GFS_TRAVERSAL_CONTINUE))
++ if (!(op->traversal_options & GLOBUS_GFS_TRAVERSAL_CONTINUE))
+ {
+ /** MLSR failure. We want to write out the information for
+ * this directory and then fail. */
+@@ -9036,13 +9036,13 @@ globus_l_gfs_data_list_stat_cb(
+ stat_array = reply->info.stat.stat_array;
+ stat_count = reply->info.stat.stat_count;
+ file_count = stat_count;
+-
++
+ if(op->list_depth != 0)
+ {
+ /** Skip the first entry if we are including the directory itself in the listing */
+ int base_entry = 0;
+-
+- /** Correct for path which pointed to a single file */
++
++ /** Correct for path which pointed to a single file */
+ if(stat_count == 1 && op->current_path && op->current_path->subpath)
+ {
+ int plen = strlen(op->current_path->subpath);
+@@ -9050,12 +9050,12 @@ globus_l_gfs_data_list_stat_cb(
+ if(plen > nlen && strcmp(&op->current_path->subpath[plen-nlen], stat_array[0].name) == 0)
+ {
+ op->current_path->subpath[plen-nlen-1] = '\0';
+- }
++ }
+ }
+
+ if (stat_info->include_path_stat && stat_count > 0 && S_ISDIR(stat_array[0].mode))
+ {
+- if (op->current_path)
++ if (op->current_path)
+ {
+ stat_array[0].name[0] = '\0';
+ }
+@@ -9066,11 +9066,11 @@ globus_l_gfs_data_list_stat_cb(
+ }
+ ++base_entry;
+ }
+-
++
+ /** Move unwanted directory entries to the end and add them to the path */
+ for (i = base_entry; i < file_count;)
+ {
+- if (S_ISDIR(stat_array[i].mode) &&
++ if (S_ISDIR(stat_array[i].mode) &&
+ (stat_info->include_path_stat ||
+ (stat_array[i].name[0] == '.' &&
+ (stat_array[i].name[1] == '\0' || (stat_array[i].name[1] == '.' && stat_array[i].name[2] == '\0')))))
+@@ -9081,29 +9081,29 @@ globus_l_gfs_data_list_stat_cb(
+ memcpy(&stat_array[i], &stat_array[file_count-1], sizeof(globus_gfs_stat_t));
+ memcpy(&stat_array[file_count-1], &stat_temp, sizeof(globus_gfs_stat_t));
+ /** Decrement effective count */
+- --file_count;
++ --file_count;
+ }
+ else
+ {
+ ++i;
+- }
++ }
+ }
+-
++
+ dirlen = strlen(stat_info->pathname);
+- baselen = op->current_path ?
+- (strlen(op->current_path->pathname) - strlen(op->current_path->subpath)) :
++ baselen = op->current_path ?
++ (strlen(op->current_path->pathname) - strlen(op->current_path->subpath)) :
+ (dirlen + 1);
+-
++
+ /** Add directories, minus the current (.) and parent (..), to the list
+ * of paths to be explored. Paths should be added at the end of the list. */
+ for (i = base_entry; i < stat_count; ++i)
+ {
+ globus_l_gfs_data_path_list_t* newpath = NULL;
+-
++
+ /** If we are to follow symbolic links, create a new traversal path for each */
+- if ((op->traversal_options & GLOBUS_GFS_TRAVERSAL_FOLLOW_SYMLINKS) &&
++ if ((op->traversal_options & GLOBUS_GFS_TRAVERSAL_FOLLOW_SYMLINKS) &&
+ stat_array[i].symlink_target &&
+- stat_array[i].error != GLOBUS_GRIDFTP_SERVER_CONTROL_STAT_INVALIDLINK)
++ stat_array[i].error != GLOBUS_GRIDFTP_SERVER_CONTROL_STAT_INVALIDLINK)
+ {
+ newpath = (globus_l_gfs_data_path_list_t*)globus_malloc(sizeof(globus_l_gfs_data_path_list_t));
+ if (newpath)
+@@ -9114,19 +9114,19 @@ globus_l_gfs_data_list_stat_cb(
+ else
+ {
+ goto error;
+- }
+- }
++ }
++ }
+ /** Create new traversal paths for subdirectories (ignore . and ..) */
+ else if (S_ISDIR(stat_array[i].mode) &&
+- (stat_array[i].name[0] != '.' ||
++ (stat_array[i].name[0] != '.' ||
+ (stat_array[i].name[1] != '\0' && (stat_array[i].name[1] != '.' || stat_array[i].name[2] != '\0'))))
+ {
+ newpath = (globus_l_gfs_data_path_list_t*)globus_malloc(sizeof(globus_l_gfs_data_path_list_t));
+ if (newpath)
+ {
+- newpath->pathname = (char *)globus_malloc(dirlen + strlen(stat_array[i].name) + 2);
++ newpath->pathname = (char *)globus_malloc(dirlen + strlen(stat_array[i].name) + 2);
+ sprintf(newpath->pathname, "%s/%s", stat_info->pathname, stat_array[i].name);
+- newpath->subpath = &newpath->pathname[baselen];
++ newpath->subpath = &newpath->pathname[baselen];
+ }
+ else
+ {
+@@ -9134,20 +9134,20 @@ globus_l_gfs_data_list_stat_cb(
+ }
+ }
+
+- if (newpath)
++ if (newpath)
+ {
+ /*
+ * This section does cycle and duplicate path detection. We only need to do
+ * this when symbolic link traversal is on (shouldn't happen otherwise, unless
+ * someone's done something nasty with hard links).
+- *
++ *
+ * We check symbolic link targets against a set of "root paths", which are either
+- * the base root the MLSR was started with, or other link targets. If a root is
++ * the base root the MLSR was started with, or other link targets. If a root is
+ * entirely contained in a target, we'll already catch it, so no need to add it.
+- *
+- * If the target is entirely contained in a root, then we have a cycle, and we
+- * mark the path as such.
+- *
++ *
++ * If the target is entirely contained in a root, then we have a cycle, and we
++ * mark the path as such.
++ *
+ * When expanding directories, if the parent is marked as having a cycle, we
+ * check the subdirectory. If the subdirectory still has a cycle, it is marked
+ * as such--however, if it doesn't then we can avoid the cycle check for future
+@@ -9158,11 +9158,11 @@ globus_l_gfs_data_list_stat_cb(
+ */
+ if (op->traversal_options & GLOBUS_GFS_TRAVERSAL_FOLLOW_SYMLINKS)
+ {
+- globus_l_gfs_data_path_list_t* iter;
+- int newpathlen = strlen(newpath->pathname);
+-
++ globus_l_gfs_data_path_list_t* iter;
++ int newpathlen = strlen(newpath->pathname);
++
+ newpath->has_cycle = GLOBUS_FALSE;
+-
++
+ /** For symbolic links, validate the path--we don't want any duplicated paths */
+ if (stat_array[i].symlink_target)
+ {
+@@ -9181,7 +9181,7 @@ globus_l_gfs_data_list_stat_cb(
+ (iter->pathname[newpathlen] == '/' || iter->pathname[newpathlen] == '\0'))
+ {
+ /** This target has a cycle */
+- newpath->has_cycle = GLOBUS_TRUE;
++ newpath->has_cycle = GLOBUS_TRUE;
+ }
+ }
+ }
+@@ -9196,7 +9196,7 @@ globus_l_gfs_data_list_stat_cb(
+ globus_free(newpath->pathname);
+ globus_free(newpath);
+ newpath = NULL;
+- }
++ }
+ else if(strncmp(iter->pathname, newpath->pathname, newpathlen) == 0 &&
+ (iter->pathname[newpathlen] == '/' || iter->pathname[newpathlen] == '\0'))
+ {
+@@ -9205,19 +9205,19 @@ globus_l_gfs_data_list_stat_cb(
+ }
+ }
+ }
+-
++
+ /** Add the path to the traversal list */
+- if (newpath)
++ if (newpath)
+ {
+ if (stat_array[i].symlink_target)
+ {
+ globus_l_gfs_data_path_list_t** ppiter;
+-
++
+ /** Append symlink targets to the end of the traversal queue */
+- newpath->next = NULL;
++ newpath->next = NULL;
+ for (ppiter = &op->path_list; *ppiter; ppiter = &((*ppiter)->next)) ;
+- *ppiter = newpath;
+-
++ *ppiter = newpath;
++
+ /** Symbolic links to directories should be added to the root list. */
+ if (S_ISDIR(stat_array[i].link_mode))
+ {
+@@ -9228,37 +9228,37 @@ globus_l_gfs_data_list_stat_cb(
+ newroot->pathname = globus_libc_strdup(newpath->pathname);
+ newroot->subpath = NULL;
+ newroot->next = op->root_paths;
+- op->root_paths = newroot;
+- }
++ op->root_paths = newroot;
++ }
+ else
+ {
+ goto error;
+ }
+ }
+- }
+- else
++ }
++ else
+ {
+ /** Prepend directory expansion targets to the head of the queue */
+ newpath->next = op->path_list;
+ op->path_list = newpath;
+ }
+- }
++ }
+ }
+ }
+ }
+-
++
+ globus_mutex_lock(&op->stat_lock);
+ if(!op->begin_called)
+ {
+ op->begin_called = GLOBUS_TRUE;
+ globus_gridftp_server_begin_transfer(op, 0, NULL);
+ }
+-
++
+ list_buffer = NULL;
+ buffer_len = 0;
+-
+- if(file_count > 0)
+- {
++
++ if(file_count > 0)
++ {
+ result = globus_gridftp_server_control_list_buffer_alloc(
+ op->list_type,
+ op->uid,
+@@ -9273,7 +9273,7 @@ globus_l_gfs_data_list_stat_cb(
+ "globus_gridftp_server_control_list_buffer_alloc", result);
+ goto error;
+ }
+- }
++ }
+ else if(op->delayed_error != GLOBUS_SUCCESS || !globus_l_gfs_data_request_next_path(op))
+ {
+ list_buffer = (globus_byte_t *) globus_libc_strdup("\r");
+@@ -9289,12 +9289,12 @@ globus_l_gfs_data_list_stat_cb(
+ result = GlobusGFSErrorMemory("bounce_info");
+ goto error;
+ }
+-
++
+ if(reply->code != 100)
+ {
+ bounce_info->final_stat = GLOBUS_TRUE;
+ }
+-
++
+ result = globus_gridftp_server_register_write(
+ op,
+ list_buffer,
+@@ -9312,8 +9312,8 @@ globus_l_gfs_data_list_stat_cb(
+ goto error;
+ }
+ op->list_buffer_offset += buffer_len;
+- }
+-
++ }
++
+ globus_mutex_unlock(&op->stat_lock);
+
+ GlobusGFSDebugExit();
+@@ -9355,7 +9355,7 @@ globus_gridftp_server_finished_stat_custom_list(
+ result = GlobusGFSErrorMemory("bounce_info");
+ goto error;
+ }
+-
++
+ bounce_info->custom_list = GLOBUS_TRUE;
+ bounce_info->free_buffer = free_buffer;
+ if(free_buffer)
+@@ -9519,7 +9519,7 @@ globus_i_gfs_data_request_list(
+ stat_info->pathname = list_info->pathname;
+ stat_info->file_only = GLOBUS_FALSE;
+ stat_info->use_symlink_info = data_op->list_depth != 0;
+- stat_info->include_path_stat = data_op->list_depth != 0;
++ stat_info->include_path_stat = data_op->list_depth != 0;
+
+ data_op->info_struct = list_info;
+ data_op->stat_wrapper = stat_info;
+@@ -9536,7 +9536,7 @@ globus_i_gfs_data_request_list(
+
+ /**
+ *** Trim any trailing '/'
+- **/
++ **/
+ len = strlen(stat_info->pathname);
+ if(len > 0 && stat_info->pathname[len - 1] == '/')
+ {
+@@ -9801,7 +9801,7 @@ globus_l_gfs_data_begin_cb(
+ op->data_handle->info.tcp_bufsize = sndbuf;
+ }
+ }
+-
++
+ globus_gfs_log_message(
+ GLOBUS_GFS_LOG_INFO,
+ "Starting to transfer \"%s\".\n",
+@@ -9835,7 +9835,7 @@ globus_l_gfs_data_begin_cb(
+ event_reply.type = GLOBUS_GFS_EVENT_TRANSFER_CONNECTED;
+ event_reply.id = op->id;
+ event_reply.event_arg = op;
+-
++
+ if(op->event_callback != NULL)
+ {
+ op->event_callback(&event_reply, op->user_arg);
+@@ -9846,14 +9846,14 @@ globus_l_gfs_data_begin_cb(
+ event_reply.op_info->remote_ip = globus_libc_strdup(op->remote_ip);
+
+ globus_gfs_ipc_reply_event(op->ipc_handle, &event_reply);
+-
++
+ if(event_reply.op_info->remote_ip)
+ {
+ globus_free(event_reply.op_info->remote_ip);
+ }
+ globus_free(event_reply.op_info);
+ }
+-
++
+ if((!op->writing || op->retr_markers)
+ && (op->data_handle->info.mode == 'E' || op->markers))
+ {
+@@ -10041,7 +10041,7 @@ globus_l_gfs_data_end_transfer_kickout(
+ memset(&reply, '\0', sizeof(globus_gfs_finished_info_t));
+
+
+- if(op->cached_res == GLOBUS_SUCCESS &&
++ if(op->cached_res == GLOBUS_SUCCESS &&
+ op->writing && op->data_handle->http_handle)
+ {
+ globus_xio_data_descriptor_t descriptor;
+@@ -10054,12 +10054,12 @@ globus_l_gfs_data_end_transfer_kickout(
+ globus_hashtable_t header_table = NULL;
+ globus_bool_t eof = 0;
+
+-
++
+ globus_xio_handle_cntl(
+ handle,
+ op->session_handle->http_driver,
+ GLOBUS_XIO_HTTP_HANDLE_SET_END_OF_ENTITY);
+-
++
+ result = globus_xio_data_descriptor_init(&descriptor, handle);
+ globus_assert(result == GLOBUS_SUCCESS);
+
+@@ -10104,7 +10104,7 @@ globus_l_gfs_data_end_transfer_kickout(
+
+ body_buffer = malloc(buflen+1);
+ do
+- {
++ {
+ body_nbytes = 0;
+ result = globus_xio_read(
+ handle,
+@@ -10131,13 +10131,13 @@ globus_l_gfs_data_end_transfer_kickout(
+ else
+ {
+ waitfor = GLOBUS_MIN(1024, buflen-total_nbytes);
+- }
++ }
+ } while(!eof);
+-
++
+ body_buffer[total_nbytes] = '\0';
+ globus_i_gfs_data_http_print_response(
+ status_code, &header_table, body_buffer, &header_str);
+-
++
+ err_str = globus_common_create_string(
+ "HTTP PUT failed with \"%03d %s\"\n%s",
+ status_code,
+@@ -10145,7 +10145,7 @@ globus_l_gfs_data_end_transfer_kickout(
+ header_str);
+
+ result = GlobusGFSErrorGeneric(err_str);
+-
++
+ globus_free(err_str);
+ globus_free(header_str);
+ globus_free(body_buffer);
+@@ -10181,7 +10181,7 @@ globus_l_gfs_data_end_transfer_kickout(
+ eof = GLOBUS_TRUE;
+ }
+ total_nbytes += body_nbytes;
+-
++
+ if(body_nbytes == 0 || total_nbytes == buflen)
+ {
+ eof = GLOBUS_TRUE;
+@@ -10189,14 +10189,14 @@ globus_l_gfs_data_end_transfer_kickout(
+ else
+ {
+ waitfor = GLOBUS_MIN(1024, buflen-total_nbytes);
+- }
++ }
+ }
+ result = GLOBUS_SUCCESS;
+ globus_free(body_buffer);
+ globus_i_gfs_data_http_print_response(
+ status_code, &header_table, NULL, &op->data_handle->http_response_str);
+ }
+-
++
+ }
+ response_exit:
+ if(op->cached_res == GLOBUS_SUCCESS)
+@@ -10450,7 +10450,7 @@ response_exit:
+ {
+ globus_free(retransmit_str);
+ }
+-
++
+ /* XXX sc process bytes transferred count */
+ {
+ char * names[5] =
+@@ -10495,7 +10495,7 @@ response_exit:
+ reply.result = op->cached_res;
+
+ /* pull response code from error */
+- if(reply.result != GLOBUS_SUCCESS &&
++ if(reply.result != GLOBUS_SUCCESS &&
+ (reply.code = globus_gfs_error_get_ftp_response_code(
+ globus_error_peek(reply.result))) != 0)
+ {
+@@ -10506,9 +10506,9 @@ response_exit:
+ {
+ reply.code = op->user_code;
+
+- /* DO NETLOGGER STUFF
++ /* DO NETLOGGER STUFF
+ * XXX unless user has a message -- will only be a problem if a DSI
+- * is sending messages to the control channel, in which case they
++ * is sending messages to the control channel, in which case they
+ * just aren't compatible with the netlogger bottleneck reporting
+ */
+ if(op->user_msg == NULL)
+@@ -10533,7 +10533,7 @@ response_exit:
+ &reply);
+ }
+ globus_l_gfs_data_reset_watchdog(op->session_handle, NULL);
+-
++
+ /* remove the reference for this callback. It is possible that before
+ acquiring this lock the completing state occurred and we are
+ ready to finish */
+@@ -10688,7 +10688,7 @@ globus_l_gfs_data_end_read_kickout(
+ }
+
+ globus_mutex_lock(&op->session_handle->mutex);
+- {
++ {
+ switch(op->data_handle->state)
+ {
+ case GLOBUS_L_GFS_DATA_HANDLE_INUSE:
+@@ -10715,7 +10715,7 @@ globus_l_gfs_data_end_read_kickout(
+ default:
+ break;
+ }
+-
++
+ recv_info = op->info_struct;
+ object.name = recv_info->pathname;
+ object.size = op->bytes_transferred;
+@@ -10788,7 +10788,7 @@ void
+ globus_l_gfs_data_send_eof_cb(
+ void * callback_arg,
+ struct globus_ftp_control_handle_s * handle,
+- globus_object_t * error)
++ globus_object_t * error)
+ {
+ globus_l_gfs_data_operation_t * op;
+ GlobusGFSName(globus_l_gfs_data_send_eof_cb);
+@@ -11102,7 +11102,7 @@ globus_l_gfs_data_trev_kickout(
+ bounce_info->op->recvd_bytes = 0;
+ event_reply->type = GLOBUS_GFS_EVENT_BYTES_RECVD;
+ break;
+-
++
+ case GLOBUS_GFS_EVENT_RANGES_RECVD:
+ event_reply->type = GLOBUS_GFS_EVENT_RANGES_RECVD;
+ globus_range_list_copy(
+@@ -11111,7 +11111,7 @@ globus_l_gfs_data_trev_kickout(
+ globus_range_list_remove(
+ bounce_info->op->recvd_ranges, 0, GLOBUS_RANGE_LIST_MAX);
+ break;
+-
++
+ default:
+ globus_assert(0 && "invalid state, not possible");
+ break;
+@@ -11378,7 +11378,7 @@ globus_i_gfs_data_request_transfer_event(
+ GlobusGFSDebugEnter();
+
+ session_handle = (globus_l_gfs_data_session_t *) session_arg;
+- op = (globus_l_gfs_data_operation_t *)
++ op = (globus_l_gfs_data_operation_t *)
+ globus_handle_table_lookup(
+ &session_handle->handle_table, (intptr_t) event_info->event_arg);
+ if(op == NULL)
+@@ -11561,7 +11561,7 @@ globus_i_gfs_data_request_transfer_event(
+ globus_mutex_unlock(&op->session_handle->mutex);
+
+ /*
+- if(event_info->type == GLOBUS_GFS_EVENT_TRANSFER_COMPLETE &&
++ if(event_info->type == GLOBUS_GFS_EVENT_TRANSFER_COMPLETE &&
+ op->data_handle->state == GLOBUS_L_GFS_DATA_HANDLE_TE_VALID)
+ {
+ op->data_handle->state = GLOBUS_L_GFS_DATA_HANDLE_VALID;
+@@ -11603,7 +11603,7 @@ globus_i_gfs_data_session_start(
+ session_handle->del_cred = session_info->del_cred;
+ session_handle->context = context;
+ session_handle->dcsc_cred = GSS_C_NO_CREDENTIAL;
+- session_handle->order_data = session_handle->dsi->descriptor &
++ session_handle->order_data = session_handle->dsi->descriptor &
+ GLOBUS_GFS_DSI_DESCRIPTOR_REQUIRES_ORDERED_DATA;
+ result = globus_l_gfs_data_operation_init(&op, session_handle);
+ if(result != GLOBUS_SUCCESS)
+@@ -11619,7 +11619,7 @@ globus_i_gfs_data_session_start(
+ op->callback = cb;
+ op->user_arg = user_arg;
+ op->info_struct = session_info;
+-
++
+ result = globus_l_gfs_data_load_stack(
+ "default",
+ &op->session_handle->net_stack_list,
+@@ -11657,11 +11657,11 @@ globus_i_gfs_data_session_start(
+ if(globus_i_gfs_config_int("auth_level") & GLOBUS_L_GFS_AUTH_IDENTIFY)
+ {
+ globus_l_gfs_data_authorize(op, context, session_info);
+-
++
+ if(globus_i_gfs_config_bool("hybrid"))
+ {
+ globus_gfs_session_info_t * session_info_copy;
+-
++
+ session_info_copy = (globus_gfs_session_info_t *)
+ globus_malloc(sizeof(globus_gfs_session_info_t));
+ session_info_copy->del_cred = session_info->del_cred;
+@@ -11672,7 +11672,7 @@ globus_i_gfs_data_session_start(
+ session_info_copy->subject = globus_libc_strdup(session_info->subject);
+ session_info_copy->cookie = globus_libc_strdup(session_info->cookie);
+ session_info_copy->host_id = globus_libc_strdup(session_info->host_id);
+-
++
+ session_handle->session_info_copy = session_info_copy;
+ session_handle->hybrid = GLOBUS_TRUE;
+ }
+@@ -11694,7 +11694,7 @@ globus_i_gfs_data_session_start(
+ op->session_handle->gid_array);
+ }
+
+- op->session_handle->username =
++ op->session_handle->username =
+ globus_libc_strdup(session_info->username);
+
+ pwent = getpwuid(op->session_handle->uid);
+@@ -11706,30 +11706,30 @@ globus_i_gfs_data_session_start(
+ {
+ op->session_handle->true_home = globus_l_gfs_defaulthome();
+ }
+-
++
+ custom_home_dir = globus_i_gfs_config_string("home_dir");
+ if(custom_home_dir)
+ {
+ char * var_dir;
+-
++
+ var_dir = globus_l_gfs_data_update_var_path(
+ op->session_handle, custom_home_dir);
+-
++
+ op->session_handle->home_dir = var_dir;
+ }
+ else
+ {
+- op->session_handle->home_dir =
++ op->session_handle->home_dir =
+ globus_libc_strdup(op->session_handle->true_home);
+ }
+-
++
+ globus_l_gfs_data_update_restricted_paths(
+ op->session_handle, &globus_l_gfs_path_alias_list_base);
+ globus_l_gfs_data_update_restricted_paths(
+ op->session_handle, &globus_l_gfs_path_alias_list_sharing);
+ op->session_handle->active_rp_list = &globus_l_gfs_path_alias_list_base;
+-
+- if(!globus_i_gfs_config_bool("use_home_dirs") ||
++
++ if(!globus_i_gfs_config_bool("use_home_dirs") ||
+ op->session_handle->home_dir == NULL)
+ {
+ if(op->session_handle->home_dir)
+@@ -11737,12 +11737,12 @@ globus_i_gfs_data_session_start(
+ globus_free(op->session_handle->home_dir);
+ }
+ op->session_handle->home_dir = strdup("/");
+- }
++ }
+
+ if(globus_i_gfs_config_bool("hybrid"))
+ {
+ globus_gfs_session_info_t * session_info_copy;
+-
++
+ session_info_copy = (globus_gfs_session_info_t *)
+ globus_malloc(sizeof(globus_gfs_session_info_t));
+ session_info_copy->del_cred = session_info->del_cred;
+@@ -11753,18 +11753,18 @@ globus_i_gfs_data_session_start(
+ session_info_copy->subject = globus_libc_strdup(session_info->subject);
+ session_info_copy->cookie = globus_libc_strdup(session_info->cookie);
+ session_info_copy->host_id = globus_libc_strdup(session_info->host_id);
+-
++
+ session_handle->session_info_copy = session_info_copy;
+ session_handle->hybrid = GLOBUS_TRUE;
+ }
+-
++
+ globus_l_gfs_data_auth_init_cb(
+ NULL, GFS_ACL_ACTION_INIT, op, GLOBUS_SUCCESS);
+ }
+
+ GlobusGFSDebugExit();
+ }
+-
++
+ void
+ globus_i_gfs_data_session_stop(
+ globus_gfs_ipc_handle_t ipc_handle,
+@@ -11830,7 +11830,7 @@ globus_i_gfs_data_session_stop(
+ globus_gfs_log_message(
+ GLOBUS_GFS_LOG_INFO,
+ "Called main session_stop after %d ticks.\n", waitcnt - 1);
+- }
++ }
+ }
+
+ if(globus_l_gfs_watchdog_limit)
+@@ -11860,7 +11860,7 @@ globus_l_gfs_finished_command_kickout(
+
+ bounce = (globus_l_gfs_data_cmd_bounce_t *) user_arg;
+ op = bounce->op;
+-
++
+ if(op->callback != NULL)
+ {
+ op->callback(
+@@ -11873,7 +11873,7 @@ globus_l_gfs_finished_command_kickout(
+ op->ipc_handle,
+ &bounce->reply);
+ }
+-
++
+ if(bounce->reply.info.command.checksum)
+ {
+ globus_free(bounce->reply.info.command.checksum);
+@@ -11906,7 +11906,7 @@ globus_l_gfs_finished_command_kickout(
+ globus_assert(destroy_op);
+ globus_l_gfs_data_fire_cb(op, remote_data_arg, destroy_session);
+ globus_l_gfs_data_operation_destroy(op);
+-
++
+ globus_free(bounce);
+ }
+
+@@ -11969,7 +11969,7 @@ globus_gridftp_server_finished_command(
+ }
+ op->cached_res = result;
+
+- bounce = (globus_l_gfs_data_cmd_bounce_t *)
++ bounce = (globus_l_gfs_data_cmd_bounce_t *)
+ globus_calloc(1, sizeof(globus_l_gfs_data_cmd_bounce_t));
+
+ bounce->op = op;
+@@ -11980,7 +11980,7 @@ globus_gridftp_server_finished_command(
+ bounce->reply.info.command.checksum = globus_libc_strdup(op->cksm_response);
+
+ /* pull response code from error */
+- if(result != GLOBUS_SUCCESS &&
++ if(result != GLOBUS_SUCCESS &&
+ (code = globus_gfs_error_get_ftp_response_code(
+ globus_error_peek(result))) != 0)
+ {
+@@ -12003,7 +12003,7 @@ globus_gridftp_server_finished_command(
+ bounce->reply.info.command.created_dir = globus_libc_strdup(op->pathname);
+ }
+ }
+-
++
+ result = globus_callback_register_oneshot(
+ NULL,
+ NULL,
+@@ -12038,9 +12038,9 @@ globus_gridftp_server_finished_stat_partial(
+
+ globus_mutex_lock(&op->stat_lock);
+ if(result == GLOBUS_SUCCESS)
+- {
++ {
+ stat_info = (globus_gfs_stat_info_t *) op->info_struct;
+-
++
+ stat_copy = (globus_gfs_stat_t *)
+ globus_malloc(sizeof(globus_gfs_stat_t) * stat_count);
+ if(stat_copy == NULL)
+@@ -12048,9 +12048,9 @@ globus_gridftp_server_finished_stat_partial(
+ result = GlobusGFSErrorMemory("stat_copy");
+ }
+ }
+-
++
+ if(result == GLOBUS_SUCCESS)
+- {
++ {
+ base_path = stat_info->pathname;
+ /* if we have explicit access on the base path, no need to prune */
+ if(stat_info->file_only || globus_i_gfs_data_check_path(op->session_handle,
+@@ -12082,7 +12082,7 @@ globus_gridftp_server_finished_stat_partial(
+ char * nam;
+ char * full_path;
+ char * slash;
+-
++
+ if(base_path[strlen(base_path) - 1] != '/')
+ {
+ slash = "/";
+@@ -12096,21 +12096,21 @@ globus_gridftp_server_finished_stat_partial(
+ nam = stat_array[i].name;
+ full_path = globus_common_create_string(
+ "%s%s%s", base_path, slash, nam);
+- if(nam && ((nam[0] == '.' &&
++ if(nam && ((nam[0] == '.' &&
+ (nam[1] == '\0' || (nam[1] == '.' && nam[2] == '\0'))) ||
+ (globus_i_gfs_data_check_path(op->session_handle,
+ full_path, NULL, GFS_L_LIST, 0) == GLOBUS_SUCCESS)))
+ {
+ memcpy(
+- &stat_copy[pruned_stat_count],
++ &stat_copy[pruned_stat_count],
+ &stat_array[i],
+ sizeof(globus_gfs_stat_t));
+-
+- stat_copy[pruned_stat_count].name =
++
++ stat_copy[pruned_stat_count].name =
+ globus_libc_strdup(stat_array[i].name);
+ stat_copy[pruned_stat_count].symlink_target =
+ globus_libc_strdup(stat_array[i].symlink_target);
+-
++
+ pruned_stat_count++;
+ }
+ globus_free(full_path);
+@@ -12121,7 +12121,7 @@ globus_gridftp_server_finished_stat_partial(
+ stat_copy[0].nlink = pruned_stat_count;
+ }
+ }
+-
++
+ }
+ else
+ {
+@@ -12143,7 +12143,7 @@ globus_gridftp_server_finished_stat_partial(
+ bounce_info->stat_count = stat_count;
+ bounce_info->stat_array = stat_copy;
+ bounce_info->final_stat = GLOBUS_FALSE;
+-
++
+ result = globus_callback_register_oneshot(
+ GLOBUS_NULL,
+ GLOBUS_NULL,
+@@ -12158,7 +12158,7 @@ globus_gridftp_server_finished_stat_partial(
+ globus_mutex_unlock(&op->stat_lock);
+
+ globus_poll();
+-
++
+ GlobusGFSDebugExit();
+ return;
+
+@@ -12185,7 +12185,7 @@ globus_gridftp_server_intermediate_command(
+
+ globus_l_gfs_data_alive(op->session_handle);
+
+- bounce = (globus_l_gfs_data_cmd_bounce_t *)
++ bounce = (globus_l_gfs_data_cmd_bounce_t *)
+ globus_calloc(1, sizeof(globus_l_gfs_data_cmd_bounce_t));
+
+ switch(op->command)
+@@ -12194,7 +12194,7 @@ globus_gridftp_server_intermediate_command(
+ bounce->reply.info.command.checksum = globus_libc_strdup(command_data);
+ bounce->reply.code = 113;
+ break;
+-
++
+ case GLOBUS_GFS_CMD_HTTP_PUT:
+ case GLOBUS_GFS_CMD_HTTP_GET:
+ bounce->reply.info.command.checksum = globus_libc_strdup(command_data);
+@@ -12248,7 +12248,7 @@ globus_gridftp_server_finished_stat(
+ GlobusGFSDebugEnter();
+
+ globus_l_gfs_data_alive(op->session_handle);
+-
++
+ globus_mutex_lock(&op->stat_lock);
+ if(stat_array != NULL && stat_count > 0)
+ {
+@@ -12261,7 +12261,7 @@ globus_gridftp_server_finished_stat(
+ result = GlobusGFSErrorMemory("stat_copy");
+ goto error_alloc;
+ }
+-
++
+ base_path = stat_info->pathname;
+ /* if we have explicit access on the base path, no need to prune */
+ if(stat_info->file_only || globus_i_gfs_data_check_path(op->session_handle,
+@@ -12293,7 +12293,7 @@ globus_gridftp_server_finished_stat(
+ char * nam;
+ char * full_path;
+ char * slash;
+-
++
+ if(base_path[strlen(base_path) - 1] != '/')
+ {
+ slash = "/";
+@@ -12307,21 +12307,21 @@ globus_gridftp_server_finished_stat(
+ nam = stat_array[i].name;
+ full_path = globus_common_create_string(
+ "%s%s%s", base_path, slash, nam);
+- if(nam && ((nam[0] == '.' &&
++ if(nam && ((nam[0] == '.' &&
+ (nam[1] == '\0' || (nam[1] == '.' && nam[2] == '\0'))) ||
+ (globus_i_gfs_data_check_path(op->session_handle,
+ full_path, NULL, GFS_L_LIST, 0) == GLOBUS_SUCCESS)))
+ {
+ memcpy(
+- &stat_copy[pruned_stat_count],
++ &stat_copy[pruned_stat_count],
+ &stat_array[i],
+ sizeof(globus_gfs_stat_t));
+-
+- stat_copy[pruned_stat_count].name =
++
++ stat_copy[pruned_stat_count].name =
+ globus_libc_strdup(stat_array[i].name);
+ stat_copy[pruned_stat_count].symlink_target =
+ globus_libc_strdup(stat_array[i].symlink_target);
+-
++
+ pruned_stat_count++;
+ }
+ globus_free(full_path);
+@@ -12332,7 +12332,7 @@ globus_gridftp_server_finished_stat(
+ stat_copy[0].nlink = pruned_stat_count;
+ }
+ }
+-
++
+ }
+ else
+ {
+@@ -12354,7 +12354,7 @@ globus_gridftp_server_finished_stat(
+ bounce_info->stat_count = stat_count;
+ bounce_info->stat_array = stat_copy;
+ bounce_info->final_stat = GLOBUS_TRUE;
+-
++
+ result = globus_callback_register_oneshot(
+ GLOBUS_NULL,
+ GLOBUS_NULL,
+@@ -12477,7 +12477,7 @@ globus_gridftp_server_begin_transfer(
+ {
+ GlobusGFSDebugInfo(
+ "globus_ftp_control_data_connect_read");
+-
++
+ if(op->order_data && op->data_handle->info.mode == 'E')
+ {
+ result = globus_ftp_control_set_force_order(
+@@ -12748,7 +12748,7 @@ globus_l_gfs_operation_finished_kickout(
+ if(bounce->finished_info->type == GLOBUS_GFS_OP_SESSION_START)
+ {
+ /* update home dir based on restricted paths */
+-
++
+ /* reset home dir to / if chroot. */
+ if(op->session_handle->chroot_path)
+ {
+@@ -12775,7 +12775,7 @@ globus_l_gfs_operation_finished_kickout(
+ globus_free(op->session_handle->home_dir);
+ }
+ op->session_handle->home_dir = strdup("/");
+-
++
+ bounce->finished_info->info.session.home_dir =
+ op->session_handle->home_dir;
+ }
+@@ -12861,9 +12861,9 @@ globus_gridftp_server_operation_finished(
+ break;
+ case GLOBUS_GFS_OP_STAT:
+ globus_gridftp_server_finished_stat_partial(
+- op,
+- result,
+- finished_info->info.stat.stat_array,
++ op,
++ result,
++ finished_info->info.stat.stat_array,
+ finished_info->info.stat.stat_count);
+ return;
+ default:
+@@ -12881,13 +12881,13 @@ globus_gridftp_server_operation_finished(
+
+ finished_info->id = op->id;
+ finished_info->result = result;
+-
++
+ if(finished_info->msg != NULL)
+ {
+ op->user_msg = globus_libc_strdup(finished_info->msg);
+ }
+ op->user_code = finished_info->code;
+-
++
+ switch(finished_info->type)
+ {
+ case GLOBUS_GFS_OP_RECV:
+@@ -12925,23 +12925,23 @@ globus_gridftp_server_operation_finished(
+ {
+ globus_free(op->session_handle->home_dir);
+ }
+- op->session_handle->home_dir =
++ op->session_handle->home_dir =
+ strdup(finished_info->info.session.home_dir);
+ }
+-
++
+ if(globus_hashtable_empty(&op->session_handle->custom_cmd_table))
+ {
+ finished_info->op_info = NULL;
+ }
+- if(op->callback != NULL &&
++ if(op->callback != NULL &&
+ !globus_hashtable_empty(
+ &op->session_handle->custom_cmd_table))
+ {
+ finished_info->op_info = globus_calloc(1, sizeof(globus_i_gfs_op_info_t));
+- finished_info->op_info->custom_command_table =
++ finished_info->op_info->custom_command_table =
+ op->session_handle->custom_cmd_table;
+ }
+-
++
+ break;
+
+ case GLOBUS_GFS_OP_PASSIVE:
+@@ -13071,7 +13071,7 @@ globus_gridftp_server_update_bytes_recvd(
+ globus_mutex_lock(&op->session_handle->mutex);
+ {
+ op->recvd_bytes += length;
+-
++
+ if(op->data_handle->http_handle)
+ {
+ op->data_handle->http_transferred += length;
+@@ -13119,7 +13119,7 @@ globus_gridftp_server_update_bytes_written(
+ op->recvd_bytes += length;
+ globus_range_list_insert(
+ op->recvd_ranges, offset + op->transfer_delta, length);
+-
++
+ if(op->data_handle->http_handle)
+ {
+ op->data_handle->http_transferred += length;
+@@ -13144,9 +13144,9 @@ globus_gridftp_server_get_optimal_concurrency(
+ return;
+ }
+ if(!op->writing)
+- {
++ {
+ globus_mutex_lock(&op->session_handle->mutex);
+- if(op->data_handle->state == GLOBUS_L_GFS_DATA_HANDLE_INUSE &&
++ if(op->data_handle->state == GLOBUS_L_GFS_DATA_HANDLE_INUSE &&
+ op->data_handle->is_mine)
+ {
+ unsigned int num_streams;
+@@ -13353,7 +13353,7 @@ globus_gridftp_server_query_op_info(
+ {
+ globus_result_t res = GLOBUS_SUCCESS;
+ va_list ap;
+-
++
+ char *** argv;
+ int * argc;
+ GlobusGFSName(globus_gridftp_server_query_op_info);
+@@ -13374,16 +13374,16 @@ globus_gridftp_server_query_op_info(
+ case GLOBUS_GFS_OP_INFO_CMD_ARGS:
+ argv = va_arg(ap, char ***);
+ argc = va_arg(ap, int *);
+-
++
+ *argv = op_info->argv;
+ *argc = op_info->argc;
+ break;
+-
++
+ default:
+ res = GlobusGFSErrorGeneric("Invalid query parameter.");
+ break;
+ }
+-
++
+ va_end(ap);
+
+ if(res != GLOBUS_SUCCESS)
+@@ -13397,7 +13397,7 @@ globus_gridftp_server_query_op_info(
+ err:
+ GlobusGFSDebugExitWithError();
+ return res;
+-}
++}
+
+ globus_result_t
+ globus_gridftp_server_set_checksum_support(
+@@ -13441,7 +13441,7 @@ globus_gridftp_server_add_command(
+ result = GlobusGFSErrorGeneric("Invalid cmd_id.");;
+ goto err;
+ }
+-
++
+ if(op->session_handle->custom_cmd_table == NULL)
+ {
+ globus_hashtable_init(
+@@ -13450,10 +13450,10 @@ globus_gridftp_server_add_command(
+ globus_hashtable_string_hash,
+ globus_hashtable_string_keyeq);
+ }
+-
++
+ cmd_ent = (globus_i_gfs_cmd_ent_t *)
+ globus_calloc(1, sizeof(globus_i_gfs_cmd_ent_t));
+-
++
+ cmd_ent->cmd_name = globus_libc_strdup(command_name);
+ ptr = cmd_ent->cmd_name;
+ while(ptr && *ptr)
+@@ -13467,7 +13467,7 @@ globus_gridftp_server_add_command(
+ cmd_ent->help_str = globus_libc_strdup(help_string);
+ cmd_ent->has_pathname = has_pathname;
+ cmd_ent->access_type = access_type;
+-
++
+ rc = globus_hashtable_insert(
+ &op->session_handle->custom_cmd_table, cmd_ent->cmd_name, cmd_ent);
+
+@@ -13476,15 +13476,15 @@ globus_gridftp_server_add_command(
+ result = GlobusGFSErrorGeneric("Could not store command entry.");
+ goto err;
+ }
+-
+- GlobusGFSDebugExit();
++
++ GlobusGFSDebugExit();
+ return GLOBUS_SUCCESS;
+-
++
+ err:
+- GlobusGFSDebugExitWithError();
++ GlobusGFSDebugExitWithError();
+ return result;
+ }
+-
++
+
+ /* this is used to translate the restart and partial offset/lengths into
+ a sets of ranges to transfer... storage interface shouldn't know about
+@@ -13561,9 +13561,9 @@ globus_gridftp_server_get_read_range(
+ globus_off_t part_size;
+ GlobusGFSName(globus_gridftp_server_get_read_range);
+ GlobusGFSDebugEnter();
+-
++
+ globus_l_gfs_data_alive(op->session_handle);
+-
++
+ /* this whole function is crazy ugly and inneffiecient...
+ needs rethinking */
+ globus_mutex_lock(&op->session_handle->mutex);
+@@ -13733,7 +13733,7 @@ globus_result_t
+ globus_gridftp_server_get_recv_modification_time(
+ globus_gfs_operation_t op,
+ time_t * out_time)
+-{
++{
+ globus_result_t result;
+ time_t tmp_time = -1;
+ GlobusGFSName(globus_gridftp_server_get_recv_modification_time);
+@@ -13744,13 +13744,13 @@ globus_gridftp_server_get_recv_modification_time(
+ result = GlobusGFSErrorGeneric("Invalid parameters.");
+ goto error;
+ }
+-
++
+ if(op->storattr && op->storattr->modify)
+ {
+ char* tz;
+ struct tm modtime;
+ memset(&modtime, 0, sizeof(modtime));
+- if (sscanf(op->storattr->modify, "%4d%2d%2d%2d%2d%2d",
++ if (sscanf(op->storattr->modify, "%4d%2d%2d%2d%2d%2d",
+ &modtime.tm_year, &modtime.tm_mon, &modtime.tm_mday,
+ &modtime.tm_hour, &modtime.tm_min, &modtime.tm_sec) != 6)
+ {
+@@ -13771,11 +13771,11 @@ globus_gridftp_server_get_recv_modification_time(
+ else
+ globus_libc_unsetenv("TZ");
+ tzset();
+-
++
+ op->storattr->modify_seen = GLOBUS_TRUE;
+ }
+ *out_time = tmp_time;
+-
++
+ GlobusGFSDebugExit();
+ return GLOBUS_SUCCESS;
+
+@@ -13784,8 +13784,8 @@ error:
+ *out_time = -1;
+ return result;
+ }
+-
+-
++
++
+
+ globus_result_t
+ globus_gridftp_server_get_recv_attr_string(
+@@ -13804,7 +13804,7 @@ globus_gridftp_server_get_recv_attr_string(
+ result = GlobusGFSErrorGeneric("Invalid parameters.");
+ goto error;
+ }
+-
++
+ if(op->storattr)
+ {
+ if(requested_attr)
+@@ -13838,7 +13838,7 @@ globus_gridftp_server_get_recv_attr_string(
+ }
+ }
+ *out_value = tmp_val;
+-
++
+ GlobusGFSDebugExit();
+ return GLOBUS_SUCCESS;
+
+@@ -13846,7 +13846,7 @@ error:
+ GlobusGFSDebugExitWithError();
+ return result;
+ }
+-
++
+
+ globus_result_t
+ globus_gridftp_server_register_read(
+@@ -14046,7 +14046,7 @@ globus_gridftp_server_finished_session_start(
+ finished_info.info.session.home_dir = home_dir;
+
+ /* pull response code from error */
+- if(result != GLOBUS_SUCCESS &&
++ if(result != GLOBUS_SUCCESS &&
+ (code = globus_gfs_error_get_ftp_response_code(
+ globus_error_peek(result))) != 0)
+ {
+@@ -14084,7 +14084,7 @@ globus_gridftp_server_finished_active_data(
+ finished_info.info.data.bi_directional = bi_directional;
+
+ /* pull response code from error */
+- if(result != GLOBUS_SUCCESS &&
++ if(result != GLOBUS_SUCCESS &&
+ (code = globus_gfs_error_get_ftp_response_code(
+ globus_error_peek(result))) != 0)
+ {
+@@ -14126,7 +14126,7 @@ globus_gridftp_server_finished_passive_data(
+ finished_info.info.data.cs_count = cs_count;
+
+ /* pull response code from error */
+- if(result != GLOBUS_SUCCESS &&
++ if(result != GLOBUS_SUCCESS &&
+ (code = globus_gfs_error_get_ftp_response_code(
+ globus_error_peek(result))) != 0)
+ {
+@@ -14155,7 +14155,7 @@ globus_i_gfs_data_request_set_cred(
+
+ session_handle = (globus_l_gfs_data_session_t *) session_arg;
+ globus_l_gfs_data_reset_watchdog(session_handle, NULL);
+-
++
+ if(del_cred != NULL)
+ {
+ session_handle->del_cred = del_cred;
+@@ -14186,7 +14186,7 @@ globus_i_gfs_data_request_buffer_send(
+
+ session_handle = (globus_l_gfs_data_session_t *) session_arg;
+ globus_l_gfs_data_reset_watchdog(session_handle, NULL);
+-
++
+ if(buffer_type & GLOBUS_GFS_BUFFER_SERVER_DEFINED)
+ {
+ switch(buffer_type)
+@@ -14215,11 +14215,11 @@ globus_i_gfs_data_request_buffer_send(
+
+ void
+ globus_i_gfs_data_http_read_cb(
+- globus_xio_handle_t xio_handle,
++ globus_xio_handle_t xio_handle,
+ globus_result_t result,
+ globus_byte_t * buffer,
+ globus_size_t length,
+- globus_size_t nbytes,
++ globus_size_t nbytes,
+ globus_xio_data_descriptor_t data_desc,
+ void * user_arg)
+ {
+@@ -14232,11 +14232,11 @@ globus_i_gfs_data_http_read_cb(
+
+ offset = bounce_info->op->bytes_transferred;
+ bounce_info->op->bytes_transferred += nbytes;
+-
++
+ eof = globus_xio_error_is_eof(result);
+ if(eof)
+- {
+- if(bounce_info->op->bytes_transferred <
++ {
++ if(bounce_info->op->bytes_transferred <
+ bounce_info->op->data_handle->http_length)
+ {
+ result = GlobusGFSErrorGeneric(
+@@ -14247,7 +14247,7 @@ globus_i_gfs_data_http_read_cb(
+ result = GLOBUS_SUCCESS;
+ }
+ }
+- if(bounce_info->op->bytes_transferred >
++ if(bounce_info->op->bytes_transferred >
+ bounce_info->op->data_handle->http_length)
+ {
+ result = GlobusGFSErrorGeneric(
+@@ -14271,11 +14271,11 @@ globus_i_gfs_data_http_read_cb(
+
+ void
+ globus_i_gfs_data_http_write_cb(
+- globus_xio_handle_t xio_handle,
++ globus_xio_handle_t xio_handle,
+ globus_result_t result,
+ globus_byte_t * buffer,
+ globus_size_t length,
+- globus_size_t nbytes,
++ globus_size_t nbytes,
+ globus_xio_data_descriptor_t data_desc,
+ void * user_arg)
+ {
+@@ -14316,9 +14316,9 @@ globus_l_gfs_data_http_perf(
+ void * arg)
+ {
+ globus_l_gfs_data_operation_t * op;
+-
++
+ op = (globus_l_gfs_data_operation_t *) arg;
+-
++
+ if(op->data_handle)
+ {
+ globus_gfs_event_info_t event_reply;
+@@ -14350,14 +14350,14 @@ globus_l_gfs_data_http_transfer_cb(
+ globus_mutex_unlock(&op->session_handle->mutex);
+ globus_assert(!destroy_op);
+ }
+-
++
+ if(op->data_handle->perf_handle != GLOBUS_NULL_HANDLE)
+ {
+ globus_callback_unregister(
+ op->data_handle->perf_handle, NULL, NULL, NULL);
+ op->data_handle->perf_handle = GLOBUS_NULL_HANDLE;
+ }
+-
++
+ globus_xio_close(op->data_handle->http_handle, NULL);
+ globus_libc_unsetenv("GLOBUS_GFS_EXTRA_CA_CERTS");
+
+@@ -14369,7 +14369,7 @@ globus_l_gfs_data_http_transfer_cb(
+ {
+ char * count;
+ globus_mutex_lock(&op->session_handle->mutex);
+- {
++ {
+ count = globus_common_create_string("%"GLOBUS_OFF_T_FORMAT,
+ op->data_handle->http_transferred);
+ op->data_handle->http_transferred = 0;
+@@ -14393,7 +14393,7 @@ globus_l_gfs_data_http_event_cb(
+ globus_result_t result = GLOBUS_SUCCESS;
+ char * count;
+ globus_l_gfs_data_operation_t * op;
+-
++
+ GlobusGFSName(globus_l_gfs_data_http_event_cb);
+ GlobusGFSDebugEnter();
+
+@@ -14403,7 +14403,7 @@ globus_l_gfs_data_http_event_cb(
+ {
+ case GLOBUS_GFS_EVENT_TRANSFER_BEGIN:
+ globus_gridftp_server_intermediate_command(op, result, "0");
+-
++
+ if(op->data_handle->perf_handle == GLOBUS_NULL_HANDLE)
+ {
+ globus_reltime_t timer;
+@@ -14416,16 +14416,16 @@ globus_l_gfs_data_http_event_cb(
+ (void *) op);
+ }
+ break;
+-
++
+ case GLOBUS_GFS_EVENT_TRANSFER_CONNECTED:
+ break;
+-
++
+ case GLOBUS_GFS_EVENT_DISCONNECTED:
+ break;
+-
++
+ case GLOBUS_GFS_EVENT_BYTES_RECVD:
+ globus_mutex_lock(&op->session_handle->mutex);
+- {
++ {
+ count = globus_common_create_string("%"GLOBUS_OFF_T_FORMAT,
+ op->data_handle->http_transferred);
+ }
+@@ -14435,10 +14435,10 @@ globus_l_gfs_data_http_event_cb(
+ globus_free(count);
+
+ break;
+-
++
+ case GLOBUS_GFS_EVENT_RANGES_RECVD:
+ break;
+-
++
+ default:
+ globus_assert(0 && "Unexpected event type");
+ break;
+@@ -14466,7 +14466,7 @@ globus_i_gfs_data_http_parse_args(
+ int tmp_consume;
+ GlobusGFSName(globus_i_gfs_data_http_parse_args);
+ GlobusGFSDebugEnter();
+-
++
+ if((tmp_val = globus_i_gfs_kv_getval(argstring, "OFFSET", 0)) == NULL)
+ {
+ result = GlobusGFSErrorGeneric(
+@@ -14480,7 +14480,7 @@ globus_i_gfs_data_http_parse_args(
+ "Invalid arguments: Invalid OFFSET.");
+ goto err;
+ }
+-
++
+ if((tmp_val = globus_i_gfs_kv_getval(argstring, "LENGTH", 0)) == NULL)
+ {
+ result = GlobusGFSErrorGeneric(
+@@ -14515,7 +14515,7 @@ globus_i_gfs_data_http_parse_args(
+ *length = tmp_len;
+ *request = tmp_req;
+ *path = tmp_path;
+-
++
+ GlobusGFSDebugExit();
+ return GLOBUS_SUCCESS;
+
+@@ -14553,7 +14553,7 @@ globus_i_gfs_data_http_init(
+ globus_l_gfs_data_session_t * session_handle,
+ globus_bool_t https,
+ globus_xio_handle_t * handle,
+- globus_xio_attr_t * attr,
++ globus_xio_attr_t * attr,
+ globus_xio_data_descriptor_t * descriptor)
+ {
+ globus_result_t result;
+@@ -14583,7 +14583,7 @@ globus_i_gfs_data_http_init(
+ if(!session_handle->http_stack)
+ {
+ globus_xio_stack_init(&session_handle->http_stack, NULL);
+-
++
+ result = globus_xio_stack_push_driver(
+ session_handle->http_stack,
+ gfs_l_tcp_driver);
+@@ -14600,7 +14600,7 @@ globus_i_gfs_data_http_init(
+ if(!session_handle->https_stack)
+ {
+ globus_xio_stack_init(&session_handle->https_stack, NULL);
+-
++
+ result = globus_xio_stack_push_driver(
+ session_handle->https_stack,
+ gfs_l_tcp_driver);
+@@ -14630,7 +14630,7 @@ globus_i_gfs_data_http_init(
+ result = globus_xio_handle_create(
+ handle, session_handle->http_stack);
+ }
+-
++
+ globus_assert(result == GLOBUS_SUCCESS);
+ }
+ if(attr)
+@@ -14646,25 +14646,25 @@ globus_i_gfs_data_http_init(
+ if(https)
+ {
+ result = globus_xio_attr_cntl(
+- *attr,
+- gfs_l_gsi_driver,
++ *attr,
++ gfs_l_gsi_driver,
+ GLOBUS_XIO_GSI_SET_SSL_COMPATIBLE,
+ GLOBUS_TRUE);
+ globus_assert(result == GLOBUS_SUCCESS);
+ result = globus_xio_attr_cntl(
+- *attr,
+- gfs_l_gsi_driver,
++ *attr,
++ gfs_l_gsi_driver,
+ GLOBUS_XIO_GSI_SET_PROTECTION_LEVEL,
+ GLOBUS_XIO_GSI_PROTECTION_LEVEL_PRIVACY);
+ globus_assert(result == GLOBUS_SUCCESS);
+ result = globus_xio_attr_cntl(
+- *attr,
+- gfs_l_gsi_driver,
++ *attr,
++ gfs_l_gsi_driver,
+ GLOBUS_XIO_GSI_SET_ANON);
+ globus_assert(result == GLOBUS_SUCCESS);
+ result = globus_xio_attr_cntl(
+- *attr,
+- gfs_l_gsi_driver,
++ *attr,
++ gfs_l_gsi_driver,
+ GLOBUS_XIO_GSI_SET_ALLOW_MISSING_SIGNING_POLICY,
+ GLOBUS_TRUE);
+ globus_assert(result == GLOBUS_SUCCESS);
+@@ -14674,7 +14674,7 @@ globus_i_gfs_data_http_init(
+ }
+ else if(session_handle->http_ca_certs)
+ {
+- globus_libc_setenv("GLOBUS_GFS_EXTRA_CA_CERTS",
++ globus_libc_setenv("GLOBUS_GFS_EXTRA_CA_CERTS",
+ session_handle->http_ca_certs, 1);
+ }
+ }
+@@ -14682,7 +14682,7 @@ globus_i_gfs_data_http_init(
+
+ result = globus_xio_data_descriptor_init(descriptor, *handle);
+ globus_assert(result == GLOBUS_SUCCESS);
+-
++
+ GlobusGFSDebugExit();
+ return GLOBUS_SUCCESS;
+ }
+@@ -14695,7 +14695,7 @@ globus_i_gfs_http_data_parse_request(
+ globus_bool_t * https,
+ int * http_ver,
+ char ** method,
+- globus_xio_http_header_t ** headers,
++ globus_xio_http_header_t ** headers,
+ int * count)
+ {
+ globus_result_t res;
+@@ -14725,11 +14725,11 @@ globus_i_gfs_http_data_parse_request(
+ res = GlobusGFSErrorGeneric("Could not decode.");
+ goto err;
+ }
+-
++
+ res = -1;
+-
+- /*
+- parse from
++
++ /*
++ parse from
+ VERB {http|https}://hostname[:port]/url-encoded-path[?qs] HTTP/1.1\r\n
+ */
+ line = d_req;
+@@ -14746,7 +14746,7 @@ globus_i_gfs_http_data_parse_request(
+ goto err;
+ }
+ *ptr++ = 0;
+- tmp_method = strdup(line);
++ tmp_method = strdup(line);
+ tmp_url = strdup(ptr);
+ ptr = strchr(tmp_url, ' ');
+ if(!ptr)
+@@ -14759,7 +14759,7 @@ globus_i_gfs_http_data_parse_request(
+ {
+ tmp_ver = GLOBUS_XIO_HTTP_VERSION_1_1;
+ }
+-
++
+ tmp_headers = globus_malloc(cnt * sizeof(globus_xio_http_header_t));
+ /* parse headers
+ Header-1: foo \r\n
+@@ -14781,7 +14781,7 @@ globus_i_gfs_http_data_parse_request(
+ *ptr = 0;
+ next_line = ptr + 2;
+ }
+-
++
+ ptr = strchr(line, ':');
+ if(!ptr)
+ {
+@@ -14793,19 +14793,19 @@ globus_i_gfs_http_data_parse_request(
+ ptr++;
+ tmp_hname = strdup(line);
+ tmp_hval = strdup(ptr);
+-
++
+ if(i >= cnt)
+ {
+ cnt += 20;
+ tmp_headers = globus_realloc(
+ tmp_headers, cnt * sizeof(globus_xio_http_header_t));
+ }
+-
++
+ tmp_headers[i].name = tmp_hname;
+ tmp_headers[i].value = tmp_hval;
+ i++;
+-
+-
++
++
+ line = next_line;
+ }
+
+@@ -14817,7 +14817,7 @@ globus_i_gfs_http_data_parse_request(
+ {
+ *https = GLOBUS_FALSE;
+ }
+-
++
+ /* find third / in scheme://host/ to get path */
+ ptr = strchr(tmp_url, '/');
+ if(!ptr)
+@@ -14839,7 +14839,7 @@ globus_i_gfs_http_data_parse_request(
+ res = GlobusGFSErrorGeneric("Invalid URI.");
+ goto err;
+ }
+-
++
+ /* urlencode path in because xio will decode it */
+ enc_path = globus_url_string_hex_encode(ptr, "<>:@");
+ *ptr = 0;
+@@ -14850,20 +14850,20 @@ globus_i_gfs_http_data_parse_request(
+ *count = i;
+ *method = tmp_method;
+ *http_ver = tmp_ver;
+-
++
+ globus_free(tmp_url);
+ globus_free(d_req);
+
+ GlobusGFSDebugExit();
+-
++
+ return GLOBUS_SUCCESS;
+ err:
+ GlobusGFSDebugExitWithError();
+- return res;
++ return res;
+ }
+
+
+-globus_result_t
++globus_result_t
+ globus_i_gfs_data_http_get(
+ globus_l_gfs_data_operation_t * op,
+ char * path,
+@@ -14896,7 +14896,7 @@ globus_i_gfs_data_http_get(
+ char * ptr;
+ GlobusGFSName(globus_l_gfs_data_http_get);
+ GlobusGFSDebugEnter();
+-
++
+ /* parse url, headers */
+ result = globus_i_gfs_http_data_parse_request(
+ request, &url, &https, &http_ver, &method, &headers, &count);
+@@ -14905,7 +14905,7 @@ globus_i_gfs_data_http_get(
+ result = GlobusGFSErrorWrapFailed("Invalid request. Parsing", result);
+ goto response_exit;
+ }
+-
++
+ handle = op->session_handle->http_handle;
+ result = globus_i_gfs_data_http_init(op->session_handle,
+ https, &handle, &attr, &descriptor);
+@@ -14913,7 +14913,7 @@ globus_i_gfs_data_http_get(
+ {
+ goto response_exit;
+ }
+-
++
+ result = globus_xio_attr_cntl(
+ attr,
+ op->session_handle->http_driver,
+@@ -14933,8 +14933,8 @@ globus_i_gfs_data_http_get(
+ {
+ goto response_exit;
+ }
+-
+- /* set individual headers */
++
++ /* set individual headers */
+ for (i = 0; i < count; i++)
+ {
+ result = globus_xio_attr_cntl(
+@@ -14954,9 +14954,9 @@ globus_i_gfs_data_http_get(
+ {
+ retry = do_retry && (globus_error_get_type(globus_error_peek(result)) ==
+ GLOBUS_XIO_HTTP_ERROR_PERSISTENT_CONNECTION_DROPPED);
+-
++
+ if(!retry)
+- {
++ {
+ result = GlobusGFSErrorWrapFailed("HTTP connection", result);
+ goto response_exit;
+ }
+@@ -14990,7 +14990,7 @@ globus_i_gfs_data_http_get(
+ {
+ *ptr = '\0';
+ }
+-
++
+ /* read response, no data */
+ result = globus_xio_read(
+ handle,
+@@ -15009,7 +15009,7 @@ globus_i_gfs_data_http_get(
+ result = GLOBUS_SUCCESS;
+ }
+ }
+-
++
+ if(retry)
+ {
+ globus_xio_close(op->session_handle->http_handle, NULL);
+@@ -15030,7 +15030,7 @@ globus_i_gfs_data_http_get(
+ return globus_i_gfs_data_http_get(
+ op, path, request, offset, length, GLOBUS_FALSE);
+ }
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ result = GlobusGFSErrorWrapFailed("Before getting response, HTTP connection", result);
+@@ -15090,9 +15090,9 @@ globus_i_gfs_data_http_get(
+ else
+ {
+ waitfor = GLOBUS_MIN(1024, buflen-total_nbytes);
+- }
++ }
+ } while(!eof);
+-
++
+ body_buffer[total_nbytes] = '\0';
+ globus_i_gfs_data_http_print_response(
+ status_code, &header_table, body_buffer, &header_str);
+@@ -15104,7 +15104,7 @@ globus_i_gfs_data_http_get(
+ header_str);
+
+ result = GlobusGFSErrorGeneric(err_str);
+-
++
+ globus_free(err_str);
+ globus_free(header_str);
+ globus_free(body_buffer);
+@@ -15115,10 +15115,10 @@ globus_i_gfs_data_http_get(
+ {
+ globus_i_gfs_data_http_print_response(
+ status_code, &header_table, NULL, &op->user_msg);
+- }
+-
+-
+- /* set up internal file recv request */
++ }
++
++
++ /* set up internal file recv request */
+ recv_info = (globus_gfs_transfer_info_t *)
+ globus_calloc(1, sizeof(globus_gfs_transfer_info_t));
+ recv_info->alloc_size = length;
+@@ -15148,7 +15148,7 @@ globus_i_gfs_data_http_get(
+ &data_handle->session_handle->handle_table,
+ data_handle,
+ 1);
+-
++
+ data_handle->http_handle = handle;
+ data_handle->http_length = length;
+ data_handle->http_ip = globus_libc_strdup(op->http_ip);
+@@ -15163,8 +15163,8 @@ globus_i_gfs_data_http_get(
+ globus_l_gfs_data_http_transfer_cb,
+ globus_l_gfs_data_http_event_cb,
+ op);
+-
+-
++
++
+ return GLOBUS_SUCCESS;
+
+ open_exit:
+@@ -15173,10 +15173,10 @@ response_exit:
+
+ GlobusGFSDebugExit();
+ return result;
+-
++
+ }
+
+-globus_result_t
++globus_result_t
+ globus_i_gfs_data_http_put(
+ globus_l_gfs_data_operation_t * op,
+ char * path,
+@@ -15209,7 +15209,7 @@ globus_i_gfs_data_http_put(
+ char * ptr;
+ GlobusGFSName(globus_l_gfs_data_http_put);
+ GlobusGFSDebugEnter();
+-
++
+ /* parse url, headers */
+ result = globus_i_gfs_http_data_parse_request(
+ request, &url, &https, &http_ver, &method, &headers, &count);
+@@ -15226,7 +15226,7 @@ globus_i_gfs_data_http_put(
+ {
+ goto response_exit;
+ }
+-
++
+ result = globus_xio_attr_cntl(
+ attr,
+ op->session_handle->http_driver,
+@@ -15246,8 +15246,8 @@ globus_i_gfs_data_http_put(
+ {
+ goto response_exit;
+ }
+-
+- /* set individual headers */
++
++ /* set individual headers */
+ for (i = 0; i < count; i++)
+ {
+ result = globus_xio_attr_cntl(
+@@ -15289,7 +15289,7 @@ globus_i_gfs_data_http_put(
+ goto response_exit;
+ }
+ }
+-
++
+ result = globus_xio_open(handle, url, attr);
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -15327,7 +15327,7 @@ globus_i_gfs_data_http_put(
+ result = GLOBUS_SUCCESS;
+ }
+ }
+-
++
+ if(retry)
+ {
+ globus_xio_close(op->session_handle->http_handle, NULL);
+@@ -15347,7 +15347,7 @@ globus_i_gfs_data_http_put(
+ return globus_i_gfs_data_http_put(
+ op, path, request, offset, length, GLOBUS_FALSE);
+ }
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ result = GlobusGFSErrorWrapFailed("Before getting response, HTTP connection", result);
+@@ -15376,7 +15376,7 @@ globus_i_gfs_data_http_put(
+ globus_size_t total_nbytes = 0;
+ globus_bool_t eof;
+ globus_size_t waitfor = 0;
+-
++
+ body_buffer = malloc(buflen+1);
+ do
+ {
+@@ -15399,7 +15399,7 @@ globus_i_gfs_data_http_put(
+ eof = GLOBUS_TRUE;
+ }
+ total_nbytes += body_nbytes;
+-
++
+ if(body_nbytes == 0 || total_nbytes == buflen)
+ {
+ eof = GLOBUS_TRUE;
+@@ -15407,25 +15407,25 @@ globus_i_gfs_data_http_put(
+ else
+ {
+ waitfor = GLOBUS_MIN(1024, buflen-total_nbytes);
+- }
++ }
+ } while(!eof);
+-
++
+ body_buffer[total_nbytes] = '\0';
+ globus_i_gfs_data_http_print_response(
+ status_code, &header_table, body_buffer, &header_str);
+-
++
+ err_str = globus_common_create_string(
+ "HTTP PUT failed with \"%03d %s\"\n%s",
+ status_code,
+ reason_phrase,
+ header_str);
+-
++
+ result = GlobusGFSErrorGeneric(err_str);
+-
++
+ globus_free(err_str);
+ globus_free(header_str);
+ globus_free(body_buffer);
+-
++
+ goto open_exit;
+ }
+ }
+@@ -15460,12 +15460,12 @@ globus_i_gfs_data_http_put(
+ &data_handle->session_handle->handle_table,
+ data_handle,
+ 1);
+-
++
+ data_handle->http_handle = handle;
+ data_handle->http_length = length;
+ data_handle->http_ip = globus_libc_strdup(op->http_ip);
+ op->data_handle = data_handle;
+-
++
+ op->ref++;
+ globus_i_gfs_data_request_send(
+ NULL,
+@@ -15475,11 +15475,11 @@ globus_i_gfs_data_http_put(
+ globus_l_gfs_data_http_transfer_cb,
+ globus_l_gfs_data_http_event_cb,
+ op);
+-
+-
++
++
+ return GLOBUS_SUCCESS;
+
+-open_exit:
++open_exit:
+ response_exit:
+ GlobusGFSDebugExit();
+ return result;
+diff --git a/gridftp/server/src/globus_i_gfs_default_brain.c b/gridftp/server/src/globus_i_gfs_default_brain.c
+index d476d224d..d11ae92fb 100644
+--- a/gridftp/server/src/globus_i_gfs_default_brain.c
++++ b/gridftp/server/src/globus_i_gfs_default_brain.c
+@@ -84,7 +84,7 @@ gfs_l_db_node_cmp(
+ }
+ /* if the total number of connections is capped and we have exceded
+ the cap send it to the back */
+- if(n1->total_max_connections > 0
++ if(n1->total_max_connections > 0
+ && n1->total_connections >= n1->total_max_connections)
+ {
+ return 1;
+@@ -121,7 +121,7 @@ gfs_l_db_parse_string_list(
+ {
+ return NULL;
+ }
+-
++
+ tmp_str = globus_libc_strdup(str_list);
+ last_str = tmp_str;
+ while((p = strchr(last_str, ',')) != NULL)
+@@ -131,7 +131,7 @@ gfs_l_db_parse_string_list(
+ last_str = p + 1;
+ }
+ globus_list_insert(&list, strdup(last_str));
+-
++
+ globus_free(tmp_str);
+
+ return list;
+@@ -156,7 +156,7 @@ globus_l_brain_log_socket(
+ {
+ peer_contact = strdup("could get peer addr");
+ }
+-
++
+ globus_gfs_log_message(
+ GLOBUS_GFS_LOG_WARN,
+ "[%s] %s", peer_contact, msg);
+@@ -242,7 +242,7 @@ globus_l_gfs_gfork_dyn_reg(
+ repo = (gfs_l_db_repo_t *) calloc(1, sizeof(gfs_l_db_repo_t));
+ globus_priority_q_init(&repo->node_q, gfs_l_db_node_cmp);
+ globus_hashtable_init(
+- &repo->node_table,
++ &repo->node_table,
+ 32,
+ globus_hashtable_string_hash,
+ globus_hashtable_string_keyeq);
+@@ -257,7 +257,7 @@ globus_l_gfs_gfork_dyn_reg(
+ }
+
+ if(node == NULL)
+- {
++ {
+ node = (gfs_l_db_node_t*)globus_calloc(1, sizeof(gfs_l_db_node_t));
+ node->host_id = strdup(cs);
+ node->cookie_id = cookie_id;
+@@ -407,14 +407,14 @@ globus_l_gfs_gfork_incoming_cb(
+ {
+ globus_gfs_log_message(
+ GLOBUS_GFS_LOG_ERR,
+- "[%s] error in dyn reg size\n",
++ "[%s] error in dyn reg size\n",
+ "globus_l_gfs_gfork_incoming_cb()");
+ }
+ else
+ {
+ globus_gfs_log_message(
+ GLOBUS_GFS_LOG_INFO,
+- "[%s] registering a new backend %d\n",
++ "[%s] registering a new backend %d\n",
+ "globus_l_gfs_gfork_incoming_cb()",
+ n32);
+ globus_l_gfs_gfork_dyn_reg(
+@@ -476,9 +476,9 @@ globus_l_gfs_gfork_incoming_cb(
+
+ default:
+ globus_gfs_log_message(
+- GLOBUS_GFS_LOG_WARN,
++ GLOBUS_GFS_LOG_WARN,
+ "Unknown GFork message type received.\n");
+- break;
++ break;
+ }
+ }
+ globus_mutex_unlock(&globus_l_brain_mutex);
+@@ -520,7 +520,7 @@ globus_l_gfs_default_brain_init(
+ GFS_DB_REPO_SIZE,
+ globus_hashtable_string_hash,
+ globus_hashtable_string_keyeq);
+-
++
+ remote_list = globus_i_gfs_config_string("remote_nodes");
+ list = gfs_l_db_parse_string_list(remote_list);
+
+@@ -531,7 +531,7 @@ globus_l_gfs_default_brain_init(
+ globus_priority_q_init(&default_repo->node_q, gfs_l_db_node_cmp);
+
+ globus_hashtable_init(
+- &gfs_l_db_default_repo->node_table,
++ &gfs_l_db_default_repo->node_table,
+ 32,
+ globus_hashtable_string_hash,
+ globus_hashtable_string_keyeq);
+@@ -574,7 +574,7 @@ globus_l_gfs_default_brain_init(
+ if(result != GLOBUS_SUCCESS)
+ {
+ globus_gfs_log_result(
+- GLOBUS_GFS_LOG_DUMP,
++ GLOBUS_GFS_LOG_DUMP,
+ "GFork functionality not enabled.",
+ result);
+
+@@ -615,7 +615,7 @@ globus_l_gfs_default_brain_available(
+ int * count)
+ {
+ int size;
+-
++
+ size = globus_priority_q_size(&gfs_l_db_default_repo->node_q);
+ *count = size;
+
+@@ -690,7 +690,7 @@ globus_l_gfs_default_brain_select_nodes(
+ }
+ count = 0;
+ e_count = count;
+-
++
+ do
+ {
+ loop_count = 0;
+@@ -709,7 +709,7 @@ globus_l_gfs_default_brain_select_nodes(
+ else if(
+ (node->current_connection >= node->max_connection &&
+ node->max_connection < 0) ||
+- (node->total_max_connections > 0 &&
++ (node->total_max_connections > 0 &&
+ node->total_connections >= node->total_max_connections))
+ {
+ /* need to up everything for sake of nice clean up*/
+@@ -733,8 +733,8 @@ globus_l_gfs_default_brain_select_nodes(
+ GlobusGFSErrorObjParameter("No nodes available."));
+ goto error_short;
+ }
+-
+- /* if we are here we were successful and must re-enqueue the nodes
++
++ /* if we are here we were successful and must re-enqueue the nodes
+ * we just took out with new order */
+ for(i = count - loop_count; i < count; i++)
+ {
+diff --git a/gridftp/server/src/modules/file/globus_gridftp_server_file.c b/gridftp/server/src/modules/file/globus_gridftp_server_file.c
+index 2ce4c7fae..0325cd30b 100644
+--- a/gridftp/server/src/modules/file/globus_gridftp_server_file.c
++++ b/gridftp/server/src/modules/file/globus_gridftp_server_file.c
+@@ -58,7 +58,7 @@ GlobusDebugDeclare(GLOBUS_GRIDFTP_SERVER_FILE);
+ GlobusGFSFileDebugPrintf( \
+ GLOBUS_GFS_DEBUG_TRACE, \
+ ("[%s] Entering\n", _gfs_name))
+-
++
+ #define GlobusGFSFileDebugExit() \
+ GlobusGFSFileDebugPrintf( \
+ GLOBUS_GFS_DEBUG_TRACE, \
+@@ -98,7 +98,7 @@ typedef struct globus_l_gfs_file_cksm_monitor_s
+ globus_size_t block_size;
+ globus_l_gfs_file_cksm_cb_t internal_cb;
+ void * internal_cb_arg;
+-
++
+ globus_callback_handle_t marker_handle;
+ int marker_freq;
+ globus_bool_t send_marker;
+@@ -116,7 +116,7 @@ typedef struct globus_l_gfs_file_cksm_monitor_s
+ globus_byte_t buffer[];
+ } globus_l_gfs_file_cksm_monitor_t;
+
+-typedef struct
++typedef struct
+ {
+ gss_cred_id_t cred;
+ char * sbj;
+@@ -190,7 +190,7 @@ globus_l_gfs_file_cksm(
+ globus_off_t length,
+ globus_l_gfs_file_cksm_cb_t internal_cb,
+ void * internal_cb_arg);
+-
++
+ static
+ globus_result_t
+ globus_l_gfs_file_make_stack(
+@@ -279,7 +279,7 @@ error_push:
+ * else if priority_1 comes before priority_2, return < 0
+ * else return 0
+ */
+-
++
+ static
+ int
+ globus_l_gfs_file_queue_compare(
+@@ -294,7 +294,7 @@ globus_l_gfs_file_queue_compare(
+
+ buf_info1 = (globus_l_buffer_info_t *) priority_1;
+ buf_info2 = (globus_l_buffer_info_t *) priority_2;
+-
++
+ /* the void * are really just offsets */
+ if(buf_info1->offset > buf_info2->offset)
+ {
+@@ -304,7 +304,7 @@ globus_l_gfs_file_queue_compare(
+ {
+ rc = -1;
+ }
+-
++
+ GlobusGFSFileDebugExit();
+ return rc;
+ }
+@@ -321,7 +321,7 @@ globus_l_gfs_file_monitor_init(
+ int rc;
+ GlobusGFSName(globus_l_gfs_file_monitor_init);
+ GlobusGFSFileDebugEnter();
+-
++
+ monitor = (globus_l_file_monitor_t *) globus_malloc(
+ sizeof(globus_l_file_monitor_t));
+ if(!monitor)
+@@ -329,15 +329,15 @@ globus_l_gfs_file_monitor_init(
+ result = GlobusGFSErrorMemory("monitor");
+ goto error_alloc;
+ }
+-
++
+ rc = globus_memory_init(&monitor->mem, block_size, optimal_count);
+ if(!rc)
+ {
+ globus_free(monitor);
+ result = GlobusGFSErrorMemory("buffer");
+ goto error_alloc;
+- }
+-
++ }
++
+ globus_mutex_init(&monitor->lock, NULL);
+ globus_priority_q_init(
+ &monitor->queue, globus_l_gfs_file_queue_compare);
+@@ -360,7 +360,7 @@ globus_l_gfs_file_monitor_init(
+ monitor->pathname = NULL;
+
+ *u_monitor = monitor;
+-
++
+ GlobusGFSFileDebugExit();
+ return GLOBUS_SUCCESS;
+
+@@ -379,7 +379,7 @@ globus_l_gfs_file_monitor_destroy(
+ globus_byte_t * buffer;
+ GlobusGFSName(globus_l_gfs_file_monitor_destroy);
+ GlobusGFSFileDebugEnter();
+-
++
+ while(!globus_priority_q_empty(&monitor->queue))
+ {
+ buf_info = (globus_l_buffer_info_t *)
+@@ -393,7 +393,7 @@ globus_l_gfs_file_monitor_destroy(
+ globus_free(buf_info);
+ }
+ }
+-
++
+ for(list = monitor->buffer_list;
+ !globus_list_empty(list);
+ list = globus_list_rest(list))
+@@ -401,12 +401,12 @@ globus_l_gfs_file_monitor_destroy(
+ buffer = (globus_byte_t *) globus_list_first(list);
+ globus_memory_push_node(&monitor->mem, buffer);
+ }
+-
++
+ if(monitor->pathname)
+ {
+ globus_free(monitor->pathname);
+ }
+-
++
+ if(monitor->expected_cksm)
+ {
+ globus_free(monitor->expected_cksm);
+@@ -415,7 +415,7 @@ globus_l_gfs_file_monitor_destroy(
+ {
+ globus_free(monitor->expected_cksm_alg);
+ }
+-
++
+ globus_priority_q_destroy(&monitor->queue);
+ globus_list_free(monitor->buffer_list);
+ globus_memory_destroy(&monitor->mem);
+@@ -436,12 +436,12 @@ globus_l_gfs_file_cksm_verify(
+ globus_l_file_monitor_t * monitor;
+ GlobusGFSName(globus_l_gfs_file_cksm_verify);
+ GlobusGFSFileDebugEnter();
+-
++
+ monitor = (globus_l_file_monitor_t *) user_arg;
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+- monitor->finish_result =
++ monitor->finish_result =
+ GlobusGFSErrorWrapFailed("checksum verification", result);
+ }
+ else if(strcmp(monitor->expected_cksm, cksm) != 0)
+@@ -452,13 +452,13 @@ globus_l_gfs_file_cksm_verify(
+
+ globus_gridftp_server_finished_transfer(
+ monitor->op, monitor->finish_result);
+-
++
+ globus_l_gfs_file_monitor_destroy(monitor);
+
+ GlobusGFSFileDebugExit();
+ }
+
+-static
++static
+ globus_bool_t
+ globus_l_gfs_file_timeout_cb(
+ globus_xio_handle_t handle,
+@@ -472,7 +472,7 @@ globus_l_gfs_file_timeout_cb(
+ globus_gfs_log_message(
+ GLOBUS_GFS_LOG_WARN,
+ "A file access timeout has occurred.\n");
+-
++
+ GlobusGFSFileDebugExit();
+
+ return GLOBUS_TRUE;
+@@ -491,10 +491,10 @@ globus_l_gfs_file_close_cb(
+ monitor = (globus_l_file_monitor_t *) user_arg;
+
+ GlobusGFSFileDebugEnter();
+-
++
+ if(monitor != NULL)
+ {
+- /* must lock/unlock or we can get to the destroy before the
++ /* must lock/unlock or we can get to the destroy before the
+ registeration locak has actually released... crazy threads */
+ globus_mutex_lock(&monitor->lock);
+ {
+@@ -505,20 +505,20 @@ globus_l_gfs_file_close_cb(
+ }
+ globus_mutex_unlock(&monitor->lock);
+
+- if(monitor->finish_result == GLOBUS_SUCCESS &&
++ if(monitor->finish_result == GLOBUS_SUCCESS &&
+ monitor->utime >= 0)
+ {
+ monitor->finish_result = globus_l_gfs_file_utime(
+ NULL, monitor->pathname, monitor->utime);
+ }
+-
+- if(monitor->finish_result == GLOBUS_SUCCESS &&
++
++ if(monitor->finish_result == GLOBUS_SUCCESS &&
+ monitor->expected_cksm != NULL)
+ {
+ /* verify file before finishing */
+ result = globus_l_gfs_file_cksm(
+- NULL,
+- monitor->pathname,
++ NULL,
++ monitor->pathname,
+ monitor->expected_cksm_alg,
+ 0,
+ -1,
+@@ -529,7 +529,7 @@ globus_l_gfs_file_close_cb(
+ {
+ globus_gridftp_server_finished_transfer(
+ monitor->op, monitor->finish_result);
+-
++
+ globus_l_gfs_file_monitor_destroy(monitor);
+ }
+ }
+@@ -597,8 +597,8 @@ globus_l_gfs_file_close(
+ /**
+ * stat calls
+ */
+-
+-/* basepath and filename must be MAXPATHLEN long
++
++/* basepath and filename must be MAXPATHLEN long
+ * the pathname may be absolute or relative, basepath will be the same */
+ static
+ void
+@@ -611,12 +611,12 @@ globus_l_gfs_file_partition_path(
+ char * filepart;
+ GlobusGFSName(globus_l_gfs_file_partition_path);
+ GlobusGFSFileDebugEnter();
+-
++
+ strncpy(buf, pathname, MAXPATHLEN);
+ buf[MAXPATHLEN - 1] = '\0';
+-
++
+ filepart = strrchr(buf, '/');
+-
++
+ #ifdef WIN32
+
+
+@@ -652,15 +652,15 @@ globus_l_gfs_file_partition_path(
+ }
+ }
+ else
+- {
++ {
+ *filepart++ = '\0';
+ strcpy(basepath, buf);
+ strcpy(filename, filepart);
+ }
+- }
++ }
+
+ if(filename[0] == 0)
+- {
++ {
+ filename[0] = '/';
+ filename[1] = 0;
+ }
+@@ -678,7 +678,7 @@ globus_l_gfs_file_realpath(
+ char resolved[MAXPATHLEN];
+ GlobusGFSName(globus_l_gfs_file_stat);
+ GlobusGFSFileDebugEnter();
+-
++
+ if(realpath(in_path, resolved) == NULL)
+ {
+ result = GlobusGFSErrorSystemError("realpath", errno);
+@@ -719,7 +719,7 @@ globus_l_gfs_file_copy_stat(
+ stat_object->ino = stat_buf->st_ino;
+ stat_object->link_mode = link_mode;
+ stat_object->error = error;
+-
++
+ if(filename && *filename)
+ {
+ stat_object->name = globus_libc_strdup(filename);
+@@ -748,23 +748,23 @@ globus_l_gfs_file_destroy_stat(
+ int i;
+ GlobusGFSName(globus_l_gfs_file_destroy_stat);
+ GlobusGFSFileDebugEnter();
+-
++
+ for(i = 0; i < stat_count; i++)
+ {
+ if(stat_array[i].name != NULL)
+ {
+ globus_free(stat_array[i].name);
+- }
++ }
+ if(stat_array[i].symlink_target != NULL)
+ {
+ globus_free(stat_array[i].symlink_target);
+ }
+ }
+- globus_free(stat_array);
++ globus_free(stat_array);
+
+ GlobusGFSFileDebugExit();
+ }
+-
++
+
+ #define GFS_STAT_COUNT_CHECK 100
+ #define GFS_STAT_COUNT_MAX 1000
+@@ -787,39 +787,39 @@ globus_l_gfs_file_stat(
+ char filename[MAXPATHLEN];
+ char symlink_target[MAXPATHLEN];
+ globus_gridftp_server_control_stat_error_t base_error = GLOBUS_GRIDFTP_SERVER_CONTROL_STAT_SUCCESS;
+-
++
+ GlobusGFSName(globus_l_gfs_file_stat);
+ GlobusGFSFileDebugEnter();
+-
++
+ /* lstat is the same as stat when not operating on a link */
+ if(lstat(stat_info->pathname, &stat_buf) != 0)
+ {
+ result = GlobusGFSErrorSystemError("stat", errno);
+ goto error_stat1;
+ }
+- /* if this is a link we still need to stat to get the info we are
+- interested in and then use realpath() to get the full path of
++ /* if this is a link we still need to stat to get the info we are
++ interested in and then use realpath() to get the full path of
+ the symlink target */
+ *symlink_target = '\0';
+ if(S_ISLNK(stat_buf.st_mode))
+ {
+ int stat_result = 0;
+-
++
+ if(stat_info->use_symlink_info)
+ {
+ memset(&link_stat_buf, 0, sizeof(struct stat));
+ stat_result = stat(stat_info->pathname, &link_stat_buf);
+- }
++ }
+ else if(stat(stat_info->pathname, &stat_buf) != 0)
+ {
+ result = GlobusGFSErrorSystemError("stat", errno);
+ goto error_stat1;
+ }
+-
++
+ if(stat_result < 0 || realpath(stat_info->pathname, symlink_target) == NULL)
+ {
+ int nchars = readlink(stat_info->pathname, symlink_target, MAXPATHLEN);
+- if (nchars < 0)
++ if (nchars < 0)
+ {
+ result = GlobusGFSErrorSystemError("realpath", errno);
+ goto error_stat1;
+@@ -827,9 +827,9 @@ globus_l_gfs_file_stat(
+ symlink_target[nchars] = '\0';
+ base_error = GLOBUS_GRIDFTP_SERVER_CONTROL_STAT_INVALIDLINK;
+ }
+- }
++ }
+ globus_l_gfs_file_partition_path(stat_info->pathname, basepath, filename);
+-
++
+ if(!S_ISDIR(stat_buf.st_mode) || stat_info->file_only)
+ {
+ stat_array = (globus_gfs_stat_t *)
+@@ -839,7 +839,7 @@ globus_l_gfs_file_stat(
+ result = GlobusGFSErrorMemory("stat_array");
+ goto error_alloc1;
+ }
+-
++
+ globus_l_gfs_file_copy_stat(
+ stat_array, &stat_buf, filename, symlink_target, link_stat_buf.st_mode, base_error);
+ stat_count = 1;
+@@ -859,17 +859,17 @@ globus_l_gfs_file_stat(
+ globus_bool_t check_cdir = GLOBUS_TRUE;
+
+ stat_limit_time = time(NULL) + GFS_STAT_TIME;
+-
++
+ stat_count = stat_info->include_path_stat ? 1 : 0;
+
+-
++
+ {
+- if(stat_info->pathname &&
++ if(stat_info->pathname &&
+ stat_info->pathname[0] == '/' && stat_info->pathname[1] == 0)
+ {
+ DWORD drivemask;
+ char drive[] = "A";
+-
++
+ stat_array = (globus_gfs_stat_t *)
+ globus_malloc(sizeof(globus_gfs_stat_t) * 30);
+ if(!stat_array)
+@@ -892,7 +892,7 @@ globus_l_gfs_file_stat(
+ }
+
+ goto done_fake;
+-
++
+ }
+ }
+
+@@ -904,7 +904,7 @@ globus_l_gfs_file_stat(
+ if (!stat_info->include_path_stat)
+ goto error_open;
+ }
+-
++
+ total_stat_count = 0;
+
+ while(globus_libc_readdir_r(dir, &dir_entry) == 0 && dir_entry)
+@@ -912,46 +912,46 @@ globus_l_gfs_file_stat(
+ total_stat_count++;
+ globus_free(dir_entry);
+ }
+-
++
+ globus_libc_rewinddir(dir);
+
+ stat_array = (globus_gfs_stat_t *) globus_malloc(
+- sizeof(globus_gfs_stat_t) *
++ sizeof(globus_gfs_stat_t) *
+ (GLOBUS_MIN(stat_limit_max, total_stat_count) + 1));
+ if(!stat_array)
+ {
+ result = GlobusGFSErrorMemory("stat_array");
+ goto error_alloc2;
+ }
+-
++
+ snprintf(
+- dir_path,
+- sizeof(dir_path),
+- "%s/%s",
+- (basepath[0] != '/' || basepath[1] != '\0') ? basepath : "",
++ dir_path,
++ sizeof(dir_path),
++ "%s/%s",
++ (basepath[0] != '/' || basepath[1] != '\0') ? basepath : "",
+ filename);
+-
++
+ dir_path[maxpathlen - 1] = '\0';
+ if(!basepath[0] && filename[0] == '/')
+ {
+ dir_path[0] = 0;
+ }
+-
++
+ i = 0;
+- if(stat_info->include_path_stat)
++ if(stat_info->include_path_stat)
+ {
+ globus_l_gfs_file_copy_stat(&stat_array[i++], &stat_buf, filename, NULL, 0,
+ dir ? GLOBUS_GRIDFTP_SERVER_CONTROL_STAT_SUCCESS : GLOBUS_GRIDFTP_SERVER_CONTROL_STAT_OPENFAILED);
+ }
+-
++
+ while(globus_libc_readdir_r(dir, &dir_entry) == 0 && dir_entry)
+ {
+ char path[maxpathlen];
+-
++
+ base_error = GLOBUS_GRIDFTP_SERVER_CONTROL_STAT_SUCCESS;
+ snprintf(path, sizeof(path), "%s/%s", dir_path, dir_entry->d_name);
+ path[maxpathlen - 1] = '\0';
+-
++
+ if(stat(path, &stat_buf) != 0)
+ {
+ /* stat() doesn't return a useful error */
+@@ -980,7 +980,7 @@ globus_l_gfs_file_stat(
+ &stat_array[i], &stat_buf, dir_entry->d_name, symlink_target, link_stat_buf.st_mode, base_error);
+
+ /* set nlink to total files in dir for . entry */
+- if(check_cdir && dir_entry->d_name &&
++ if(check_cdir && dir_entry->d_name &&
+ dir_entry->d_name[0] == '.' && dir_entry->d_name[1] == '\0')
+ {
+ check_cdir = GLOBUS_FALSE;
+@@ -990,7 +990,7 @@ globus_l_gfs_file_stat(
+ {
+ unsigned long h = 0;
+ char * key;
+-
++
+ key = path;
+ while(*key)
+ {
+@@ -1001,13 +1001,13 @@ globus_l_gfs_file_stat(
+
+ i++;
+ globus_free(dir_entry);
+-
++
+ /* send updates every GFS_STAT_TIME, checked every GFS_STAT_CHECK */
+ if(i >= stat_limit_check)
+ {
+ time_t tmp_time;
+ globus_bool_t send_stats = GLOBUS_FALSE;
+-
++
+ tmp_time = time(NULL);
+ if(i >= stat_limit_max || tmp_time > stat_limit_time)
+ {
+@@ -1017,7 +1017,7 @@ globus_l_gfs_file_stat(
+ {
+ stat_limit_check += GFS_STAT_COUNT_CHECK;
+ }
+-
++
+ if(send_stats)
+ {
+ stat_count = i;
+@@ -1025,12 +1025,12 @@ globus_l_gfs_file_stat(
+ stat_limit_time = tmp_time + GFS_STAT_TIME;
+
+ i = 0;
+-
++
+ globus_gridftp_server_finished_stat_partial(
+ op, GLOBUS_SUCCESS, stat_array, stat_count);
+-
++
+ globus_l_gfs_file_destroy_stat(stat_array, stat_count);
+-
++
+ stat_array = (globus_gfs_stat_t *) globus_malloc(
+ sizeof(globus_gfs_stat_t) * (stat_limit_max + 1));
+ if(!stat_array)
+@@ -1038,13 +1038,13 @@ globus_l_gfs_file_stat(
+ result = GlobusGFSErrorMemory("stat_array");
+ goto error_alloc2;
+ }
+-
++
+ stat_count = 0;
+ }
+- }
++ }
+ }
+ stat_count = i;
+-
++
+ closedir(dir);
+ goto done_fake;
+
+@@ -1071,11 +1071,11 @@ done_fake:
+ int slow_listing_thresh;
+
+ stat_limit_time = time(NULL) + GFS_STAT_TIME;
+-
++
+ total_stat_count = scandir(
+- stat_info->pathname,
+- &entries,
+- NULL,
++ stat_info->pathname,
++ &entries,
++ NULL,
+ (getenv("FTPNOSORT") ? NULL : alphasort));
+ if(total_stat_count < 0)
+ {
+@@ -1090,33 +1090,33 @@ done_fake:
+ }
+
+ stat_array = (globus_gfs_stat_t *) globus_malloc(
+- sizeof(globus_gfs_stat_t) *
++ sizeof(globus_gfs_stat_t) *
+ (GLOBUS_MIN(stat_limit_max, total_stat_count) + 1));
+ if(!stat_array)
+ {
+ result = GlobusGFSErrorMemory("stat_array");
+ goto error_open;
+ }
+-
++
+ snprintf(
+- dir_path,
+- sizeof(dir_path),
+- "%s/%s",
+- (basepath[0] != '/' || basepath[1] != '\0') ? basepath : "",
++ dir_path,
++ sizeof(dir_path),
++ "%s/%s",
++ (basepath[0] != '/' || basepath[1] != '\0') ? basepath : "",
+ filename);
+-
++
+ dir_path[MAXPATHLEN - 1] = '\0';
+-
++
+ i = 0;
+ j = 0;
+ while(j < total_stat_count)
+- {
++ {
+ char path[MAXPATHLEN];
+-
++
+ dir_entry = entries[j++];
+ snprintf(path, sizeof(path), "%s/%s", dir_path, dir_entry->d_name);
+ path[MAXPATHLEN - 1] = '\0';
+-
++
+ /* fake a stat response if stats are slow, d_type is valid,
+ * and indicates a file or dir */
+ #ifndef _DIRENT_HAVE_D_TYPE
+@@ -1186,7 +1186,7 @@ done_fake:
+ }
+ globus_l_gfs_file_copy_stat(
+ &stat_array[i], &stat_buf, dir_entry->d_name, symlink_target, link_stat_buf.st_mode, base_error);
+-
++
+ /* set nlink to total files in dir for . entry */
+ if(check_cdir &&
+ dir_entry->d_name[0] == '.' && dir_entry->d_name[1] == '\0')
+@@ -1204,7 +1204,7 @@ done_fake:
+ {
+ time_t tmp_time;
+ globus_bool_t send_stats = GLOBUS_FALSE;
+-
++
+ tmp_time = time(NULL);
+ if(i >= stat_limit_max || tmp_time >= stat_limit_time)
+ {
+@@ -1214,7 +1214,7 @@ done_fake:
+ {
+ stat_limit_check += GFS_STAT_COUNT_CHECK;
+ }
+-
++
+ if(send_stats)
+ {
+ stat_count = i;
+@@ -1227,7 +1227,7 @@ done_fake:
+ op, GLOBUS_SUCCESS, stat_array, stat_count);
+
+ globus_l_gfs_file_destroy_stat(stat_array, stat_count);
+-
++
+ stat_array = (globus_gfs_stat_t *) globus_malloc(
+ sizeof(globus_gfs_stat_t) * (stat_limit_max + 1));
+ if(!stat_array)
+@@ -1235,13 +1235,13 @@ done_fake:
+ result = GlobusGFSErrorMemory("stat_array");
+ goto error_open;
+ }
+-
++
+ stat_count = 0;
+ }
+- }
++ }
+ }
+ stat_count = i;
+-
++
+ if(entries)
+ {
+ globus_free(entries);
+@@ -1252,7 +1252,7 @@ done_fake:
+ globus_gridftp_server_finished_stat(
+ op, result, stat_array, stat_count);
+ globus_l_gfs_file_destroy_stat(stat_array, stat_count);
+-
++
+ GlobusGFSFileDebugExit();
+ return;
+
+@@ -1276,12 +1276,12 @@ globus_l_gfs_file_truncate(
+ globus_result_t result;
+ globus_xio_system_file_t fd;
+ struct stat sbuf;
+-
++
+ GlobusGFSName(globus_l_gfs_file_truncate);
+ GlobusGFSFileDebugEnter();
+
+ result = globus_xio_system_file_open(
+- &fd, pathname,
++ &fd, pathname,
+ GLOBUS_XIO_FILE_RDWR | GLOBUS_XIO_FILE_BINARY, 0);
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -1289,16 +1289,16 @@ globus_l_gfs_file_truncate(
+ }
+
+ #ifdef WIN32
+- rc = stat(pathname, &sbuf);
++ rc = stat(pathname, &sbuf);
+ #else
+ rc = fstat(fd, &sbuf);
+-#endif
++#endif
+ if(rc != 0)
+ {
+ result = GlobusGFSErrorSystemError("stat", errno);
+ goto error_close;
+ }
+-
++
+ if(offset > sbuf.st_size)
+ {
+ result = GlobusGFSErrorGeneric(
+@@ -1311,15 +1311,15 @@ globus_l_gfs_file_truncate(
+ {
+ goto error_close;
+ }
+-
++
+ result = globus_xio_system_file_close(fd);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error;
+ }
+-
++
+ globus_gridftp_server_finished_command(op, GLOBUS_SUCCESS, NULL);
+-
++
+ GlobusGFSFileDebugExit();
+ return GLOBUS_SUCCESS;
+
+@@ -1347,12 +1347,12 @@ globus_l_gfs_file_mkdir(
+ result = GlobusGFSErrorSystemError("mkdir", errno);
+ goto error;
+ }
+-
++
+ globus_gridftp_server_finished_command(op, GLOBUS_SUCCESS, NULL);
+-
++
+ GlobusGFSFileDebugExit();
+ return GLOBUS_SUCCESS;
+-
++
+ error:
+ GlobusGFSFileDebugExitWithError();
+ return result;
+@@ -1375,12 +1375,12 @@ globus_l_gfs_file_rmdir(
+ result = GlobusGFSErrorSystemError("rmdir", errno);
+ goto error;
+ }
+-
++
+ globus_gridftp_server_finished_command(op, GLOBUS_SUCCESS, NULL);
+-
++
+ GlobusGFSFileDebugExit();
+ return GLOBUS_SUCCESS;
+-
++
+ error:
+ GlobusGFSFileDebugExitWithError();
+ return result;
+@@ -1401,18 +1401,18 @@ globus_l_gfs_file_delete_dir(
+ char path[MAXPATHLEN];
+ GlobusGFSName(globus_l_gfs_file_delete_dir);
+ GlobusGFSFileDebugEnter();
+-
++
+ /* lstat is the same as stat when not operating on a link */
+ if(lstat(pathname, &stat_buf) != 0)
+ {
+ result = GlobusGFSErrorSystemError("stat", errno);
+ goto error_stat;
+ }
+-
++
+ if(!S_ISDIR(stat_buf.st_mode))
+ {
+ /* remove anything that isn't a dir -- don't follow links */
+- rc = unlink(pathname);
++ rc = unlink(pathname);
+ if(rc != 0)
+ {
+ result = GlobusGFSErrorSystemError("unlink", errno);
+@@ -1427,13 +1427,13 @@ globus_l_gfs_file_delete_dir(
+ result = GlobusGFSErrorSystemError("opendir", errno);
+ goto error_open;
+ }
+-
++
+ for(i = 0;
+ globus_libc_readdir_r(dir, &dir_entry) == 0 && dir_entry;
+ i++)
+- {
+- if(dir_entry->d_name[0] == '.' &&
+- (dir_entry->d_name[1] == '\0' ||
++ {
++ if(dir_entry->d_name[0] == '.' &&
++ (dir_entry->d_name[1] == '\0' ||
+ (dir_entry->d_name[1] == '.' && dir_entry->d_name[2] == '\0')))
+ {
+ globus_free(dir_entry);
+@@ -1441,7 +1441,7 @@ globus_l_gfs_file_delete_dir(
+ }
+ snprintf(path, sizeof(path), "%s/%s", pathname, dir_entry->d_name);
+ path[MAXPATHLEN - 1] = '\0';
+-
++
+ /* lstat is the same as stat when not operating on a link */
+ if(lstat(path, &stat_buf) != 0)
+ {
+@@ -1450,11 +1450,11 @@ globus_l_gfs_file_delete_dir(
+ /* just skip invalid entries */
+ continue;
+ }
+-
++
+ if(!S_ISDIR(stat_buf.st_mode))
+ {
+ /* remove anything that isn't a dir -- don't follow links */
+- rc = unlink(path);
++ rc = unlink(path);
+ if(rc != 0)
+ {
+ result = GlobusGFSErrorSystemError("unlink", errno);
+@@ -1480,23 +1480,23 @@ globus_l_gfs_file_delete_dir(
+ result = GlobusGFSErrorSystemError("rmdir", errno);
+ goto error_rmdir;
+ }
+- }
+-
++ }
++
+ GlobusGFSFileDebugExit();
+ return GLOBUS_SUCCESS;
+
+ error_recurse:
+ error_unlink2:
+- closedir(dir);
+- globus_free(dir_entry);
+-error_open:
++ closedir(dir);
++ globus_free(dir_entry);
++error_open:
+ error_stat:
+ error_unlink1:
+-error_rmdir:
++error_rmdir:
+ GlobusGFSFileDebugExitWithError();
+- return result;
++ return result;
+ }
+-
++
+ static
+ globus_result_t
+ globus_l_gfs_file_delete(
+@@ -1527,12 +1527,12 @@ globus_l_gfs_file_delete(
+ goto error;
+ }
+ }
+-
++
+ globus_gridftp_server_finished_command(op, GLOBUS_SUCCESS, NULL);
+-
++
+ GlobusGFSFileDebugExit();
+ return GLOBUS_SUCCESS;
+-
++
+ error:
+ GlobusGFSFileDebugExitWithError();
+ return result;
+@@ -1556,12 +1556,12 @@ globus_l_gfs_file_rename(
+ result = GlobusGFSErrorSystemError("rename", errno);
+ goto error;
+ }
+-
++
+ globus_gridftp_server_finished_command(op, GLOBUS_SUCCESS, NULL);
+-
++
+ GlobusGFSFileDebugExit();
+ return GLOBUS_SUCCESS;
+-
++
+ error:
+ GlobusGFSFileDebugExitWithError();
+ return result;
+@@ -1579,7 +1579,7 @@ globus_l_gfs_file_chgrp(
+ struct group * grp_info;
+ int grp_id;
+ char* endpt;
+-
++
+ GlobusGFSName(globus_l_gfs_file_chgrp);
+ GlobusGFSFileDebugEnter();
+
+@@ -1587,7 +1587,7 @@ globus_l_gfs_file_chgrp(
+ if(grp_info != NULL)
+ {
+ grp_id = grp_info->gr_gid;
+- }
++ }
+ else
+ {
+ grp_id = strtol(group, &endpt, 10);
+@@ -1597,25 +1597,25 @@ globus_l_gfs_file_chgrp(
+ goto error;
+ }
+ }
+-
++
+ if(grp_id < 0)
+ {
+ result = GlobusGFSErrorSystemError("chgrp", EPERM);
+ goto error;
+ }
+-
++
+ rc = chown(pathname, -1, grp_id);
+ if(rc != 0)
+ {
+ result = GlobusGFSErrorSystemError("chgrp", errno);
+ goto error;
+ }
+-
++
+ globus_gridftp_server_finished_command(op, GLOBUS_SUCCESS, NULL);
+-
++
+ GlobusGFSFileDebugExit();
+ return GLOBUS_SUCCESS;
+-
++
+ error:
+ GlobusGFSFileDebugExitWithError();
+ return result;
+@@ -1624,17 +1624,17 @@ error:
+ #ifdef WIN32
+
+ /* utime on win32 does not work with directories.
+- we can work around that by opening a HANDLE with the
+- FILE_FLAG_BACKUP_SEMANTICS flag, getting the fd from that, and calling
++ we can work around that by opening a HANDLE with the
++ FILE_FLAG_BACKUP_SEMANTICS flag, getting the fd from that, and calling
+ _futime on that fd.
+
+- we could call SetFileTime() with the HANDLE, but there are quirks with
++ we could call SetFileTime() with the HANDLE, but there are quirks with
+ DST that result in the time returned by stat() being different than the
+ set time depending on the date and current DST state. the perl module
+ Win32-UTCFileTime documents that bit of fun.
+ */
+-
+-static BOOL
++
++static BOOL
+ utime_win(
+ const char * path,
+ struct utimbuf * ubuf)
+@@ -1643,7 +1643,7 @@ utime_win(
+ int rc;
+ int fd;
+ hFile = CreateFile(
+- path, FILE_WRITE_ATTRIBUTES, FILE_SHARE_WRITE, 0,
++ path, FILE_WRITE_ATTRIBUTES, FILE_SHARE_WRITE, 0,
+ OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
+ if (hFile == INVALID_HANDLE_VALUE)
+ {
+@@ -1676,7 +1676,7 @@ globus_l_gfs_file_utime(
+
+ #ifdef WIN32
+ rc = utime_win(pathname, &ubuf);
+-#else
++#else
+ rc = utime(pathname, &ubuf);
+ #endif
+ if(rc != 0)
+@@ -1684,15 +1684,15 @@ globus_l_gfs_file_utime(
+ result = GlobusGFSErrorSystemError("utime", errno);
+ goto error;
+ }
+-
++
+ if(op)
+ {
+ globus_gridftp_server_finished_command(op, GLOBUS_SUCCESS, NULL);
+ }
+-
++
+ GlobusGFSFileDebugExit();
+ return GLOBUS_SUCCESS;
+-
++
+ error:
+ GlobusGFSFileDebugExitWithError();
+ return result;
+@@ -1716,12 +1716,12 @@ globus_l_gfs_file_symlink(
+ result = GlobusGFSErrorSystemError("symlink", errno);
+ goto error;
+ }
+-
++
+ globus_gridftp_server_finished_command(op, GLOBUS_SUCCESS, NULL);
+-
++
+ GlobusGFSFileDebugExit();
+ return GLOBUS_SUCCESS;
+-
++
+ error:
+ GlobusGFSFileDebugExitWithError();
+ return result;
+@@ -1745,12 +1745,12 @@ globus_l_gfs_file_chmod(
+ result = GlobusGFSErrorSystemError("chmod", errno);
+ goto error;
+ }
+-
++
+ globus_gridftp_server_finished_command(op, GLOBUS_SUCCESS, NULL);
+-
++
+ GlobusGFSFileDebugExit();
+ return GLOBUS_SUCCESS;
+-
++
+ error:
+ GlobusGFSFileDebugExitWithError();
+ return result;
+@@ -1759,11 +1759,11 @@ error:
+ static
+ void
+ globus_l_gfs_file_cksm_read_cb(
+- globus_xio_handle_t handle,
++ globus_xio_handle_t handle,
+ globus_result_t result,
+ globus_byte_t * buffer,
+ globus_size_t len,
+- globus_size_t nbytes,
++ globus_size_t nbytes,
+ globus_xio_data_descriptor_t data_desc,
+ void * user_arg)
+ {
+@@ -1777,11 +1777,11 @@ globus_l_gfs_file_cksm_read_cb(
+ unsigned char sha[SHA512_DIGEST_LENGTH];
+ char shasum[SHA512_DIGEST_LENGTH * 2 + 1] = {0};
+ char adler32_human[2*sizeof(uint32_t)+1];
+- int i;
++ int i;
+
+ GlobusGFSName(globus_l_gfs_file_cksm_read_cb);
+ GlobusGFSFileDebugEnter();
+-
++
+ monitor = (globus_l_gfs_file_cksm_monitor_t *) user_arg;
+
+ if(result != GLOBUS_SUCCESS)
+@@ -1796,11 +1796,11 @@ globus_l_gfs_file_cksm_read_cb(
+ "checksum read callback", result);
+ goto error_read;
+ }
+- }
++ }
+ if(monitor->length >= 0)
+ {
+ monitor->read_left -= nbytes;
+- monitor->count = (monitor->read_left > monitor->block_size) ?
++ monitor->count = (monitor->read_left > monitor->block_size) ?
+ monitor->block_size : monitor->read_left;
+ if(monitor->read_left == 0)
+ {
+@@ -1835,10 +1835,10 @@ globus_l_gfs_file_cksm_read_cb(
+ if(monitor->send_marker)
+ {
+ monitor->send_marker = GLOBUS_FALSE;
+-
++
+ char count[128];
+ sprintf(count, "%"GLOBUS_OFF_T_FORMAT, monitor->total_bytes);
+-
++
+ globus_gridftp_server_intermediate_command(
+ monitor->op, GLOBUS_SUCCESS, count);
+ }
+@@ -1874,7 +1874,7 @@ globus_l_gfs_file_cksm_read_cb(
+ NULL);
+ monitor->marker_handle = GLOBUS_NULL_HANDLE;
+ }
+-
++
+ globus_xio_register_close(
+ handle,
+ NULL,
+@@ -1937,22 +1937,22 @@ globus_l_gfs_file_cksm_read_cb(
+ {
+ globus_gridftp_server_finished_command(
+ monitor->op, GLOBUS_SUCCESS, cksmptr);
+- }
+-
++ }
++
+ globus_free(monitor);
+-
+- }
++
++ }
+ GlobusGFSFileDebugExit();
+ return;
+-
++
+
+ error_register:
+ error_read:
+ globus_xio_register_close(handle, NULL, NULL, NULL);
+ handle = NULL;
+- globus_gridftp_server_finished_command(monitor->op, result, NULL);
++ globus_gridftp_server_finished_command(monitor->op, result, NULL);
+ globus_free(monitor);
+-
++
+ GlobusGFSFileDebugExitWithError();
+ }
+
+@@ -1962,7 +1962,7 @@ globus_l_gfs_file_marker_cb(
+ void * user_arg)
+ {
+ globus_l_gfs_file_cksm_monitor_t * monitor;
+-
++
+ monitor = (globus_l_gfs_file_cksm_monitor_t *) user_arg;
+ monitor->send_marker = GLOBUS_TRUE;
+ }
+@@ -1973,20 +1973,20 @@ globus_l_gfs_file_open_cksm_cb(
+ globus_xio_handle_t handle,
+ globus_result_t result,
+ void * user_arg)
+-{
++{
+ globus_l_gfs_file_cksm_monitor_t * monitor;
+ GlobusGFSName(globus_l_gfs_file_open_cksm_cb);
+ GlobusGFSFileDebugEnter();
+-
++
+ monitor = (globus_l_gfs_file_cksm_monitor_t *) user_arg;
+
+ if(result != GLOBUS_SUCCESS)
+ {
+ result = GlobusGFSErrorWrapFailed(
+ "open", result);
+- goto error_open;
+- }
+-
++ goto error_open;
++ }
++
+ if(monitor->op)
+ {
+ globus_gridftp_server_get_update_interval(
+@@ -1997,7 +1997,7 @@ globus_l_gfs_file_open_cksm_cb(
+ {
+ globus_result_t res;
+ globus_reltime_t delay;
+-
++
+ GlobusTimeReltimeSet(delay, monitor->marker_freq, 0);
+ res = globus_callback_register_periodic(
+ &monitor->marker_handle,
+@@ -2007,21 +2007,21 @@ globus_l_gfs_file_open_cksm_cb(
+ monitor);
+ if(res != GLOBUS_SUCCESS)
+ {
+-
++
+ }
+ }
+-
++
+ if(monitor->length >= 0)
+ {
+ monitor->read_left = monitor->length;
+- monitor->count = (monitor->read_left > monitor->block_size) ?
++ monitor->count = (monitor->read_left > monitor->block_size) ?
+ monitor->block_size : monitor->read_left;
+ }
+ else
+ {
+ monitor->count = monitor->block_size;
+ }
+-
++
+ if(monitor->offset > 0)
+ {
+ result = globus_xio_handle_cntl(
+@@ -2058,8 +2058,8 @@ globus_l_gfs_file_open_cksm_cb(
+ {
+ monitor->adler32ctx = adler32(0, NULL, 0);
+ }
+-
+-
++
++
+ result = globus_xio_register_read(
+ handle,
+ monitor->buffer,
+@@ -2077,7 +2077,7 @@ globus_l_gfs_file_open_cksm_cb(
+
+ GlobusGFSFileDebugExit();
+ return;
+-
++
+ error_register:
+ error_seek:
+ error_open:
+@@ -2090,9 +2090,9 @@ error_open:
+ else
+ {
+ globus_gridftp_server_finished_command(monitor->op, result, NULL);
+- }
++ }
+ globus_free(monitor);
+-
++
+ GlobusGFSFileDebugExitWithError();
+ }
+
+@@ -2118,7 +2118,7 @@ globus_l_gfs_file_cksm(
+ int cksm_type = 0;
+ GlobusGFSName(globus_l_gfs_file_cksm);
+ GlobusGFSFileDebugEnter();
+-
++
+ if(offset < 0)
+ {
+ result = GlobusGFSErrorGeneric("Invalid offset.");
+@@ -2186,18 +2186,18 @@ globus_l_gfs_file_cksm(
+ {
+ globus_gfs_log_message(
+ GLOBUS_GFS_LOG_WARN,
+- "Unable to set file access timeout of %d seconds\n",
++ "Unable to set file access timeout of %d seconds\n",
+ timeout);
+ }
+ }
+-
++
+ result = globus_xio_stack_init(&stack, NULL);
+ if(result != GLOBUS_SUCCESS)
+ {
+ result = GlobusGFSErrorWrapFailed("globus_xio_stack_init", result);
+ goto error_stack;
+ }
+-
++
+ result = globus_xio_stack_push_driver(stack, globus_l_gfs_file_driver);
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -2222,7 +2222,7 @@ globus_l_gfs_file_cksm(
+ result = GlobusGFSErrorMemory("checksum buffer");
+ goto error_mem;
+ }
+-
++
+ monitor->op = op;
+ monitor->offset = offset;
+ monitor->length = length;
+@@ -2246,7 +2246,7 @@ globus_l_gfs_file_cksm(
+
+ globus_xio_attr_destroy(attr);
+ globus_xio_stack_destroy(stack);
+-
++
+ GlobusGFSFileDebugExit();
+ return GLOBUS_SUCCESS;
+
+@@ -2254,22 +2254,22 @@ error_register:
+ globus_xio_register_close(file_handle, NULL, NULL, NULL);
+ file_handle = NULL;
+ globus_free(monitor);
+-
++
+ error_mem:
+ error_create:
+ error_push:
+ globus_xio_stack_destroy(stack);
+-
++
+ error_stack:
+-error_cntl:
++error_cntl:
+ globus_xio_attr_destroy(attr);
+-
++
+ error_attr:
+ alg_error:
+ param_error:
+ GlobusGFSFileDebugExitWithError();
+ return result;
+-}
++}
+
+ static
+ void
+@@ -2324,15 +2324,15 @@ globus_l_gfs_file_command(
+ break;
+ case GLOBUS_GFS_CMD_CKSM:
+ result = globus_l_gfs_file_cksm(
+- op,
+- cmd_info->pathname,
++ op,
++ cmd_info->pathname,
+ cmd_info->cksm_alg,
+ cmd_info->cksm_offset,
+ cmd_info->cksm_length,
+ NULL,
+ NULL);
+ break;
+-
++
+ default:
+ result = GLOBUS_FAILURE;
+ break;
+@@ -2342,12 +2342,12 @@ globus_l_gfs_file_command(
+ {
+ goto error;
+ }
+-
++
+ GlobusGFSFileDebugExit();
+ return;
+
+ error:
+- globus_gridftp_server_finished_command(op, result, NULL);
++ globus_gridftp_server_finished_command(op, result, NULL);
+
+ GlobusGFSFileDebugExitWithError();
+ }
+@@ -2371,29 +2371,29 @@ static
+ globus_result_t
+ globus_l_gfs_file_dispatch_write(
+ globus_l_file_monitor_t * monitor);
+-
++
+ static
+ void
+ globus_l_gfs_file_write_cb(
+- globus_xio_handle_t xio_handle,
++ globus_xio_handle_t xio_handle,
+ globus_result_t result,
+ globus_byte_t * buffer,
+ globus_size_t len,
+- globus_size_t nbytes,
++ globus_size_t nbytes,
+ globus_xio_data_descriptor_t data_desc,
+ void * user_arg)
+ {
+ globus_l_file_monitor_t * monitor;
+ GlobusGFSName(globus_l_gfs_file_write_cb);
+ GlobusGFSFileDebugEnter();
+-
++
+ monitor = (globus_l_file_monitor_t *) user_arg;
+-
++
+ globus_mutex_lock(&monitor->lock);
+- {
++ {
+ monitor->pending_writes--;
+ globus_gridftp_server_update_bytes_written(
+- monitor->op,
++ monitor->op,
+ monitor->file_offset,
+ nbytes);
+ monitor->file_offset += nbytes;
+@@ -2406,7 +2406,7 @@ globus_l_gfs_file_write_cb(
+ {
+ goto error;
+ }
+-
++
+ if(!monitor->eof)
+ {
+ result = globus_gridftp_server_register_read(
+@@ -2421,14 +2421,14 @@ globus_l_gfs_file_write_cb(
+ "globus_gridftp_server_register_read", result);
+ goto error;
+ }
+-
++
+ monitor->pending_reads++;
+ }
+ else
+ {
+ globus_memory_push_node(&monitor->mem, buffer);
+ }
+-
++
+ result = globus_l_gfs_file_dispatch_write(monitor);
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -2436,7 +2436,7 @@ globus_l_gfs_file_write_cb(
+ "globus_l_gfs_file_dispatch_write", result);
+ goto error_dispatch;
+ }
+-
++
+ if(monitor->pending_reads == 0 && monitor->pending_writes == 0)
+ {
+ globus_assert(monitor->eof || monitor->aborted);
+@@ -2450,7 +2450,7 @@ globus_l_gfs_file_write_cb(
+ }
+ }
+ /* already unlocked */
+-
++
+ GlobusGFSFileDebugExit();
+ return;
+
+@@ -2461,7 +2461,7 @@ error_dispatch:
+ {
+ /* there are still outstanding callbacks, wait for them */
+ globus_mutex_unlock(&monitor->lock);
+-
++
+ GlobusGFSFileDebugExitWithError();
+ return;
+ }
+@@ -2482,7 +2482,7 @@ globus_l_gfs_file_dispatch_write(
+ globus_result_t result;
+ GlobusGFSName(globus_l_gfs_file_dispatch_write);
+ GlobusGFSFileDebugEnter();
+-
++
+ if(monitor->pending_writes == 0 && !monitor->aborted)
+ {
+ buf_info = (globus_l_buffer_info_t *)
+@@ -2490,7 +2490,7 @@ globus_l_gfs_file_dispatch_write(
+ if(buf_info)
+ {
+ if(buf_info->offset != monitor->file_offset)
+- {
++ {
+ globus_off_t seek_tmp;
+
+ monitor->file_offset = buf_info->offset;
+@@ -2509,7 +2509,7 @@ globus_l_gfs_file_dispatch_write(
+ goto error_seek;
+ }
+ }
+-
++
+ result = globus_xio_register_write(
+ monitor->file_handle,
+ buf_info->buffer,
+@@ -2524,13 +2524,13 @@ globus_l_gfs_file_dispatch_write(
+ "globus_xio_register_write", result);
+ goto error_register;
+ }
+-
++
+ monitor->pending_writes++;
+-
++
+ globus_free(buf_info);
+ }
+ }
+-
++
+ GlobusGFSFileDebugExit();
+ return GLOBUS_SUCCESS;
+
+@@ -2557,7 +2557,7 @@ globus_l_gfs_file_update_concurrency(
+ int extra;
+ GlobusGFSName(globus_l_gfs_file_update_concurrency);
+ GlobusGFSFileDebugEnter();
+-
++
+ if(!monitor->eof)
+ {
+ monitor->concurrency_check = monitor->concurrency_check_interval;
+@@ -2566,16 +2566,16 @@ globus_l_gfs_file_update_concurrency(
+ {
+ monitor->concurrency_check_interval = 1024;
+ }
+-
++
+ globus_gridftp_server_get_optimal_concurrency(
+ monitor->op, &optimal_count);
+ extra = optimal_count - monitor->optimal_count;
+-
++
+ monitor->optimal_count = optimal_count;
+ while(extra-- > 0)
+ {
+ globus_byte_t * buffer;
+-
++
+ buffer = globus_memory_pop_node(&monitor->mem);
+ result = globus_gridftp_server_register_read(
+ monitor->op,
+@@ -2590,11 +2590,11 @@ globus_l_gfs_file_update_concurrency(
+ "globus_gridftp_server_register_read", result);
+ goto error_register;
+ }
+-
++
+ monitor->pending_reads++;
+ }
+ }
+-
++
+ GlobusGFSFileDebugExit();
+ return;
+
+@@ -2618,9 +2618,9 @@ globus_l_gfs_file_server_read_cb(
+ int rc;
+ GlobusGFSName(globus_l_gfs_file_server_read_cb);
+ GlobusGFSFileDebugEnter();
+-
++
+ monitor = (globus_l_file_monitor_t *) user_arg;
+-
++
+ globus_mutex_lock(&monitor->lock);
+ {
+ monitor->pending_reads--;
+@@ -2632,20 +2632,20 @@ globus_l_gfs_file_server_read_cb(
+ {
+ goto error;
+ }
+-
++
+ if(eof)
+ {
+ monitor->eof = GLOBUS_TRUE;
+ }
+-
+- buf_info = (globus_l_buffer_info_t *)
++
++ buf_info = (globus_l_buffer_info_t *)
+ globus_malloc(sizeof(globus_l_buffer_info_t));
+ if(!buf_info)
+ {
+ monitor->error = GlobusGFSErrorObjMemory("buf_info");
+ goto error_alloc;
+ }
+-
++
+ /* XXX offset may need some interpretation here depending on type of
+ * transfer (may need to remember original start offset)
+ */
+@@ -2656,8 +2656,8 @@ globus_l_gfs_file_server_read_cb(
+ if(monitor->concurrency_check == 0 && !eof)
+ {
+ globus_l_gfs_file_update_concurrency(monitor);
+- }
+-
++ }
++
+ rc = globus_priority_q_enqueue(
+ &monitor->queue, buf_info, buf_info);
+ if(rc != GLOBUS_SUCCESS)
+@@ -2677,15 +2677,15 @@ globus_l_gfs_file_server_read_cb(
+
+ }
+ globus_mutex_unlock(&monitor->lock);
+-
++
+ GlobusGFSFileDebugExit();
+ return;
+-
++
+ error_enqueue:
+ error_dispatch:
+ /* can't free buf_info, its in queue */
+ globus_free(buf_info);
+-
++
+ error_alloc:
+ error:
+ globus_memory_push_node(&monitor->mem, buffer);
+@@ -2713,7 +2713,7 @@ globus_l_gfs_file_open_write_cb(
+ globus_l_file_monitor_t * monitor;
+ GlobusGFSName(globus_l_gfs_file_open_write_cb);
+ GlobusGFSFileDebugEnter();
+-
++
+ monitor = (globus_l_file_monitor_t *) user_arg;
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -2725,18 +2725,18 @@ globus_l_gfs_file_open_write_cb(
+
+ globus_gridftp_server_begin_transfer(
+ monitor->op, GLOBUS_GFS_EVENT_TRANSFER_ABORT, monitor);
+-
++
+ globus_mutex_lock(&monitor->lock);
+ {
+ int optimal_count;
+ globus_size_t block_size;
+-
++
+ optimal_count = monitor->optimal_count;
+ block_size = monitor->block_size;
+ while(optimal_count--)
+ {
+ globus_byte_t * buffer;
+-
++
+ buffer = globus_memory_pop_node(&monitor->mem);
+ result = globus_gridftp_server_register_read(
+ monitor->op,
+@@ -2751,12 +2751,12 @@ globus_l_gfs_file_open_write_cb(
+ "globus_gridftp_server_register_read", result);
+ goto error_register;
+ }
+-
++
+ monitor->pending_reads++;
+ }
+ }
+ globus_mutex_unlock(&monitor->lock);
+-
++
+ GlobusGFSFileDebugExit();
+ return;
+
+@@ -2785,7 +2785,7 @@ globus_l_gfs_file_open_read_cb(
+ globus_xio_handle_t handle,
+ globus_result_t result,
+ void * user_arg);
+-
++
+ static
+ globus_result_t
+ globus_l_gfs_file_open(
+@@ -2804,7 +2804,7 @@ globus_l_gfs_file_open(
+ GlobusGFSFileDebugEnter();
+
+ monitor = (globus_l_file_monitor_t *) arg;
+-
++
+ result = globus_xio_attr_init(&attr);
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -2816,7 +2816,7 @@ globus_l_gfs_file_open(
+ if(globus_gfs_config_get_bool("direct_io"))
+ {
+ open_flags |= O_DIRECT;
+- }
++ }
+ #endif
+
+ result = globus_xio_attr_cntl(
+@@ -2836,9 +2836,9 @@ globus_l_gfs_file_open(
+ if(perms != NULL)
+ {
+ int p = 0;
+-
++
+ p = strtoul(perms, NULL, 8);
+- if(p > 0 ||
++ if(p > 0 ||
+ (perms[0] == '0' && perms[1] == '\0'))
+ {
+ result = globus_xio_attr_cntl(
+@@ -2879,12 +2879,12 @@ globus_l_gfs_file_open(
+ {
+ globus_gfs_log_message(
+ GLOBUS_GFS_LOG_WARN,
+- "Unable to set file access timeout of %d seconds\n",
++ "Unable to set file access timeout of %d seconds\n",
+ timeout);
+ }
+ }
+-
+-
++
++
+ result = globus_xio_stack_init(&stack, NULL);
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -2904,13 +2904,13 @@ globus_l_gfs_file_open(
+ result = GlobusGFSErrorWrapFailed("globus_xio_handle_create", result);
+ goto error_create;
+ }
+-
++
+ result = globus_xio_register_open(
+ *file_handle,
+ pathname,
+ attr,
+- (open_flags & GLOBUS_XIO_FILE_CREAT) ?
+- globus_l_gfs_file_open_write_cb :
++ (open_flags & GLOBUS_XIO_FILE_CREAT) ?
++ globus_l_gfs_file_open_write_cb :
+ globus_l_gfs_file_open_read_cb,
+ arg);
+ if(result != GLOBUS_SUCCESS)
+@@ -2918,11 +2918,11 @@ globus_l_gfs_file_open(
+ result = GlobusGFSErrorWrapFailed("globus_xio_register_open", result);
+ goto error_register;
+ }
+-
+-
++
++
+ globus_xio_attr_destroy(attr);
+ globus_xio_stack_destroy(stack);
+-
++
+ GlobusGFSFileDebugExit();
+ return GLOBUS_SUCCESS;
+
+@@ -2932,11 +2932,11 @@ error_register:
+ error_create:
+ error_push:
+ globus_xio_stack_destroy(stack);
+-
++
+ error_stack:
+-error_cntl:
++error_cntl:
+ globus_xio_attr_destroy(attr);
+-
++
+ error_attr:
+ GlobusGFSFileDebugExitWithError();
+ return result;
+@@ -2972,7 +2972,7 @@ globus_l_gfs_file_recv(
+ goto error_alloc;
+ }
+ monitor->session = (gfs_l_file_session_t *) user_arg;
+-
++
+ globus_gridftp_server_get_write_range(
+ op,
+ &offset,
+@@ -2987,29 +2987,29 @@ globus_l_gfs_file_recv(
+ "globus_gridftp_server_get_recv_modification_time", result);
+ goto error_alloc;
+ }
+-
++
+ monitor->op = op;
+ monitor->pathname = globus_libc_strdup(transfer_info->pathname);
+-
+- open_flags = GLOBUS_XIO_FILE_BINARY |
+- GLOBUS_XIO_FILE_CREAT |
++
++ open_flags = GLOBUS_XIO_FILE_BINARY |
++ GLOBUS_XIO_FILE_CREAT |
+ GLOBUS_XIO_FILE_WRONLY;
+ if(transfer_info->truncate)
+ {
+ open_flags |= GLOBUS_XIO_FILE_TRUNC;
+ }
+-
++
+ if(transfer_info->expected_checksum)
+ {
+- monitor->expected_cksm =
++ monitor->expected_cksm =
+ globus_libc_strdup(transfer_info->expected_checksum);
+ }
+ if(transfer_info->expected_checksum_alg)
+ {
+- monitor->expected_cksm_alg =
++ monitor->expected_cksm_alg =
+ globus_libc_strdup(transfer_info->expected_checksum_alg);
+ }
+-
++
+ result = globus_l_gfs_file_open(
+ &monitor->file_handle, transfer_info->pathname, open_flags, monitor);
+ if(result != GLOBUS_SUCCESS)
+@@ -3017,13 +3017,13 @@ globus_l_gfs_file_recv(
+ result = GlobusGFSErrorWrapFailed("globus_l_gfs_file_open", result);
+ goto error_open;
+ }
+-
++
+ GlobusGFSFileDebugExit();
+ return;
+
+ error_open:
+ globus_l_gfs_file_monitor_destroy(monitor);
+-
++
+ error_alloc:
+ globus_gridftp_server_finished_transfer(op, result);
+
+@@ -3037,14 +3037,14 @@ error_alloc:
+ static
+ void
+ globus_l_gfs_file_read_cb(
+- globus_xio_handle_t xio_handle,
++ globus_xio_handle_t xio_handle,
+ globus_result_t result,
+ globus_byte_t * buffer,
+ globus_size_t len,
+- globus_size_t nbytes,
++ globus_size_t nbytes,
+ globus_xio_data_descriptor_t data_desc,
+ void * user_arg);
+-
++
+ /* called LOCKED */
+ static
+ globus_result_t
+@@ -3056,8 +3056,8 @@ globus_l_gfs_file_dispatch_read(
+ globus_size_t read_length;
+ GlobusGFSName(globus_l_gfs_file_dispatch_read);
+ GlobusGFSFileDebugEnter();
+-
+- if(monitor->first_read && monitor->pending_reads == 0 &&
++
++ if(monitor->first_read && monitor->pending_reads == 0 &&
+ !monitor->eof && !globus_list_empty(monitor->buffer_list) &&
+ !monitor->aborted)
+ {
+@@ -3070,19 +3070,19 @@ globus_l_gfs_file_dispatch_read(
+ monitor->eof = GLOBUS_TRUE;
+ }
+ else
+- {
++ {
+ if (monitor->file_offset != monitor->read_offset)
+ {
+ globus_off_t seek_tmp;
+ seek_tmp = monitor->read_offset;
+-
++
+ result = globus_xio_handle_cntl(
+ monitor->file_handle,
+ GLOBUS_XIO_QUERY,
+ GLOBUS_XIO_SEEK,
+ seek_tmp,
+ GLOBUS_XIO_FILE_SEEK_SET);
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ result = GlobusGFSErrorWrapFailed(
+@@ -3091,19 +3091,19 @@ globus_l_gfs_file_dispatch_read(
+ }
+ monitor->file_offset = monitor->read_offset;
+ }
+-
++
+ }
+ monitor->first_read = GLOBUS_FALSE;
+- }
++ }
+
+- if(monitor->pending_reads == 0 && !monitor->eof &&
++ if(monitor->pending_reads == 0 && !monitor->eof &&
+ !globus_list_empty(monitor->buffer_list) && !monitor->aborted)
+ {
+ buffer = globus_list_remove(
+ &monitor->buffer_list, monitor->buffer_list);
+ globus_assert(buffer);
+-
+- if(monitor->read_length != -1 &&
++
++ if(monitor->read_length != -1 &&
+ monitor->block_size > monitor->read_length)
+ {
+ read_length = monitor->read_length;
+@@ -3112,7 +3112,7 @@ globus_l_gfs_file_dispatch_read(
+ {
+ read_length = monitor->block_size;
+ }
+-
++
+ result = globus_xio_register_read(
+ monitor->file_handle,
+ buffer,
+@@ -3128,10 +3128,10 @@ globus_l_gfs_file_dispatch_read(
+ "globus_xio_register_read", result);
+ goto error_register;
+ }
+-
++
+ monitor->pending_reads++;
+ }
+-
++
+ GlobusGFSFileDebugExit();
+ return GLOBUS_SUCCESS;
+
+@@ -3153,11 +3153,11 @@ globus_l_gfs_file_server_write_cb(
+ globus_l_file_monitor_t * monitor;
+ GlobusGFSName(globus_l_gfs_file_server_write_cb);
+ GlobusGFSFileDebugEnter();
+-
++
+ monitor = (globus_l_file_monitor_t *) user_arg;
+-
++
+ globus_mutex_lock(&monitor->lock);
+- {
++ {
+ monitor->pending_writes--;
+ globus_list_insert(&monitor->buffer_list, buffer);
+
+@@ -3169,7 +3169,7 @@ globus_l_gfs_file_server_write_cb(
+ {
+ goto error;
+ }
+-
++
+ result = globus_l_gfs_file_dispatch_read(monitor);
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -3177,7 +3177,7 @@ globus_l_gfs_file_server_write_cb(
+ "globus_l_gfs_file_dispatch_read", result);
+ goto error;
+ }
+-
++
+ if(monitor->pending_reads == 0 && monitor->pending_writes == 0)
+ {
+ globus_assert(monitor->eof || monitor->aborted);
+@@ -3190,7 +3190,7 @@ globus_l_gfs_file_server_write_cb(
+ }
+ }
+ /* already unlocked */
+-
++
+ GlobusGFSFileDebugExit();
+ return;
+
+@@ -3199,7 +3199,7 @@ error:
+ {
+ /* there are still outstanding callbacks, wait for them */
+ globus_mutex_unlock(&monitor->lock);
+-
++
+ GlobusGFSFileDebugExitWithError();
+ return;
+ }
+@@ -3212,20 +3212,20 @@ error:
+ static
+ void
+ globus_l_gfs_file_read_cb(
+- globus_xio_handle_t xio_handle,
++ globus_xio_handle_t xio_handle,
+ globus_result_t result,
+ globus_byte_t * buffer,
+ globus_size_t len,
+- globus_size_t nbytes,
++ globus_size_t nbytes,
+ globus_xio_data_descriptor_t data_desc,
+ void * user_arg)
+ {
+ globus_l_file_monitor_t * monitor;
+ GlobusGFSName(globus_l_gfs_file_read_cb);
+ GlobusGFSFileDebugEnter();
+-
++
+ monitor = (globus_l_file_monitor_t *) user_arg;
+-
++
+ globus_mutex_lock(&monitor->lock);
+ {
+ monitor->pending_reads--;
+@@ -3246,7 +3246,7 @@ globus_l_gfs_file_read_cb(
+ globus_list_insert(&monitor->buffer_list, buffer);
+ goto error;
+ }
+-
++
+ if(nbytes > 0)
+ {
+ result = globus_gridftp_server_register_write(
+@@ -3264,7 +3264,7 @@ globus_l_gfs_file_read_cb(
+ "globus_gridftp_server_register_write", result);
+ goto error;
+ }
+-
++
+ monitor->pending_writes++;
+ monitor->file_offset += nbytes;
+ if(monitor->read_length != -1)
+@@ -3276,12 +3276,12 @@ globus_l_gfs_file_read_cb(
+ {
+ globus_list_insert(&monitor->buffer_list, buffer);
+ }
+-
++
+ if(monitor->read_length == 0)
+ {
+ monitor->first_read = GLOBUS_TRUE;
+ }
+-
++
+ result = globus_l_gfs_file_dispatch_read(monitor);
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -3289,7 +3289,7 @@ globus_l_gfs_file_read_cb(
+ "globus_l_gfs_file_dispatch_read", result);
+ goto error;
+ }
+-
++
+ if(monitor->pending_reads == 0 && monitor->pending_writes == 0)
+ {
+ globus_assert(monitor->eof || monitor->aborted);
+@@ -3312,7 +3312,7 @@ error:
+ {
+ /* there are still outstanding callbacks, wait for them */
+ globus_mutex_unlock(&monitor->lock);
+-
++
+ GlobusGFSFileDebugExitWithError();
+ return;
+ }
+@@ -3332,7 +3332,7 @@ globus_l_gfs_file_open_read_cb(
+ globus_l_file_monitor_t * monitor;
+ GlobusGFSName(globus_l_gfs_file_open_read_cb);
+ GlobusGFSFileDebugEnter();
+-
++
+ monitor = (globus_l_file_monitor_t *) user_arg;
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -3341,10 +3341,10 @@ globus_l_gfs_file_open_read_cb(
+ monitor->file_handle = NULL;
+ goto error_open;
+ }
+-
++
+ globus_gridftp_server_begin_transfer(
+ monitor->op, GLOBUS_GFS_EVENT_TRANSFER_ABORT, monitor);
+-
++
+ globus_mutex_lock(&monitor->lock);
+ monitor->first_read = GLOBUS_TRUE;
+ result = globus_l_gfs_file_dispatch_read(monitor);
+@@ -3354,7 +3354,7 @@ globus_l_gfs_file_open_read_cb(
+ "globus_l_gfs_file_dispatch_read", result);
+ goto error_dispatch;
+ }
+-
++
+ if(monitor->pending_reads == 0 && monitor->pending_writes == 0)
+ {
+ globus_assert(monitor->eof || monitor->aborted);
+@@ -3366,7 +3366,7 @@ globus_l_gfs_file_open_read_cb(
+ {
+ globus_mutex_unlock(&monitor->lock);
+ }
+-
++
+ GlobusGFSFileDebugExit();
+ return;
+
+@@ -3394,11 +3394,11 @@ globus_l_gfs_file_send(
+ globus_xio_file_flag_t open_flags;
+ GlobusGFSName(globus_l_gfs_file_send);
+ GlobusGFSFileDebugEnter();
+-
++
+ globus_gridftp_server_get_optimal_concurrency(op, &optimal_count);
+ globus_gridftp_server_get_block_size(op, &block_size);
+ globus_assert(optimal_count > 0 && block_size > 0);
+-
++
+ result = globus_l_gfs_file_monitor_init(
+ &monitor, block_size, optimal_count);
+ if(result != GLOBUS_SUCCESS)
+@@ -3407,7 +3407,7 @@ globus_l_gfs_file_send(
+ "globus_l_gfs_file_monitor_init", result);
+ goto error_alloc;
+ }
+-
++
+ while(optimal_count--)
+ {
+ globus_byte_t * buffer;
+@@ -3428,14 +3428,14 @@ globus_l_gfs_file_send(
+ result = GlobusGFSErrorWrapFailed("globus_l_gfs_file_open", result);
+ goto error_open;
+ }
+-
++
+ GlobusGFSFileDebugExit();
+ return;
+
+ error_open:
+ globus_l_gfs_file_monitor_destroy(monitor);
+-
+-error_alloc:
++
++error_alloc:
+ globus_gridftp_server_finished_transfer(op, result);
+
+ GlobusGFSFileDebugExitWithError();
+@@ -3450,7 +3450,7 @@ globus_l_gfs_file_event(
+ globus_l_file_monitor_t * monitor;
+ GlobusGFSName(globus_l_gfs_file_event);
+ GlobusGFSFileDebugEnter();
+-
++
+ monitor = (globus_l_file_monitor_t *) event_info->event_arg;
+
+ switch(event_info->type)
+@@ -3461,18 +3461,18 @@ globus_l_gfs_file_event(
+ monitor->aborted = GLOBUS_TRUE;
+ }
+ globus_mutex_unlock(&monitor->lock);
+-
++
+ globus_xio_handle_cancel_operations(
+ monitor->file_handle,
+- GLOBUS_XIO_CANCEL_OPEN |
++ GLOBUS_XIO_CANCEL_OPEN |
+ GLOBUS_XIO_CANCEL_READ |
+ GLOBUS_XIO_CANCEL_WRITE);
+ break;
+-
++
+ default:
+ break;
+ }
+-
++
+ GlobusGFSFileDebugExit();
+ }
+
+@@ -3540,7 +3540,7 @@ static
+ int
+ globus_l_gfs_file_deactivate(void);
+
+-static globus_gfs_storage_iface_t globus_l_gfs_file_dsi_iface =
++static globus_gfs_storage_iface_t globus_l_gfs_file_dsi_iface =
+ {
+ GLOBUS_GFS_DSI_DESCRIPTOR_SENDER | GLOBUS_GFS_DSI_DESCRIPTOR_HAS_REALPATH,
+ globus_l_gfs_file_init,
+@@ -3552,7 +3552,7 @@ static globus_gfs_storage_iface_t globus_l_gfs_file_dsi_iface =
+ NULL, /* active */
+ NULL, /* passive */
+ NULL, /* data destroy */
+- globus_l_gfs_file_command,
++ globus_l_gfs_file_command,
+ globus_l_gfs_file_stat,
+ NULL,
+ NULL,
+@@ -3577,13 +3577,13 @@ globus_l_gfs_file_activate(void)
+ {
+ goto error_activate;
+ }
+-
++
+ if(globus_xio_driver_load(
+ "file", &globus_l_gfs_file_driver) != GLOBUS_SUCCESS)
+ {
+ goto error_load_file;
+ }
+-
++
+ globus_extension_registry_add(
+ GLOBUS_GFS_DSI_REGISTRY,
+ "file",
+@@ -3592,12 +3592,12 @@ globus_l_gfs_file_activate(void)
+
+ GlobusDebugInit(GLOBUS_GRIDFTP_SERVER_FILE,
+ ERROR WARNING TRACE INTERNAL_TRACE INFO STATE INFO_VERBOSE);
+-
++
+ return GLOBUS_SUCCESS;
+-
++
+ error_load_file:
+ globus_module_deactivate(GLOBUS_XIO_MODULE);
+-
++
+ error_activate:
+ return GLOBUS_FAILURE;
+ }
+@@ -3608,8 +3608,8 @@ globus_l_gfs_file_deactivate(void)
+ {
+ globus_extension_registry_remove(
+ GLOBUS_GFS_DSI_REGISTRY, "file");
+-
++
+ globus_xio_driver_unload(globus_l_gfs_file_driver);
+-
++
+ return globus_module_deactivate(GLOBUS_XIO_MODULE);
+ }
+diff --git a/gridftp/server/src/modules/remote/globus_gridftp_server_remote.c b/gridftp/server/src/modules/remote/globus_gridftp_server_remote.c
+index 99721dda2..324f8f585 100644
+--- a/gridftp/server/src/modules/remote/globus_gridftp_server_remote.c
++++ b/gridftp/server/src/modules/remote/globus_gridftp_server_remote.c
+@@ -22,18 +22,18 @@ GlobusDebugDeclare(GLOBUS_GRIDFTP_SERVER_REMOTE);
+ #define BRAIN_RETRY 256
+
+ #define GlobusGFSRemoteDebugPrintf(level, message) \
+- GlobusDebugPrintf(GLOBUS_GRIDFTP_SERVER_REMOTE, level, message)
+-
++ GlobusDebugPrintf(GLOBUS_GRIDFTP_SERVER_REMOTE, level, message)
++
+ #define GlobusGFSRemoteDebugEnter() \
+ GlobusGFSRemoteDebugPrintf( \
+ GLOBUS_GFS_DEBUG_TRACE, \
+- ("[%s] Entering\n", _gfs_name))
+-
++ ("[%s] Entering\n", _gfs_name))
++
+ #define GlobusGFSRemoteDebugExit() \
+ GlobusGFSRemoteDebugPrintf( \
+ GLOBUS_GFS_DEBUG_TRACE, \
+- ("[%s] Exiting\n", _gfs_name))
+-
++ ("[%s] Exiting\n", _gfs_name))
++
+ #define GlobusGFSRemoteDebugExitWithError() \
+ GlobusGFSRemoteDebugPrintf( \
+ GLOBUS_GFS_DEBUG_TRACE, \
+@@ -71,7 +71,7 @@ typedef struct globus_l_gfs_remote_ipc_bounce_s
+ int begin_event_pending;
+ int event_pending;
+ int * eof_count;
+- globus_l_gfs_remote_node_handle_t * node_handle;
++ globus_l_gfs_remote_node_handle_t * node_handle;
+ int partial_eof_counts;
+ globus_bool_t recv_pending;
+ int nodes_requesting;
+@@ -93,7 +93,7 @@ typedef void
+ typedef struct globus_l_gfs_remote_node_info_s
+ {
+ globus_gfs_ipc_handle_t ipc_handle;
+- globus_l_gfs_remote_node_handle_t * node_handle;
++ globus_l_gfs_remote_node_handle_t * node_handle;
+ struct globus_l_gfs_remote_ipc_bounce_s * bounce;
+ char * cs;
+ void * data_arg;
+@@ -127,7 +127,7 @@ typedef enum
+ GLOBUS_L_GFS_REMOTE_STRIPED_ONE_TO_ONE = 1,
+ GLOBUS_L_GFS_REMOTE_STRIPED_ALL_TO_ALL
+ } globus_l_gfs_remote_striped_mode_t;
+-
++
+ typedef struct globus_l_gfs_remote_control_node_bounce_s
+ {
+ globus_l_gfs_remote_handle_t * my_handle;
+@@ -156,7 +156,7 @@ do \
+ _op, \
+ _result, \
+ &_finished_info); \
+-} while(0)
++} while(0)
+
+ static
+ void
+@@ -176,7 +176,7 @@ globus_l_gfs_remote_node_release(
+ {
+ GlobusGFSName(globus_l_gfs_remote_node_release);
+ GlobusGFSRemoteDebugEnter();
+-
++
+ if(node_info->my_handle->control_node != node_info)
+ {
+ globus_gfs_brain_release_node(
+@@ -200,7 +200,7 @@ globus_l_gfs_remote_node_release(
+
+ GlobusGFSRemoteDebugExit();
+ return GLOBUS_SUCCESS;
+-}
++}
+
+ static
+ void
+@@ -233,7 +233,7 @@ globus_l_gfs_remote_node_request_kickout(
+ globus_l_gfs_remote_node_info_t * node_info;
+ GlobusGFSName(globus_l_gfs_remote_node_request_kickout);
+ GlobusGFSRemoteDebugEnter();
+-
++
+ node_info = (globus_l_gfs_remote_node_info_t *) user_arg;
+
+ /* LOCKS! */
+@@ -269,7 +269,7 @@ globus_l_gfs_remote_node_request_kickout(
+ int cs_len = 1;
+ globus_i_gfs_brain_node_t ** brain_node_array;
+ globus_gfs_log_result(
+- GLOBUS_GFS_LOG_WARN,
++ GLOBUS_GFS_LOG_WARN,
+ "could not get initially requested node, trying another",
+ result);
+ /* select a new set of nodes */
+@@ -302,13 +302,13 @@ globus_l_gfs_remote_node_request_kickout(
+ {
+ callback = GLOBUS_TRUE;
+ }
+- globus_free(brain_node_array);
++ globus_free(brain_node_array);
+ }
+ }
+ }
+
+ if(callback)
+- {
++ {
+ node_info->callback(
+ node_info,
+ result,
+@@ -347,16 +347,16 @@ globus_l_gfs_remote_node_request_fake_kickout(
+ globus_l_gfs_remote_control_node_bounce_t * bounce;
+ GlobusGFSName(globus_l_gfs_remote_node_request_fake_kickout);
+ GlobusGFSRemoteDebugEnter();
+-
++
+ bounce = (globus_l_gfs_remote_control_node_bounce_t *) user_arg;
+-
++
+ bounce->callback(
+ bounce->my_handle->control_node,
+ GLOBUS_SUCCESS,
+ bounce->user_arg);
+
+ globus_free(bounce);
+-
++
+ GlobusGFSRemoteDebugExit();
+ }
+
+@@ -465,7 +465,7 @@ globus_l_gfs_remote_select_nodes(
+ node_info->user_arg = user_arg;
+ node_info->my_handle = my_handle;
+ bounce->ndx_offset++;
+-
++
+ my_handle->session_info.host_id = node_info->brain_node->host_id;
+ result = globus_gfs_ipc_handle_obtain(
+ &my_handle->session_info,
+@@ -497,7 +497,7 @@ globus_l_gfs_remote_select_nodes(
+
+
+ static
+-globus_result_t
++globus_result_t
+ globus_l_gfs_remote_node_request(
+ globus_l_gfs_remote_handle_t * my_handle,
+ int num_nodes,
+@@ -527,7 +527,7 @@ globus_l_gfs_remote_node_request(
+
+ nodes_created = 1;
+ ndx_offset = 1;
+-
++
+ result = globus_callback_register_oneshot(
+ NULL,
+ NULL,
+@@ -540,9 +540,9 @@ globus_l_gfs_remote_node_request(
+ }
+ }
+ num_nodes -= nodes_created;
+-
++
+ if(num_nodes > 0 || nodes_created == 0)
+- {
++ {
+ bounce = (globus_l_gfs_remote_control_node_bounce_t *) globus_calloc(
+ 1, sizeof(globus_l_gfs_remote_control_node_bounce_t));
+ bounce->my_handle = my_handle;
+@@ -562,7 +562,7 @@ globus_l_gfs_remote_node_request(
+ error:
+ GlobusGFSRemoteDebugExitWithError();
+ return result;
+-}
++}
+
+ static
+ void
+@@ -575,7 +575,7 @@ globus_l_gfs_ipc_finished_cb(
+ globus_l_gfs_remote_ipc_bounce_t * bounce_info;
+ GlobusGFSName(globus_l_gfs_ipc_finished_cb);
+ GlobusGFSRemoteDebugEnter();
+-
++
+ bounce_info = (globus_l_gfs_remote_ipc_bounce_t *) user_arg;
+
+ globus_gridftp_server_operation_finished(
+@@ -609,7 +609,7 @@ globus_l_gfs_ipc_passive_cb(
+ GlobusGFSName(globus_l_gfs_ipc_passive_cb);
+ GlobusGFSRemoteDebugEnter();
+
+- node_info = (globus_l_gfs_remote_node_info_t *) user_arg;
++ node_info = (globus_l_gfs_remote_node_info_t *) user_arg;
+ bounce_info = node_info->bounce;
+ my_handle = bounce_info->my_handle;
+
+@@ -618,7 +618,7 @@ globus_l_gfs_ipc_passive_cb(
+ bounce_info->cached_result = reply->result;
+ }
+ else
+- {
++ {
+ /* XXX this is suspect if we chain DSIs another step */
+ node_info->cs = globus_libc_strdup(
+ reply->info.data.contact_strings[0]);
+@@ -633,7 +633,7 @@ globus_l_gfs_ipc_passive_cb(
+ bounce_info->nodes_obtained++;
+ }
+
+- /* if we got 'em all */
++ /* if we got 'em all */
+ if(!bounce_info->nodes_pending && !bounce_info->nodes_requesting)
+ {
+ globus_l_gfs_remote_node_info_t ** node_array;
+@@ -644,10 +644,10 @@ globus_l_gfs_ipc_passive_cb(
+ {
+ goto error;
+ }
+-
++
+ memcpy(&finished_info, reply, sizeof(globus_gfs_finished_info_t));
+
+- finished_info.info.data.data_arg = bounce_info->node_handle;
++ finished_info.info.data.data_arg = bounce_info->node_handle;
+ finished_info.info.data.cs_count = bounce_info->nodes_obtained;
+
+ /* gotta do some smushin' */
+@@ -659,27 +659,27 @@ globus_l_gfs_ipc_passive_cb(
+ finished_info.info.data.cs_count);
+ for(i = 0; i < bounce_info->node_handle->count; i++)
+ {
+- node_info = (globus_l_gfs_remote_node_info_t *)
++ node_info = (globus_l_gfs_remote_node_info_t *)
+ bounce_info->node_handle->nodes[i];
+ if(node_info != NULL)
+ {
+- if(bounce_info->my_handle->striped_mode ==
++ if(bounce_info->my_handle->striped_mode ==
+ GLOBUS_L_GFS_REMOTE_STRIPED_ONE_TO_ONE)
+ {
+ node_info->stripe_count = 1;
+ }
+ else
+ {
+- node_info->stripe_count =
++ node_info->stripe_count =
+ finished_info.info.data.cs_count;
+ }
+
+ /* XXX handle case where cs_count from a single node > 1 */
+ node_array[ndx] = node_info;
+- finished_info.info.data.contact_strings[ndx] =
++ finished_info.info.data.contact_strings[ndx] =
+ node_info->cs;
+ node_info->cs = NULL;
+-
++
+ if(node_info->info && node_info->info_needs_free)
+ {
+ globus_free(node_info->info);
+@@ -696,7 +696,7 @@ globus_l_gfs_ipc_passive_cb(
+ }
+ }
+ globus_mutex_unlock(&my_handle->mutex);
+-
++
+
+ if(finished)
+ {
+@@ -709,12 +709,12 @@ globus_l_gfs_ipc_passive_cb(
+ for(ndx = 0; ndx < finished_info.info.data.cs_count; ndx++)
+ {
+ globus_free((void *) finished_info.info.data.contact_strings[ndx]);
+- }
++ }
+ globus_free(finished_info.info.data.contact_strings);
+-
++
+ globus_free(bounce_info);
+ }
+-
++
+ GlobusGFSRemoteDebugExit();
+ return;
+ error:
+@@ -743,19 +743,19 @@ globus_l_gfs_ipc_active_cb(
+
+ GlobusGFSRemoteDebugEnter();
+
+- node_info = (globus_l_gfs_remote_node_info_t *) user_arg;
++ node_info = (globus_l_gfs_remote_node_info_t *) user_arg;
+ bounce_info = node_info->bounce;
+ node_info->data_arg = reply->info.data.data_arg;
+ my_handle = bounce_info->my_handle;
+
+- if(bounce_info->my_handle->striped_mode ==
++ if(bounce_info->my_handle->striped_mode ==
+ GLOBUS_L_GFS_REMOTE_STRIPED_ONE_TO_ONE)
+ {
+ node_info->stripe_count = 1;
+ }
+ else
+ {
+- node_info->stripe_count =
++ node_info->stripe_count =
+ ((globus_gfs_data_info_t *) bounce_info->state)->cs_count;
+ }
+
+@@ -766,7 +766,7 @@ globus_l_gfs_ipc_active_cb(
+ {
+ bounce_info->nodes_obtained++;
+ }
+- /* in the failure case it is just an unobtained node, if we
++ /* in the failure case it is just an unobtained node, if we
+ got 0 it will be an error */
+
+ /* if this is the last one */
+@@ -774,7 +774,7 @@ globus_l_gfs_ipc_active_cb(
+ && bounce_info->nodes_requesting == 0)
+ {
+ finished = GLOBUS_TRUE;
+-
++
+ /* if we failed to get any succesfully */
+ if(bounce_info->nodes_obtained == 0)
+ {
+@@ -801,7 +801,7 @@ globus_l_gfs_ipc_active_cb(
+ globus_free(node_info->info);
+ node_info->info = NULL;
+ node_info->info_needs_free = GLOBUS_FALSE;
+- }
++ }
+ }
+ }
+ }
+@@ -813,7 +813,7 @@ globus_l_gfs_ipc_active_cb(
+ globus_gridftp_server_operation_finished(
+ bounce_info->op,
+ finished_info.result,
+- &finished_info);
++ &finished_info);
+
+ globus_free(bounce_info);
+ }
+@@ -849,7 +849,7 @@ globus_l_gfs_ipc_transfer_cb(
+ node_info = (globus_l_gfs_remote_node_info_t *) user_arg;
+ bounce_info = node_info->bounce;
+ my_handle = bounce_info->my_handle;
+-
++
+ globus_mutex_lock(&my_handle->mutex);
+ {
+ bounce_info->nodes_pending--;
+@@ -857,13 +857,13 @@ globus_l_gfs_ipc_transfer_cb(
+ {
+ bounce_info->cached_result = reply->result;
+ }
+-
++
+ /* wait for all the nodes to return, or if recving and we get an error
+- before the first begin_cb we quit right now */
+- if((!bounce_info->nodes_pending && !bounce_info->nodes_requesting) ||
++ before the first begin_cb we quit right now */
++ if((!bounce_info->nodes_pending && !bounce_info->nodes_requesting) ||
+ (bounce_info->cached_result != GLOBUS_SUCCESS &&
+ bounce_info->recv_pending))
+- {
++ {
+ memset(&finished_info, '\0', sizeof(globus_gfs_finished_info_t));
+ finished_info.type = reply->type;
+ finished_info.id = reply->id;
+@@ -872,15 +872,15 @@ globus_l_gfs_ipc_transfer_cb(
+ finished_info.result = bounce_info->cached_result;
+ finish = GLOBUS_TRUE;
+ op = bounce_info->op;
+-
++
+ if(!bounce_info->events_enabled)
+ {
+ globus_l_gfs_remote_node_info_t * node_info;
+-
++
+ for(i = 0; i < bounce_info->node_handle->count; i++)
+ {
+ node_info = bounce_info->node_handle->nodes[i];
+-
++
+ if(node_info->info && node_info->info_needs_free)
+ {
+ globus_free(node_info->info);
+@@ -893,17 +893,17 @@ globus_l_gfs_ipc_transfer_cb(
+ globus_free(bounce_info->eof_count);
+ }
+ globus_free(bounce_info);
+- }
++ }
+ }
+ }
+ globus_mutex_unlock(&my_handle->mutex);
+-
++
+ if(finish)
+ {
+ globus_gridftp_server_operation_finished(
+ op,
+ finished_info.result,
+- &finished_info);
++ &finished_info);
+ }
+
+ GlobusGFSRemoteDebugExit();
+@@ -930,8 +930,8 @@ globus_l_gfs_ipc_event_cb(
+ int ctr;
+ GlobusGFSName(globus_l_gfs_ipc_event_cb);
+ GlobusGFSRemoteDebugEnter();
+-
+- node_info = (globus_l_gfs_remote_node_info_t *) user_arg;
++
++ node_info = (globus_l_gfs_remote_node_info_t *) user_arg;
+ bounce_info = node_info->bounce;
+ my_handle = bounce_info->my_handle;
+
+@@ -954,12 +954,12 @@ globus_l_gfs_ipc_event_cb(
+ {
+ bounce_info->events_enabled = GLOBUS_TRUE;
+ reply->event_arg = bounce_info;
+- reply->event_mask =
+- GLOBUS_GFS_EVENT_TRANSFER_ABORT |
++ reply->event_mask =
++ GLOBUS_GFS_EVENT_TRANSFER_ABORT |
+ GLOBUS_GFS_EVENT_TRANSFER_COMPLETE |
+ GLOBUS_GFS_EVENT_BYTES_RECVD |
+ GLOBUS_GFS_EVENT_RANGES_RECVD;
+-
++
+ globus_gridftp_server_operation_event(
+ bounce_info->op,
+ GLOBUS_SUCCESS,
+@@ -969,7 +969,7 @@ globus_l_gfs_ipc_event_cb(
+ break;
+ case GLOBUS_GFS_EVENT_TRANSFER_CONNECTED:
+ bounce_info->event_pending--;
+- if(!bounce_info->event_pending &&
++ if(!bounce_info->event_pending &&
+ !bounce_info->recv_pending &&
+ !bounce_info->nodes_requesting)
+ {
+@@ -982,7 +982,7 @@ globus_l_gfs_ipc_event_cb(
+ {
+ node_info = bounce_info->node_handle->nodes[i];
+ info = (globus_gfs_transfer_info_t *) node_info->info;
+-
++
+ if(node_info->ipc_handle == ipc_handle)
+ {
+ globus_assert(
+@@ -996,11 +996,11 @@ globus_l_gfs_ipc_event_cb(
+ }
+ }
+ for(ctr = 0; ctr < reply->node_count; ctr++)
+- {
++ {
+ bounce_info->eof_count[ctr] += reply->eof_count[ctr];
+ }
+ bounce_info->partial_eof_counts++;
+- if(bounce_info->partial_eof_counts + 1 ==
++ if(bounce_info->partial_eof_counts + 1 ==
+ bounce_info->node_count && !bounce_info->finished)
+ {
+ memset(&event_info, '\0', sizeof(globus_gfs_event_info_t));
+@@ -1012,10 +1012,10 @@ globus_l_gfs_ipc_event_cb(
+ master_node->ipc_handle,
+ &event_info);
+ bounce_info->final_eof++;
+- }
++ }
+ break;
+ default:
+- if(!bounce_info->event_pending ||
++ if(!bounce_info->event_pending ||
+ reply->type == GLOBUS_GFS_EVENT_BYTES_RECVD ||
+ reply->type == GLOBUS_GFS_EVENT_RANGES_RECVD)
+ {
+@@ -1027,14 +1027,14 @@ globus_l_gfs_ipc_event_cb(
+ globus_mutex_unlock(&my_handle->mutex);
+
+ if(finish)
+- {
++ {
+ reply->event_arg = bounce_info;
+ globus_gridftp_server_operation_event(
+ bounce_info->op,
+ GLOBUS_SUCCESS,
+ reply);
+ }
+-
++
+ GlobusGFSRemoteDebugExit();
+ }
+
+@@ -1050,7 +1050,7 @@ globus_l_gfs_remote_init_bounce_info(
+ globus_result_t result;
+ GlobusGFSName(globus_l_gfs_remote_init_bounce_info);
+ GlobusGFSRemoteDebugEnter();
+-
++
+ bounce_info = (globus_l_gfs_remote_ipc_bounce_t *)
+ globus_calloc(1, sizeof(globus_l_gfs_remote_ipc_bounce_t));
+ if(!bounce_info)
+@@ -1058,12 +1058,12 @@ globus_l_gfs_remote_init_bounce_info(
+ result = GlobusGFSErrorMemory("bounce_info");
+ goto error_alloc;
+ }
+-
++
+ bounce_info->op = op;
+ bounce_info->state = state;
+ bounce_info->my_handle = my_handle;
+ *bounce = bounce_info;
+-
++
+ GlobusGFSRemoteDebugExit();
+ return GLOBUS_SUCCESS;
+
+@@ -1084,9 +1084,9 @@ globus_l_gfs_remote_stat(
+ globus_l_gfs_remote_handle_t * my_handle;
+ GlobusGFSName(globus_l_gfs_remote_stat);
+ GlobusGFSRemoteDebugEnter();
+-
++
+ my_handle = (globus_l_gfs_remote_handle_t *) user_arg;
+-
++
+ result = globus_l_gfs_remote_init_bounce_info(
+ &bounce_info, op, stat_info, my_handle);
+
+@@ -1119,7 +1119,7 @@ globus_l_gfs_remote_command(
+ GlobusGFSRemoteDebugEnter();
+
+ my_handle = (globus_l_gfs_remote_handle_t *) user_arg;
+-
++
+ result = globus_l_gfs_remote_init_bounce_info(
+ &bounce_info, op, command_info, my_handle);
+
+@@ -1151,20 +1151,20 @@ globus_l_gfs_remote_list(
+ globus_l_gfs_remote_node_info_t * node_info;
+ GlobusGFSName(globus_l_gfs_remote_list);
+ GlobusGFSRemoteDebugEnter();
+-
++
+ my_handle = (globus_l_gfs_remote_handle_t *) user_arg;
+
+- /* XXX it appears no lock is needed here */
++ /* XXX it appears no lock is needed here */
+ result = globus_l_gfs_remote_init_bounce_info(
+ &bounce_info, op, transfer_info, my_handle);
+- globus_free(bounce_info->node_handle);
+-
+- bounce_info->node_handle = (globus_l_gfs_remote_node_handle_t *)
++ globus_free(bounce_info->node_handle);
++
++ bounce_info->node_handle = (globus_l_gfs_remote_node_handle_t *)
+ transfer_info->data_arg;
+ bounce_info->node_handle->destroy++;
+-
++
+ node_info = bounce_info->node_handle->nodes[0];
+-
++
+ transfer_info->data_arg = node_info->data_arg;
+ transfer_info->stripe_count = 1;
+ transfer_info->node_ndx = 0;
+@@ -1176,13 +1176,13 @@ globus_l_gfs_remote_list(
+ node_info->info = NULL;
+ node_info->info_needs_free = GLOBUS_FALSE;
+ node_info->bounce = bounce_info;
+-
++
+ result = globus_gfs_ipc_request_list(
+ node_info->ipc_handle,
+ transfer_info,
+ globus_l_gfs_ipc_transfer_cb,
+ globus_l_gfs_ipc_event_cb,
+- node_info);
++ node_info);
+ if(result != GLOBUS_SUCCESS)
+ {
+ GlobusGFSErrorOpFinished(
+@@ -1207,21 +1207,21 @@ globus_l_gfs_remote_recv_next(
+ int ndx = 1;
+ GlobusGFSName(globus_l_gfs_remote_recv_next);
+ GlobusGFSRemoteDebugEnter();
+-
++
+ /* already sent recv to node 0, now send the rest */
+ transfer_info = (globus_gfs_transfer_info_t *) bounce_info->state;
+-
++
+ node_count = bounce_info->node_handle->count;
+-
++
+ for(i = 1; i < bounce_info->node_handle->count; i++)
+ {
+ node_info = bounce_info->node_handle->nodes[i];
+-
++
+ new_transfer_info = (globus_gfs_transfer_info_t *)
+ globus_calloc(1, sizeof(globus_gfs_transfer_info_t));
+- memcpy(new_transfer_info, transfer_info,
++ memcpy(new_transfer_info, transfer_info,
+ sizeof(globus_gfs_transfer_info_t));
+-
++
+ new_transfer_info->truncate = GLOBUS_FALSE;
+ new_transfer_info->data_arg = node_info->data_arg;
+ new_transfer_info->node_count = node_count;
+@@ -1238,7 +1238,7 @@ globus_l_gfs_remote_recv_next(
+ new_transfer_info,
+ globus_l_gfs_ipc_transfer_cb,
+ globus_l_gfs_ipc_event_cb,
+- node_info);
++ node_info);
+ if(result != GLOBUS_SUCCESS)
+ {
+ if(bounce_info->nodes_pending > 0)
+@@ -1256,7 +1256,7 @@ globus_l_gfs_remote_recv_next(
+ bounce_info->event_pending++;
+ bounce_info->begin_event_pending++;
+ }
+-
++
+ bounce_info->recv_pending = GLOBUS_FALSE;
+
+ GlobusGFSRemoteDebugExit();
+@@ -1280,23 +1280,23 @@ globus_l_gfs_remote_recv(
+ int node_count;
+ GlobusGFSName(globus_l_gfs_remote_recv);
+ GlobusGFSRemoteDebugEnter();
+-
++
+ my_handle = (globus_l_gfs_remote_handle_t *) user_arg;
+
+ globus_mutex_lock(&my_handle->mutex);
+ {
+ result = globus_l_gfs_remote_init_bounce_info(
+ &bounce_info, op, transfer_info, my_handle);
+-
+- bounce_info->node_handle = (globus_l_gfs_remote_node_handle_t *)
++
++ bounce_info->node_handle = (globus_l_gfs_remote_node_handle_t *)
+ transfer_info->data_arg;
+
+ /* only going to do the first recv request here, the others
+- will be sent after this one responds with the begin event
+-
+- we need to do this primarily to make sure the file is opened
++ will be sent after this one responds with the begin event
++
++ we need to do this primarily to make sure the file is opened
+ in TRUNC mode only the first time */
+-
++
+ bounce_info->node_handle->destroy++;
+ node_count = bounce_info->node_handle->count;
+ if(node_count > 1)
+@@ -1305,9 +1305,9 @@ globus_l_gfs_remote_recv(
+ }
+ bounce_info->nodes_requesting = node_count;
+ bounce_info->node_count = node_count;
+-
++
+ node_info = bounce_info->node_handle->nodes[0];
+-
++
+ new_transfer_info = (globus_gfs_transfer_info_t *)
+ globus_calloc(1, sizeof(globus_gfs_transfer_info_t));
+ memcpy(new_transfer_info,transfer_info,
+@@ -1326,14 +1326,14 @@ globus_l_gfs_remote_recv(
+ new_transfer_info,
+ globus_l_gfs_ipc_transfer_cb,
+ globus_l_gfs_ipc_event_cb,
+- node_info);
++ node_info);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error;
+ }
+ /* could maybe get away with no lock if we moved the next few lines
+- above the request. we would have to then assume that the
+- values were meaningless under error. This way is more
++ above the request. we would have to then assume that the
++ values were meaningless under error. This way is more
+ consistant and the lock is not very costly */
+ bounce_info->nodes_pending++;
+ bounce_info->event_pending++;
+@@ -1368,21 +1368,21 @@ globus_l_gfs_remote_send(
+ int i;
+ GlobusGFSName(globus_l_gfs_remote_send);
+ GlobusGFSRemoteDebugEnter();
+-
++
+ my_handle = (globus_l_gfs_remote_handle_t *) user_arg;
+
+ globus_mutex_lock(&my_handle->mutex);
+ {
+ result = globus_l_gfs_remote_init_bounce_info(
+ &bounce_info, op, transfer_info, my_handle);
+-
++
+ bounce_info->node_handle = (globus_l_gfs_remote_node_handle_t *)
+ transfer_info->data_arg;
+ bounce_info->node_handle->destroy++;
+
+ node_count = bounce_info->node_handle->count;
+
+- bounce_info->eof_count = (int *)
++ bounce_info->eof_count = (int *)
+ globus_calloc(1, node_count * sizeof(int) + 1);
+
+ bounce_info->nodes_requesting = node_count;
+@@ -1391,12 +1391,12 @@ globus_l_gfs_remote_send(
+ for(i = 0; i < bounce_info->node_handle->count; i++)
+ {
+ node_info = bounce_info->node_handle->nodes[i];
+-
++
+ new_transfer_info = (globus_gfs_transfer_info_t *)
+ globus_calloc(1, sizeof(globus_gfs_transfer_info_t));
+ memcpy(new_transfer_info,
+ transfer_info, sizeof(globus_gfs_transfer_info_t));
+-
++
+ new_transfer_info->data_arg = node_info->data_arg;
+ new_transfer_info->node_count = node_count;
+ new_transfer_info->stripe_count = node_info->stripe_count;
+@@ -1404,17 +1404,17 @@ globus_l_gfs_remote_send(
+ node_info->info = new_transfer_info;
+ node_info->info_needs_free = GLOBUS_TRUE;
+ node_info->bounce = bounce_info;
+-
++
+ bounce_info->nodes_pending++;
+ bounce_info->event_pending++;
+ bounce_info->begin_event_pending++;
+-
++
+ result = globus_gfs_ipc_request_send(
+ node_info->ipc_handle,
+ new_transfer_info,
+ globus_l_gfs_ipc_transfer_cb,
+ globus_l_gfs_ipc_event_cb,
+- node_info);
++ node_info);
+ if(result != GLOBUS_SUCCESS)
+ {
+ /* if some callbacks are pending we need to wait for the
+@@ -1473,17 +1473,17 @@ globus_l_gfs_remote_active_kickout(
+
+ new_data_info = (globus_gfs_data_info_t *)
+ globus_calloc(1, sizeof(globus_gfs_data_info_t));
+-
++
+ memcpy(
+ new_data_info, bounce_info->state, sizeof(globus_gfs_data_info_t));
+
+- if(bounce_info->my_handle->striped_mode ==
++ if(bounce_info->my_handle->striped_mode ==
+ GLOBUS_L_GFS_REMOTE_STRIPED_ONE_TO_ONE)
+ {
+ new_data_info->cs_count = 1;
+- new_data_info->contact_strings =
++ new_data_info->contact_strings =
+ (const char **) calloc(1, sizeof(char *));
+- new_data_info->contact_strings[0] =
++ new_data_info->contact_strings[0] =
+ globus_libc_strdup(
+ data_info->contact_strings[bounce_info->node_ndx]);
+ }
+@@ -1494,7 +1494,7 @@ globus_l_gfs_remote_active_kickout(
+ node_info->ipc_handle,
+ new_data_info,
+ globus_l_gfs_ipc_active_cb,
+- node_info);
++ node_info);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error;
+@@ -1540,14 +1540,14 @@ globus_l_gfs_remote_active(
+ int num_nodes;
+ GlobusGFSName(globus_l_gfs_remote_active);
+ GlobusGFSRemoteDebugEnter();
+-
++
+ my_handle = (globus_l_gfs_remote_handle_t *) user_arg;
+
+ globus_mutex_lock(&my_handle->mutex);
+- {
++ {
+ result = globus_l_gfs_remote_init_bounce_info(
+ &bounce_info, op, data_info, my_handle);
+-
++
+ num_nodes = data_info->cs_count;
+
+ bounce_info->node_handle = (globus_l_gfs_remote_node_handle_t *)
+@@ -1563,7 +1563,7 @@ globus_l_gfs_remote_active(
+ num_nodes,
+ NULL,
+ globus_l_gfs_remote_active_kickout,
+- bounce_info);
++ bounce_info);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error;
+@@ -1592,12 +1592,12 @@ globus_l_gfs_remote_passive_kickout(
+ globus_l_gfs_remote_ipc_bounce_t * bounce_info;
+ GlobusGFSName(globus_l_gfs_remote_passive_kickout);
+ GlobusGFSRemoteDebugEnter();
+-
++
+ bounce_info = (globus_l_gfs_remote_ipc_bounce_t *) user_arg;
+ my_handle = (globus_l_gfs_remote_handle_t *) bounce_info->my_handle;
+
+ globus_mutex_lock(&my_handle->mutex);
+- {
++ {
+ bounce_info->nodes_requesting--;
+ if(result != GLOBUS_SUCCESS)
+ {
+@@ -1651,9 +1651,9 @@ globus_l_gfs_remote_passive(
+ int num_nodes;
+ GlobusGFSName(globus_l_gfs_remote_passive);
+ GlobusGFSRemoteDebugEnter();
+-
++
+ my_handle = (globus_l_gfs_remote_handle_t *) user_arg;
+-
++
+ result = globus_l_gfs_remote_init_bounce_info(
+ &bounce_info, op, data_info, my_handle);
+
+@@ -1677,7 +1677,7 @@ globus_l_gfs_remote_passive(
+ bounce_info->nodes_requesting,
+ NULL,
+ globus_l_gfs_remote_passive_kickout,
+- bounce_info);
++ bounce_info);
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error;
+@@ -1713,24 +1713,24 @@ globus_l_gfs_remote_data_destroy(
+ globus_l_gfs_remote_node_handle_t * node_handle;
+ GlobusGFSName(globus_l_gfs_remote_data_destroy);
+ GlobusGFSRemoteDebugEnter();
+-
++
+ my_handle = (globus_l_gfs_remote_handle_t *) user_arg;
+ node_handle = (globus_l_gfs_remote_node_handle_t *) data_arg;
+
+ globus_mutex_lock(&my_handle->mutex);
+- {
++ {
+ for(i = 0; i < node_handle->count; i++)
+ {
+ node_info = (globus_l_gfs_remote_node_info_t *)
+ node_handle->nodes[i];
+-
++
+ result = globus_gfs_ipc_request_data_destroy(
+ node_info->ipc_handle,
+- node_info->data_arg);
++ node_info->data_arg);
+ if(result != GLOBUS_SUCCESS)
+ {
+ globus_gfs_log_result(
+- GLOBUS_GFS_LOG_ERR,
++ GLOBUS_GFS_LOG_ERR,
+ "IPC ERROR: remote_data_destroy: ipc call", result);
+ }
+ if(node_info->cs != NULL)
+@@ -1761,7 +1761,7 @@ globus_l_gfs_remote_data_destroy(
+ {
+ globus_free(node_handle->nodes);
+ globus_free(node_handle);
+- }
++ }
+ GlobusGFSRemoteDebugExit();
+ }
+
+@@ -1782,11 +1782,11 @@ globus_l_gfs_remote_trev(
+ globus_l_gfs_remote_node_handle_t * free_nh = NULL;
+ GlobusGFSName(globus_l_gfs_remote_trev);
+ GlobusGFSRemoteDebugEnter();
+-
++
+ bounce_info = (globus_l_gfs_remote_ipc_bounce_t *) event_info->event_arg;
+-
++
+ my_handle = (globus_l_gfs_remote_handle_t *) user_arg;
+-
++
+ memset(&new_event_info, '\0', sizeof(globus_gfs_event_info_t));
+ new_event_info.type = event_info->type;
+
+@@ -1799,9 +1799,9 @@ globus_l_gfs_remote_trev(
+ node_info->ipc_handle,
+ &new_event_info);
+ }
+-
++
+ globus_mutex_lock(&my_handle->mutex);
+- {
++ {
+ if(event_info->type == GLOBUS_GFS_EVENT_TRANSFER_COMPLETE)
+ {
+ for(i = 0; i < bounce_info->node_handle->count; i++)
+@@ -1848,7 +1848,7 @@ globus_l_gfs_remote_session_start_kickout(
+ void * user_arg)
+ {
+ globus_l_gfs_remote_handle_t * my_handle;
+- globus_gfs_finished_info_t finished_info;
++ globus_gfs_finished_info_t finished_info;
+ GlobusGFSName(globus_l_gfs_remote_session_start_kickout);
+ GlobusGFSRemoteDebugEnter();
+
+@@ -1856,40 +1856,40 @@ globus_l_gfs_remote_session_start_kickout(
+ with this handle until we signal it has started */
+
+ my_handle = (globus_l_gfs_remote_handle_t *) user_arg;
+-
++
+ if(result != GLOBUS_SUCCESS)
+ {
+ goto error;
+ }
+
+ memset(&finished_info, '\0', sizeof(globus_gfs_finished_info_t));
+- finished_info.type = GLOBUS_GFS_OP_SESSION_START;
+- finished_info.result = result;
++ finished_info.type = GLOBUS_GFS_OP_SESSION_START;
++ finished_info.result = result;
+ finished_info.info.session.session_arg = my_handle;
+- finished_info.info.session.username = node_info->username;
+- finished_info.info.session.home_dir = node_info->home_dir;
++ finished_info.info.session.username = node_info->username;
++ finished_info.info.session.home_dir = node_info->home_dir;
+ my_handle->control_node = node_info;
+
+- globus_gridftp_server_operation_finished(
+- my_handle->op,
+- result,
++ globus_gridftp_server_operation_finished(
++ my_handle->op,
++ result,
+ &finished_info);
+
+ GlobusGFSRemoteDebugExit();
+ return;
+-
+-error:
++
++error:
+ memset(&finished_info, '\0', sizeof(globus_gfs_finished_info_t));
+ finished_info.type = GLOBUS_GFS_OP_SESSION_START;
+ finished_info.result = result;
+
+- globus_gridftp_server_operation_finished(
+- my_handle->op,
+- finished_info.result,
++ globus_gridftp_server_operation_finished(
++ my_handle->op,
++ finished_info.result,
+ &finished_info);
+-
++
+ GlobusGFSRemoteDebugExitWithError();
+-}
++}
+
+ static
+ void
+@@ -1902,8 +1902,8 @@ globus_l_gfs_remote_session_start(
+ int nodes_requesting = 1;
+ GlobusGFSName(globus_l_gfs_remote_session_start);
+ GlobusGFSRemoteDebugEnter();
+-
+- my_handle = (globus_l_gfs_remote_handle_t *)
++
++ my_handle = (globus_l_gfs_remote_handle_t *)
+ globus_calloc(1, sizeof(globus_l_gfs_remote_handle_t));
+ globus_mutex_init(&my_handle->mutex, NULL);
+ my_handle->ipc_release_reason = GLOBUS_GFS_BRAIN_REASON_COMPLETE;
+@@ -1935,7 +1935,7 @@ globus_l_gfs_remote_session_start(
+ {
+ GlobusGFSErrorOpFinished(op, GLOBUS_GFS_OP_SESSION_START, result);
+ }
+-
++
+ GlobusGFSRemoteDebugExit();
+ }
+
+@@ -1952,7 +1952,7 @@ globus_l_gfs_remote_session_end(
+ GlobusGFSRemoteDebugEnter();
+
+ my_handle = (globus_l_gfs_remote_handle_t *) user_arg;
+-
++
+ if(my_handle == NULL)
+ {
+ goto error;
+@@ -1965,10 +1965,10 @@ globus_l_gfs_remote_session_end(
+ if(result != GLOBUS_SUCCESS)
+ {
+ globus_gfs_log_result(
+- GLOBUS_GFS_LOG_ERR,
++ GLOBUS_GFS_LOG_ERR,
+ "ERROR: remote_data_destroy: handle_release", result);
+ }
+-
++
+ if(my_handle->session_info.username != NULL)
+ {
+ globus_free(my_handle->session_info.username);
+@@ -1983,10 +1983,10 @@ globus_l_gfs_remote_session_end(
+ }
+ globus_mutex_destroy(&my_handle->mutex);
+ globus_free(my_handle);
+-
++
+ GlobusGFSRemoteDebugExit();
+ return;
+-
++
+ error:
+ GlobusGFSRemoteDebugExitWithError();
+ }
+@@ -1999,7 +1999,7 @@ static
+ int
+ globus_l_gfs_remote_deactivate(void);
+
+-static globus_gfs_storage_iface_t globus_l_gfs_remote_dsi_iface =
++static globus_gfs_storage_iface_t globus_l_gfs_remote_dsi_iface =
+ {
+ 0,
+ globus_l_gfs_remote_session_start,
+@@ -2011,7 +2011,7 @@ static globus_gfs_storage_iface_t globus_l_gfs_remote_dsi_iface =
+ globus_l_gfs_remote_active,
+ globus_l_gfs_remote_passive,
+ globus_l_gfs_remote_data_destroy,
+- globus_l_gfs_remote_command,
++ globus_l_gfs_remote_command,
+ globus_l_gfs_remote_stat,
+ NULL,
+ NULL
+@@ -2033,13 +2033,13 @@ globus_l_gfs_remote_activate(void)
+ {
+ int rc;
+ GlobusGFSName(globus_l_gfs_remote_activate);
+-
++
+ rc = globus_module_activate(GLOBUS_COMMON_MODULE);
+ if(rc != GLOBUS_SUCCESS)
+ {
+ goto error;
+ }
+-
++
+ globus_extension_registry_add(
+ GLOBUS_GFS_DSI_REGISTRY,
+ "remote",
+@@ -2048,7 +2048,7 @@ globus_l_gfs_remote_activate(void)
+
+ GlobusDebugInit(GLOBUS_GRIDFTP_SERVER_REMOTE,
+ ERROR WARNING TRACE INTERNAL_TRACE INFO STATE INFO_VERBOSE);
+-
++
+ return GLOBUS_SUCCESS;
+
+ error:
+@@ -2060,11 +2060,11 @@ int
+ globus_l_gfs_remote_deactivate(void)
+ {
+ GlobusGFSName(globus_l_gfs_remote_deactivate);
+-
++
+ globus_extension_registry_remove(
+ GLOBUS_GFS_DSI_REGISTRY, "remote");
+-
++
+ globus_module_deactivate(GLOBUS_COMMON_MODULE);
+-
++
+ return GLOBUS_SUCCESS;
+ }
+--
+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..7ea126e
--- /dev/null
+++ b/0002-Fix-compiler-and-doxygen-warnings.patch
@@ -0,0 +1,321 @@
+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
+
+---
+ gridftp/server/src/gfs_dynbe_client.c | 1 +
+ gridftp/server/src/gfs_gfork_master.c | 5 +++++
+ gridftp/server/src/globus_i_gfs_config.c | 7 +++----
+ gridftp/server/src/globus_i_gfs_control.c | 3 +--
+ gridftp/server/src/globus_i_gfs_data.c | 20 ++++++++-----------
+ .../server/src/globus_i_gfs_default_brain.c | 3 +--
+ .../modules/file/globus_gridftp_server_file.c | 5 +----
+ .../remote/globus_gridftp_server_remote.c | 6 ++----
+ 8 files changed, 22 insertions(+), 28 deletions(-)
+
+diff --git a/gridftp/server/src/gfs_dynbe_client.c b/gridftp/server/src/gfs_dynbe_client.c
+index 9c132d5f6..09bee672a 100644
+--- a/gridftp/server/src/gfs_dynbe_client.c
++++ b/gridftp/server/src/gfs_dynbe_client.c
+@@ -392,6 +392,7 @@ gfs_l_dynclient_opts_gsi(
+ return GLOBUS_SUCCESS;
+ }
+
++static
+ globus_options_entry_t gfork_l_opts_table[] =
+ {
+ {"quiet", "q", NULL, NULL,
+diff --git a/gridftp/server/src/gfs_gfork_master.c b/gridftp/server/src/gfs_gfork_master.c
+index 91b201459..b22ae6f94 100644
+--- a/gridftp/server/src/gfs_gfork_master.c
++++ b/gridftp/server/src/gfs_gfork_master.c
+@@ -1033,6 +1033,7 @@ gfs_l_gfork_mem_limit_send(
+ }
+ }
+
++/*
+ static
+ void
+ gfs_l_gfork_kill_send(
+@@ -1069,6 +1070,7 @@ gfs_l_gfork_kill_send(
+ result, 3, "failed to send kill to %d\n", to_pid);
+ }
+ }
++*/
+
+ static
+ void
+@@ -1176,6 +1178,7 @@ gfs_l_gfork_mem_try(
+ }
+ }
+
++/*
+ static
+ void
+ gfs_l_gfork_mem_try_cb(
+@@ -1194,6 +1197,7 @@ gfs_l_gfork_mem_try_cb(
+ }
+ globus_mutex_unlock(&g_mutex);
+ }
++*/
+
+ static
+ void
+@@ -2132,6 +2136,7 @@ error_format:
+
+
+
++static
+ globus_options_entry_t gfork_l_opts_table[] =
+ {
+ {"help", "h", NULL, NULL,
+diff --git a/gridftp/server/src/globus_i_gfs_config.c b/gridftp/server/src/globus_i_gfs_config.c
+index 57367ac64..0f1a5356b 100644
+--- a/gridftp/server/src/globus_i_gfs_config.c
++++ b/gridftp/server/src/globus_i_gfs_config.c
+@@ -2439,7 +2439,6 @@ globus_l_gfs_config_misc()
+ globus_list_t * popen_list = NULL;
+ char * module;
+ char * ptr;
+- int rc;
+ char * value;
+ char * data;
+ globus_result_t result;
+@@ -2634,7 +2633,7 @@ globus_l_gfs_config_misc()
+ }
+ else if((value = globus_i_gfs_config_string("banner_file")) != GLOBUS_NULL)
+ {
+- rc = globus_l_config_loadfile(value, &data);
++ globus_l_config_loadfile(value, &data);
+ }
+ else if((value = globus_i_gfs_config_string("banner")) != GLOBUS_NULL)
+ {
+@@ -2672,7 +2671,7 @@ globus_l_gfs_config_misc()
+
+ if((value = globus_i_gfs_config_string("login_msg_file")) != GLOBUS_NULL)
+ {
+- rc = globus_l_config_loadfile(value, &data);
++ globus_l_config_loadfile(value, &data);
+ globus_l_gfs_config_set("login_msg", 0, data);
+ }
+
+@@ -3120,7 +3119,7 @@ globus_i_gfs_config_init_envs(
+ /* only enable threads for real process, not daemon */
+ if(globus_l_gfs_num_threads > 0 && globus_l_gfs_is_worker)
+ {
+- char nthreads[8];
++ char nthreads[11];
+ snprintf(nthreads, sizeof(nthreads), "%d", globus_l_gfs_num_threads);
+ setenv("GLOBUS_CALLBACK_POLLING_THREADS", nthreads, 1);
+ globus_thread_set_model("pthread");
+diff --git a/gridftp/server/src/globus_i_gfs_control.c b/gridftp/server/src/globus_i_gfs_control.c
+index 6c369c1d1..496ef12df 100644
+--- a/gridftp/server/src/globus_i_gfs_control.c
++++ b/gridftp/server/src/globus_i_gfs_control.c
+@@ -608,13 +608,12 @@ globus_l_gfs_auth_session_cb(
+ !globus_hashtable_empty(&reply->op_info->custom_command_table))
+ {
+ globus_list_t * list;
+- int rc;
+ globus_i_gfs_cmd_ent_t * cmd_ent;
+
+ auth_info->instance->custom_cmd_table =
+ reply->op_info->custom_command_table;
+
+- rc = globus_hashtable_to_list(
++ globus_hashtable_to_list(
+ &reply->op_info->custom_command_table, &list);
+
+ while(!globus_list_empty(list))
+diff --git a/gridftp/server/src/globus_i_gfs_data.c b/gridftp/server/src/globus_i_gfs_data.c
+index b2be75e4f..4fccc9dfb 100644
+--- a/gridftp/server/src/globus_i_gfs_data.c
++++ b/gridftp/server/src/globus_i_gfs_data.c
+@@ -656,13 +656,12 @@ globus_i_gfs_data_http_print_response(
+ char * header_str = NULL;
+ char * header_tmp;
+ globus_result_t result;
+- int rc;
+ globus_xio_http_header_t * header;
+ char * b64_header = NULL;
+ char * b64_body = NULL;
+ int body_len = 0;
+
+- rc = globus_hashtable_to_list(header_table, &header_list);
++ globus_hashtable_to_list(header_table, &header_list);
+
+ header_str = strdup("");
+ while(!globus_list_empty(header_list))
+@@ -2679,7 +2678,6 @@ globus_l_gfs_data_new_dsi(
+ const char * in_module_name)
+ {
+ const char * module_name;
+- globus_result_t result;
+ GlobusGFSName(globus_l_gfs_data_new_dsi);
+ GlobusGFSDebugEnter();
+
+@@ -2708,7 +2706,7 @@ globus_l_gfs_data_new_dsi(
+ globus_extension_release(session_handle->mod_dsi_handle);
+
+ session_handle->mod_dsi_name = globus_libc_strdup(module_name);
+- result = globus_i_gfs_data_new_dsi(
++ globus_i_gfs_data_new_dsi(
+ &session_handle->mod_dsi_handle,
+ session_handle->mod_dsi_name,
+ &session_handle->mod_dsi,
+@@ -2722,7 +2720,7 @@ globus_l_gfs_data_new_dsi(
+ else
+ {
+ session_handle->mod_dsi_name = globus_libc_strdup(module_name);
+- result = globus_i_gfs_data_new_dsi(
++ globus_i_gfs_data_new_dsi(
+ &session_handle->mod_dsi_handle,
+ session_handle->mod_dsi_name,
+ &session_handle->mod_dsi,
+@@ -13503,7 +13501,6 @@ globus_gridftp_server_get_write_range(
+ globus_off_t tmp_len = -1;
+ globus_off_t tmp_write = 0;
+ globus_off_t tmp_transfer = 0;
+- int rc;
+ GlobusGFSName(globus_gridftp_server_get_write_range);
+ GlobusGFSDebugEnter();
+
+@@ -13511,7 +13508,7 @@ globus_gridftp_server_get_write_range(
+
+ if(globus_range_list_size(op->range_list))
+ {
+- rc = globus_range_list_remove_at(
++ globus_range_list_remove_at(
+ op->range_list,
+ 0,
+ &tmp_off,
+@@ -13551,7 +13548,6 @@ globus_gridftp_server_get_read_range(
+ globus_off_t tmp_off = 0;
+ globus_off_t tmp_len = -1;
+ globus_off_t tmp_write = 0;
+- int rc;
+ globus_off_t start_offset;
+ globus_off_t end_offset;
+ globus_off_t stripe_block_size;
+@@ -13604,7 +13600,7 @@ globus_gridftp_server_get_read_range(
+
+ if(globus_range_list_size(op->stripe_range_list))
+ {
+- rc = globus_range_list_remove_at(
++ globus_range_list_remove_at(
+ op->stripe_range_list,
+ 0,
+ &tmp_off,
+@@ -13616,7 +13612,7 @@ globus_gridftp_server_get_read_range(
+ {
+ for(i = 0; i < size; i++)
+ {
+- rc = globus_range_list_at(
++ globus_range_list_at(
+ op->range_list,
+ i,
+ &tmp_off,
+@@ -13656,7 +13652,7 @@ globus_gridftp_server_get_read_range(
+
+ if(globus_range_list_size(op->stripe_range_list))
+ {
+- rc = globus_range_list_remove_at(
++ globus_range_list_remove_at(
+ op->stripe_range_list,
+ 0,
+ &tmp_off,
+@@ -13678,7 +13674,7 @@ globus_gridftp_server_get_read_range(
+ }
+ else if(globus_range_list_size(op->range_list))
+ {
+- rc = globus_range_list_remove_at(
++ globus_range_list_remove_at(
+ op->range_list,
+ 0,
+ &tmp_off,
+diff --git a/gridftp/server/src/globus_i_gfs_default_brain.c b/gridftp/server/src/globus_i_gfs_default_brain.c
+index d11ae92fb..ae456da66 100644
+--- a/gridftp/server/src/globus_i_gfs_default_brain.c
++++ b/gridftp/server/src/globus_i_gfs_default_brain.c
+@@ -326,7 +326,6 @@ globus_l_gfs_mem_limit_release_cb(
+ void * user_arg)
+ {
+ globus_xio_iovec_t iov[1];
+- globus_result_t result;
+ globus_byte_t * buffer;
+ uint32_t tmp32;
+
+@@ -343,7 +342,7 @@ globus_l_gfs_mem_limit_release_cb(
+ iov[0].iov_base = buffer;
+ iov[0].iov_len = GF_RELEASE_MSG_LEN;
+
+- result = globus_gfork_send(
++ globus_gfork_send(
+ globus_l_gfs_gfork_handle,
+ -1, /* to the master */
+ iov,
+diff --git a/gridftp/server/src/modules/file/globus_gridftp_server_file.c b/gridftp/server/src/modules/file/globus_gridftp_server_file.c
+index 0325cd30b..360583644 100644
+--- a/gridftp/server/src/modules/file/globus_gridftp_server_file.c
++++ b/gridftp/server/src/modules/file/globus_gridftp_server_file.c
+@@ -1397,7 +1397,6 @@ globus_l_gfs_file_delete_dir(
+ DIR * dir;
+ struct stat stat_buf;
+ struct dirent * dir_entry;
+- int i;
+ char path[MAXPATHLEN];
+ GlobusGFSName(globus_l_gfs_file_delete_dir);
+ GlobusGFSFileDebugEnter();
+@@ -1428,9 +1427,7 @@ globus_l_gfs_file_delete_dir(
+ goto error_open;
+ }
+
+- for(i = 0;
+- globus_libc_readdir_r(dir, &dir_entry) == 0 && dir_entry;
+- i++)
++ while(globus_libc_readdir_r(dir, &dir_entry) == 0 && dir_entry)
+ {
+ if(dir_entry->d_name[0] == '.' &&
+ (dir_entry->d_name[1] == '\0' ||
+diff --git a/gridftp/server/src/modules/remote/globus_gridftp_server_remote.c b/gridftp/server/src/modules/remote/globus_gridftp_server_remote.c
+index 324f8f585..85d0969fa 100644
+--- a/gridftp/server/src/modules/remote/globus_gridftp_server_remote.c
++++ b/gridftp/server/src/modules/remote/globus_gridftp_server_remote.c
+@@ -926,7 +926,6 @@ globus_l_gfs_ipc_event_cb(
+ globus_l_gfs_remote_node_info_t * node_info;
+ globus_gfs_transfer_info_t * info;
+ globus_gfs_event_info_t event_info;
+- globus_result_t result;
+ int ctr;
+ GlobusGFSName(globus_l_gfs_ipc_event_cb);
+ GlobusGFSRemoteDebugEnter();
+@@ -1008,7 +1007,7 @@ globus_l_gfs_ipc_event_cb(
+ event_info.event_arg = master_node->event_arg;
+ event_info.eof_count = bounce_info->eof_count;
+ event_info.node_count = bounce_info->partial_eof_counts + 1;
+- result = globus_gfs_ipc_request_transfer_event(
++ globus_gfs_ipc_request_transfer_event(
+ master_node->ipc_handle,
+ &event_info);
+ bounce_info->final_eof++;
+@@ -1774,7 +1773,6 @@ globus_l_gfs_remote_trev(
+ {
+ globus_bool_t free_node = GLOBUS_FALSE;
+ int i;
+- globus_result_t result;
+ globus_l_gfs_remote_handle_t * my_handle;
+ globus_l_gfs_remote_node_info_t * node_info;
+ globus_gfs_event_info_t new_event_info;
+@@ -1795,7 +1793,7 @@ globus_l_gfs_remote_trev(
+ node_info = bounce_info->node_handle->nodes[i];
+
+ new_event_info.event_arg = node_info->event_arg;
+- result = globus_gfs_ipc_request_transfer_event(
++ globus_gfs_ipc_request_transfer_event(
+ node_info->ipc_handle,
+ &new_event_info);
+ }
+--
+2.54.0
+
diff --git a/globus-gridftp-server.spec b/globus-gridftp-server.spec
index 49143da..b5af9d8 100644
--- a/globus-gridftp-server.spec
+++ b/globus-gridftp-server.spec
@@ -3,7 +3,7 @@
Name: globus-gridftp-server
%global _name %(tr - _ <<< %{name})
Version: 13.28
-Release: 2%{?dist}
+Release: 3%{?dist}
Summary: Grid Community Toolkit - Globus GridFTP Server
License: Apache-2.0
@@ -12,6 +12,8 @@ Source: https://repo.gridcf.org/gct6/sources/%{_name}-%{version}.tar.gz
Source1: %{name}.service
Source2: globus-gridftp-sshftp.service
Source8: README
+Patch0: 0001-Untabify-and-remove-trailing-white-space.patch
+Patch1: 0002-Fix-compiler-and-doxygen-warnings.patch
BuildRequires: make
BuildRequires: gcc
@@ -88,6 +90,8 @@ Globus GridFTP Server Development Files
%prep
%setup -q -n %{_name}-%{version}
+%patch -P0 -p4
+%patch -P1 -p4
%build
# Reduce overlinking
@@ -178,6 +182,9 @@ rm %{buildroot}%{_pkgdocdir}/GLOBUS_LICENSE
%{_libdir}/pkgconfig/%{name}.pc
%changelog
+* Sun Jun 14 2026 Mattias Ellert <mattias.ellert@physics.uu.se> - 13.28-3
+- Fix compiler warnings
+
* Fri Jan 16 2026 Fedora Release Engineering <releng@fedoraproject.org> - 13.28-2
- Rebuilt for https://fedoraproject.org/wiki/Fedora_44_Mass_Rebuild
^ permalink raw reply related [flat|nested] only message in thread
only message in thread, other threads:[~2026-06-14 8:47 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-06-14 8:47 [rpms/globus-gridftp-server] rawhide: Fix compiler warnings Mattias Ellert
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox