X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/c0b134a445a12a98c70313ce18b94858ef9a4b77..0679ac4ca9d8fda7fc27dd0d44de48957c0ff88d:/flist.c

diff --git a/flist.c b/flist.c
index dc283a1f..5babe91c 100644
--- a/flist.c
+++ b/flist.c
@@ -53,12 +53,12 @@ extern int preserve_uid;
 extern int preserve_gid;
 extern int relative_paths;
 extern int implied_dirs;
-extern int skip_empty_dirs;
+extern int prune_empty_dirs;
 extern int copy_links;
 extern int copy_unsafe_links;
 extern int protocol_version;
 extern int sanitize_paths;
-extern int orig_umask;
+extern const char *io_write_phase;
 extern struct stats stats;
 extern struct file_list *the_file_list;
 
@@ -76,7 +76,6 @@ unsigned int file_struct_len;
 
 static char empty_sum[MD4_SUM_LENGTH];
 static int flist_count_offset;
-static int max_dir_depth = 0;
 
 static void clean_flist(struct file_list *flist, int strip_root, int no_dups);
 static void output_flist(struct file_list *flist);
@@ -131,26 +130,26 @@ void show_flist_stats(void)
 
 static void list_file_entry(struct file_struct *f)
 {
-	char perms[11];
+	char permbuf[PERMSTRING_SIZE];
 
 	if (!f->basename) {
 		/* this can happen if duplicate names were removed */
 		return;
 	}
 
-	permstring(perms, f->mode);
+	permstring(permbuf, f->mode);
 
 #ifdef SUPPORT_LINKS
 	if (preserve_links && S_ISLNK(f->mode)) {
 		rprintf(FINFO, "%s %11.0f %s %s -> %s\n",
-			perms,
+			permbuf,
 			(double)f->length, timestring(f->modtime),
 			f_name(f, NULL), f->u.link);
 	} else
 #endif
 	{
 		rprintf(FINFO, "%s %11.0f %s %s\n",
-			perms,
+			permbuf,
 			(double)f->length, timestring(f->modtime),
 			f_name(f, NULL));
 	}
@@ -635,8 +634,6 @@ static struct file_struct *receive_file_entry(struct file_list *flist,
 		bp[-1] = '\0';
 		lastdir_depth = count_dir_elements(lastdir);
 		file->dir.depth = lastdir_depth + 1;
-		if (lastdir_depth >= max_dir_depth)
-			max_dir_depth = lastdir_depth + 1;
 	} else if (dirname) {
 		file->dirname = dirname; /* we're reusing lastname */
 		file->dir.depth = lastdir_depth + 1;
@@ -716,12 +713,6 @@ static struct file_struct *receive_file_entry(struct file_list *flist,
 		read_buf(f, sum, checksum_len);
 	}
 
-	if (!preserve_perms) {
-		/* set an appropriate set of permissions based on original
-		 * permissions and umask. This emulates what GNU cp does */
-		file->mode &= ~orig_umask;
-	}
-
 	return file;
 }
 
@@ -1439,45 +1430,48 @@ static int file_compare(struct file_struct **file1, struct file_struct **file2)
 int flist_find(struct file_list *flist, struct file_struct *f)
 {
 	int low = flist->low, high = flist->high;
-	int ret, mid, mid_up;
+	int diff, mid, mid_up;
 
 	while (low <= high) {
 		mid = (low + high) / 2;
 		if (flist->files[mid]->basename)
 			mid_up = mid;
-		else if (flist->files[mid]->dir.depth) {
+		else {
+			/* Scan for the next non-empty entry using the cached
+			 * distance values.  If the value isn't fully up-to-
+			 * date, update it. */
 			mid_up = mid + flist->files[mid]->dir.depth;
-			if (mid_up < mid) {
-				high = mid_up;
-				continue;
+			if (!flist->files[mid_up]->basename) {
+				do {
+				    mid_up += flist->files[mid_up]->dir.depth;
+				} while (!flist->files[mid_up]->basename);
+				flist->files[mid]->dir.depth = mid_up - mid;
 			}
-		} else {
-			/* Scan for the next non-empty entry and cache
-			 * the distance so we never do this again. */
-			mid_up = mid;
-			while (++mid_up <= high
-			    && !flist->files[mid_up]->basename) {}
 			if (mid_up > high) {
-				high = mid;
-				while (--high >= low
-				    && !flist->files[high]->basename) {}
-				flist->files[mid]->dir.depth = high - mid;
+				/* If there's nothing left above us, set high to
+				 * a non-empty entry below us and continue. */
+				high = mid - flist->files[mid]->length;
+				if (!flist->files[high]->basename) {
+					do {
+					    high -= flist->files[high]->length;
+					} while (!flist->files[high]->basename);
+					flist->files[mid]->length = mid - high;
+				}
 				continue;
 			}
-			flist->files[mid]->dir.depth = mid_up - mid;
 		}
-		ret = f_name_cmp(flist->files[mid_up], f);
-		if (ret == 0) {
+		diff = f_name_cmp(flist->files[mid_up], f);
+		if (diff == 0) {
 			if (protocol_version < 29
 			    && S_ISDIR(flist->files[mid_up]->mode)
 			    != S_ISDIR(f->mode))
 				return -1;
 			return mid_up;
 		}
-		if (ret > 0)
-			high = mid - 1;
-		else
+		if (diff < 0)
 			low = mid_up + 1;
+		else
+			high = mid - 1;
 	}
 	return -1;
 }
@@ -1486,11 +1480,16 @@ int flist_find(struct file_list *flist, struct file_struct *f)
  * Free up any resources a file_struct has allocated
  * and clear the file.
  */
-void clear_file(int i, struct file_list *flist)
+void clear_file(struct file_struct *file, struct file_list *flist)
 {
-	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);
+	if (flist->hlink_pool && file->link_u.idev)
+		pool_free(flist->hlink_pool, 0, file->link_u.idev);
+	memset(file, 0, file_struct_len);
+	/* In an empty entry, dir.depth is an offset to the next non-empty
+	 * entry.  Likewise for length in the opposite direction.  We assume
+	 * that we're alone for now since flist_find() will adjust the counts
+	 * it runs into that aren't up-to-date. */
+	file->length = file->dir.depth = 1;
 }
 
 /*
@@ -1538,6 +1537,7 @@ void flist_free(struct file_list *flist)
  */
 static void clean_flist(struct file_list *flist, int strip_root, int no_dups)
 {
+	char fbuf[MAXPATHLEN];
 	int i, prev_i = 0;
 
 	if (!flist)
@@ -1591,14 +1591,14 @@ static void clean_flist(struct file_list *flist, int strip_root, int no_dups)
 			if (verbose > 1 && !am_server) {
 				rprintf(FINFO,
 					"removing duplicate name %s from file list (%d)\n",
-					f_name(file, NULL), drop);
+					f_name(file, fbuf), drop);
 			}
 			/* Make sure we don't lose track of a user-specified
 			 * top directory. */
 			flist->files[keep]->flags |= flist->files[drop]->flags
 						   & (FLAG_TOP_DIR|FLAG_DEL_HERE);
 
-			clear_file(drop, flist);
+			clear_file(flist->files[drop], flist);
 
 			if (keep == i) {
 				if (flist->low == drop) {
@@ -1629,33 +1629,58 @@ static void clean_flist(struct file_list *flist, int strip_root, int no_dups)
 		}
 	}
 
-	if (skip_empty_dirs && no_dups && max_dir_depth) {
-		int j, cur_depth = 0;
-		int *maybe_dirs = new_array(int, max_dir_depth);
+	if (prune_empty_dirs && no_dups) {
+		int j, prev_depth = 0;
 
-		maybe_dirs[0] = -1;
+		prev_i = 0; /* It's OK that this isn't really true. */
 
 		for (i = flist->low; i <= flist->high; i++) {
-			struct file_struct *file = flist->files[i];
+			struct file_struct *fp, *file = flist->files[i];
 
+			/* This temporarily abuses the dir.depth value for a
+			 * directory that is in a chain that might get pruned.
+			 * We restore the old value if it gets a reprieve. */
 			if (S_ISDIR(file->mode) && file->dir.depth) {
-				j = cur_depth;
-				cur_depth = file->dir.depth - 1;
-				for ( ; j >= cur_depth; j--) {
-					if (maybe_dirs[j] < 0)
-						continue;
-					clear_file(maybe_dirs[j], flist);
+				/* Dump empty dirs when coming back down. */
+				for (j = prev_depth; j >= file->dir.depth; j--) {
+					fp = flist->files[prev_i];
+					if (fp->dir.depth >= 0)
+						break;
+					prev_i = -fp->dir.depth-1;
+					clear_file(fp, flist);
+				}
+				prev_depth = file->dir.depth;
+				if (is_excluded(f_name(file, fbuf), 1,
+						       ALL_FILTERS)) {
+					/* Keep dirs through this dir. */
+					for (j = prev_depth-1; ; j--) {
+						fp = flist->files[prev_i];
+						if (fp->dir.depth >= 0)
+							break;
+						prev_i = -fp->dir.depth-1;
+						fp->dir.depth = j;
+					}
+				} else
+					file->dir.depth = -prev_i-1;
+				prev_i = i;
+			} else {
+				/* Keep dirs through this non-dir. */
+				for (j = prev_depth; ; j--) {
+					fp = flist->files[prev_i];
+					if (fp->dir.depth >= 0)
+						break;
+					prev_i = -fp->dir.depth-1;
+					fp->dir.depth = j;
 				}
-				maybe_dirs[cur_depth] = i;
-			} else if (maybe_dirs[cur_depth] >= 0) {
-				for (j = 0; j <= cur_depth; j++)
-					maybe_dirs[j] = -1;
 			}
 		}
-		for (j = cur_depth; j >= 0; j--) {
-			if (maybe_dirs[j] < 0)
-				continue;
-			clear_file(maybe_dirs[j], flist);
+		/* Dump empty all remaining empty dirs. */
+		while (1) {
+			struct file_struct *fp = flist->files[prev_i];
+			if (fp->dir.depth >= 0)
+				break;
+			prev_i = -fp->dir.depth-1;
+			clear_file(fp, flist);
 		}
 
 		for (i = flist->low; i <= flist->high; i++) {
@@ -1885,6 +1910,7 @@ struct file_list *get_dirlist(char *dirname, int dlen,
 	struct file_list *dirlist;
 	char dirbuf[MAXPATHLEN];
 	int save_recurse = recurse;
+	int save_xfer_dirs = xfer_dirs;
 
 	if (dlen < 0) {
 		dlen = strlcpy(dirbuf, dirname, MAXPATHLEN);
@@ -1896,7 +1922,9 @@ struct file_list *get_dirlist(char *dirname, int dlen,
 	dirlist = flist_new(WITHOUT_HLINK, "get_dirlist");
 
 	recurse = 0;
+	xfer_dirs = 1;
 	send_directory(ignore_filter_rules ? -2 : -1, dirlist, dirname, dlen);
+	xfer_dirs = save_xfer_dirs;
 	recurse = save_recurse;
 	if (do_progress)
 		flist_count_offset += dirlist->count;