X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/f05f993eb72937bbd446a4758b7f0232de764889..b9f592fbf50b0dc9e3d1d33b8deb2bf9abad9ef6:/flist.c

diff --git a/flist.c b/flist.c
index 22f688d1..ebb70e49 100644
--- a/flist.c
+++ b/flist.c
@@ -33,9 +33,11 @@ extern int verbose;
 extern int do_progress;
 extern int am_root;
 extern int am_server;
+extern int am_daemon;
 extern int always_checksum;
 extern int module_id;
 extern int ignore_errors;
+extern int numeric_ids;
 
 extern int cvs_exclude;
 
@@ -45,42 +47,41 @@ extern char *files_from;
 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 copy_links;
 extern int copy_unsafe_links;
 extern int protocol_version;
 extern int sanitize_paths;
+extern int delete_excluded;
+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 exclude_list_struct exclude_list;
+extern struct exclude_list_struct server_exclude_list;
+extern struct exclude_list_struct local_exclude_list;
 
 int io_error;
 
 static char empty_sum[MD4_SUM_LENGTH];
-static unsigned int min_file_struct_len;
+static unsigned int file_struct_len;
 
 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;
+	struct file_struct f;
 
-    /* Figure out how big the file_struct is without trailing padding */
-    min_file_struct_len = ((char*)&f.flags - (char*)&f) + sizeof f.flags;
+	/* Figure out how big the file_struct is without trailing padding */
+	file_struct_len = offsetof(struct file_struct, flags) + sizeof f.flags;
 }
 
 
@@ -92,7 +93,7 @@ static int show_filelist_p(void)
 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);
 }
@@ -106,7 +107,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);
 }
 
@@ -131,9 +132,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);
 
@@ -141,14 +143,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));
+	}
 }
 
 
@@ -171,10 +175,10 @@ 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, keep_dirlinks) < 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;
@@ -192,12 +196,19 @@ 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
@@ -210,6 +221,8 @@ int link_stat(const char *path, STRUCT_STAT * buffer)
  */
 static int check_exclude_file(char *fname, int is_dir, int exclude_level)
 {
+	int rc;
+
 #if 0 /* This currently never happens, so avoid a useless compare. */
 	if (exclude_level == NO_EXCLUDES)
 		return 0;
@@ -225,15 +238,16 @@ 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_exclude_list.head
+	    && check_exclude(&server_exclude_list, fname, is_dir) < 0)
 		return 1;
 	if (exclude_level != ALL_EXCLUDES)
 		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 (exclude_list.head
+	    && (rc = check_exclude(&exclude_list, fname, is_dir)) != 0)
+		return rc < 0;
+	if (local_exclude_list.head
+	    && check_exclude(&local_exclude_list, fname, is_dir) < 0)
 		return 1;
 	return 0;
 }
@@ -244,7 +258,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;
 }
@@ -256,14 +270,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;
 }
 
 
@@ -277,37 +291,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;
-
-		if (flist->malloced < 1000)
-			flist->malloced += 1000;
-		else
-			flist->malloced *= 2;
+	struct file_struct **new_ptr;
 
-		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) {
+		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)
@@ -315,12 +333,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 uint64 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)
@@ -329,7 +348,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;
@@ -337,7 +357,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;
 
@@ -348,22 +368,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)
@@ -391,8 +409,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)
@@ -434,20 +452,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
@@ -483,8 +508,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);
 		}
 	}
 
@@ -495,12 +520,14 @@ 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 uint64 dev;
+	static dev_t rdev;
+	static uint32 rdev_major;
 	static uid_t uid;
 	static gid_t gid;
 	static char lastname[MAXPATHLEN], *lastdir;
@@ -508,16 +535,17 @@ void receive_file_entry(struct file_struct **fptr, unsigned short flags, int f)
 	char thisname[MAXPATHLEN];
 	unsigned int l1 = 0, l2 = 0;
 	int alloc_len, basename_len, dirname_len, linkname_len, sum_len;
-	int file_struct_len, idev_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';
+		lastdir_len = -1;
 		return;
 	}
 
@@ -577,15 +605,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);
 		}
 	}
 
@@ -602,24 +633,14 @@ 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;
-	file_struct_len = idev_len? sizeof file[0] : min_file_struct_len;
 
 	alloc_len = file_struct_len + dirname_len + basename_len
