X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/904e5af12874694c47b7ccf7b8b2e6aa883cab0f..82ad07c4182f744c07b96a15df4572e559ed7dc8:/generator.c

diff --git a/generator.c b/generator.c
index c5facb7c..536302f1 100644
--- a/generator.c
+++ b/generator.c
@@ -1,39 +1,37 @@
-/* -*- c-file-style: "linux" -*-
-
-   rsync -- fast file replication program
-
-   Copyright (C) 1996-2000 by Andrew Tridgell
-   Copyright (C) Paul Mackerras 1996
-   Copyright (C) 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.
-*/
+/*
+ * Routines that are exclusive to the generator process.
+ *
+ * Copyright (C) 1996-2000 Andrew Tridgell
+ * Copyright (C) 1996 Paul Mackerras
+ * Copyright (C) 2002 Martin Pool <mbp@samba.org>
+ * Copyright (C) 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"
 
 extern int verbose;
 extern int dry_run;
 extern int do_xfers;
-extern int log_format_has_i;
-extern int log_format_has_o_or_i;
-extern int daemon_log_format_has_i;
+extern int stdout_format_has_i;
+extern int logfile_format_has_i;
 extern int am_root;
 extern int am_server;
 extern int am_daemon;
 extern int do_progress;
-extern int recurse;
 extern int relative_paths;
 extern int implied_dirs;
 extern int keep_dirlinks;
@@ -52,7 +50,8 @@ extern int delete_during;
 extern int delete_after;
 extern int module_id;
 extern int ignore_errors;
-extern int remove_sent_files;
+extern int flist_extra_ndx;
+extern int remove_source_files;
 extern int delay_updates;
 extern int update_only;
 extern int ignore_existing;
@@ -80,12 +79,14 @@ extern int copy_dest;
 extern int link_dest;
 extern int whole_file;
 extern int list_only;
+extern int new_root_dir;
 extern int read_batch;
 extern int safe_symlinks;
 extern long block_size; /* "long" because popt can't set an int32. */
 extern int max_delete;
 extern int force_delete;
 extern int one_file_system;
+extern int file_struct_len;
 extern struct stats stats;
 extern dev_t filesystem_dev;
 extern char *backup_dir;
@@ -94,13 +95,26 @@ extern int backup_suffix_len;
 extern struct file_list *the_file_list;
 extern struct filter_list_struct server_filter_list;
 
+int ignore_perishable = 0;
+int non_perishable_cnt = 0;
+
 static int deletion_count = 0; /* used to implement --max-delete */
-static int can_link_symlinks = 1; /* start out optimistic */
-static int can_link_devices = 1;
+static FILE *delete_delay_fp = NULL;
+
+/* For calling delete_item() and delete_dir_contents(). */
+#define DEL_RECURSE		(1<<1) /* recurse */
+#define DEL_DIR_IS_EMPTY	(1<<2) /* internal delete_FUNCTIONS use only */
 
-/* For calling delete_file() */
-#define DEL_FORCE_RECURSE	(1<<1) /* recurse even w/o --force */
-#define DEL_TERSE		(1<<3)
+enum nonregtype {
+    TYPE_DIR, TYPE_SPECIAL, TYPE_DEVICE, TYPE_SYMLINK
+};
+
+enum delret {
+    DR_SUCCESS = 0, DR_FAILURE, DR_AT_LIMIT, DR_NOT_EMPTY
+};
+
+/* Forward declaration for delete_item(). */
+static enum delret delete_dir_contents(char *fname, int flags);
 
 
 static int is_backup_file(char *fn)
@@ -109,109 +123,213 @@ static int is_backup_file(char *fn)
 	return k > 0 && strcmp(fn+k, backup_suffix) == 0;
 }
 
-
-/* Delete a file or directory.  If DEL_FORCE_RECURSE is set in the flags, or if
- * force_delete is set, this will delete recursively.
+/* Delete a file or directory.  If DEL_RECURSE is set in the flags, this will
+ * delete recursively.
  *
- * Note that fname must point to a MAXPATHLEN buffer if the mode indicates it's
+ * Note that fbuf must point to a MAXPATHLEN buffer if the mode indicates it's
  * a directory! (The buffer is used for recursion, but returned unchanged.)
  */
