X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/a289addd96ee4510cac3676b8c119230c518e32c..25ff04417e4b4fa0aeb44e0b1576a01021aa1650:/flist.c

diff --git a/flist.c b/flist.c
index a7050aeb..bc247a88 100644
--- a/flist.c
+++ b/flist.c
@@ -31,57 +31,75 @@ extern struct stats stats;
 
 extern int verbose;
 extern int do_progress;
+extern int am_root;
 extern int am_server;
+extern int am_daemon;
+extern int am_sender;
+extern int delete_during;
 extern int always_checksum;
 extern int module_id;
 extern int ignore_errors;
-
-extern int cvs_exclude;
+extern int numeric_ids;
 
 extern int recurse;
+extern int xfer_dirs;
 extern char curr_dir[MAXPATHLEN];
-extern char *files_from;
+extern unsigned int curr_dir_len;
+extern char *backup_dir;
+extern char *backup_suffix;
 extern int filesfrom_fd;
 
 extern int one_file_system;
-extern int make_backups;
+extern int keep_dirlinks;
 extern int preserve_links;
 extern int preserve_hard_links;
 extern int preserve_perms;
 extern int preserve_devices;
 extern int preserve_uid;
 extern int preserve_gid;
-extern int preserve_times;
 extern int relative_paths;
 extern int implied_dirs;
+extern int make_backups;
+extern int backup_suffix_len;
 extern int copy_links;
 extern int copy_unsafe_links;
 extern int protocol_version;
 extern int sanitize_paths;
+extern int delete_excluded;
+extern int max_delete;
+extern int orig_umask;
+extern int list_only;
 
-extern int read_batch;
-extern int write_batch;
-
-extern struct exclude_struct **exclude_list;
-extern struct exclude_struct **server_exclude_list;
-extern struct exclude_struct **local_exclude_list;
+extern struct filter_list_struct filter_list;
+extern struct filter_list_struct server_filter_list;
 
 int io_error;
 
 static char empty_sum[MD4_SUM_LENGTH];
+static unsigned int file_struct_len;
+static struct file_list *received_flist;
 
 static void clean_flist(struct file_list *flist, int strip_root, int no_dups);
+static void output_flist(struct file_list *flist, const char *whose_list);
+
+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;
+}
 
 
 static int show_filelist_p(void)
 {
-	return verbose && (recurse || files_from) && !am_server;
+	return verbose && xfer_dirs && !am_server;
 }
 
 static void start_filelist_progress(char *kind)
 {
 	rprintf(FINFO, "%s ... ", kind);
-	if ((verbose > 1) || do_progress)
+	if (verbose > 1 || do_progress)
 		rprintf(FINFO, "\n");
 	rflush(FINFO);
 }
@@ -95,7 +113,7 @@ static void emit_filelist_progress(const struct file_list *flist)
 
 static void maybe_emit_filelist_progress(const struct file_list *flist)
 {
-	if (do_progress && show_filelist_p() && ((flist->count % 100) == 0))
+	if (do_progress && show_filelist_p() && (flist->count % 100) == 0)
 		emit_filelist_progress(flist);
 }
 
@@ -120,9 +138,10 @@ static void list_file_entry(struct file_struct *f)
 {
 	char perms[11];
 
-	if (!f->basename)
+	if (!f->basename) {
 		/* this can happen if duplicate names were removed */
 		return;
+	}
 
 	permstring(perms, f->mode);
 
@@ -130,14 +149,16 @@ static void list_file_entry(struct file_struct *f)
 	if (preserve_links && S_ISLNK(f->mode)) {
 		rprintf(FINFO, "%s %11.0f %s %s -> %s\n",
 			perms,
-			(double) f->length, timestring(f->modtime),
+			(double)f->length, timestring(f->modtime),
 			f_name(f), f->u.link);
 	} else
 #endif
+	{
 		rprintf(FINFO, "%s %11.0f %s %s\n",
 			perms,
-			(double) f->length, timestring(f->modtime),
+			(double)f->length, timestring(f->modtime),
 			f_name(f));
+	}
 }
 
 
@@ -155,15 +176,15 @@ static void list_file_entry(struct file_struct *f)
  * @post @p buffer contains information about the link or the
  * referrent as appropriate, if they exist.
  **/
-int readlink_stat(const char *path, STRUCT_STAT *buffer, char *linkbuf)
+static int readlink_stat(const char *path, STRUCT_STAT *buffer, char *linkbuf)
 {
 #if SUPPORT_LINKS
 	if (copy_links)
 		return do_stat(path, buffer);
-	if (do_lstat(path, buffer) == -1)
+	if (link_stat(path, buffer, 0) < 0)
 		return -1;
 	if (S_ISLNK(buffer->st_mode)) {
-		int l = readlink((char *) path, linkbuf, MAXPATHLEN - 1);
+		int l = readlink((char *)path, linkbuf, MAXPATHLEN - 1);
 		if (l == -1)
 			return -1;
 		linkbuf[l] = 0;
@@ -181,26 +202,31 @@ int readlink_stat(const char *path, STRUCT_STAT *buffer, char *linkbuf)
 #endif
 }
 
-int link_stat(const char *path, STRUCT_STAT * buffer)
+int link_stat(const char *path, STRUCT_STAT *buffer, int follow_dirlinks)
 {
 #if SUPPORT_LINKS
 	if (copy_links)
 		return do_stat(path, buffer);
-	return do_lstat(path, buffer);
+	if (do_lstat(path, buffer) < 0)
+		return -1;
+	if (follow_dirlinks && S_ISLNK(buffer->st_mode)) {
+		STRUCT_STAT st;
+		if (do_stat(path, &st) == 0 && S_ISDIR(st.st_mode))
+			*buffer = st;
+	}
+	return 0;
 #else
 	return do_stat(path, buffer);
 #endif
 }
 
-/*
- * This function is used to check if a file should be included/excluded
+/* This function is used to check if a file should be included/excluded
  * from the list of files based on its name and type etc.  The value of
- * exclude_level is set to either SERVER_EXCLUDES or ALL_EXCLUDES.
- */
-static int check_exclude_file(char *fname, int is_dir, int exclude_level)
+ * filter_level is set to either SERVER_FILTERS or ALL_FILTERS. */
+static int is_excluded(char *fname, int is_dir, int filter_level)
 {
 #if 0 /* This currently never happens, so avoid a useless compare. */
-	if (exclude_level == NO_EXCLUDES)
+	if (filter_level == NO_FILTERS)
 		return 0;
 #endif
 	if (fname) {
@@ -214,15 +240,13 @@ static int check_exclude_file(char *fname, int is_dir, int exclude_level)
 				return 0;
 		}
 	}
-	if (server_exclude_list
-	 && check_exclude(server_exclude_list, fname, is_dir))
+	if (server_filter_list.head
+	    && check_filter(&server_filter_list, fname, is_dir) < 0)
 		return 1;
-	if (exclude_level != ALL_EXCLUDES)
+	if (filter_level != ALL_FILTERS)
 		return 0;
-	if (exclude_list && check_exclude(exclude_list, fname, is_dir))
-		return 1;
-	if (local_exclude_list
-	 && check_exclude(local_exclude_list, fname, is_dir))
+	if (filter_list.head
+	    && check_filter(&filter_list, fname, is_dir) < 0)
 		return 1;
 	return 0;
 }
