X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/b2e4811db2cf4434b829f855fcf3c576228e5704..b0cacef14b62dae31f044a0b580ee35b0a2bfbe3:/generator.c

diff --git a/generator.c b/generator.c
index 582ab797..ffd8ab71 100644
--- a/generator.c
+++ b/generator.c
@@ -93,123 +93,176 @@ 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 */
 
-/* For calling delete_file() */
-#define DEL_FORCE_RECURSE	(1<<1) /* recurse even w/o --force */
-#define DEL_TERSE		(1<<3)
+/* 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 */
 
 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)
 {
 	int k = strlen(fn) - backup_suffix_len;
 	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
  * 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 *fname, 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",
+			fname, mode, flags);
 	}
 
-	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
+	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(fname, 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(fname) == 0;
+	} else if (make_backups && (backup_dir || !is_backup_file(fname))) {
+		what = "make_backup";
+		ok = make_backup(fname);
+	} else {
+		what = "unlink";
+		ok = robust_unlink(fname) == 0;
+	}
+
 	if (ok) {
-		if (!(flags & DEL_TERSE))
+		if (!replace)
 			log_delete(fname, mode);
-		return 0;
+		ret = DR_SUCCESS;
+	} else {
+		if (S_ISDIR(mode) && errno == ENOTEMPTY) {
+			rprintf(FINFO, "cannot delete non-empty directory: %s\n",
+				fname);
+			ret = DR_NOT_EMPTY;
+		} else if (errno != ENOENT) {
+			rsyserr(FERROR, errno, "delete_file: %s(%s) failed",
+				what, full_fname(fname));
+			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, fname);
 	}
-	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_POINT) {
+			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 (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));
-		return -1;
+	if (ret == DR_NOT_EMPTY) {
+		rprintf(FINFO, "cannot delete non-empty directory: %s\n",
+			fname);
 	}
-
-	return 0;
+	return ret;
 }
 
 
@@ -275,11 +328,17 @@ 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_POINT) {
+			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);
+			delete_item(delbuf, fp->mode, NULL, DEL_RECURSE);
 		}
 	}
 
@@ -336,7 +395,7 @@ int unchanged_attrs(struct file_struct *file, STRUCT_STAT *st)
 }
 
 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
@@ -467,8 +526,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,
@@ -860,7 +919,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;
@@ -871,7 +930,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;
@@ -925,7 +984,7 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 		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
 			 && do_stat(dn, &st) < 0
@@ -944,7 +1003,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;
 		}
 
@@ -977,7 +1037,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;
 		}
@@ -1071,7 +1131,7 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 			}
 			/* 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;
 		} else if (basis_dir[0] != NULL) {
 			int j = try_dests_non(file, fname, ndx, fnamecmpbuf, &st,
@@ -1119,11 +1179,19 @@ 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) {
-			if ((IS_DEVICE(file->mode) && !IS_DEVICE(st.st_mode))
-			 || (IS_SPECIAL(file->mode) && !IS_SPECIAL(st.st_mode)))
-				statret = -1;
-			else if ((st.st_mode & ~CHMOD_BITS) == (file->mode & ~CHMOD_BITS)
-			      && st.st_rdev == file->u.rdev) {
+			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) {
 				/* The device or special file is identical. */
 				if (itemizing)
 					itemize(file, ndx, 0, &st, 0, 0, NULL);
@@ -1134,7 +1202,7 @@ static void recv_generator(char *fname, struct file_struct *file, int ndx,
 					goto return_with_success;
 				return;
 			}
-			if (delete_item(fname, st.st_mode, del_opts) < 0)
+			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,
@@ -1220,7 +1288,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;
@@ -1609,7 +1677,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);