-static int delete_item(char *fname, int mode, int flags)
+static enum delret delete_item(char *fbuf, int mode, char *replace, int flags)
 {
-	struct file_list *dirlist;
-	int j, dlen, zap_dir, ok;
-	unsigned remainder;
-	void *save_filters;
-	char *p;
+	enum delret ret;
+	char *what;
+	int ok;
 
-	if (!S_ISDIR(mode)) {
-		if (max_delete && ++deletion_count > max_delete)
-			return 0;
-		if (make_backups && (backup_dir || !is_backup_file(fname)))
-			ok = make_backup(fname);
-		else
-			ok = robust_unlink(fname) == 0;
-		if (ok) {
-			if (!(flags & DEL_TERSE))
-				log_delete(fname, mode);
-			return 0;
-		}
-		if (errno == ENOENT) {
-			deletion_count--;
-			return 0;
-		}
-		rsyserr(FERROR, errno, "delete_file: unlink %s failed",
-			full_fname(fname));
-		return -1;
+	if (verbose > 2) {
+		rprintf(FINFO, "delete_item(%s) mode=%o flags=%d\n",
+			fbuf, mode, flags);
+	}
+
+	if (S_ISDIR(mode) && !(flags & DEL_DIR_IS_EMPTY)) {
+		ignore_perishable = 1;
+		/* If DEL_RECURSE is not set, this just reports emptiness. */
+		ret = delete_dir_contents(fbuf, flags);
+		ignore_perishable = 0;
+		if (ret == DR_NOT_EMPTY || ret == DR_AT_LIMIT)
+			goto check_ret;
+		/* OK: try to delete the directory. */
+	}
+
+	if (!replace && max_delete >= 0 && ++deletion_count > max_delete)
+		return DR_AT_LIMIT;
+
+	if (S_ISDIR(mode)) {
+		what = "rmdir";
+		ok = do_rmdir(fbuf) == 0;
+	} else if (make_backups && (backup_dir || !is_backup_file(fbuf))) {
+		what = "make_backup";
+		ok = make_backup(fbuf);
+	} else {
+		what = "unlink";
+		ok = robust_unlink(fbuf) == 0;
 	}
 
-	zap_dir = flags & DEL_FORCE_RECURSE || force_delete;
-	if ((max_delete && ++deletion_count > max_delete)
-	    || (dry_run && zap_dir)) {
-		ok = 0;
-		errno = ENOTEMPTY;
-	} else if (make_backups && !backup_dir && !is_backup_file(fname)
-	    && !(flags & DEL_FORCE_RECURSE))
-		ok = make_backup(fname);
-	else
-		ok = do_rmdir(fname) == 0;
 	if (ok) {
-		if (!(flags & DEL_TERSE))
-			log_delete(fname, mode);
-		return 0;
+		if (!replace)
+			log_delete(fbuf, mode);
+		ret = DR_SUCCESS;
+	} else {
+		if (S_ISDIR(mode) && errno == ENOTEMPTY) {
+			rprintf(FINFO, "cannot delete non-empty directory: %s\n",
+				fbuf);
+			ret = DR_NOT_EMPTY;
+		} else if (errno != ENOENT) {
+			rsyserr(FERROR, errno, "delete_file: %s(%s) failed",
+				what, fbuf);
+			ret = DR_FAILURE;
+		} else {
+			deletion_count--;
+			ret = DR_SUCCESS;
+		}
 	}
-	if (errno == ENOENT) {
-		deletion_count--;
-		return 0;
+
+  check_ret:
+	if (replace && ret != DR_SUCCESS) {
+		rprintf(FERROR, "could not make way for new %s: %s\n",
+			replace, fbuf);
 	}
-	if (!zap_dir) {
-		rsyserr(FERROR, errno, "delete_file: rmdir %s failed",
-			full_fname(fname));
-		return -1;
+	return ret;
+}
+
+/* The directory is about to be deleted: if DEL_RECURSE is given, delete all
+ * its contents, otherwise just checks for content.  Returns DR_SUCCESS or
+ * DR_NOT_EMPTY.  Note that fname must point to a MAXPATHLEN buffer!  (The
+ * buffer is used for recursion, but returned unchanged.)
+ */
+static enum delret delete_dir_contents(char *fname, int flags)
+{
+	struct file_list *dirlist;
+	enum delret ret;
+	unsigned remainder;
+	void *save_filters;
+	int j, dlen;
+	char *p;
+
+	if (verbose > 3) {
+		rprintf(FINFO, "delete_dir_contents(%s) flags=%d\n",
+			fname, flags);
 	}
-	flags |= DEL_FORCE_RECURSE; /* mark subdir dels as not "in the way" */
-	deletion_count--;
 
 	dlen = strlen(fname);
 	save_filters = push_local_filters(fname, dlen);
 
+	non_perishable_cnt = 0;
 	dirlist = get_dirlist(fname, dlen, 0);
+	ret = non_perishable_cnt ? DR_NOT_EMPTY : DR_SUCCESS;
+
+	if (!dirlist->count)
+		goto done;
+
+	if (!(flags & DEL_RECURSE)) {
+		ret = DR_NOT_EMPTY;
+		goto done;
+	}
 
 	p = fname + dlen;
 	if (dlen != 1 || *fname != '/')
 		*p++ = '/';
 	remainder = MAXPATHLEN - (p - fname);
 
+	/* We do our own recursion, so make delete_item() non-recursive. */
+	flags = (flags & ~DEL_RECURSE) | DEL_DIR_IS_EMPTY;
+
 	for (j = dirlist->count; j--; ) {
 		struct file_struct *fp = dirlist->files[j];
 
-		if (fp->flags & FLAG_MOUNT_POINT)
+		if (fp->flags & FLAG_MOUNT_DIR) {
+			if (verbose > 1) {
+				rprintf(FINFO,
+				    "mount point, %s, pins parent directory\n",
+				    f_name(fp, NULL));
+			}
+			ret = DR_NOT_EMPTY;
 			continue;
+		}
 
 		strlcpy(p, fp->basename, remainder);
-		delete_item(fname, fp->mode, flags & ~DEL_TERSE);
+		/* Save stack by recursing to ourself directly. */
+		if (S_ISDIR(fp->mode)
+		 && delete_dir_contents(fname, flags | DEL_RECURSE) != DR_SUCCESS)
+			ret = DR_NOT_EMPTY;
+		if (delete_item(fname, fp->mode, NULL, flags) != DR_SUCCESS)
+			ret = DR_NOT_EMPTY;
 	}
-	flist_free(dirlist);
 
 	fname[dlen] = '\0';
 
+  done:
+	flist_free(dirlist);
 	pop_local_filters(save_filters);
 
-	if (max_delete && ++deletion_count > max_delete)
-		return 0;
+	if (ret == DR_NOT_EMPTY) {
+		rprintf(FINFO, "cannot delete non-empty directory: %s\n",
+			fname);
+	}
+	return ret;
+}
 
-	if (do_rmdir(fname) == 0) {
-		if (!(flags & DEL_TERSE))
-			log_delete(fname, mode);
-	} else if (errno != ENOTEMPTY && errno != EEXIST && errno != ENOENT) {
-		rsyserr(FERROR, errno, "delete_file: rmdir %s failed",
-			full_fname(fname));
+static void start_delete_temp(void)
+{
+	char fnametmp[MAXPATHLEN];
+	int fd, save_dry_run = dry_run;
+
+	dry_run = 0;
+	if (!get_tmpname(fnametmp, "deldelay")
+	 || (fd = do_mkstemp(fnametmp, 0600)) < 0
+	 || !(delete_delay_fp = fdopen(fd, "w+"))) {
+		rprintf(FERROR, "Unable to create delete-delay temp file.\n");
+		exit_cleanup(RERR_FILEIO);
+	}
+	dry_run = save_dry_run;
+	unlink(fnametmp);
+}
+
+static int read_delay_line(FILE *fp, char *buf, int bsize)
+{
+	int ch, mode = 0;
+
+	if ((ch = fgetc(fp)) == EOF)
 		return -1;
+
+	while (1) {
+		if (ch == ' ')
+			break;
+		if (ch > '7' || ch < '0') {
+			rprintf(FERROR, "invalid data in delete-delay file.\n");
+			exit_cleanup(RERR_FILEIO);
+		}
+		mode = mode*8 + ch - '0';
+		if ((ch = fgetc(fp)) == EOF) {
+		  unexpected_eof:
+			rprintf(FERROR, "unexpected EOF in delete-delay file.\n");
+			exit_cleanup(RERR_FILEIO);
+		}
 	}
 
-	return 0;
+	while (1) {
+		if ((ch = fgetc(fp)) == EOF)
+			goto unexpected_eof;
+		if (bsize-- <= 0) {
+			rprintf(FERROR, "filename too long in delete-delay file.\n");
+			exit_cleanup(RERR_FILEIO);
+		}
+		*buf++ = (char)ch;
+		if (ch == '\0')
+			break;
+	}
+
+	return mode;
 }
 
+static void delayed_deletions(char *delbuf)
+{
+	int mode;
+
+	fseek(delete_delay_fp, 0, 0);
+	while ((mode = read_delay_line(delete_delay_fp, delbuf, MAXPATHLEN)) >= 0)
+		delete_item(delbuf, mode, NULL, DEL_RECURSE);
+	fclose(delete_delay_fp);
+}
 
 /* This function is used to implement per-directory deletion, and is used by
  * all the --delete-WHEN options.  Note that the fbuf pointer must point to a
@@ -275,11 +393,20 @@ static void delete_in_dir(struct file_list *flist, char *fbuf,
 	 * from the filesystem. */
 	for (i = dirlist->count; i--; ) {
 		struct file_struct *fp = dirlist->files[i];
-		if (!fp->basename || fp->flags & FLAG_MOUNT_POINT)
+		if (!fp->basename)
+			continue;
+		if (fp->flags & FLAG_MOUNT_DIR) {
+			if (verbose > 1)
+				rprintf(FINFO, "cannot delete mount point: %s\n",
+					f_name(fp, NULL));
 			continue;
+		}
 		if (flist_find(flist, fp) < 0) {
 			f_name(fp, delbuf);
-			delete_item(delbuf, fp->mode, DEL_FORCE_RECURSE);
+			if (delete_delay_fp)
+				fprintf(delete_delay_fp, "%o %s%c", (short)fp->mode, delbuf, '\0');
+			else
+				delete_item(delbuf, fp->mode, NULL, DEL_RECURSE);
 		}
 	}
 
@@ -294,14 +421,14 @@ static void do_delete_pass(struct file_list *flist)
 	STRUCT_STAT st;
 	int j;
 
-	if (dry_run > 1 /* destination doesn't exist yet */
-	 || list_only)
+	/* dry_run is incremented when the destination doesn't exist yet. */
+	if (dry_run > 1 || list_only)
 		return;
 
 	for (j = 0; j < flist->count; j++) {
 		struct file_struct *file = flist->files[j];
 
-		if (!(file->flags & FLAG_DEL_HERE))
+		if (!(file->flags & FLAG_XFER_DIR))
 			continue;
 
 		f_name(file, fbuf);
@@ -326,17 +453,17 @@ int unchanged_attrs(struct file_struct *file, STRUCT_STAT *st)
 	 && (st->st_mode & CHMOD_BITS) != (file->mode & CHMOD_BITS))
 		return 0;
 
-	if (am_root && preserve_uid && st->st_uid != file->uid)
+	if (am_root && preserve_uid && st->st_uid != F_UID(file))
 		return 0;
 
-	if (preserve_gid && file->gid != GID_NONE && st->st_gid != file->gid)
+	if (preserve_gid && F_GID(file) != GID_NONE && st->st_gid != F_GID(file))
 		return 0;
 
 	return 1;
 }
 
 void itemize(struct file_struct *file, int ndx, int statret, STRUCT_STAT *st,
-	     int32 iflags, uchar fnamecmp_type, char *xname)
+	     int32 iflags, uchar fnamecmp_type, const char *xname)
 {
 	if (statret >= 0) { /* A from-dest-dir statret can == 1! */
 		int keep_time = !preserve_times ? 0
@@ -346,22 +473,23 @@ void itemize(struct file_struct *file, int ndx, int statret, STRUCT_STAT *st,
 		if (S_ISREG(file->mode) && file->length != st->st_size)
 			iflags |= ITEM_REPORT_SIZE;
 		if ((iflags & (ITEM_TRANSFER|ITEM_LOCAL_CHANGE) && !keep_time
-		     && (!(iflags & ITEM_XNAME_FOLLOWS) || *xname))
-		    || (keep_time && cmp_time(file->modtime, st->st_mtime) != 0))
+		  && !(iflags & ITEM_MATCHED)
+		  && (!(iflags & ITEM_XNAME_FOLLOWS) || *xname))
+		 || (keep_time && cmp_time(file->modtime, st->st_mtime) != 0))
 			iflags |= ITEM_REPORT_TIME;
 		if ((file->mode & CHMOD_BITS) != (st->st_mode & CHMOD_BITS))
 			iflags |= ITEM_REPORT_PERMS;
-		if (preserve_uid && am_root && file->uid != st->st_uid)
+		if (preserve_uid && am_root && F_UID(file) != st->st_uid)
 			iflags |= ITEM_REPORT_OWNER;
-		if (preserve_gid && file->gid != GID_NONE
-		    && st->st_gid != file->gid)
+		if (preserve_gid && F_GID(file) != GID_NONE
+		    && st->st_gid != F_GID(file))
 			iflags |= ITEM_REPORT_GROUP;
 	} else
 		iflags |= ITEM_IS_NEW;
 
 	iflags &= 0xffff;
 	if ((iflags & SIGNIFICANT_ITEM_FLAGS || verbose > 1
-	  || log_format_has_i > 1 || (xname && *xname)) && !read_batch) {
+	  || stdout_format_has_i > 1 || (xname && *xname)) && !read_batch) {
 		if (protocol_version >= 29) {
 			if (ndx >= 0)
 				write_int(sock_f_out, ndx);
@@ -370,8 +498,10 @@ void itemize(struct file_struct *file, int ndx, int statret, STRUCT_STAT *st,
 				write_byte(sock_f_out, fnamecmp_type);
 			if (iflags & ITEM_XNAME_FOLLOWS)
 				write_vstring(sock_f_out, xname, strlen(xname));
-		} else if (ndx >= 0)
-			log_item(file, &stats, iflags, xname);
+		} else if (ndx >= 0) {
+			enum logcode code = logfile_format_has_i ? FINFO : FCLIENT;
+			log_item(code, file, &stats, iflags, xname);
+		}
 	}
 }
 