@@ -233,7 +257,7 @@ static dev_t filesystem_dev;
 static void set_filesystem(char *fname)
 {
 	STRUCT_STAT st;
-	if (link_stat(fname, &st) != 0)
+	if (do_stat(fname, &st) != 0)
 		return;
 	filesystem_dev = st.st_dev;
 }
@@ -245,14 +269,14 @@ static int to_wire_mode(mode_t mode)
 	if (S_ISLNK(mode) && (_S_IFLNK != 0120000))
 		return (mode & ~(_S_IFMT)) | 0120000;
 #endif
-	return (int) mode;
+	return (int)mode;
 }
 
 static mode_t from_wire_mode(int mode)
 {
 	if ((mode & (_S_IFMT)) == 0120000 && (_S_IFLNK != 0120000))
 		return (mode & ~(_S_IFMT)) | _S_IFLNK;
-	return (mode_t) mode;
+	return (mode_t)mode;
 }
 
 
@@ -266,38 +290,41 @@ static int flist_dir_len;
  * Make sure @p flist is big enough to hold at least @p flist->count
  * entries.
  **/
-static void flist_expand(struct file_list *flist)
+void flist_expand(struct file_list *flist)
 {
-	if (flist->count >= flist->malloced) {
-		void *new_ptr;
+	struct file_struct **new_ptr;
 
-		if (flist->malloced < 1000)
-			flist->malloced += 1000;
-		else
-			flist->malloced *= 2;
-
-		if (flist->files) {
-			new_ptr = realloc_array(flist->files,
-						struct file_struct *,
-						flist->malloced);
-		} else {
-			new_ptr = new_array(struct file_struct *,
-					    flist->malloced);
-		}
+	if (flist->count < flist->malloced)
+		return;
 
-		if (verbose >= 2) {
-			rprintf(FINFO, "[%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" : "");
-		}
+	if (flist->malloced < FLIST_START)
+		flist->malloced = FLIST_START;
+	else if (flist->malloced >= FLIST_LINEAR)
+		flist->malloced += FLIST_LINEAR;
+	else
+		flist->malloced *= 2;
+
+	/*
+	 * In case count jumped or we are starting the list
+	 * with a known size just set it.
+	 */
+	if (flist->malloced < flist->count)
+		flist->malloced = flist->count;
+
+	new_ptr = realloc_array(flist->files, struct file_struct *,
+				flist->malloced);
+
+	if (verbose >= 2 && flist->malloced != FLIST_START) {
+		rprintf(FINFO, "[%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" : "");
+	}
 
-		flist->files = (struct file_struct **) new_ptr;
+	flist->files = new_ptr;
 
-		if (!flist->files)
-			out_of_memory("flist_expand");
-	}
+	if (!flist->files)
+		out_of_memory("flist_expand");
 }
 
 void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
@@ -305,12 +332,13 @@ void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
 	unsigned short flags;
 	static time_t modtime;
 	static mode_t mode;
-	static DEV64_T rdev, rdev_high;
-	static DEV64_T dev;
+	static int64 dev;
+	static dev_t rdev;
+	static uint32 rdev_major;
 	static uid_t uid;
 	static gid_t gid;
 	static char lastname[MAXPATHLEN];
-	char *fname, fbuf[MAXPATHLEN];
+	char fname[MAXPATHLEN];
 	int l1, l2;
 
 	if (f == -1)
@@ -319,7 +347,8 @@ void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
 	if (!file) {
 		write_byte(f, 0);
 		modtime = 0, mode = 0;
-		rdev = 0, rdev_high = 0, dev = 0;
+		dev = 0, rdev = makedev(0, 0);
+		rdev_major = 0;
 		uid = 0, gid = 0;
 		*lastname = '\0';
 		return;
@@ -327,7 +356,7 @@ void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
 
 	io_write_phase = "send_file_entry";
 
-	fname = f_name_to(file, fbuf);
+	f_name_to(file, fname);
 
 	flags = base_flags;
 
@@ -338,22 +367,20 @@ void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
 	if (preserve_devices) {
 		if (protocol_version < 28) {
 			if (IS_DEVICE(mode)) {
-				if (file->u.rdev == rdev) {
-					/* Set both flags to simplify the test
-					 * when writing the data. */
-					flags |= XMIT_SAME_RDEV_pre28
-					       | XMIT_SAME_HIGH_RDEV;
-				} else
+				if (file->u.rdev == rdev)
+					flags |= XMIT_SAME_RDEV_pre28;
+				else
 					rdev = file->u.rdev;
 			} else
-				rdev = 0;
+				rdev = makedev(0, 0);
 		} else if (IS_DEVICE(mode)) {
-			if ((file->u.rdev & ~0xFF) == rdev_high)
-				flags |= XMIT_SAME_HIGH_RDEV;
-			else {
-				rdev = file->u.rdev;
-				rdev_high = rdev & ~0xFF;
-			}
+			rdev = file->u.rdev;
+			if ((uint32)major(rdev) == rdev_major)
+				flags |= XMIT_SAME_RDEV_MAJOR;
+			else
+				rdev_major = major(rdev);
+			if ((uint32)minor(rdev) <= 0xFFu)
+				flags |= XMIT_RDEV_MINOR_IS_SMALL;
 		}
 	}
 	if (file->uid == uid)
@@ -381,8 +408,8 @@ void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
 #endif
 
 	for (l1 = 0;
-	     lastname[l1] && (fname[l1] == lastname[l1]) && (l1 < 255);
-	     l1++) {}
+	    lastname[l1] && (fname[l1] == lastname[l1]) && (l1 < 255);
+	    l1++) {}
 	l2 = strlen(fname+l1);
 
 	if (l1 > 0)
