X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/4f5b0756df0dfc925b9576db47ecce949c378e18..7f2a1f651e6db7483bcb3d2678dcb60cc4e54582:/flist.c

diff --git a/flist.c b/flist.c
index 731ffee9..05b53f6e 100644
--- a/flist.c
+++ b/flist.c
@@ -30,24 +30,20 @@
 extern struct stats stats;
 
 extern int verbose;
-extern int do_progress;
+extern int dry_run;
+extern int list_only;
 extern int am_root;
 extern int am_server;
 extern int am_daemon;
 extern int am_sender;
+extern int do_progress;
 extern int always_checksum;
 extern int module_id;
 extern int ignore_errors;
 extern int numeric_ids;
-
 extern int recurse;
 extern int xfer_dirs;
-extern char curr_dir[MAXPATHLEN];
-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 keep_dirlinks;
 extern int preserve_links;
@@ -58,15 +54,21 @@ extern int preserve_uid;
 extern int preserve_gid;
 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 max_delete;
+extern int force_delete;
 extern int orig_umask;
-extern int list_only;
+extern int make_backups;
+extern unsigned int curr_dir_len;
+extern char *log_format;
+extern char *backup_dir;
+extern char *backup_suffix;
+extern int backup_suffix_len;
+
+extern char curr_dir[MAXPATHLEN];
 
 extern struct filter_list_struct filter_list;
 extern struct filter_list_struct server_filter_list;
@@ -75,9 +77,8 @@ int io_error;
 
 static char empty_sum[MD4_SUM_LENGTH];
 static unsigned int file_struct_len;
-static struct file_list *received_flist;
+static struct file_list *received_flist, *sorting_flist;
 static dev_t filesystem_dev; /* used to implement -x */
-static int deletion_count = 0; /* used to implement --max-delete */
 
 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);
@@ -330,7 +331,7 @@ void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
 	char fname[MAXPATHLEN];
 	int l1, l2;
 