@@ -387,7 +517,7 @@ int unchanged_file(char *fn, struct file_struct *file, STRUCT_STAT *st)
 	if (always_checksum && S_ISREG(st->st_mode)) {
 		char sum[MD4_SUM_LENGTH];
 		file_checksum(fn, sum, st->st_size);
-		return memcmp(sum, file->u.sum, checksum_len) == 0;
+		return memcmp(sum, F_SUM(file), checksum_len) == 0;
 	}
 
 	if (size_only)
@@ -454,7 +584,7 @@ static void sum_sizes_sqroot(struct sum_struct *sum, int64 len)
 		int64 l;
 		int b = BLOCKSUM_BIAS;
 		for (l = len; l >>= 1; b += 2) {}
-		for (c = blength; c >>= 1 && b; b--) {}
+		for (c = blength; (c >>= 1) && b; b--) {}
 		/* add a bit, subtract rollsum, round up. */
 		s2length = (b + 1 - 32 + 7) / 8; /* --optimize in compiler-- */
 		s2length = MAX(s2length, csum_length);
@@ -464,8 +594,8 @@ static void sum_sizes_sqroot(struct sum_struct *sum, int64 len)
 	sum->flength	= len;
 	sum->blength	= blength;
 	sum->s2length	= s2length;
-	sum->remainder	= len % blength;
-	sum->count	= len / blength + (sum->remainder != 0);
+	sum->remainder	= (int32)(len % blength);
+	sum->count	= (int32)(len / blength) + (sum->remainder != 0);
 
 	if (sum->count && verbose > 2) {
 		rprintf(FINFO,
@@ -549,8 +679,7 @@ static int find_fuzzy(struct file_struct *file, struct file_list *dirlist)
 		int len, suf_len;
 		uint32 dist;
 
-		if (!S_ISREG(fp->mode) || !fp->length
-		    || fp->flags & FLAG_NO_FUZZY)
+		if (!S_ISREG(fp->mode) || !fp->length || fp->flags & FLAG_SENT)
 			continue;
 
 		name = fp->basename;
@@ -595,10 +724,10 @@ void check_for_finished_hlinks(int itemizing, enum logcode code)
 			continue;
 
 		file = the_file_list->files[ndx];
-		if (!file->link_u.links)
+		if (!IS_HLINKED(file))
 			continue;
 
-		hard_link_cluster(file, ndx, itemizing, code);
+		hard_link_cluster(file, ndx, itemizing, code, -1);
 	}
 }
 