@@ -392,11 +419,11 @@ void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
 
 	/* We must make sure we don't send a zero flag byte or the
 	 * other end will terminate the flist transfer.  Note that
-	 * the use of XMIT_TOP_DIR on a non-dir has no meaning, so
+	 * the use of XMIT_DEL_START on a non-dir has no meaning, so
 	 * it's harmless way to add a bit to the first flag byte. */
 	if (protocol_version >= 28) {
 		if (!flags && !S_ISDIR(mode))
-			flags |= XMIT_TOP_DIR;
+			flags |= XMIT_DEL_START;
 		if ((flags & 0xFF00) || !flags) {
 			flags |= XMIT_EXTENDED_FLAGS;
 			write_byte(f, flags);
@@ -405,7 +432,7 @@ void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
 			write_byte(f, flags);
 	} else {
 		if (!(flags & 0xFF) && !S_ISDIR(mode))
-			flags |= XMIT_TOP_DIR;
+			flags |= XMIT_DEL_START;
 		if (!(flags & 0xFF))
 			flags |= XMIT_LONG_NAME;
 		write_byte(f, flags);
@@ -424,20 +451,27 @@ void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
 	if (!(flags & XMIT_SAME_MODE))
 		write_int(f, to_wire_mode(mode));
 	if (preserve_uid && !(flags & XMIT_SAME_UID)) {
-		add_uid(uid);
+		if (!numeric_ids)
+			add_uid(uid);
 		write_int(f, uid);
 	}
 	if (preserve_gid && !(flags & XMIT_SAME_GID)) {
-		add_gid(gid);
+		if (!numeric_ids)
+			add_gid(gid);
 		write_int(f, gid);
 	}
 	if (preserve_devices && IS_DEVICE(mode)) {
-		/* If XMIT_SAME_HIGH_RDEV is off, XMIT_SAME_RDEV_pre28 is
-		 * also off. */
-		if (!(flags & XMIT_SAME_HIGH_RDEV))
-			write_int(f, rdev);
-		else if (protocol_version >= 28)
-			write_byte(f, rdev);
+		if (protocol_version < 28) {
+			if (!(flags & XMIT_SAME_RDEV_pre28))
+				write_int(f, (int)rdev);
+		} else {
+			if (!(flags & XMIT_SAME_RDEV_MAJOR))
+				write_int(f, major(rdev));
+			if (flags & XMIT_RDEV_MINOR_IS_SMALL)
+				write_byte(f, minor(rdev));
+			else
+				write_int(f, minor(rdev));
+		}
 	}
 
 #if SUPPORT_LINKS
@@ -473,8 +507,8 @@ void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
 		} else
 			sum = NULL;
 		if (sum) {
-			write_buf(f, sum, protocol_version < 21? 2
-							: MD4_SUM_LENGTH);
+			write_buf(f, sum,
+			    protocol_version < 21 ? 2 : MD4_SUM_LENGTH);
 		}
 	}
 
@@ -485,28 +519,35 @@ void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
 
 
 
-void receive_file_entry(struct file_struct **fptr, unsigned short flags, int f)
+void receive_file_entry(struct file_struct **fptr, unsigned short flags,
+			struct file_list *flist, int f)
 {
 	static time_t modtime;
 	static mode_t mode;
-	static DEV64_T rdev, rdev_high;
-	static DEV64_T dev;
+	static int64 dev;
+	static dev_t rdev;
+	static uint32 rdev_major;
 	static uid_t uid;
 	static gid_t gid;
 	static char lastname[MAXPATHLEN], *lastdir;
-	static int lastdir_len = -1;
+	static int lastdir_depth, lastdir_len = -1;
+	static unsigned int del_heir_name_len = -1;
+	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, idev_len;
+	int alloc_len, basename_len, dirname_len, linkname_len, sum_len;
 	OFF_T file_length;
 	char *basename, *dirname, *bp;
 	struct file_struct *file;
 
 	if (!fptr) {
 		modtime = 0, mode = 0;
-		rdev = 0, rdev_high = 0, dev = 0;
+		dev = 0, rdev = makedev(0, 0);
+		rdev_major = 0;
 		uid = 0, gid = 0;
 		*lastname = '\0';
+		del_heir_name_len = lastdir_len = -1;
+		in_del_hier = 0;
 		return;
 	}
 
@@ -531,10 +572,10 @@ void receive_file_entry(struct file_struct **fptr, unsigned short flags, int f)
 
 	strlcpy(lastname, thisname, MAXPATHLEN);
 
-	clean_fname(thisname);
+	clean_fname(thisname, 0);
 
 	if (sanitize_paths)
-		sanitize_path(thisname, NULL);
+		sanitize_path(thisname, thisname, "", 0);
 
 	if ((basename = strrchr(thisname, '/')) != NULL) {
 		dirname_len = ++basename - thisname; /* counts future '\0' */
@@ -566,15 +607,18 @@ void receive_file_entry(struct file_struct **fptr, unsigned short flags, int f)
 		if (protocol_version < 28) {
 			if (IS_DEVICE(mode)) {
 				if (!(flags & XMIT_SAME_RDEV_pre28))
-					rdev = (DEV64_T)read_int(f);
+					rdev = (dev_t)read_int(f);
 			} else
-				rdev = 0;
+				rdev = makedev(0, 0);
 		} else if (IS_DEVICE(mode)) {
-			if (!(flags & XMIT_SAME_HIGH_RDEV)) {
-				rdev = (DEV64_T)read_int(f);
-				rdev_high = rdev & ~0xFF;
-			} else
-				rdev = rdev_high | (DEV64_T)read_byte(f);
+			uint32 rdev_minor;
+			if (!(flags & XMIT_SAME_RDEV_MAJOR))
+				rdev_major = read_int(f);
+			if (flags & XMIT_RDEV_MINOR_IS_SMALL)
+				rdev_minor = read_byte(f);
+			else
+				rdev_minor = read_int(f);
+			rdev = makedev(rdev_major, rdev_minor);
 		}
 	}
 
@@ -591,38 +635,45 @@ void receive_file_entry(struct file_struct **fptr, unsigned short flags, int f)
 #endif
 		linkname_len = 0;
 
-#if SUPPORT_HARD_LINKS
-	if (preserve_hard_links && protocol_version < 28 && S_ISREG(mode))
-		flags |= XMIT_HAS_IDEV_DATA;
-	if (flags & XMIT_HAS_IDEV_DATA)
-		idev_len = sizeof (struct idev);
-	else
-#endif
-		idev_len = 0;
-
 	sum_len = always_checksum && S_ISREG(mode) ? MD4_SUM_LENGTH : 0;
 
-	alloc_len = sizeof file[0] + dirname_len + basename_len
-		  + linkname_len + sum_len + idev_len;
-	if (!(bp = new_array(char, alloc_len)))
-		out_of_memory("receive_file_entry");
+	alloc_len = file_struct_len + dirname_len + basename_len
+		  + linkname_len + sum_len;
+	bp = pool_alloc(flist->file_pool, alloc_len, "receive_file_entry");
+
 	file = *fptr = (struct file_struct *)bp;
-	memset(bp, 0, sizeof file[0]);
-	bp += sizeof file[0];
+	memset(bp, 0, file_struct_len);
+	bp += file_struct_len;
 
-	file->flags = flags & XMIT_TOP_DIR ? FLAG_TOP_DIR : 0;
+	file->flags = 0;
 	file->modtime = modtime;
 	file->length = file_length;
 	file->mode = mode;
 	file->uid = uid;
 	file->gid = gid;
 
+	if (S_ISDIR(mode)) {
+		if (flags & XMIT_DEL_START) {
+			in_del_hier = 1;
+			del_heir_name_len = l1 + l2;
+			file->flags |= FLAG_DEL_START;
+		} else if (delete_during && in_del_hier) {
+			if (!relative_paths || (l1 >= del_heir_name_len
+			    && thisname[del_heir_name_len] == '/'))
+				file->flags |= FLAG_DEL_START;
+			else
+				in_del_hier = 0;
+		}
+	}
+
 	if (dirname_len) {
 		file->dirname = lastdir = bp;
 		lastdir_len = dirname_len - 1;
 		memcpy(bp, dirname, dirname_len - 1);
 		bp += dirname_len;
 		bp[-1] = '\0';
+		if (sanitize_paths)
+			lastdir_depth = count_dir_elements(lastdir);
 	} else if (dirname)
 		file->dirname = dirname;
 
@@ -638,24 +689,30 @@ void receive_file_entry(struct file_struct **fptr, unsigned short flags, int f)
 		file->u.link = bp;
 		read_sbuf(f, bp, linkname_len - 1);
 		if (sanitize_paths)
-			sanitize_path(bp, lastdir);
+			sanitize_path(bp, bp, "", lastdir_depth);
 		bp += linkname_len;
 	}
 #endif
 
 #if SUPPORT_HARD_LINKS
