X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/151f59f155c1a2f3f6301c0ad5b59654d922e34a..30e50494bbb057d4191e4636b963c6b7b0770ece:/flist.c

diff --git a/flist.c b/flist.c
index 30e88ab4..11d4b041 100644
--- a/flist.c
+++ b/flist.c
@@ -1,34 +1,30 @@
 /*
-   Copyright (C) Andrew Tridgell 1996
-   Copyright (C) Paul Mackerras 1996
-   Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-/** @file flist.c
- * Generate and receive file lists
+ * Generate and receive file lists.
  *
- * @sa http://lists.samba.org/pipermail/rsync/2000-June/002351.html
+ * Copyright (C) 1996 Andrew Tridgell
+ * Copyright (C) 1996 Paul Mackerras
+ * Copyright (C) 2001, 2002 Martin Pool <mbp@samba.org>
+ * Copyright (C) 2002, 2003, 2004, 2005, 2006 Wayne Davison
  *
- **/
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
+ */
 
 #include "rsync.h"
+#include "rounding.h"
 
 extern int verbose;
-extern int dry_run;
 extern int list_only;
 extern int am_root;
 extern int am_server;
@@ -43,48 +39,62 @@ extern int recurse;
 extern int xfer_dirs;
 extern int filesfrom_fd;
 extern int one_file_system;
+extern int copy_dirlinks;
 extern int keep_dirlinks;
 extern int preserve_links;
 extern int preserve_hard_links;
-extern int preserve_perms;
 extern int preserve_devices;
+extern int preserve_specials;
 extern int preserve_uid;
 extern int preserve_gid;
 extern int relative_paths;
 extern int implied_dirs;
+extern int flist_extra_cnt;
+extern int ignore_perishable;
+extern int non_perishable_cnt;
+extern int prune_empty_dirs;
 extern int copy_links;
 extern int copy_unsafe_links;
 extern int protocol_version;
 extern int sanitize_paths;
-extern int orig_umask;
 extern struct stats stats;
 extern struct file_list *the_file_list;
 
 extern char curr_dir[MAXPATHLEN];
 
+extern struct chmod_mode_struct *chmod_modes;
+
 extern struct filter_list_struct filter_list;
 extern struct filter_list_struct server_filter_list;
 
 int io_error;
+int checksum_len;
 dev_t filesystem_dev; /* used to implement -x */
 
+/* The tmp_* vars are used as a cache area by make_file() to store data
+ * that the sender doesn't need to remember in its file list.  The data
+ * will survive just long enough to be used by send_file_entry(). */
+static dev_t tmp_rdev;
+#ifdef SUPPORT_HARD_LINKS
+static int64 tmp_dev, tmp_ino;
+#endif
+static char tmp_sum[MD4_SUM_LENGTH];
+
 static char empty_sum[MD4_SUM_LENGTH];
-static int flist_count_offset;
-static unsigned int file_struct_len;
-static struct file_list *sorting_flist;
+static int flist_count_offset; /* for --delete --progress */
 
 static void clean_flist(struct file_list *flist, int strip_root, int no_dups);
 static void output_flist(struct file_list *flist);
 
 void init_flist(void)
 {
-	struct file_struct f;
-
-	/* Figure out how big the file_struct is without trailing padding */
-	file_struct_len = offsetof(struct file_struct, flags) + sizeof f.flags;
+	if (verbose > 4) {
+		rprintf(FINFO, "FILE_STRUCT_LEN=%d, EXTRA_LEN=%d\n",
+			(int)FILE_STRUCT_LEN, (int)EXTRA_LEN);
+	}
+	checksum_len = protocol_version < 21 ? 2 : MD4_SUM_LENGTH;
 }
 