@@ -631,7 +760,7 @@ static int try_dests_reg(struct file_struct *file, char *fname, int ndx,
 		case 2:
 			if (!unchanged_attrs(file, stp))
 				continue;
-			if ((always_checksum || ignore_times)
+			if (always_checksum && preserve_times
 			 && cmp_time(stp->st_mtime, file->modtime))
 				continue;
 			best_match = j;
@@ -648,29 +777,27 @@ static int try_dests_reg(struct file_struct *file, char *fname, int ndx,
 		j = best_match;
 		pathjoin(cmpbuf, MAXPATHLEN, basis_dir[j], fname);
 		if (link_stat(cmpbuf, stp, 0) < 0)
-			match_level = 0;
+			return -1;
 	}
 
-#ifdef HAVE_LINK
 	if (match_level == 3 && !copy_dest) {
+#ifdef SUPPORT_HARD_LINKS
 		if (link_dest) {
+			int i = itemizing && (verbose > 1 || stdout_format_has_i > 1);
 			if (hard_link_one(file, ndx, fname, 0, stp,
-					  cmpbuf, 1,
-					  itemizing && verbose > 1,
-					  code) < 0)
+					  cmpbuf, 1, i, code) < 0)
 				goto try_a_copy;
-			if (preserve_hard_links && file->link_u.links)
-				hard_link_cluster(file, ndx, itemizing, code);
-		} else if (itemizing)
+			if (preserve_hard_links && IS_HLINKED(file))
+				hard_link_cluster(file, ndx, itemizing, code, j);
+		} else
+#endif
+		if (itemizing)
 			itemize(file, ndx, 0, stp, 0, 0, NULL);
 		if (verbose > 1 && maybe_ATTRS_REPORT) {
-			code = daemon_log_format_has_i || dry_run
-			     ? FCLIENT : FINFO;
-			rprintf(code, "%s is uptodate\n", fname);
+			rprintf(FCLIENT, "%s is uptodate\n", fname);
 		}
 		return -2;
 	}
-#endif
 
 	if (match_level >= 2) {
 	  try_a_copy: /* Copy the file locally. */
@@ -687,13 +814,12 @@ static int try_dests_reg(struct file_struct *file, char *fname, int ndx,
 		if (maybe_ATTRS_REPORT
 		 && ((!itemizing && verbose && match_level == 2)
 		  || (verbose > 1 && match_level == 3))) {
-			code = daemon_log_format_has_i || dry_run
-			     ? FCLIENT : FINFO;
+			code = match_level == 3 ? FCLIENT : FINFO;
 			rprintf(code, "%s%s\n", fname,
 				match_level == 3 ? " is uptodate" : "");
 		}
-		if (preserve_hard_links && file->link_u.links)
-			hard_link_cluster(file, ndx, itemizing, code);
+		if (preserve_hard_links && IS_HLINKED(file))
+			hard_link_cluster(file, ndx, itemizing, code, j);
 		return -2;
 	}
 
@@ -701,56 +827,143 @@ static int try_dests_reg(struct file_struct *file, char *fname, int ndx,
 }
 
 /* This is only called for non-regular files.  We return -2 if we've finished
- * handling the file, or -1 if no dest-linking occurred. */
+ * handling the file, or -1 if no dest-linking occurred, or a non-negative
+ * value if we found an alternate basis file. */
 static int try_dests_non(struct file_struct *file, char *fname, int ndx,
-			 int itemizing, int *possible_ptr,
+			 char *cmpbuf, STRUCT_STAT *stp, int itemizing,
 			 int maybe_ATTRS_REPORT, enum logcode code)
 {
-	char fnamebuf[MAXPATHLEN], lnk[MAXPATHLEN];
-	STRUCT_STAT st;
-	int len, i = 0;
+	char lnk[MAXPATHLEN];
+	int best_match = -1;
+	int match_level = 0;
+	enum nonregtype type;
+	int len, j = 0;
+
+#ifndef SUPPORT_LINKS
+	if (S_ISLNK(file->mode))
+		return -1;
+#endif
+	if (S_ISDIR(file->mode)) {
+		type = TYPE_DIR;
+	} else if (IS_SPECIAL(file->mode))
+		type = TYPE_SPECIAL;
+	else if (IS_DEVICE(file->mode))
+		type = TYPE_DEVICE;
+#ifdef SUPPORT_LINKS
+	else if (S_ISLNK(file->mode))
+		type = TYPE_SYMLINK;
+#endif
+	else {
+		rprintf(FERROR,
+			"internal: try_dests_non() called with invalid mode (%o)\n",
+			(int)file->mode);
+		exit_cleanup(RERR_UNSUPPORTED);
+	}
 
 	do {
-		pathjoin(fnamebuf, MAXPATHLEN, basis_dir[i], fname);
-		if (link_stat(fnamebuf, &st, 0) < 0 || S_ISDIR(st.st_mode)
-		 || !unchanged_attrs(file, &st))
+		pathjoin(cmpbuf, MAXPATHLEN, basis_dir[j], fname);
+		if (link_stat(cmpbuf, stp, 0) < 0)
 			continue;
-		if (S_ISLNK(file->mode)) {
+		switch (type) {
+		case TYPE_DIR:
+			if (!S_ISDIR(stp->st_mode))
+				continue;
+			break;
+		case TYPE_SPECIAL:
+			if (!IS_SPECIAL(stp->st_mode))
+				continue;
+			break;
+		case TYPE_DEVICE:
+			if (!IS_DEVICE(stp->st_mode))
+				continue;
+			break;
 #ifdef SUPPORT_LINKS
-			if ((len = readlink(fnamebuf, lnk, MAXPATHLEN-1)) <= 0)
+		case TYPE_SYMLINK:
+			if (!S_ISLNK(stp->st_mode))
 				continue;
-			lnk[len] = '\0';
-			if (strcmp(lnk, file->u.link) != 0)
+			break;
 #endif
+		}
+		if (match_level < 1) {
+			match_level = 1;
+			best_match = j;
+		}
+		switch (type) {
+		case TYPE_DIR:
+			break;
+		case TYPE_SPECIAL:
+		case TYPE_DEVICE:
+			if (stp->st_rdev != MAKEDEV(F_DMAJOR(file), F_DMINOR(file)))
 				continue;
-		} else {
-			if (!IS_DEVICE(st.st_mode) || st.st_rdev != file->u.rdev)
+			break;
+#ifdef SUPPORT_LINKS
+		case TYPE_SYMLINK:
+			if ((len = readlink(cmpbuf, lnk, MAXPATHLEN-1)) <= 0)
 				continue;
+			lnk[len] = '\0';
+			if (strcmp(lnk, F_SYMLINK(file)) != 0)
+				continue;
+			break;
+#endif
 		}
-		if (link_dest) {
-			if (do_link(fnamebuf, fname) < 0) {
-				/* TODO improve this to be based on errno? */
-				*possible_ptr = 0;
-				break;
-			}
-			if (preserve_hard_links && file->link_u.links)
-				hard_link_cluster(file, ndx, itemizing, code);
+		if (match_level < 2) {
+			match_level = 2;
+			best_match = j;
 		}
-		if (itemizing && log_format_has_i && verbose > 1) {
-			int changes = compare_dest ? 0 : ITEM_LOCAL_CHANGE
-				    + (link_dest ? ITEM_XNAME_FOLLOWS : 0);
-			char *lp = link_dest ? "" : NULL;
-			itemize(file, ndx, 0, &st, changes, 0, lp);
+		if (unchanged_attrs(file, stp)) {
+			match_level = 3;
+			best_match = j;
+			break;
+		}
+	} while (basis_dir[++j] != NULL);
+
+	if (!match_level)
+		return -1;
+
+	if (j != best_match) {
+		j = best_match;
+		pathjoin(cmpbuf, MAXPATHLEN, basis_dir[j], fname);
+		if (link_stat(cmpbuf, stp, 0) < 0)
+			return -1;
+	}
+
+	if (match_level == 3) {
+#ifdef SUPPORT_HARD_LINKS
+		if (link_dest
+#ifndef CAN_HARDLINK_SYMLINK
+		 && !S_ISLNK(file->mode)
+#endif
+#ifndef CAN_HARDLINK_SPECIAL
+		 && !IS_SPECIAL(file->mode) && !IS_DEVICE(file->mode)
+#endif
+		 && !S_ISDIR(file->mode)) {
+			if (do_link(cmpbuf, fname) < 0) {
+				rsyserr(FERROR, errno,
+					"failed to hard-link %s with %s",
+					cmpbuf, fname);
+				return j;
+			}
+			if (preserve_hard_links && IS_HLINKED(file))
+				hard_link_cluster(file, ndx, itemizing, code, -1);
+		} else
+#endif
+			match_level = 2;
+		if (itemizing && stdout_format_has_i
+		 && (verbose > 1 || stdout_format_has_i > 1)) {
+			int chg = compare_dest && type != TYPE_DIR ? 0
+			    : ITEM_LOCAL_CHANGE
+			     + (match_level == 3 ? ITEM_XNAME_FOLLOWS : 0);
+			char *lp = match_level == 3 ? "" : NULL;
+			itemize(file, ndx, 0, stp, chg + ITEM_MATCHED, 0, lp);
 		}
 		if (verbose > 1 && maybe_ATTRS_REPORT) {
-			code = daemon_log_format_has_i || dry_run
-			     ? FCLIENT : FINFO;
-			rprintf(code, "%s is uptodate\n", fname);
+			rprintf(FCLIENT, "%s%s is uptodate\n",
+				fname, type == TYPE_DIR ? "/" : "");
 		}
 		return -2;
-	} while (basis_dir[++i] != NULL);
+	}
 
-	return -1;
+	return j;
 }
 
 static int phase = 0;
@@ -770,7 +983,7 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 			   enum logcode code, int f_out)
 {
 	static int missing_below = -1, excluded_below = -1;
-	static char *parent_dirname = "";
+	static const char *parent_dirname = "";
 	static struct file_list *fuzzy_dirlist = NULL;
 	static int need_fuzzy_dirlist = 0;
 	struct file_struct *fuzzy_file = NULL;
@@ -781,7 +994,7 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 	char *fnamecmp, *partialptr, *backupptr = NULL;
 	char fnamecmpbuf[MAXPATHLEN];
 	uchar fnamecmp_type;
-	int del_opts = DEL_TERSE | (delete_mode ? DEL_FORCE_RECURSE : 0);
+	int del_opts = delete_mode || force_delete ? DEL_RECURSE : 0;
 
 	if (list_only)
 		return;
@@ -792,7 +1005,8 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 			fuzzy_dirlist = NULL;
 		}
 		if (missing_below >= 0) {
-			dry_run--;
+			if (dry_run)
+				dry_run--;
 			missing_below = -1;
 		}
 		parent_dirname = "";
@@ -822,17 +1036,22 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 		}
 	}
 