-	if (idev_len) {
-		file->link_u.idev = (struct idev *)bp;
-		bp += idev_len;
+	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);
-			file->F_INODE = read_int(f);
+			inode = read_int(f);
 		} else {
 			if (!(flags & XMIT_SAME_DEV))
 				dev = read_longint(f);
-			file->F_INODE = 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;
 		}
-		file->F_DEV = dev;
 	}
 #endif
 
@@ -670,13 +727,12 @@ void receive_file_entry(struct file_struct **fptr, unsigned short flags, int f)
 		} else
 			sum = NULL;
 		if (sum) {
-			read_buf(f, sum, protocol_version < 21? 2
-						: MD4_SUM_LENGTH);
+			read_buf(f, sum,
+			    protocol_version < 21 ? 2 : MD4_SUM_LENGTH);
 		}
 	}
 
 	if (!preserve_perms) {
-		extern int orig_umask;
 		/* set an appropriate set of permissions based on original
 		 * permissions and umask. This emulates what GNU cp does */
 		file->mode &= ~orig_umask;
@@ -699,7 +755,8 @@ void receive_file_entry(struct file_struct **fptr, unsigned short flags, int f)
  * 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, int exclude_level)
+struct file_struct *make_file(char *fname, struct file_list *flist,
+			      int filter_level)
 {
 	static char *lastdir;
 	static int lastdir_len = -1;
@@ -708,66 +765,87 @@ struct file_struct *make_file(char *fname, int exclude_level)
 	char sum[SUM_LENGTH];
 	char thisname[MAXPATHLEN];
 	char linkname[MAXPATHLEN];
-	int alloc_len, basename_len, dirname_len, linkname_len, sum_len, idev_len;
+	int alloc_len, basename_len, dirname_len, linkname_len, sum_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", fname);
 		return NULL;
 	}
-	clean_fname(thisname);
+	clean_fname(thisname, 0);
 	if (sanitize_paths)