-		  + linkname_len + sum_len + idev_len;
-	if (!(bp = new_array(char, alloc_len)))
-		out_of_memory("receive_file_entry");
+		  + linkname_len + sum_len;
+	bp = pool_alloc(flist->file_pool, alloc_len, "receive_file_entry");
+
 	file = *fptr = (struct file_struct *)bp;
-	memset(bp, 0, min_file_struct_len);
+	memset(bp, 0, file_struct_len);
 	bp += file_struct_len;
 
 	file->flags = flags & XMIT_TOP_DIR ? FLAG_TOP_DIR : 0;
@@ -629,13 +650,6 @@ void receive_file_entry(struct file_struct **fptr, unsigned short flags, int f)
 	file->uid = uid;
 	file->gid = gid;
 
-#if SUPPORT_HARD_LINKS
-	if (idev_len) {
-		file->link_u.idev = (struct idev *)bp;
-		bp += idev_len;
-	}
-#endif
-
 	if (dirname_len) {
 		file->dirname = lastdir = bp;
 		lastdir_len = dirname_len - 1;
@@ -663,16 +677,24 @@ void receive_file_entry(struct file_struct **fptr, unsigned short flags, int f)
 #endif
 
 #if SUPPORT_HARD_LINKS
-	if (idev_len) {
+	if (preserve_hard_links && protocol_version < 28 && S_ISREG(mode))
+		flags |= XMIT_HAS_IDEV_DATA;
+	if (flags & XMIT_HAS_IDEV_DATA) {
+		uint64 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
 
@@ -687,13 +709,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;
@@ -716,7 +737,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 exclude_level)
 {
 	static char *lastdir;
 	static int lastdir_len = -1;
@@ -726,10 +748,12 @@ struct file_struct *make_file(char *fname, int exclude_level)
 	char thisname[MAXPATHLEN];
 	char linkname[MAXPATHLEN];
 	int alloc_len, basename_len, dirname_len, linkname_len, sum_len;
-	int file_struct_len, idev_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);
@@ -743,18 +767,32 @@ struct file_struct *make_file(char *fname, int exclude_level)
 
 	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 (exclude_level != NO_EXCLUDES
+		    && check_exclude_file(thisname, 0, exclude_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;
 	}
 
@@ -780,7 +818,7 @@ struct file_struct *make_file(char *fname, int exclude_level)
 	if (lp_ignore_nonreadable(module_id) && access(thisname, R_OK) != 0)
 		return NULL;
 
-      skip_excludes:
+skip_excludes:
 
 	if (verbose > 2) {
 		rprintf(FINFO, "[%s] make_file(%s,*,%d)\n",
@@ -808,32 +846,20 @@ struct file_struct *make_file(char *fname, int exclude_level)
 	linkname_len = 0;
 #endif
 
-#if SUPPORT_HARD_LINKS
-	if (preserve_hard_links) {
-		if (protocol_version < 28) {
-			if (S_ISREG(st.st_mode))
-				idev_len = sizeof (struct idev);
-			else
-				idev_len = 0;
-		} else {
-			if (!S_ISDIR(st.st_mode) && st.st_nlink > 1)
-				idev_len = sizeof (struct idev);
-			else
-				idev_len = 0;
-		}
-	} else
-#endif
-		idev_len = 0;
-
 	sum_len = always_checksum && S_ISREG(st.st_mode) ? MD4_SUM_LENGTH : 0;
-	file_struct_len = idev_len? sizeof file[0] : min_file_struct_len;
 
 	alloc_len = file_struct_len + dirname_len + basename_len
-		  + linkname_len + sum_len + idev_len;
-	if (!(bp = new_array(char, alloc_len)))
-		out_of_memory("receive_file_entry");
+	    + 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, min_file_struct_len);
+	memset(bp, 0, file_struct_len);
 	bp += file_struct_len;
 
 	file->flags = flags;
@@ -844,9 +870,20 @@ struct file_struct *make_file(char *fname, int exclude_level)
 	file->gid = st.st_gid;
 
 #if SUPPORT_HARD_LINKS
-	if (idev_len) {
-		file->link_u.idev = (struct idev *)bp;
-		bp += idev_len;
+	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;
 	}
@@ -898,12 +935,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_EXCLUDES : ALL_EXCLUDES);
 
 	if (!file)
 		return;
@@ -912,9 +947,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);
@@ -922,10 +954,15 @@ 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;
+		struct exclude_list_struct last_list = local_exclude_list;
+		local_exclude_list.head = local_exclude_list.tail = NULL;
 		send_directory(f, flist, f_name_to(file, fbuf));
-		local_exclude_list = last_exclude_list;
-		return;
+		if (verbose > 2) {
+			rprintf(FINFO, "[%s] popping %sexclude list\n",
+				who_am_i(), local_exclude_list.debug_type);
+		}
+		clear_exclude_list(&local_exclude_list);
+		local_exclude_list = last_list;
 	}
 }
 