-	if (missing_below >= 0 && file->dir.depth <= missing_below) {
-		dry_run--;
-		missing_below = -1;
+	if (missing_below >= 0) {
+		if (file->dir.depth <= missing_below) {
+			if (dry_run)
+				dry_run--;
+			missing_below = -1;
+		} else if (!dry_run)
+			return;
 	}
 	if (dry_run > 1) {
 		statret = -1;
 		stat_errno = ENOENT;
 	} else {
-		char *dn = file->dirname ? file->dirname : ".";
+		const char *dn = file->dirname ? file->dirname : ".";
 		if (parent_dirname != dn && strcmp(parent_dirname, dn) != 0) {
-			if (relative_paths && !implied_dirs && stat(dn, &st) < 0
+			if (relative_paths && !implied_dirs
+			 && do_stat(dn, &st) < 0
 			 && create_directory_path(fname) < 0) {
 				rsyserr(FERROR, errno,
 					"recv_generator: mkdir %s failed",
@@ -848,7 +1067,8 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 		parent_dirname = dn;
 
 		if (need_fuzzy_dirlist && S_ISREG(file->mode)) {
-			fuzzy_dirlist = get_dirlist(dn, -1, 1);
+			strlcpy(fnamecmpbuf, dn, sizeof fnamecmpbuf);
+			fuzzy_dirlist = get_dirlist(fnamecmpbuf, -1, 1);
 			need_fuzzy_dirlist = 0;
 		}
 
@@ -881,7 +1101,7 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 		 * we need to delete it.  If it doesn't exist, then
 		 * (perhaps recursively) create it. */
 		if (statret == 0 && !S_ISDIR(st.st_mode)) {
-			if (delete_item(fname, st.st_mode, del_opts) < 0)
+			if (delete_item(fname, st.st_mode, "directory", del_opts) != 0)
 				return;
 			statret = -1;
 		}
@@ -889,42 +1109,69 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 			missing_below = file->dir.depth;
 			dry_run++;
 		}
+		real_ret = statret;
+		real_st = st;
+		if (new_root_dir) {
+			if (*fname == '.' && fname[1] == '\0')
+				statret = -1;
+			new_root_dir = 0;
+		}
+		if (statret != 0 && basis_dir[0] != NULL) {
+			int j = try_dests_non(file, fname, ndx, fnamecmpbuf, &st,
+					      itemizing, maybe_ATTRS_REPORT, code);
+			if (j == -2) {
+				itemizing = 0;
+				code = FNONE;
+			} else if (j >= 0)
+				statret = 1;
+		}
 		if (itemizing && f_out != -1) {
 			itemize(file, ndx, statret, &st,
 				statret ? ITEM_LOCAL_CHANGE : 0, 0, NULL);
 		}
-		if (statret != 0 && do_mkdir(fname,file->mode) < 0 && errno != EEXIST) {
+		if (real_ret != 0 && do_mkdir(fname,file->mode) < 0 && errno != EEXIST) {
 			if (!relative_paths || errno != ENOENT
 			    || create_directory_path(fname) < 0
 			    || (do_mkdir(fname, file->mode) < 0 && errno != EEXIST)) {
 				rsyserr(FERROR, errno,
 					"recv_generator: mkdir %s failed",
 					full_fname(fname));
+				file->flags |= FLAG_MISSING_DIR;
+				if (ndx+1 < the_file_list->count
+				 && the_file_list->files[ndx+1]->dir.depth > file->dir.depth) {
+					rprintf(FERROR,
+					    "*** Skipping everything below this failed directory ***\n");
+					missing_below = file->dir.depth;
+				}
+				return;
 			}
 		}
-		if (set_file_attrs(fname, file, statret ? NULL : &st, 0)
-		    && verbose && code && f_out != -1)
+		if (set_file_attrs(fname, file, real_ret ? NULL : &real_st, 0)
+		    && verbose && code != FNONE && f_out != -1)
 			rprintf(code, "%s/\n", fname);
+		if (real_ret != 0 && one_file_system)
+			real_st.st_dev = filesystem_dev;
 		if (delete_during && f_out != -1 && !phase && dry_run < 2
-		    && (file->flags & FLAG_DEL_HERE))
-			delete_in_dir(the_file_list, fname, file, &st);
+		    && (file->flags & FLAG_XFER_DIR))
+			delete_in_dir(the_file_list, fname, file, &real_st);
 		return;
 	}
 
-	if (preserve_hard_links && file->link_u.links
+	if (preserve_hard_links && IS_HLINKED(file)
 	    && hard_link_check(file, ndx, fname, statret, &st,
 			       itemizing, code, HL_CHECK_MASTER))
 		return;
 
 	if (preserve_links && S_ISLNK(file->mode)) {
 #ifdef SUPPORT_LINKS
-		if (safe_symlinks && unsafe_symlink(file->u.link, fname)) {
+		const char *sl = F_SYMLINK(file);
+		if (safe_symlinks && unsafe_symlink(sl, fname)) {
 			if (verbose) {
 				if (the_file_list->count == 1)
 					fname = f_name(file, NULL);
 				rprintf(FINFO,
 					"ignoring unsafe symlink %s -> \"%s\"\n",
-					full_fname(fname), file->u.link);
+					full_fname(fname), sl);
 			}
 			return;
 		}
@@ -932,67 +1179,62 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 			char lnk[MAXPATHLEN];
 			int len;
 
-			if (!S_ISDIR(st.st_mode)
-			    && (len = readlink(fname, lnk, MAXPATHLEN-1)) > 0) {
-				lnk[len] = 0;
-				/* A link already pointing to the
-				 * right place -- no further action
-				 * required. */
-				if (strcmp(lnk, file->u.link) == 0) {
-					if (itemizing) {
-						itemize(file, ndx, 0, &st, 0,
-							0, NULL);
-					}
-					set_file_attrs(fname, file, &st,
-						       maybe_ATTRS_REPORT);
-					if (preserve_hard_links
-					    && file->link_u.links) {
-						hard_link_cluster(file, ndx,
-								  itemizing,
-								  code);
-					}
-					return;
-				}
+			if (!S_ISLNK(st.st_mode))
+				statret = -1;
+			else if ((len = readlink(fname, lnk, MAXPATHLEN-1)) > 0
+			      && strncmp(lnk, sl, len) == 0 && sl[len] == '\0') {
+				/* The link is pointing to the right place. */
+				if (itemizing)
+					itemize(file, ndx, 0, &st, 0, 0, NULL);
+				set_file_attrs(fname, file, &st, maybe_ATTRS_REPORT);
+				if (preserve_hard_links && IS_HLINKED(file))
+					hard_link_cluster(file, ndx, itemizing, code, -1);
+				if (remove_source_files == 1)
+					goto return_with_success;
+				return;
 			}
 			/* Not the right symlink (or not a symlink), so
 			 * delete it. */
-			if (delete_item(fname, st.st_mode, del_opts) < 0)
+			if (delete_item(fname, st.st_mode, "symlink", del_opts) != 0)
 				return;
-			if (!S_ISLNK(st.st_mode))
-				statret = -1;
-		} else if (basis_dir[0] != NULL && can_link_symlinks) {
-			if (try_dests_non(file, fname, ndx, itemizing,
-					  &can_link_symlinks,
-					  maybe_ATTRS_REPORT, code) == -2) {
+		} else if (basis_dir[0] != NULL) {
+			int j = try_dests_non(file, fname, ndx, fnamecmpbuf, &st,
+					      itemizing, maybe_ATTRS_REPORT, code);
+			if (j == -2) {
+#ifndef CAN_HARDLINK_SYMLINK
+				if (link_dest) {
+					/* Resort to --copy-dest behavior. */
+				} else
+#endif
 				if (!copy_dest)
 					return;
-				itemizing = code = 0;
-			}
+				itemizing = 0;
+				code = FNONE;
+			} else if (j >= 0)
+				statret = 1;
 		}
-		if (preserve_hard_links && file->link_u.links
+		if (preserve_hard_links && IS_HLINKED(file)
 		    && hard_link_check(file, ndx, fname, -1, &st,
 				       itemizing, code, HL_SKIP))
 			return;
-		if (do_symlink(file->u.link,fname) != 0) {
+		if (do_symlink(sl, fname) != 0) {
 			rsyserr(FERROR, errno, "symlink %s -> \"%s\" failed",
-				full_fname(fname), file->u.link);
+				full_fname(fname), sl);
 		} else {
 			set_file_attrs(fname, file, NULL, 0);
 			if (itemizing) {
 				itemize(file, ndx, statret, &st,
 					ITEM_LOCAL_CHANGE, 0, NULL);
 			}
-			if (code && verbose) {
-				rprintf(code, "%s -> %s\n", fname,
-					file->u.link);
-			}
-			if (remove_sent_files && !dry_run) {
-				char numbuf[4];
-				SIVAL(numbuf, 0, ndx);
-				send_msg(MSG_SUCCESS, numbuf, 4);
-			}
-			if (preserve_hard_links && file->link_u.links)
-				hard_link_cluster(file, ndx, itemizing, code);
+			if (code != FNONE && verbose)
+				rprintf(code, "%s -> %s\n", fname, sl);
+			if (preserve_hard_links && IS_HLINKED(file))
+				hard_link_cluster(file, ndx, itemizing, code, -1);
+			/* This does not check remove_source_files == 1
+			 * because this is one of the items that the old
+			 * --remove-sent-files option would remove. */
+			if (remove_source_files)
+				goto return_with_success;
 		}
 #endif
 		return;
@@ -1000,56 +1242,72 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 
 	if ((am_root && preserve_devices && IS_DEVICE(file->mode))
 	 || (preserve_specials && IS_SPECIAL(file->mode))) {
-		if (statret != 0
-		 && (basis_dir[0] != NULL && can_link_devices)) {
-			if (try_dests_non(file, fname, ndx, itemizing,
-					  &can_link_devices,
-					  maybe_ATTRS_REPORT, code) == -2) {
-				if (!copy_dest)
-					return;
-				itemizing = code = 0;
+		dev_t rdev = MAKEDEV(F_DMAJOR(file), F_DMINOR(file));
+		if (statret == 0) {
+			char *t;
+			if (IS_DEVICE(file->mode)) {
+				if (!IS_DEVICE(st.st_mode))
+					statret = -1;
+				t = "device file";
+			} else {
+				if (!IS_SPECIAL(st.st_mode))
+					statret = -1;
+				t = "special file";
 			}
-		}
-		if (statret != 0
-		 || (st.st_mode & ~CHMOD_BITS) != (file->mode & ~CHMOD_BITS)
-		 || st.st_rdev != file->u.rdev) {
 			if (statret == 0
-			 && delete_item(fname, st.st_mode, del_opts) < 0)
-				return;
-			if (preserve_hard_links && file->link_u.links
-			    && hard_link_check(file, ndx, fname, -1, &st,
-					       itemizing, code, HL_SKIP))
+			 && (st.st_mode & ~CHMOD_BITS) == (file->mode & ~CHMOD_BITS)
+			 && st.st_rdev == rdev) {
+				/* The device or special file is identical. */
+				if (itemizing)
+					itemize(file, ndx, 0, &st, 0, 0, NULL);
+				set_file_attrs(fname, file, &st, maybe_ATTRS_REPORT);
+				if (preserve_hard_links && IS_HLINKED(file))
+					hard_link_cluster(file, ndx, itemizing, code, -1);
+				if (remove_source_files == 1)
+					goto return_with_success;
 				return;
-			if ((IS_DEVICE(file->mode) && !IS_DEVICE(st.st_mode))
-			 || (IS_SPECIAL(file->mode) && !IS_SPECIAL(st.st_mode)))
-				statret = -1;
-			if (verbose > 2) {
-				rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
-					fname,
-					(int)file->mode, (int)file->u.rdev);
-			}
-			if (do_mknod(fname,file->mode,file->u.rdev) < 0) {
-				rsyserr(FERROR, errno, "mknod %s failed",
-					full_fname(fname));
-			} else {
-				set_file_attrs(fname, file, NULL, 0);
-				if (itemizing) {
-					itemize(file, ndx, statret, &st,
-						ITEM_LOCAL_CHANGE, 0, NULL);
-				}
-				if (code && verbose)
-					rprintf(code, "%s\n", fname);
-				if (preserve_hard_links && file->link_u.links) {
-					hard_link_cluster(file, ndx,
-							  itemizing, code);
-				}
 			}
+			if (delete_item(fname, st.st_mode, t, del_opts) != 0)
+				return;
+		} else if (basis_dir[0] != NULL) {
+			int j = try_dests_non(file, fname, ndx, fnamecmpbuf, &st,
+					      itemizing, maybe_ATTRS_REPORT, code);
+			if (j == -2) {
+#ifndef CAN_HARDLINK_SPECIAL
+				if (link_dest) {
+					/* Resort to --copy-dest behavior. */
+				} else
+#endif
+				if (!copy_dest)
+					return;
+				itemizing = 0;
+				code = FNONE;
+			} else if (j >= 0)
+				statret = 1;
+		}
+		if (preserve_hard_links && IS_HLINKED(file)
+		    && hard_link_check(file, ndx, fname, -1, &st,
+				       itemizing, code, HL_SKIP))
+			return;
+		if (verbose > 2) {
+			rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
+				fname, (int)file->mode, (int)rdev);
+		}
+		if (do_mknod(fname, file->mode, rdev) < 0) {
+			rsyserr(FERROR, errno, "mknod %s failed",
+				full_fname(fname));
 		} else {
-			if (itemizing)
-				itemize(file, ndx, statret, &st, 0, 0, NULL);
-			set_file_attrs(fname, file, &st, maybe_ATTRS_REPORT);
-			if (preserve_hard_links && file->link_u.links)
-				hard_link_cluster(file, ndx, itemizing, code);
+			set_file_attrs(fname, file, NULL, 0);
+			if (itemizing) {
+				itemize(file, ndx, statret, &st,
+					ITEM_LOCAL_CHANGE, 0, NULL);
+			}
+			if (code != FNONE && verbose)
+				rprintf(code, "%s\n", fname);
+			if (preserve_hard_links && IS_HLINKED(file))
+				hard_link_cluster(file, ndx, itemizing, code, -1);
+			if (remove_source_files == 1)
+				goto return_with_success;
 		}
 		return;
 	}
@@ -1095,7 +1353,7 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 	fnamecmp_type = FNAMECMP_FNAME;
 
 	if (statret == 0 && !S_ISREG(st.st_mode)) {
-		if (delete_item(fname, st.st_mode, del_opts) != 0)
+		if (delete_item(fname, st.st_mode, "regular file", del_opts) != 0)
 			return;
 		statret = -1;
 		stat_errno = ENOENT;
@@ -1104,9 +1362,12 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 	if (statret != 0 && basis_dir[0] != NULL) {
 		int j = try_dests_reg(file, fname, ndx, fnamecmpbuf, &st,
 				      itemizing, maybe_ATTRS_REPORT, code);
-		if (j == -2)
+		if (j == -2) {
+			if (remove_source_files == 1)
+				goto return_with_success;
 			return;
-		if (j != -1) {
+		}
+		if (j >= 0) {
 			fnamecmp = fnamecmpbuf;
 			fnamecmp_type = j;
 			statret = 0;
@@ -1141,7 +1402,7 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 	}
 
 	if (statret != 0) {
-		if (preserve_hard_links && file->link_u.links
+		if (preserve_hard_links && IS_HLINKED(file)
 		    && hard_link_check(file, ndx, fname, statret, &st,
 				       itemizing, code, HL_SKIP))
 			return;
@@ -1169,8 +1430,16 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 				0, 0, NULL);
 		}
 		set_file_attrs(fname, file, &st, maybe_ATTRS_REPORT);
-		if (preserve_hard_links && file->link_u.links)
-			hard_link_cluster(file, ndx, itemizing, code);
+		if (preserve_hard_links && IS_HLINKED(file))
+			hard_link_cluster(file, ndx, itemizing, code, -1);
+		if (remove_source_files != 1)
+			return;
+	  return_with_success:
+		if (!dry_run) {
+			char numbuf[4];
+			SIVAL(numbuf, 0, ndx);
+			send_msg(MSG_SUCCESS, numbuf, 4);
+		}
 		return;
 	}
 
@@ -1188,7 +1457,7 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 	if (fuzzy_dirlist) {
 		int j = flist_find(fuzzy_dirlist, file);
 		if (j >= 0) /* don't use changing file as future fuzzy basis */
-			fuzzy_dirlist->files[j]->flags |= FLAG_NO_FUZZY;
+			fuzzy_dirlist->files[j]->flags |= FLAG_SENT;
 	}
 
 	/* open the file */
@@ -1199,7 +1468,7 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 			full_fname(fnamecmp));
 	  pretend_missing:
 		/* pretend the file didn't exist */
-		if (preserve_hard_links && file->link_u.links
+		if (preserve_hard_links && IS_HLINKED(file)
 		    && hard_link_check(file, ndx, fname, statret, &st,
 				       itemizing, code, HL_SKIP))
 			return;
@@ -1219,7 +1488,7 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 		if (robust_unlink(backupptr) && errno != ENOENT) {
 			rsyserr(FERROR, errno, "unlink %s",
 				full_fname(backupptr));
-			free(back_file);
+			unmake_file(back_file);
 			close(fd);
 			return;
 		}
@@ -1227,7 +1496,7 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 		    O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, 0600)) < 0) {
 			rsyserr(FERROR, errno, "open %s",
 				full_fname(backupptr));
-			free(back_file);
+			unmake_file(back_file);
 			close(fd);
 			return;
 		}
@@ -1243,8 +1512,8 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 		rprintf(FINFO, "generating and sending sums for %d\n", ndx);
 
   notify_others:
-	if (remove_sent_files && !delay_updates && !phase)
-	    increment_active_files(ndx, itemizing, code);
+	if (remove_source_files && !delay_updates && !phase)
+		increment_active_files(ndx, itemizing, code);
 	write_int(f_out, ndx);
 	if (itemizing) {
 		int iflags = ITEM_TRANSFER;
@@ -1259,8 +1528,8 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 	}
 
 	if (!do_xfers) {
-		if (preserve_hard_links && file->link_u.links)
-			hard_link_cluster(file, ndx, itemizing, code);
+		if (preserve_hard_links && IS_HLINKED(file))
+			hard_link_cluster(file, ndx, itemizing, code, -1);
 		return;
 	}
 	if (read_batch)
@@ -1280,7 +1549,7 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 			rprintf(FINFO, "backed up %s to %s\n",
 				fname, backupptr);
 		}
-		free(back_file);
+		unmake_file(back_file);
 	}
 
 	close(fd);
@@ -1299,19 +1568,20 @@ void generate_files(int f_out, struct file_list *flist, char *local_name)
 	int save_ignore_non_existing = ignore_non_existing;
 	int save_do_progress = do_progress;
 	int save_make_backups = make_backups;
+	int dir_tweaking = !(list_only || local_name || dry_run);
 
 	if (protocol_version >= 29) {
 		itemizing = 1;
-		maybe_ATTRS_REPORT = log_format_has_i ? 0 : ATTRS_REPORT;
-		code = daemon_log_format_has_i ? 0 : FLOG;
+		maybe_ATTRS_REPORT = stdout_format_has_i ? 0 : ATTRS_REPORT;
+		code = logfile_format_has_i ? FNONE : FLOG;
 	} else if (am_daemon) {
-		itemizing = daemon_log_format_has_i && do_xfers;
+		itemizing = logfile_format_has_i && do_xfers;
 		maybe_ATTRS_REPORT = ATTRS_REPORT;
 		code = itemizing || !do_xfers ? FCLIENT : FINFO;
 	} else if (!am_server) {
-		itemizing = log_format_has_i;
-		maybe_ATTRS_REPORT = log_format_has_i ? 0 : ATTRS_REPORT;
-		code = itemizing ? 0 : FINFO;
+		itemizing = stdout_format_has_i;
+		maybe_ATTRS_REPORT = stdout_format_has_i ? 0 : ATTRS_REPORT;
+		code = itemizing ? FNONE : FINFO;
 	} else {
 		itemizing = 0;
 		maybe_ATTRS_REPORT = ATTRS_REPORT;
@@ -1325,6 +1595,8 @@ void generate_files(int f_out, struct file_list *flist, char *local_name)
 
 	if (delete_before && !local_name && flist->count > 0)
 		do_delete_pass(flist);
+	if (delete_during == 2)
+		start_delete_temp();
 	do_progress = 0;
 
 	if (append_mode || whole_file < 0)
@@ -1360,7 +1632,7 @@ void generate_files(int f_out, struct file_list *flist, char *local_name)
 		 * them.  This is then fixed after the transfer is done. */
 #ifdef HAVE_CHMOD
 		if (!am_root && S_ISDIR(file->mode) && !(file->mode & S_IWUSR)
-		    && !list_only) {
+		 && dir_tweaking) {
 			mode_t mode = file->mode | S_IWUSR; /* user write */
 			char *fname = local_name ? local_name : fbuf;
 			if (do_chmod(fname, mode) < 0) {
@@ -1396,7 +1668,7 @@ void generate_files(int f_out, struct file_list *flist, char *local_name)
 	if (verbose > 2)
 		rprintf(FINFO,"generate_files phase=%d\n",phase);
 
-	write_int(f_out, -1);
+	write_int(f_out, NDX_DONE);
 
 	/* files can cycle through the system more than once
 	 * to catch initial checksum errors */
@@ -1418,10 +1690,10 @@ void generate_files(int f_out, struct file_list *flist, char *local_name)
 	if (verbose > 2)
 		rprintf(FINFO,"generate_files phase=%d\n",phase);
 
-	write_int(f_out, -1);
+	write_int(f_out, NDX_DONE);
 	/* Reduce round-trip lag-time for a useless delay-updates phase. */
 	if (protocol_version >= 29 && !delay_updates)
-		write_int(f_out, -1);
+		write_int(f_out, NDX_DONE);
 
 	/* Read MSG_DONE for the redo phase (and any prior messages). */
 	get_redo_num(itemizing, code);
@@ -1431,17 +1703,18 @@ void generate_files(int f_out, struct file_list *flist, char *local_name)
 		if (verbose > 2)
 			rprintf(FINFO, "generate_files phase=%d\n", phase);
 		if (delay_updates)
-			write_int(f_out, -1);
+			write_int(f_out, NDX_DONE);
 		/* Read MSG_DONE for delay-updates phase & prior messages. */
 		get_redo_num(itemizing, code);
 	}
 
 	do_progress = save_do_progress;
+	if (delete_delay_fp)
+		delayed_deletions(fbuf);
 	if (delete_after && !local_name && flist->count > 0)
 		do_delete_pass(flist);
 
-	if ((need_retouch_dir_perms || need_retouch_dir_times)
-	    && !list_only && !local_name && !dry_run) {
+	if ((need_retouch_dir_perms || need_retouch_dir_times) && dir_tweaking) {
 		int j = 0;
 		/* Now we need to fix any directory permissions that were
 		 * modified during the transfer and/or re-set any tweaked
@@ -1453,6 +1726,16 @@ void generate_files(int f_out, struct file_list *flist, char *local_name)
 				continue;
 			if (!need_retouch_dir_times && file->mode & S_IWUSR)
 				continue;
+			if (file->flags & FLAG_MISSING_DIR) {
+				int missing = file->dir.depth;
+				while (++i < flist->count) {
+					file = flist->files[i];
+					if (file->dir.depth <= missing)
+						break;
+				}
+				i--;
+				continue;
+			}
 			recv_generator(f_name(file, NULL), file, i, itemizing,
 				       maybe_ATTRS_REPORT, code, -1);
 			if (allowed_lull && !(++j % lull_mod))
@@ -1463,7 +1746,7 @@ void generate_files(int f_out, struct file_list *flist, char *local_name)
 	}
 	recv_generator(NULL, NULL, 0, 0, 0, code, -1);
 
-	if (max_delete > 0 && deletion_count > max_delete) {
+	if (max_delete >= 0 && deletion_count > max_delete) {
 		rprintf(FINFO,
 			"Deletions stopped due to --max-delete limit (%d skipped)\n",
 			deletion_count - max_delete);