-		sanitize_path(thisname, NULL);
+		sanitize_path(thisname, thisname, "", 0);
 
 	memset(sum, 0, SUM_LENGTH);
 
 	if (readlink_stat(thisname, &st, linkname) != 0) {
 		int save_errno = errno;
-		if (errno == ENOENT && exclude_level != NO_EXCLUDES) {
-			/* either symlink pointing nowhere or file that
-			 * was removed during rsync run; see if excluded
-			 * before reporting an error */
-			if (check_exclude_file(thisname, 0, exclude_level)) {
-				/* file is excluded anyway, ignore silently */
-				return NULL;
+		/* See if file is excluded before reporting an error. */
+		if (filter_level != NO_FILTERS
+		    && is_excluded(thisname, 0, filter_level))
+			return NULL;
+		if (save_errno == ENOENT) {
+#if SUPPORT_LINKS
+			/* Avoid "vanished" error if symlink points nowhere. */
+			if (copy_links && do_lstat(thisname, &st) == 0
+			    && S_ISLNK(st.st_mode)) {
+				io_error |= IOERR_GENERAL;
+				rprintf(FERROR, "symlink has no referent: %s\n",
+					full_fname(thisname));
+			} else
+#endif
+			{
+				enum logcode c = am_daemon && protocol_version < 28
+				    ? FERROR : FINFO;
+				io_error |= IOERR_VANISHED;
+				rprintf(c, "file has vanished: %s\n",
+					full_fname(thisname));
 			}
+		} else {
+			io_error |= IOERR_GENERAL;
+			rsyserr(FERROR, save_errno, "readlink %s failed",
+				full_fname(thisname));
 		}
-		io_error |= IOERR_GENERAL;
-		rprintf(FERROR, "readlink %s failed: %s\n",
-			full_fname(thisname), strerror(save_errno));
 		return NULL;
 	}
 
-	/* backup.c calls us with exclude_level set to NO_EXCLUDES. */
-	if (exclude_level == NO_EXCLUDES)
-		goto skip_excludes;
+	/* backup.c calls us with filter_level set to NO_FILTERS. */
+	if (filter_level == NO_FILTERS)
+		goto skip_filters;
 
-	if (S_ISDIR(st.st_mode) && !recurse && !files_from) {
+	if (S_ISDIR(st.st_mode) && !xfer_dirs) {
 		rprintf(FINFO, "skipping directory %s\n", thisname);
 		return NULL;
 	}
 
-	if (one_file_system && st.st_dev != filesystem_dev) {
-		/* We allow a directory though to preserve the mount point.
-		 * However, flag it so that we don't recurse. */
-		if (!S_ISDIR(st.st_mode))
-			return NULL;
+	/* We only care about 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;
-	}
 
-	if (check_exclude_file(thisname, S_ISDIR(st.st_mode) != 0, exclude_level))
+	if (is_excluded(thisname, S_ISDIR(st.st_mode) != 0, filter_level))
 		return NULL;
 
-	if (lp_ignore_nonreadable(module_id) && access(thisname, R_OK) != 0)
-		return NULL;
+	if (lp_ignore_nonreadable(module_id)) {
+#if SUPPORT_LINKS
+		if (!S_ISLNK(st.st_mode))
+#endif
+			if (access(thisname, R_OK) != 0)
+				return NULL;
+	}
 
-      skip_excludes:
+skip_filters:
 
 	if (verbose > 2) {
 		rprintf(FINFO, "[%s] make_file(%s,*,%d)\n",
-			who_am_i(), thisname, exclude_level);
+			who_am_i(), thisname, filter_level);
 	}
 
 	if ((basename = strrchr(thisname, '/')) != NULL) {
@@ -791,24 +869,21 @@ struct file_struct *make_file(char *fname, int exclude_level)
 	linkname_len = 0;
 #endif
 
-#if SUPPORT_HARD_LINKS
-	if (preserve_hard_links) {
-		idev_len = (protocol_version < 28 ? S_ISREG(st.st_mode)
-			  : !S_ISDIR(st.st_mode) && st.st_nlink > 1)
-			 ? sizeof (struct idev) : 0;
-	} else
-#endif
-		idev_len = 0;
-
 	sum_len = always_checksum && S_ISREG(st.st_mode) ? MD4_SUM_LENGTH : 0;
 
-	alloc_len = sizeof file[0] + dirname_len + basename_len
-		  + linkname_len + sum_len + idev_len;
-	if (!(bp = new_array(char, alloc_len)))
-		out_of_memory("receive_file_entry");
+	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 (!(bp = new_array(char, alloc_len)))
+			out_of_memory("receive_file_entry");
+	}
+
 	file = (struct file_struct *)bp;
-	memset(bp, 0, sizeof file[0]);
-	bp += sizeof file[0];
+	memset(bp, 0, file_struct_len);
+	bp += file_struct_len;
 
 	file->flags = flags;
 	file->modtime = st.st_mtime;
@@ -817,6 +892,26 @@ struct file_struct *make_file(char *fname, int exclude_level)
 	file->uid = st.st_uid;
 	file->gid = st.st_gid;
 
+#if 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 (file->link_u.idev) {
+		file->F_DEV = st.st_dev;
+		file->F_INODE = st.st_ino;
+	}
+#endif
+
 	if (dirname_len) {
 		file->dirname = lastdir = bp;
 		lastdir_len = dirname_len - 1;
@@ -830,7 +925,7 @@ struct file_struct *make_file(char *fname, int exclude_level)
 	memcpy(bp, basename, basename_len);
 	bp += basename_len;
 
-#ifdef HAVE_STRUCT_STAT_ST_RDEV
+#if HAVE_STRUCT_STAT_ST_RDEV
 	if (preserve_devices && IS_DEVICE(st.st_mode))
 		file->u.rdev = st.st_rdev;
 #endif
@@ -843,15 +938,6 @@ struct file_struct *make_file(char *fname, int exclude_level)
 	}
 #endif
 
-#if SUPPORT_HARD_LINKS
-	if (idev_len) {
-		file->link_u.idev = (struct idev *)bp;
-		bp += idev_len;
-		file->F_DEV = st.st_dev;
-		file->F_INODE = st.st_ino;
-	}
-#endif
-
 	if (sum_len) {
 		file->u.sum = bp;
 		file_checksum(thisname, bp, st.st_size);
@@ -860,6 +946,26 @@ struct file_struct *make_file(char *fname, int exclude_level)
 
 	file->basedir = 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 i = flist_find(received_flist, file);
+		if (i >= 0 && S_ISDIR(received_flist->files[i]->mode)
+		    && do_stat(thisname, &st2) == 0 && S_ISDIR(st2.st_mode)) {
+			file->modtime = st2.st_mtime;
+			file->length = st2.st_size;
+			file->mode = st2.st_mode;
+			file->uid = st2.st_uid;
+			file->gid = st2.st_gid;
+			file->u.link = NULL;
+			if (file->link_u.idev) {
+				pool_free(flist->hlink_pool, 0, file->link_u.idev);
+				file->link_u.idev = NULL;
+			}
+		}
+	}
+
 	if (!S_ISDIR(st.st_mode))
 		stats.total_size += st.st_size;
 
@@ -872,12 +978,10 @@ void send_file_name(int f, struct file_list *flist, char *fname,
 {
 	struct file_struct *file;
 	char fbuf[MAXPATHLEN];
-	extern int delete_excluded;
 
 	/* f is set to -1 when calculating deletion file list */
-	file = make_file(fname,
-			 f == -1 && delete_excluded? SERVER_EXCLUDES
-						   : ALL_EXCLUDES);
+	file = make_file(fname, flist,
+	    f == -1 && delete_excluded? SERVER_FILTERS : ALL_FILTERS);
 
 	if (!file)
 		return;
@@ -886,9 +990,6 @@ void send_file_name(int f, struct file_list *flist, char *fname,
 
 	flist_expand(flist);
 
-	if (write_batch)
-		file->flags |= FLAG_TOP_DIR;
-
 	if (file->basename[0]) {
 		flist->files[flist->count++] = file;
 		send_file_entry(file, f, base_flags);
@@ -896,27 +997,26 @@ void send_file_name(int f, struct file_list *flist, char *fname,
 
 	if (recursive && S_ISDIR(file->mode)
 	    && !(file->flags & FLAG_MOUNT_POINT)) {
-		struct exclude_struct **last_exclude_list = local_exclude_list;
 		send_directory(f, flist, f_name_to(file, fbuf));
-		local_exclude_list = last_exclude_list;
-		return;
 	}
 }
 
 
+/* Note that the "recurse" value either contains -1, for infinite recursion,
+ * or a number >= 0 indicating how many levels of recursion we will allow. */
 static void send_directory(int f, struct file_list *flist, char *dir)
 {
 	DIR *d;
 	struct dirent *di;
 	char fname[MAXPATHLEN];
 	unsigned int offset;
+	void *save_filters;
 	char *p;
 
 	d = opendir(dir);
 	if (!d) {
 		io_error |= IOERR_GENERAL;
-		rprintf(FERROR, "opendir %s failed: %s\n",
-			full_fname(dir), strerror(errno));
+		rsyserr(FERROR, errno, "opendir %s failed", full_fname(dir));
 		return;
 	}
 
@@ -934,28 +1034,17 @@ static void send_directory(int f, struct file_list *flist, char *dir)
 		offset++;
 	}
 
-	local_exclude_list = NULL;
-
-	if (cvs_exclude) {
-		if (strlcpy(p, ".cvsignore", MAXPATHLEN - offset)
-		    < MAXPATHLEN - offset)
-			add_exclude_file(&local_exclude_list,fname,MISSING_OK,ADD_EXCLUDE);
-		else {
-			io_error |= IOERR_GENERAL;
-			rprintf(FINFO,
-				"cannot cvs-exclude in long-named directory %s\n",
-				full_fname(fname));
-		}
-	}
+	save_filters = push_local_filters(fname, offset);
 
 	for (errno = 0, di = readdir(d); di; errno = 0, di = readdir(d)) {
 		char *dname = d_name(di);
 		if (dname[0] == '.' && (dname[1] == '\0'
 		    || (dname[1] == '.' && dname[2] == '\0')))
 			continue;
-		if (strlcpy(p, dname, MAXPATHLEN - offset) < MAXPATHLEN - offset)
-			send_file_name(f, flist, fname, recurse, 0);
-		else {
+		if (strlcpy(p, dname, MAXPATHLEN - offset) < MAXPATHLEN - offset) {
+			int do_subdirs = recurse >= 1 ? recurse-- : recurse;
+			send_file_name(f, flist, fname, do_subdirs, 0);
+		} else {
 			io_error |= IOERR_GENERAL;
 			rprintf(FINFO,
 				"cannot send long-named file %s\n",
@@ -964,23 +1053,23 @@ static void send_directory(int f, struct file_list *flist, char *dir)
 	}
 	if (errno) {
 		io_error |= IOERR_GENERAL;
-		rprintf(FERROR, "readdir(%s): (%d) %s\n",
-			dir, errno, strerror(errno));
+		rsyserr(FERROR, errno, "readdir(%s)", dir);
 	}
 
-	if (local_exclude_list)
-		free_exclude_list(&local_exclude_list); /* Zeros pointer too */
+	pop_local_filters(save_filters);
 
 	closedir(d);
 }
 
 
-/**
- * The delete_files() function in receiver.c sets f to -1 so that we just
- * construct the file list in memory without sending it over the wire.  It
- * also has the side-effect of ignoring user-excludes if delete_excluded
- * is set (so that the delete list includes user-excluded files).
- **/
+/* This function is normally called by the sender, but the receiving side
+ * also uses it to construct one or more file lists if one of the --delete
+ * options have been specified.  The delete_in_dir() function sets f to -1
+ * so that we just construct the file list in memory without sending it
+ * over the wire.  It also has the side-effect of ignoring user-excludes if
+ * delete_excluded is set (so that the delete list includes user-excluded
+ * files) and it avoids some per-arg init code for limited recursion (since
+ * delete_in_dir() sets recurse before calling this function). */
 struct file_list *send_file_list(int f, int argc, char *argv[])
 {
 	int l;
@@ -988,6 +1077,8 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
 	char *p, *dir, olddir[sizeof curr_dir];
 	char lastpath[MAXPATHLEN] = "";
 	struct file_list *flist;
+	BOOL need_first_push = True;
+	struct timeval start_tv, end_tv;
 	int64 start_write;
 	int use_ff_fd = 0;
 
@@ -995,39 +1086,46 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
 		start_filelist_progress("building file list");
 
 	start_write = stats.total_written;
+	gettimeofday(&start_tv, NULL);
 
-	flist = flist_new();
+	flist = flist_new(f == -1 ? WITHOUT_HLINK : WITH_HLINK,
+			  "send_file_list");
 
 	if (f != -1) {
-		io_start_buffering_out(f);
+		io_start_buffering_out();
 		if (filesfrom_fd >= 0) {
 			if (argv[0] && !push_dir(argv[0])) {
-				rprintf(FERROR, "push_dir %s failed: %s\n",
-					full_fname(argv[0]), strerror(errno));
+				rsyserr(FERROR, errno, "push_dir %s failed",
+					full_fname(argv[0]));
 				exit_cleanup(RERR_FILESELECT);
 			}
 			use_ff_fd = 1;
+			if (curr_dir_len < MAXPATHLEN - 1) {
+				push_local_filters(curr_dir, curr_dir_len);
+				need_first_push = False;
+			}
 		}
 	}
 
 	while (1) {
 		char fname2[MAXPATHLEN];
 		char *fname = fname2;
+		int do_subdirs;
 
 		if (use_ff_fd) {
 			if (read_filesfrom_line(filesfrom_fd, fname) == 0)
 				break;
-			sanitize_path(fname, NULL);
+			sanitize_path(fname, fname, "", 0);
 		} else {
 			if (argc-- == 0)
 				break;
 			strlcpy(fname, *argv++, MAXPATHLEN);
 			if (sanitize_paths)
-				sanitize_path(fname, NULL);
+				sanitize_path(fname, fname, "", 0);
 		}
 
 		l = strlen(fname);
-		if (fname[l - 1] == '/') {
+		if (!l || fname[l - 1] == '/') {
 			if (l == 2 && fname[0] == '.') {
 				/* Turn "./" into just "." rather than "./." */
 				fname[1] = '\0';
@@ -1036,17 +1134,33 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
 				fname[l] = '\0';
 			}
 		}
+		if (f == -1)
+			; /* recurse is pre-set */
+		else if (fname[l-1] == '.' && (l == 1 || fname[l-2] == '/')) {
+			if (!recurse && xfer_dirs)
+				recurse = 1; /* allow one level */
+		} else if (recurse > 0)
+			recurse = 0;
+
+		if (need_first_push) {
+			if ((p = strrchr(fname, '/')) != NULL) {
+				if (*++p && strcmp(p, ".") != 0)
+					push_local_filters(fname, p - fname);
+			} else if (strcmp(fname, ".") != 0)
+				push_local_filters(fname, 0);
+			need_first_push = False;
+		}
 
-		if (link_stat(fname, &st) != 0) {
+		if (link_stat(fname, &st, keep_dirlinks) != 0) {
 			if (f != -1) {
 				io_error |= IOERR_GENERAL;
-				rprintf(FERROR, "link_stat %s failed: %s\n",
-					full_fname(fname), strerror(errno));
+				rsyserr(FERROR, errno, "link_stat %s failed",
+					full_fname(fname));
 			}
 			continue;
 		}
 
-		if (S_ISDIR(st.st_mode) && !recurse && !files_from) {
+		if (S_ISDIR(st.st_mode) && !xfer_dirs) {
 			rprintf(FINFO, "skipping directory %s\n", fname);
 			continue;
 		}
@@ -1078,21 +1192,17 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
 			}
 			*p = '/';
 			if (fn != p || (*lp && *lp != '/')) {
-				int copy_links_saved = copy_links;
-				int recurse_saved = recurse;
+				int save_copy_links = copy_links;
+				int save_xfer_dirs = xfer_dirs;
 				copy_links = copy_unsafe_links;
-				/* set recurse to 1 to prevent make_file
-				 * from ignoring directory, but still
-				 * turn off the recursive parameter to
-				 * send_file_name */
-				recurse = 1;
+				xfer_dirs = 1;
 				while ((slash = strchr(slash+1, '/')) != 0) {
 					*slash = 0;
 					send_file_name(f, flist, fname, 0, 0);
 					*slash = '/';
 				}
-				copy_links = copy_links_saved;
-				recurse = recurse_saved;
+				copy_links = save_copy_links;
+				xfer_dirs = save_xfer_dirs;
 				*p = 0;
 				strlcpy(lastpath, fname, sizeof lastpath);
 				*p = '/';
@@ -1110,8 +1220,8 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
 
 			if (!push_dir(dir)) {
 				io_error |= IOERR_GENERAL;
-				rprintf(FERROR, "push_dir %s failed: %s\n",
-					full_fname(dir), strerror(errno));
+				rsyserr(FERROR, errno, "push_dir %s failed",
+					full_fname(dir));
 				continue;
 			}
 
@@ -1127,24 +1237,43 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
 		if (one_file_system)
 			set_filesystem(fname);
 
-		send_file_name(f, flist, fname, recurse, XMIT_TOP_DIR);
+		do_subdirs = recurse >= 1 ? recurse-- : recurse;
+		send_file_name(f, flist, fname, do_subdirs, XMIT_DEL_START);
 
 		if (olddir[0]) {
 			flist_dir = NULL;
 			flist_dir_len = 0;
 			if (!pop_dir(olddir)) {
-				rprintf(FERROR, "pop_dir %s failed: %s\n",
-					full_fname(dir), strerror(errno));
+				rsyserr(FERROR, errno, "pop_dir %s failed",
+					full_fname(dir));
 				exit_cleanup(RERR_FILESELECT);
 			}
 		}
 	}
 
 	if (f != -1) {
+		gettimeofday(&end_tv, NULL);
+		stats.flist_buildtime =
+		    (int64)(end_tv.tv_sec - start_tv.tv_sec) * 1000
+			 + (end_tv.tv_usec - start_tv.tv_usec) / 1000;
+		if (stats.flist_buildtime == 0)
+			stats.flist_buildtime = 1;
+		start_tv = end_tv;
+
 		send_file_entry(NULL, f, 0);
 
 		if (show_filelist_p())
 			finish_filelist_progress(flist);
+
+		gettimeofday(&end_tv, NULL);
+		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;
 	}
 
 	clean_flist(flist, 0, 0);
@@ -1160,10 +1289,11 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
 		io_end_buffering();
 		stats.flist_size = stats.total_written - start_write;
 		stats.num_files = flist->count;
-		if (write_batch)
-			write_batch_flist_info(flist->count, flist->files);
 	}
 
+	if (verbose > 3)
+		output_flist(flist, f < 0 ? "delete" : who_am_i());
+
 	if (verbose > 2)
 		rprintf(FINFO, "send_file_list done\n");
 
@@ -1176,16 +1306,14 @@ struct file_list *recv_file_list(int f)
 	struct file_list *flist;
 	unsigned short flags;
 	int64 start_read;
-	extern int list_only;
 
 	if (show_filelist_p())
 		start_filelist_progress("receiving file list");
 
 	start_read = stats.total_read;
 
-	flist = new(struct file_list);
-	if (!flist)
-		goto oom;
+	flist = flist_new(WITH_HLINK, "recv_file_list");
+	received_flist = flist;
 
 	flist->count = 0;
 	flist->malloced = 1000;
@@ -1201,7 +1329,7 @@ struct file_list *recv_file_list(int f)
 
 		if (protocol_version >= 28 && (flags & XMIT_EXTENDED_FLAGS))
 			flags |= read_byte(f) << 8;
-		receive_file_entry(&flist->files[i], flags, f);
+		receive_file_entry(&flist->files[i], flags, flist, f);
 
 		if (S_ISREG(flist->files[i]->mode))
 			stats.total_size += flist->files[i]->length;
@@ -1215,7 +1343,7 @@ struct file_list *recv_file_list(int f)
 				f_name(flist->files[i]));
 		}
 	}
-	receive_file_entry(NULL, 0, 0); /* Signal that we're done. */
+	receive_file_entry(NULL, 0, NULL, 0); /* Signal that we're done. */
 
 	if (verbose > 2)
 		rprintf(FINFO, "received %d names\n", flist->count);
@@ -1230,15 +1358,16 @@ struct file_list *recv_file_list(int f)
 		 * protocol version 15 */
 		recv_uid_list(f, flist);
 
-		if (!read_batch) {
-			/* Recv the io_error flag */
-			if (lp_ignore_errors(module_id) || ignore_errors)
-				read_int(f);
-			else
-				io_error |= read_int(f);
-		}
+		/* Recv the io_error flag */
+		if (lp_ignore_errors(module_id) || ignore_errors)
+			read_int(f);
+		else
+			io_error |= read_int(f);
 	}
 
+	if (verbose > 3)
+		output_flist(flist, who_am_i());
+
 	if (list_only) {
 		int i;
 		for (i = 0; i < flist->count; i++)
@@ -1253,7 +1382,7 @@ struct file_list *recv_file_list(int f)
 
 	return flist;
 
-      oom:
+oom:
 	out_of_memory("recv_file_list");
 	return NULL;		/* not reached */
 }
@@ -1301,34 +1430,42 @@ int flist_find(struct file_list *flist, struct file_struct *f)
 	return -1;
 }
 
-
 /*
- * Free up any resources a file_struct has allocated, and optionally free
- * it up as well.
+ * Free up any resources a file_struct has allocated
+ * and clear the file.
  */
-void free_file(struct file_struct *file, int free_the_struct)
+void clear_file(int i, struct file_list *flist)
 {
-	if (free_the_struct)
-		free(file);
-	else
-		memset(file, 0, sizeof file[0]);
+	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);
 }
 
 
 /*
  * allocate a new file list
  */
-struct file_list *flist_new(void)
+struct file_list *flist_new(int with_hlink, char *msg)
 {
 	struct file_list *flist;
 
 	flist = new(struct file_list);
 	if (!flist)
-		out_of_memory("send_file_list");
+		out_of_memory(msg);
 
-	flist->count = 0;
-	flist->malloced = 0;
-	flist->files = NULL;
+	memset(flist, 0, sizeof (struct file_list));
+
+	if (!(flist->file_pool = pool_create(FILE_EXTENT, 0,
+	    out_of_memory, POOL_INTERN)))
+		out_of_memory(msg);
+
+#if 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;
 }
@@ -1338,9 +1475,8 @@ struct file_list *flist_new(void)
  */
 void flist_free(struct file_list *flist)
 {
-	int i;
-	for (i = 1; i < flist->count; i++)
-		free_file(flist->files[i], FREE_STRUCT);
+	pool_destroy(flist->file_pool);
+	pool_destroy(flist->hlink_pool);
 	free(flist->files);
 	free(flist);
 }
@@ -1358,7 +1494,7 @@ static void clean_flist(struct file_list *flist, int strip_root, int no_dups)
 		return;
 
 	qsort(flist->files, flist->count,
-	      sizeof(flist->files[0]), (int (*)()) file_compare);
+	    sizeof flist->files[0], (int (*)())file_compare);
 
 	for (i = no_dups? 0 : flist->count; i < flist->count; i++) {
 		if (flist->files[i]->basename) {
@@ -1378,9 +1514,10 @@ static void clean_flist(struct file_list *flist, int strip_root, int no_dups)
 			/* Make sure that if we unduplicate '.', that we don't
 			 * lose track of a user-specified starting point (or
 			 * else deletions will mysteriously fail with -R). */
-			if (flist->files[i]->flags & FLAG_TOP_DIR)
-				flist->files[prev_i]->flags |= FLAG_TOP_DIR;
-			free_file(flist->files[i], CLEAR_STRUCT);
+			if (flist->files[i]->flags & FLAG_DEL_START)
+				flist->files[prev_i]->flags |= FLAG_DEL_START;
+
+			clear_file(i, flist);
 		} else
 			prev_i = i;
 	}
@@ -1403,18 +1540,28 @@ static void clean_flist(struct file_list *flist, int strip_root, int no_dups)
 			}
 		}
 	}
+}
 