@@ -941,8 +978,7 @@ static void send_directory(int f, struct file_list *flist, char *dir)
 	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;
 	}
 
@@ -960,13 +996,12 @@ 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 {
+		    < MAXPATHLEN - offset) {
+			add_exclude_file(&local_exclude_list, fname,
+					 XFLG_WORD_SPLIT | XFLG_WORDS_ONLY);
+		} else {
 			io_error |= IOERR_GENERAL;
 			rprintf(FINFO,
 				"cannot cvs-exclude in long-named directory %s\n",
@@ -990,18 +1025,16 @@ 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 */
-
 	closedir(d);
 }
 
 
 /**
+ * This function is normally called by the sender, but the receiver also
+ * uses it to construct its own file list if --delete has been specified.
  * 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
@@ -1022,14 +1055,15 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
 
 	start_write = stats.total_written;
 
-	flist = flist_new();
+	flist = flist_new(f == -1 ? WITHOUT_HLINK : WITH_HLINK,
+	    "send_file_list");
 
 	if (f != -1) {
 		io_start_buffering_out(f);
 		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;
@@ -1063,11 +1097,11 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
 			}
 		}
 
-		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;
 		}
@@ -1136,8 +1170,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;
 			}
 
@@ -1159,8 +1193,8 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
 			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);
 			}
 		}
@@ -1173,6 +1207,11 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
 			finish_filelist_progress(flist);
 	}
 
+	if (flist->hlink_pool) {
+		pool_destroy(flist->hlink_pool);
+		flist->hlink_pool = NULL;
+	}
+
 	clean_flist(flist, 0, 0);
 
 	if (f != -1) {
@@ -1186,10 +1225,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);
+
 	if (verbose > 2)
 		rprintf(FINFO, "send_file_list done\n");
 
@@ -1202,16 +1242,13 @@ 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");
 
 	flist->count = 0;
 	flist->malloced = 1000;
@@ -1227,7 +1264,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;
@@ -1241,7 +1278,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);
@@ -1256,15 +1293,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);
+
 	if (list_only) {
 		int i;
 		for (i = 0; i < flist->count; i++)
@@ -1279,7 +1317,7 @@ struct file_list *recv_file_list(int f)
 
 	return flist;
 
-      oom:
+oom:
 	out_of_memory("recv_file_list");
 	return NULL;		/* not reached */
 }
@@ -1327,34 +1365,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, min_file_struct_len);
+	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;
 }
@@ -1364,9 +1410,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);
 }
@@ -1384,7 +1429,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) {
@@ -1406,7 +1451,8 @@ static void clean_flist(struct file_list *flist, int strip_root, int no_dups)
 			 * 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);
+
+			clear_file(i, flist);
 		} else
 			prev_i = i;
 	}
@@ -1429,25 +1475,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)
+{
+	char uidbuf[16], gidbuf[16];
+	struct file_struct *file;
+	int i;
 
 	for (i = 0; i < flist->count; i++) {
-		char uidbuf[16], gidbuf[16];
-		struct file_struct *file = flist->files[i];
+		file = flist->files[i];
 		if (am_root && preserve_uid)
 			sprintf(uidbuf, " uid=%ld", (long)file->uid);
 		else
 			*uidbuf = '\0';
-		if (preserve_gid)
+		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",
 			who_am_i(), i, NS(file->basedir), NS(file->dirname),
-			NS(file->basename), (int) file->mode,
-			(double) file->length, uidbuf, gidbuf);
+			NS(file->basename), (int)file->mode,
+			(double)file->length, uidbuf, gidbuf);
 	}
 }
 
@@ -1475,11 +1524,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;