-
 static int show_filelist_p(void)
 {
 	return verbose && xfer_dirs && !am_server;
@@ -92,26 +102,23 @@ static int show_filelist_p(void)
 
 static void start_filelist_progress(char *kind)
 {
-	rprintf(FINFO, "%s ... ", kind);
+	rprintf(FCLIENT, "%s ... ", kind);
 	if (verbose > 1 || do_progress)
-		rprintf(FINFO, "\n");
+		rprintf(FCLIENT, "\n");
 	rflush(FINFO);
 }
 
-
 static void emit_filelist_progress(int count)
 {
-	rprintf(FINFO, " %d files...\r", count);
+	rprintf(FCLIENT, " %d files...\r", count);
 }
 
-
 static void maybe_emit_filelist_progress(int count)
 {
 	if (do_progress && show_filelist_p() && (count % 100) == 0)
 		emit_filelist_progress(count);
 }
 
-
 static void finish_filelist_progress(const struct file_list *flist)
 {
 	if (do_progress) {
@@ -127,90 +134,80 @@ void show_flist_stats(void)
 	/* Nothing yet */
 }
 
-
 static void list_file_entry(struct file_struct *f)
 {
-	char perms[11];
+	char permbuf[PERMSTRING_SIZE];
+	double len;
 
-	if (!f->basename) {
+	if (!F_IS_ACTIVE(f)) {
 		/* this can happen if duplicate names were removed */
 		return;
 	}
 
-	permstring(perms, f->mode);
+	permstring(permbuf, f->mode);
+	len = F_LENGTH(f);
 
 #ifdef SUPPORT_LINKS
 	if (preserve_links && S_ISLNK(f->mode)) {
 		rprintf(FINFO, "%s %11.0f %s %s -> %s\n",
-			perms,
-			(double)f->length, timestring(f->modtime),
-			safe_fname(f_name(f)), safe_fname(f->u.link));
+			permbuf, len, timestring(f->modtime),
+			f_name(f, NULL), F_SYMLINK(f));
 	} else
 #endif
 	{
 		rprintf(FINFO, "%s %11.0f %s %s\n",
-			perms,
-			(double)f->length, timestring(f->modtime),
-			safe_fname(f_name(f)));
+			permbuf, len, timestring(f->modtime),
+			f_name(f, NULL));
 	}
 }
 
-
-/**
- * Stat either a symlink or its referent, depending on the settings of
- * copy_links, copy_unsafe_links, etc.
- *
- * @retval -1 on error
- *
- * @retval 0 for success
+/* Stat either a symlink or its referent, depending on the settings of
+ * copy_links, copy_unsafe_links, etc.  Returns -1 on error, 0 on success.
  *
- * @post If @p path is a symlink, then @p linkbuf (of size @c
- * MAXPATHLEN) contains the symlink target.
+ * If path is the name of a symlink, then the linkbuf buffer (which must hold
+ * MAXPATHLEN chars) will be set to the symlink's target string.
  *
- * @post @p buffer contains information about the link or the
- * referrent as appropriate, if they exist.
- **/
-static int readlink_stat(const char *path, STRUCT_STAT *buffer, char *linkbuf)
+ * The stat structure pointed to by stp will contain information about the
+ * link or the referent as appropriate, if they exist. */
+static int readlink_stat(const char *path, STRUCT_STAT *stp, char *linkbuf)
 {
 #ifdef SUPPORT_LINKS
-	if (copy_links)
-		return do_stat(path, buffer);
-	if (link_stat(path, buffer, 0) < 0)
+	if (link_stat(path, stp, copy_dirlinks) < 0)
 		return -1;
-	if (S_ISLNK(buffer->st_mode)) {
-		int l = readlink((char *)path, linkbuf, MAXPATHLEN - 1);
-		if (l == -1)
+	if (S_ISLNK(stp->st_mode)) {
+		int llen = readlink(path, linkbuf, MAXPATHLEN - 1);
+		if (llen < 0)
 			return -1;
-		linkbuf[l] = 0;
+		linkbuf[llen] = '\0';
 		if (copy_unsafe_links && unsafe_symlink(linkbuf, path)) {
 			if (verbose > 1) {
 				rprintf(FINFO,"copying unsafe symlink \"%s\" -> \"%s\"\n",
-					safe_fname(path), safe_fname(linkbuf));
+					path, linkbuf);
 			}
-			return do_stat(path, buffer);
+			return do_stat(path, stp);
 		}
 	}
 	return 0;
 #else
-	return do_stat(path, buffer);
+	return do_stat(path, stp);
 #endif
 }
 
-int link_stat(const char *path, STRUCT_STAT *buffer, int follow_dirlinks)
+int link_stat(const char *path, STRUCT_STAT *stp, int follow_dirlinks)
 {
 #ifdef SUPPORT_LINKS
 	if (copy_links)
-		return do_stat(path, buffer);
-	if (do_lstat(path, buffer) < 0)
+		return do_stat(path, stp);
+	if (do_lstat(path, stp) < 0)
 		return -1;
-	if (follow_dirlinks && S_ISLNK(buffer->st_mode)) {
+	if (follow_dirlinks && S_ISLNK(stp->st_mode)) {
 		STRUCT_STAT st;
 		if (do_stat(path, &st) == 0 && S_ISDIR(st.st_mode))
-			*buffer = st;
+			*stp = st;
 	}
 	return 0;
 #else
-	return do_stat(path, buffer);
+	return do_stat(path, stp);
 #endif
 }
 
@@ -248,24 +245,27 @@ static int is_excluded(char *fname, int is_dir, int filter_level)
 static int to_wire_mode(mode_t mode)
 {
 #ifdef SUPPORT_LINKS
-	if (S_ISLNK(mode) && (_S_IFLNK != 0120000))
+#if _S_IFLNK != 0120000
+	if (S_ISLNK(mode))
 		return (mode & ~(_S_IFMT)) | 0120000;
 #endif
-	return (int)mode;
+#endif
+	return mode;
 }
 
 static mode_t from_wire_mode(int mode)
 {
-	if ((mode & (_S_IFMT)) == 0120000 && (_S_IFLNK != 0120000))
+#if _S_IFLNK != 0120000
+	if ((mode & (_S_IFMT)) == 0120000)
 		return (mode & ~(_S_IFMT)) | _S_IFLNK;
-	return (mode_t)mode;
+#endif
+	return mode;
 }
 
-
 static void send_directory(int f, struct file_list *flist,
 			   char *fbuf, int len);
 
-static char *flist_dir;
+static const char *flist_dir;
 static int flist_dir_len;
 
 
@@ -298,7 +298,7 @@ void flist_expand(struct file_list *flist)
 				flist->malloced);
 
 	if (verbose >= 2 && flist->malloced != FLIST_START) {
-		rprintf(FINFO, "[%s] expand file_list to %.0f bytes, did%s move\n",
+		rprintf(FCLIENT, "[%s] expand file_list to %.0f bytes, did%s move\n",
 		    who_am_i(),
 		    (double)sizeof flist->files[0] * flist->malloced,
 		    (new_ptr == flist->files) ? " not" : "");
@@ -310,7 +310,7 @@ void flist_expand(struct file_list *flist)
 		out_of_memory("flist_expand");
 }
 
-void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
+static void send_file_entry(struct file_struct *file, int f, int ndx)
 {
 	unsigned short flags;
 	static time_t modtime;
@@ -322,42 +322,26 @@ void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
 	static gid_t gid;
 	static char lastname[MAXPATHLEN];
 	char fname[MAXPATHLEN];
+	int first_hlink_ndx = -1;
 	int l1, l2;
 
-	if (f < 0)
-		return;
+	f_name(file, fname);
 
-	if (!file) {
-		write_byte(f, 0);
-		modtime = 0, mode = 0;
-		dev = 0, rdev = makedev(0, 0);
-		rdev_major = 0;
-		uid = 0, gid = 0;
-		*lastname = '\0';
-		return;
-	}
-
-	io_write_phase = "send_file_entry";
-
-	f_name_to(file, fname);
-
-	flags = base_flags;
+	flags = file->flags & FLAG_TOP_DIR; /* FLAG_TOP_DIR == XMIT_TOP_DIR */
 
 	if (file->mode == mode)
 		flags |= XMIT_SAME_MODE;
 	else
 		mode = file->mode;
-	if (preserve_devices) {
+	if ((preserve_devices && IS_DEVICE(mode))
+	 || (preserve_specials && IS_SPECIAL(mode))) {
 		if (protocol_version < 28) {
-			if (IS_DEVICE(mode)) {
-				if (file->u.rdev == rdev)
-					flags |= XMIT_SAME_RDEV_pre28;
-				else
-					rdev = file->u.rdev;
-			} else
-				rdev = makedev(0, 0);
-		} else if (IS_DEVICE(mode)) {
-			rdev = file->u.rdev;
+			if (tmp_rdev == rdev)
+				flags |= XMIT_SAME_RDEV_pre28;
+			else
+				rdev = tmp_rdev;
+		} else {
+			rdev = tmp_rdev;
 			if ((uint32)major(rdev) == rdev_major)
 				flags |= XMIT_SAME_RDEV_MAJOR;
 			else
@@ -365,28 +349,43 @@ void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
 			if ((uint32)minor(rdev) <= 0xFFu)
 				flags |= XMIT_RDEV_MINOR_IS_SMALL;
 		}
+	} else if (protocol_version < 28)
+		rdev = MAKEDEV(0, 0);
+	if (preserve_uid) {
+		if (F_UID(file) == uid)
+			flags |= XMIT_SAME_UID;
+		else
+			uid = F_UID(file);
+	}
+	if (preserve_gid) {
+		if (F_GID(file) == gid)
+			flags |= XMIT_SAME_GID;
+		else
+			gid = F_GID(file);
 	}
-	if (file->uid == uid)
-		flags |= XMIT_SAME_UID;
-	else
-		uid = file->uid;
-	if (file->gid == gid)
-		flags |= XMIT_SAME_GID;
-	else
-		gid = file->gid;
 	if (file->modtime == modtime)
 		flags |= XMIT_SAME_TIME;
 	else
 		modtime = file->modtime;
 
 #ifdef SUPPORT_HARD_LINKS
-	if (file->link_u.idev) {
-		if (file->F_DEV == dev) {
-			if (protocol_version >= 28)
-				flags |= XMIT_SAME_DEV;
-		} else
-			dev = file->F_DEV;
-		flags |= XMIT_HAS_IDEV_DATA;
+	if (tmp_dev != 0) {
+		if (protocol_version >= 30) {
+			struct idev_node *np = idev_node(tmp_dev, tmp_ino);
+			first_hlink_ndx = (int32)np->data - 1;
+			if (first_hlink_ndx < 0) {
+				np->data = (void*)(ndx + 1);
+				flags |= XMIT_HLINK_FIRST;
+			}
+			flags |= XMIT_HLINKED;
+		} else {
+			if (tmp_dev == dev) {
+				if (protocol_version >= 28)
+					flags |= XMIT_SAME_DEV_pre30;
+			} else
+				dev = tmp_dev;
+			flags |= XMIT_HLINKED;
+		}
 	}
 #endif
 
@@ -409,15 +408,12 @@ void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
 			flags |= XMIT_TOP_DIR;
 		if ((flags & 0xFF00) || !flags) {
 			flags |= XMIT_EXTENDED_FLAGS;
-			write_byte(f, flags);
-			write_byte(f, flags >> 8);
+			write_shortint(f, flags);
 		} else
 			write_byte(f, flags);
 	} else {
-		if (!(flags & 0xFF) && !S_ISDIR(mode))
-			flags |= XMIT_TOP_DIR;
 		if (!(flags & 0xFF))
-			flags |= XMIT_LONG_NAME;
+			flags |= S_ISDIR(mode) ? XMIT_LONG_NAME : XMIT_TOP_DIR;
 		write_byte(f, flags);
 	}
 	if (flags & XMIT_SAME_NAME)
@@ -428,7 +424,12 @@ void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
 		write_byte(f, l2);
 	write_buf(f, fname + l1, l2);
 
-	write_longint(f, file->length);
+	if (first_hlink_ndx >= 0) {
+		write_int(f, first_hlink_ndx);
+		goto the_end;
+	}
+
+	write_longint(f, F_LENGTH(file));
 	if (!(flags & XMIT_SAME_TIME))
 		write_int(f, modtime);
 	if (!(flags & XMIT_SAME_MODE))
@@ -443,7 +444,8 @@ void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
 			add_gid(gid);
 		write_int(f, gid);
 	}
-	if (preserve_devices && IS_DEVICE(mode)) {
+	if ((preserve_devices && IS_DEVICE(mode))
+	 || (preserve_specials && IS_SPECIAL(mode))) {
 		if (protocol_version < 28) {
 			if (!(flags & XMIT_SAME_RDEV_pre28))
 				write_int(f, (int)rdev);
@@ -459,51 +461,45 @@ void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
 
 #ifdef SUPPORT_LINKS
 	if (preserve_links && S_ISLNK(mode)) {
-		int len = strlen(file->u.link);
+		const char *sl = F_SYMLINK(file);
+		int len = strlen(sl);
 		write_int(f, len);
-		write_buf(f, file->u.link, len);
+		write_buf(f, sl, len);
 	}
 #endif
 
 #ifdef SUPPORT_HARD_LINKS
-	if (flags & XMIT_HAS_IDEV_DATA) {
+	if (tmp_dev != 0 && protocol_version < 30) {
 		if (protocol_version < 26) {
 			/* 32-bit dev_t and ino_t */
-			write_int(f, dev);
-			write_int(f, file->F_INODE);
+			write_int(f, (int32)dev);
+			write_int(f, (int32)tmp_ino);
 		} else {
 			/* 64-bit dev_t and ino_t */
-			if (!(flags & XMIT_SAME_DEV))
+			if (!(flags & XMIT_SAME_DEV_pre30))
 				write_longint(f, dev);
-			write_longint(f, file->F_INODE);
+			write_longint(f, tmp_ino);
 		}
 	}
 #endif
 
-	if (always_checksum) {
-		char *sum;
+	if (always_checksum && (S_ISREG(mode) || protocol_version < 28)) {
+		const char *sum;
 		if (S_ISREG(mode))
-			sum = file->u.sum;
-		else if (protocol_version < 28) {
+			sum = tmp_sum;
+		else {
 			/* Prior to 28, we sent a useless set of nulls. */
 			sum = empty_sum;
-		} else
-			sum = NULL;
-		if (sum) {
-			write_buf(f, sum,
-			    protocol_version < 21 ? 2 : MD4_SUM_LENGTH);
 		}
+		write_buf(f, sum, checksum_len);
 	}
 
+  the_end:
 	strlcpy(lastname, fname, MAXPATHLEN);
-
-	io_write_phase = "unknown";
 }
 
-
-
-static struct file_struct *receive_file_entry(struct file_list *flist,
-					      unsigned short flags, int f)
+static struct file_struct *recv_file_entry(struct file_list *flist,
+					   unsigned short flags, int f)
 {
 	static time_t modtime;
 	static mode_t mode;
@@ -518,14 +514,16 @@ static struct file_struct *receive_file_entry(struct file_list *flist,
 	static int in_del_hier = 0;
 	char thisname[MAXPATHLEN];
 	unsigned int l1 = 0, l2 = 0;
-	int alloc_len, basename_len, dirname_len, linkname_len, sum_len;
+	int alloc_len, basename_len, dirname_len, linkname_len;
+	int extra_len = flist_extra_cnt * EXTRA_LEN;
+	int first_hlink_ndx = -1;
 	OFF_T file_length;
 	char *basename, *dirname, *bp;
 	struct file_struct *file;
 
 	if (!flist) {
 		modtime = 0, mode = 0;
-		dev = 0, rdev = makedev(0, 0);
+		dev = 0, rdev = MAKEDEV(0, 0);
 		rdev_major = 0;
 		uid = 0, gid = 0;
 		*lastname = '\0';
@@ -544,9 +542,9 @@ static struct file_struct *receive_file_entry(struct file_list *flist,
 
 	if (l2 >= MAXPATHLEN - l1) {
 		rprintf(FERROR,
-			"overflow: flags=0x%x l1=%d l2=%d lastname=%s\n",
-			flags, l1, l2, safe_fname(lastname));
-		overflow_exit("receive_file_entry");
+			"overflow: flags=0x%x l1=%d l2=%d lastname=%s [%s]\n",
+			flags, l1, l2, lastname, who_am_i());
+		overflow_exit("recv_file_entry");
 	}
 
 	strlcpy(thisname, lastname, l1 + 1);
@@ -558,7 +556,7 @@ static struct file_struct *receive_file_entry(struct file_list *flist,
 	clean_fname(thisname, 0);
 
 	if (sanitize_paths)
-		sanitize_path(thisname, thisname, "", 0);
+		sanitize_path(thisname, thisname, "", 0, NULL);
 
 	if ((basename = strrchr(thisname, '/')) != NULL) {
 		dirname_len = ++basename - thisname; /* counts future '\0' */
@@ -575,25 +573,58 @@ static struct file_struct *receive_file_entry(struct file_list *flist,
 	}
 	basename_len = strlen(basename) + 1; /* count the '\0' */
 
+#ifdef SUPPORT_HARD_LINKS
+	if (protocol_version >= 30
+	 && BITS_SETnUNSET(flags, XMIT_HLINKED, XMIT_HLINK_FIRST)) {
+		struct file_struct *first;
+		first_hlink_ndx = read_int(f);
+		if (first_hlink_ndx < 0 || first_hlink_ndx >= flist->count) {
+			rprintf(FERROR,
+				"hard-link reference out of range: %d (%d)\n",
+				first_hlink_ndx, flist->count);
+			exit_cleanup(RERR_PROTOCOL);
+		}
+		first = flist->files[first_hlink_ndx];
+		file_length = F_LENGTH(first);
+		modtime = first->modtime;
+		mode = first->mode;
+		if (preserve_uid)
+			uid = F_UID(first);
+		if (preserve_gid)
+			gid = F_GID(first);
+		if ((preserve_devices && IS_DEVICE(mode))
+		 || (preserve_specials && IS_SPECIAL(mode))) {
+			uint32 *devp = F_RDEV_P(first);
+			rdev = MAKEDEV(DEV_MAJOR(devp), DEV_MINOR(devp));
+		}
+		if (preserve_links && S_ISLNK(mode))
+			linkname_len = strlen(F_SYMLINK(first)) + 1;
+		else
+			linkname_len = 0;
+		goto create_object;
+	}
+#endif
+
 	file_length = read_longint(f);
 	if (!(flags & XMIT_SAME_TIME))
 		modtime = (time_t)read_int(f);
 	if (!(flags & XMIT_SAME_MODE))
 		mode = from_wire_mode(read_int(f));
 
+	if (chmod_modes && !S_ISLNK(mode))
+		mode = tweak_mode(mode, chmod_modes);
+
 	if (preserve_uid && !(flags & XMIT_SAME_UID))
 		uid = (uid_t)read_int(f);
 	if (preserve_gid && !(flags & XMIT_SAME_GID))
 		gid = (gid_t)read_int(f);
 
-	if (preserve_devices) {
+	if ((preserve_devices && IS_DEVICE(mode))
+	 || (preserve_specials && IS_SPECIAL(mode))) {
 		if (protocol_version < 28) {
-			if (IS_DEVICE(mode)) {
-				if (!(flags & XMIT_SAME_RDEV_pre28))
-					rdev = (dev_t)read_int(f);
-			} else
-				rdev = makedev(0, 0);
-		} else if (IS_DEVICE(mode)) {
+			if (!(flags & XMIT_SAME_RDEV_pre28))
+				rdev = (dev_t)read_int(f);
+		} else {
 			uint32 rdev_minor;
 			if (!(flags & XMIT_SAME_RDEV_MAJOR))
 				rdev_major = read_int(f);
@@ -601,9 +632,12 @@ static struct file_struct *receive_file_entry(struct file_list *flist,
 				rdev_minor = read_byte(f);
 			else
 				rdev_minor = read_int(f);
-			rdev = makedev(rdev_major, rdev_minor);
+			rdev = MAKEDEV(rdev_major, rdev_minor);
 		}
-	}
+		extra_len += 2 * EXTRA_LEN;
+		file_length = 0;
+	} else if (protocol_version < 28)
+		rdev = MAKEDEV(0, 0);
 
 #ifdef SUPPORT_LINKS
 	if (preserve_links && S_ISLNK(mode)) {
@@ -611,29 +645,61 @@ static struct file_struct *receive_file_entry(struct file_list *flist,
 		if (linkname_len <= 0 || linkname_len > MAXPATHLEN) {
 			rprintf(FERROR, "overflow: linkname_len=%d\n",
 				linkname_len - 1);
-			overflow_exit("receive_file_entry");
+			overflow_exit("recv_file_entry");
 		}
 	}
 	else
 #endif
 		linkname_len = 0;
 
-	sum_len = always_checksum && S_ISREG(mode) ? MD4_SUM_LENGTH : 0;
+#ifdef SUPPORT_HARD_LINKS
+  create_object:
+	if (preserve_hard_links) {
+		if (protocol_version < 28 && S_ISREG(mode))
+			flags |= XMIT_HLINKED;
+		if (flags & XMIT_HLINKED)
+			extra_len += EXTRA_LEN;
+	}
+#endif
+
+	if (always_checksum && S_ISREG(mode))
+		extra_len += SUM_EXTRA_CNT * EXTRA_LEN;
+
+	if (file_length > 0xFFFFFFFFu && S_ISREG(mode))
+		extra_len += EXTRA_LEN;
+
+#if EXTRA_ROUNDING > 0
+	if (extra_len & (EXTRA_ROUNDING * EXTRA_LEN))
+		extra_len = (extra_len | (EXTRA_ROUNDING * EXTRA_LEN)) + EXTRA_LEN;
+#endif
 
-	alloc_len = file_struct_len + dirname_len + basename_len
-		  + linkname_len + sum_len;
-	bp = pool_alloc(flist->file_pool, alloc_len, "receive_file_entry");
+	alloc_len = FILE_STRUCT_LEN + extra_len + basename_len + dirname_len
+		  + linkname_len;
+	bp = pool_alloc(flist->file_pool, alloc_len, "recv_file_entry");
 
+	memset(bp, 0, extra_len + FILE_STRUCT_LEN);
+	bp += extra_len;
 	file = (struct file_struct *)bp;
-	memset(bp, 0, file_struct_len);
-	bp += file_struct_len;
+	bp += FILE_STRUCT_LEN;
+
+	memcpy(bp, basename, basename_len);
+	bp += basename_len + linkname_len; /* skip space for symlink too */
 
-	file->flags = 0;
+#ifdef SUPPORT_HARD_LINKS
+	if (flags & XMIT_HLINKED)
+		file->flags |= FLAG_HLINKED;
+#endif
 	file->modtime = modtime;
-	file->length = file_length;
+	file->len32 = (uint32)file_length;
+	if (file_length > 0xFFFFFFFFu && S_ISREG(mode)) {
+		file->flags |= FLAG_LENGTH64;
+		OPT_EXTRA(file, 0)->unum = (uint32)(file_length >> 32);
+	}
 	file->mode = mode;
-	file->uid = uid;
-	file->gid = gid;
+	if (preserve_uid)
+		F_UID(file) = uid;
+	if (preserve_gid)
+		F_GID(file) = gid;
 
 	if (dirname_len) {
 		file->dirname = lastdir = bp;
@@ -642,98 +708,100 @@ static struct file_struct *receive_file_entry(struct file_list *flist,
 		bp += dirname_len;
 		bp[-1] = '\0';
 		lastdir_depth = count_dir_elements(lastdir);
-		file->dir.depth = lastdir_depth + 1;
+		F_DEPTH(file) = lastdir_depth + 1;
 	} else if (dirname) {
 		file->dirname = dirname; /* we're reusing lastname */
-		file->dir.depth = lastdir_depth + 1;
+		F_DEPTH(file) = lastdir_depth + 1;
 	} else
-		file->dir.depth = 1;
+		F_DEPTH(file) = 1;
 
 	if (S_ISDIR(mode)) {
 		if (basename_len == 1+1 && *basename == '.') /* +1 for '\0' */
-			file->dir.depth--;
+			F_DEPTH(file)--;
 		if (flags & XMIT_TOP_DIR) {
-			in_del_hier = 1;
-			del_hier_name_len = file->dir.depth == 0 ? 0 : l1 + l2;
+			in_del_hier = recurse;
+			del_hier_name_len = F_DEPTH(file) == 0 ? 0 : l1 + l2;
 			if (relative_paths && del_hier_name_len > 2
-			    && basename_len == 1+1 && *basename == '.')
+			    && lastname[del_hier_name_len-1] == '.'
+			    && lastname[del_hier_name_len-2] == '/')
 				del_hier_name_len -= 2;
-			file->flags |= FLAG_TOP_DIR | FLAG_DEL_HERE;
+			file->flags |= FLAG_TOP_DIR | FLAG_XFER_DIR;
 		} else if (in_del_hier) {
 			if (!relative_paths || !del_hier_name_len
 			 || (l1 >= del_hier_name_len
-			  && thisname[del_hier_name_len] == '/'))
-				file->flags |= FLAG_DEL_HERE;
+			  && lastname[del_hier_name_len] == '/'))
+				file->flags |= FLAG_XFER_DIR;
 			else
 				in_del_hier = 0;
 		}
 	}
 
-	file->basename = bp;
-	memcpy(bp, basename, basename_len);
-	bp += basename_len;
-
-	if (preserve_devices && IS_DEVICE(mode))
-		file->u.rdev = rdev;
+	if ((preserve_devices && IS_DEVICE(mode))
+	 || (preserve_specials && IS_SPECIAL(mode))) {
+		uint32 *devp = F_RDEV_P(file);
+		DEV_MAJOR(devp) = major(rdev);
+		DEV_MINOR(devp) = minor(rdev);
+	}
 
 #ifdef SUPPORT_LINKS
 	if (linkname_len) {
-		file->u.link = bp;
-		read_sbuf(f, bp, linkname_len - 1);
+		bp = (char*)file->basename + basename_len;
+		if (first_hlink_ndx >= 0) {
+			struct file_struct *first = flist->files[first_hlink_ndx];
+			memcpy(bp, F_SYMLINK(first), linkname_len);
+		} else
+			read_sbuf(f, bp, linkname_len - 1);
 		if (sanitize_paths)
-			sanitize_path(bp, bp, "", lastdir_depth);
-		bp += linkname_len;
+			sanitize_path(bp, bp, "", lastdir_depth, NULL);
 	}
 #endif
 
 #ifdef SUPPORT_HARD_LINKS
-	if (preserve_hard_links && protocol_version < 28 && S_ISREG(mode))
-		flags |= XMIT_HAS_IDEV_DATA;
-	if (flags & XMIT_HAS_IDEV_DATA) {
-		int64 inode;
-		if (protocol_version < 26) {
-			dev = read_int(f);
-			inode = read_int(f);
+	if (preserve_hard_links && flags & XMIT_HLINKED) {
+		if (protocol_version >= 30) {
+			F_HL_GNUM(file) = flags & XMIT_HLINK_FIRST
+					? flist->count : first_hlink_ndx;
 		} else {
-			if (!(flags & XMIT_SAME_DEV))
-				dev = read_longint(f);
-			inode = read_longint(f);
-		}
-		if (flist->hlink_pool) {
-			file->link_u.idev = pool_talloc(flist->hlink_pool,
-			    struct idev, 1, "inode_table");
-			file->F_INODE = inode;
-			file->F_DEV = dev;
+			static int32 cnt = 0;
+			struct idev_node *np;
+			int64 ino;
+			int32 ndx;
+			if (protocol_version < 26) {
+				dev = read_int(f);
+				ino = read_int(f);
+			} else {
+				if (!(flags & XMIT_SAME_DEV_pre30))
+					dev = read_longint(f);
+				ino = read_longint(f);
+			}
+			np = idev_node(dev, ino);
+			ndx = (int32)np->data - 1;
+			if (ndx < 0) {
+				ndx = cnt++;
+				np->data = (void*)cnt;
+			}
+			F_HL_GNUM(file) = ndx;
 		}
 	}
 #endif
 
-	if (always_checksum) {
-		char *sum;
-		if (sum_len) {
-			file->u.sum = sum = bp;
-			/*bp += sum_len;*/
-		} else if (protocol_version < 28) {
+	if (always_checksum && (S_ISREG(mode) || protocol_version < 28)) {
+		if (S_ISREG(mode))
+			bp = (char*)F_SUM(file);
+		else {
 			/* Prior to 28, we get a useless set of nulls. */
-			sum = empty_sum;
-		} else
-			sum = NULL;
-		if (sum) {
-			read_buf(f, sum,
-			    protocol_version < 21 ? 2 : MD4_SUM_LENGTH);
+			bp = tmp_sum;
 		}
-	}
-
-	if (!preserve_perms) {
-		/* set an appropriate set of permissions based on original
-		 * permissions and umask. This emulates what GNU cp does */
-		file->mode &= ~orig_umask;
+		if (first_hlink_ndx >= 0) {
+			struct file_struct *first = flist->files[first_hlink_ndx];
+			memcpy(bp, F_SUM(first), checksum_len);
+		} else
+			read_buf(f, bp, checksum_len);
 	}
 
 	return file;
 }
 
-
 /**
  * Create a file_struct for a named file by reading its stat()
  * information and performing extensive checks against global
@@ -749,41 +817,44 @@ static struct file_struct *receive_file_entry(struct file_list *flist,
  * statting directories if we're not recursing, but this is not a very
  * important case.  Some systems may not have d_type.
  **/
-struct file_struct *make_file(char *fname, struct file_list *flist,
-			      int filter_level)
+struct file_struct *make_file(const char *fname, struct file_list *flist,
+			      STRUCT_STAT *stp, int flags, int filter_level)
 {
 	static char *lastdir;
 	static int lastdir_len = -1;
 	struct file_struct *file;
 	STRUCT_STAT st;
-	char sum[SUM_LENGTH];
 	char thisname[MAXPATHLEN];
 	char linkname[MAXPATHLEN];
-	int alloc_len, basename_len, dirname_len, linkname_len, sum_len;
+	int alloc_len, basename_len, dirname_len, linkname_len;
+	int extra_len = flist_extra_cnt * EXTRA_LEN;
 	char *basename, *dirname, *bp;
-	unsigned short flags = 0;
 
 	if (!flist || !flist->count)	/* Ignore lastdir when invalid. */
 		lastdir_len = -1;
 
 	if (strlcpy(thisname, fname, sizeof thisname)
 	    >= sizeof thisname - flist_dir_len) {
-		rprintf(FINFO, "skipping overly long name: %s\n",
-			safe_fname(fname));
+		rprintf(FINFO, "skipping overly long name: %s\n", fname);
 		return NULL;
 	}
 	clean_fname(thisname, 0);
 	if (sanitize_paths)
-		sanitize_path(thisname, thisname, "", 0);
-
-	memset(sum, 0, SUM_LENGTH);
+		sanitize_path(thisname, thisname, "", 0, NULL);
 
-	if (readlink_stat(thisname, &st, linkname) != 0) {
+	if (stp && S_ISDIR(stp->st_mode)) {
+		st = *stp; /* Needed for "symlink/." with --relative. */
+		*linkname = '\0'; /* make IBM code checker happy */
+	} else if (readlink_stat(thisname, &st, linkname) != 0) {
 		int save_errno = errno;
 		/* See if file is excluded before reporting an error. */
 		if (filter_level != NO_FILTERS
-		    && is_excluded(thisname, 0, filter_level))
+		 && (is_excluded(thisname, 0, filter_level)
+		  || is_excluded(thisname, 1, filter_level))) {
+			if (ignore_perishable && save_errno != ENOENT)
+				non_perishable_cnt++;
 			return NULL;
+		}
 		if (save_errno == ENOENT) {
 #ifdef SUPPORT_LINKS
 			/* Avoid "vanished" error if symlink points nowhere. */
@@ -814,19 +885,30 @@ struct file_struct *make_file(char *fname, struct file_list *flist,
 		goto skip_filters;
 
 	if (S_ISDIR(st.st_mode) && !xfer_dirs) {
-		rprintf(FINFO, "skipping directory %s\n", safe_fname(thisname));
+		rprintf(FINFO, "skipping directory %s\n", thisname);
 		return NULL;
 	}
 
-	/* We only care about directories because we need to avoid recursing
+	/* -x only affects directories because we need to avoid recursing
 	 * into a mount-point directory, not to avoid copying a symlinked
 	 * file if -L (or similar) was specified. */
 	if (one_file_system && st.st_dev != filesystem_dev
-	    && S_ISDIR(st.st_mode))
-		flags |= FLAG_MOUNT_POINT;
+	 && S_ISDIR(st.st_mode)) {
+		if (one_file_system > 1) {
+			if (verbose > 2) {
+				rprintf(FINFO, "skipping mount-point dir %s\n",
+					thisname);
+			}
+			return NULL;
+		}
+		flags |= FLAG_MOUNT_DIR;
+	}
 
-	if (is_excluded(thisname, S_ISDIR(st.st_mode) != 0, filter_level))
+	if (is_excluded(thisname, S_ISDIR(st.st_mode) != 0, filter_level)) {
+		if (ignore_perishable)
+			non_perishable_cnt++;
 		return NULL;
+	}
 
 	if (lp_ignore_nonreadable(module_id)) {
 #ifdef SUPPORT_LINKS
@@ -836,11 +918,11 @@ struct file_struct *make_file(char *fname, struct file_list *flist,
 				return NULL;
 	}
 
-skip_filters:
+  skip_filters:
 
 	if (verbose > 2) {
 		rprintf(FINFO, "[%s] make_file(%s,*,%d)\n",
-			who_am_i(), safe_fname(thisname), filter_level);
+			who_am_i(), thisname, filter_level);
 	}
 
 	if ((basename = strrchr(thisname, '/')) != NULL) {
@@ -864,49 +946,63 @@ skip_filters:
 	linkname_len = 0;
 #endif
 
-	sum_len = always_checksum && S_ISREG(st.st_mode) ? MD4_SUM_LENGTH : 0;
+	if (st.st_size > 0xFFFFFFFFu && S_ISREG(st.st_mode))
+		extra_len += EXTRA_LEN;
 
-	alloc_len = file_struct_len + dirname_len + basename_len
-	    + linkname_len + sum_len;
-	if (flist) {
-		bp = pool_alloc(flist->file_pool, alloc_len,
-		    "receive_file_entry");
-	} else {
+#if EXTRA_ROUNDING > 0
+	if (extra_len & (EXTRA_ROUNDING * EXTRA_LEN))
+		extra_len = (extra_len | (EXTRA_ROUNDING * EXTRA_LEN)) + EXTRA_LEN;
+#endif
+
+	alloc_len = FILE_STRUCT_LEN + extra_len + basename_len + dirname_len
+		  + linkname_len;
+	if (flist)
+		bp = pool_alloc(flist->file_pool, alloc_len, "make_file");
+	else {
 		if (!(bp = new_array(char, alloc_len)))
-			out_of_memory("receive_file_entry");
+			out_of_memory("make_file");
 	}
 
+	memset(bp, 0, extra_len + FILE_STRUCT_LEN);
+	bp += extra_len;
 	file = (struct file_struct *)bp;
-	memset(bp, 0, file_struct_len);
-	bp += file_struct_len;
+	bp += FILE_STRUCT_LEN;
 
-	file->flags = flags;
-	file->modtime = st.st_mtime;
-	file->length = st.st_size;
-	file->mode = st.st_mode;
-	file->uid = st.st_uid;
-	file->gid = st.st_gid;
+	memcpy(bp, basename, basename_len);
+	bp += basename_len + linkname_len; /* skip space for symlink too */
 
 #ifdef SUPPORT_HARD_LINKS
-	if (flist && flist->hlink_pool) {
-		if (protocol_version < 28) {
-			if (S_ISREG(st.st_mode))
-				file->link_u.idev = pool_talloc(
-				    flist->hlink_pool, struct idev, 1,
-				    "inode_table");
-		} else {
-			if (!S_ISDIR(st.st_mode) && st.st_nlink > 1)
-				file->link_u.idev = pool_talloc(
-				    flist->hlink_pool, struct idev, 1,
-				    "inode_table");
-		}
+	if (preserve_hard_links && flist) {
+		if (protocol_version >= 28
+		 ? (!S_ISDIR(st.st_mode) && st.st_nlink > 1)
+		 : S_ISREG(st.st_mode)) {
+			tmp_dev = st.st_dev;
+			tmp_ino = st.st_ino;
+		} else
+			tmp_dev = 0;
 	}
-	if (file->link_u.idev) {
-		file->F_DEV = st.st_dev;
-		file->F_INODE = st.st_ino;
+#endif
+
+#ifdef HAVE_STRUCT_STAT_ST_RDEV
+	if (IS_DEVICE(st.st_mode) || IS_SPECIAL(st.st_mode)) {
+		tmp_rdev = st.st_rdev;
+		st.st_size = 0;
 	}
 #endif
 
+	file->flags = flags;
+	file->modtime = st.st_mtime;
+	file->len32 = (uint32)st.st_size;
+	if (st.st_size > 0xFFFFFFFFu && S_ISREG(st.st_mode)) {
+		file->flags |= FLAG_LENGTH64;
+		OPT_EXTRA(file, 0)->unum = (uint32)(st.st_size >> 32);
+	}
+	file->mode = st.st_mode;
+	if (preserve_uid)
+		F_UID(file) = st.st_uid;
+	if (preserve_gid)
+		F_GID(file) = st.st_gid;
+
 	if (dirname_len) {
 		file->dirname = lastdir = bp;
 		lastdir_len = dirname_len - 1;
@@ -916,45 +1012,33 @@ skip_filters:
 	} else if (dirname)
 		file->dirname = dirname;
 
-	file->basename = bp;
-	memcpy(bp, basename, basename_len);
-	bp += basename_len;
-
-#ifdef HAVE_STRUCT_STAT_ST_RDEV
-	if (preserve_devices && IS_DEVICE(st.st_mode))
-		file->u.rdev = st.st_rdev;
-#endif
-
 #ifdef SUPPORT_LINKS
 	if (linkname_len) {
-		file->u.link = bp;
+		bp = (char*)file->basename + basename_len;
 		memcpy(bp, linkname, linkname_len);
-		bp += linkname_len;
 	}
 #endif
 
-	if (sum_len) {
-		file->u.sum = bp;
-		file_checksum(thisname, bp, st.st_size);
-		/*bp += sum_len;*/
-	}
+	if (always_checksum && am_sender && S_ISREG(st.st_mode))
+		file_checksum(thisname, tmp_sum, st.st_size);
 
-	file->dir.root = flist_dir;
+	F_ROOTDIR(file) = flist_dir;
 
 	/* This code is only used by the receiver when it is building
 	 * a list of files for a delete pass. */
 	if (keep_dirlinks && linkname_len && flist) {
 		STRUCT_STAT st2;
 		int save_mode = file->mode;
-		file->mode = S_IFDIR; /* find a directory w/our name */
+		file->mode = S_IFDIR; /* Find a directory with our name. */
 		if (flist_find(the_file_list, file) >= 0
 		    && do_stat(thisname, &st2) == 0 && S_ISDIR(st2.st_mode)) {
 			file->modtime = st2.st_mtime;
-			file->length = st2.st_size;
+			file->len32 = 0;
 			file->mode = st2.st_mode;
-			file->uid = st2.st_uid;
-			file->gid = st2.st_gid;
-			file->u.link = NULL;
+			if (preserve_uid)
+				F_UID(file) = st2.st_uid;
+			if (preserve_gid)
+				F_GID(file) = st2.st_gid;
 		} else
 			file->mode = save_mode;
 	}
@@ -962,37 +1046,54 @@ skip_filters:
 	if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode))
 		stats.total_size += st.st_size;
 
+	if (basename_len == 0+1)
+		return NULL;
+
 	return file;
 }
 
+/* Only called for temporary file_struct entries created by make_file(). */
+void unmake_file(struct file_struct *file)
+{
+	int extra_cnt = flist_extra_cnt + LEN64_BUMP(file);
+#if EXTRA_ROUNDING > 0
+	if (extra_cnt & EXTRA_ROUNDING)
+		extra_cnt = (extra_cnt | EXTRA_ROUNDING) + 1;
+#endif
+	free(REQ_EXTRA(file, extra_cnt));
+}
 
 static struct file_struct *send_file_name(int f, struct file_list *flist,
-					  char *fname, unsigned short base_flags)
+					  char *fname, STRUCT_STAT *stp,
+					  unsigned short flags)
 {
 	struct file_struct *file;
 
-	file = make_file(fname, flist, f == -2 ? SERVER_FILTERS : ALL_FILTERS);
+	file = make_file(fname, flist, stp, flags,
+			 f == -2 ? SERVER_FILTERS : ALL_FILTERS);
 	if (!file)
 		return NULL;
 
+	if (chmod_modes && !S_ISLNK(file->mode))
+		file->mode = tweak_mode(file->mode, chmod_modes);
+
 	maybe_emit_filelist_progress(flist->count + flist_count_offset);
 
 	flist_expand(flist);
-
-	if (file->basename[0]) {
-		flist->files[flist->count++] = file;
-		send_file_entry(file, f, base_flags);
-	}
+	flist->files[flist->count++] = file;
+	if (f >= 0)
+		send_file_entry(file, f, flist->count - 1);
 	return file;
 }
 
 static void send_if_directory(int f, struct file_list *flist,
-			      struct file_struct *file)
+			      struct file_struct *file,
+			      char *fbuf, unsigned int ol)
 {
-	char fbuf[MAXPATHLEN];
+	char is_dot_dir = fbuf[ol-1] == '.' && (ol == 1 || fbuf[ol-2] == '/');
 
 	if (S_ISDIR(file->mode)
-	    && !(file->flags & FLAG_MOUNT_POINT) && f_name_to(file, fbuf)) {
+	    && !(file->flags & FLAG_MOUNT_DIR) && f_name(file, fbuf)) {
 		void *save_filters;
 		unsigned int len = strlen(fbuf);
 		if (len > 1 && fbuf[len-1] == '/')
@@ -1006,17 +1107,18 @@ static void send_if_directory(int f, struct file_list *flist,
 		save_filters = push_local_filters(fbuf, len);
 		send_directory(f, flist, fbuf, len);
 		pop_local_filters(save_filters);
+		fbuf[ol] = '\0';
+		if (is_dot_dir)
+			fbuf[ol-1] = '.';
 	}
 }
 
-
 /* This function is normally called by the sender, but the receiving side also
  * calls it from get_dirlist() with f set to -1 so that we just construct the
  * file list in memory without sending it over the wire.  Also, get_dirlist()
  * might call this with f set to -2, which also indicates that local filter
  * rules should be ignored. */
-static void send_directory(int f, struct file_list *flist,
-			   char *fbuf, int len)
+static void send_directory(int f, struct file_list *flist, char *fbuf, int len)
 {
 	struct dirent *di;
 	unsigned remainder;
@@ -1041,14 +1143,15 @@ static void send_directory(int f, struct file_list *flist,
 		if (dname[0] == '.' && (dname[1] == '\0'
 		    || (dname[1] == '.' && dname[2] == '\0')))
 			continue;
-		if (strlcpy(p, dname, remainder) < remainder)
-			send_file_name(f, flist, fbuf, 0);
-		else {
+		if (strlcpy(p, dname, remainder) >= remainder) {
 			io_error |= IOERR_GENERAL;
 			rprintf(FINFO,
 				"cannot send long-named file %s\n",
 				full_fname(fbuf));
+			continue;
 		}
+
+		send_file_name(f, flist, fbuf, NULL, 0);
 	}
 
 	fbuf[len] = '\0';
@@ -1062,15 +1165,15 @@ static void send_directory(int f, struct file_list *flist,
 
 	if (recurse) {
 		int i, end = flist->count - 1;
+		/* send_if_directory() bumps flist->count, so use "end". */
 		for (i = start; i <= end; i++)
-			send_if_directory(f, flist, flist->files[i]);
+			send_if_directory(f, flist, flist->files[i], fbuf, len);
 	}
 }
 
-
 struct file_list *send_file_list(int f, int argc, char *argv[])
 {
-	int l;
+	int len;
 	STRUCT_STAT st;
 	char *p, *dir, olddir[sizeof curr_dir];
 	char lastpath[MAXPATHLEN] = "";
@@ -1079,17 +1182,23 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
 	int64 start_write;
 	int use_ff_fd = 0;
 
+	rprintf(FLOG, "building file list\n");
 	if (show_filelist_p())
 		start_filelist_progress("building file list");
 
 	start_write = stats.total_written;
 	gettimeofday(&start_tv, NULL);
 
-	flist = flist_new(WITH_HLINK, "send_file_list");
+#ifdef SUPPORT_HARD_LINKS
+	if (preserve_hard_links && protocol_version >= 30)
+		init_hard_links();
+#endif
+
+	flist = flist_new("send_file_list");
 
 	io_start_buffering_out();
 	if (filesfrom_fd >= 0) {
-		if (argv[0] && !push_dir(argv[0])) {
+		if (argv[0] && !push_dir(argv[0], 0)) {
 			rsyserr(FERROR, errno, "push_dir %s failed",
 				full_fname(argv[0]));
 			exit_cleanup(RERR_FILESELECT);
@@ -1098,58 +1207,59 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
 	}
 
 	while (1) {
-		struct file_struct *file;
-		char fname2[MAXPATHLEN];
-		char *fname = fname2;
+		char fbuf[MAXPATHLEN];
+		char *fn;
 		int is_dot_dir;
 
 		if (use_ff_fd) {
-			if (read_filesfrom_line(filesfrom_fd, fname) == 0)
+			if (read_filesfrom_line(filesfrom_fd, fbuf) == 0)
 				break;
-			sanitize_path(fname, fname, "", 0);
+			sanitize_path(fbuf, fbuf, "", 0, NULL);
 		} else {
 			if (argc-- == 0)
 				break;
-			strlcpy(fname, *argv++, MAXPATHLEN);
+			strlcpy(fbuf, *argv++, MAXPATHLEN);
 			if (sanitize_paths)
-				sanitize_path(fname, fname, "", 0);
+				sanitize_path(fbuf, fbuf, "", 0, NULL);
 		}
 
-		l = strlen(fname);
-		if (!l || fname[l - 1] == '/') {
-			if (l == 2 && fname[0] == '.') {
+		len = strlen(fbuf);
+		if (relative_paths) {
+			/* We clean up fbuf below. */
+			is_dot_dir = 0;
+		} else if (!len || fbuf[len - 1] == '/') {
+			if (len == 2 && fbuf[0] == '.') {
 				/* Turn "./" into just "." rather than "./." */
-				fname[1] = '\0';
+				fbuf[1] = '\0';
 			} else {
-				if (l + 1 >= MAXPATHLEN)
+				if (len + 1 >= MAXPATHLEN)
 					overflow_exit("send_file_list");
-				fname[l++] = '.';
-				fname[l] = '\0';
+				fbuf[len++] = '.';
+				fbuf[len] = '\0';
 			}
 			is_dot_dir = 1;
-		} else if (l > 1 && fname[l-1] == '.' && fname[l-2] == '.'
-		    && (l == 2 || fname[l-3] == '/')) {
-			if (l + 2 >= MAXPATHLEN)
+		} else if (len > 1 && fbuf[len-1] == '.' && fbuf[len-2] == '.'
+		    && (len == 2 || fbuf[len-3] == '/')) {
+			if (len + 2 >= MAXPATHLEN)
 				overflow_exit("send_file_list");
-			fname[l++] = '/';
-			fname[l++] = '.';
-			fname[l] = '\0';
+			fbuf[len++] = '/';
+			fbuf[len++] = '.';
+			fbuf[len] = '\0';
 			is_dot_dir = 1;
 		} else {
-			is_dot_dir = fname[l-1] == '.'
-				   && (l == 1 || fname[l-2] == '/');
+			is_dot_dir = fbuf[len-1] == '.'
+				   && (len == 1 || fbuf[len-2] == '/');
 		}
 
-		if (link_stat(fname, &st, keep_dirlinks) != 0) {
+		if (link_stat(fbuf, &st, copy_dirlinks) != 0) {
 			io_error |= IOERR_GENERAL;
 			rsyserr(FERROR, errno, "link_stat %s failed",
-				full_fname(fname));
+				full_fname(fbuf));
 			continue;
 		}
 
 		if (S_ISDIR(st.st_mode) && !xfer_dirs) {
-			rprintf(FINFO, "skipping directory %s\n",
-				safe_fname(fname));
+			rprintf(FINFO, "skipping directory %s\n", fbuf);
 			continue;
 		}
 
@@ -1157,56 +1267,74 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
 		olddir[0] = '\0';
 
 		if (!relative_paths) {
-			p = strrchr(fname, '/');
+			p = strrchr(fbuf, '/');
 			if (p) {
 				*p = '\0';
-				if (p == fname)
+				if (p == fbuf)
 					dir = "/";
 				else
-					dir = fname;
-				fname = p + 1;
-			}
-		} else if (implied_dirs && (p=strrchr(fname,'/')) && p != fname) {
-			/* Send the implied directories at the start of the
-			 * source spec, so we get their permissions right. */
-			char *lp = lastpath, *fn = fname, *slash = fname;
-			*p = '\0';
-			/* Skip any initial directories in our path that we
-			 * have in common with lastpath. */
-			while (*fn && *lp == *fn) {
-				if (*fn == '/')
-					slash = fn;
-				lp++, fn++;
+					dir = fbuf;
+				len -= p - fbuf + 1;
+				fn = p + 1;
+			} else
+				fn = fbuf;
+		} else {
+			if ((p = strstr(fbuf, "/./")) != NULL) {
+				*p = '\0';
+				if (p == fbuf)
+					dir = "/";
+				else
+					dir = fbuf;
+				len -= p - fbuf + 3;
+				fn = p + 3;
+			} else
+				fn = fbuf;
+			/* Get rid of trailing "/" and "/.". */
+			while (len) {
+				if (fn[len - 1] == '/') {
+					is_dot_dir = 1;
+					if (!--len && !dir) {
+						len++;
+						break;
+					}
+				}
+				else if (len >= 2 && fn[len - 1] == '.'
+						  && fn[len - 2] == '/') {
+					is_dot_dir = 1;
+					if (!(len -= 2) && !dir) {
+						len++;
+						break;
+					}
+				} else
+					break;
 			}
-			*p = '/';
-			if (fn != p || (*lp && *lp != '/')) {
-				int save_copy_links = copy_links;
-				int save_xfer_dirs = xfer_dirs;
-				copy_links = copy_unsafe_links;
-				xfer_dirs = 1;
-				while ((slash = strchr(slash+1, '/')) != 0) {
-					*slash = '\0';
-					send_file_name(f, flist, fname, 0);
-					*slash = '/';
+			if (len == 1 && fn[0] == '/')
+				fn[len++] = '.';
+			fn[len] = '\0';
+			/* Reject a ".." dir in the active part of the path. */
+			for (p = fn; (p = strstr(p, "..")) != NULL; p += 2) {
+				if ((p[2] == '/' || p[2] == '\0')
+				 && (p == fn || p[-1] == '/')) {
+					rprintf(FERROR,
+					    "found \"..\" dir in relative path: %s\n",
+					    fbuf);
+					exit_cleanup(RERR_SYNTAX);
 				}
-				copy_links = save_copy_links;
-				xfer_dirs = save_xfer_dirs;
-				*p = '\0';
-				strlcpy(lastpath, fname, sizeof lastpath);
-				*p = '/';
 			}
 		}
 
-		if (!*fname)
-			fname = ".";
+		if (!*fn) {
+			len = 1;
+			fn = ".";
+		}
 
 		if (dir && *dir) {
-			static char *lastdir;
+			static const char *lastdir;
 			static int lastdir_len;
 
-			strcpy(olddir, curr_dir); /* can't overflow */
+			strlcpy(olddir, curr_dir, sizeof olddir);
 
-			if (!push_dir(dir)) {
+			if (!push_dir(dir, 0)) {
 				io_error |= IOERR_GENERAL;
 				rsyserr(FERROR, errno, "push_dir %s failed",
 					full_fname(dir));
@@ -1222,20 +1350,56 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
 			}
 		}
 
+		if (fn != fbuf)
+			memmove(fbuf, fn, len + 1);
+
+		if (implied_dirs && (p=strrchr(fbuf,'/')) && p != fbuf) {
+			/* Send the implied directories at the start of the
+			 * source spec, so we get their permissions right. */
+			char *lp = lastpath, *slash = fbuf;
+			*p = '\0';
+			/* Skip any initial directories in our path that we
+			 * have in common with lastpath. */
+			for (fn = fbuf; *fn && *lp == *fn; lp++, fn++) {
+				if (*fn == '/')
+					slash = fn;
+			}
+			*p = '/';
+			if (fn != p || (*lp && *lp != '/')) {
+				int save_copy_links = copy_links;
+				int save_xfer_dirs = xfer_dirs;
+				copy_links |= copy_unsafe_links;
+				xfer_dirs = 1;
+				while ((slash = strchr(slash+1, '/')) != 0) {
+					*slash = '\0';
+					send_file_name(f, flist, fbuf, NULL, 0);
+					*slash = '/';
+				}
+				copy_links = save_copy_links;
+				xfer_dirs = save_xfer_dirs;
+				*p = '\0';
+				strlcpy(lastpath, fbuf, sizeof lastpath);
+				*p = '/';
+			}
+		}
+
 		if (one_file_system)
 			filesystem_dev = st.st_dev;
 
-		if ((file = send_file_name(f, flist, fname, XMIT_TOP_DIR))) {
-			if (recurse || (xfer_dirs && is_dot_dir))
-				send_if_directory(f, flist, file);
-		}
+		if (recurse || (xfer_dirs && is_dot_dir)) {
+			struct file_struct *file;
+			file = send_file_name(f, flist, fbuf, &st, FLAG_TOP_DIR);
+			if (file)
+				send_if_directory(f, flist, file, fbuf, len);
+		} else
+			send_file_name(f, flist, fbuf, &st, 0);
 
 		if (olddir[0]) {
 			flist_dir = NULL;
 			flist_dir_len = 0;
 			if (!pop_dir(olddir)) {
 				rsyserr(FERROR, errno, "pop_dir %s failed",
-					full_fname(dir));
+					full_fname(olddir));
 				exit_cleanup(RERR_FILESELECT);
 			}
 		}
@@ -1248,7 +1412,12 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
 		stats.flist_buildtime = 1;
 	start_tv = end_tv;
 
-	send_file_entry(NULL, f, 0);
+	write_byte(f, 0); /* Indicate end of file list */
+
+#ifdef SUPPORT_HARD_LINKS
+	if (preserve_hard_links && protocol_version >= 30)
+		idev_destroy();
+#endif
 
 	if (show_filelist_p())
 		finish_filelist_progress(flist);
@@ -1257,20 +1426,14 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
 	stats.flist_xfertime = (int64)(end_tv.tv_sec - start_tv.tv_sec) * 1000
 			     + (end_tv.tv_usec - start_tv.tv_usec) / 1000;
 
-	if (flist->hlink_pool) {
-		pool_destroy(flist->hlink_pool);
-		flist->hlink_pool = NULL;
-	}
-
 	/* Sort the list without removing any duplicates.  This allows the
 	 * receiving side to ask for any name they like, which gives us the
 	 * flexibility to change the way we unduplicate names in the future
 	 * without causing a compatibility problem with older versions. */
 	clean_flist(flist, 0, 0);
 
-	/* Now send the uid/gid list. This was introduced in
-	 * protocol version 15 */
-	send_uid_list(f);
+	if (!numeric_ids)
+		send_uid_list(f);
 
 	/* send the io_error flag */
 	write_int(f, lp_ignore_errors(module_id) ? 0 : io_error);
@@ -1288,26 +1451,24 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
 	return flist;
 }
 
-
 struct file_list *recv_file_list(int f)
 {
 	struct file_list *flist;
 	unsigned short flags;
 	int64 start_read;
 
+	rprintf(FLOG, "receiving file list\n");
 	if (show_filelist_p())
 		start_filelist_progress("receiving file list");
 
 	start_read = stats.total_read;
 
-	flist = flist_new(WITH_HLINK, "recv_file_list");
-
-	flist->count = 0;
-	flist->malloced = 1000;
-	flist->files = new_array(struct file_struct *, flist->malloced);
-	if (!flist->files)
-		goto oom;
+	flist = flist_new("recv_file_list");
 
+#ifdef SUPPORT_HARD_LINKS
+	if (preserve_hard_links && protocol_version < 30)
+		init_hard_links();
+#endif
 
 	while ((flags = read_byte(f)) != 0) {
 		struct file_struct *file;
@@ -1316,10 +1477,10 @@ struct file_list *recv_file_list(int f)
 
 		if (protocol_version >= 28 && (flags & XMIT_EXTENDED_FLAGS))
 			flags |= read_byte(f) << 8;
-		file = receive_file_entry(flist, flags, f);
+		file = recv_file_entry(flist, flags, f);
 
-		if (S_ISREG(file->mode))
-			stats.total_size += file->length;
+		if (S_ISREG(file->mode) || S_ISLNK(file->mode))
+			stats.total_size += F_LENGTH(file);
 
 		flist->files[flist->count++] = file;
 
@@ -1327,10 +1488,10 @@ struct file_list *recv_file_list(int f)
 
 		if (verbose > 2) {
 			rprintf(FINFO, "recv_file_name(%s)\n",
-				safe_fname(f_name(file)));
+				f_name(file, NULL));
 		}
 	}
-	receive_file_entry(NULL, 0, 0); /* Signal that we're done. */
+	recv_file_entry(NULL, 0, 0); /* Signal that we're done. */
 
 	if (verbose > 2)
 		rprintf(FINFO, "received %d names\n", flist->count);
@@ -1341,8 +1502,6 @@ struct file_list *recv_file_list(int f)
 	clean_flist(flist, relative_paths, 1);
 
 	if (f >= 0) {
-		/* Now send the uid/gid list. This was introduced in
-		 * protocol version 15 */
 		recv_uid_list(f, flist);
 
 		/* Recv the io_error flag */
@@ -1368,65 +1527,81 @@ struct file_list *recv_file_list(int f)
 	stats.num_files = flist->count;
 
 	return flist;
-
-oom:
-	out_of_memory("recv_file_list");
-	return NULL;		/* not reached */
 }
 
-
 static int file_compare(struct file_struct **file1, struct file_struct **file2)
 {
 	return f_name_cmp(*file1, *file2);
 }
 
-
 /* Search for an identically-named item in the file list.  Note that the
  * items must agree in their directory-ness, or no match is returned. */
 int flist_find(struct file_list *flist, struct file_struct *f)
 {
 	int low = flist->low, high = flist->high;
-	int ret, mid, mid_up;
+	int diff, mid, mid_up;
 
 	while (low <= high) {
 		mid = (low + high) / 2;
-		for (mid_up = mid; !flist->files[mid_up]->basename; mid_up++) {}
-		if (mid_up <= high)
-			ret = f_name_cmp(flist->files[mid_up], f);
-		else
-			ret = 1;
-		if (ret == 0) {
+		if (F_IS_ACTIVE(flist->files[mid]))
+			mid_up = mid;
+		else {
+			/* Scan for the next non-empty entry using the cached
+			 * distance values.  If the value isn't fully up-to-
+			 * date, update it. */
+			mid_up = mid + F_DEPTH(flist->files[mid]);
+			if (!F_IS_ACTIVE(flist->files[mid_up])) {
+				do {
+				    mid_up += F_DEPTH(flist->files[mid_up]);
+				} while (!F_IS_ACTIVE(flist->files[mid_up]));
+				F_DEPTH(flist->files[mid]) = mid_up - mid;
+			}
+			if (mid_up > high) {
+				/* If there's nothing left above us, set high to
+				 * a non-empty entry below us and continue. */
+				high = mid - (int)flist->files[mid]->len32;
+				if (!F_IS_ACTIVE(flist->files[high])) {
+					do {
+					    high -= (int)flist->files[high]->len32;
+					} while (!F_IS_ACTIVE(flist->files[high]));
+					flist->files[mid]->len32 = mid - high;
+				}
+				continue;
+			}
+		}
+		diff = f_name_cmp(flist->files[mid_up], f);
+		if (diff == 0) {
 			if (protocol_version < 29
 			    && S_ISDIR(flist->files[mid_up]->mode)
 			    != S_ISDIR(f->mode))
 				return -1;
 			return mid_up;
 		}
-		if (ret > 0)
-			high = mid - 1;
-		else
+		if (diff < 0)
 			low = mid_up + 1;
+		else
+			high = mid - 1;
 	}
 	return -1;
 }
 
-
 /*
  * Free up any resources a file_struct has allocated
  * and clear the file.
  */
-void clear_file(int i, struct file_list *flist)
+void clear_file(struct file_struct *file)
 {
-	if (flist->hlink_pool && flist->files[i]->link_u.idev)
-		pool_free(flist->hlink_pool, 0, flist->files[i]->link_u.idev);
-	memset(flist->files[i], 0, file_struct_len);
+	/* The +1 zeros out the first char of the basename. */
+	memset(file, 0, FILE_STRUCT_LEN + 1);
+	/* In an empty entry, F_DEPTH() is an offset to the next non-empty
+	 * entry.  Likewise for len32 in the opposite direction.  We assume
+	 * that we're alone for now since flist_find() will adjust the counts
+	 * it runs into that aren't up-to-date. */
+	file->len32 = F_DEPTH(file) = 1;
 }
 
-
-/*
- * allocate a new file list
- */
-struct file_list *flist_new(int with_hlink, char *msg)
+/* Allocate a new file list. */
+struct file_list *flist_new(char *msg)
 {
 	struct file_list *flist;
 
@@ -1434,41 +1609,29 @@ struct file_list *flist_new(int with_hlink, char *msg)
 	if (!flist)
 		out_of_memory(msg);
 
-	memset(flist, 0, sizeof (struct file_list));
+	memset(flist, 0, sizeof flist[0]);
 
-	if (!(flist->file_pool = pool_create(FILE_EXTENT, 0,
-	    out_of_memory, POOL_INTERN)))
+	if (!(flist->file_pool = pool_create(FILE_EXTENT, 0, out_of_memory, POOL_INTERN)))
 		out_of_memory(msg);
 
-#ifdef SUPPORT_HARD_LINKS
-	if (with_hlink && preserve_hard_links) {
-		if (!(flist->hlink_pool = pool_create(HLINK_EXTENT,
-		    sizeof (struct idev), out_of_memory, POOL_INTERN)))
-			out_of_memory(msg);
-	}
-#endif
-
 	return flist;
 }
 
-/*
- * free up all elements in a flist
- */
+/* Free up all elements in a flist. */
 void flist_free(struct file_list *flist)
 {
 	pool_destroy(flist->file_pool);
-	pool_destroy(flist->hlink_pool);
 	free(flist->files);
 	free(flist);
 }
 
-
 /*
  * This routine ensures we don't have any duplicate names in our file list.
  * duplicate names can cause corruption because of the pipelining
  */
 static void clean_flist(struct file_list *flist, int strip_root, int no_dups)
 {
+	char fbuf[MAXPATHLEN];
 	int i, prev_i = 0;
 
 	if (!flist)
@@ -1478,13 +1641,11 @@ static void clean_flist(struct file_list *flist, int strip_root, int no_dups)
 		return;
 	}
 
-	sorting_flist = flist;
 	qsort(flist->files, flist->count,
 	    sizeof flist->files[0], (int (*)())file_compare);
-	sorting_flist = NULL;
 
 	for (i = no_dups? 0 : flist->count; i < flist->count; i++) {
-		if (flist->files[i]->basename) {
+		if (F_IS_ACTIVE(flist->files[i])) {
 			prev_i = i;
 			break;
 		}
@@ -1494,7 +1655,7 @@ static void clean_flist(struct file_list *flist, int strip_root, int no_dups)
 		int j;
 		struct file_struct *file = flist->files[i];
 
-		if (!file->basename)
+		if (!F_IS_ACTIVE(file))
 			continue;
 		if (f_name_cmp(file, flist->files[prev_i]) == 0)
 			j = prev_i;
@@ -1524,19 +1685,19 @@ static void clean_flist(struct file_list *flist, int strip_root, int no_dups)
 			if (verbose > 1 && !am_server) {
 				rprintf(FINFO,
 					"removing duplicate name %s from file list (%d)\n",
-					safe_fname(f_name(file)), drop);
+					f_name(file, fbuf), drop);
 			}
-			/* Make sure that if we unduplicate '.', that we don't
-			 * lose track of a user-specified top directory. */
+			/* Make sure we don't lose track of a user-specified
+			 * top directory. */
 			flist->files[keep]->flags |= flist->files[drop]->flags
-						   & (FLAG_TOP_DIR|FLAG_DEL_HERE);
+						   & (FLAG_TOP_DIR|FLAG_XFER_DIR);
 
-			clear_file(drop, flist);
+			clear_file(flist->files[drop]);
 
 			if (keep == i) {
 				if (flist->low == drop) {
 					for (j = drop + 1;
-					     j < i && !flist->files[j]->basename;
+					     j < i && !F_IS_ACTIVE(flist->files[j]);
 					     j++) {}
 					flist->low = j;
 				}
@@ -1555,48 +1716,118 @@ static void clean_flist(struct file_list *flist, int strip_root, int no_dups)
 
 			if (!file->dirname)
 				continue;
-			if (*file->dirname == '/') {
-				char *s = file->dirname + 1;
-				while (*s == '/') s++;
-				memmove(file->dirname, s, strlen(s) + 1);
-			}
-
+			while (*file->dirname == '/')
+				file->dirname++;
 			if (!*file->dirname)
 				file->dirname = NULL;
 		}
 	}
-}
 
+	if (prune_empty_dirs && no_dups) {
+		int j, prev_depth = 0;
+
+		prev_i = 0; /* It's OK that this isn't really true. */
+
+		for (i = flist->low; i <= flist->high; i++) {
+			struct file_struct *fp, *file = flist->files[i];
+
+			/* This temporarily abuses the F_DEPTH() value for a
+			 * directory that is in a chain that might get pruned.
+			 * We restore the old value if it gets a reprieve. */
+			if (S_ISDIR(file->mode) && F_DEPTH(file)) {
+				/* Dump empty dirs when coming back down. */
+				for (j = prev_depth; j >= F_DEPTH(file); j--) {
+					fp = flist->files[prev_i];
+					if (F_DEPTH(fp) >= 0)
+						break;
+					prev_i = -F_DEPTH(fp)-1;
+					clear_file(fp);
+				}
+				prev_depth = F_DEPTH(file);
+				if (is_excluded(f_name(file, fbuf), 1,
+						       ALL_FILTERS)) {
+					/* Keep dirs through this dir. */
+					for (j = prev_depth-1; ; j--) {
+						fp = flist->files[prev_i];
+						if (F_DEPTH(fp) >= 0)
+							break;
+						prev_i = -F_DEPTH(fp)-1;
+						F_DEPTH(fp) = j;
+					}
+				} else
+					F_DEPTH(file) = -prev_i-1;
+				prev_i = i;
+			} else {
+				/* Keep dirs through this non-dir. */
+				for (j = prev_depth; ; j--) {
+					fp = flist->files[prev_i];
+					if (F_DEPTH(fp) >= 0)
+						break;
+					prev_i = -F_DEPTH(fp)-1;
+					F_DEPTH(fp) = j;
+				}
+			}
+		}
+		/* Dump empty all remaining empty dirs. */
+		while (1) {
+			struct file_struct *fp = flist->files[prev_i];
+			if (F_DEPTH(fp) >= 0)
+				break;
+			prev_i = -F_DEPTH(fp)-1;
+			clear_file(fp);
+		}
+
+		for (i = flist->low; i <= flist->high; i++) {
+			if (F_IS_ACTIVE(flist->files[i]))
+				break;
+		}
+		flist->low = i;
+		for (i = flist->high; i >= flist->low; i--) {
+			if (F_IS_ACTIVE(flist->files[i]))
+				break;
+		}
+		flist->high = i;
+	}
+}
 
 static void output_flist(struct file_list *flist)
 {
 	char uidbuf[16], gidbuf[16], depthbuf[16];
 	struct file_struct *file;
+	const char *root, *dir, *slash, *name, *trail;
 	const char *who = who_am_i();
 	int i;
 
 	for (i = 0; i < flist->count; i++) {
 		file = flist->files[i];
-		if ((am_root || am_sender) && preserve_uid)
-			sprintf(uidbuf, " uid=%ld", (long)file->uid);
-		else
+		if ((am_root || am_sender) && preserve_uid) {
+			snprintf(uidbuf, sizeof uidbuf, " uid=%ld",
+				 (long)F_UID(file));
+		} else
 			*uidbuf = '\0';
-		if (preserve_gid && file->gid != GID_NONE)
-			sprintf(gidbuf, " gid=%ld", (long)file->gid);
-		else
+		if (preserve_gid && F_GID(file) != GID_NONE) {
+			snprintf(gidbuf, sizeof gidbuf, " gid=%ld",
+				 (long)F_GID(file));
+		} else
 			*gidbuf = '\0';
 		if (!am_sender)
-			sprintf(depthbuf, "%d", file->dir.depth);
+			snprintf(depthbuf, sizeof depthbuf, "%d", F_DEPTH(file));
+		if (F_IS_ACTIVE(file)) {
+			root = am_sender ? NS(F_ROOTDIR(file)) : depthbuf;
+			if ((dir = file->dirname) == NULL)
+				dir = slash = "";
+			else
+				slash = "/";
+			name = file->basename;
+			trail = S_ISDIR(file->mode) ? "/" : "";
+		} else
+			root = dir = slash = name = trail = "";
 		rprintf(FINFO, "[%s] i=%d %s %s%s%s%s mode=0%o len=%.0f%s%s flags=%x\n",
-			who, i, am_sender ? NS(file->dir.root) : depthbuf,
-			file->dirname ? safe_fname(file->dirname) : "",
-			file->dirname ? "/" : "", NS(file->basename),
-			S_ISDIR(file->mode) ? "/" : "", (int)file->mode,
-			(double)file->length, uidbuf, gidbuf, file->flags);
+			who, i, root, dir, slash, name, trail, (int)file->mode,
+			(double)F_LENGTH(file), uidbuf, gidbuf, file->flags);
 	}
 }
 
-
 enum fnc_state { s_DIR, s_SLASH, s_BASE, s_TRAILING };
 enum fnc_type { t_PATH, t_ITEM };
 
@@ -1623,12 +1854,12 @@ int f_name_cmp(struct file_struct *f1, struct file_struct *f2)
 	enum fnc_type type1, type2;
 	enum fnc_type t_path = protocol_version >= 29 ? t_PATH : t_ITEM;
 
-	if (!f1 || !f1->basename) {
-		if (!f2 || !f2->basename)
+	if (!f1 || !F_IS_ACTIVE(f1)) {
+		if (!f2 || !F_IS_ACTIVE(f2))
 			return 0;
 		return -1;
 	}
-	if (!f2 || !f2->basename)
+	if (!f2 || !F_IS_ACTIVE(f2))
 		return 1;
 
 	c1 = (uchar*)f1->dirname;
@@ -1637,34 +1868,26 @@ int f_name_cmp(struct file_struct *f1, struct file_struct *f2)
 		c1 = c2 = NULL;
 	if (!c1) {
 		type1 = S_ISDIR(f1->mode) ? t_path : t_ITEM;
-		c1 = (uchar*)f1->basename;
+		c1 = (const uchar*)f1->basename;
 		if (type1 == t_PATH && *c1 == '.' && !c1[1]) {
 			type1 = t_ITEM;
 			state1 = s_TRAILING;
 			c1 = (uchar*)"";
 		} else
 			state1 = s_BASE;
-	} else if (!*c1) {
-		type1 = t_path;
-		state1 = s_SLASH;
-		c1 = (uchar*)"/";
 	} else {
 		type1 = t_path;
 		state1 = s_DIR;
 	}
 	if (!c2) {
 		type2 = S_ISDIR(f2->mode) ? t_path : t_ITEM;
-		c2 = (uchar*)f2->basename;
+		c2 = (const uchar*)f2->basename;
 		if (type2 == t_PATH && *c2 == '.' && !c2[1]) {
 			type2 = t_ITEM;
 			state2 = s_TRAILING;
 			c2 = (uchar*)"";
 		} else
 			state2 = s_BASE;
-	} else if (!*c2) {
-		type2 = t_path;
-		state2 = s_SLASH;
-		c2 = (uchar*)"/";
 	} else {
 		type2 = t_path;
 		state2 = s_DIR;
@@ -1673,9 +1896,7 @@ int f_name_cmp(struct file_struct *f1, struct file_struct *f2)
 	if (type1 != type2)
 		return type1 == t_PATH ? 1 : -1;
 
-	while (1) {
-		if ((dif = (int)*c1++ - (int)*c2++) != 0)
-			break;
+	do {
 		if (!*c1) {
 			switch (state1) {
 			case s_DIR:
@@ -1684,7 +1905,7 @@ int f_name_cmp(struct file_struct *f1, struct file_struct *f2)
 				break;
 			case s_SLASH:
 				type1 = S_ISDIR(f1->mode) ? t_path : t_ITEM;
-				c1 = (uchar*)f1->basename;
+				c1 = (const uchar*)f1->basename;
 				if (type1 == t_PATH && *c1 == '.' && !c1[1]) {
 					type1 = t_ITEM;
 					state1 = s_TRAILING;
@@ -1714,7 +1935,7 @@ int f_name_cmp(struct file_struct *f1, struct file_struct *f2)
 				break;
 			case s_SLASH:
 				type2 = S_ISDIR(f2->mode) ? t_path : t_ITEM;
-				c2 = (uchar*)f2->basename;
+				c2 = (const uchar*)f2->basename;
 				if (type2 == t_PATH && *c2 == '.' && !c2[1]) {
 					type2 = t_ITEM;
 					state2 = s_TRAILING;
@@ -1738,55 +1959,55 @@ int f_name_cmp(struct file_struct *f1, struct file_struct *f2)
 			if (type1 != type2)
 				return type1 == t_PATH ? 1 : -1;
 		}
-	}
+	} while ((dif = (int)*c1++ - (int)*c2++) == 0);
 
 	return dif;
 }
 
+char *f_name_buf(void)
+{
+	static char names[5][MAXPATHLEN];
+	static unsigned int n;
+
+	n = (n + 1) % (sizeof names / sizeof names[0]);
+
+	return names[n];
+}
 
 /* Return a copy of the full filename of a flist entry, using the indicated
- * buffer.  No size-checking is done because we checked the size when creating
- * the file_struct entry.
+ * buffer or one of 5 static buffers if fbuf is NULL.  No size-checking is
+ * done because we checked the size when creating the file_struct entry.
  */
-char *f_name_to(struct file_struct *f, char *fbuf)
+char *f_name(struct file_struct *f, char *fbuf)
 {
-	if (!f || !f->basename)
+	if (!f || !F_IS_ACTIVE(f))
 		return NULL;
 
+	if (!fbuf)
+		fbuf = f_name_buf();
+
 	if (f->dirname) {
 		int len = strlen(f->dirname);
 		memcpy(fbuf, f->dirname, len);
 		fbuf[len] = '/';
-		strcpy(fbuf + len + 1, f->basename);
+		strlcpy(fbuf + len + 1, f->basename, MAXPATHLEN - (len + 1));
 	} else
-		strcpy(fbuf, f->basename);
-	return fbuf;
-}
+		strlcpy(fbuf, f->basename, MAXPATHLEN);
 
-
-/* Like f_name_to(), but we rotate through 5 static buffers of our own. */
-char *f_name(struct file_struct *f)
-{
-	static char names[5][MAXPATHLEN];
-	static unsigned int n;
-
-	n = (n + 1) % (sizeof names / sizeof names[0]);
-
-	return f_name_to(f, names[n]);
+	return fbuf;
 }
 
-
 /* Do a non-recursive scan of the named directory, possibly ignoring all
  * exclude rules except for the daemon's.  If "dlen" is >=0, it is the length
  * of the dirname string, and also indicates that "dirname" is a MAXPATHLEN
  * buffer (the functions we call will append names onto the end, but the old
  * dir value will be restored on exit). */
-struct file_list *get_dirlist(char *dirname, int dlen,
-			      int ignore_filter_rules)
+struct file_list *get_dirlist(char *dirname, int dlen, int ignore_filter_rules)
 {
 	struct file_list *dirlist;
 	char dirbuf[MAXPATHLEN];
 	int save_recurse = recurse;
+	int save_xfer_dirs = xfer_dirs;
 
 	if (dlen < 0) {
 		dlen = strlcpy(dirbuf, dirname, MAXPATHLEN);
@@ -1795,10 +2016,12 @@ struct file_list *get_dirlist(char *dirname, int dlen,
 		dirname = dirbuf;
 	}
 
-	dirlist = flist_new(WITHOUT_HLINK, "get_dirlist");
+	dirlist = flist_new("get_dirlist");
 
 	recurse = 0;
+	xfer_dirs = 1;
 	send_directory(ignore_filter_rules ? -2 : -1, dirlist, dirname, dlen);
+	xfer_dirs = save_xfer_dirs;
 	recurse = save_recurse;
 	if (do_progress)
 		flist_count_offset += dirlist->count;