-	if (verbose <= 3)
-		return;
+static void output_flist(struct file_list *flist, const char *whose_list)
+{
+	char uidbuf[16], gidbuf[16];
+	struct file_struct *file;
+	int i;
 
 	for (i = 0; i < flist->count; i++) {
-		rprintf(FINFO, "[%s] i=%d %s %s %s mode=0%o len=%.0f\n",
-			who_am_i(), i,
-			NS(flist->files[i]->basedir),
-			NS(flist->files[i]->dirname),
-			NS(flist->files[i]->basename),
-			(int) flist->files[i]->mode,
-			(double) flist->files[i]->length);
+		file = flist->files[i];
+		if ((am_root || am_sender) && preserve_uid)
+			sprintf(uidbuf, " uid=%ld", (long)file->uid);
+		else
+			*uidbuf = '\0';
+		if (preserve_gid && file->gid != GID_NONE)
+			sprintf(gidbuf, " gid=%ld", (long)file->gid);
+		else
+			*gidbuf = '\0';
+		rprintf(FINFO, "[%s] i=%d %s %s %s mode=0%o len=%.0f%s%s\n",
+			whose_list, i, NS(file->basedir), NS(file->dirname),
+			NS(file->basename), (int)file->mode,
+			(double)file->length, uidbuf, gidbuf);
 	}
 }
 