-	if (f == -1)
+	if (f < 0)
 		return;
 
 	if (!file) {
@@ -975,7 +976,8 @@ void send_file_name(int f, struct file_list *flist, char *fname,
 	struct file_struct *file;
 	char fbuf[MAXPATHLEN];
 
-	if (!(file = make_file(fname, flist, ALL_FILTERS)))
+	file = make_file(fname, flist, f == -2 ? SERVER_FILTERS : ALL_FILTERS);
+	if (!file)
 		return;
 
 	maybe_emit_filelist_progress(flist);
@@ -1010,7 +1012,9 @@ void send_file_name(int f, struct file_list *flist, char *fname,
  * or a number >= 0 indicating how many levels of recursion we will allow.
  * This function is normally called by the sender, but the receiving side
  * also calls it from delete_in_dir() with f set to -1 so that we just
- * construct the file list in memory without sending it over the wire. */
+ * construct the file list in memory without sending it over the wire.  Also,
+ * get_dirlist() calls this with f set to -2, which indicates that local
+ * filter rules should be ignored. */
 static void send_directory(int f, struct file_list *flist,
 			   char *fbuf, unsigned int len)
 {
@@ -1315,7 +1319,7 @@ struct file_list *recv_file_list(int f)
 
 	clean_flist(flist, relative_paths, 1);
 
-	if (f != -1) {
+	if (f >= 0) {
 		/* Now send the uid/gid list. This was introduced in
 		 * protocol version 15 */
 		recv_uid_list(f, flist);
@@ -1449,8 +1453,10 @@ static void clean_flist(struct file_list *flist, int strip_root, int no_dups)
 	if (!flist || flist->count == 0)
 		return;
 
+	sorting_flist = flist;
 	qsort(flist->files, flist->count,
 	    sizeof flist->files[0], (int (*)())file_compare);
+	sorting_flist = NULL;
 
 	for (i = no_dups? 0 : flist->count; i < flist->count; i++) {
 		if (flist->files[i]->basename) {
@@ -1671,6 +1677,18 @@ int f_name_cmp(struct file_struct *f1, struct file_struct *f2)
 		if (!*c2) {
 			switch (state2) {
 			case s_DIR:
+				if (state1 == s_SLASH && sorting_flist) {
+					int j;
+					/* Optimize for future comparisons. */
+					for (j = 0;
+					     j < sorting_flist->count;
+					     j++) {
+						struct file_struct *fp
+						    = sorting_flist->files[j];
+						if (fp->dirname == f2->dirname)
+							fp->dirname = f1->dirname;
+					}
+				}
 				state2 = s_SLASH;
 				c2 = (uchar*)"/";
 				break;
@@ -1733,6 +1751,30 @@ char *f_name(struct file_struct *f)
 }
 
 
+struct file_list *get_dirlist(const char *dirname, int ignore_filter_rules)
+{
+	struct file_list *dirlist;
+	char dirbuf[MAXPATHLEN];
+	int dlen;
+	int save_recurse = recurse;
+
+	dlen = strlcpy(dirbuf, dirname, MAXPATHLEN);
+	if (dlen >= MAXPATHLEN)
+		return NULL;
+
+	dirlist = flist_new(WITHOUT_HLINK, "get_dirlist");
+	recurse = 0;
+	send_directory(ignore_filter_rules ? -2 : -1, dirlist, dirbuf, dlen);
+	recurse = save_recurse;
+
+	clean_flist(dirlist, 0, 0);
+
+	return dirlist;
+}
+
+
+static int deletion_count = 0; /* used to implement --max-delete */
+
 static int is_backup_file(char *fn)
 {
 	int k = strlen(fn) - backup_suffix_len;
@@ -1740,6 +1782,121 @@ static int is_backup_file(char *fn)
 }
 
 
+/* Delete a file or directory.  If DEL_FORCE_RECURSE is set in the flags, or if
+ * force_delete is set, this will delete recursively as long as DEL_NO_RECURSE
+ * is not set in the flags. */
+int delete_file(char *fname, int mode, int flags)
+{
+	struct file_list *dirlist;
+	char buf[MAXPATHLEN];
+	int j, zap_dir, ok;
+	void *save_filters;
+
+	if (max_delete && deletion_count >= max_delete)
+		return -1;
+
+	if (!S_ISDIR(mode)) {
+		if (make_backups && (backup_dir || !is_backup_file(fname)))
+			ok = make_backup(fname);
+		else
+			ok = robust_unlink(fname) == 0;
+		if (ok) {
+			if ((verbose || log_format) && !(flags & DEL_TERSE))
+				log_delete(fname, mode);
+			deletion_count++;
+			return 0;
+		}
+		if (errno == ENOENT)
+			return 0;
+		rsyserr(FERROR, errno, "delete_file: unlink %s failed",
+			full_fname(fname));
+		return -1;
+	}
+
+	zap_dir = (flags & DEL_FORCE_RECURSE || (force_delete && recurse))
+		&& !(flags & DEL_NO_RECURSE);
+	if (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 ((verbose || log_format) && !(flags & DEL_TERSE))
+			log_delete(fname, mode);
+		deletion_count++;
+		return 0;
+	}
+	if (errno == ENOENT)
+		return 0;
+	if (!zap_dir || (errno != ENOTEMPTY && errno != EEXIST)) {
+		rsyserr(FERROR, errno, "delete_file: rmdir %s failed",
+			full_fname(fname));
+		return -1;
+	}
+	flags |= DEL_FORCE_RECURSE;
+
+	save_filters = push_local_filters(fname, strlen(fname));
+
+	dirlist = get_dirlist(fname, 0);
+	for (j = dirlist->count; j--; ) {
+		struct file_struct *fp = dirlist->files[j];
+		f_name_to(fp, buf);
+		if (delete_file(buf, fp->mode, flags & ~DEL_TERSE) != 0) {
+			flist_free(dirlist);
+			return -1;
+		}
+	}
+	flist_free(dirlist);
+
+	pop_local_filters(save_filters);
+
+	if (max_delete && deletion_count >= max_delete)
+		return -1;
+
+	if (do_rmdir(fname) == 0) {
+		if ((verbose || log_format) && !(flags & DEL_TERSE))
+			log_delete(fname, mode);
+		deletion_count++;
+	} else if (errno != ENOTEMPTY && errno != ENOENT) {
+		rsyserr(FERROR, errno, "delete_file: rmdir %s failed",
+			full_fname(fname));
+		return -1;
+	}
+
+	return 0;
+}
+
+
+/* If an item in dir_list is not found in full_list, delete it from the
+ * filesystem. */
+static void delete_missing(struct file_list *full_list,
+			   struct file_list *dir_list, const char *dirname)
+{
+	char fbuf[MAXPATHLEN];
+	int i;
+
+	if (max_delete && deletion_count >= max_delete)
+		return;
+
+	if (verbose > 2)
+		rprintf(FINFO, "delete_missing(%s)\n", safe_fname(dirname));
+
+	for (i = dir_list->count; i--; ) {
+		if (!dir_list->files[i]->basename)
+			continue;
+		if (flist_find(full_list, dir_list->files[i]) < 0) {
+			char *fn = f_name_to(dir_list->files[i], fbuf);
+			int mode = dir_list->files[i]->mode;
+			if (delete_file(fn, mode, DEL_FORCE_RECURSE) < 0)
+				break;
+		}
+	}
+}
+
+
 /* 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 MAXPATHLEN buffer with the name of the
@@ -1795,6 +1952,8 @@ void delete_in_dir(struct file_list *flist, char *fbuf,
 	recurse = -1;
 	fbuf[dlen] = '\0';
 
+	clean_flist(dir_list, 0, 0);
+
 	if (verbose > 3)
 		output_flist(dir_list, "delete");
 
@@ -1802,41 +1961,3 @@ void delete_in_dir(struct file_list *flist, char *fbuf,
 
 	flist_free(dir_list);
 }
-
-
-/* If an item in dir_list is not found in full_list, delete it from the
- * filesystem. */
-void delete_missing(struct file_list *full_list, struct file_list *dir_list,
-		    const char *dirname)
-{
-	int i, mode;
-
-	if (max_delete && deletion_count >= max_delete)
-		return;
-
-	if (verbose > 2)
-		rprintf(FINFO, "delete_missing(%s)\n", safe_fname(dirname));
-
-	for (i = dir_list->count; i--; ) {
-		if (!dir_list->files[i]->basename)
-			continue;
-		mode = dir_list->files[i]->mode;
-		if (flist_find(full_list, dir_list->files[i]) < 0) {
-			char *f = f_name(dir_list->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 if (S_ISDIR(mode))
-				delete_file(f, DEL_DIR | DEL_FORCE_RECURSE);
-			else
-				delete_file(f, 0);
-			deletion_count++;
-			if (max_delete && deletion_count >= max_delete)
-				break;
-		}
-	}
-}