@@ -1442,11 +1589,17 @@ int f_name_cmp(struct file_struct *f1, struct file_struct *f2)
 	if (!(c1 = (uchar*)f1->dirname)) {
 		state1 = fnc_BASE;
 		c1 = (uchar*)f1->basename;
+	} else if (!*c1) {
+		state1 = fnc_SLASH;
+		c1 = (uchar*)"/";
 	} else
 		state1 = fnc_DIR;
 	if (!(c2 = (uchar*)f2->dirname)) {
 		state2 = fnc_BASE;
 		c2 = (uchar*)f2->basename;
+	} else if (!*c2) {
+		state2 = fnc_SLASH;
+		c2 = (uchar*)"/";
 	} else
 		state2 = fnc_DIR;
 
@@ -1520,3 +1673,79 @@ char *f_name(struct file_struct *f)
 
 	return f_name_to(f, names[n]);
 }
+
+static int is_backup_file(char *fn)
+{
+	int k = strlen(fn) - backup_suffix_len;
+	return k > 0 && strcmp(fn+k, backup_suffix) == 0;
+}
+
+void delete_in_dir(struct file_list *flist, char *fname)
+{
+	static int deletion_count = 0;
+	struct file_list *del_flist;
+	int save_recurse = recurse;
+	int save_xfer_dirs = xfer_dirs;
+	int save_implied_dirs = implied_dirs;
+	int save_relative_paths = relative_paths;
+	char *argv[1];
+	int i, j, mode;
+
+	if (max_delete && deletion_count >= max_delete)
+		return;
+
+	if (io_error && !(lp_ignore_errors(module_id) || ignore_errors)) {
+		rprintf(FINFO, "IO error encountered - skipping file deletion\n");
+		max_delete = -1; /* avoid duplicating the above warning */
+		return;
+	}
+
+	if (delete_during) {
+		recurse = 1; /* allow one level only */
+		xfer_dirs = 1;
+		implied_dirs = 0;
+		relative_paths = 1;
+	}
+
+	argv[0] = fname;
+	del_flist = send_file_list(-1, 1, argv);
+
+	relative_paths = save_relative_paths;
+	implied_dirs = save_implied_dirs;
+	xfer_dirs = save_xfer_dirs;
+	recurse = save_recurse;
+
+	if (!del_flist)
+		return;
+
+	if (verbose > 1)
+		rprintf(FINFO, "deleting in %s\n", safe_fname(fname));
+
+	for (i = del_flist->count-1; i >= 0; i--) {
+		if (max_delete && deletion_count >= max_delete)
+			break;
+		if (!del_flist->files[i]->basename)
+			continue;
+		mode = del_flist->files[i]->mode;
+		if ((j = flist_find(flist, del_flist->files[i])) < 0
+		    || (delete_during && S_ISDIR(mode)
+		     && !S_ISDIR(flist->files[j]->mode))) {
+			char *f = f_name(del_flist->files[i]);
+			if (make_backups && (backup_dir || !is_backup_file(f))
+			  && !S_ISDIR(mode)) {
+				make_backup(f);
+				if (verbose) {
+					rprintf(FINFO, "deleting %s\n",
+						safe_fname(f));
+				}
+			} else {
+				int dflags = delete_during
+				    ? DEL_DIR | DEL_FORCE_RECURSE
+				    : DEL_DIR | DEL_NO_RECURSE;
+				delete_file(f, S_ISDIR(mode) ? dflags : 0);
+			}
+			deletion_count++;
+		}
+	}
+	flist_free(del_flist);
+}